1767 fix geth skaled trace inconsistencies

libethereum/Block.cpp

@@ -821,8 +821,9 @@
 
                 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 );
+
+                _tracer->finalizeAndPrintTrace(
+                    resultReceipt.first, stateBefore, m_state.mutableHistoricState() );
                 // 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 );

libethereum/Transaction.cpp

@@ -123,6 +123,18 @@
     case TransactionException::InvalidContractDeployer:
         _out << "InvalidContractDeployer";
         break;
+    case TransactionException::RevertInstruction:
+        _out << "RevertInstruction";
+        break;
+    case TransactionException::InvalidZeroSignatureFormat:
+        _out << "InvalidZeroSignatureFormat";
+        break;
+    case TransactionException::AddressAlreadyUsed:
+        _out << "AddressAlreadyUsed";
+        break;
+    case TransactionException::WouldNotBeInBlock:
+        _out << "WouldNotBeInBlock";
+        break;
     default:
         _out << "Unknown";
         break;

libhistoric/AlethExtVM.cpp

@@ -56,7 +56,7 @@
                 _e.go( _onOp );
             } catch ( ... ) {
                 exception = boost::current_exception();  // Catch all exceptions to be rethrown in
-                                                         // parent thread.
+                // parent thread.
             }
         }
     }.join();
@@ -88,9 +88,15 @@
     case TransactionException::RevertInstruction:
         return EVMC_REVERT;
 
+    case TransactionException::OutOfGasIntrinsic:
+        return EVMC_OUT_OF_GAS;
+
     case TransactionException::OutOfGas:
         return EVMC_OUT_OF_GAS;
 
+    case TransactionException::OutOfGasBase:
+        return EVMC_OUT_OF_GAS;
+
     case TransactionException::BadInstruction:
         return EVMC_UNDEFINED_INSTRUCTION;
 
@@ -100,9 +106,12 @@
     case TransactionException::StackUnderflow:
         return EVMC_STACK_UNDERFLOW;
 
-    case TransactionException ::BadJumpDestination:
+    case TransactionException::BadJumpDestination:
         return EVMC_BAD_JUMP_DESTINATION;
 
+    case TransactionException::InvalidContractDeployer:
+        return EVMC_CONTRACT_VALIDATION_FAILURE;
+
     default:
         return EVMC_FAILURE;
     }

libhistoric/AlethStandardTrace.cpp

@@ -50,7 +50,7 @@
     vector< uint8_t > returnData;
     uint64_t logTopicsCount = 0;
     switch ( _inst ) {
-        // record storage accesses
+    // record storage accesses
     case Instruction::SLOAD:
         // SLOAD - record storage access
         // the stackSize() check prevents malicios code crashing the tracer
@@ -67,7 +67,7 @@
                 _vm->getStackElement( 1 );
         }
         break;
-    // NOW HANDLE CONTRACT FUNCTION CALL INSTRUCTIONS
+        // NOW HANDLE CONTRACT FUNCTION CALL INSTRUCTIONS
     case Instruction::CALL:
     case Instruction::CALLCODE:
     case Instruction::DELEGATECALL:
@@ -78,7 +78,7 @@
             m_accessedAccounts.insert( address );
         }
         break;
-    // NOW HANDLE SUICIDE
+        // NOW HANDLE SUICIDE
     case Instruction::SUICIDE:
         if ( _vm->stackSize() > 0 ) {
             m_accessedAccounts.insert( asAddress( _vm->getStackElement( 0 ) ) );
@@ -118,18 +118,31 @@
     // check if instruction depth changed. This means a function has been called or has returned
 
     if ( currentDepth == m_lastOpRecord.m_depth + 1 ) {
-        // we are beginning to execute a new function
-        auto data = _ext.data.toVector();
-        recordFunctionIsCalled( _ext.caller, _ext.myAddress, _gasRemaining, data, _ext.value );
+        recordFunctionIsCalled(
+            _ext.caller, _ext.myAddress, _gasRemaining, getInputData( _ext ), _ext.value );
     } else if ( currentDepth == m_lastOpRecord.m_depth - 1 ) {
         auto status = _vm->getAndClearLastCallStatus();
+
         recordFunctionReturned( status, _vm->getReturnData(),
             getCurrentlyExecutingFunctionCall()->getFunctionGasLimit() - _gasRemaining );
     } else {
         // depth did not increase or decrease by one, therefore it should be the same
         STATE_CHECK( currentDepth == m_lastOpRecord.m_depth )
     }
 }
+
+vector< uint8_t > AlethStandardTrace::getInputData( const AlethExtVM& _ext ) const {
+    if ( m_lastOpRecord.m_op == Instruction::CREATE ||
+         m_lastOpRecord.m_op == Instruction::CREATE2 ) {
+        // we are in a constructor code, so input to the function is current
+        // code
+        return _ext.code;
+    } else {
+        // we are in a regular function so input is inputData field of _ext
+        return _ext.data.toVector();
+    }
+}
+
 const Address& AlethStandardTrace::getFrom() const {
     STATE_CHECK( m_isFinalized )
     return m_from;
@@ -266,6 +279,7 @@
     STATE_CHECK( m_isFinalized )
     return m_gasLimit;
 }
