public UnsignedTransactionService(
ITransactionBuilder builder,
INosqlRepo <UnsignedTransactionEntity> unsignedTxRepo)
{
_builder = builder;
_unsignedTxRepo = unsignedTxRepo;
}
public SwedbankMobileBankIdClient(int nbrOfTimesToCheckIfLoginIsDone, int nbrOfSecondsToWaitBetweenLoginChecks,
ITransactionBuilder transactionBuilder)
{
_nbrOfTimesToCheckIfLoginIsDone = nbrOfTimesToCheckIfLoginIsDone;
_nbrOfSecondsToWaitBetweenLoginChecks = nbrOfSecondsToWaitBetweenLoginChecks;
_transactionBuilder = transactionBuilder;
}
public void Setup()
{
_container?.Dispose();
TestUtils.DeleteTestChainData();
_eventData = new Dictionary <UInt256, ByteString>();
var containerBuilder = new SimpleInjectorContainerBuilder(new ConfigManager(
Path.Join(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config.json"),
new RunOptions()
));
containerBuilder.RegisterModule <BlockchainModule>();
containerBuilder.RegisterModule <ConfigModule>();
containerBuilder.RegisterModule <StorageModule>();
_container = containerBuilder.Build();
_blockManager = _container.Resolve <IBlockManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
_stateManager = _container.Resolve <IStateManager>();
_wallet = _container.Resolve <IPrivateWallet>();
_transactionPool = _container.Resolve <ITransactionPool>();
_configManager = _container.Resolve <IConfigManager>();
// set chainId from config
if (TransactionUtils.ChainId(false) == 0)
{
var chainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId;
var newChainId = _configManager.GetConfig <NetworkConfig>("network")?.NewChainId;
TransactionUtils.SetChainId((int)chainId !, (int)newChainId !);
HardforkHeights.SetHardforkHeights(_configManager.GetConfig <HardforkConfig>("hardfork") ?? throw new InvalidOperationException());
StakingContract.Initialize(_configManager.GetConfig <NetworkConfig>("network") ?? throw new InvalidOperationException());
CycleDuration = StakingContract.CycleDuration;
}
}
public void Setup()
{
_container?.Dispose();
TestUtils.DeleteTestChainData();
var containerBuilder = new SimpleInjectorContainerBuilder(new ConfigManager(
Path.Join(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config2.json"),
new RunOptions()
));
containerBuilder.RegisterModule <BlockchainModule>();
containerBuilder.RegisterModule <ConfigModule>();
containerBuilder.RegisterModule <StorageModule>();
containerBuilder.RegisterModule <ConsensusModule>();
containerBuilder.RegisterModule <NetworkModule>();
_container = containerBuilder.Build();
_privateWallet = _container.Resolve <IPrivateWallet>();
_validatorStatusManager = _container.Resolve <IValidatorStatusManager>();
_configManager = _container.Resolve <IConfigManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
ServiceBinder.BindService <GenericParameterAttributes>();
_apiService = new ValidatorServiceWeb3(_validatorStatusManager, _privateWallet, _transactionBuilder);
}
private void _Bench_Execute_Blocks(
ITransactionBuilder transactionBuilder,
ITransactionSigner transactionSigner,
EcdsaKeyPair keyPair)
{
const int txGenerate = 50;
const int txPerBlock = 10;
Logger.LogInformation($"Setting initial balance for the 'From' address");
_stateManager.LastApprovedSnapshot.Balances.AddBalance(keyPair.PublicKey.GetAddress(),
Money.Parse("2000000"));
for (var k = 0; k < txGenerate / txPerBlock; k++)
{
var txReceipts = new List <TransactionReceipt>();
var watch = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < txPerBlock; i++)
{
var randomValue = new Random().Next(1, 100);
var amount = Money.Parse($"{randomValue}.0").ToUInt256();
byte[] random = new byte[32];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(random);
var tx = new Transaction
{
To = random.Slice(0, 20).ToUInt160(),
From = keyPair.PublicKey.GetAddress(),
GasPrice = (ulong)Money.Parse("0.0000001").ToWei(),
GasLimit = 100000000,
Nonce = _transactionPool.GetNextNonceForAddress(keyPair.PublicKey.GetAddress()) + (ulong)i,
Value = amount
};
txReceipts.Add(transactionSigner.Sign(tx, keyPair, true));
}
watch.Stop();
Console.WriteLine($"Building TXs Time: {watch.ElapsedMilliseconds} ms");
Block block = null !;
watch.Restart();
block = BuildBlock(txReceipts.ToArray());
watch.Stop();
Console.WriteLine($"Building Block Time: {watch.ElapsedMilliseconds} ms");
watch.Restart();
ExecuteBlock(block, txReceipts.ToArray());
watch.Stop();
Console.WriteLine($"Block Emulation + Execution Time: {watch.ElapsedMilliseconds} ms");
var executedBlock =
_stateManager.LastApprovedSnapshot.Blocks.GetBlockByHeight(block !.Header.Index);
Console.WriteLine($"Executed Transactions: {executedBlock!.TransactionHashes.Count}");
Console.WriteLine(
$"Balance After Transaction {_stateManager.LastApprovedSnapshot.Balances.GetBalance(keyPair.PublicKey.GetAddress())}");
}
}
public IncomeItemCommands(IEntityRepository repository,
ICurrentSession currentSession,
ITransactionBuilder transactionBuilder)
{
_repository = repository;
_currentSession = currentSession;
_transactionBuilder = transactionBuilder;
}
public ValidatorServiceWeb3(
IValidatorStatusManager validatorStatusManager, IPrivateWallet privateWallet,
ITransactionBuilder transactionBuilder)
{
_validatorStatusManager = validatorStatusManager;
_privateWallet = privateWallet;
_transactionBuilder = transactionBuilder;
}
public UnsignedTransactionService(
ITransactionBuilder builder,
INosqlRepo <UnsignedTransactionEntity> unsignedTxRepo,
INosqlRepo <BroadcastedTransaction> broadcastTxRepo)
{
_builder = builder;
_unsignedTxRepo = unsignedTxRepo;
_broadcastTxRepo = broadcastTxRepo;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="cMCCoinRepository">Repository Interface</param>
public BinanceBuilder(ITransactionBuilder transactionBuilder, IApiInformationBuilder apiInformationBuilder, ICoinInformationBuilder coinInformationBuilder)
{
_trxBldr = transactionBuilder;
_apiBldr = apiInformationBuilder;
_coinBldr = coinInformationBuilder;
_binanceRepo = new BinanceRepository();
this._helper = new ObjectHelper();
this._dtHelper = new DateTimeHelper();
this.lastRun = null;
}
public CryptoPortfolioManager(IApiInformationBuilder apiInformationBuilder, ICoinInformationBuilder coinInfoBuilder, ITransactionBuilder transactionBuilder, ICoinMarketCapBuilder coinMarketCapBuilder)
{
this._nnBldr = new NinetyNineCryptoBuilder();
this._coindarBldr = new CoindarBuilder();
this._cmcBldr = coinMarketCapBuilder;
this._coinInfoBldr = coinInfoBuilder;
this._displayCoinBldr = new DisplayCoinBuilder(coinInfoBuilder);
this._apiBldr = apiInformationBuilder;
this._trxBldr = transactionBuilder;
this._binanceBldr = new BinanceBuilder(transactionBuilder, apiInformationBuilder, coinInfoBuilder);
}
public WalletInformation(IScriptBuilder scriptBuilder, ITransactionHelper transactionHelper,
IWalletRepository walletRepository, ITransactionBuilder transactionBuilder, IWalletHelper walletHelper)
{
_scriptBuilder = scriptBuilder;
_transactionHelper = transactionHelper;
_walletRepository = walletRepository;
_transactionBuilder = transactionBuilder;
_walletHelper = walletHelper;
InitializeComponent();
Loaded += Load;
}
public AccountCommands(IEntityRepository repository,
ICurrentSession currentSession,
IIncomeItemCommands incomeItemCommands,
ITimeService timeService,
ITransactionBuilder transactionBuilder)
{
_repository = repository;
_currentSession = currentSession;
_incomeItemCommands = incomeItemCommands;
_timeService = timeService;
_transactionBuilder = transactionBuilder;
}
public TransactionsController(IAddressValidator addressValidator,
IOperationRepository operationRepository,
ITransactionBroadcaster transactionBroadcaster,
IObservableOperationRepository observableOperationRepository,
ITransactionBuilder transactionBuilder)
{
_addressValidator = addressValidator;
_operationRepository = operationRepository;
_transactionBroadcaster = transactionBroadcaster;
_observableOperationRepository = observableOperationRepository;
_transactionBuilder = transactionBuilder;
}
public ExpensesBillCommands(
IEntityRepository repository,
ICurrentSession currentSession,
IBalancesUpdaterFactory balancesUpdaterFactory,
ITransitionBalanceUpdater transitionBalanceUpdater,
ITransactionBuilder transactionBuilder)
{
_repository = repository;
_currentSession = currentSession;
_balancesUpdaterFactory = balancesUpdaterFactory;
_transitionBalanceUpdater = transitionBalanceUpdater;
_transactionBuilder = transactionBuilder;
}
private void _Bench_Tx_Pool(
ITransactionBuilder transactionBuilder,
ITransactionSigner transactionSigner,
EcdsaKeyPair keyPair)
{
const int txGenerate = 1000;
const int txPerBlock = 1000;
Logger.LogInformation($"Setting initial balance for the 'From' address");
_stateManager.LastApprovedSnapshot.Balances.AddBalance(keyPair.PublicKey.GetAddress(),
Money.Parse("200000"));
var txReceipts = new List <TransactionReceipt>();
for (int i = 0; i < txGenerate; i++)
{
var randomValue = new Random().Next(1, 100);
var amount = Money.Parse($"{randomValue}.0").ToUInt256();
byte[] random = new byte[32];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(random);
var tx = new Transaction
{
To = random.Slice(0, 20).ToUInt160(),
From = keyPair.PublicKey.GetAddress(),
GasPrice = (ulong)Money.Parse("0.0000001").ToWei(),
GasLimit = 100000000,
Nonce = (ulong)i,
Value = amount
};
txReceipts.Add(transactionSigner.Sign(tx, keyPair, true));
}
ITransactionPool transactionPool = _container.Resolve <ITransactionPool>();
var watch = System.Diagnostics.Stopwatch.StartNew();
foreach (var txr in txReceipts)
{
transactionPool.Add(txr, false);
}
watch.Stop();
Console.WriteLine($"Time to Add {transactionPool.Transactions.Count} Tx to pool: {watch.ElapsedMilliseconds} ms");
watch.Restart();
var txs = transactionPool.Peek(txGenerate, txGenerate);
watch.Stop();
Console.WriteLine($"Time to Peek {txs.Count} Tx from pool: {watch.ElapsedMilliseconds} ms");
}
private static void _BenchOneTxInBlock(
ITransactionBuilder transactionBuilder,
ITransactionSigner transactionSigner,
EcdsaKeyPair keyPair
)
{
var address1 = "0x6bc32575acb8754886dc283c2c8ac54b1bd93195".HexToUInt160();
var address2 = "0xe3c7a20ee19c0107b9121087bcba18eb4dcb8576".HexToUInt160();
var lastTime = TimeUtils.CurrentTimeMillis();
const int tries = 100;
for (var i = 0; i < tries; i++)
{
if (i % 10 == 0)
{
Console.CursorLeft = 0;
Console.Write($"Benchmarking... {100 * i / tries}%");
}
var transferTx =
transactionBuilder.TransferTransaction(address1, address2, Money.FromDecimal(1.2m));
var signed = transactionSigner.Sign(transferTx, keyPair, true);
// var blockWithTxs = new BlockBuilder(latestBlock.Header)
// .WithTransactions(new[] {signed})
// .Build(123456);
// // var stateHash = blockchainManager.CalcStateHash(blockWithTxs.Block, blockWithTxs.Transactions);
// var block = blockWithTxs.Block;
// // block.Header.StateHash = stateHash;
// block.Hash = block.Header.Keccak();
// block.Multisig = new MultiSig
// {
// Quorum = 1,
// Signatures =
// {
// new MultiSig.Types.SignatureByValidator
// {
// Key = keyPair.PublicKey,
// Value = blockManager.Sign(block.Header, keyPair)
// }
// },
// Validators = {keyPair.PublicKey}
// };
// // blockchainManager.PersistBlockManually(block, blockWithTxs.Transactions);
}
var deltaTime = TimeUtils.CurrentTimeMillis() - lastTime;
Console.CursorLeft = "Benchmarking... ".Length;
Console.WriteLine($"{1000 * tries / deltaTime} RPS");
}
public AccountService(
IStateManager stateManager,
ITransactionManager transactionManager,
ITransactionPool transactionPool,
IPrivateWallet privateWallet,
ITransactionBuilder transactionBuilder,
ITransactionSigner transactionSigner
)
{
_stateManager = stateManager;
_transactionManager = transactionManager;
_transactionPool = transactionPool;
_privateWallet = privateWallet;
_transactionBuilder = transactionBuilder;
_transactionSigner = transactionSigner;
}
private const int BatchSize = 1000; // TODO: calculate batch size
public BlockProducer(
ITransactionPool transactionPool,
IValidatorManager validatorManager,
IBlockSynchronizer blockSynchronizer,
IBlockManager blockManager,
IStateManager stateManager,
ITransactionBuilder transactionBuilder
)
{
_transactionPool = transactionPool;
_validatorManager = validatorManager;
_blockSynchronizer = blockSynchronizer;
_blockManager = blockManager;
_stateManager = stateManager;
_transactionBuilder = transactionBuilder;
}
public void Setup()
{
_container?.Dispose();
TestUtils.DeleteTestChainData();
var containerBuilder = new SimpleInjectorContainerBuilder(new ConfigManager(
Path.Join(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config2.json"),
new RunOptions()
));
containerBuilder.RegisterModule <BlockchainModule>();
containerBuilder.RegisterModule <ConfigModule>();
containerBuilder.RegisterModule <StorageModule>();
_container = containerBuilder.Build();
_configManager = _container.Resolve <IConfigManager>();
_stateManager = _container.Resolve <IStateManager>();
_contractRegisterer = _container.Resolve <IContractRegisterer>();
_privateWallet = _container.Resolve <IPrivateWallet>();
_snapshotIndexer = _container.Resolve <ISnapshotIndexRepository>();
_systemContractReader = _container.Resolve <ISystemContractReader>();
_transactionManager = _container.Resolve <ITransactionManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
_transactionSigner = _container.Resolve <ITransactionSigner>();
_transactionPool = _container.Resolve <ITransactionPool>();
_blockManager = _container.Resolve <IBlockManager>();
// set chainId from config
if (TransactionUtils.ChainId(false) == 0)
{
var chainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId;
var newChainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId;
TransactionUtils.SetChainId((int)chainId !, (int)newChainId !);
HardforkHeights.SetHardforkHeights(_configManager.GetConfig <HardforkConfig>("hardfork") ?? throw new InvalidOperationException());
}
ServiceBinder.BindService <GenericParameterAttributes>();
_apiService = new AccountServiceWeb3(_stateManager, _snapshotIndexer, _contractRegisterer, _systemContractReader, _transactionPool);
_transactionApiService = new TransactionServiceWeb3(_stateManager, _transactionManager, _transactionBuilder, _transactionSigner,
_transactionPool, _contractRegisterer, _privateWallet);
_blockManager.TryBuildGenesisBlock();
}
public TransactionServiceWeb3(
IStateManager stateManager,
ITransactionManager transactionManager,
ITransactionBuilder transactionBuilder,
ITransactionSigner transactionSigner,
ITransactionPool transactionPool,
IContractRegisterer contractRegisterer,
IPrivateWallet privateWallet)
{
_stateManager = stateManager;
_transactionManager = transactionManager;
_transactionBuilder = transactionBuilder;
_transactionSigner = transactionSigner;
_transactionPool = transactionPool;
_contractRegisterer = contractRegisterer;
_privateWallet = privateWallet;
}
public ConsoleManager(
ITransactionBuilder transactionBuilder,
ITransactionPool transactionPool,
ITransactionManager transactionManager,
ITransactionSigner transactionSigner,
IBlockManager blockManager,
IStateManager stateManager,
ISystemContractReader systemContractReader,
IValidatorStatusManager validatorStatusManager
)
{
_blockManager = blockManager;
_transactionBuilder = transactionBuilder;
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_transactionSigner = transactionSigner;
_stateManager = stateManager;
_systemContractReader = systemContractReader;
_validatorStatusManager = validatorStatusManager;
}
public RpcManager(
ITransactionManager transactionManager,
IBlockManager blockManager,
IConfigManager configManager,
IStateManager stateManager,
ISnapshotIndexRepository snapshotIndexer,
ITransactionPool transactionPool,
IVirtualMachine virtualMachine,
IContractRegisterer contractRegisterer,
IValidatorStatusManager validatorStatusManager,
ISystemContractReader systemContractReader,
IBlockSynchronizer blockSynchronizer,
ILocalTransactionRepository localTransactionRepository,
ITransactionSigner transactionSigner,
IPrivateWallet privateWallet,
ITransactionBuilder transactionBuilder,
IBlockchainEventFilter blockchainEventFilter,
INetworkManager networkManager,
INodeRetrieval nodeRetrieval,
IConsensusManager consensusManager
)
{
_transactionManager = transactionManager;
_blockManager = blockManager;
_configManager = configManager;
_stateManager = stateManager;
_snapshotIndexer = snapshotIndexer;
_transactionPool = transactionPool;
_contractRegisterer = contractRegisterer;
_validatorStatusManager = validatorStatusManager;
_systemContractReader = systemContractReader;
_blockSynchronizer = blockSynchronizer;
_localTransactionRepository = localTransactionRepository;
_transactionSigner = transactionSigner;
_transactionBuilder = transactionBuilder;
_privateWallet = privateWallet;
_blockchainEventFilter = blockchainEventFilter;
_networkManager = networkManager;
_nodeRetrieval = nodeRetrieval;
_consensusManager = consensusManager;
}
public ValidatorStatusManager(
ITransactionPool transactionPool,
ITransactionSigner transactionSigner,
ITransactionBuilder transactionBuilder,
IPrivateWallet privateWallet,
IStateManager stateManager,
IValidatorAttendanceRepository validatorAttendanceRepository,
ISystemContractReader systemContractReader
)
{
_transactionPool = transactionPool;
_transactionSigner = transactionSigner;
_transactionBuilder = transactionBuilder;
_privateWallet = privateWallet;
_stateManager = stateManager;
_validatorAttendanceRepository = validatorAttendanceRepository;
_systemContractReader = systemContractReader;
_withdrawTriggered = false;
_started = false;
_thread = null;
_stopRequested = false;
}
static void Main(string[] args)
{
var serviceProvider = ConfigureForMongoDB("DigitalCurrency", 10500);
//var serviceProvider = ConfigureForLiteDb("node.db", 10500);
_host = serviceProvider.GetService <IBlockchainNode>();
_miner = serviceProvider.GetService <IBlockMiner>();
_network = serviceProvider.GetService <IPeerNetwork>();
_sigService = serviceProvider.GetService <ISignatureService>();
_addressEncoder = serviceProvider.GetService <IAddressEncoder>();
_txnRepo = serviceProvider.GetService <ICustomInstructionRepository>();
_blockRepo = serviceProvider.GetService <IBlockRepository>();
_txnBuilder = serviceProvider.GetService <ITransactionBuilder>();
Console.Write("Enter passphrase:");
var phrase = Console.ReadLine();
var keys = _sigService.GetKeyPairFromPhrase(phrase);
var address = _addressEncoder.EncodeAddress(keys.PublicKey, 0);
Console.WriteLine($"Your address is {address}");
_network.Open();
PrintHelp();
while (true)
{
Console.Write(">");
var command = Console.ReadLine();
if (command == "exit")
{
break;
}
RunCommand(command, keys);
}
_network.Close();
}
public ConsoleCommands(
ITransactionBuilder transactionBuilder,
ITransactionPool transactionPool,
ITransactionManager transactionManager,
ITransactionSigner transactionSigner,
IBlockManager blockManager,
IStateManager stateManager,
ISystemContractReader systemContractReader,
IValidatorStatusManager validatorStatusManager,
EcdsaKeyPair keyPair
)
{
_blockManager = blockManager;
_transactionBuilder = transactionBuilder;
_transactionPool = transactionPool;
_transactionManager = transactionManager;
_transactionSigner = transactionSigner;
_stateManager = stateManager;
_systemContractReader = systemContractReader;
_validatorStatusManager = validatorStatusManager;
_keyPair = keyPair;
}
public KeyGenManager(
IBlockManager blockManager,
ITransactionManager transactionManager,
ITransactionBuilder transactionBuilder,
IPrivateWallet privateWallet,
ITransactionPool transactionPool,
ITransactionSigner transactionSigner,
IKeyGenRepository keyGenRepository,
IBlockSynchronizer blockSynchronizer,
ISystemContractReader systemContractReader
)
{
_blockManager = blockManager;
_transactionManager = transactionManager;
_transactionBuilder = transactionBuilder;
_privateWallet = privateWallet;
_transactionPool = transactionPool;
_transactionSigner = transactionSigner;
_keyGenRepository = keyGenRepository;
_blockSynchronizer = blockSynchronizer;
_systemContractReader = systemContractReader;
_blockManager.OnSystemContractInvoked += BlockManagerOnSystemContractInvoked;
}
public TransactionBuildManager(ITransactionBuilder builder)
{
Builder = builder;
}
public SwedbankInternetBankClient(string civicNumber, string password, ITransactionBuilder transactionBuilder)
{
_civicNumber = civicNumber;
_password = password;
_transactionBuilder = transactionBuilder;
}
public void Start(RunOptions options)
{
_blockManager = _container.Resolve <IBlockManager>();
_configManager = _container.Resolve <IConfigManager>();
_stateManager = _container.Resolve <IStateManager>();
_transactionBuilder = _container.Resolve <ITransactionBuilder>();
_transactionPool = _container.Resolve <ITransactionPool>();
_transactionSigner = _container.Resolve <ITransactionSigner>();
_wallet = _container.Resolve <IPrivateWallet>();
var keyPair = _wallet.EcdsaKeyPair;
Console.WriteLine("-------------------------------");
Console.WriteLine("Private Key: " + keyPair.PrivateKey.Encode().ToHex());
Console.WriteLine("Public Key: " + keyPair.PublicKey.EncodeCompressed().ToHex());
Console.WriteLine("Address: " + Crypto.ComputeAddress(keyPair.PublicKey.EncodeCompressed()).ToHex());
Console.WriteLine("-------------------------------");
if (_blockManager.TryBuildGenesisBlock())
{
Console.WriteLine("Generated genesis block");
}
var genesisBlock = _stateManager.LastApprovedSnapshot.Blocks.GetBlockByHeight(0);
Console.WriteLine("Genesis Block: " + genesisBlock !.Hash.ToHex());
Console.WriteLine($" + prevBlockHash: {genesisBlock.Header.PrevBlockHash.ToHex()}");
Console.WriteLine($" + merkleRoot: {genesisBlock.Header.MerkleRoot.ToHex()}");
Console.WriteLine($" + nonce: {genesisBlock.Header.Nonce}");
Console.WriteLine($" + transactionHashes: {genesisBlock.TransactionHashes.Count}");
foreach (var s in genesisBlock.TransactionHashes)
{
Console.WriteLine($" + - {s.ToHex()}");
}
Console.WriteLine($" + hash: {genesisBlock.Hash.ToHex()}");
var address1 = "0xe3c7a20ee19c0107b9121087bcba18eb4dcb8576".HexToUInt160();
var address2 = "0x6bc32575acb8754886dc283c2c8ac54b1bd93195".HexToUInt160();
Console.WriteLine("-------------------------------");
// Console.WriteLine("Current block header height: " + blockchainContext.CurrentBlockHeight);
Console.WriteLine("-------------------------------");
Console.WriteLine("Balance of LA 0x3e: " +
_stateManager.LastApprovedSnapshot.Balances.GetBalance(address1));
Console.WriteLine("Balance of LA 0x6b: " +
_stateManager.LastApprovedSnapshot.Balances.GetBalance(address2));
Console.WriteLine("-------------------------------");
Logger.LogInformation($"Setting chainId");
var chainId = _configManager.GetConfig <NetworkConfig>("network")?.ChainId ?? 42;
var newChainId = _configManager.GetConfig <NetworkConfig>("network")?.NewChainId ?? chainId;
TransactionUtils.SetChainId((int)chainId, newChainId);
// _BenchTxProcessing(_transactionBuilder, _transactionSigner, keyPair);
// _BenchOneTxInBlock(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------START - TX POOL BENCHMARK----------------");
_Bench_Tx_Pool(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - TX POOL BENCHMARK----------------");
Console.WriteLine("---------------START - BLOCK EMULATE BENCHMARK----------------");
_Bench_Emulate_Block(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - BLOCK EMULATE BENCHMARK----------------");
Console.WriteLine("---------------START - BLOCK EMULATE + EXECUTE BENCHMARK----------------");
_Bench_Emulate_Execute_Tx(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - BLOCK EMULATE + EXECUTE BENCHMARK----------------");
Console.WriteLine("---------------START - MULTIPLE BLOCKS EMULATE + EXECUTE BENCHMARK----------------");
_Bench_Execute_Blocks(_transactionBuilder, _transactionSigner, keyPair);
Console.WriteLine("---------------END - MULTIPLE BLOCKS EMULATE + EXECUTE BENCHMARK----------------");
Environment.Exit(0);
}
public DefaultSignService(
ITransactionBuilder transactionBuilder)
{
_transactionBuilder = transactionBuilder;
}
public BaseBuilder(IAddressEncoder addressEncoder, ISignatureService signatureService, ITransactionBuilder transactionBuilder)
: base(addressEncoder, signatureService, transactionBuilder)
{
}
protected BlockbaseTransactionBuilder(IAddressEncoder addressEncoder, ISignatureService signatureService, ITransactionBuilder transactionBuilder)
{
AddressEncoder = addressEncoder;
SignatureService = signatureService;
TransactionBuilder = transactionBuilder;
}
