以太坊虚拟机(下篇)

// filedir:go-ethereum-1.10.2corevmevm.go  L204// Call executes the contract associated with the addr with the given input as// parameters. It also handles any necessary value transfer required and takes// the necessary steps to create accounts and reverses the state in case of an// execution error or failed value transfer.func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // Fail if we're trying to transfer more than the available balance  if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {    return nil, gas, ErrInsufficientBalance  }  snapshot := evm.StateDB.Snapshot()  p, isPrecompile := evm.precompile(addr)
  if !evm.StateDB.Exist(addr) {    if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {      // Calling a non existing account, don't do anything, but ping the tracer      if evm.vmConfig.Debug && evm.depth == 0 {        evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)        evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)      }      return nil, gas, nil    }    evm.StateDB.CreateAccount(addr)  }  evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)
  // Capture the tracer start/end events in debug mode  if evm.vmConfig.Debug && evm.depth == 0 {    evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)    defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters      evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)    }(gas, time.Now())  }
  if isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    code := evm.StateDB.GetCode(addr)    if len(code) == 0 {      ret, err = nil, nil // gas is unchanged    } else {      addrCopy := addr      // If the account has no code, we can abort here      // The depth-check is already done, and precompiles handled above      contract := NewContract(caller, AccountRef(addrCopy), value, gas)      contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)      ret, err = run(evm, contract, input, false)      gas = contract.Gas    }  }  // When an error was returned by the EVM or when setting the creation code  // above we revert to the snapshot and consume any gas remaining. Additionally  // when we're in homestead this also counts for code storage gas errors.  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }    // TODO: consider clearing up unused snapshots:    //} else {    //  evm.StateDB.DiscardSnapshot(snapshot)  }  return ret, gas, err}

// Call executes the contract associated with the addr with the given input as// parameters. It also handles any necessary value transfer required and takes// the necessary steps to create accounts and reverses the state in case of an// execution error or failed value transfer.func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // Fail if we're trying to transfer more than the available balance  if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {    return nil, gas, ErrInsufficientBalance  }    ......

  snapshot := evm.StateDB.Snapshot()  p, isPrecompile := evm.precompile(addr)
  if !evm.StateDB.Exist(addr) {    if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {      // Calling a non existing account, don't do anything, but ping the tracer      if evm.vmConfig.Debug && evm.depth == 0 {        evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)        evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)      }      return nil, gas, nil    }    evm.StateDB.CreateAccount(addr)  }  evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)

// Transfer subtracts amount from sender and adds amount to recipient using the given Dbfunc Transfer(db vm.StateDB, sender, recipient common.Address, amount *big.Int) {  db.SubBalance(sender, amount)  db.AddBalance(recipient, amount)}

  // Capture the tracer start/end events in debug mode  if evm.vmConfig.Debug && evm.depth == 0 {    evm.vmConfig.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)    defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters      evm.vmConfig.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)    }(gas, time.Now())  }

  if isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    code := evm.StateDB.GetCode(addr)    if len(code) == 0 {      ret, err = nil, nil // gas is unchanged    } else {      addrCopy := addr      // If the account has no code, we can abort here      // The depth-check is already done, and precompiles handled above      contract := NewContract(caller, AccountRef(addrCopy), value, gas)      contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)      ret, err = run(evm, contract, input, false)      gas = contract.Gas    }  }

// filedir:go-ethereum-1.10.2corevmcontracts.go  L145// RunPrecompiledContract runs and evaluates the output of a precompiled contract.// It returns// - the returned bytes,// - the _remaining_ gas,// - any error that occurredfunc RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {  gasCost := p.RequiredGas(input)  if suppliedGas < gasCost {    return nil, 0, ErrOutOfGas  }  suppliedGas -= gasCost  output, err := p.Run(input)  return output, suppliedGas, err}

// filedir:go-ethereum-1.10.2corevmcontracts.go  L167func (c *ecrecover) Run(input []byte) ([]byte, error) {  const ecRecoverInputLength = 128
  input = common.RightPadBytes(input, ecRecoverInputLength)  // "input" is (hash, v, r, s), each 32 bytes  // but for ecrecover we want (r, s, v)
  r := new(big.Int).SetBytes(input[64:96])  s := new(big.Int).SetBytes(input[96:128])  v := input[63] - 27
  // tighter sig s values input homestead only apply to tx sigs  if !allZero(input[32:63]) || !crypto.ValidateSignatureValues(v, r, s, false) {    return nil, nil  }  // We must make sure not to modify the 'input', so placing the 'v' along with  // the signature needs to be done on a new allocation  sig := make([]byte, 65)  copy(sig, input[64:128])  sig[64] = v  // v needs to be at the end for libsecp256k1  pubKey, err := crypto.Ecrecover(input[:32], sig)  // make sure the public key is a valid one  if err != nil {    return nil, nil  }
  // the first byte of pubkey is bitcoin heritage  return common.LeftPadBytes(crypto.Keccak256(pubKey[1:])[12:], 32), nil}

// run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter.func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, error) {  for _, interpreter := range evm.interpreters {    if interpreter.CanRun(contract.Code) {      if evm.interpreter != interpreter {        // Ensure that the interpreter pointer is set back        // to its current value upon return.        defer func(i Interpreter) {          evm.interpreter = i        }(evm.interpreter)        evm.interpreter = interpreter      }      return interpreter.Run(contract, input, readOnly)    }  }  return nil, errors.New("no compatible interpreter")}

// Run loops and evaluates the contract's code with the given input data and returns// the return byte-slice and an error if one occurred.//// It's important to note that any errors returned by the interpreter should be// considered a revert-and-consume-all-gas operation except for// ErrExecutionReverted which means revert-and-keep-gas-left.func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error) {
  // Increment the call depth which is restricted to 1024  in.evm.depth++  defer func() { in.evm.depth-- }()
  // Make sure the readOnly is only set if we aren't in readOnly yet.  // This makes also sure that the readOnly flag isn't removed for child calls.  if readOnly && !in.readOnly {    in.readOnly = true    defer func() { in.readOnly = false }()  }
  // Reset the previous call's return data. It's unimportant to preserve the old buffer  // as every returning call will return new data anyway.  in.returnData = nil
  // Don't bother with the execution if there's no code.  if len(contract.Code) == 0 {    return nil, nil  }
  var (    op          OpCode        // current opcode    mem         = NewMemory() // bound memory    stack       = newstack()  // local stack    callContext = &ScopeContext{      Memory:   mem,      Stack:    stack,      Contract: contract,    }    // For optimisation reason we're using uint64 as the program counter.    // It's theoretically possible to go above 2^64. The YP defines the PC    // to be uint256. Practically much less so feasible.    pc   = uint64(0) // program counter    cost uint64    // copies used by tracer    pcCopy  uint64 // needed for the deferred Tracer    gasCopy uint64 // for Tracer to log gas remaining before execution    logged  bool   // deferred Tracer should ignore already logged steps    res     []byte // result of the opcode execution function  )  // Don't move this deferrred function, it's placed before the capturestate-deferred method,  // so that it get's executed _after_: the capturestate needs the stacks before  // they are returned to the pools  defer func() {    returnStack(stack)  }()  contract.Input = input
  if in.cfg.Debug {    defer func() {      if err != nil {        if !logged {          in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)        } else {          in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, callContext, in.evm.depth, err)        }      }    }()  }  // The Interpreter main run loop (contextual). This loop runs until either an  // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during  // the execution of one of the operations or until the done flag is set by the  // parent context.  steps := 0  for {    steps++    if steps%1000 == 0 && atomic.LoadInt32(&in.evm.abort) != 0 {      break    }    if in.cfg.Debug {      // Capture pre-execution values for tracing.      logged, pcCopy, gasCopy = false, pc, contract.Gas    }
    // Get the operation from the jump table and validate the stack to ensure there are    // enough stack items available to perform the operation.    op = contract.GetOp(pc)    operation := in.cfg.JumpTable[op]    if operation == nil {      return nil, &ErrInvalidOpCode{opcode: op}    }    // Validate stack    if sLen := stack.len(); sLen < operation.minStack {      return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}    } else if sLen > operation.maxStack {      return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}    }    // If the operation is valid, enforce and write restrictions    if in.readOnly && in.evm.chainRules.IsByzantium {      // If the interpreter is operating in readonly mode, make sure no      // state-modifying operation is performed. The 3rd stack item      // for a call operation is the value. Transferring value from one      // account to the others means the state is modified and should also      // return with an error.      if operation.writes || (op == CALL && stack.Back(2).Sign() != 0) {        return nil, ErrWriteProtection      }    }    // Static portion of gas    cost = operation.constantGas // For tracing    if !contract.UseGas(operation.constantGas) {      return nil, ErrOutOfGas    }
    var memorySize uint64    // calculate the new memory size and expand the memory to fit    // the operation    // Memory check needs to be done prior to evaluating the dynamic gas portion,    // to detect calculation overflows    if operation.memorySize != nil {      memSize, overflow := operation.memorySize(stack)      if overflow {        return nil, ErrGasUintOverflow      }      // memory is expanded in words of 32 bytes. Gas      // is also calculated in words.      if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {        return nil, ErrGasUintOverflow      }    }    // Dynamic portion of gas    // consume the gas and return an error if not enough gas is available.    // cost is explicitly set so that the capture state defer method can get the proper cost    if operation.dynamicGas != nil {      var dynamicCost uint64      dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)      cost += dynamicCost // total cost, for debug tracing      if err != nil || !contract.UseGas(dynamicCost) {        return nil, ErrOutOfGas      }    }    if memorySize > 0 {      mem.Resize(memorySize)    }
    if in.cfg.Debug {      in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)      logged = true    }
    // execute the operation    res, err = operation.execute(&pc, in, callContext)    // if the operation clears the return data (e.g. it has returning data)    // set the last return to the result of the operation.    if operation.returns {      in.returnData = common.CopyBytes(res)    }
    switch {    case err != nil:      return nil, err    case operation.reverts:      return res, ErrExecutionReverted    case operation.halts:      return res, nil    case !operation.jumps:      pc++    }  }  return nil, nil}

  // When an error was returned by the EVM or when setting the creation code  // above we revert to the snapshot and consume any gas remaining. Additionally  // when we're in homestead this also counts for code storage gas errors.  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }    // TODO: consider clearing up unused snapshots:    //} else {    //  evm.StateDB.DiscardSnapshot(snapshot)  }  return ret, gas, err

// CallCode executes the contract associated with the addr with the given input// as parameters. It also handles any necessary value transfer required and takes// the necessary steps to create accounts and reverses the state in case of an// execution error or failed value transfer.//// CallCode differs from Call in the sense that it executes the given address'// code with the caller as context.func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // Fail if we're trying to transfer more than the available balance  // Note although it's noop to transfer X ether to caller itself. But  // if caller doesn't have enough balance, it would be an error to allow  // over-charging itself. So the check here is necessary.  if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {    return nil, gas, ErrInsufficientBalance  }  var snapshot = evm.StateDB.Snapshot()
  // It is allowed to call precompiles, even via delegatecall  if p, isPrecompile := evm.precompile(addr); isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    addrCopy := addr    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    contract := NewContract(caller, AccountRef(caller.Address()), value, gas)    contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))    ret, err = run(evm, contract, input, false)    gas = contract.Gas  }  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }  }  return ret, gas, err}

  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // Fail if we're trying to transfer more than the available balance  // Note although it's noop to transfer X ether to caller itself. But  // if caller doesn't have enough balance, it would be an error to allow  // over-charging itself. So the check here is necessary.  if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {    return nil, gas, ErrInsufficientBalance  }  var snapshot = evm.StateDB.Snapshot()

  // It is allowed to call precompiles, even via delegatecall  if p, isPrecompile := evm.precompile(addr); isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    addrCopy := addr    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    contract := NewContract(caller, AccountRef(caller.Address()), value, gas)    contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))    ret, err = run(evm, contract, input, false)    gas = contract.Gas  }  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }  }  return ret, gas, err

// RunPrecompiledContract runs and evaluates the output of a precompiled contract.// It returns// - the returned bytes,// - the _remaining_ gas,// - any error that occurredfunc RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uint64) (ret []byte, remainingGas uint64, err error) {  gasCost := p.RequiredGas(input)  if suppliedGas < gasCost {    return nil, 0, ErrOutOfGas  }  suppliedGas -= gasCost  output, err := p.Run(input)  return output, suppliedGas, err}

// run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter.func run(evm *EVM, contract *Contract, input []byte, readOnly bool) ([]byte, error) {  for _, interpreter := range evm.interpreters {    if interpreter.CanRun(contract.Code) {      if evm.interpreter != interpreter {        // Ensure that the interpreter pointer is set back        // to its current value upon return.        defer func(i Interpreter) {          evm.interpreter = i        }(evm.interpreter)        evm.interpreter = interpreter      }      return interpreter.Run(contract, input, readOnly)    }  }  return nil, errors.New("no compatible interpreter")}

  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }  }  return ret, gas, err

