private void ConfirmEnoughEstimate(Transaction tx, Block block, long estimate)
{
CallOutputTracer outputTracer = new CallOutputTracer();
tx.GasLimit = estimate;
TestContext.WriteLine(tx.GasLimit);
GethLikeTxTracer gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
string traceEnoughGas = new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true);
_transactionProcessor.CallAndRestore(tx, block.Header, outputTracer);
traceEnoughGas.Should().NotContain("OutOfGas");
outputTracer = new CallOutputTracer();
tx.GasLimit = Math.Min(estimate - 1, estimate * 63 / 64);
TestContext.WriteLine(tx.GasLimit);
gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
string traceOutOfGas = new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true);
TestContext.WriteLine(traceOutOfGas);
_transactionProcessor.CallAndRestore(tx, block.Header, outputTracer);
bool failed = traceEnoughGas.Contains("failed") || traceEnoughGas.Contains("OutOfGas");
failed.Should().BeTrue();
}
public static string TestSerializedRequest <T>(IReadOnlyCollection <JsonConverter> converters, T module, string method, params string[] parameters) where T : class, IModule
{
IJsonRpcService service = BuildRpcService(module);
JsonRpcRequest request = GetJsonRequest(method, parameters);
JsonRpcResponse response = service.SendRequestAsync(request).Result;
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
foreach (JsonConverter converter in converters)
{
serializer.RegisterConverter(converter);
}
Stream stream = new MemoryStream();
serializer.Serialize(stream, response);
// for coverage (and to prove that it does not throw
Stream indentedStream = new MemoryStream();
serializer.Serialize(indentedStream, response, true);
stream.Seek(0, SeekOrigin.Begin);
string serialized = new StreamReader(stream).ReadToEnd();
TestContext.Out?.WriteLine("Serialized:");
TestContext.Out?.WriteLine(serialized);
return(serialized);
}
private IJsonSerializer CreateJsonSerializer(JsonRpcService jsonRpcService)
{
IJsonSerializer serializer = new EthereumJsonSerializer();
serializer.RegisterConverters(jsonRpcService.Converters);
return(serializer);
}
public void Same_storage_format_as_in_geth(string keyJson)
{
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
KeyStoreItem item = serializer.Deserialize <KeyStoreItem>(keyJson);
SecureString securePassword = new SecureString();
string password = "******";
for (int i = 0; i < password.Length; i++)
{
securePassword.AppendChar(password[i]);
}
Address address = new Address(item.Address);
_store.StoreKey(address, item);
try
{
string[] files = _store.FindKeyFiles(address);
Assert.AreEqual(1, files.Length);
string text = File.ReadAllText(files[0]);
Assert.AreEqual(keyJson, text, "same json");
}
finally
{
_store.DeleteKey(new Address(item.Address));
}
}
public void RunMigration(int?migratedBlockNumber)
{
int chainLength = 10;
IConfigProvider configProvider = Substitute.For <IConfigProvider>();
BlockTreeBuilder blockTreeBuilder = Core.Test.Builders.Build.A.BlockTree().OfChainLength(chainLength);
InMemoryReceiptStorage inMemoryReceiptStorage = new() { MigratedBlockNumber = migratedBlockNumber != null ? 0 : long.MaxValue };
InMemoryReceiptStorage outMemoryReceiptStorage = new() { MigratedBlockNumber = migratedBlockNumber != null ? 0 : long.MaxValue };
NethermindApi context = new()
{
ConfigProvider = configProvider,
EthereumJsonSerializer = new EthereumJsonSerializer(),
LogManager = LimboLogs.Instance,
ReceiptStorage = new TestReceiptStorage(inMemoryReceiptStorage, outMemoryReceiptStorage),
DbProvider = Substitute.For <IDbProvider>(),
BlockTree = blockTreeBuilder.TestObject,
Synchronizer = Substitute.For <ISynchronizer>(),
ChainLevelInfoRepository = blockTreeBuilder.ChainLevelInfoRepository,
SyncModeSelector = Substitute.For <ISyncModeSelector>()
};
configProvider.GetConfig <IInitConfig>().StoreReceipts.Returns(true);
configProvider.GetConfig <IInitConfig>().ReceiptsMigration.Returns(true);
context.SyncModeSelector.Current.Returns(SyncMode.WaitingForBlock);
int txIndex = 0;
for (int i = 1; i < chainLength; i++)
{
Block block = context.BlockTree.FindBlock(i);
inMemoryReceiptStorage.Insert(block, new[] {
Core.Test.Builders.Build.A.Receipt.WithTransactionHash(TestItem.Keccaks[txIndex++]).TestObject,
Core.Test.Builders.Build.A.Receipt.WithTransactionHash(TestItem.Keccaks[txIndex++]).TestObject
});
}
ManualResetEvent guard = new(false);
Keccak lastTransaction = TestItem.Keccaks[txIndex - 1];
context.DbProvider.ReceiptsDb.When(x => x.Remove(lastTransaction.Bytes)).Do(c => guard.Set());
ReceiptMigration migration = new(context);
if (migratedBlockNumber.HasValue)
{
migration.Run(migratedBlockNumber.Value);
}
else
{
migration.Run();
}
guard.WaitOne(TimeSpan.FromSeconds(1));
int txCount = ((migratedBlockNumber ?? chainLength) - 1 - 1) * 2;
context.DbProvider.ReceiptsDb.Received(Quantity.Exactly(txCount)).Remove(Arg.Any <byte[]>());
outMemoryReceiptStorage.Count.Should().Be(txCount);
}
private class TestReceiptStorage : IReceiptStorage
{
public void Can_unlock_test_accounts(string keyJson)
{
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
KeyStoreItem item = serializer.Deserialize <KeyStoreItem>(keyJson);
SecureString securePassword = new SecureString();
string password = "******";
for (int i = 0; i < password.Length; i++)
{
securePassword.AppendChar(password[i]);
}
securePassword.MakeReadOnly();
_store.StoreKey(new Address(item.Address), item);
try
{
(PrivateKey key, Result result) = _store.GetKey(new Address(item.Address), securePassword);
Assert.AreEqual(ResultType.Success, result.ResultType, item.Address + " " + result.Error);
Assert.AreEqual(key.Address.ToString(false, false), item.Address);
}
finally
{
_store.DeleteKey(new Address(item.Address));
}
}
public void Can_call_by_hash_canonical()
{
Block lastHead = _blockTree.Head;
Block block = Build.A.Block.WithParent(lastHead).TestObject;
Block newBlockOnMain = Build.A.Block.WithParent(lastHead).WithDifficulty(block.Difficulty + 1).TestObject;
BlockTreeBuilder.AddBlock(_blockTree, block);
BlockTreeBuilder.AddBlock(_blockTree, newBlockOnMain);
// would need to setup state root somehow...
TransactionForRpc tx = new TransactionForRpc
{
From = TestItem.AddressA,
To = TestItem.AddressB,
GasPrice = _useNonZeroGasPrice ? 10.GWei() : 0
};
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
string response = RpcTest.TestSerializedRequest(_proofModule, "proof_call", $"{serializer.Serialize(tx)}", $"{{\"blockHash\" : \"{block.Hash}\", \"requireCanonical\" : true}}");
Assert.True(response.Contains("-32000"));
response = RpcTest.TestSerializedRequest(_proofModule, "proof_call", $"{serializer.Serialize(tx)}", $"{{\"blockHash\" : \"{TestItem.KeccakG}\", \"requireCanonical\" : true}}");
Assert.True(response.Contains("-32001"));
}
private void LogDiagnosticTrace(IBlockTracer blockTracer)
{
GethLikeBlockTracer gethTracer = blockTracer as GethLikeBlockTracer;
ParityLikeBlockTracer parityTracer = blockTracer as ParityLikeBlockTracer;
if (gethTracer != null)
{
var serializer = new EthereumJsonSerializer();
var trace = gethTracer.BuildResult();
var serialized = serializer.Serialize(trace, true);
if (_logger.IsInfo)
{
_logger.Info(serialized);
}
}
if (parityTracer != null)
{
var serializer = new EthereumJsonSerializer();
var trace = parityTracer.BuildResult();
var serialized = serializer.Serialize(trace, true);
if (_logger.IsInfo)
{
_logger.Info(serialized);
}
}
}
private void LogDiagnosticTrace(IBlockTracer blockTracer, Block block)
{
FileStream GetDiagnosticFile() => new FileStream($"trace_{block}.txt", FileMode.Create, FileAccess.Write);
GethLikeBlockTracer gethTracer = blockTracer as GethLikeBlockTracer;
ParityLikeBlockTracer parityTracer = blockTracer as ParityLikeBlockTracer;
if (gethTracer != null)
{
using var diagnosticFile = GetDiagnosticFile();
var serializer = new EthereumJsonSerializer();
var trace = gethTracer.BuildResult();
serializer.Serialize(diagnosticFile, trace, true);
if (_logger.IsInfo)
{
_logger.Info($"Created trace of block {block} in file {diagnosticFile.Name}");
}
}
if (parityTracer != null)
{
using var diagnosticFile = GetDiagnosticFile();
var serializer = new EthereumJsonSerializer();
var trace = parityTracer.BuildResult();
serializer.Serialize(diagnosticFile, trace, true);
if (_logger.IsInfo)
{
_logger.Info($"Created trace of block {block} in file {diagnosticFile.Name}");
}
}
}
public void Can_call_by_hash()
{
StateProvider stateProvider = CreateInitialState(null);
Keccak root = stateProvider.StateRoot;
Block block = Build.A.Block.WithParent(_blockTree.Head).WithStateRoot(root).TestObject;
BlockTreeBuilder.AddBlock(_blockTree, block);
// would need to setup state root somehow...
TransactionForRpc tx = new TransactionForRpc
{
From = TestItem.AddressA,
To = TestItem.AddressB,
GasPrice = _useNonZeroGasPrice ? 10.GWei() : 0
};
_proofModule.proof_call(tx, new BlockParameter(block.Hash));
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
string response = RpcTest.TestSerializedRequest(_proofModule, "proof_call", $"{serializer.Serialize(tx)}", $"{block.Hash}");
Assert.True(response.Contains("\"result\""));
}
public Task Run(string[] args)
{
(CommandLineApplication app, var buildConfigProvider, var getDbBasePath) = BuildCommandLineApp();
ManualResetEventSlim appClosed = new ManualResetEventSlim(true);
app.OnExecute(async() =>
{
appClosed.Reset();
IConfigProvider configProvider = buildConfigProvider();
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
_logger = new NLogLogger(initConfig.LogFileName, initConfig.LogDirectory);
if (_logger.IsDebug)
{
_logger.Debug($"Nethermind version: {ClientVersion.Description}");
}
LogMemoryConfiguration();
string?pathDbPath = getDbBasePath();
if (!string.IsNullOrWhiteSpace(pathDbPath))
{
string newDbPath = Path.Combine(pathDbPath, initConfig.BaseDbPath);
if (_logger.IsDebug)
{
_logger.Debug(
$"Adding prefix to baseDbPath, new value: {newDbPath}, old value: {initConfig.BaseDbPath}");
}
initConfig.BaseDbPath =
newDbPath ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory ?? "", "db");
}
Console.Title = initConfig.LogFileName;
Console.CancelKeyPress += ConsoleOnCancelKeyPress;
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
if (_logger.IsDebug)
{
_logger.Debug($"Nethermind config:\n{serializer.Serialize(initConfig, true)}\n");
}
_processExit = new TaskCompletionSource <object?>();
_cancelKeySource = new TaskCompletionSource <object?>();
await StartRunners(_processCloseCancellationSource.Token, configProvider);
await Task.WhenAny(_cancelKeySource.Task, _processExit.Task);
Console.WriteLine("Closing, please wait until all functions are stopped properly...");
StopAsync().Wait();
Console.WriteLine("All done, goodbye!");
appClosed.Set();
return(0);
});
app.Execute(args);
appClosed.Wait();
return(Task.CompletedTask);
}
public Scenario(string jsonRpcUrl)
{
var logsManager = LimboLogs.Instance;
var serializer = new EthereumJsonSerializer();
_client = new JsonRpcClientProxy(new DefaultHttpClient(new HttpClient(), serializer, logsManager, 0),
new[] { jsonRpcUrl }, logsManager);
}
public void Can_Run_Smoke_test()
{
var code = Bytes.FromHexString("0x600060000100");
var txTracer = RunVirtualMachine(code);
var serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
}
private static IJsonSerializer BuildSerializer()
{
IJsonSerializer serializer = new EthereumJsonSerializer();
serializer.RegisterConverters(EthModuleFactory.Converters);
serializer.RegisterConverters(TraceModuleFactory.Converters);
serializer.RegisterConverter(new BlockParameterConverter());
return(serializer);
}
public void CanHandleOptionalArguments()
{
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
string serialized = serializer.Serialize(new TransactionForRpc());
IEthRpcModule ethRpcModule = Substitute.For<IEthRpcModule>();
ethRpcModule.eth_call(Arg.Any<TransactionForRpc>()).ReturnsForAnyArgs(x => ResultWrapper<string>.Success("0x1"));
JsonRpcSuccessResponse response = TestRequest(ethRpcModule, "eth_call", serialized) as JsonRpcSuccessResponse;
Assert.AreEqual("0x1", response?.Result);
}
public void Can_Run_Smoke_test()
{
var code = Bytes.FromHexString("0x600060000100");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
}
private IJsonSerializer GetSerializer(IEnumerable <JsonConverter> additionalConverters)
{
IJsonSerializer jsonSerializer = new EthereumJsonSerializer();
if (additionalConverters != null)
{
jsonSerializer.RegisterConverters(additionalConverters);
}
return(jsonSerializer);
}
public void CanHandleOptionalArguments()
{
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
string serialized = serializer.Serialize(new TransactionForRpc());
IEthModule ethModule = Substitute.For <IEthModule>();
ethModule.eth_call(Arg.Any <TransactionForRpc>()).ReturnsForAnyArgs(x => ResultWrapper <byte[]> .Success(new byte[] { 1 }));
JsonRpcResponse response = TestRequest <IEthModule>(ethModule, "eth_call", serialized);
Assert.AreEqual(1, (response.Result as byte[]).Length);
}
public void Can_Invoke_Gas_Limit()
{
var code = Bytes.FromHexString("0x4500");
var txTracer = RunVirtualMachine(code);
var serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be("f4240".PadLeft(64, '0'));
}
public void Can_Invoke_Range_Proof_Precompile()
{
var code = Bytes.FromHexString("0x60008080806201000062050000F400");
var txTracer = RunVirtualMachine(code);
var serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be(VirtualMachine.BytesOne32.ToHexString());
}
public void Can_Invoke_Address()
{
var code = Bytes.FromHexString("0x3000");
var txTracer = RunVirtualMachine(code);
var serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be(VirtualMachine.BytesZero32.ToHexString());
}
public void Can_Invoke_Origin()
{
var code = Bytes.FromHexString("0x3200");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be(VirtualMachine.BytesZero32.ToHexString());
}
public void Blake_precompile()
{
Address blakeAddress = Address.FromNumber(1 + KatVirtualMachine.CatalystPrecompilesAddressingSpace);
string addressCode = blakeAddress.Bytes.ToHexString(false);
var code = Bytes.FromHexString("0x602060006080600073" + addressCode + "45fa00");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Entries.Last().Stack.First().Should().Be("0000000000000000000000000000000000000000000000000000000000000001");
trace.Entries.Last().Memory.First().Should().Be("378d0caaaa3855f1b38693c1d6ef004fd118691c95c959d4efa950d6d6fcf7c1");
}
private void TestToJson <T>(T item, JsonConverter <T> converter, string expectedResult)
{
EthereumJsonSerializer serializer = BuildSerializer();
if (converter != null)
{
serializer.RegisterConverter(converter);
}
string result = serializer.Serialize(item);
Assert.AreEqual(expectedResult, result, result.Replace("\"", "\\\""));
}
public void Setup()
{
_serializer = new EthereumJsonSerializer();
_jsonRpcClient = Substitute.For <IJsonRpcClient>();
_engine = new CliEngine(_cliConsole);
NodeManager nodeManager = new NodeManager(_engine, _serializer, _cliConsole, LimboLogs.Instance);
nodeManager.SwitchClient(_jsonRpcClient);
ICliConsole cliConsole = Substitute.For <ICliConsole>();
CliModuleLoader moduleLoader = new CliModuleLoader(_engine, nodeManager, cliConsole);
moduleLoader.LoadModule(typeof(ProofCliModule));
}
public void Run(string[] args)
{
var(app, buildConfigProvider, getDbBasePath) = BuildCommandLineApp();
ManualResetEventSlim appClosed = new ManualResetEventSlim(true);
app.OnExecute(async() =>
{
appClosed.Reset();
var configProvider = buildConfigProvider();
var initConfig = configProvider.GetConfig <IInitConfig>();
LogManager.Configuration = new XmlLoggingConfiguration("NLog.config".GetApplicationResourcePath());
_logger = new NLogLogger(initConfig.LogFileName, initConfig.LogDirectory);
LogMemoryConfiguration();
var pathDbPath = getDbBasePath();
if (!string.IsNullOrWhiteSpace(pathDbPath))
{
var newDbPath = Path.Combine(pathDbPath, initConfig.BaseDbPath);
if (_logger.IsDebug)
{
_logger.Debug($"Adding prefix to baseDbPath, new value: {newDbPath}, old value: {initConfig.BaseDbPath}");
}
initConfig.BaseDbPath = newDbPath ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "db");
}
Console.Title = initConfig.LogFileName;
Console.CancelKeyPress += ConsoleOnCancelKeyPress;
var serializer = new EthereumJsonSerializer();
if (_logger.IsInfo)
{
_logger.Info($"Nethermind config:\n{serializer.Serialize(initConfig, true)}\n");
}
_cancelKeySource = new TaskCompletionSource <object>();
await StartRunners(configProvider);
await _cancelKeySource.Task;
Console.WriteLine("Closing, please wait until all functions are stopped properly...");
StopAsync().Wait();
Console.WriteLine("All done, goodbye!");
appClosed.Set();
return(0);
});
app.Execute(args);
appClosed.Wait();
}
protected void TestRoundtrip <T>(string json, JsonConverter converter = null)
{
EthereumJsonSerializer serializer = BuildSerializer();
if (converter != null)
{
serializer.RegisterConverter(converter);
}
T deserialized = serializer.Deserialize <T>(json);
string result = serializer.Serialize(deserialized);
Assert.AreEqual(json, result);
}
public void Setup()
{
_blockTree = Build.A.BlockTree().OfChainLength(5).TestObject;
_networkConfig = new NetworkConfig();
IPeerManager peerManager = Substitute.For <IPeerManager>();
peerManager.ActivePeers.Returns(new List <Peer> {
new Peer(new Node("127.0.0.1", 30303, true))
});
IStaticNodesManager staticNodesManager = Substitute.For <IStaticNodesManager>();
Enode enode = new Enode(_enodeString);
_adminRpcModule = new AdminRpcModule(_blockTree, _networkConfig, peerManager, staticNodesManager, enode, _exampleDataDir);
_serializer = new EthereumJsonSerializer();
}
public PeersApp() : base("Peers")
{
string[] urls = { DefaultUrl };
var logger = LimboLogs.Instance;
var serializer = new EthereumJsonSerializer();
var httpClient = new HttpClient();
var defaultHttpClient = new DefaultHttpClient(httpClient, serializer, logger, int.MaxValue);
var proxy = new JsonRpcClientProxy(defaultHttpClient, urls, logger);
_adminRpc = new AdminJsonRpcClientProxy(proxy);
MenuBar menu = new MenuBar(new MenuBarItem[]
{
new MenuBarItem("_File", new MenuItem[]
{
new MenuItem("_Quit", "", () => { Application.RequestStop(); })
}),
});
ListView view = new ListView()
{
X = 0,
Y = 1,
Width = Dim.Fill(),
Height = Dim.Fill() - 1,
};
view.AllowsAll();
Add(menu, view);
bool UpdateTimer(MainLoop mainLoop)
{
_adminRpc.admin_peers(true).ContinueWith(
t => Application.MainLoop.Invoke(() =>
{
Title = $"Last Peers Update {DateTime.Now}";
view.SetSourceAsync(t.Result.Result.Select(ToPeerInfoRow).OrderByDescending(r => r.Reputation).ToArray());
})
);
return(true);
}
var token = Application.MainLoop.AddTimeout(TimeSpan.FromSeconds(10), UpdateTimer);
}
public void Init(string path)
{
var dbOnTheRocks = new BlocksRocksDb(path, new DbConfig(), LimboLogs.Instance);
var blocksBytes = dbOnTheRocks.GetAll();
var blockDecoder = new BlockDecoder();
var blocks = blocksBytes
.Select(b => blockDecoder.Decode(b.Value.AsRlpStream()))
.OrderBy(b => b.Number)
.ToList();
var window = new Window("Blocks")
{
X = 0, Y = 10, Width = Dim.Fill(), Height = Dim.Fill()
};
if (!blocks.Any())
{
MessageBox.Query(40, 7, "Info", "No data.");
window.FocusPrev();
return;
}
var y = 1;
foreach (var block in blocks)
{
var blockBtn = new Button(1, y++, $"Number: {block.Number}, Hash: {block.Hash}");
blockBtn.Clicked = () =>
{
var blockDetailsWindow = new Window("Block details")
{
X = 0, Y = 10, Width = Dim.Fill(), Height = Dim.Fill()
};
Application.Top.Add(blockDetailsWindow);
var serializer = new EthereumJsonSerializer();
var blockLbl = new Label(1, 1, serializer.Serialize(block, true));
blockDetailsWindow.Add(blockLbl);
Application.Run(blockDetailsWindow);
};
window.Add(blockBtn);
}
Application.Top.Add(window);
Application.Run(window);
}
