hardfork Integration test with eth_simulateV1

api/api_test.go

@@ -67,9 +67,9 @@ func (f TransactionEmitterFunc) Emit(tx *types.Transaction) error {
 	return f(tx)
 }
 
-func newRPCBalance(balance *big.Int) **hexutil.Big {
+func newRPCBalance(balance *big.Int) *hexutil.Big {
 	rpcBalance := (*hexutil.Big)(balance)
-	return &rpcBalance
+	return rpcBalance
 }
 
 func hex2Bytes(str string) *hexutil.Bytes {

api/error.go

@@ -106,6 +106,23 @@ var (
 
 )
 
+const (
+	errCodeNonceTooHigh            = -38011
+	errCodeNonceTooLow             = -38010
+	errCodeIntrinsicGas            = -38013
+	errCodeInsufficientFunds       = -38014
+	errCodeBlockGasLimitReached    = -38015
+	errCodeBlockNumberInvalid      = -38020
+	errCodeBlockTimestampInvalid   = -38021
+	errCodeSenderIsNotEOA          = -38024
+	errCodeMaxInitCodeSizeExceeded = -38025
+	errCodeClientLimitExceeded     = -38026
+	errCodeInternalError           = -32603
+	errCodeInvalidParams           = -32602
+	errCodeReverted                = -32000
+	errCodeVMError                 = -32015
+)
+
 
 // EIP-7702 state transition errors.
 // Note these are just informational, and do not cause tx execution abort.
@@ -115,4 +132,32 @@ var (
 	ErrAuthorizationInvalidSignature   = errors.New("EIP-7702 authorization has invalid signature")
 	ErrAuthorizationDestinationHasCode = errors.New("EIP-7702 authorization destination is a contract")
 	ErrAuthorizationNonceMismatch      = errors.New("EIP-7702 authorization nonce does not match current account nonce")
-)
+)
+
+type callError struct {
+	Message string `json:"message"`
+	Code    int    `json:"code"`
+	Data    string `json:"data,omitempty"`
+}
+
+type invalidParamsError struct{ message string }
+
+func (e *invalidParamsError) Error() string  { return e.message }
+func (e *invalidParamsError) ErrorCode() int { return errCodeInvalidParams }
+
+type clientLimitExceededError struct{ message string }
+
+type invalidBlockNumberError struct{ message string }
+func (e *invalidBlockNumberError) Error() string  { return e.message }
+func (e *invalidBlockNumberError) ErrorCode() int { return errCodeBlockNumberInvalid }
+
+type invalidBlockTimestampError struct{ message string }
+func (e *invalidBlockTimestampError) Error() string  { return e.message }
+
+func (e *clientLimitExceededError) Error() string  { return e.message }
+func (e *clientLimitExceededError) ErrorCode() int { return errCodeClientLimitExceeded }
+
+type blockGasLimitReachedError struct{ message string }
+
+func (e *blockGasLimitReachedError) Error() string  { return e.message }
+func (e *blockGasLimitReachedError) ErrorCode() int { return errCodeBlockGasLimitReached }

api/eth.go

@@ -133,7 +133,7 @@ func (s *PublicBlockChainAPI) GetStorageAt(ctx *rpc.CallContext, address common.
 type OverrideAccount struct {
 	Nonce     *hexutil.Uint64              `json:"nonce"`
 	Code      *hexutil.Bytes               `json:"code"`
-	Balance   **hexutil.Big                `json:"balance"`
+	Balance   *hexutil.Big                `json:"balance"`
 	State     *map[ctypes.Hash]ctypes.Hash `json:"state"`
 	StateDiff *map[ctypes.Hash]ctypes.Hash `json:"stateDiff"`
 }
@@ -176,7 +176,7 @@ func (diff *StateOverride) Apply(state state.StateDB) error {
 		}
 		// Override account balance.
 		if account.Balance != nil {
-			state.SetBalance(addr, (*big.Int)(*account.Balance))
+			state.SetBalance(addr, (*big.Int)(account.Balance))
 		}
 		if account.State != nil && account.StateDiff != nil {
 			return fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())
@@ -192,9 +192,35 @@ func (diff *StateOverride) Apply(state state.StateDB) error {
 			}
 		}
 	}
+
+	// Now finalize the changes. Finalize is normally performed between transactions.
+	// By using finalize, the overrides are semantically behaving as
+	// if they were created in a transaction just before the tracing occur.
+	state.Finalise()
 	return nil
 }
 
