core, params: implement EIP-3529

core/blockchain_test.go

@@ -3102,7 +3102,8 @@ func TestEIP2718Transition(t *testing.T) {
  block := chain.GetBlockByNumber(1)
 
  // Expected gas is intrinsic + 2 * pc + hot load + cold load, since only one load is in the access list
- expected := params.TxGas + params.TxAccessListAddressGas + params.TxAccessListStorageKeyGas + vm.GasQuickStep*2 + vm.WarmStorageReadCostEIP2929 + vm.ColdSloadCostEIP2929
+ expected := params.TxGas + params.TxAccessListAddressGas + params.TxAccessListStorageKeyGas +
+ vm.GasQuickStep*2 + params.WarmStorageReadCostEIP2929 + params.ColdSloadCostEIP2929
  if block.GasUsed() != expected {
  t.Fatalf("incorrect amount of gas spent: expected %d, got %d", expected, block.GasUsed())
 

core/state_transition.go

@@ -241,6 +241,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
  sender := vm.AccountRef(msg.From())
  homestead := st.evm.ChainConfig().IsHomestead(st.evm.Context.BlockNumber)
  istanbul := st.evm.ChainConfig().IsIstanbul(st.evm.Context.BlockNumber)
+ eip3529 := st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber)
  contractCreation := msg.To() == nil
 
  // Check clauses 4-5, subtract intrinsic gas if everything is correct
@@ -273,7 +274,13 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
  st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
  ret, st.gas, vmerr = st.evm.Call(sender, st.to(), st.data, st.gas, st.value)
  }
- st.refundGas()
+ if !eip3529 {
+ // Before EIP-3529: refunds were capped to gasUsed / 2
+ st.refundGas(params.RefundQuotient)
+ } else {
+ // After EIP-3529: refunds are capped to gasUsed / 5
+ st.refundGas(params.RefundQuotientEIP3529)
+ }
  st.state.AddBalance(st.evm.Context.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))
 
  return &ExecutionResult{
@@ -283,9 +290,9 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
  }, nil
 }
 