// DelegateCall executes the contract associated with the addr with the given input// as parameters. It reverses the state in case of an execution error.//// DelegateCall differs from CallCode in the sense that it executes the given address'// code with the caller as context and the caller is set to the caller of the caller.func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  var snapshot = evm.StateDB.Snapshot()
  // It is allowed to call precompiles, even via delegatecall  if p, isPrecompile := evm.precompile(addr); isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    addrCopy := addr    // Initialise a new contract and make initialise the delegate values    contract := NewContract(caller, AccountRef(caller.Address()), nil, gas).AsDelegate()    contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))    ret, err = run(evm, contract, input, false)    gas = contract.Gas  }  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }  }  return ret, gas, err}

// StaticCall executes the contract associated with the addr with the given input// as parameters while disallowing any modifications to the state during the call.// Opcodes that attempt to perform such modifications will result in exceptions// instead of performing the modifications.func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // We take a snapshot here. This is a bit counter-intuitive, and could probably be skipped.  // However, even a staticcall is considered a 'touch'. On mainnet, static calls were introduced  // after all empty accounts were deleted, so this is not required. However, if we omit this,  // then certain tests start failing; stRevertTest/RevertPrecompiledTouchExactOOG.json.  // We could change this, but for now it's left for legacy reasons  var snapshot = evm.StateDB.Snapshot()
  // We do an AddBalance of zero here, just in order to trigger a touch.  // This doesn't matter on Mainnet, where all empties are gone at the time of Byzantium,  // but is the correct thing to do and matters on other networks, in tests, and potential  // future scenarios  evm.StateDB.AddBalance(addr, big0)
  if p, isPrecompile := evm.precompile(addr); isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    // At this point, we use a copy of address. If we don't, the go compiler will    // leak the 'contract' to the outer scope, and make allocation for 'contract'    // even if the actual execution ends on RunPrecompiled above.    addrCopy := addr    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    contract := NewContract(caller, AccountRef(addrCopy), new(big.Int), gas)    contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))    // When an error was returned by the EVM or when setting the creation code    // above we revert to the snapshot and consume any gas remaining. Additionally    // when we're in Homestead this also counts for code storage gas errors.    ret, err = run(evm, contract, input, true)    gas = contract.Gas  }  if err != nil {    evm.StateDB.RevertToSnapshot(snapshot)    if err != ErrExecutionReverted {      gas = 0    }  }  return ret, gas, err}

