public void parity_netPeers_null_ActivePeers()
{
LimboLogs logger = LimboLogs.Instance;
MainnetSpecProvider specProvider = MainnetSpecProvider.Instance;
EthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider.ChainId, logger);
InMemoryTxStorage txStorage = new InMemoryTxStorage();
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
ITransactionComparerProvider transactionComparerProvider =
new TransactionComparerProvider(specProvider, blockTree);
TxPool.TxPool txPool = new TxPool.TxPool(txStorage, ethereumEcdsa, new ChainHeadInfoProvider(specProvider, blockTree, new StateReader(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance)), new TxPoolConfig(),
new TxValidator(specProvider.ChainId), LimboLogs.Instance, transactionComparerProvider.GetDefaultComparer());
new OnChainTxWatcher(blockTree, txPool, specProvider, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
IPeerManager peerManager = Substitute.For <IPeerManager>();
IParityRpcModule parityRpcModule = new ParityRpcModule(ethereumEcdsa, txPool, blockTree, receiptStorage, new Enode(TestItem.PublicKeyA, IPAddress.Loopback, 8545),
_signerStore, new MemKeyStore(new[] { TestItem.PrivateKeyA }), logger, peerManager);
string serialized = RpcTest.TestSerializedRequest(parityRpcModule, "parity_netPeers");
string expectedResult = "{\"jsonrpc\":\"2.0\",\"result\":{\"active\":0,\"connected\":0,\"max\":0,\"peers\":[]},\"id\":67}";
Assert.AreEqual(expectedResult, serialized);
}
public void Mainnet_loads_properly()
{
ChainSpecLoader loader = new(new EthereumJsonSerializer());
string path = Path.Combine(TestContext.CurrentContext.WorkDirectory, "../../../../Chains/foundation.json");
ChainSpec chainSpec = loader.Load(File.ReadAllText(path));
chainSpec.Parameters.Eip2537Transition.Should().BeNull();
ChainSpecBasedSpecProvider provider = new(chainSpec);
MainnetSpecProvider mainnet = MainnetSpecProvider.Instance;
List <long> blockNumbersToTest = new()
{
0,
1,
MainnetSpecProvider.HomesteadBlockNumber - 1,
MainnetSpecProvider.HomesteadBlockNumber,
MainnetSpecProvider.TangerineWhistleBlockNumber - 1,
MainnetSpecProvider.TangerineWhistleBlockNumber,
MainnetSpecProvider.SpuriousDragonBlockNumber - 1,
MainnetSpecProvider.SpuriousDragonBlockNumber,
MainnetSpecProvider.ByzantiumBlockNumber - 1,
MainnetSpecProvider.ByzantiumBlockNumber,
MainnetSpecProvider.ConstantinopleFixBlockNumber - 1,
MainnetSpecProvider.ConstantinopleFixBlockNumber,
MainnetSpecProvider.IstanbulBlockNumber - 1,
MainnetSpecProvider.IstanbulBlockNumber,
MainnetSpecProvider.MuirGlacierBlockNumber - 1,
MainnetSpecProvider.MuirGlacierBlockNumber,
MainnetSpecProvider.BerlinBlockNumber - 1,
MainnetSpecProvider.BerlinBlockNumber,
MainnetSpecProvider.LondonBlockNumber - 1,
MainnetSpecProvider.LondonBlockNumber,
MainnetSpecProvider.ArrowGlacierBlockNumber - 1,
MainnetSpecProvider.ArrowGlacierBlockNumber,
MainnetSpecProvider.GrayGlacierBlockNumber - 1,
MainnetSpecProvider.GrayGlacierBlockNumber,
99_000_000, // far in the future
};
CompareSpecProviders(mainnet, provider, blockNumbersToTest);
Assert.AreEqual(MainnetSpecProvider.LondonBlockNumber, provider.GenesisSpec.Eip1559TransitionBlock);
Assert.AreEqual(0_000_000, provider.GetSpec(4_369_999).DifficultyBombDelay);
Assert.AreEqual(3_000_000, provider.GetSpec(4_370_000).DifficultyBombDelay);
Assert.AreEqual(3_000_000, provider.GetSpec(7_279_999).DifficultyBombDelay);
Assert.AreEqual(3_000_000, provider.GetSpec(7_279_999).DifficultyBombDelay);
Assert.AreEqual(5_000_000, provider.GetSpec(7_280_000).DifficultyBombDelay);
Assert.AreEqual(5_000_000, provider.GetSpec(9_199_999).DifficultyBombDelay);
Assert.AreEqual(9_000_000, provider.GetSpec(9_200_000).DifficultyBombDelay);
Assert.AreEqual(9_000_000, provider.GetSpec(12_000_000).DifficultyBombDelay);
Assert.AreEqual(9_000_000, provider.GetSpec(12_964_999).DifficultyBombDelay);
Assert.AreEqual(9_700_000, provider.GetSpec(12_965_000).DifficultyBombDelay);
Assert.AreEqual(9_700_000, provider.GetSpec(13_772_999).DifficultyBombDelay);
Assert.AreEqual(10_700_000, provider.GetSpec(13_773_000).DifficultyBombDelay);
Assert.AreEqual(10_700_000, provider.GetSpec(15_049_999).DifficultyBombDelay);
Assert.AreEqual(11_400_000, provider.GetSpec(15_050_000).DifficultyBombDelay);
Assert.AreEqual(11_400_000, provider.GetSpec(99_414_000).DifficultyBombDelay);
Assert.AreEqual(MainnetSpecProvider.Instance.TerminalTotalDifficulty, provider.TerminalTotalDifficulty);
}
public static INdmBlockchainBridge BuildABridge()
{
IDbProvider memDbProvider = TestMemDbProvider.Init();
StateReader stateReader = new StateReader(
new TrieStore(memDbProvider.StateDb, LimboLogs.Instance), memDbProvider.CodeDb, LimboLogs.Instance);
var trieStore = new TrieStore(memDbProvider.StateDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(trieStore, memDbProvider.CodeDb, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
MainnetSpecProvider specProvider = MainnetSpecProvider.Instance;
ITransactionComparerProvider transactionComparerProvider =
new TransactionComparerProvider(MainnetSpecProvider.Instance, blockTree);
ITxPool txPool = new TxPool.TxPool(
new InMemoryTxStorage(), ecdsa,
new ChainHeadInfoProvider(specProvider, blockTree, stateProvider),
new TxPoolConfig(),
new TxValidator(specProvider.ChainId),
LimboLogs.Instance,
transactionComparerProvider.GetDefaultComparer());
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(ecdsa, specProvider);
LogFinder logFinder = new LogFinder(blockTree, new InMemoryReceiptStorage(), NullBloomStorage.Instance,
LimboLogs.Instance, receiptsRecovery, 1024);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new TrieStore(memDbProvider.StateDb, LimboLogs.Instance).AsReadOnly(memDbProvider.StateDb),
new ReadOnlyBlockTree(blockTree),
specProvider, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
specProvider,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
public void Initialize()
{
LimboLogs logger = LimboLogs.Instance;
MainnetSpecProvider specProvider = MainnetSpecProvider.Instance;
EthereumEcdsa ethereumEcdsa = new(specProvider.ChainId, logger);
Peer peerA = SetUpPeerA(); //standard case
Peer peerB = SetUpPeerB(); //Session is null
Peer peerC = SetUpPeerC(); //Node is null, Caps are empty
IPeerManager peerManager = Substitute.For <IPeerManager>();
peerManager.ActivePeers.Returns(new List <Peer> {
peerA, peerB, peerC
});
peerManager.ConnectedPeers.Returns(new List <Peer> {
peerA, peerB, peerA, peerC, peerB
});
peerManager.MaxActivePeers.Returns(15);
StateProvider stateProvider = new(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance);
StateReader stateReader = new(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
ITransactionComparerProvider transactionComparerProvider =
new TransactionComparerProvider(specProvider, blockTree);
TxPool.TxPool txPool = new(ethereumEcdsa, new ChainHeadInfoProvider(new FixedBlockChainHeadSpecProvider(specProvider), blockTree, stateProvider), new TxPoolConfig(),
new TxValidator(specProvider.ChainId), LimboLogs.Instance, transactionComparerProvider.GetDefaultComparer());
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
_signerStore = new Signer(specProvider.ChainId, TestItem.PrivateKeyB, logger);
_parityRpcModule = new ParityRpcModule(ethereumEcdsa, txPool, blockTree, receiptStorage, new Enode(TestItem.PublicKeyA, IPAddress.Loopback, 8545),
_signerStore, new MemKeyStore(new[] { TestItem.PrivateKeyA }), MainnetSpecProvider.Instance, peerManager);
int blockNumber = 2;
Transaction pendingTransaction = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber)).TestObject;
pendingTransaction.Signature.V = 37;
stateProvider.CreateAccount(pendingTransaction.SenderAddress, UInt256.UInt128MaxValue);
txPool.SubmitTx(pendingTransaction, TxHandlingOptions.None);
blockNumber = 1;
Transaction transaction1 = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber))
.WithNonce(100).TestObject;
transaction1.Signature.V = 37;
stateProvider.CreateAccount(transaction1.SenderAddress, UInt256.UInt128MaxValue);
var transaction2 = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber))
.WithNonce(120).TestObject;
transaction2.Signature.V = 37;
var transaction3 = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber))
.WithNonce(110).TestObject;
transaction2.Signature.V = 37;
Block genesis = Build.A.Block.Genesis
.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"))
.TestObject;
blockTree.SuggestBlock(genesis);
blockTree.UpdateMainChain(new[] { genesis }, true);
Block previousBlock = genesis;
Block block = Build.A.Block.WithNumber(blockNumber).WithParent(previousBlock)
.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"))
.WithTransactions(transaction1, transaction2, transaction3)
.TestObject;
blockTree.SuggestBlock(block);
blockTree.UpdateMainChain(new[] { block }, true);
LogEntry[] logEntries = new[] { Build.A.LogEntry.TestObject };
TxReceipt receipt1 = new()
{
Bloom = new Bloom(logEntries),
Index = 0,
Recipient = TestItem.AddressA,
Sender = TestItem.AddressB,
BlockHash = TestItem.KeccakA,
BlockNumber = 1,
ContractAddress = TestItem.AddressC,
GasUsed = 1000,
TxHash = transaction1.Hash,
StatusCode = 0,
GasUsedTotal = 2000,
Logs = logEntries
};
TxReceipt receipt2 = new()
{
Bloom = new Bloom(logEntries),
Index = 1,
Recipient = TestItem.AddressA,
Sender = TestItem.AddressB,
BlockHash = TestItem.KeccakA,
BlockNumber = 1,
ContractAddress = TestItem.AddressC,
GasUsed = 1000,
TxHash = transaction2.Hash,
StatusCode = 0,
GasUsedTotal = 2000,
Logs = logEntries
};
TxReceipt receipt3 = new()
{
Bloom = new Bloom(logEntries),
Index = 2,
Recipient = TestItem.AddressA,
Sender = TestItem.AddressB,
BlockHash = TestItem.KeccakA,
BlockNumber = 1,
ContractAddress = TestItem.AddressC,
GasUsed = 1000,
TxHash = transaction3.Hash,
StatusCode = 0,
GasUsedTotal = 2000,
Logs = logEntries
};
receiptStorage.Insert(block, receipt1, receipt2, receipt3);
}
private static Peer SetUpPeerA()
{
Node node = new(TestItem.PublicKeyA, "127.0.0.1", 30303, true);
node.ClientId = "Geth/v1.9.21-stable/linux-amd64/go1.15.2";
Peer peer = new(node);
peer.InSession = null;
peer.OutSession = Substitute.For <ISession>();
peer.OutSession.RemoteNodeId.Returns(TestItem.PublicKeyA);
IProtocolHandler protocolHandler = Substitute.For <IProtocolHandler, ISyncPeer>();
peer.OutSession.TryGetProtocolHandler(Protocol.Eth, out Arg.Any <IProtocolHandler>()).Returns(x =>
{
x[1] = protocolHandler;
return(true);
});
byte version = 65;
protocolHandler.ProtocolVersion.Returns(version);
if (protocolHandler is ISyncPeer syncPeer)
{
UInt256 difficulty = 0x5ea4ed;
syncPeer.TotalDifficulty.Returns(difficulty);
syncPeer.HeadHash.Returns(TestItem.KeccakA);
}
IProtocolHandler p2PProtocolHandler = Substitute.For <IProtocolHandler, IP2PProtocolHandler>();
peer.OutSession.TryGetProtocolHandler(Protocol.P2P, out Arg.Any <IProtocolHandler>()).Returns(x =>
{
x[1] = p2PProtocolHandler;
return(true);
});
if (p2PProtocolHandler is IP2PProtocolHandler p2PHandler)
{
p2PHandler.AgreedCapabilities.Returns(new List <Capability> {
new("eth", 65), new("eth", 64)
});
}
public void Initialize()
{
LimboLogs logger = LimboLogs.Instance;
MainnetSpecProvider specProvider = MainnetSpecProvider.Instance;
EthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider.ChainId, logger);
InMemoryTxStorage txStorage = new InMemoryTxStorage();
Peer peerA = SetUpPeerA(); //standard case
Peer peerB = SetUpPeerB(); //Session is null
Peer peerC = SetUpPeerC(); //Node is null, Caps are empty
IPeerManager peerManager = Substitute.For <IPeerManager>();
peerManager.ActivePeers.Returns(new List <Peer> {
peerA, peerB, peerC
});
peerManager.ConnectedPeers.Returns(new List <Peer> {
peerA, peerB, peerA, peerC, peerB
});
peerManager.MaxActivePeers.Returns(15);
StateProvider stateProvider = new StateProvider(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance);
StateReader stateReader = new StateReader(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
ITransactionComparerProvider transactionComparerProvider =
new TransactionComparerProvider(specProvider, blockTree);
TxPool.TxPool txPool = new TxPool.TxPool(txStorage, ethereumEcdsa, new ChainHeadInfoProvider(new FixedBlockChainHeadSpecProvider(specProvider), blockTree, stateProvider), new TxPoolConfig(),
new TxValidator(specProvider.ChainId), LimboLogs.Instance, transactionComparerProvider.GetDefaultComparer());
new OnChainTxWatcher(blockTree, txPool, specProvider, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
_signerStore = new Signer(specProvider.ChainId, TestItem.PrivateKeyB, logger);
_parityRpcModule = new ParityRpcModule(ethereumEcdsa, txPool, blockTree, receiptStorage, new Enode(TestItem.PublicKeyA, IPAddress.Loopback, 8545),
_signerStore, new MemKeyStore(new[] { TestItem.PrivateKeyA }), logger, peerManager);
int blockNumber = 2;
Transaction pendingTransaction = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber)).TestObject;
pendingTransaction.Signature.V = 37;
stateProvider.CreateAccount(pendingTransaction.SenderAddress, UInt256.UInt128MaxValue);
txPool.AddTransaction(pendingTransaction, TxHandlingOptions.None);
blockNumber = 1;
Transaction transaction = Build.A.Transaction.Signed(ethereumEcdsa, TestItem.PrivateKeyD, false)
.WithSenderAddress(Address.FromNumber((UInt256)blockNumber))
.WithNonce(100).TestObject;
transaction.Signature.V = 37;
stateProvider.CreateAccount(transaction.SenderAddress, UInt256.UInt128MaxValue);
txPool.AddTransaction(transaction, TxHandlingOptions.None);
Block genesis = Build.A.Block.Genesis
.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"))
.TestObject;
blockTree.SuggestBlock(genesis);
blockTree.UpdateMainChain(new[] { genesis }, true);
Block previousBlock = genesis;
Block block = Build.A.Block.WithNumber(blockNumber).WithParent(previousBlock)
.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"))
.WithTransactions(transaction)
.TestObject;
blockTree.SuggestBlock(block);
blockTree.UpdateMainChain(new[] { block }, true);
LogEntry[] logEntries = new[] { Build.A.LogEntry.TestObject };
receiptStorage.Insert(block, new TxReceipt()
{
Bloom = new Bloom(logEntries),
Index = 1,
Recipient = TestItem.AddressA,
Sender = TestItem.AddressB,
BlockHash = TestItem.KeccakA,
BlockNumber = 1,
ContractAddress = TestItem.AddressC,
GasUsed = 1000,
TxHash = transaction.Hash,
StatusCode = 0,
GasUsedTotal = 2000,
Logs = logEntries
});
}