-func (st *StateTransition) refundGas() {
- // Apply refund counter, capped to half of the used gas.
- refund := st.gasUsed() / 2
+func (st *StateTransition) refundGas(refundQuotient uint64) {
+ // Apply refund counter, capped to a refund quotient
+ refund := st.gasUsed() / refundQuotient
  if refund > st.state.GetRefund() {
  refund = st.state.GetRefund()
  }

core/vm/eips.go

@@ -25,6 +25,7 @@ import (
 )
 
 var activators = map[int]func(*JumpTable){
+ 3529: enable3529,
  2929: enable2929,
  2200: enable2200,
  1884: enable1884,
@@ -115,32 +116,41 @@ func enable2929(jt *JumpTable) {
  jt[SLOAD].constantGas = 0
  jt[SLOAD].dynamicGas = gasSLoadEIP2929
 
- jt[EXTCODECOPY].constantGas = WarmStorageReadCostEIP2929
+ jt[EXTCODECOPY].constantGas = params.WarmStorageReadCostEIP2929
  jt[EXTCODECOPY].dynamicGas = gasExtCodeCopyEIP2929
 
- jt[EXTCODESIZE].constantGas = WarmStorageReadCostEIP2929
+ jt[EXTCODESIZE].constantGas = params.WarmStorageReadCostEIP2929
  jt[EXTCODESIZE].dynamicGas = gasEip2929AccountCheck
 
- jt[EXTCODEHASH].constantGas = WarmStorageReadCostEIP2929
+ jt[EXTCODEHASH].constantGas = params.WarmStorageReadCostEIP2929
  jt[EXTCODEHASH].dynamicGas = gasEip2929AccountCheck
 
- jt[BALANCE].constantGas = WarmStorageReadCostEIP2929
+ jt[BALANCE].constantGas = params.WarmStorageReadCostEIP2929
  jt[BALANCE].dynamicGas = gasEip2929AccountCheck
 
- jt[CALL].constantGas = WarmStorageReadCostEIP2929
+ jt[CALL].constantGas = params.WarmStorageReadCostEIP2929
  jt[CALL].dynamicGas = gasCallEIP2929
 
- jt[CALLCODE].constantGas = WarmStorageReadCostEIP2929
+ jt[CALLCODE].constantGas = params.WarmStorageReadCostEIP2929
  jt[CALLCODE].dynamicGas = gasCallCodeEIP2929
 
- jt[STATICCALL].constantGas = WarmStorageReadCostEIP2929
+ jt[STATICCALL].constantGas = params.WarmStorageReadCostEIP2929
  jt[STATICCALL].dynamicGas = gasStaticCallEIP2929
 
- jt[DELEGATECALL].constantGas = WarmStorageReadCostEIP2929
+ jt[DELEGATECALL].constantGas = params.WarmStorageReadCostEIP2929
  jt[DELEGATECALL].dynamicGas = gasDelegateCallEIP2929
 
  // This was previously part of the dynamic cost, but we're using it as a constantGas
  // factor here
  jt[SELFDESTRUCT].constantGas = params.SelfdestructGasEIP150
  jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP2929
 }
+
+// enable3529 enabled "EIP-3529: Reduction in refunds":
+// - Removes refunds for selfdestructs
+// - Reduces refunds for SSTORE
+// - Reduces max refunds to 20% gas
+func enable3529(jt *JumpTable) {
+ jt[SSTORE].dynamicGas = gasSStoreEIP3529
+ jt[SELFDESTRUCT].dynamicGas = gasSelfdestructEIP3529
+}

core/vm/interpreter.go

@@ -98,6 +98,8 @@ func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {
  if cfg.JumpTable[STOP] == nil {
  var jt JumpTable
  switch {
+ case evm.chainRules.IsLondon:
+ jt = londonInstructionSet
  case evm.chainRules.IsBerlin:
  jt = berlinInstructionSet
  case evm.chainRules.IsIstanbul:

core/vm/jump_table.go

@@ -57,11 +57,20 @@ var (
  constantinopleInstructionSet = newConstantinopleInstructionSet()
  istanbulInstructionSet = newIstanbulInstructionSet()
  berlinInstructionSet = newBerlinInstructionSet()
+ londonInstructionSet = newLondonInstructionSet()
 )
 
 // JumpTable contains the EVM opcodes supported at a given fork.
 type JumpTable [256]*operation
 
+// newLondonInstructionSet returns the frontier, homestead, byzantium,
+// contantinople, istanbul, petersburg, berlin and london instructions.
+func newLondonInstructionSet() JumpTable {
+ instructionSet := newBerlinInstructionSet()
+ enable3529(&instructionSet) // EIP-3529: Reduction in refunds https://eips.ethereum.org/EIPS/eip-3529
+ return instructionSet
+}
+
 // newBerlinInstructionSet returns the frontier, homestead, byzantium,
 // contantinople, istanbul, petersburg and berlin instructions.
 func newBerlinInstructionSet() JumpTable {

core/vm/operations_acl.go

@@ -24,91 +24,75 @@ import (
  "github.com/ethereum/go-ethereum/params"
 )
 
-const (
- ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
- ColdSloadCostEIP2929 = uint64(2100) // COLD_SLOAD_COST
- WarmStorageReadCostEIP2929 = uint64(100) // WARM_STORAGE_READ_COST
-)
-
-// gasSStoreEIP2929 implements gas cost for SSTORE according to EIP-2929
-//
-// When calling SSTORE, check if the (address, storage_key) pair is in accessed_storage_keys.
-// If it is not, charge an additional COLD_SLOAD_COST gas, and add the pair to accessed_storage_keys.
-// Additionally, modify the parameters defined in EIP 2200 as follows:
-//
-// Parameter Old value New value
-// SLOAD_GAS 800 = WARM_STORAGE_READ_COST
-// SSTORE_RESET_GAS 5000 5000 - COLD_SLOAD_COST
-//
-//The other parameters defined in EIP 2200 are unchanged.
-// see gasSStoreEIP2200(...) in core/vm/gas_table.go for more info about how EIP 2200 is specified
-func gasSStoreEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
- // If we fail the minimum gas availability invariant, fail (0)
- if contract.Gas <= params.SstoreSentryGasEIP2200 {
- return 0, errors.New("not enough gas for reentrancy sentry")
- }
- // Gas sentry honoured, do the actual gas calculation based on the stored value
- var (
- y, x = stack.Back(1), stack.peek()
- slot = common.Hash(x.Bytes32())
- current = evm.StateDB.GetState(contract.Address(), slot)
- cost = uint64(0)
- )
- // Check slot presence in the access list
- if addrPresent, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot); !slotPresent {
- cost = ColdSloadCostEIP2929
- // If the caller cannot afford the cost, this change will be rolled back
- evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
- if !addrPresent {
- // Once we're done with YOLOv2 and schedule this for mainnet, might
- // be good to remove this panic here, which is just really a
- // canary to have during testing
- panic("impossible case: address was not present in access list during sstore op")
+func makeGasSStoreFunc(clearingRefund uint64) gasFunc {
+ return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+ // If we fail the minimum gas availability invariant, fail (0)
+ if contract.Gas <= params.SstoreSentryGasEIP2200 {
+ return 0, errors.New("not enough gas for reentrancy sentry")
  }
- }
- value := common.Hash(y.Bytes32())
+ // Gas sentry honoured, do the actual gas calculation based on the stored value
+ var (
+ y, x = stack.Back(1), stack.peek()
+ slot = common.Hash(x.Bytes32())
+ current = evm.StateDB.GetState(contract.Address(), slot)
+ cost = uint64(0)
+ )
+ // Check slot presence in the access list
+ if addrPresent, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot); !slotPresent {
+ cost = params.ColdSloadCostEIP2929
+ // If the caller cannot afford the cost, this change will be rolled back
+ evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
+ if !addrPresent {
+ // Once we're done with YOLOv2 and schedule this for mainnet, might
+ // be good to remove this panic here, which is just really a
+ // canary to have during testing
+ panic("impossible case: address was not present in access list during sstore op")
+ }
+ }
+ value := common.Hash(y.Bytes32())
 
- if current == value { // noop (1)
- // EIP 2200 original clause:
- // return params.SloadGasEIP2200, nil
- return cost + WarmStorageReadCostEIP2929, nil // SLOAD_GAS
- }
- original := evm.StateDB.GetCommittedState(contract.Address(), x.Bytes32())
- if original == current {
- if original == (common.Hash{}) { // create slot (2.1.1)
- return cost + params.SstoreSetGasEIP2200, nil
+ if current == value { // noop (1)
+ // EIP 2200 original clause:
+ // return params.SloadGasEIP2200, nil
+ return cost + params.WarmStorageReadCostEIP2929, nil // SLOAD_GAS
  }
- if value == (common.Hash{}) { // delete slot (2.1.2b)
- evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200)
+ original := evm.StateDB.GetCommittedState(contract.Address(), x.Bytes32())
+ if original == current {
+ if original == (common.Hash{}) { // create slot (2.1.1)
+ return cost + params.SstoreSetGasEIP2200, nil
+ }
+ if value == (common.Hash{}) { // delete slot (2.1.2b)
+ evm.StateDB.AddRefund(clearingRefund)
+ }
+ // EIP-2200 original clause:
+ // return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2)
+ return cost + (params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929), nil // write existing slot (2.1.2)
  }
- // EIP-2200 original clause:
- // return params.SstoreResetGasEIP2200, nil // write existing slot (2.1.2)
- return cost + (params.SstoreResetGasEIP2200 - ColdSloadCostEIP2929), nil // write existing slot (2.1.2)
- }
- if original != (common.Hash{}) {
- if current == (common.Hash{}) { // recreate slot (2.2.1.1)
- evm.StateDB.SubRefund(params.SstoreClearsScheduleRefundEIP2200)
- } else if value == (common.Hash{}) { // delete slot (2.2.1.2)
- evm.StateDB.AddRefund(params.SstoreClearsScheduleRefundEIP2200)
+ if original != (common.Hash{}) {
+ if current == (common.Hash{}) { // recreate slot (2.2.1.1)
+ evm.StateDB.SubRefund(clearingRefund)
+ } else if value == (common.Hash{}) { // delete slot (2.2.1.2)
+ evm.StateDB.AddRefund(clearingRefund)
+ }
  }
- }
- if original == value {
- if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
- // EIP 2200 Original clause:
- //evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.SloadGasEIP2200)
- evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - WarmStorageReadCostEIP2929)
- } else { // reset to original existing slot (2.2.2.2)
- // EIP 2200 Original clause:
- // evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200)
- // - SSTORE_RESET_GAS redefined as (5000 - COLD_SLOAD_COST)
- // - SLOAD_GAS redefined as WARM_STORAGE_READ_COST
- // Final: (5000 - COLD_SLOAD_COST) - WARM_STORAGE_READ_COST
- evm.StateDB.AddRefund((params.SstoreResetGasEIP2200 - ColdSloadCostEIP2929) - WarmStorageReadCostEIP2929)
+  if original == value {
+  if original == (common.Hash{}) { // reset to original inexistent slot (2.2.2.1)
+  // EIP 2200 Original clause:
+  //evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.SloadGasEIP2200)
+  evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - params.WarmStorageReadCostEIP2929)
+ } else { // reset to original existing slot (2.2.2.2)
+  // EIP 2200 Original clause:
+  // evm.StateDB.AddRefund(params.SstoreResetGasEIP2200 - params.SloadGasEIP2200)
+  // - SSTORE_RESET_GAS redefined as (5000 - COLD_SLOAD_COST)
+  // - SLOAD_GAS redefined as WARM_STORAGE_READ_COST
+  // Final: (5000 - COLD_SLOAD_COST) - WARM_STORAGE_READ_COST
+  evm.StateDB.AddRefund((params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929) - params.WarmStorageReadCostEIP2929)
+ }
  }
+ // EIP-2200 original clause:
+ //return params.SloadGasEIP2200, nil // dirty update (2.2)
+ return cost + params.WarmStorageReadCostEIP2929, nil // dirty update (2.2)
  }
- // EIP-2200 original clause:
- //return params.SloadGasEIP2200, nil // dirty update (2.2)
- return cost + WarmStorageReadCostEIP2929, nil // dirty update (2.2)
 }
 
 // gasSLoadEIP2929 calculates dynamic gas for SLOAD according to EIP-2929
@@ -124,9 +108,9 @@ func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me
  // If the caller cannot afford the cost, this change will be rolled back
  // If he does afford it, we can skip checking the same thing later on, during execution
  evm.StateDB.AddSlotToAccessList(contract.Address(), slot)
- return ColdSloadCostEIP2929, nil
+ return params.ColdSloadCostEIP2929, nil
  }
- return WarmStorageReadCostEIP2929, nil
+ return params.WarmStorageReadCostEIP2929, nil
 }
 
 // gasExtCodeCopyEIP2929 implements extcodecopy according to EIP-2929
@@ -146,7 +130,7 @@ func gasExtCodeCopyEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memo
  evm.StateDB.AddAddressToAccessList(addr)
  var overflow bool
  // We charge (cold-warm), since 'warm' is already charged as constantGas
- if gas, overflow = math.SafeAdd(gas, ColdAccountAccessCostEIP2929-WarmStorageReadCostEIP2929); overflow {
+ if gas, overflow = math.SafeAdd(gas, params.ColdAccountAccessCostEIP2929-params.WarmStorageReadCostEIP2929); overflow {
  return 0, ErrGasUintOverflow
  }
  return gas, nil
@@ -168,7 +152,7 @@ func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Mem
  // If the caller cannot afford the cost, this change will be rolled back
  evm.StateDB.AddAddressToAccessList(addr)
  // The warm storage read cost is already charged as constantGas
- return ColdAccountAccessCostEIP2929 - WarmStorageReadCostEIP2929, nil
+ return params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929, nil
  }
  return 0, nil
 }
@@ -180,7 +164,7 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc) gasFunc {
  warmAccess := evm.StateDB.AddressInAccessList(addr)
  // The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant cost, so
  // the cost to charge for cold access, if any, is Cold - Warm
- coldCost := ColdAccountAccessCostEIP2929 - WarmStorageReadCostEIP2929
+ coldCost := params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP2929
  if !warmAccess {
  evm.StateDB.AddAddressToAccessList(addr)
  // Charge the remaining difference here already, to correctly calculate available
@@ -212,25 +196,49 @@ var (
  gasDelegateCallEIP2929 = makeCallVariantGasCallEIP2929(gasDelegateCall)
  gasStaticCallEIP2929 = makeCallVariantGasCallEIP2929(gasStaticCall)
  gasCallCodeEIP2929 = makeCallVariantGasCallEIP2929(gasCallCode)
+ gasSelfdestructEIP2929 = makeSelfdestructGasFn(true)
+ // gasSelfdestructEIP3529 implements the changes in EIP-2539 (no refunds)
+ gasSelfdestructEIP3529 = makeSelfdestructGasFn(false)
+
+ // gasSStoreEIP2929 implements gas cost for SSTORE according to EIP-2929
+ //
+ // When calling SSTORE, check if the (address, storage_key) pair is in accessed_storage_keys.
+ // If it is not, charge an additional COLD_SLOAD_COST gas, and add the pair to accessed_storage_keys.
+ // Additionally, modify the parameters defined in EIP 2200 as follows:
+ //
+ // Parameter Old value New value
+ // SLOAD_GAS 800 = WARM_STORAGE_READ_COST
+ // SSTORE_RESET_GAS 5000 5000 - COLD_SLOAD_COST
+ //
+ //The other parameters defined in EIP 2200 are unchanged.
+ // see gasSStoreEIP2200(...) in core/vm/gas_table.go for more info about how EIP 2200 is specified
+ gasSStoreEIP2929 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP2200)
+
+ // gasSStoreEIP2539 implements gas cost for SSTORE according to EPI-2539
+ // Replace `SSTORE_CLEARS_SCHEDULE` with `SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST` (4,800)
+ gasSStoreEIP3529 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529)
 )
 
-func gasSelfdestructEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
- var (
- gas uint64
- address = common.Address(stack.peek().Bytes20())
- )
- if !evm.StateDB.AddressInAccessList(address) {
- // If the caller cannot afford the cost, this change will be rolled back
- evm.StateDB.AddAddressToAccessList(address)
- gas = ColdAccountAccessCostEIP2929
- }
- // if empty and transfers value
- if evm.StateDB.Empty(address) && evm.StateDB.GetBalance(contract.Address()).Sign() != 0 {
- gas += params.CreateBySelfdestructGas
- }
- if !evm.StateDB.HasSuicided(contract.Address()) {
- evm.StateDB.AddRefund(params.SelfdestructRefundGas)
+// makeSelfdestructGasFn can create the selfdestruct dynamic gas function for EIP-2929 and EIP-2539
+func makeSelfdestructGasFn(refundsEnabled bool) gasFunc {
+ gasFunc := func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+ var (
+ gas uint64
+ address = common.Address(stack.peek().Bytes20())
+ )
+ if !evm.StateDB.AddressInAccessList(address) {
+ // If the caller cannot afford the cost, this change will be rolled back
+ evm.StateDB.AddAddressToAccessList(address)
+ gas = params.ColdAccountAccessCostEIP2929
+ }
+ // if empty and transfers value
+ if evm.StateDB.Empty(address) && evm.StateDB.GetBalance(contract.Address()).Sign() != 0 {
+ gas += params.CreateBySelfdestructGas
+ }
+ if refundsEnabled && !evm.StateDB.HasSuicided(contract.Address()) {
+ evm.StateDB.AddRefund(params.SelfdestructRefundGas)
+ }
+ return gas, nil
  }
- return gas, nil
-
+ return gasFunc
 }