+
 void AlethStandardTrace::setOriginalFromBalance( const u256& _originalFromBalance ) {
     STATE_CHECK( !m_isFinalized )
     m_originalFromBalance = _originalFromBalance;
@@ -386,21 +400,49 @@
     ExecutionResult& _er, HistoricState& _statePre, HistoricState& _statePost ) {
     m_totalGasUsed = ( uint64_t ) _er.gasUsed;
 
-    auto statusCode = AlethExtVM::transactionExceptionToEvmcStatusCode( _er.excepted );
+    m_output = _er.output;
+    m_deployedContractAddress = _er.newAddress;
+    m_evmcStatusCode = AlethExtVM::transactionExceptionToEvmcStatusCode( _er.excepted );
 
     STATE_CHECK( m_topFunctionCall == m_currentlyExecutingFunctionCall )
 
     // if transaction is not just ETH transfer
     // record return of the top function.
     if ( m_topFunctionCall ) {
-        recordFunctionReturned( statusCode, _er.output, m_totalGasUsed );
+        recordFunctionReturned( m_evmcStatusCode, m_output, m_totalGasUsed );
     }
+
+
+    recordMinerFeePayment( _statePost );
+
+
     // we are done. Set the trace to finalized
     STATE_CHECK( !m_isFinalized.exchange( true ) )
     // now print trace
     printTrace( _er, _statePre, _statePost );
 }
 
+void eth::AlethStandardTrace::recordMinerFeePayment( HistoricState& _statePost ) {
+    if ( !m_isCall ) {  // geth does not record miner fee payments in call traces
+        auto fee = m_gasPrice * m_totalGasUsed;
+        auto fromPostBalance = _statePost.balance( m_from );
+        STATE_CHECK( fromPostBalance >= fee )
+        _statePost.setBalance( m_from, fromPostBalance - fee );
+        auto minerBalance = _statePost.balance( m_blockAuthor );
+        _statePost.setBalance( m_blockAuthor, minerBalance + fee );
+    }
+}
+
+const bytes& AlethStandardTrace::getOutput() const {
+    STATE_CHECK( m_isFinalized )
+    return m_output;
+}
+
+bool AlethStandardTrace::isFailed() const {
+    STATE_CHECK( m_isFinalized )
+    return m_evmcStatusCode != EVMC_SUCCESS;
+}
+
 void eth::AlethStandardTrace::printTrace( ExecutionResult& _er, const HistoricState& _statePre,
     const HistoricState& _statePost ) {  // now print the trace
     m_jsonTrace = Json::Value( Json::objectValue );
@@ -496,10 +538,12 @@
     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;
@@ -509,6 +553,27 @@
     STATE_CHECK( m_isFinalized )
     return m_gasPrice;
 }
+
+evmc_status_code AlethStandardTrace::getEVMCStatusCode() const {
+    STATE_CHECK( m_isFinalized )
+    return m_evmcStatusCode;
+}
+
+const Address& AlethStandardTrace::getDeployedContractAddress() const {
+    return m_deployedContractAddress;
+}
+
+// return true if transaction is a simple Eth transfer
+[[nodiscard]] bool AlethStandardTrace::isSimpleTransfer() {
+    return !m_topFunctionCall;
+}
+
+// return true if transaction is contract creation
+[[nodiscard]] bool AlethStandardTrace::isContractCreation() {
+    return m_topFunctionCall && m_topFunctionCall->getType() == Instruction::CREATE;
+}
+
 }  // namespace dev::eth
 
+
 #endif

libhistoric/AlethStandardTrace.h

