private static JsonSerializer BuildSerializer <T>()
{
TraceModule module = new TraceModule(Substitute.For <IBlockchainBridge>(), NullLogManager.Instance, Substitute.For <ITracer>());
JsonSerializer serializer = new JsonSerializer();
foreach (JsonConverter converter in EthModuleFactory.Converters)
{
serializer.Converters.Add(converter);
}
foreach (JsonConverter converter in TraceModuleFactory.Converters)
{
serializer.Converters.Add(converter);
}
foreach (JsonConverter converter in EthereumJsonSerializer.BasicConverters)
{
serializer.Converters.Add(converter);
}
serializer.Converters.Add(new BlockParameterConverter());
return(serializer);
}
public void Can_trace_raw_parity_style()
{
TraceModule traceModule = new TraceModule(NullReceiptStorage.Instance, _tracer, _blockTree, _jsonRpcConfig);
ResultWrapper <ParityTxTraceFromReplay> result = traceModule.trace_rawTransaction(Bytes.FromHexString("f889808609184e72a00082271094000000000000000000000000000000000000000080a47f74657374320000000000000000000000000000000000000000000000000000006000571ca08a8bbf888cfa37bbf0bb965423625641fc956967b81d12e23709cead01446075a01ce999b56a8a88504be365442ea61239198e23d1fce7d00fcfc5cd3b44b7215f"), new[] { "trace" });
Assert.NotNull(result.Data);
}
public void IsRbacWhiteListPathsTests(string path, bool expected)
{
// Test
var actual = TraceModule.IsRbacWhiteListPaths(path);
// Assert
Assert.Equal(expected, actual);
}
public void Trace_replayBlockTransactions_null()
{
IBlockchainBridge blockchainBridge = Substitute.For <IBlockchainBridge>();
ITracer tracer = Substitute.For <ITracer>();
ITraceModule module = new TraceModule(blockchainBridge, NullLogManager.Instance, tracer);
string serialized = RpcTest.TestSerializedRequest(TraceModuleFactory.Converters, module, "trace_replayBlockTransactions", "earliest", "[]");
Assert.AreEqual("{\"id\":67,\"jsonrpc\":\"2.0\",\"result\":null}", serialized);
}
public void Trace_replay_transaction(string types)
{
ParityTraceAction subtrace = new ParityTraceAction();
subtrace.Value = 67890;
subtrace.CallType = "call";
subtrace.From = TestObject.AddressC;
subtrace.To = TestObject.AddressD;
subtrace.Input = Bytes.Empty;
subtrace.Gas = 10000;
subtrace.TraceAddress = new int[] { 0, 0 };
ParityLikeTxTrace result = new ParityLikeTxTrace();
result.Action = new ParityTraceAction();
result.Action.Value = 12345;
result.Action.CallType = "init";
result.Action.From = TestObject.AddressA;
result.Action.To = TestObject.AddressB;
result.Action.Input = new byte[] { 1, 2, 3, 4, 5, 6 };
result.Action.Gas = 40000;
result.Action.TraceAddress = new int[] { 0 };
result.Action.Subtraces.Add(subtrace);
result.BlockHash = TestObject.KeccakB;
result.BlockNumber = 123456;
result.TransactionHash = TestObject.KeccakC;
result.TransactionPosition = 5;
result.Action.TraceAddress = new int[] { 1, 2, 3 };
ParityAccountStateChange stateChange = new ParityAccountStateChange();
stateChange.Balance = new ParityStateChange <UInt256>(1, 2);
stateChange.Nonce = new ParityStateChange <UInt256>(0, 1);
stateChange.Storage = new Dictionary <UInt256, ParityStateChange <byte[]> >();
stateChange.Storage[1] = new ParityStateChange <byte[]>(new byte[] { 1 }, new byte[] { 2 });
result.StateChanges = new Dictionary <Address, ParityAccountStateChange>();
result.StateChanges.Add(TestObject.AddressC, stateChange);
ITracer tracer = Substitute.For <ITracer>();
tracer.ParityTrace(TestObject.KeccakC, Arg.Any <ParityTraceTypes>()).Returns(result);
ITraceModule module = new TraceModule(Substitute.For <IConfigProvider>(), NullLogManager.Instance, new UnforgivingJsonSerializer(), tracer);
JsonRpcResponse response = RpcTest.TestRequest(module, "trace_replayTransaction", TestObject.KeccakC.ToString(true), types);
Assert.IsNull(response.Error, "error");
Assert.NotNull(response.Result, "result");
// Assert.False(response.Result is string s && s.Contains("\""));
}
public void Trace_replay_transaction()
{
ParityLikeTxTrace result = BuildParityTxTrace();
ITracer tracer = Substitute.For <ITracer>();
tracer.ParityTrace(TestItem.KeccakC, Arg.Any <ParityTraceTypes>()).Returns(result);
ITraceModule module = new TraceModule(Substitute.For <IBlockchainBridge>(), NullLogManager.Instance, tracer);
string serialized = RpcTest.TestSerializedRequest(TraceModuleFactory.Converters, module, "trace_replayTransaction", TestItem.KeccakC.ToString(true), "[\"stateDiff\", \"trace\"]");
Assert.AreEqual("{\"id\":67,\"jsonrpc\":\"2.0\",\"result\":{\"output\":null,\"stateDiff\":{\"0x76e68a8696537e4141926f3e528733af9e237d69\":{\"balance\":{\"*\":{\"from\":\"0x1\",\"to\":\"0x2\"}},\"code\":{\"*\":{\"from\":\"0x01\",\"to\":\"0x02\"}},\"nonce\":{\"*\":{\"from\":\"0x0\",\"to\":\"0x1\"}},\"storage\":{\"0x0000000000000000000000000000000000000000000000000000000000000001\":{\"*\":{\"from\":\"0x0000000000000000000000000000000000000000000000000000000000000001\",\"to\":\"0x0000000000000000000000000000000000000000000000000000000000000002\"}}}}},\"trace\":[{\"action\":{\"callType\":\"init\",\"from\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"gas\":\"0x9c40\",\"input\":\"0x010203040506\",\"to\":\"0x942921b14f1b1c385cd7e0cc2ef7abe5598c8358\",\"value\":\"0x3039\"},\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":1,\"traceAddress\":[1,2,3],\"type\":null},{\"action\":{\"callType\":\"call\",\"from\":\"0x76e68a8696537e4141926f3e528733af9e237d69\",\"gas\":\"0x2710\",\"input\":\"0x\",\"to\":\"0x475674cb523a0a2736b7f7534390288fce16982c\",\"value\":\"0x10932\"},\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":0,\"traceAddress\":[0,0],\"type\":null}],\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"vmTrace\":null}}", serialized);
}
public void Trace_replay_transaction()
{
ParityTraceAction subtrace = new ParityTraceAction();
subtrace.Value = 67890;
subtrace.CallType = "call";
subtrace.From = TestItem.AddressC;
subtrace.To = TestItem.AddressD;
subtrace.Input = Bytes.Empty;
subtrace.Gas = 10000;
subtrace.TraceAddress = new int[] { 0, 0 };
ParityLikeTxTrace result = new ParityLikeTxTrace();
result.Action = new ParityTraceAction();
result.Action.Value = 12345;
result.Action.CallType = "init";
result.Action.From = TestItem.AddressA;
result.Action.To = TestItem.AddressB;
result.Action.Input = new byte[] { 1, 2, 3, 4, 5, 6 };
result.Action.Gas = 40000;
result.Action.TraceAddress = new int[] { 0 };
result.Action.Subtraces.Add(subtrace);
result.BlockHash = TestItem.KeccakB;
result.BlockNumber = 123456;
result.TransactionHash = TestItem.KeccakC;
result.TransactionPosition = 5;
result.Action.TraceAddress = new int[] { 1, 2, 3 };
ParityAccountStateChange stateChange = new ParityAccountStateChange();
stateChange.Balance = new ParityStateChange <UInt256>(1, 2);
stateChange.Nonce = new ParityStateChange <UInt256>(0, 1);
stateChange.Storage = new Dictionary <UInt256, ParityStateChange <byte[]> >();
stateChange.Storage[1] = new ParityStateChange <byte[]>(new byte[] { 1 }, new byte[] { 2 });
result.StateChanges = new Dictionary <Address, ParityAccountStateChange>();
result.StateChanges.Add(TestItem.AddressC, stateChange);
ITracer tracer = Substitute.For <ITracer>();
tracer.ParityTrace(TestItem.KeccakC, Arg.Any <ParityTraceTypes>()).Returns(result);
ITraceModule module = new TraceModule(NullLogManager.Instance, tracer);
string serialized = RpcTest.TestSerializedRequest(module, "trace_replayTransaction", TestItem.KeccakC.ToString(true), "[\"stateDiff\", \"trace\"]");
Assert.AreEqual("{\"id\":\"0x43\",\"jsonrpc\":\"2.0\",\"result\":{\"trace\":[{\"action\":{\"callType\":\"init\",\"from\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"gas\":\"0x9c40\",\"input\":\"0x010203040506\",\"to\":\"0x942921b14f1b1c385cd7e0cc2ef7abe5598c8358\",\"value\":\"0x3039\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":1,\"traceAddress\":\"[1, 2, 3]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"init\"},{\"action\":{\"callType\":\"call\",\"from\":\"0x76e68a8696537e4141926f3e528733af9e237d69\",\"gas\":\"0x2710\",\"input\":\"0x\",\"to\":\"0x475674cb523a0a2736b7f7534390288fce16982c\",\"value\":\"0x10932\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":0,\"traceAddress\":\"[0, 0]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"call\"}],\"stateDiff\":{\"0x76e68a8696537e4141926f3e528733af9e237d69\":{\"balance\":{\"*\":{\"from\":\"0x1\",\"to\":\"0x2\"}},\"code\":\"=\",\"nonce\":{\"*\":{\"from\":\"0x0\",\"to\":\"0x1\"}},\"storage\":{\"0x0000000000000000000000000000000000000000000000000000000000000001\":{\"*\":{\"from\":\"0x0000000000000000000000000000000000000000000000000000000000000001\",\"to\":\"0x0000000000000000000000000000000000000000000000000000000000000002\"}}}}}}}", serialized);
}
private static JsonSerializer BuildSerializer <T>()
{
TraceModule module = new TraceModule(Substitute.For <IConfigProvider>(), NullLogManager.Instance, Substitute.For <IJsonSerializer>(), Substitute.For <ITracer>());
JsonSerializer serializer = new JsonSerializer();
IReadOnlyCollection <JsonConverter> converters = module.GetConverters();
foreach (JsonConverter converter in converters)
{
serializer.Converters.Add(converter);
}
foreach (JsonConverter converter in EthereumJsonSerializer.BasicConverters)
{
serializer.Converters.Add(converter);
}
return(serializer);
}
public void Trace_raw_transaction()
{
ParityLikeTxTrace result1 = BuildParityTxTrace();
ParityLikeTxTrace result2 = BuildParityTxTrace();
Block block = Build.A.Block.TestObject;
IBlockchainBridge blockchainBridge = Substitute.For <IBlockchainBridge>();
blockchainBridge.FindEarliestBlock().Returns(block);
ITracer tracer = Substitute.For <ITracer>();
tracer.ParityTraceBlock(block.Hash, Arg.Any <ParityTraceTypes>()).Returns(new[] { result1, result2 });
ITraceModule module = new TraceModule(blockchainBridge, NullLogManager.Instance, tracer);
string serialized = RpcTest.TestSerializedRequest(TraceModuleFactory.Converters, module, "trace_rawTransaction", "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675", "[\"trace\"]");
Assert.AreEqual("{\"id\":67,\"jsonrpc\":\"2.0\",\"result\":null}", serialized);
}
public void Trace_block()
{
ParityLikeTxTrace result1 = BuildParityTxTrace();
ParityLikeTxTrace result2 = BuildParityTxTrace();
Block block = Build.A.Block.TestObject;
IBlockchainBridge blockchainBridge = Substitute.For <IBlockchainBridge>();
blockchainBridge.FindEarliestBlock().Returns(block);
ITracer tracer = Substitute.For <ITracer>();
tracer.ParityTraceBlock(block.Hash, Arg.Any <ParityTraceTypes>()).Returns(new[] { result1, result2 });
ITraceModule module = new TraceModule(blockchainBridge, NullLogManager.Instance, tracer);
string serialized = RpcTest.TestSerializedRequest(module, "trace_block", "earliest");
Assert.AreEqual("{\"id\":67,\"jsonrpc\":\"2.0\",\"result\":[{\"trace\":[{\"action\":{\"callType\":\"init\",\"from\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"gas\":\"0x9c40\",\"input\":\"0x010203040506\",\"to\":\"0x942921b14f1b1c385cd7e0cc2ef7abe5598c8358\",\"value\":\"0x3039\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":1,\"traceAddress\":\"[1, 2, 3]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"init\"},{\"action\":{\"callType\":\"call\",\"from\":\"0x76e68a8696537e4141926f3e528733af9e237d69\",\"gas\":\"0x2710\",\"input\":\"0x\",\"to\":\"0x475674cb523a0a2736b7f7534390288fce16982c\",\"value\":\"0x10932\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":0,\"traceAddress\":\"[0, 0]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"call\"}],\"stateDiff\":{\"0x76e68a8696537e4141926f3e528733af9e237d69\":{\"balance\":{\"*\":{\"from\":\"0x1\",\"to\":\"0x2\"}},\"code\":{\"*\":{\"from\":\"0x01\",\"to\":\"0x02\"}},\"nonce\":{\"*\":{\"from\":\"0x0\",\"to\":\"0x1\"}},\"storage\":{\"0x0000000000000000000000000000000000000000000000000000000000000001\":{\"*\":{\"from\":\"0x0000000000000000000000000000000000000000000000000000000000000001\",\"to\":\"0x0000000000000000000000000000000000000000000000000000000000000002\"}}}}}},{\"trace\":[{\"action\":{\"callType\":\"init\",\"from\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"gas\":\"0x9c40\",\"input\":\"0x010203040506\",\"to\":\"0x942921b14f1b1c385cd7e0cc2ef7abe5598c8358\",\"value\":\"0x3039\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":1,\"traceAddress\":\"[1, 2, 3]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"init\"},{\"action\":{\"callType\":\"call\",\"from\":\"0x76e68a8696537e4141926f3e528733af9e237d69\",\"gas\":\"0x2710\",\"input\":\"0x\",\"to\":\"0x475674cb523a0a2736b7f7534390288fce16982c\",\"value\":\"0x10932\"},\"blockHash\":\"0x1f675bff07515f5df96737194ea945c36c41e7b4fcef307b7cd4d0e602a69111\",\"blockNumber\":\"0x1e240\",\"result\":{\"gasUsed\":\"0x0\",\"output\":null},\"subtraces\":0,\"traceAddress\":\"[0, 0]\",\"transactionHash\":\"0x017e667f4b8c174291d1543c466717566e206df1bfd6f30271055ddafdb18f72\",\"transactionPosition\":5,\"type\":\"call\"}],\"stateDiff\":{\"0x76e68a8696537e4141926f3e528733af9e237d69\":{\"balance\":{\"*\":{\"from\":\"0x1\",\"to\":\"0x2\"}},\"code\":{\"*\":{\"from\":\"0x01\",\"to\":\"0x02\"}},\"nonce\":{\"*\":{\"from\":\"0x0\",\"to\":\"0x1\"}},\"storage\":{\"0x0000000000000000000000000000000000000000000000000000000000000001\":{\"*\":{\"from\":\"0x0000000000000000000000000000000000000000000000000000000000000001\",\"to\":\"0x0000000000000000000000000000000000000000000000000000000000000002\"}}}}}}]}", serialized);
}
private void RegisterJsonRpcModules()
{
if (!_initConfig.JsonRpcEnabled)
{
return;
}
if (_logger.IsDebug)
{
_logger.Debug($"Resolving CLI ({nameof(Cli.CliModuleLoader)})");
}
IReadOnlyDbProvider rpcDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain rpcChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, _transactionPool, _receiptStorage);
ITracer tracer = new Tracer(rpcChain.Processor, _receiptStorage, _blockTree, _dbProvider.TraceDb);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, _blockProcessor, _transactionPool, _logManager);
RpcState rpcState = new RpcState(_blockTree, _specProvider, rpcDbProvider, _logManager);
//creating blockchain bridge
var blockchainBridge = new BlockchainBridge(
rpcState.StateReader,
rpcState.StateProvider,
rpcState.StorageProvider,
rpcState.BlockTree,
_transactionPool,
_transactionPoolInfoProvider,
_receiptStorage,
filterStore,
filterManager,
_wallet,
rpcState.TransactionProcessor);
TransactionPool debugTransactionPool = new TransactionPool(new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval, _initConfig.RemovePendingTransactionInterval),
_timestamp,
_ethereumEcdsa,
_specProvider,
_logManager,
_initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
var debugReceiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
AlternativeChain debugChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, debugTransactionPool, debugReceiptStorage);
IReadOnlyDbProvider debugDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var debugBridge = new DebugBridge(_configProvider, debugDbProvider, tracer, debugChain.Processor);
EthModule module = new EthModule(_jsonSerializer, _configProvider, _logManager, blockchainBridge);
_rpcModuleProvider.Register <IEthModule>(module);
DebugModule debugModule = new DebugModule(_configProvider, _logManager, debugBridge, _jsonSerializer);
_rpcModuleProvider.Register <IDebugModule>(debugModule);
if (_sealer is CliqueSealer)
{
CliqueModule cliqueModule = new CliqueModule(_configProvider, _logManager, _jsonSerializer, new CliqueBridge(_blockProducer as ICliqueBlockProducer, _snapshotManager, _blockTree));
_rpcModuleProvider.Register <ICliqueModule>(cliqueModule);
}
if (_initConfig.EnableUnsecuredDevWallet)
{
PersonalBridge personalBridge = new PersonalBridge(_wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _configProvider, _logManager, _jsonSerializer);
_rpcModuleProvider.Register <IPersonalModule>(personalModule);
}
AdminModule adminModule = new AdminModule(_configProvider, _logManager, _jsonSerializer);
_rpcModuleProvider.Register <IAdminModule>(adminModule);
TxPoolModule txPoolModule = new TxPoolModule(_configProvider, _logManager, _jsonSerializer, blockchainBridge);
_rpcModuleProvider.Register <ITxPoolModule>(txPoolModule);
if (_initConfig.NetworkEnabled && _initConfig.SynchronizationEnabled)
{
NetModule netModule = new NetModule(_configProvider, _logManager, _jsonSerializer, new NetBridge(_enode, _syncManager, _peerManager));
_rpcModuleProvider.Register <INetModule>(netModule);
}
TraceModule traceModule = new TraceModule(_configProvider, _logManager, _jsonSerializer, tracer);
_rpcModuleProvider.Register <ITraceModule>(traceModule);
}
private void Initialize(bool auRa = false)
{
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IEthereumEcdsa ethereumEcdsa = new EthereumEcdsa(specProvider, LimboLogs.Instance);
ITxStorage txStorage = new InMemoryTxStorage();
_stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
IStateReader stateReader = new StateReader(_stateDb, codeDb, LimboLogs.Instance);
_stateProvider = new StateProvider(_stateDb, codeDb, LimboLogs.Instance);
_stateProvider.CreateAccount(TestItem.AddressA, 1000.Ether());
_stateProvider.CreateAccount(TestItem.AddressB, 1000.Ether());
_stateProvider.CreateAccount(TestItem.AddressC, 1000.Ether());
byte[] code = Bytes.FromHexString("0xabcd");
Keccak codeHash = Keccak.Compute(code);
_stateProvider.UpdateCode(code);
_stateProvider.UpdateCodeHash(TestItem.AddressA, codeHash, specProvider.GenesisSpec);
IStorageProvider storageProvider = new StorageProvider(_stateDb, _stateProvider, LimboLogs.Instance);
storageProvider.Set(new StorageCell(TestItem.AddressA, UInt256.One), Bytes.FromHexString("0xabcdef"));
storageProvider.Commit();
_stateProvider.Commit(specProvider.GenesisSpec);
_stateProvider.CommitTree();
ITxPool txPool = new TxPool.TxPool(txStorage, Timestamper.Default, ethereumEcdsa, specProvider, new TxPoolConfig(), _stateProvider, LimboLogs.Instance);
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockDb), specProvider, txPool, NullBloomStorage.Instance, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
VirtualMachine virtualMachine = new VirtualMachine(_stateProvider, storageProvider, new BlockhashProvider(blockTree, LimboLogs.Instance), specProvider, LimboLogs.Instance);
TransactionProcessor txProcessor = new TransactionProcessor(specProvider, _stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
IBlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, new RewardCalculator(specProvider), txProcessor, _stateDb, codeDb, _stateProvider, storageProvider, txPool, receiptStorage, LimboLogs.Instance);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, blockProcessor, txPool, LimboLogs.Instance);
_blockchainBridge = new BlockchainBridge(stateReader, _stateProvider, storageProvider, blockTree, txPool, receiptStorage, filterStore, filterManager, NullWallet.Instance, txProcessor, ethereumEcdsa, NullBloomStorage.Instance, LimboLogs.Instance, false);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, new TxSignaturesRecoveryStep(ethereumEcdsa, txPool, LimboLogs.Instance), LimboLogs.Instance, true);
blockchainProcessor.Start();
ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
blockTree.NewHeadBlock += (s, e) =>
{
Console.WriteLine(e.Block.Header.Hash);
if (e.Block.Number == 9)
{
resetEvent.Set();
}
};
var genesisBlockBuilder = Build.A.Block.Genesis.WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"));
if (auRa)
{
genesisBlockBuilder.WithAura(0, new byte[65]);
}
Block genesis = genesisBlockBuilder.TestObject;
blockTree.SuggestBlock(genesis);
Block previousBlock = genesis;
for (int i = 1; i < 10; i++)
{
List <Transaction> transactions = new List <Transaction>();
for (int j = 0; j < i; j++)
{
transactions.Add(Build.A.Transaction.WithNonce((UInt256)j).SignedAndResolved().TestObject);
}
BlockBuilder builder = Build.A.Block.WithNumber(i).WithParent(previousBlock).WithTransactions(transactions.ToArray()).WithStateRoot(new Keccak("0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f"));
if (auRa)
{
builder.WithAura(i, i.ToByteArray());
}
Block block = builder.TestObject;
blockTree.SuggestBlock(block);
previousBlock = block;
}
IReceiptsRecovery receiptsRecovery = new ReceiptsRecovery();
IReceiptFinder receiptFinder = new FullInfoReceiptFinder(receiptStorage, receiptsRecovery, blockTree);
resetEvent.Wait(2000);
_traceModule = new TraceModule(receiptFinder, new Tracer(_stateProvider, blockchainProcessor), _blockchainBridge);
_blockTree = blockTree;
}
private void RegisterJsonRpcModules()
{
if (!_initConfig.JsonRpcEnabled)
{
return;
}
if (_logger.IsDebug)
{
_logger.Debug($"Resolving CLI ({nameof(Cli.CliModuleLoader)})");
}
IReadOnlyDbProvider rpcDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain rpcChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
ITracer tracer = new Tracer(rpcChain.Processor, _receiptStorage, new ReadOnlyBlockTree(_blockTree), _dbProvider.TraceDb);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, _blockProcessor, _txPool, _logManager);
RpcState rpcState = new RpcState(_blockTree, _specProvider, rpcDbProvider, _logManager);
//creating blockchain bridge
var blockchainBridge = new BlockchainBridge(
rpcState.StateReader,
rpcState.StateProvider,
rpcState.StorageProvider,
rpcState.BlockTree,
_txPool,
_transactionPoolInfoProvider,
_receiptStorage,
filterStore,
filterManager,
_wallet,
rpcState.TransactionProcessor,
_ethereumEcdsa);
AlternativeChain debugChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, NullTxPool.Instance, NullReceiptStorage.Instance);
IReadOnlyDbProvider debugDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var debugBridge = new DebugBridge(_configProvider, debugDbProvider, tracer, debugChain.Processor);
EthModule module = new EthModule(_logManager, blockchainBridge);
_rpcModuleProvider.Register <IEthModule>(module);
DebugModule debugModule = new DebugModule(_logManager, debugBridge);
_rpcModuleProvider.Register <IDebugModule>(debugModule);
if (_sealValidator is CliqueSealValidator)
{
CliqueModule cliqueModule = new CliqueModule(_logManager, new CliqueBridge(_blockProducer as ICliqueBlockProducer, _snapshotManager, _blockTree));
_rpcModuleProvider.Register <ICliqueModule>(cliqueModule);
}
if (_initConfig.EnableUnsecuredDevWallet)
{
PersonalBridge personalBridge = new PersonalBridge(_ethereumEcdsa, _wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _logManager);
_rpcModuleProvider.Register <IPersonalModule>(personalModule);
}
AdminModule adminModule = new AdminModule(_logManager, _peerManager, _staticNodesManager);
_rpcModuleProvider.Register <IAdminModule>(adminModule);
TxPoolModule txPoolModule = new TxPoolModule(_logManager, blockchainBridge);
_rpcModuleProvider.Register <ITxPoolModule>(txPoolModule);
NetModule netModule = new NetModule(_logManager, new NetBridge(_enode, _syncServer, _peerManager));
_rpcModuleProvider.Register <INetModule>(netModule);
TraceModule traceModule = new TraceModule(blockchainBridge, _logManager, tracer);
_rpcModuleProvider.Register <ITraceModule>(traceModule);
}
private void RegisterJsonRpcModules()
{
if (!_initConfig.JsonRpcEnabled)
{
return;
}
IReadOnlyDbProvider rpcDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain rpcChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, _transactionPool, _receiptStorage);
ITracer tracer = new Tracer(rpcChain.Processor, _receiptStorage, _blockTree, _dbProvider.TraceDb);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, _blockProcessor, _transactionPool, _logManager);
_wallet = HiveEnabled ? (IWallet) new HiveWallet() : new DevWallet(_logManager);
RpcState rpcState = new RpcState(_blockTree, _specProvider, rpcDbProvider, _logManager);
//creating blockchain bridge
var blockchainBridge = new BlockchainBridge(
_ethereumSigner,
rpcState.StateProvider,
rpcState.BlockTree,
_transactionPool,
_transactionPoolInfoProvider,
_receiptStorage,
filterStore,
filterManager,
_wallet,
rpcState.TransactionProcessor);
TransactionPool debugTransactionPool = new TransactionPool(new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval, _initConfig.RemovePendingTransactionInterval),
_timestamp,
_ethereumSigner,
_logManager,
_initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
var debugReceiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
AlternativeChain debugChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, debugTransactionPool, debugReceiptStorage);
IReadOnlyDbProvider debugDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var debugBridge = new DebugBridge(debugDbProvider, tracer, debugChain.Processor);
JsonRpcModelMapper mapper = new JsonRpcModelMapper();
EthModule module = new EthModule(_jsonSerializer, _configProvider, mapper, _logManager, blockchainBridge);
_rpcModuleProvider.Register <IEthModule>(module);
DebugModule debugModule = new DebugModule(_configProvider, _logManager, debugBridge, mapper, _jsonSerializer);
_rpcModuleProvider.Register <IDebugModule>(debugModule);
if (_sealEngine is CliqueSealEngine)
{
CliqueModule cliqueModule = new CliqueModule(_configProvider, _logManager, _jsonSerializer, new CliqueBridge(_blockProducer as CliqueBlockProducer, _blockTree));
_rpcModuleProvider.Register <ICliqueModule>(cliqueModule);
}
AdminModule adminModule = new AdminModule(_configProvider, _logManager, _jsonSerializer);
_rpcModuleProvider.Register <IAdminModule>(adminModule);
TxPoolModule txPoolModule = new TxPoolModule(_configProvider, _logManager, _jsonSerializer, blockchainBridge, mapper);
_rpcModuleProvider.Register <ITxPoolModule>(txPoolModule);
if (_initConfig.NetworkEnabled && _initConfig.SynchronizationEnabled)
{
NetModule netModule = new NetModule(_configProvider, _logManager, _jsonSerializer, new NetBridge(_syncManager));
_rpcModuleProvider.Register <INetModule>(netModule);
}
TraceModule traceModule = new TraceModule(_configProvider, _logManager, _jsonSerializer, tracer);
_rpcModuleProvider.Register <ITraceModule>(traceModule);
_rpcModuleProvider.Register <INethmModule>(new NethmModule(_configProvider, _logManager, _jsonSerializer, _enode));
}