// CallCode executes the contract associated with the addr with the given input// as parameters. It also handles any necessary value transfer required and takes// the necessary steps to create accounts and reverses the state in case of an// execution error or failed value transfer.//// CallCode differs from Call in the sense that it executes the given address'// code with the caller as context.func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {  if evm.vmConfig.NoRecursion && evm.depth > 0 {    return nil, gas, nil  }  // Fail if we're trying to execute above the call depth limit  if evm.depth > int(params.CallCreateDepth) {    return nil, gas, ErrDepth  }  // Fail if we're trying to transfer more than the available balance  // Note although it's noop to transfer X ether to caller itself. But  // if caller doesn't have enough balance, it would be an error to allow  // over-charging itself. So the check here is necessary.  if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {    return nil, gas, ErrInsufficientBalance  }  var snapshot = evm.StateDB.Snapshot()
  // It is allowed to call precompiles, even via delegatecall  if p, isPrecompile := evm.precompile(addr); isPrecompile {    ret, gas, err = RunPrecompiledContract(p, input, gas)  } else {    addrCopy := addr    // Initialise a new contract and set the code that is to be used by the EVM.    // The contract is a scoped environment for this execution context only.    contract := NewContract(caller, AccountRef(caller.Address()), value, gas)    contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), evm.StateDB.GetCode(addrCopy))    ret, err = run(evm, contract, input, false)    gas = contract.Gas  }    ......

