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);
}
