public ParityLikeTxTracer(Block block, Transaction tx, ParityTraceTypes parityTraceTypes)
{
_tx = tx;
_trace = new ParityLikeTxTrace();
_trace.TransactionHash = tx?.Hash;
_trace.TransactionPosition = tx == null ? (int?)null : block.Transactions.Select((t, ix) => (t, ix)).Where(p => p.t.Hash == tx.Hash).Select((t, ix) => ix).SingleOrDefault();
_trace.BlockNumber = block.Number;
_trace.BlockHash = block.Hash;
if ((parityTraceTypes & ParityTraceTypes.StateDiff) != 0)
{
IsTracingState = true;
_trace.StateChanges = new Dictionary <Address, ParityAccountStateChange>();
}
if ((parityTraceTypes & ParityTraceTypes.Trace) != 0)
{
IsTracingCalls = true;
IsTracingReceipt = true;
}
if ((parityTraceTypes & ParityTraceTypes.VmTrace) != 0)
{
throw new NotImplementedException();
}
}
public ParityLikeBlockTracer(Keccak txHash, ParityTraceTypes types, CancellationToken cancellationToken = default(CancellationToken))
: base(txHash)
{
_cancellationToken = cancellationToken;
_types = types;
IsTracingRewards = (types & ParityTraceTypes.Rewards) == ParityTraceTypes.Rewards;
}
private ParityLikeTxTrace ParityTrace(Block block, Keccak txHash, ParityTraceTypes traceTypes)
{
ParityLikeBlockTracer listener = new ParityLikeBlockTracer(txHash, traceTypes);
_processor.Process(block, ProcessingOptions.ForceProcessing | ProcessingOptions.WithRollback | ProcessingOptions.ReadOnlyChain, listener);
return(listener.BuildResult().SingleOrDefault());
}
public ParityLikeBlockTracer(ParityTraceTypes types, TxTraceFilter?traceFilter, ISpecProvider specProvider)
{
_types = types;
_traceFilter = traceFilter;
_specProvider = specProvider;
IsTracingRewards = (types & ParityTraceTypes.Rewards) == ParityTraceTypes.Rewards;
}
public ParityLikeTxTrace ParityTrace(Keccak txHash, ParityTraceTypes parityTraceTypes)
{
byte[] traceBytes = _traceDb.Get(txHash);
if (traceBytes != null)
{
return(Rlp.Decode <ParityLikeTxTrace>(traceBytes));
}
TransactionReceipt transactionReceipt = _receiptStorage.Get(txHash);
Block block = _blockTree.FindBlock(transactionReceipt.BlockNumber);
if (block == null)
{
throw new InvalidOperationException("Only historical blocks");
}
return(ParityTrace(block, txHash, parityTraceTypes));
}
public ParityLikeTxTrace ParityTrace(Keccak txHash, ParityTraceTypes traceTypes)
{
byte[] traceBytes = _traceDb.Get(txHash);
if (traceBytes != null)
{
return(Rlp.Decode <ParityLikeTxTrace>(traceBytes));
}
TxReceipt txReceipt = _receiptStorage.Find(txHash);
Block block = _blockTree.FindBlock(txReceipt.BlockNumber, BlockTreeLookupOptions.RequireCanonical);
if (block == null)
{
throw new InvalidOperationException("Only historical blocks");
}
return(ParityTrace(block, txHash, traceTypes));
}
private BlockReceiptsTracer BuildTracer(Block block, Transaction tx, bool stateDiff, bool trace)
{
ParityTraceTypes types = ParityTraceTypes.None;
if (stateDiff)
{
types = types | ParityTraceTypes.StateDiff;
}
if (trace)
{
types = types | ParityTraceTypes.Trace;
}
IBlockTracer otherTracer = types != ParityTraceTypes.None ? new ParityLikeBlockTracer(tx.Hash, ParityTraceTypes.Trace | ParityTraceTypes.StateDiff) : (IBlockTracer)NullBlockTracer.Instance;
BlockReceiptsTracer tracer = new BlockReceiptsTracer(_specProvider, _stateProvider);
tracer.SetOtherTracer(otherTracer);
return(tracer);
}
private ParityLikeTxTrace[] ParityTraceBlock(Block block, ParityTraceTypes traceTypes)
{
if (block == null)
{
throw new InvalidOperationException("Only canonical, historical blocks supported");
}
if (block.Number != 0)
{
Block parent = _blockTree.FindParent(block);
if (!_blockTree.IsMainChain(parent.Hash))
{
throw new InvalidOperationException("Cannot trace orphaned blocks");
}
}
ParityLikeBlockTracer listener = new ParityLikeBlockTracer(traceTypes);
_processor.Process(block, ProcessingOptions.ForceProcessing | ProcessingOptions.WithRollback | ProcessingOptions.ReadOnlyChain | ProcessingOptions.NoValidation, listener);
return(listener.BuildResult().ToArray());
}
public ParityLikeTxTrace ParityTraceRawTransaction(byte[] txRlp, ParityTraceTypes traceTypes)
{
BlockHeader headBlockHeader = _blockTree.Head;
BlockHeader traceHeader = new BlockHeader(
headBlockHeader.Hash,
Keccak.OfAnEmptySequenceRlp,
Address.Zero,
headBlockHeader.Difficulty,
headBlockHeader.Number + 1,
headBlockHeader.GasLimit,
headBlockHeader.Timestamp + 1,
headBlockHeader.ExtraData);
Transaction tx = _transactionDecoder.Decode(new RlpStream(txRlp));
Block block = new Block(traceHeader, new[] { tx }, Enumerable.Empty <BlockHeader>());
block.Author = Address.Zero;
block.TotalDifficulty = headBlockHeader.TotalDifficulty + traceHeader.Difficulty;
return(ParityTraceBlock(block, traceTypes)[0]);
}
public void Throw_operation_canceled_after_given_timeout()
{
var timeout = TimeSpan.FromMilliseconds(100);
Transaction transactionMock = Substitute.For <Transaction>();
ParityTraceTypes type = ParityTraceTypes.Trace;
Address address = new Address(new byte[] { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
CancellationToken cancellationToken = new CancellationTokenSource(timeout).Token;
ParityLikeTxTracer tracer = new ParityLikeTxTracer(_blockTree.Head, transactionMock, type, cancellationToken);
Thread.Sleep(timeout.Add(TimeSpan.FromMilliseconds(100)));
Assert.Throws <OperationCanceledException>(() => tracer.StartOperation(0, 0, default(Instruction), 0));
Assert.Throws <OperationCanceledException>(() => tracer.ReportAction(0, 0, address, address, new byte[] { 0, 0, 0 }, ExecutionType.Transaction));
Assert.Throws <OperationCanceledException>(() => tracer.ReportAction(0, 0, address, address, new byte[] { 0, 0, 0 }, ExecutionType.Transaction));
Assert.Throws <OperationCanceledException>(() => tracer.ReportSelfDestruct(address, 0, address));
Assert.Throws <OperationCanceledException>(() => tracer.ReportStackPush(null));
}
public ParityLikeTxTrace[] ParityTraceBlock(UInt256 blockNumber, ParityTraceTypes parityTraceTypes)
{
Block block = _blockTree.FindBlock(blockNumber);
bool loadedFromDb = true;
List <ParityLikeTxTrace> result = new List <ParityLikeTxTrace>();
for (int i = 0; i < block.Transactions.Length; i++)
{
byte[] traceBytes = _traceDb.Get(block.Transactions[i].Hash);
if (traceBytes != null)
{
result.Add(Rlp.Decode <ParityLikeTxTrace>(traceBytes));
}
else
{
loadedFromDb = false;
break;
}
}
if (loadedFromDb)
{
byte[] traceBytes = _traceDb.Get(block.Hash);
if (traceBytes != null)
{
result.AddRange(Rlp.DecodeArray <ParityLikeTxTrace>(new Rlp.DecoderContext(traceBytes), RlpBehaviors.None));
}
}
if (loadedFromDb)
{
return(result.ToArray());
}
return(ParityTraceBlock(block, parityTraceTypes));
}
private (ParityLikeTxTrace trace, Block block, Transaction tx) ExecuteAndTraceParityCall(ParityTraceTypes traceTypes, params byte[] code)
{
(var block, var transaction) = PrepareTx(BlockNumber, 100000, code);
ParityLikeTxTracer tracer = new ParityLikeTxTracer(block, transaction, traceTypes);
_processor.Execute(transaction, block.Header, tracer);
return(tracer.BuildResult(), block, transaction);
}
public ParityLikeBlockTracer(ParityTraceTypes types)
{
_types = types;
IsTracingRewards = (types & ParityTraceTypes.Rewards) == ParityTraceTypes.Rewards;
}
public ParityLikeBlockTracer(Keccak txHash, ParityTraceTypes types)
: base(txHash)
{
_types = types;
IsTracingRewards = (types & ParityTraceTypes.Rewards) == ParityTraceTypes.Rewards;
}
public ParityLikeBlockTracer(Keccak txHash, ParityTraceTypes types)
: base(txHash)
{
_types = types;
}
public ParityLikeBlockTracer(ParityTraceTypes types)
{
_types = types;
}
public ParityLikeTxTrace[] ParityTraceBlock(Keccak blockHash, ParityTraceTypes parityTraceTypes)
{
Block block = _blockTree.FindBlock(blockHash, false);
return(ParityTraceBlock(block, parityTraceTypes));
}
public ParityLikeTxTrace[] ParityTraceBlock(Keccak blockHash, ParityTraceTypes traceTypes)
{
Block block = _blockTree.FindBlock(blockHash, BlockTreeLookupOptions.None);
return(ParityTraceBlock(block, traceTypes));
}