func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {  var precompiles map[common.Address]PrecompiledContract  switch {  case evm.chainRules.IsBerlin:    precompiles = PrecompiledContractsBerlin  case evm.chainRules.IsIstanbul:    precompiles = PrecompiledContractsIstanbul  case evm.chainRules.IsByzantium:    precompiles = PrecompiledContractsByzantium  default:    precompiles = PrecompiledContractsHomestead  }  p, ok := precompiles[addr]  return p, ok}

// filedir:go-ethereum-1.10.2paramsconfig.go  L616// Rules wraps ChainConfig and is merely syntactic sugar or can be used for functions// that do not have or require information about the block.//// Rules is a one time interface meaning that it shouldn't be used in between transition// phases.type Rules struct {  ChainID                                                 *big.Int  IsHomestead, IsEIP150, IsEIP155, IsEIP158               bool  IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool  IsBerlin                                                bool}

// PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum// contracts used in the Frontier and Homestead releases.var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{  common.BytesToAddress([]byte{1}): &ecrecover{},  common.BytesToAddress([]byte{2}): &sha256hash{},  common.BytesToAddress([]byte{3}): &ripemd160hash{},  common.BytesToAddress([]byte{4}): &dataCopy{},}
// PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum// contracts used in the Byzantium release.var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{  common.BytesToAddress([]byte{1}): &ecrecover{},  common.BytesToAddress([]byte{2}): &sha256hash{},  common.BytesToAddress([]byte{3}): &ripemd160hash{},  common.BytesToAddress([]byte{4}): &dataCopy{},  common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false},  common.BytesToAddress([]byte{6}): &bn256AddByzantium{},  common.BytesToAddress([]byte{7}): &bn256ScalarMulByzantium{},  common.BytesToAddress([]byte{8}): &bn256PairingByzantium{},}
// PrecompiledContractsIstanbul contains the default set of pre-compiled Ethereum// contracts used in the Istanbul release.var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{  common.BytesToAddress([]byte{1}): &ecrecover{},  common.BytesToAddress([]byte{2}): &sha256hash{},  common.BytesToAddress([]byte{3}): &ripemd160hash{},  common.BytesToAddress([]byte{4}): &dataCopy{},  common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false},  common.BytesToAddress([]byte{6}): &bn256AddIstanbul{},  common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},  common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},  common.BytesToAddress([]byte{9}): &blake2F{},}
// PrecompiledContractsBerlin contains the default set of pre-compiled Ethereum// contracts used in the Berlin release.var PrecompiledContractsBerlin = map[common.Address]PrecompiledContract{  common.BytesToAddress([]byte{1}): &ecrecover{},  common.BytesToAddress([]byte{2}): &sha256hash{},  common.BytesToAddress([]byte{3}): &ripemd160hash{},  common.BytesToAddress([]byte{4}): &dataCopy{},  common.BytesToAddress([]byte{5}): &bigModExp{eip2565: true},  common.BytesToAddress([]byte{6}): &bn256AddIstanbul{},  common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},  common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},  common.BytesToAddress([]byte{9}): &blake2F{},}
// PrecompiledContractsBLS contains the set of pre-compiled Ethereum// contracts specified in EIP-2537. These are exported for testing purposes.var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{  common.BytesToAddress([]byte{10}): &bls12381G1Add{},  common.BytesToAddress([]byte{11}): &bls12381G1Mul{},  common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{},  common.BytesToAddress([]byte{13}): &bls12381G2Add{},  common.BytesToAddress([]byte{14}): &bls12381G2Mul{},  common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{},  common.BytesToAddress([]byte{16}): &bls12381Pairing{},  common.BytesToAddress([]byte{17}): &bls12381MapG1{},  common.BytesToAddress([]byte{18}): &bls12381MapG2{},}
var (  PrecompiledAddressesBerlin    []common.Address  PrecompiledAddressesIstanbul  []common.Address  PrecompiledAddressesByzantium []common.Address  PrecompiledAddressesHomestead []common.Address)