@@ -82,7 +82,7 @@ class AlethStandardTrace {
     [[nodiscard]] const std::set< Address >& getAccessedAccounts() const;
     [[nodiscard]] const h256& getTxHash() const;
     [[nodiscard]] const std::shared_ptr< Json::Value >& getDefaultOpTrace() const;
-
+    [[nodiscard]] const Address& getDeployedContractAddress() const;
     [[nodiscard]] const std::shared_ptr< FunctionCallRecord >& getCurrentlyExecutingFunctionCall()
         const;
     [[nodiscard]] const Address& getBlockAuthor() const;
@@ -95,9 +95,14 @@ class AlethStandardTrace {
     [[nodiscard]] const u256& getValue() const;
     [[nodiscard]] const bytes& getInputData() const;
     [[nodiscard]] const Address& getTo() const;
+    [[nodiscard]] const u256& getGasPrice() const;
+    [[nodiscard]] const bytes& getOutput() const;
+    [[nodiscard]] bool isFailed() const;
+    [[nodiscard]] evmc_status_code getEVMCStatusCode() const;
+    [[nodiscard]] bool isSimpleTransfer();
+    [[nodiscard]] bool isContractCreation();
 
-    static string toGethCompatibleCompactHexPrefixed( const u256& _value );
-
+    [[nodiscard]] static string toGethCompatibleCompactHexPrefixed( const u256& _value );
 
 private:
     void setCurrentlyExecutingFunctionCall(
@@ -130,7 +135,6 @@ class AlethStandardTrace {
     [[nodiscard]] static std::vector< std::uint8_t >
     extractSmartContractMemoryByteArrayFromStackPointer( const LegacyVM* _vm );
 
-
     // this is called when the function call depth of the current instruction is different from the
     // previous instruction. This happens when a function is called or returned.
     void processFunctionCallOrReturnIfHappened(
@@ -145,6 +149,13 @@ class AlethStandardTrace {
 
     void recordMinerPayment( u256 _minerGasPayment );
 
+    void printTrace(
+        ExecutionResult& _er, const HistoricState& _statePre, const HistoricState& _statePost );
+
+    [[nodiscard]] vector< uint8_t > getInputData( const AlethExtVM& _ext ) const;
+
+    void recordMinerFeePayment( HistoricState& _statePost );
+
     std::shared_ptr< FunctionCallRecord > m_topFunctionCall;
     std::shared_ptr< FunctionCallRecord > m_currentlyExecutingFunctionCall;
     std::vector< Instruction > m_lastInst;
@@ -176,18 +187,14 @@ class AlethStandardTrace {
     u256 m_minerPayment;
     u256 m_originalFromBalance;
     bool m_isCall;
-
-public:
-    const u256& getGasPrice() const;
-
-private:
     uint64_t m_totalGasUsed;
     u256 m_value;
     u256 m_gasLimit;
     bytes m_inputData;
     u256 m_gasPrice;
-
-    void printTrace(
-        ExecutionResult& _er, const HistoricState& _statePre, const HistoricState& _statePost );
+    bytes m_output;
+    evmc_status_code m_evmcStatusCode;
+    // this will include deployed contract address if the transaction was CREATE
+    Address m_deployedContractAddress;
 };
 }  // namespace dev::eth

libhistoric/CallTracePrinter.cpp

@@ -28,16 +28,36 @@
 namespace dev::eth {
 
 // call tracer as implemented by geth
-void CallTracePrinter::print(
-    Json::Value& _jsonTrace, const ExecutionResult&, const HistoricState&, const HistoricState& ) {
+void CallTracePrinter::print( Json::Value& _jsonTrace, const ExecutionResult&, const HistoricState&,
+    const HistoricState& _statePost ) {
     STATE_CHECK( _jsonTrace.isObject() )
 
-    auto topFunctionCallRecord = m_trace.getTopFunctionCall();
-    if ( !topFunctionCallRecord ) {
-        // no bytecodes were executed
+    // first print error description if the transaction failed
+    if ( m_trace.isFailed() ) {
+        _jsonTrace["error"] = getEvmErrorDescription( m_trace.getEVMCStatusCode() );
+    }
+
+    // now deal with the cases of simple ETH transfer vs contract interaction
+    if ( m_trace.isSimpleTransfer() ) {
+        // no bytecode was executed
         printTransferTrace( _jsonTrace );
     } else {
-        topFunctionCallRecord->printTrace( _jsonTrace, 0, m_trace.getOptions() );
+        printContractTransactionTrace( _jsonTrace, _statePost );
+    }
+}
+void CallTracePrinter::printContractTransactionTrace(
+    Json::Value& _jsonTrace, const HistoricState& _statePost ) {
+    auto topFunctionCall = m_trace.getTopFunctionCall();
+    STATE_CHECK( topFunctionCall );
+    // call trace on the top Solidity function call in the stack
+    // this will also recursively call printTrace on nested calls if exist
+    topFunctionCall->printTrace( _jsonTrace, _statePost, 0, m_trace.getOptions() );
+    // handle the case of a transaction that deploys a contract
+    // in this case geth prints transaction input data as input
+    // end prints to as newly created contract address
+    if ( m_trace.isContractCreation() ) {
+        _jsonTrace["input"] = toHexPrefixed( m_trace.getInputData() );
+        _jsonTrace["to"] = toHexPrefixed( m_trace.getDeployedContractAddress() );
     }
 }
 
@@ -51,16 +71,12 @@
     _jsonTrace["type"] = "CALL";
     _jsonTrace["from"] = toHexPrefixed( m_trace.getFrom() );
     _jsonTrace["to"] = toHexPrefixed( m_trace.getTo() );
-
     _jsonTrace["gas"] =
         AlethStandardTrace::toGethCompatibleCompactHexPrefixed( m_trace.getGasLimit() );
     _jsonTrace["gasUsed"] =
         AlethStandardTrace::toGethCompatibleCompactHexPrefixed( m_trace.getTotalGasUsed() );
-
-
     _jsonTrace["value"] =
         AlethStandardTrace::toGethCompatibleCompactHexPrefixed( m_trace.getValue() );
-
     _jsonTrace["input"] = toHexPrefixed( m_trace.getInputData() );
 }
 

libhistoric/CallTracePrinter.h

@@ -39,5 +39,7 @@ class CallTracePrinter : public TracePrinter {
 
 private:
     void printTransferTrace( Json::Value& _jsonTrace );
+
+    void printContractTransactionTrace( Json::Value& _jsonTrace, const HistoricState& _statePost );
 };
 }  // namespace dev::eth