1751 trace multiple transactions in a single block

libethereum/Block.cpp

@@ -795,36 +795,56 @@
 #ifdef HISTORIC_STATE
 ExecutionResult Block::executeHistoricCall( LastBlockHashesFace const& _lh, Transaction const& _t,
     std::shared_ptr< AlethStandardTrace > _tracer, uint64_t _transactionIndex ) {
-    auto onOp = OnOpFunc();
+    try {
+        auto onOp = OnOpFunc();
 
-    if ( _tracer ) {
-        onOp = _tracer->functionToExecuteOnEachOperation();
-    }
+        if ( _tracer ) {
+            onOp = _tracer->functionToExecuteOnEachOperation();
+        }
 
 
-    if ( isSealed() )
-        BOOST_THROW_EXCEPTION( InvalidOperationOnSealedBlock() );
+        if ( isSealed() )
+            BOOST_THROW_EXCEPTION( InvalidOperationOnSealedBlock() );
 
-    // Uncommitting is a non-trivial operation - only do it once we've verified as much of the
-    // transaction as possible.
-    uncommitToSeal();
+        uncommitToSeal();
 
-    u256 const gasUsed =
-        _transactionIndex ? receipt( _transactionIndex - 1 ).cumulativeGasUsed() : 0;
+        STATE_CHECK( _transactionIndex <= m_receipts.size() )
 
-    EnvInfo const envInfo{ info(), _lh, gasUsed, m_sealEngine->chainParams().chainID };
+        u256 const gasUsed =
+            _transactionIndex ? receipt( _transactionIndex - 1 ).cumulativeGasUsed() : 0;
 
-    if ( _tracer ) {
-        HistoricState stateBefore( m_state.mutableHistoricState() );
-        auto resultReceipt = m_state.mutableHistoricState().execute(
-            envInfo, *m_sealEngine, _t, skale::Permanence::Uncommitted, onOp );
-        HistoricState stateAfter( m_state.mutableHistoricState() );
-        _tracer->finalizeTrace( resultReceipt.first, stateBefore, stateAfter );
-        return resultReceipt.first;
-    } else {
-        auto resultReceipt = m_state.mutableHistoricState().execute(
-            envInfo, *m_sealEngine, _t, skale::Permanence::Reverted, onOp );
-        return resultReceipt.first;
+        EnvInfo const envInfo{ info(), _lh, gasUsed, m_sealEngine->chainParams().chainID };
+
+        if ( _tracer ) {
+            try {
+                HistoricState stateBefore( m_state.mutableHistoricState() );
+
+                auto resultReceipt = m_state.mutableHistoricState().execute(
+                    envInfo, *m_sealEngine, _t, skale::Permanence::Uncommitted, onOp );
+                HistoricState stateAfter( m_state.mutableHistoricState() );
+                _tracer->finalizeAndPrintTrace( resultReceipt.first, stateBefore, stateAfter );
+                // for tracing the entire block is traced therefore, we save transaction receipt
+                // as it is used for execution of the next transaction
+                m_receipts.push_back( resultReceipt.second );
+                return resultReceipt.first;
+            } catch ( std::exception& e ) {
+                throw dev::eth::VMTracingError( "Exception doing trace for transaction index:" +
+                                                std::to_string( _transactionIndex ) + ":" +
+                                                e.what() );
+            }
+        } else {
+            auto resultReceipt = m_state.mutableHistoricState().execute(
+                envInfo, *m_sealEngine, _t, skale::Permanence::Reverted, onOp );
+            return resultReceipt.first;
+        }
+    } catch ( std::exception& e ) {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error( "Could not execute historic call for transactionIndex:" +
+                                to_string( _transactionIndex ) + ":" + e.what() ) );
+    } catch ( ... ) {
+        BOOST_THROW_EXCEPTION(
+            std::runtime_error( "Could not execute historic call for transactionIndex:" +
+                                to_string( _transactionIndex ) + ": unknown error" ) );
     }
 }
 #endif

libethereum/Client.cpp