// filedir:go-ethereum-1.10.2corevminterpreter.go  L28// Config are the configuration options for the Interpretertype Config struct {  Debug                   bool   // Enables debugging  Tracer                  Tracer // Opcode logger  NoRecursion             bool   // Disables call, callcode, delegate call and create  EnablePreimageRecording bool   // Enables recording of SHA3/keccak preimages
  JumpTable [256]*operation // EVM instruction table, automatically populated if unset
  EWASMInterpreter string // External EWASM interpreter options  EVMInterpreter   string // External EVM interpreter options
  ExtraEips []int // Additional EIPS that are to be enabled}
// Interpreter is used to run Ethereum based contracts and will utilise the// passed environment to query external sources for state information.// The Interpreter will run the byte code VM based on the passed// configuration.type Interpreter interface {  // Run loops and evaluates the contract's code with the given input data and returns  // the return byte-slice and an error if one occurred.  Run(contract *Contract, input []byte, static bool) ([]byte, error)  // CanRun tells if the contract, passed as an argument, can be  // run by the current interpreter. This is meant so that the  // caller can do something like:  //  // ```golang  // for _, interpreter := range interpreters {  //   if interpreter.CanRun(contract.code) {  //     interpreter.Run(contract.code, input)  //   }  // }  // ```  CanRun([]byte) bool}

// filedir:go-ethereum-1.10.2corevminterpreter.go  L92// NewEVMInterpreter returns a new instance of the Interpreter.func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {  // We use the STOP instruction whether to see  // the jump table was initialised. If it was not  // we'll set the default jump table.  if cfg.JumpTable[STOP] == nil {    var jt JumpTable    switch {    case evm.chainRules.IsBerlin:      jt = berlinInstructionSet    case evm.chainRules.IsIstanbul:      jt = istanbulInstructionSet    case evm.chainRules.IsConstantinople:      jt = constantinopleInstructionSet    case evm.chainRules.IsByzantium:      jt = byzantiumInstructionSet    case evm.chainRules.IsEIP158:      jt = spuriousDragonInstructionSet    case evm.chainRules.IsEIP150:      jt = tangerineWhistleInstructionSet    case evm.chainRules.IsHomestead:      jt = homesteadInstructionSet    default:      jt = frontierInstructionSet    }    for i, eip := range cfg.ExtraEips {      if err := EnableEIP(eip, &jt); err != nil {        // Disable it, so caller can check if it's activated or not        cfg.ExtraEips = append(cfg.ExtraEips[:i], cfg.ExtraEips[i+1:]...)        log.Error("EIP activation failed", "eip", eip, "error", err)      }    }    cfg.JumpTable = jt  }
  return &EVMInterpreter{    evm: evm,    cfg: cfg,  }}

