public BlockChain(ITransactionPool transactionPool)
{
this.blocks = new List <Block> {
CreateGenesisBlock()
};
this.transactionPool = transactionPool;
}
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 CliqueBlockProducer(ITransactionPool transactionPool,
IBlockchainProcessor blockchainProcessor,
IBlockTree blockTree,
ITimestamp timestamp,
ICryptoRandom cryptoRandom,
IStateProvider stateProvider,
ISnapshotManager snapshotManager,
ISealer cliqueSealer,
Address address,
ICliqueConfig config,
ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_processor = blockchainProcessor ?? throw new ArgumentNullException(nameof(blockchainProcessor));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
_timestamp = timestamp ?? throw new ArgumentNullException(nameof(timestamp));
_cryptoRandom = cryptoRandom ?? throw new ArgumentNullException(nameof(cryptoRandom));
_sealer = cliqueSealer ?? throw new ArgumentNullException(nameof(cliqueSealer));
_snapshotManager = snapshotManager ?? throw new ArgumentNullException(nameof(snapshotManager));
_config = config ?? throw new ArgumentNullException(nameof(config));
_address = address ?? throw new ArgumentNullException(nameof(address));
_timer.AutoReset = false;
_timer.Elapsed += TimerOnElapsed;
_timer.Interval = 100;
_timer.Start();
}
public void Setup()
{
_container?.Dispose();
TestUtils.DeleteTestChainData();
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>();
_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")?.ChainId;
TransactionUtils.SetChainId((int)chainId !, (int)newChainId !);
HardforkHeights.SetHardforkHeights(_configManager.GetConfig <HardforkConfig>("hardfork") ?? throw new InvalidOperationException());
}
_validatorStatusManager = new ValidatorStatusManager(
_transactionPool, _container.Resolve <ITransactionSigner>(), _container.Resolve <ITransactionBuilder>(),
_wallet, _stateManager, _container.Resolve <IValidatorAttendanceRepository>(),
_container.Resolve <ISystemContractReader>()
);
}
public BlockProcessor(
ISpecProvider specProvider,
IBlockValidator blockValidator,
IRewardCalculator rewardCalculator,
ITransactionProcessor transactionProcessor,
ISnapshotableDb stateDb,
ISnapshotableDb codeDb,
IDb traceDb,
IStateProvider stateProvider,
IStorageProvider storageProvider,
ITransactionPool transactionPool,
IReceiptStorage receiptStorage,
ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_blockValidator = blockValidator ?? throw new ArgumentNullException(nameof(blockValidator));
_stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
_storageProvider = storageProvider ?? throw new ArgumentNullException(nameof(storageProvider));
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_rewardCalculator = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator));
_transactionProcessor = transactionProcessor ?? throw new ArgumentNullException(nameof(transactionProcessor));
_stateDb = stateDb ?? throw new ArgumentNullException(nameof(stateDb));
_codeDb = codeDb ?? throw new ArgumentNullException(nameof(codeDb));
_traceDb = traceDb ?? throw new ArgumentNullException(nameof(traceDb));
_receiptsTracer = new BlockReceiptsTracer(_specProvider, _stateProvider);
}
public BlockchainBridge(
IStateReader stateReader,
IStateProvider stateProvider,
IStorageProvider storageProvider,
IBlockTree blockTree,
ITransactionPool transactionPool,
ITransactionPoolInfoProvider transactionPoolInfoProvider,
IReceiptStorage receiptStorage,
IFilterStore filterStore,
IFilterManager filterManager,
IWallet wallet,
ITransactionProcessor transactionProcessor)
{
_stateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
_stateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
_storageProvider = storageProvider ?? throw new ArgumentNullException(nameof(storageProvider));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(_transactionPool));
_transactionPoolInfoProvider = transactionPoolInfoProvider ?? throw new ArgumentNullException(nameof(transactionPoolInfoProvider));
_receiptStorage = receiptStorage ?? throw new ArgumentNullException(nameof(receiptStorage));
_filterStore = filterStore ?? throw new ArgumentException(nameof(filterStore));
_filterManager = filterManager ?? throw new ArgumentException(nameof(filterManager));
_wallet = wallet ?? throw new ArgumentException(nameof(wallet));
_transactionProcessor = transactionProcessor ?? throw new ArgumentException(nameof(transactionProcessor));
}
public TransactionMiner(IBlockChain blockChain, IRedis redis, IWallet wallet, ITransactionPool transactionPool)
{
this._IBlockChain = blockChain;
this._IRedis = redis;
this._IWallet = wallet;
this._ITransactionPool = transactionPool;
}
public void should_add_pending_transactions()
{
_transactionPool = CreatePool(_noTransactionStorage);
var transactions = AddTransactionsToPool();
_transactionPool.GetPendingTransactions().Length.Should().Be(transactions.Length);
}
public ProtocolsManager(
ISynchronizationManager synchronizationManager,
ITransactionPool transactionPool,
IDiscoveryApp discoveryApp,
IMessageSerializationService serializationService,
IRlpxPeer localPeer,
INodeStatsManager nodeStatsManager,
IProtocolValidator protocolValidator,
INetworkStorage peerStorage,
IPerfService perfService,
ILogManager logManager)
{
_syncManager = synchronizationManager ?? throw new ArgumentNullException(nameof(synchronizationManager));
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_discoveryApp = discoveryApp ?? throw new ArgumentNullException(nameof(discoveryApp));
_serializer = serializationService ?? throw new ArgumentNullException(nameof(serializationService));
_localPeer = localPeer ?? throw new ArgumentNullException(nameof(localPeer));
_stats = nodeStatsManager ?? throw new ArgumentNullException(nameof(nodeStatsManager));
_protocolValidator = protocolValidator ?? throw new ArgumentNullException(nameof(protocolValidator));
_perfService = perfService ?? throw new ArgumentNullException(nameof(perfService));
_peerStorage = peerStorage ?? throw new ArgumentNullException(nameof(peerStorage));
_logManager = logManager ?? throw new ArgumentNullException(nameof(logManager));
_logger = _logManager.GetClassLogger();
_syncManager.SyncEvent += OnSyncEvent;
localPeer.SessionCreated += SessionCreated;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="serverContext">Server context</param>
/// <param name="blockchain">Blockchain</param>
/// <param name="blockRepository">The Block Model.</param>
/// <param name="transactionModel"></param>
/// <param name="assetModel"></param>
/// <param name="blockchainContext">The block chain context class.</param>
/// <param name="blockPool">Block pool</param>
/// <param name="blockSigner">Block signer</param>
/// <param name="blockPersister">Block persister</param>
/// <param name="transactionPool">Transaction Pool</param>
/// <param name="consoleHandler">Console handler</param>
public PromptBlockchainController(
IServerContext serverContext,
IBlockchain blockchain,
IBlockRepository blockRepository,
ITransactionRepository transactionModel,
IAssetRepository assetModel,
IBlockchainContext blockchainContext,
IBlockPool blockPool,
IBlockPersister blockPersister,
ISigner <Block> blockSigner,
ITransactionPool transactionPool,
IConsoleHandler consoleHandler)
{
_serverContext = serverContext;
_blockchain = blockchain;
_blockRepository = blockRepository;
_blockSigner = blockSigner;
_blockPersister = blockPersister;
_transactionModel = transactionModel;
_assetModel = assetModel;
_blockchainContext = blockchainContext;
_blockPool = blockPool;
_transactionPool = transactionPool;
_consoleHandler = consoleHandler;
}
public BlockchainEventFilter(IBlockManager blockManager, IStateManager stateManager, ITransactionPool transactionPool)
{
_blockManager = blockManager;
_stateManager = stateManager;
_transactionPool = transactionPool;
_currentId = 0;
}
public void Setup()
{
_currentFilterId = 0;
_filterStore = Substitute.For <IFilterStore>();
_blockProcessor = Substitute.For <IBlockProcessor>();
_transactionPool = Substitute.For <ITransactionPool>();
_logManager = Substitute.For <ILogManager>();
}
public void should_delete_pending_transactions()
{
_transactionPool = CreatePool(_noTransactionStorage);
var transactions = AddTransactionsToPool();
DeleteTransactionsFromPool(transactions);
_transactionPool.GetPendingTransactions().Should().BeEmpty();
}
public MineService(ITransactionPool transactionPool, IBlockChainService blockChainService,
ITransactionExecutingService transactionExecutingService)
{
_transactionPool = transactionPool;
_blockChainService = blockChainService;
_transactionExecutingService = transactionExecutingService;
Logger = NullLogger.Instance;
}
public Eth63ProtocolHandler(
ISession session,
IMessageSerializationService serializer,
INodeStatsManager nodeStatsManager,
ISynchronizationManager syncManager,
ILogManager logManager, IPerfService perfService,
ITransactionPool transactionPool) : base(session, serializer, nodeStatsManager, syncManager, logManager, perfService, transactionPool)
{
}
public Eth63ProtocolHandler(
IP2PSession p2PSession,
IMessageSerializationService serializer,
ISynchronizationManager syncManager,
ILogManager logManager, IPerfService perfService,
IBlockTree blockTree, ITransactionPool transactionPool, ITimestamp timestamp) : base(p2PSession, serializer,
syncManager, logManager, perfService, blockTree, transactionPool, timestamp)
{
}
public void should_add_valid_transactions()
{
_transactionPool = CreatePool(_noTransactionStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, RopstenSpecProvider.ByzantiumBlockNumber).TestObject;
AddTransactionResult result = _transactionPool.AddTransaction(tx, 1);
_transactionPool.GetPendingTransactions().Length.Should().Be(1);
result.Should().Be(AddTransactionResult.Added);
}
public void should_ignore_old_scheme_signatures()
{
_transactionPool = CreatePool(_noTransactionStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, 1).TestObject;
AddTransactionResult result = _transactionPool.AddTransaction(tx, 1);
_transactionPool.GetPendingTransactions().Length.Should().Be(0);
result.Should().Be(AddTransactionResult.OldScheme);
}
public void should_ignore_transactions_with_different_chain_id()
{
_transactionPool = CreatePool(_noTransactionStorage);
EthereumEcdsa ecdsa = new EthereumEcdsa(MainNetSpecProvider.Instance, _logManager);
Transaction tx = Build.A.Transaction.SignedAndResolved(ecdsa, TestItem.PrivateKeyA, MainNetSpecProvider.ByzantiumBlockNumber).TestObject;
AddTransactionResult result = _transactionPool.AddTransaction(tx, 1);
_transactionPool.GetPendingTransactions().Length.Should().Be(0);
result.Should().Be(AddTransactionResult.InvalidChainId);
}
public void should_add_peers()
{
_transactionPool = CreatePool(_noTransactionStorage);
var peers = GetPeers();
foreach ((ISynchronizationPeer peer, _) in peers)
{
_transactionPool.AddPeer(peer);
}
}
public ApiController(ILogger<ApiController> logger, IClock clock, IBlockChain blockChain, IRedis redis, IWallet wallet, ITransactionPool transactionPool, ITransactionMiner transactionMiner)
{
this._ILogger = logger;
this._IClock = clock;
this._IBlockChain = blockChain;
this._IRedis = redis;
this._IWallet = wallet;
this._ITransactionPool = transactionPool;
this._ITransactionMiner = transactionMiner;
}
public AccountServiceWeb3(IStateManager stateManager,
ISnapshotIndexRepository snapshotIndexer,
IContractRegisterer contractRegisterer,
ISystemContractReader systemContractReader, ITransactionPool transactionPool)
{
_stateManager = stateManager;
_snapshotIndexer = snapshotIndexer;
_contractRegisterer = contractRegisterer;
_systemContractReader = systemContractReader;
_transactionPool = transactionPool;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="transactionRepository">Transaction respository access.</param>
/// <param name="transactionPool">Transaction Pool</param>
/// <param name="transactionSigner">The transaction signer</param>
/// <param name="logger">Logger</param>
public TransactionMessageHandler(
ITransactionRepository transactionRepository,
ITransactionPool transactionPool,
ISigner <Transaction> transactionSigner,
ILogger <TransactionMessageHandler> logger)
{
_transactionRepository = transactionRepository ?? throw new ArgumentNullException(nameof(transactionRepository));
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_transactionSigner = transactionSigner ?? throw new ArgumentNullException(nameof(transactionSigner));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public TransactionProcessor(
ITransactionPool transactionPool,
IVerifier <Transaction> transactionVerifier,
IRepository repository,
IAsyncDelayer asyncDelayer)
{
_verifiedTransactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_transactionVerifier = transactionVerifier ?? throw new ArgumentNullException(nameof(transactionVerifier));
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
}
public void should_ignore_already_known()
{
_transactionPool = CreatePool(_noTransactionStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumSigner, TestItem.PrivateKeyA, RopstenSpecProvider.ByzantiumBlockNumber).TestObject;
AddTransactionResult result1 = _transactionPool.AddTransaction(tx, 1);
AddTransactionResult result2 = _transactionPool.AddTransaction(tx, 1);
_transactionPool.GetPendingTransactions().Length.Should().Be(1);
result1.Should().Be(AddTransactionResult.Added);
result2.Should().Be(AddTransactionResult.AlreadyKnown);
}
public void Initialize()
{
NetworkNodeDecoder.Init();
_timestamp = new Timestamp();
_logManager = new OneLoggerLogManager(new SimpleConsoleLogger());
_configurationProvider = new ConfigProvider();
INetworkConfig networkConfig = _configurationProvider.GetConfig <INetworkConfig>();
networkConfig.DbBasePath = Path.Combine(Path.GetTempPath(), "PeerManagerTests");
networkConfig.IsActivePeerTimerEnabled = false;
networkConfig.IsDiscoveryNodesPersistenceOn = false;
networkConfig.IsPeersPersistenceOn = false;
if (!Directory.Exists(networkConfig.DbBasePath))
{
Directory.CreateDirectory(networkConfig.DbBasePath);
}
var syncManager = Substitute.For <ISynchronizationManager>();
Block genesisBlock = Build.A.Block.Genesis.TestObject;
syncManager.Head.Returns(genesisBlock.Header);
syncManager.Genesis.Returns(genesisBlock.Header);
_nodeFactory = new NodeFactory(LimboLogs.Instance);
_localPeer = new TestRlpxPeer();
var keyProvider = new PrivateKeyGenerator(new CryptoRandom());
var key = keyProvider.Generate().PublicKey;
_synchronizationManager = Substitute.For <ISynchronizationManager>();
IStatsConfig statsConfig = _configurationProvider.GetConfig <IStatsConfig>();
var nodeTable = new NodeTable(_nodeFactory, Substitute.For <IKeyStore>(), new NodeDistanceCalculator(networkConfig), networkConfig, _logManager);
nodeTable.Initialize(new NodeId(key));
_discoveryManager = new DiscoveryManager(new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, new DiscoveryMessageFactory(networkConfig, _timestamp), Substitute.For <IEvictionManager>(), new NodeStatsProvider(_configurationProvider.GetConfig <IStatsConfig>(), _nodeFactory, _logManager, true), networkConfig, _logManager), _nodeFactory, nodeTable, new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager)), networkConfig, _logManager);
_discoveryManager.MessageSender = Substitute.For <IMessageSender>();
_transactionPool = NullTransactionPool.Instance;
_blockTree = Substitute.For <IBlockTree>();
var app = new DiscoveryApp(new NodesLocator(nodeTable, _discoveryManager, _configurationProvider, _logManager), _discoveryManager, _nodeFactory, nodeTable, Substitute.For <IMessageSerializationService>(), new CryptoRandom(), Substitute.For <INetworkStorage>(), networkConfig, _logManager, new PerfService(_logManager));
app.Initialize(key);
var sessionLogger = new PeerSessionLogger(_logManager, _configurationProvider, new PerfService(_logManager));
sessionLogger.Init(Path.GetTempPath());
var networkStorage = new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager));
_peerManager = new PeerManager(_localPeer, app, _synchronizationManager, new NodeStatsProvider(statsConfig, _nodeFactory, _logManager, true), networkStorage, _nodeFactory, _configurationProvider, new PerfService(_logManager), _transactionPool, _logManager, sessionLogger);
_peerManager.Init(true);
}
private Transactions AddAndFilterTransactions(ITransactionStorage storage, params ITransactionFilter[] filters)
{
_transactionPool = CreatePool(storage);
foreach (var filter in filters ?? Enumerable.Empty <ITransactionFilter>())
{
_transactionPool.AddFilter(filter);
}
var pendingTransactions = AddTransactionsToPool();
var filteredTransactions = GetTransactionsFromStorage(storage, pendingTransactions);
return(new Transactions(pendingTransactions, filteredTransactions));
}
public DevBlockProducer(
ITransactionPool transactionPool,
IBlockchainProcessor devProcessor,
IBlockTree blockTree,
ITimestamp timestamp,
ILogManager logManager)
{
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_processor = devProcessor ?? throw new ArgumentNullException(nameof(devProcessor));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_timestamp = timestamp;
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
}
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");
}
public void should_delete_peers()
{
_transactionPool = CreatePool(_noTransactionStorage);
var peers = GetPeers();
foreach ((ISynchronizationPeer peer, _) in peers)
{
_transactionPool.AddPeer(peer);
}
foreach ((ISynchronizationPeer peer, _) in peers)
{
_transactionPool.RemovePeer(peer.Node.Id);
}
}