@@ -1346,43 +1346,48 @@
 
 
 Json::Value Client::traceBlock( BlockNumber _blockNumber, Json::Value const& _jsonTraceConfig ) {
-    Block previousBlock = blockByNumber( _blockNumber - 1 );
-    Block historicBlock = blockByNumber( _blockNumber );
+    try {
+        Block previousBlock = blockByNumber( _blockNumber - 1 );
+        Block historicBlock = blockByNumber( _blockNumber );
 
-    Json::Value traces( Json::arrayValue );
+        Json::Value traces( Json::arrayValue );
 
-    auto hash = ClientBase::hashFromNumber( _blockNumber );
-    Transactions transactions = this->transactions( hash );
+        auto hash = ClientBase::hashFromNumber( _blockNumber );
+        Transactions transactions = this->transactions( hash );
 
-    auto traceOptions = TraceOptions::make( _jsonTraceConfig );
+        auto traceOptions = TraceOptions::make( _jsonTraceConfig );
 
-    // cache results for better peformance
-    string key = to_string( _blockNumber ) + traceOptions.toString();
+        // cache results for better peformance
+        string key = to_string( _blockNumber ) + traceOptions.toString();
 
-    auto cachedResult = m_blockTraceCache.getIfExists( key );
-    if ( cachedResult.has_value() ) {
-        return std::any_cast< Json::Value >( cachedResult );
-    }
+        auto cachedResult = m_blockTraceCache.getIfExists( key );
+        if ( cachedResult.has_value() ) {
+            return std::any_cast< Json::Value >( cachedResult );
+        }
 
-    for ( unsigned k = 0; k < transactions.size(); k++ ) {
-        Json::Value transactionLog( Json::objectValue );
-        Transaction tx = transactions.at( k );
-        auto hashString = toHexPrefixed( tx.sha3() );
-        transactionLog["txHash"] = hashString;
-        tx.checkOutExternalGas( chainParams().externalGasDifficulty );
-        auto tracer =
-            std::make_shared< AlethStandardTrace >( tx, historicBlock.author(), traceOptions );
-        auto executionResult =
-            previousBlock.executeHistoricCall( bc().lastBlockHashes(), tx, tracer, k );
-        auto result = tracer->getJSONResult();
-        transactionLog["result"] = result;
-        traces.append( transactionLog );
-    }
+        for ( unsigned k = 0; k < transactions.size(); k++ ) {
+            Json::Value transactionLog( Json::objectValue );
+            Transaction tx = transactions.at( k );
+            auto hashString = toHexPrefixed( tx.sha3() );
+            transactionLog["txHash"] = hashString;
+            tx.checkOutExternalGas( chainParams().externalGasDifficulty );
+            auto tracer =
+                std::make_shared< AlethStandardTrace >( tx, historicBlock.author(), traceOptions );
+            auto executionResult =
+                previousBlock.executeHistoricCall( bc().lastBlockHashes(), tx, tracer, k );
+            auto result = tracer->getJSONResult();
+            transactionLog["result"] = result;
+            traces.append( transactionLog );
+        }
 
-    auto tracesSize = traces.toStyledString().size();
-    m_blockTraceCache.put( key, traces, tracesSize );
+        auto tracesSize = traces.toStyledString().size();
+        m_blockTraceCache.put( key, traces, tracesSize );
 
-    return traces;
+        return traces;
+    } catch ( std::exception& e ) {
+        BOOST_THROW_EXCEPTION( std::runtime_error(
+            "Could not trace block:" + to_string( _blockNumber ) + ":" + e.what() ) );
+    }
 }
 
 #endif

libhistoric/AlethStandardTrace.cpp

@@ -27,6 +27,7 @@
 namespace dev::eth {
 
 TraceOptions eth::AlethStandardTrace::getOptions() const {
+    STATE_CHECK( m_isFinalized )
     return m_options;
 }
 
@@ -35,6 +36,7 @@
     const LegacyVM* _vm ) {
     STATE_CHECK( _face )
     STATE_CHECK( _vm )
+    STATE_CHECK( !m_isFinalized )
 
     // check if instruction depth changed. This means a function has been called or has returned
     processFunctionCallOrReturnIfHappened( _ext, _vm, ( uint64_t ) _gasRemaining );
@@ -105,6 +107,7 @@
     // record the instruction
     m_lastOpRecord = OpExecutionRecord( _ext.depth, _inst, _gasRemaining, _lastOpGas );
 }