+func applyMessageWithEVM(ctx *rpc.CallContext, evm *vm.EVM, msg *Msg, timeout time.Duration, gp *GasPool) (*ExecutionResult, error) {
+	// Wait for the context to be done and cancel the evm. Even if the
+	// EVM has finished, cancelling may be done (repeatedly)
+	go func() {
+		<-ctx.Context().Done()
+		evm.Cancel()
+	}()
+
+	// Execute the message.
+	result, err := ApplyMessage(evm, msg, gp)
+
+	// If the timer caused an abort, return an appropriate error message
+	if evm.Cancelled() {
+		return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)
+	}
+	if err != nil {
+		return result, fmt.Errorf("err: %w (supplied gas %d)", err, msg.gasLimit)
+	}
+	return result, nil
+}
+
 func DoCall(cctx *rpc.CallContext, getEVM func(state.StateDB, *vm.Config, common.Address, *big.Int) *vm.EVM, args TransactionArgs, prevState *PreviousState, blockNrOrHash vm.BlockNumberOrHash, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*ExecutionResult, *PreviousState, error) {
 	defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now())
 	if prevState == nil || prevState.header == nil || prevState.state == nil {
@@ -340,6 +366,61 @@ func (s *PublicBlockChainAPI) Call(ctx *rpc.CallContext, args TransactionArgs, b
 	return res, err
 }
 
+// SimulateV1 executes series of transactions on top of a base state.
+// The transactions are packed into blocks. For each block, block header
+// fields can be overridden. The state can also be overridden prior to
+// execution of each block.
+//
+// Note, this function doesn't make any changes in the state/blockchain and is
+// useful to execute and retrieve values.
+func (s *PublicBlockChainAPI) SimulateV1(ctx *rpc.CallContext, opts simOpts, blockNrOrHash *vm.BlockNumberOrHash) ([]*simBlockResult, error) {
+	if len(opts.BlockStateCalls) == 0 {
+		return nil, &invalidParamsError{message: "empty input"}
+	} else if len(opts.BlockStateCalls) > maxSimulateBlocks {
+		return nil,  &clientLimitExceededError{message: "too many blocks"}
+	}
+
+	bNrOrHash := vm.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
+	if blockNrOrHash != nil {
+		bNrOrHash = *blockNrOrHash
+	}
+
+	var results []*simBlockResult
+
+	err := s.evmmgr.View(bNrOrHash, &vm.Config{NoBaseFee: !opts.Validation}, ctx, func(statedb state.StateDB, baseHeader *types.Header, evmFn func(state.StateDB, *vm.Config, common.Address, *big.Int) *vm.EVM, chaincfg *params.ChainConfig) error {
+		gasCap := s.gasLimit(baseHeader)
+		if gasCap == 0 {
+			gasCap = math.MaxUint64
+		}
+
+		sim := &simulator{
+			timeout:        30 * time.Second, 
+			state:          statedb.Copy(),
+			base:           types.CopyHeader(baseHeader),
+			chainConfig:    chaincfg,
+			// Each tx and all the series of txes shouldn't consume more gas than cap
+			gp:             new(GasPool).AddGas(gasCap),
+			traceTransfers: opts.TraceTransfers,
+			validate:       opts.Validation,
+			fullTx:         opts.ReturnFullTransactions,
+			evmFn:          evmFn,
+		}
+		var err error
+		results, err = sim.execute(ctx, opts.BlockStateCalls)
+		return err
+	})
+
+	if err != nil {
+		switch err.(type) {
+		case codedError:
+		default:
+			err = evmError{err}
+		}
+		return nil, err
+	}
+	return results, nil
+}
+
 //
 type estimateGasError struct {
 	error  string // Concrete error type if it's failed to estimate gas usage

api/logtracer.go

@@ -0,0 +1,87 @@
+package api
+
+import (
+	"math/big"
+	"time"
+
+	"github.com/openrelayxyz/cardinal-evm/common"
+	"github.com/openrelayxyz/cardinal-evm/types"
+	"github.com/openrelayxyz/cardinal-evm/vm"
+	ctypes "github.com/openrelayxyz/cardinal-types"
+)
+
+var (
+	// keccak256("Transfer(address,address,uint256)")
+	transferTopic = ctypes.HexToHash("ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef")
+	// ERC-7528
+	transferAddress = common.HexToAddress("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")
+)
+
+
+type tracer struct {
+	// logs keeps logs for all open call frames.
+	// This lets us clear logs for failed calls.
+	logs           []*types.Log
+	count          int
+	traceTransfers bool
+	blockNumber    uint64
+	blockTimestamp    uint64
+	blockHash      ctypes.Hash
+	txHash         ctypes.Hash
+	txIdx          uint
+}
+
+func newTracer(traceTransfers bool, blockNumber uint64,  blockTimestamp uint64, blockHash, txHash ctypes.Hash, txIndex uint) *tracer {
+	return &tracer{
+		logs:           make([]*types.Log, 0),
+		traceTransfers: traceTransfers,
+		blockNumber:    blockNumber,
+		blockHash:      blockHash,
+		txHash:         txHash,
+		txIdx:          txIndex,
+		blockTimestamp: blockTimestamp,
+	}
+}
+
+func (t *tracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {}
+
+func (t *tracer) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int){
+	if !t.traceTransfers {
+        return
+    }
+    // Capture the initial transaction value transfer
+    if !create && value != nil && value.Sign() > 0 {
+        topics := []ctypes.Hash{
+            transferTopic,
+            ctypes.BytesToHash(from.Bytes()),
+            ctypes.BytesToHash(to.Bytes()),
+        }
+        t.logs = append(t.logs, &types.Log{
+            Address:     transferAddress,
+            Topics:      topics,
+            Data:        ctypes.BigToHash(value).Bytes(), 
+            BlockNumber: t.blockNumber,
+            BlockHash:   t.blockHash,
+            TxHash:      t.txHash,
+            TxIndex:     t.txIdx,
+            Index:       uint(t.count),
+			BlockTimestamp: t.blockTimestamp,
+        })
+        t.count++
+    }
+}
+func (t *tracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error){}
+func (t *tracer) CaptureExit(output []byte, gasUsed uint64, err error){}
+func (t *tracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, depth int, err error){}
+func (t *tracer) CaptureEnd(output []byte, gasUsed uint64, time time.Duration, err error){}
+
+// reset prepares the tracer for the next transaction.
+func (t *tracer) reset(txHash ctypes.Hash, txIdx uint) {
+	t.logs = make([]*types.Log, 0)
+	t.txHash = txHash
+	t.txIdx = txIdx
+}
+
+func (t *tracer) Logs() []*types.Log {
+	return t.logs
+}