type (  executionFunc func(pc *uint64, interpreter *EVMInterpreter, callContext *ScopeContext) ([]byte, error)  gasFunc       func(*EVM, *Contract, *Stack, *Memory, uint64) (uint64, error) // last parameter is the requested memory size as a uint64  // memorySizeFunc returns the required size, and whether the operation overflowed a uint64  memorySizeFunc func(*Stack) (size uint64, overflow bool))
type operation struct {  // execute is the operation function  execute     executionFunc  constantGas uint64  dynamicGas  gasFunc  // minStack tells how many stack items are required  minStack int  // maxStack specifies the max length the stack can have for this operation  // to not overflow the stack.  maxStack int
  // memorySize returns the memory size required for the operation  memorySize memorySizeFunc
  halts   bool // indicates whether the operation should halt further execution  jumps   bool // indicates whether the program counter should not increment  writes  bool // determines whether this a state modifying operation  reverts bool // determines whether the operation reverts state (implicitly halts)  returns bool // determines whether the operations sets the return data content}

// JumpTable contains the EVM opcodes supported at a given fork.type JumpTable [256]*operation
// newBerlinInstructionSet returns the frontier, homestead, byzantium,// contantinople, istanbul, petersburg and berlin instructions.func newBerlinInstructionSet() JumpTable {  instructionSet := newIstanbulInstructionSet()  enable2929(&instructionSet) // Access lists for trie accesses https://eips.ethereum.org/EIPS/eip-2929  return instructionSet}
// newIstanbulInstructionSet returns the frontier, homestead, byzantium,// contantinople, istanbul and petersburg instructions.func newIstanbulInstructionSet() JumpTable {  instructionSet := newConstantinopleInstructionSet()
  enable1344(&instructionSet) // ChainID opcode - https://eips.ethereum.org/EIPS/eip-1344  enable1884(&instructionSet) // Reprice reader opcodes - https://eips.ethereum.org/EIPS/eip-1884  enable2200(&instructionSet) // Net metered SSTORE - https://eips.ethereum.org/EIPS/eip-2200
  return instructionSet}

// newConstantinopleInstructionSet returns the frontier, homestead,// byzantium and contantinople instructions.func newConstantinopleInstructionSet() JumpTable {  instructionSet := newByzantiumInstructionSet()  instructionSet[SHL] = &operation{    execute:     opSHL,    constantGas: GasFastestStep,    minStack:    minStack(2, 1),    maxStack:    maxStack(2, 1),  }  instructionSet[SHR] = &operation{    execute:     opSHR,    constantGas: GasFastestStep,    minStack:    minStack(2, 1),    maxStack:    maxStack(2, 1),  }  instructionSet[SAR] = &operation{    execute:     opSAR,    constantGas: GasFastestStep,    minStack:    minStack(2, 1),    maxStack:    maxStack(2, 1),  }  instructionSet[EXTCODEHASH] = &operation{    execute:     opExtCodeHash,    constantGas: params.ExtcodeHashGasConstantinople,    minStack:    minStack(1, 1),    maxStack:    maxStack(1, 1),  }  instructionSet[CREATE2] = &operation{    execute:     opCreate2,    constantGas: params.Create2Gas,    dynamicGas:  gasCreate2,    minStack:    minStack(4, 1),    maxStack:    maxStack(4, 1),    memorySize:  memoryCreate2,    writes:      true,    returns:     true,  }  return instructionSet}......

func opAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {    x, y := scope.Stack.pop(), scope.Stack.peek()    y.Add(&x, y)    return nil, nil}
func opSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {    x, y := scope.Stack.pop(), scope.Stack.peek()    y.Sub(&x, y)    return nil, nil}
func opMul(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {    x, y := scope.Stack.pop(), scope.Stack.peek()    y.Mul(&x, y)    return nil, nil}

// filedir: go-ethereum-1.10.2corevminterpreter.go L133// Run loops and evaluates the contract's code with the given input data and returns// the return byte-slice and an error if one occurred.//// It's important to note that any errors returned by the interpreter should be// considered a revert-and-consume-all-gas operation except for// ErrExecutionReverted which means revert-and-keep-gas-left.func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error) {
  // Increment the call depth which is restricted to 1024  in.evm.depth++  defer func() { in.evm.depth-- }()
  // Make sure the readOnly is only set if we aren't in readOnly yet.  // This makes also sure that the readOnly flag isn't removed for child calls.  if readOnly && !in.readOnly {    in.readOnly = true    defer func() { in.readOnly = false }()  }
  // Reset the previous call's return data. It's unimportant to preserve the old buffer  // as every returning call will return new data anyway.  in.returnData = nil
  // Don't bother with the execution if there's no code.  if len(contract.Code) == 0 {    return nil, nil  }
  var (    op          OpCode        // current opcode    mem         = NewMemory() // bound memory    stack       = newstack()  // local stack    callContext = &ScopeContext{      Memory:   mem,      Stack:    stack,      Contract: contract,    }    // For optimisation reason we're using uint64 as the program counter.    // It's theoretically possible to go above 2^64. The YP defines the PC    // to be uint256. Practically much less so feasible.    pc   = uint64(0) // program counter    cost uint64    // copies used by tracer    pcCopy  uint64 // needed for the deferred Tracer    gasCopy uint64 // for Tracer to log gas remaining before execution    logged  bool   // deferred Tracer should ignore already logged steps    res     []byte // result of the opcode execution function  )  // Don't move this deferrred function, it's placed before the capturestate-deferred method,  // so that it get's executed _after_: the capturestate needs the stacks before  // they are returned to the pools  defer func() {    returnStack(stack)  }()  contract.Input = input
  if in.cfg.Debug {    defer func() {      if err != nil {        if !logged {          in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)        } else {          in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, callContext, in.evm.depth, err)        }      }    }()  }  // The Interpreter main run loop (contextual). This loop runs until either an  // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during  // the execution of one of the operations or until the done flag is set by the  // parent context.  steps := 0  for {    steps++    if steps%1000 == 0 && atomic.LoadInt32(&in.evm.abort) != 0 {      break    }    if in.cfg.Debug {      // Capture pre-execution values for tracing.      logged, pcCopy, gasCopy = false, pc, contract.Gas    }
    // Get the operation from the jump table and validate the stack to ensure there are    // enough stack items available to perform the operation.    op = contract.GetOp(pc)    operation := in.cfg.JumpTable[op]    if operation == nil {      return nil, &ErrInvalidOpCode{opcode: op}    }    // Validate stack    if sLen := stack.len(); sLen < operation.minStack {      return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}    } else if sLen > operation.maxStack {      return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}    }    // If the operation is valid, enforce and write restrictions    if in.readOnly && in.evm.chainRules.IsByzantium {      // If the interpreter is operating in readonly mode, make sure no      // state-modifying operation is performed. The 3rd stack item      // for a call operation is the value. Transferring value from one      // account to the others means the state is modified and should also      // return with an error.      if operation.writes || (op == CALL && stack.Back(2).Sign() != 0) {        return nil, ErrWriteProtection      }    }    // Static portion of gas    cost = operation.constantGas // For tracing    if !contract.UseGas(operation.constantGas) {      return nil, ErrOutOfGas    }
    var memorySize uint64    // calculate the new memory size and expand the memory to fit    // the operation    // Memory check needs to be done prior to evaluating the dynamic gas portion,    // to detect calculation overflows    if operation.memorySize != nil {      memSize, overflow := operation.memorySize(stack)      if overflow {        return nil, ErrGasUintOverflow      }      // memory is expanded in words of 32 bytes. Gas      // is also calculated in words.      if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {        return nil, ErrGasUintOverflow      }    }    // Dynamic portion of gas    // consume the gas and return an error if not enough gas is available.    // cost is explicitly set so that the capture state defer method can get the proper cost    if operation.dynamicGas != nil {      var dynamicCost uint64      dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)      cost += dynamicCost // total cost, for debug tracing      if err != nil || !contract.UseGas(dynamicCost) {        return nil, ErrOutOfGas      }    }    if memorySize > 0 {      mem.Resize(memorySize)    }
    if in.cfg.Debug {      in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)      logged = true    }
    // execute the operation    res, err = operation.execute(&pc, in, callContext)    // if the operation clears the return data (e.g. it has returning data)    // set the last return to the result of the operation.    if operation.returns {      in.returnData = common.CopyBytes(res)    }
    switch {    case err != nil:      return nil, err    case operation.reverts:      return res, ErrExecutionReverted    case operation.halts:      return res, nil    case !operation.jumps:      pc++    }  }  return nil, nil}

  // Increment the call depth which is restricted to 1024  in.evm.depth++  defer func() { in.evm.depth-- }()

  // Make sure the readOnly is only set if we aren't in readOnly yet.  // This makes also sure that the readOnly flag isn't removed for child calls.  if readOnly && !in.readOnly {    in.readOnly = true    defer func() { in.readOnly = false }()  }
  // Reset the previous call's return data. It's unimportant to preserve the old buffer  // as every returning call will return new data anyway.  in.returnData = nil
  // Don't bother with the execution if there's no code.  if len(contract.Code) == 0 {    return nil, nil  }
  var (    op          OpCode        // current opcode    mem         = NewMemory() // bound memory    stack       = newstack()  // local stack    callContext = &ScopeContext{      Memory:   mem,      Stack:    stack,      Contract: contract,    }    // For optimisation reason we're using uint64 as the program counter.    // It's theoretically possible to go above 2^64. The YP defines the PC    // to be uint256. Practically much less so feasible.    pc   = uint64(0) // program counter    cost uint64    // copies used by tracer    pcCopy  uint64 // needed for the deferred Tracer    gasCopy uint64 // for Tracer to log gas remaining before execution    logged  bool   // deferred Tracer should ignore already logged steps    res     []byte // result of the opcode execution function  )  // Don't move this deferrred function, it's placed before the capturestate-deferred method,  // so that it get's executed _after_: the capturestate needs the stacks before  // they are returned to the pools  defer func() {    returnStack(stack)  }()  contract.Input = input
  if in.cfg.Debug {    defer func() {      if err != nil {        if !logged {          in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)        } else {          in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, callContext, in.evm.depth, err)        }      }    }()  }

  steps := 0  for {    steps++    if steps%1000 == 0 && atomic.LoadInt32(&in.evm.abort) != 0 {      break    }    if in.cfg.Debug {      // Capture pre-execution values for tracing.      logged, pcCopy, gasCopy = false, pc, contract.Gas    }

    // Get the operation from the jump table and validate the stack to ensure there are    // enough stack items available to perform the operation.    op = contract.GetOp(pc)    operation := in.cfg.JumpTable[op]    if operation == nil {      return nil, &ErrInvalidOpCode{opcode: op}    }    // Validate stack    if sLen := stack.len(); sLen < operation.minStack {      return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}    } else if sLen > operation.maxStack {      return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}    }    // If the operation is valid, enforce and write restrictions    if in.readOnly && in.evm.chainRules.IsByzantium {      // If the interpreter is operating in readonly mode, make sure no      // state-modifying operation is performed. The 3rd stack item      // for a call operation is the value. Transferring value from one      // account to the others means the state is modified and should also      // return with an error.      if operation.writes || (op == CALL && stack.Back(2).Sign() != 0) {        return nil, ErrWriteProtection      }    }    // Static portion of gas    cost = operation.constantGas // For tracing    if !contract.UseGas(operation.constantGas) {      return nil, ErrOutOfGas    }

    var memorySize uint64    // calculate the new memory size and expand the memory to fit    // the operation    // Memory check needs to be done prior to evaluating the dynamic gas portion,    // to detect calculation overflows    if operation.memorySize != nil {      memSize, overflow := operation.memorySize(stack)      if overflow {        return nil, ErrGasUintOverflow      }      // memory is expanded in words of 32 bytes. Gas      // is also calculated in words.      if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {        return nil, ErrGasUintOverflow      }    }

    // Dynamic portion of gas    // consume the gas and return an error if not enough gas is available.    // cost is explicitly set so that the capture state defer method can get the proper cost    if operation.dynamicGas != nil {      var dynamicCost uint64      dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)      cost += dynamicCost // total cost, for debug tracing      if err != nil || !contract.UseGas(dynamicCost) {        return nil, ErrOutOfGas      }    }    if memorySize > 0 {      mem.Resize(memorySize)    }
    if in.cfg.Debug {      in.cfg.Tracer.CaptureState(in.evm, pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)      logged = true    }

    // execute the operation    res, err = operation.execute(&pc, in, callContext)    // if the operation clears the return data (e.g. it has returning data)    // set the last return to the result of the operation.    if operation.returns {      in.returnData = common.CopyBytes(res)    }
    switch {    case err != nil:      return nil, err    case operation.reverts:      return res, ErrExecutionReverted    case operation.halts:      return res, nil    case !operation.jumps:      pc++    }  }  return nil, nil

// OpCode is an EVM opcodetype OpCode byte
// IsPush specifies if an opcode is a PUSH opcode.func (op OpCode) IsPush() bool {  switch op {  case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:    return true  }  return false}
// IsStaticJump specifies if an opcode is JUMP.func (op OpCode) IsStaticJump() bool {  return op == JUMP}
// 0x0 range - arithmetic ops.const (  STOP OpCode = iota  ADD  MUL  SUB  DIV  SDIV  MOD  SMOD  ADDMOD  MULMOD  EXP  SIGNEXTEND)
// 0x10 range - comparison ops.const (  LT OpCode = iota + 0x10  GT  SLT  SGT  EQ  ISZERO  AND  OR  XOR  NOT  BYTE  SHL  SHR  SAR
  SHA3 OpCode = 0x20)
