private static TransactionContext GetTransactionContext(IChainContext chainContext, Address to, ByteString param, out TransactionTrace trace) { var generatedTxn = new Transaction { From = FromAddress, To = to, MethodName = nameof(ACS2BaseContainer.ACS2BaseStub.GetResourceInfo), Params = param, Signature = ByteString.CopyFromUtf8(KernelConstants.SignaturePlaceholder) }; trace = new TransactionTrace { TransactionId = generatedTxn.GetHash() }; return(new TransactionContext { PreviousBlockHash = chainContext.BlockHash, CurrentBlockTime = TimestampHelper.GetUtcNow(), Transaction = generatedTxn, BlockHeight = chainContext.BlockHeight + 1, Trace = trace, CallDepth = 0, StateCache = chainContext.StateCache }); }
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result) { var returnSet = new ExecutionReturnSet { TransactionId = result.TransactionId, Status = result.Status, Bloom = result.Bloom }; if (trace.IsSuccessful()) { foreach (var s in trace.GetFlattenedWrites()) { returnSet.StateChanges[s.Key] = s.Value; } returnSet.ReturnValue = trace.ReturnValue; } foreach (var s in trace.GetFlattenedReads()) { returnSet.StateAccesses[s.Key] = s.Value; } return(returnSet); }
public async Task <TransactionTrace> ExecuteAsync(IChainContext chainContext, Transaction transaction, Timestamp currentBlockTime) { var trace = new TransactionTrace() { TransactionId = transaction.GetHash() }; var transactionContext = new TransactionContext { PreviousBlockHash = chainContext.BlockHash, CurrentBlockTime = currentBlockTime, Transaction = transaction, BlockHeight = chainContext.BlockHeight + 1, Trace = trace, CallDepth = 0, StateCache = chainContext.StateCache }; var executive = await _smartContractExecutiveService.GetExecutiveAsync( chainContext, transaction.To); try { await executive.ApplyAsync(transactionContext); } finally { await _smartContractExecutiveService.PutExecutiveAsync(chainContext, transaction.To, executive); } return(trace); }
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result) { var returnSet = new ExecutionReturnSet() { TransactionId = result.TransactionId, Status = result.Status, Bloom = result.Bloom }; foreach (var tx in result.DeferredTransactions) { returnSet.DeferredTransactions.Add(tx); } if (trace.IsSuccessful()) { foreach (var s in trace.GetFlattenedWrite()) { returnSet.StateChanges[s.Key] = s.Value; } returnSet.ReturnValue = trace.ReturnValue; } return(returnSet); }
public static bool IsSuccessful(this TransactionTrace txTrace) { var successful = txTrace.ExecutionStatus == ExecutionStatus.Executed; if (!successful) { return(false); } foreach (var trace in txTrace.PreTraces) { if (!trace.IsSuccessful()) { return(false); } } foreach (var trace in txTrace.InlineTraces) { if (!trace.IsSuccessful()) { return(false); } } foreach (var trace in txTrace.PostTraces) { if (!trace.IsSuccessful()) { return(false); } } return(true); }
private TransactionContext CreateTransactionContext(SingleTransactionExecutingDto singleTxExecutingDto, out TransactionTrace trace) { if (singleTxExecutingDto.Transaction.To == null || singleTxExecutingDto.Transaction.From == null) { throw new Exception($"error tx: {singleTxExecutingDto.Transaction}"); } trace = new TransactionTrace { TransactionId = singleTxExecutingDto.Transaction.GetHash() }; var txContext = new TransactionContext { PreviousBlockHash = singleTxExecutingDto.ChainContext.BlockHash, CurrentBlockTime = singleTxExecutingDto.CurrentBlockTime, Transaction = singleTxExecutingDto.Transaction, BlockHeight = singleTxExecutingDto.ChainContext.BlockHeight + 1, Trace = trace, CallDepth = singleTxExecutingDto.Depth, StateCache = singleTxExecutingDto.ChainContext.StateCache, Origin = singleTxExecutingDto.Origin != null ? singleTxExecutingDto.Origin : singleTxExecutingDto.Transaction.From }; return(txContext); }
public static async Task <TransactionResourceInfo> GetTransactionResourceInfoAsync(this IExecutive executive, IChainContext chainContext, Transaction input) { var generatedTxn = new Transaction { From = FromAddress, To = input.To, MethodName = nameof(ACS2BaseContainer.ACS2BaseStub.GetResourceInfo), Params = input.ToByteString(), Signature = ByteString.CopyFromUtf8("SignaturePlaceholder") }; var txId = input.GetHash(); var trace = new TransactionTrace { TransactionId = generatedTxn.GetHash() }; var transactionContext = new TransactionContext { PreviousBlockHash = chainContext.BlockHash, CurrentBlockTime = TimestampHelper.GetUtcNow(), Transaction = generatedTxn, BlockHeight = chainContext.BlockHeight + 1, Trace = trace, CallDepth = 0, StateCache = chainContext.StateCache }; await executive.ApplyAsync(transactionContext); if (!trace.IsSuccessful()) { return(NotParallelizable(txId, executive.ContractHash)); } try { var resourceInfo = ResourceInfo.Parser.ParseFrom(trace.ReturnValue); return(new TransactionResourceInfo { TransactionId = txId, Paths = { resourceInfo.Paths }, ParallelType = resourceInfo.NonParallelizable ? ParallelType.NonParallelizable : ParallelType.Parallelizable, ContractHash = executive.ContractHash }); } catch (Exception) { return(NotParallelizable(txId, executive.ContractHash)); } }
public TransactionContext() { Origin = new Hash(); Miner = new Hash(); PreviousBlockHash = new Hash(); Transaction = new Transaction(); Trace = new TransactionTrace(); BlockHeight = 0; CallDepth = 0; }
public async Task Fibonacci16() { _transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext { BlockHash = _chain.BestChainHash, BlockHeight = _chain.BestChainHeight }, _transaction, DateTime.UtcNow); }
public async Task LoopDivAdd10M() { _transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext { BlockHash = _chain.BestChainHash, BlockHeight = _chain.BestChainHeight }, _transaction, TimestampHelper.GetUtcNow()); }
public static async Task Main(params string[] args) { // int blockNumber = 6108276; // string hash = "?"; int blockNumber = 316658; string hash = "0x846806c1e1fc530399ad80cec3121b9d90fe24e4665484b995237f7f95e2caa8"; // Console.WriteLine("Block Number:"); // int blockNumber = int.Parse(Console.ReadLine()); string nethPathBase = $"D:\\block_traces\\{blockNumber}\\neth\\"; if (!Directory.Exists(nethPathBase)) { Directory.CreateDirectory(nethPathBase); } string gethPathBase = $"D:\\block_traces\\{blockNumber}\\geth\\"; if (!Directory.Exists(gethPathBase)) { Directory.CreateDirectory(gethPathBase); } BasicJsonRpcClient localhostClient = new BasicJsonRpcClient(KnownRpcUris.Localhost, _serializer, NullLogManager.Instance); // await TraceBlock(localhostClient, blockNumber, nethPathBase); await TraceBlockByHash(localhostClient, hash, nethPathBase); BasicJsonRpcClient gethClient = new BasicJsonRpcClient(KnownRpcUris.Localhost, _serializer, NullLogManager.Instance); // await TraceBlock(gethClient, blockNumber, gethPathBase); await TraceBlockByHash(gethClient, hash, gethPathBase); string nethTx = File.ReadAllText(Path.Combine(nethPathBase, "0.txt")); string gethTx = File.ReadAllText(Path.Combine(gethPathBase, "0.txt")); TransactionTrace gethTrace = _serializer.Deserialize <TransactionTrace>(gethTx); TransactionTrace nethTrace = _serializer.Deserialize <TransactionTrace>(nethTx); _comparer.Compare(gethTrace, nethTrace); // try // { // for (int i = 41; i < 42; i++) await TraceTxByBlockhashAndIndex(KnownRpcUris.Localhost, pathBase, blockNumber, i); // } // catch (Exception e) // { // Console.WriteLine(e); // throw; // } Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void GetPluginLogs_Test() { var logEvents = new List <LogEvent>(); for (int i = 0; i < 5; i++) { logEvents.Add(new LogEvent { Name = "LogEvent" + i }); } var transactionTrace = new TransactionTrace { PreTraces = { new TransactionTrace { ExecutionStatus = ExecutionStatus.Executed, Logs = { logEvents[0] } }, new TransactionTrace { ExecutionStatus = ExecutionStatus.Canceled, Logs = { logEvents[1] } } }, InlineTraces = { new TransactionTrace { ExecutionStatus = ExecutionStatus.Executed, Logs = { logEvents[2] } } }, PostTraces = { new TransactionTrace { ExecutionStatus = ExecutionStatus.Executed, Logs = { logEvents[3] } }, new TransactionTrace { ExecutionStatus = ExecutionStatus.Canceled, Logs = { logEvents[4] } } } }; var logs = transactionTrace.GetPluginLogs().ToList(); logs.Count.ShouldBe(2); logs.ShouldContain(logEvents[0]); logs.ShouldContain(logEvents[3]); }
private async Task <TransactionTrace> ExecuteOneAsync(int depth, Transaction transaction, Hash chainId, IChainContext chainContext, Dictionary <DataPath, StateCache> stateCache, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(new TransactionTrace() { TransactionId = transaction.GetHash(), StdErr = "Execution Canceled", ExecutionStatus = ExecutionStatus.Canceled }); } var trace = new TransactionTrace() { TransactionId = transaction.GetHash() }; var txCtxt = new TransactionContext() { PreviousBlockHash = chainContext.BlockHash, Transaction = transaction, BlockHeight = chainContext.BlockHeight, Trace = trace, CallDepth = depth }; var executive = await _smartContractService.GetExecutiveAsync(transaction.To, chainId); try { executive.SetDataCache(stateCache); await executive.SetTransactionContext(txCtxt).Apply(); foreach (var inlineTx in txCtxt.Trace.InlineTransactions) { var inlineTrace = await ExecuteOneAsync(depth + 1, inlineTx, chainId, chainContext, stateCache, cancellationToken); trace.InlineTraces.Add(inlineTrace); } } catch (Exception ex) { txCtxt.Trace.ExecutionStatus = ExecutionStatus.ContractError; txCtxt.Trace.StdErr += ex + "\n"; } finally { await _smartContractService.PutExecutiveAsync(transaction.To, executive); } return(trace); }
private byte[] CreateFakeReturnValue(TransactionTrace trace, Transaction transaction, string methodName) { if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetParentChainId)) { var parentChainId = _parentChainIdHeight.Keys.FirstOrDefault(); if (parentChainId != 0) { return new SInt32Value { Value = parentChainId } }
public TransactionContext() { Origin = new Address(); Miner = new Address(); PreviousBlockHash = new Hash(); Transaction = new Transaction(); Trace = new TransactionTrace(); BlockHeight = 0; CallDepth = 0; MaxCallDepth = 4; // Default max call depth 4 }
public static void SurfaceUpError(this TransactionTrace txTrace) { foreach (var inline in txTrace.InlineTraces) { inline.SurfaceUpError(); if (inline.ExecutionStatus < txTrace.ExecutionStatus) { txTrace.ExecutionStatus = inline.ExecutionStatus; txTrace.StdErr = $"InlineError: {inline.StdErr}"; } } }
public TransactionContext() { Origin = new Address(); Miner = new Address(); PreviousBlockHash = new Hash(); Transaction = new Transaction(); Trace = new TransactionTrace(); BlockHeight = 0; CallDepth = 0; MaxCallDepth = 4; // Default max call depth 4 ExecutionCallThreshold = SmartContractConstants.ExecutionCallThreshold; ExecutionBranchThreshold = SmartContractConstants.ExecutionBranchThreshold; }
public async Task <List <TransactionTrace> > ExecuteAsync(List <Transaction> transactions, Hash chainId, CancellationToken token, Hash disambiguationHash = null) { token.Register(() => _actorEnvironment.Requestor.Tell(JobExecutionCancelMessage.Instance)); List <List <Transaction> > groups; Dictionary <Transaction, Exception> failedTxs; var dposTxs = transactions.Where(tx => tx.Type == TransactionType.DposTransaction).ToList(); var normalTxs = transactions.Where(tx => tx.Type != TransactionType.DposTransaction).ToList(); //disable parallel module by default because it doesn't finish yet (don't support contract call) if (ParallelConfig.Instance.IsParallelEnable) { var groupRes = await _grouper.ProcessWithCoreCount(GroupStrategy.Limited_MaxAddMins, ActorConfig.Instance.ConcurrencyLevel, chainId, normalTxs); groups = groupRes.Item1; failedTxs = groupRes.Item2; } else { groups = new List <List <Transaction> > { normalTxs }; failedTxs = new Dictionary <Transaction, Exception>(); } var dposResult = _singlExecutingService.ExecuteAsync(dposTxs, chainId, token); var tasks = groups.Select( txs => Task.Run(() => AttemptToSendExecutionRequest(chainId, txs, token, disambiguationHash), token) ).ToArray(); var results = dposResult.Result; results.AddRange((await Task.WhenAll(tasks)).SelectMany(x => x).ToList()); foreach (var failed in failedTxs) { var failedTrace = new TransactionTrace { StdErr = "Transaction with ID/hash " + failed.Key.GetHash().DumpHex() + " failed, detail message: \n" + failed.Value.Dump(), TransactionId = failed.Key.GetHash() }; results.Add(failedTrace); Console.WriteLine(failedTrace.StdErr); } return(results); }
private TransactionTrace GetTransactionTrace(int logEventCount = 0, int readsCount = 0, int writesCount = 0, int deletesCount = 0) { var transactionTrace = new TransactionTrace { StateSet = new TransactionExecutingStateSet() }; var writeByteString = transactionTrace.ToByteString(); transactionTrace.Logs.AddRange(Enumerable.Range(0, logEventCount).Select(x => new LogEvent()).ToArray()); transactionTrace.StateSet.Reads.Add(Enumerable.Range(0, readsCount).ToDictionary(key => key.ToString(), value => true)); transactionTrace.StateSet.Writes.Add(Enumerable.Range(0, writesCount).ToDictionary(key => key.ToString(), value => writeByteString)); transactionTrace.StateSet.Deletes.Add(Enumerable.Range(0, deletesCount).ToDictionary(key => key.ToString(), value => true)); return(transactionTrace); }
public void Compare(TransactionTrace gethTrace, TransactionTrace nethTrace) { if (gethTrace.Gas != nethTrace.Gas) { _logger.Warn($" gas geth {gethTrace.Gas} != neth {nethTrace.Gas} (diff: {gethTrace.Gas - nethTrace.Gas})"); } string gethReturnValue = gethTrace.ReturnValue; string nethReturnValue = nethTrace.ReturnValue; if (gethReturnValue != nethReturnValue) { _logger.Warn($" return value geth {gethReturnValue} != neth {nethReturnValue}"); } if (gethTrace.Failed != nethTrace.Failed) { _logger.Warn($" failed diff geth {gethTrace.Failed} != neth {nethTrace.Failed}"); } var gethEntries = gethTrace.StructLogs.ToList(); var nethEntries = nethTrace.StructLogs.ToList(); int ixDiff = 0; for (int i = 0; i < gethEntries.Count; i++) { // _logger.Info($" comparing evm entry {i}"); var gethEntry = gethEntries[i]; if (gethEntry.Error != null) { ixDiff++; continue; } int nethIx = i - ixDiff; string entryDesc = $"ix {i}/{nethIx} pc {gethEntries[i].Pc} op {gethEntries[i].Op} gas {gethEntries[i].Gas} | "; if (nethEntries.Count < nethIx + 1) { _logger.Warn($" neth entry missing"); } var nethEntry = nethEntries[nethIx]; if (!CompareEntry(gethEntry, nethEntry, entryDesc)) { break; } } }
private TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight) { if (trace.ExecutionStatus == ExecutionStatus.Undefined) { return(null); } if (trace.ExecutionStatus == ExecutionStatus.Prefailed) { return(new TransactionResult() { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Unexecutable, Error = trace.StdErr }); } if (trace.IsSuccessful()) { var txRes = new TransactionResult() { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Mined, ReturnValue = trace.ReturnValue, ReadableReturnValue = trace.ReadableReturnValue, BlockNumber = blockHeight, //StateHash = trace.GetSummarizedStateHash(), Logs = { trace.FlattenedLogs } }; txRes.UpdateBloom(); // insert deferred txn to transaction pool and wait for execution if (trace.DeferredTransaction.Length != 0) { var deferredTxn = Transaction.Parser.ParseFrom(trace.DeferredTransaction); txRes.DeferredTransactions.Add(deferredTxn); txRes.DeferredTxnId = deferredTxn.GetHash(); } return(txRes); } return(new TransactionResult() { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Failed, Error = trace.StdErr }); }
public TransactionTrace CreateFakeTransactionTrace(Transaction transaction) { string methodName = transaction.MethodName; var trace = new TransactionTrace { TransactionId = transaction.GetHash(), ExecutionStatus = ExecutionStatus.Executed, }; var returnValue = CreateFakeReturnValue(trace, transaction, methodName); trace.ReturnValue = returnValue == null ? ByteString.Empty : ByteString.CopyFrom(returnValue); return(trace); }
private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result) { var returnSet = new ExecutionReturnSet { TransactionId = result.TransactionId, Status = result.Status, Bloom = result.Bloom, TransactionResult = result }; if (trace.IsSuccessful()) { var transactionExecutingStateSets = trace.GetStateSets(); returnSet = GetReturnSet(returnSet, transactionExecutingStateSets); returnSet.ReturnValue = trace.ReturnValue; } else { var transactionExecutingStateSets = new List <TransactionExecutingStateSet>(); foreach (var preTrace in trace.PreTraces) { if (preTrace.IsSuccessful()) { transactionExecutingStateSets.AddRange(preTrace.GetStateSets()); } } foreach (var postTrace in trace.PostTraces) { if (postTrace.IsSuccessful()) { transactionExecutingStateSets.AddRange(postTrace.GetStateSets()); } } returnSet = GetReturnSet(returnSet, transactionExecutingStateSets); } var reads = trace.GetFlattenedReads(); foreach (var read in reads) { returnSet.StateAccesses[read.Key] = read.Value; } return(returnSet); }
private TransactionResult GetTransactionResult(TransactionTrace trace, long blockHeight) { if (trace.ExecutionStatus == ExecutionStatus.Undefined) { return(new TransactionResult { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Unexecutable, Error = ExecutionStatus.Undefined.ToString() }); } if (trace.ExecutionStatus == ExecutionStatus.Prefailed) { return(new TransactionResult { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Unexecutable, Error = trace.Error }); } if (trace.IsSuccessful()) { var txRes = new TransactionResult { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Mined, ReturnValue = trace.ReturnValue, ReadableReturnValue = trace.ReadableReturnValue, BlockNumber = blockHeight, //StateHash = trace.GetSummarizedStateHash(), Logs = { trace.FlattenedLogs } }; txRes.UpdateBloom(); return(txRes); } return(new TransactionResult { TransactionId = trace.TransactionId, Status = TransactionResultStatus.Failed, Error = trace.Error }); }
protected override async Task <TransactionTrace> ExecuteOneAsync(SingleTransactionExecutingDto singleTxExecutingDto, CancellationToken cancellationToken) { TransactionTrace trace = null; try { trace = await base.ExecuteOneAsync(singleTxExecutingDto, cancellationToken); } finally { await LocalEventBus.PublishAsync(new TransactionExecutedEventData { TransactionTrace = trace }); } return(trace); }
private async Task <SmartContractRegistration> GetSmartContractRegistrationFromZeroAsync( IExecutive executiveZero, IChainContext chainContext, Hash codeHash) { var transaction = new Transaction() { From = FromAddress, To = _defaultContractZeroCodeProvider.ContractZeroAddress, MethodName = "GetSmartContractRegistration", Params = codeHash.ToByteString() }; var trace = new TransactionTrace { TransactionId = transaction.GetHash() }; var txCtxt = new TransactionContext { PreviousBlockHash = chainContext.BlockHash, CurrentBlockTime = TimestampHelper.GetUtcNow(), Transaction = transaction, BlockHeight = chainContext.BlockHeight + 1, Trace = trace, CallDepth = 0, StateCache = chainContext.StateCache }; await executiveZero.ApplyAsync(txCtxt); var returnBytes = txCtxt.Trace?.ReturnValue; if (returnBytes != null && returnBytes != ByteString.Empty) { return(SmartContractRegistration.Parser.ParseFrom(returnBytes)); } if (!txCtxt.Trace.IsSuccessful()) { throw new SmartContractFindRegistrationException( $"failed to find registration from zero contract {txCtxt.Trace.Error}"); } return(null); }
public RunTime(TransactionTrace trace, BlockCapsule block, Deposit deposit, IProgramInvokeFactory invoke_factory) { this.trace = trace; this.transaction = trace.Transaction.Instance; if (block != null) { this.block = block; this.executor_type = ExecutorType.ET_NORMAL_TYPE; } else { this.block = new BlockCapsule(new Block()); this.executor_type = ExecutorType.ET_PRE_TYPE; } this.deposit = deposit; this.invoke_factory = invoke_factory; this.energy_processor = new EnergyProcessor(deposit.DBManager); ContractType contract_type = this.transaction.RawData.Contract[0].Type; switch (contract_type) { case ContractType.TriggerSmartContract: { this.transaction_type = TransactionType.TX_CONTRACT_CALL_TYPE; } break; case ContractType.CreateSmartContract: { this.transaction_type = TransactionType.TX_CONTRACT_CREATION_TYPE; } break; default: { this.transaction_type = TransactionType.TX_PRECOMPILED_TYPE; } break; } }
public static async Task CommitChangesAsync(this TransactionTrace trace, IStateStore stateStore) { if (trace.ExecutionStatus != ExecutionStatus.ExecutedButNotCommitted) { throw new InvalidOperationException( $"Attempting to commit a trace with a wrong status {trace.ExecutionStatus}."); } if (trace.StateChanges.Count > 0) { await stateStore.PipelineSetDataAsync(trace.StateChanges.ToDictionary(x => x.StatePath, x => x.StateValue.CurrentValue.ToByteArray())); } trace.StateHash = Hash.FromRawBytes(ByteArrayHelpers.Combine(trace.StateChanges.Select(x => x.StatePath.GetHash()).OrderBy(x => x).Select(x => x.Value.ToByteArray()).ToArray())); trace.ExecutionStatus = ExecutionStatus.ExecutedAndCommitted; foreach (var trc in trace.InlineTraces) { await trc.CommitChangesAsync(stateStore); } }
public static async Task Main(params string[] args) { HttpClient client = new HttpClient(); string[] transactionHashes = Directory.GetFiles(@"D:\tx_traces\nethermind").Select(Path.GetFileNameWithoutExtension).ToArray(); for (int i = 0; i < transactionHashes.Length; i++) { try { string gethPath = "D:\\tx_traces\\geth_" + transactionHashes[i] + ".txt"; string nethPath = "D:\\tx_traces\\nethermind\\" + transactionHashes[i] + ".txt"; Console.WriteLine($"Downloading {i} of {transactionHashes.Length}"); HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Post, "http://10.0.1.6:8545"); msg.Content = new StringContent($"{{\"jsonrpc\":\"2.0\",\"method\":\"debug_traceTransaction\",\"params\":[\"{transactionHashes[i]}\"],\"id\":42}}"); msg.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); HttpResponseMessage rsp = await client.SendAsync(msg); string text = await rsp.Content.ReadAsStringAsync(); File.WriteAllText(gethPath, text); IJsonSerializer serializer = new UnforgivingJsonSerializer(); WrappedTransactionTrace gethTrace = serializer.Deserialize <WrappedTransactionTrace>(text); string nethText = File.ReadAllText(nethPath); TransactionTrace nethTrace = serializer.Deserialize <TransactionTrace>(nethText); if (gethTrace.Result.Gas != nethTrace.Gas) { Console.WriteLine($"Gas difference in {transactionHashes[i]} - neth {nethTrace.Gas} vs geth {gethTrace.Result.Gas}"); } } catch (Exception e) { Console.WriteLine($"Failed at {i} with {e}"); } } Console.WriteLine("Complete"); Console.ReadLine(); }
public TransactionTrace CreateFakeTransactionTrace(Transaction transaction) { string methodName = transaction.MethodName; var trace = new TransactionTrace { TransactionId = transaction.GetHash(), ExecutionStatus = ExecutionStatus.Executed, }; var returnValue = CreateFakeReturnValue(trace, transaction, methodName); if (returnValue == null) { trace.ExecutionStatus = ExecutionStatus.ContractError; } else { trace.ReturnValue = ByteString.CopyFrom(returnValue); } return(trace); }