public Eth63ProtocolHandler(ISession session,
IMessageSerializationService serializer,
INodeStatsManager nodeStatsManager,
ISyncServer syncServer,
ILogManager logManager,
ITxPool txPool) : base(session, serializer, nodeStatsManager, syncServer, logManager, txPool)
{
}
public void should_not_retrieve_not_added_transaction()
{
var transaction = Build.A.Transaction.SignedAndResolved().TestObject;
_txPool = CreatePool(_inMemoryTxStorage);
_txPool.TryGetPendingTransaction(transaction.Hash, out var retrievedTransaction).Should().BeFalse();
retrievedTransaction.Should().BeNull();
}
public void should_delete_pending_transactions()
{
_txPool = CreatePool(_noTransactionStorage);
var transactions = AddTransactionsToPool();
DeleteTransactionsFromPool(transactions);
_txPool.GetPendingTransactions().Should().BeEmpty();
}
public void Should_not_try_to_load_transactions_from_storage()
{
var transaction = Build.A.Transaction.SignedAndResolved().TestObject;
_txPool = CreatePool(_inMemoryTxStorage);
_inMemoryTxStorage.Add(transaction);
_txPool.TryGetPendingTransaction(transaction.Hash, out var retrievedTransaction).Should().BeFalse();
}
public TxPoolTxSource(ITxPool?transactionPool, IStateReader?stateReader, ISpecProvider?specProvider, ITransactionComparerProvider transactionComparerProvider, ILogManager?logManager, ITxFilterPipeline?txFilterPipeline)
{
_transactionPool = transactionPool ?? throw new ArgumentNullException(nameof(transactionPool));
_stateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
_transactionComparerProvider = transactionComparerProvider ?? throw new ArgumentNullException(nameof(transactionComparerProvider));
_txFilterPipeline = txFilterPipeline ?? throw new ArgumentNullException(nameof(txFilterPipeline));
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
_logger = logManager?.GetClassLogger <TxPoolTxSource>() ?? throw new ArgumentNullException(nameof(logManager));
}
public void should_retrieve_stored_transaction_correctly()
{
var transaction = Build.A.Transaction.SignedAndResolved().TestObject;
_txPool = CreatePool(_inMemoryTxStorage);
_inMemoryTxStorage.Add(transaction, 100);
_txPool.TryGetPendingTransaction(transaction.Hash, out var retrievedTransaction).Should().BeTrue();
retrievedTransaction.Should().BeEquivalentTo(transaction);
}
private Transactions AddTransactions(ITxStorage storage)
{
_txPool = CreatePool(storage);
var pendingTransactions = AddTransactionsToPool();
var persistedTransactions = GetTransactionsFromStorage(storage, pendingTransactions);
return(new Transactions(pendingTransactions, persistedTransactions));
}
public void should_broadcast_own_transactions_that_were_reorganized_out()
{
_txPool = CreatePool(_noTxStorage);
var transactions = AddOwnTransactionToPool();
_txPool.RemoveTransaction(transactions[0].Hash, 1);
_txPool.AddTransaction(transactions[0], TxHandlingOptions.PersistentBroadcast);
Assert.AreEqual(1, _txPool.GetOwnPendingTransactions().Length);
}
public void should_drop_own_transaction_over_limit()
{
_txPool = CreatePool(_noTxStorage, new TxPoolConfig()
{
Size = 10
});
AddTransactionsToPool(transactionsPerPeer: 5); //generates 50 tx with 1..9 gasprice per 5 peers, only 8 up will be kept
_txPool.GetOwnPendingTransactions().Min(t => t.GasPrice).Should().Be(8);
}
public void should_add_valid_transactions()
{
_txPool = CreatePool(_noTxStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA).TestObject;
AddTxResult result = _txPool.AddTransaction(tx, TxHandlingOptions.PersistentBroadcast);
_txPool.GetPendingTransactions().Length.Should().Be(1);
result.Should().Be(AddTxResult.Added);
}
public TxPoolSender(ITxPool txPool, params ITxSealer[] sealers)
{
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_sealers = sealers ?? throw new ArgumentNullException(nameof(sealers));
if (sealers.Length == 0)
{
throw new ArgumentException("Sealers can not be empty.", nameof(sealers));
}
}
public BlockTree(
IDb blockDb,
IDb headerDb,
IDb blockInfoDb,
IChainLevelInfoRepository chainLevelInfoRepository,
ISpecProvider specProvider,
ITxPool txPool,
IBloomStorage bloomStorage,
ISyncConfig syncConfig,
ILogManager logManager)
{
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_blockDb = blockDb ?? throw new ArgumentNullException(nameof(blockDb));
_headerDb = headerDb ?? throw new ArgumentNullException(nameof(headerDb));
_blockInfoDb = blockInfoDb ?? throw new ArgumentNullException(nameof(blockInfoDb));
_specProvider = specProvider;
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_bloomStorage = bloomStorage ?? throw new ArgumentNullException(nameof(txPool));
_syncConfig = syncConfig ?? throw new ArgumentNullException(nameof(syncConfig));
_chainLevelInfoRepository = chainLevelInfoRepository ?? throw new ArgumentNullException(nameof(chainLevelInfoRepository));
var deletePointer = _blockInfoDb.Get(DeletePointerAddressInDb);
if (deletePointer != null)
{
DeleteBlocks(new Keccak(deletePointer));
}
ChainLevelInfo genesisLevel = LoadLevel(0, true);
if (genesisLevel != null)
{
if (genesisLevel.BlockInfos.Length != 1)
{
// just for corrupted test bases
genesisLevel.BlockInfos = new[] { genesisLevel.BlockInfos[0] };
_chainLevelInfoRepository.PersistLevel(0, genesisLevel);
//throw new InvalidOperationException($"Genesis level in DB has {genesisLevel.BlockInfos.Length} blocks");
}
if (genesisLevel.BlockInfos[0].WasProcessed)
{
BlockHeader genesisHeader = FindHeader(genesisLevel.BlockInfos[0].BlockHash, BlockTreeLookupOptions.None);
Genesis = genesisHeader;
LoadHeadBlockAtStart();
}
RecalculateTreeLevels();
}
if (_logger.IsInfo)
{
_logger.Info($"Block tree initialized, last processed is {Head?.Header?.ToString(BlockHeader.Format.Short) ?? "0"}, best queued is {BestSuggestedHeader?.Number.ToString() ?? "0"}, best known is {BestKnownNumber}, lowest inserted header {LowestInsertedHeader?.Number}, body {LowestInsertedBody?.Number}");
}
ThisNodeInfo.AddInfo("Chain ID :", $"{Nethermind.Core.ChainId.GetChainName(ChainId)}");
ThisNodeInfo.AddInfo("Chain head :", $"{Head?.Header?.ToString(BlockHeader.Format.Short) ?? "0"}");
}
public void should_add_valid_transactions()
{
_txPool = CreatePool(_noTxStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, RopstenSpecProvider.ByzantiumBlockNumber).TestObject;
AddTxResult result = _txPool.AddTransaction(tx, 1);
_txPool.GetPendingTransactions().Length.Should().Be(1);
result.Should().Be(AddTxResult.Added);
}
public void should_ignore_old_scheme_signatures()
{
_txPool = CreatePool(_noTxStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, 1).TestObject;
AddTxResult result = _txPool.AddTransaction(tx, 1);
_txPool.GetPendingTransactions().Length.Should().Be(0);
result.Should().Be(AddTxResult.OldScheme);
}
public void should_return_true_when_asking_for_txHash_existing_in_pool()
{
_txPool = CreatePool(_noTxStorage);
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA).TestObject;
EnsureSenderBalance(tx);
_txPool.AddTransaction(tx, TxHandlingOptions.PersistentBroadcast);
_txPool.IsInHashCache(tx.Hash).Should().Be(true);
_txPool.RemoveTransaction(tx.Hash).Should().Be(true);
}
public void should_not_broadcast_own_transactions_that_faded_out_and_came_back()
{
_txPool = CreatePool(_noTxStorage);
var transactions = AddOwnTransactionToPool();
_txPool.RemoveTransaction(transactions[0].Hash, 1);
_txPool.RemoveTransaction(TestItem.KeccakA, 100);
_txPool.AddTransaction(transactions[0], TxHandlingOptions.None);
Assert.AreEqual(0, _txPool.GetOwnPendingTransactions().Length);
}
public Eth63ProtocolHandler(ISession session,
IMessageSerializationService serializer,
INodeStatsManager nodeStatsManager,
ISyncServer syncServer,
ITxPool txPool,
ILogManager logManager) : base(session, serializer, nodeStatsManager, syncServer, txPool, logManager)
{
_nodeDataRequests = new MessageQueue <GetNodeDataMessage, byte[][]>(Send);
_receiptsRequests = new MessageQueue <GetReceiptsMessage, TxReceipt[][]>(Send);
}
public void Setup()
{
_blockchainBridge = Substitute.For <IBlockchainBridge>();
_txPool = Substitute.For <ITxPool>();
_blockFinder = Substitute.For <IBlockFinder>();
_stateReader = Substitute.For <IStateReader>();
_txSender = Substitute.For <ITxSender>();
_ndmBridge = new NdmBlockchainBridge(_blockchainBridge, _blockFinder, _stateReader, _txSender);
}
} = true; // no need to sync it at the moment
public BlockTree(
IDb blockDb,
IDb headerDb,
IDb blockInfoDb,
ISpecProvider specProvider,
ITxPool txPool,
ILogManager logManager)
: this(blockDb, headerDb, blockInfoDb, specProvider, txPool, new SyncConfig(), logManager)
{
}
public void should_add_peers()
{
_txPool = CreatePool(_noTransactionStorage);
var peers = GetPeers();
foreach ((ISyncPeer peer, _) in peers)
{
_txPool.AddPeer(peer);
}
}
public void should_add_peers()
{
_txPool = CreatePool(_noTxStorage);
var peers = GetPeers();
foreach ((ITxPoolPeer peer, _) in peers)
{
_txPool.AddPeer(peer);
}
}
public void should_ignore_transactions_with_different_chain_id()
{
_txPool = CreatePool(_noTxStorage);
EthereumEcdsa ecdsa = new EthereumEcdsa(MainNetSpecProvider.Instance, _logManager);
Transaction tx = Build.A.Transaction.SignedAndResolved(ecdsa, TestItem.PrivateKeyA, MainNetSpecProvider.ByzantiumBlockNumber).TestObject;
AddTxResult result = _txPool.AddTransaction(tx, 1);
_txPool.GetPendingTransactions().Length.Should().Be(0);
result.Should().Be(AddTxResult.InvalidChainId);
}
public void Initialize()
{
ISpecProvider specProvider = MainNetSpecProvider.Instance;
ITxPool txPool = NullTxPool.Instance;
MemDbProvider dbProvider = new MemDbProvider();
BlockTree blockTree = new BlockTree(dbProvider.BlocksDb, dbProvider.HeadersDb, dbProvider.BlockInfosDb, new ChainLevelInfoRepository(dbProvider.BlockInfosDb), specProvider, txPool, new SyncConfig(), LimboLogs.Instance);
_modulePool = new BoundedModulePool <IEthModule>(1, new EthModuleFactory(dbProvider, txPool, NullWallet.Instance, blockTree, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance), NullBlockProcessor.Instance, new InMemoryReceiptStorage(), specProvider, LimboLogs.Instance));
}
public void should_ignore_transactions_with_different_chain_id()
{
_txPool = CreatePool(_noTxStorage);
EthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, _logManager);
Transaction tx = Build.A.Transaction.SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject;
AddTxResult result = _txPool.AddTransaction(tx, TxHandlingOptions.PersistentBroadcast);
_txPool.GetPendingTransactions().Length.Should().Be(0);
result.Should().Be(AddTxResult.InvalidChainId);
}
public DepositService(IBlockchainBridge blockchainBridge, ITxPool txPool, IAbiEncoder abiEncoder, IWallet wallet,
Address contractAddress, ILogManager logManager)
{
_blockchainBridge = blockchainBridge ?? throw new ArgumentNullException(nameof(blockchainBridge));
_txPool = txPool;
_abiEncoder = abiEncoder ?? throw new ArgumentNullException(nameof(abiEncoder));
_wallet = wallet ?? throw new ArgumentNullException(nameof(wallet));
_contractAddress = contractAddress ?? throw new ArgumentNullException(nameof(contractAddress));
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
}
public Eth62ProtocolHandler(
ISession session,
IMessageSerializationService serializer,
INodeStatsManager statsManager,
ISyncServer syncServer,
ITxPool txPool,
ILogManager logManager) : base(session, serializer, statsManager, syncServer, txPool, logManager)
{
_floodController = new TxFloodController(this, Logger);
}
public void should_notify_added_peer_of_own_tx()
{
_txPool = CreatePool(_noTxStorage);
var tx = AddOwnTransactionToPool().First();
ITxPoolPeer txPoolPeer = Substitute.For <ITxPoolPeer>();
txPoolPeer.Id.Returns(TestItem.PublicKeyA);
_txPool.AddPeer(txPoolPeer);
txPoolPeer.Received().SendNewTransaction(tx, false);
}
public Eth64ProtocolHandler(ISession session,
IMessageSerializationService serializer,
INodeStatsManager nodeStatsManager,
ISyncServer syncServer,
ITxPool txPool,
ISpecProvider specProvider,
ILogManager logManager) : base(session, serializer, nodeStatsManager, syncServer, txPool, logManager)
{
_specProvider = specProvider ?? throw new ArgumentNullException(nameof(specProvider));
}
public LesProtocolHandler(
ISession session,
IMessageSerializationService serializer,
INodeStatsManager statsManager,
ISyncServer syncServer,
ILogManager logManager,
ITxPool txPool) : base(session, serializer, statsManager, syncServer, txPool, logManager)
{
_lastSentBlock = SyncServer.Head;
}
protected SyncPeerProtocolHandlerBase(ISession session,
IMessageSerializationService serializer,
INodeStatsManager statsManager,
ISyncServer syncServer,
ITxPool txPool,
ILogManager logManager) : base(session, statsManager, serializer, logManager)
{
SyncServer = syncServer ?? throw new ArgumentNullException(nameof(syncServer));
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_timestamper = Timestamper.Default;
}