// 0x30 range - closure state.const (  ADDRESS OpCode = 0x30 + iota  BALANCE  ORIGIN  CALLER  CALLVALUE  CALLDATALOAD  CALLDATASIZE  CALLDATACOPY  CODESIZE  CODECOPY  GASPRICE  EXTCODESIZE  EXTCODECOPY  RETURNDATASIZE  RETURNDATACOPY  EXTCODEHASH)......

// Stack is an object for basic stack operations. Items popped to the stack are// expected to be changed and modified. stack does not take care of adding newly// initialised objects.type Stack struct {  data []uint256.Int}func newstack() *Stack {  return stackPool.Get().(*Stack)}

func (st *Stack) push(d *uint256.Int) {  // NOTE push limit (1024) is checked in baseCheck  st.data = append(st.data, *d)}func (st *Stack) pushN(ds ...uint256.Int) {  // FIXME: Is there a way to pass args by pointers.  st.data = append(st.data, ds...)}

func (st *Stack) pop() (ret uint256.Int) {  ret = st.data[len(st.data)-1]  st.data = st.data[:len(st.data)-1]  return}

func (st *Stack) swap(n int) {  st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n]}

func (st *Stack) dup(n int) {  st.push(&st.data[st.len()-n])}

func (st *Stack) peek() *uint256.Int {  return &st.data[st.len()-1]}