+
 void AlethStandardTrace::processFunctionCallOrReturnIfHappened(
     const AlethExtVM& _ext, const LegacyVM* _vm, uint64_t _gasRemaining ) {
     STATE_CHECK( !m_isFinalized )
@@ -128,6 +131,7 @@
     }
 }
 const Address& AlethStandardTrace::getFrom() const {
+    STATE_CHECK( m_isFinalized )
     return m_from;
 }
 
@@ -147,7 +151,6 @@
     return result;
 }
 
-
 void AlethStandardTrace::recordFunctionIsCalled( const Address& _from, const Address& _to,
     uint64_t _gasLimit, const vector< uint8_t >& _inputData, const u256& _value ) {
     STATE_CHECK( !m_isFinalized )
@@ -178,13 +181,15 @@
 void AlethStandardTrace::setTopFunctionCall(
     const shared_ptr< FunctionCallRecord >& _topFunctionCall ) {
     STATE_CHECK( _topFunctionCall )
+    STATE_CHECK( !m_isFinalized )
     m_topFunctionCall = _topFunctionCall;
 }
 
 void AlethStandardTrace::recordFunctionReturned(
     evmc_status_code _status, const vector< uint8_t >& _returnData, uint64_t _gasUsed ) {
     STATE_CHECK( m_lastOpRecord.m_gasRemaining >= m_lastOpRecord.m_opGas )
     STATE_CHECK( m_currentlyExecutingFunctionCall )
+    STATE_CHECK( !m_isFinalized )
 
     // record return values
     getCurrentlyExecutingFunctionCall()->setReturnValues( _status, _returnData, _gasUsed );
@@ -203,7 +208,6 @@
 // the getter functions are called by printer classes after the trace has been generated
 const shared_ptr< FunctionCallRecord >& AlethStandardTrace::getTopFunctionCall() const {
     STATE_CHECK( m_isFinalized )
-    STATE_CHECK( m_topFunctionCall );
     return m_topFunctionCall;
 }
 
@@ -214,6 +218,11 @@
     return m_jsonTrace;
 }
 
+uint64_t AlethStandardTrace::getTotalGasUsed() const {
+    STATE_CHECK( m_isFinalized )
+    return m_totalGasUsed;
+}
+
 AlethStandardTrace::AlethStandardTrace(
     Transaction& _t, const Address& _blockAuthor, const TraceOptions& _options, bool _isCall )
     : m_defaultOpTrace{ std::make_shared< Json::Value >() },
@@ -243,12 +252,22 @@
           { TraceType::FOUR_BYTE_TRACER, m_fourByteTracePrinter },
           { TraceType::NOOP_TRACER, m_noopTracePrinter } },
       m_blockAuthor( _blockAuthor ),
-      m_isCall( _isCall ) {
+      m_isCall( _isCall ),
+      m_value( _t.value() ),
+      m_gasLimit( _t.gas() ),
+      m_inputData( _t.data() ),
+      m_gasPrice( _t.gasPrice() ) {
     // mark from and to accounts as accessed
     m_accessedAccounts.insert( m_from );
     m_accessedAccounts.insert( m_to );
 }
+
+const u256& AlethStandardTrace::getGasLimit() const {
+    STATE_CHECK( m_isFinalized )
+    return m_gasLimit;
+}
 void AlethStandardTrace::setOriginalFromBalance( const u256& _originalFromBalance ) {
+    STATE_CHECK( !m_isFinalized )
     m_originalFromBalance = _originalFromBalance;
 }
 
@@ -361,24 +380,30 @@
     return "0x" + hexStr;
 }
 
