public BlockchainBridge(TransactionProcessor processor, IReleaseSpec spec)
{
_spec = spec;
_receiptsTracer = new BlockReceiptsTracer();
_processor = processor;
_receiptsTracer.SetOtherTracer(GethTracer);
_receiptsTracer.StartNewBlockTrace(_headBlock);
}
public BlockchainBridge(TransactionProcessor processor, IReleaseSpec spec)
{
_spec = spec;
_receiptsTracer = new BlockReceiptsTracer(new SingleReleaseSpecProvider(_spec, 99), Substitute.For <IStateProvider>());
_processor = processor;
_receiptsTracer.SetOtherTracer(GethTracer);
_receiptsTracer.StartNewBlockTrace(_headBlock);
}
public BlockchainBridge(TransactionProcessor processor)
{
_receiptsTracer = new BlockReceiptsTracer();
_processor = processor;
_tx = Build.A.Transaction.SignedAndResolved(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), TestItem.PrivateKeyA).TestObject;
_headBlock = Build.A.Block.WithNumber(1).WithTransactions(Enumerable.Repeat(_tx, 100).ToArray()).TestObject;
_receiptsTracer.SetOtherTracer(GethTracer);
_receiptsTracer.StartNewBlockTrace(_headBlock);
}
public void Sets_state_root_if_provided_on_failure()
{
Block block = Build.A.Block.WithTransactions(MuirGlacier.Instance, Build.A.Transaction.TestObject).TestObject;
BlockReceiptsTracer tracer = new BlockReceiptsTracer();
tracer.SetOtherTracer(NullBlockTracer.Instance);
tracer.StartNewBlockTrace(block);
tracer.StartNewTxTrace(block.Transactions[0].Hash);
tracer.MarkAsFailed(TestItem.AddressA, 100, new byte[0], "error", TestItem.KeccakF);
Assert.AreEqual(TestItem.KeccakF, tracer.TxReceipts[0].PostTransactionState);
}
public void Sets_state_root_if_provided_on_success()
{
Block block = Build.A.Block.WithTransactions(Build.A.Transaction.TestObject).TestObject;
BlockReceiptsTracer tracer = new BlockReceiptsTracer();
tracer.SetOtherTracer(NullBlockTracer.Instance);
tracer.StartNewBlockTrace(block);
tracer.StartNewTxTrace(block.Transactions[0].Hash);
tracer.MarkAsSuccess(TestItem.AddressA, 100, new byte[0], new LogEntry[0], TestItem.KeccakF);
Assert.AreEqual(TestItem.KeccakF, tracer.TxReceipts[0].PostTransactionState);
}
public void Invokes_other_tracer_mark_as_failed_if_other_block_tracer_is_tx_tracer_too()
{
Block block = Build.A.Block.WithTransactions(MuirGlacier.Instance, Build.A.Transaction.TestObject).TestObject;
IBlockTracer otherTracer = Substitute.For <IBlockTracer, ITxTracer>();
BlockReceiptsTracer tracer = new BlockReceiptsTracer();
tracer.SetOtherTracer(otherTracer);
tracer.StartNewBlockTrace(block);
tracer.StartNewTxTrace(block.Transactions[0].Hash);
tracer.MarkAsFailed(TestItem.AddressA, 100, Array.Empty <byte>(), "error", TestItem.KeccakF);
(otherTracer as ITxTracer).Received().MarkAsFailed(TestItem.AddressA, 100, Array.Empty <byte>(), "error", TestItem.KeccakF);
}
public void Invokes_other_tracer_mark_as_success_if_other_block_tracer_is_tx_tracer_too()
{
Block block = Build.A.Block.WithTransactions(Build.A.Transaction.TestObject).TestObject;
IBlockTracer otherTracer = Substitute.For <IBlockTracer, ITxTracer>();
BlockReceiptsTracer tracer = new BlockReceiptsTracer();
tracer.SetOtherTracer(otherTracer);
tracer.StartNewBlockTrace(block);
tracer.StartNewTxTrace(block.Transactions[0].Hash);
var logEntries = new LogEntry[0];
tracer.MarkAsSuccess(TestItem.AddressA, 100, Array.Empty <byte>(), logEntries, TestItem.KeccakF);
(otherTracer as ITxTracer).Received().MarkAsSuccess(TestItem.AddressA, 100, Array.Empty <byte>(), logEntries, TestItem.KeccakF);
}
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 TxReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, IBlockTracer blockTracer)
{
_receiptsTracer.SetOtherTracer(blockTracer);
_receiptsTracer.StartNewBlockTrace(block);
for (int i = 0; i < block.Transactions.Length; i++)
{
Transaction currentTx = block.Transactions[i];
if ((processingOptions & ProcessingOptions.DoNotVerifyNonce) != 0)
{
currentTx.Nonce = _stateProvider.GetNonce(currentTx.SenderAddress);
}
_receiptsTracer.StartNewTxTrace(currentTx.Hash);
_transactionProcessor.Execute(currentTx, block.Header, _receiptsTracer);
_receiptsTracer.EndTxTrace();
TransactionProcessed?.Invoke(this, new TxProcessedEventArgs(i, currentTx, _receiptsTracer.TxReceipts[i]));
}
return(_receiptsTracer.TxReceipts);
}
public ResultWrapper <ReceiptWithProof> proof_getTransactionReceipt(Keccak txHash, bool includeHeader)
{
Keccak blockHash = _receiptFinder.FindBlockHash(txHash);
if (blockHash == null)
{
return(ResultWrapper <ReceiptWithProof> .Fail($"{txHash} receipt could not be found", ErrorCodes.ResourceNotFound));
}
SearchResult <Block> searchResult = _blockFinder.SearchForBlock(new BlockParameter(blockHash));
if (searchResult.IsError)
{
return(ResultWrapper <ReceiptWithProof> .Fail(searchResult));
}
Block block = searchResult.Object;
TxReceipt receipt = _receiptFinder.Get(block).ForTransaction(txHash);
BlockReceiptsTracer receiptsTracer = new BlockReceiptsTracer();
receiptsTracer.SetOtherTracer(NullBlockTracer.Instance);
_tracer.Trace(block, receiptsTracer);
TxReceipt[] receipts = receiptsTracer.TxReceipts;
Transaction[] txs = block.Transactions;
ReceiptWithProof receiptWithProof = new ReceiptWithProof();
receiptWithProof.Receipt = new ReceiptForRpc(txHash, receipt);
receiptWithProof.ReceiptProof = BuildReceiptProofs(block.Number, receipts, receipt.Index);
receiptWithProof.TxProof = BuildTxProofs(txs, _specProvider.GetSpec(block.Number), receipt.Index);
if (includeHeader)
{
receiptWithProof.BlockHeader = _headerDecoder.Encode(block.Header).Bytes;
}
return(ResultWrapper <ReceiptWithProof> .Success(receiptWithProof));
}
// TODO: block processor pipeline
protected virtual TxReceipt[] ProcessBlock(
Block block,
IBlockTracer blockTracer,
ProcessingOptions options)
{
IReleaseSpec spec = _specProvider.GetSpec(block.Number);
_receiptsTracer.SetOtherTracer(blockTracer);
_receiptsTracer.StartNewBlockTrace(block);
TxReceipt[] receipts = _blockTransactionsExecutor.ProcessTransactions(block, options, _receiptsTracer, spec);
_receiptsTracer.EndBlockTrace();
block.Header.ReceiptsRoot = receipts.GetReceiptsRoot(spec, block.ReceiptsRoot);
ApplyMinerRewards(block, blockTracer, spec);
_stateProvider.Commit(spec);
_stateProvider.RecalculateStateRoot();
block.Header.StateRoot = _stateProvider.StateRoot;
block.Header.Hash = block.Header.CalculateHash();
return(receipts);
}
private TransactionReceipt[] ProcessTransactions(Block block, ProcessingOptions processingOptions, IBlockTracer blockTracer)
{
_receiptsTracer.SetOtherTracer(blockTracer);
_receiptsTracer.StartNewBlockTrace(block);
for (int i = 0; i < block.Transactions.Length; i++)
{
if (_logger.IsTrace)
{
_logger.Trace($"Processing transaction {i}");
}
Transaction currentTx = block.Transactions[i];
_receiptsTracer.StartNewTxTrace(currentTx.Hash);
_transactionProcessor.Execute(currentTx, block.Header, _receiptsTracer);
_receiptsTracer.EndTxTrace();
if ((processingOptions & ProcessingOptions.ReadOnlyChain) == 0)
{
TransactionProcessed?.Invoke(this, new TransactionProcessedEventArgs(_receiptsTracer.TransactionReceipts[i]));
}
}
return(_receiptsTracer.TransactionReceipts);
}