// Back returns the n'th item in stackfunc (st *Stack) Back(n int) *uint256.Int {  return &st.data[st.len()-n-1]}

func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {  var (    gas            uint64    transfersValue = !stack.Back(2).IsZero()    address        = common.Address(stack.Back(1).Bytes20())  )  if evm.chainRules.IsEIP158 {    if transfersValue && evm.StateDB.Empty(address) {      gas += params.CallNewAccountGas    }  } else if !evm.StateDB.Exist(address) {    gas += params.CallNewAccountGas  }  if transfersValue {    gas += params.CallValueTransferGas  }  memoryGas, err := memoryGasCost(mem, memorySize)  if err != nil {    return 0, err  }  var overflow bool  if gas, overflow = math.SafeAdd(gas, memoryGas); overflow {    return 0, ErrGasUintOverflow  }
  evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))  if err != nil {    return 0, err  }  if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {    return 0, ErrGasUintOverflow  }  return gas, nil}
func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {  memoryGas, err := memoryGasCost(mem, memorySize)  if err != nil {    return 0, err  }  var (    gas      uint64    overflow bool  )  if stack.Back(2).Sign() != 0 {    gas += params.CallValueTransferGas  }  if gas, overflow = math.SafeAdd(gas, memoryGas); overflow {    return 0, ErrGasUintOverflow  }  evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))  if err != nil {    return 0, err  }  if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {    return 0, ErrGasUintOverflow  }  return gas, nil}
func gasDelegateCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {  gas, err := memoryGasCost(mem, memorySize)  if err != nil {    return 0, err  }  evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))  if err != nil {    return 0, err  }  var overflow bool  if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {    return 0, ErrGasUintOverflow  }  return gas, nil}
func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {  gas, err := memoryGasCost(mem, memorySize)  if err != nil {    return 0, err  }  evm.callGasTemp, err = callGas(evm.chainRules.IsEIP150, contract.Gas, gas, stack.Back(0))  if err != nil {    return 0, err  }  var overflow bool  if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {    return 0, ErrGasUintOverflow  }  return gas, nil}