-// execution completed.  Now use the tracer that the user requested
-// to print the resulting trace
-void eth::AlethStandardTrace::finalizeTrace(
+// execution completed.  Now finalize the trace and use the tracer that the user requested
+// to print the resulting trace to json
+void eth::AlethStandardTrace::finalizeAndPrintTrace(
     ExecutionResult& _er, HistoricState& _statePre, HistoricState& _statePost ) {
-    auto totalGasUsed = ( uint64_t ) _er.gasUsed;
-    auto statusCode = AlethExtVM::transactionExceptionToEvmcStatusCode( _er.excepted );
+    m_totalGasUsed = ( uint64_t ) _er.gasUsed;
 
-    // we are done. Set the trace to finalized.
-    STATE_CHECK( !m_isFinalized.exchange( true ) )
+    auto statusCode = AlethExtVM::transactionExceptionToEvmcStatusCode( _er.excepted );
 
-    STATE_CHECK( m_topFunctionCall )
     STATE_CHECK( m_topFunctionCall == m_currentlyExecutingFunctionCall )
 
+    // if transaction is not just ETH transfer
     // record return of the top function.
-    recordFunctionReturned( statusCode, _er.output, totalGasUsed );
+    if ( m_topFunctionCall ) {
+        recordFunctionReturned( statusCode, _er.output, m_totalGasUsed );
+    }
+    // we are done. Set the trace to finalized
+    STATE_CHECK( !m_isFinalized.exchange( true ) )
+    // now print trace
+    printTrace( _er, _statePre, _statePost );
+}
 
+void eth::AlethStandardTrace::printTrace( ExecutionResult& _er, const HistoricState& _statePre,
+    const HistoricState& _statePost ) {  // now print the trace
     m_jsonTrace = Json::Value( Json::objectValue );
-
     // now run the trace that the user wants based on options provided
     if ( m_tracePrinters.count( m_options.tracerType ) > 0 ) {
         m_tracePrinters.at( m_options.tracerType ).print( m_jsonTrace, _er, _statePre, _statePost );
@@ -427,33 +452,63 @@
 
 const shared_ptr< FunctionCallRecord >& AlethStandardTrace::getCurrentlyExecutingFunctionCall()
     const {
+    STATE_CHECK( !m_isFinalized )
     STATE_CHECK( m_currentlyExecutingFunctionCall )
     return m_currentlyExecutingFunctionCall;
 }
 
 void AlethStandardTrace::setCurrentlyExecutingFunctionCall(
     const shared_ptr< FunctionCallRecord >& _currentlyExecutingFunctionCall ) {
+    STATE_CHECK( !m_isFinalized )
     STATE_CHECK( _currentlyExecutingFunctionCall )
     m_currentlyExecutingFunctionCall = _currentlyExecutingFunctionCall;
 }
+
 const Address& AlethStandardTrace::getBlockAuthor() const {
+    STATE_CHECK( m_isFinalized )
     return m_blockAuthor;
 }
+
 const u256& AlethStandardTrace::getMinerPayment() const {
+    STATE_CHECK( m_isFinalized )
     return m_minerPayment;
 }
+
 void AlethStandardTrace::recordMinerPayment( u256 _minerGasPayment ) {
-    this->m_minerPayment = _minerGasPayment;
+    STATE_CHECK( !m_isFinalized )
+    m_minerPayment = _minerGasPayment;
     // add miner to the list of accessed accounts, since the miner is paid
     // transaction fee
-    this->m_accessedAccounts.insert( m_blockAuthor );
+    m_accessedAccounts.insert( m_blockAuthor );
 }
+
 bool AlethStandardTrace::isCall() const {
+    STATE_CHECK( m_isFinalized )
     return m_isCall;
 }
+
 const u256& AlethStandardTrace::getOriginalFromBalance() const {
+    STATE_CHECK( m_isFinalized )
     return m_originalFromBalance;
 }
+
+const bytes& AlethStandardTrace::getInputData() const {
+    STATE_CHECK( m_isFinalized )
+    return m_inputData;
+}
+const u256& AlethStandardTrace::getValue() const {
+    STATE_CHECK( m_isFinalized )
+    return m_value;
+}
+const Address& AlethStandardTrace::getTo() const {
+    STATE_CHECK( m_isFinalized )
+    return m_to;
+}
+
+const u256& AlethStandardTrace::getGasPrice() const {
+    STATE_CHECK( m_isFinalized )
+    return m_gasPrice;
+}
 }  // namespace dev::eth
 
 #endif