diff --git a/core/vm/eips.go b/core/vm/eips.go index 3252c1adc4..6dc145668c 100644 --- a/core/vm/eips.go +++ b/core/vm/eips.go @@ -569,7 +569,7 @@ func enable7904(jt *JumpTable) { jt[SMOD].constantGas = GasBaseCost jt[ADDMOD].constantGas = GasFastCost jt[MULMOD].constantGas = GasMidCost - //jt[EXP].constantGas = GasMidCost + jt[EXP].dynamicGas = gasExpEIP7904 jt[SIGNEXTEND].constantGas = GasBaseCost jt[LT].constantGas = GasBaseCost jt[GT].constantGas = GasBaseCost @@ -586,22 +586,34 @@ func enable7904(jt *JumpTable) { jt[SHR].constantGas = GasBaseCost jt[SAR].constantGas = GasBaseCost jt[ADDRESS].constantGas = GasBaseCost - //jt[BALANCE].constantGas = GasBaseCost + + jt[BALANCE].constantGas = params.WarmStorageReadCostEIP7904 + jt[BALANCE].dynamicGas = gasEip7904AccountCheck jt[ORIGIN].constantGas = GasBaseCost jt[CALLER].constantGas = GasBaseCost jt[CALLVALUE].constantGas = GasBaseCost jt[CALLDATALOAD].constantGas = GasBaseCost jt[CALLDATASIZE].constantGas = GasBaseCost - //jt[CALLDATACOPY].constantGas = GasBaseCost + + jt[CALLDATACOPY].constantGas = GasBaseCost + jt[CALLDATACOPY].dynamicGas = gasCallDataCopy7904 + jt[CODESIZE].constantGas = GasBaseCost - //jt[CODECOPY].constantGas = GasBaseCost + + jt[CODECOPY].constantGas = GasBaseCost + jt[CODECOPY].dynamicGas = gasCodeCopy7904 + jt[GASPRICE].constantGas = GasBaseCost - //jt[EXTCODESIZE].constantGas = GasBaseCost - //jt[EXTCODECOPY].constantGas = GasBaseCost + jt[EXTCODESIZE].dynamicGas = gasEip7904AccountCheck + + jt[EXTCODECOPY].dynamicGas = gasExtCodeCopy7904 + jt[RETURNDATASIZE].constantGas = GasBaseCost - //jt[RETURNDATACOPY].constantGas = GasBaseCost - //jt[EXTCODEHASH].constantGas = GasBaseCost + jt[RETURNDATACOPY].dynamicGas = gasReturnDataCopy7904 + + jt[EXTCODEHASH].dynamicGas = gasEip7904AccountCheck + jt[COINBASE].constantGas = GasBaseCost jt[TIMESTAMP].constantGas = GasBaseCost jt[NUMBER].constantGas = GasBaseCost @@ -610,8 +622,8 @@ func enable7904(jt *JumpTable) { jt[SELFBALANCE].constantGas = GasBaseCost jt[POP].constantGas = GasBaseCost jt[MLOAD].constantGas = GasBaseCost - //jt[MSTORE].constantGas = GasBaseCost - //jt[MSTORE8].constantGas = GasBaseCost + jt[MSTORE].constantGas = GasBaseCost + jt[MSTORE8].constantGas = GasBaseCost jt[JUMP].constantGas = GasBaseCost jt[JUMPI].constantGas = GasBaseCost jt[PC].constantGas = GasBaseCost @@ -619,7 +631,9 @@ func enable7904(jt *JumpTable) { jt[TLOAD].constantGas = GasWarmStorageCost jt[TSTORE].constantGas = GasWarmStorageCost jt[JUMPDEST].constantGas = GasBaseCost - //jt[MCOPY].constantGas = GasBaseCost + + jt[MCOPY].dynamicGas = gasMcopy7904 + jt[PUSH0].constantGas = GasBaseCost for i := PUSH1; i < PUSH32; i++ { jt[i].constantGas = GasBaseCost @@ -633,4 +647,12 @@ func enable7904(jt *JumpTable) { for i := SWAP1; i < SWAP16; i++ { jt[i].constantGas = GasBaseCost } + + jt[SLOAD].dynamicGas = gasSLoadEIP7904 + jt[SSTORE].dynamicGas = gasSStoreEIP7904 + jt[CALL].dynamicGas = gasCallEIP7904 + jt[STATICCALL].dynamicGas = gasStaticCallEIP7904 + jt[DELEGATECALL].dynamicGas = gasDelegateCallEIP7904 + + jt[CALLCODE].dynamicGas = gasCallCodeEIP7904 } diff --git a/core/vm/gas.go b/core/vm/gas.go index 8033005987..7ff5926c40 100644 --- a/core/vm/gas.go +++ b/core/vm/gas.go @@ -33,6 +33,8 @@ const ( GasFastCost uint64 = 2 GasMidCost uint64 = 3 GasWarmStorageCost uint64 = 5 + GasExpBaseCost uint64 = 2 + GasExpPerByteCost uint64 = 4 ) // callGas returns the actual gas cost of the call. diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index c7c1274bf2..a12d6a8b2a 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -88,12 +88,49 @@ func memoryCopierGas(stackpos int) gasFunc { } } +// memoryCopierGas7904 creates the gas functions for the following opcodes, and takes +// the stack position of the operand which determines the size of the data to copy +// as argument: +// CALLDATACOPY (stack position 2) +// CODECOPY (stack position 2) +// MCOPY (stack position 2) +// EXTCODECOPY (stack position 3) +// RETURNDATACOPY (stack position 2) +func memoryCopierGas7904(stackpos int) gasFunc { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + // Gas for expanding the memory + gas, err := memoryGasCost(mem, memorySize) + if err != nil { + return 0, err + } + // And gas for copying data, charged per word at param.CopyGas + words, overflow := stack.Back(stackpos).Uint64WithOverflow() + if overflow { + return 0, ErrGasUintOverflow + } + + if words, overflow = math.SafeMul(toWordSize(words), params.CopyGasEIP7904); overflow { + return 0, ErrGasUintOverflow + } + + if gas, overflow = math.SafeAdd(gas, words); overflow { + return 0, ErrGasUintOverflow + } + return gas, nil + } +} + var ( - gasCallDataCopy = memoryCopierGas(2) - gasCodeCopy = memoryCopierGas(2) - gasMcopy = memoryCopierGas(2) - gasExtCodeCopy = memoryCopierGas(3) - gasReturnDataCopy = memoryCopierGas(2) + gasCallDataCopy = memoryCopierGas(2) + gasCodeCopy = memoryCopierGas(2) + gasMcopy = memoryCopierGas(2) + gasExtCodeCopy = memoryCopierGas(3) + gasReturnDataCopy = memoryCopierGas(2) + gasCallDataCopy7904 = memoryCopierGas7904(2) + gasCodeCopy7904 = memoryCopierGas7904(2) + gasMcopy7904 = memoryCopierGas7904(2) + gasExtCodeCopy7904 = memoryCopierGas7904(3) + gasReturnDataCopy7904 = memoryCopierGas7904(2) ) func gasSStore(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { @@ -368,6 +405,19 @@ func gasExpEIP158(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor return gas, nil } +func gasExpEIP7904(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + expByteLen := uint64((stack.data[stack.len()-2].BitLen() + 7) / 8) + + var ( + gas = expByteLen * params.ExpByteEIP7904 // no overflow check required. Max is 256 * ExpByte gas + overflow bool + ) + if gas, overflow = math.SafeAdd(gas, params.ExpGasEIP7904); overflow { + return 0, ErrGasUintOverflow + } + return gas, nil +} + func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { var ( gas uint64 diff --git a/core/vm/operations_acl.go b/core/vm/operations_acl.go index 085b018e4c..702147eed8 100644 --- a/core/vm/operations_acl.go +++ b/core/vm/operations_acl.go @@ -26,7 +26,7 @@ import ( "github.com/ethereum/go-ethereum/params" ) -func makeGasSStoreFunc(clearingRefund uint64) gasFunc { +func makeGasSStoreFunc(clearingRefund uint64, warmLoadCosts 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 { @@ -50,7 +50,7 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { if current == value { // noop (1) // EIP 2200 original clause: // return params.SloadGasEIP2200, nil - return cost + params.WarmStorageReadCostEIP2929, nil // SLOAD_GAS + return cost + warmLoadCosts, nil // SLOAD_GAS } if original == current { if original == (common.Hash{}) { // create slot (2.1.1) @@ -74,19 +74,19 @@ func makeGasSStoreFunc(clearingRefund uint64) gasFunc { 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) + evm.StateDB.AddRefund(params.SstoreSetGasEIP2200 - warmLoadCosts) } 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) + evm.StateDB.AddRefund((params.SstoreResetGasEIP2200 - params.ColdSloadCostEIP2929) - warmLoadCosts) } } // EIP-2200 original clause: //return params.SloadGasEIP2200, nil // dirty update (2.2) - return cost + params.WarmStorageReadCostEIP2929, nil // dirty update (2.2) + return cost + warmLoadCosts, nil // dirty update (2.2) } } @@ -108,6 +108,24 @@ func gasSLoadEIP2929(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me return params.WarmStorageReadCostEIP2929, nil } +// gasSLoadEIP7904 calculates dynamic gas for SLOAD according to EIP-7904 +// For SLOAD, if the (address, storage_key) pair (where address is the address of the contract +// whose storage is being read) is not yet in accessed_storage_keys, +// charge 2100 gas and add the pair to accessed_storage_keys. +// If the pair is already in accessed_storage_keys, charge 5 gas. +func gasSLoadEIP7904(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + loc := stack.peek() + slot := common.Hash(loc.Bytes32()) + // Check slot presence in the access list + if _, slotPresent := evm.StateDB.SlotInAccessList(contract.Address(), slot); !slotPresent { + // 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 params.ColdSloadCostEIP2929, nil + } + return params.WarmStorageReadCostEIP7904, nil +} + // gasExtCodeCopyEIP2929 implements extcodecopy according to EIP-2929 // EIP spec: // > If the target is not in accessed_addresses, @@ -152,6 +170,25 @@ func gasEip2929AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Mem return 0, nil } +// gasEip7904AccountCheck checks whether the first stack item (as address) is present in the access list. +// If it is, this method returns '0', otherwise 'cold-warm' gas, presuming that the opcode using it +// is also using 'warm' as constant factor. +// This method is used by: +// - extcodehash, +// - extcodesize, +// - (ext) balance +func gasEip7904AccountCheck(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + addr := common.Address(stack.peek().Bytes20()) + // Check slot presence in the access list + if !evm.StateDB.AddressInAccessList(addr) { + // 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 params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP7904, nil + } + return 0, nil +} + func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) gasFunc { return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { addr := common.Address(stack.Back(addressPosition).Bytes20()) @@ -191,11 +228,55 @@ func makeCallVariantGasCallEIP2929(oldCalculator gasFunc, addressPosition int) g } } +func makeCallVariantGasCallEIP7904(oldCalculator gasFunc, addressPosition int) gasFunc { + return func(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { + addr := common.Address(stack.Back(addressPosition).Bytes20()) + // Check slot presence in the access list + 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 := params.ColdAccountAccessCostEIP2929 - params.WarmStorageReadCostEIP7904 + if !warmAccess { + evm.StateDB.AddAddressToAccessList(addr) + // Charge the remaining difference here already, to correctly calculate available + // gas for call + if !contract.UseGas(coldCost, evm.Config.Tracer, tracing.GasChangeCallStorageColdAccess) { + return 0, ErrOutOfGas + } + } + // Now call the old calculator, which takes into account + // - create new account + // - transfer value + // - memory expansion + // - 63/64ths rule + gas, err := oldCalculator(evm, contract, stack, mem, memorySize) + if warmAccess || err != nil { + return gas, err + } + // In case of a cold access, we temporarily add the cold charge back, and also + // add it to the returned gas. By adding it to the return, it will be charged + // outside of this function, as part of the dynamic gas, and that will make it + // also become correctly reported to tracers. + contract.Gas += coldCost + + var overflow bool + if gas, overflow = math.SafeAdd(gas, coldCost); overflow { + return 0, ErrGasUintOverflow + } + return gas, nil + } +} + var ( gasCallEIP2929 = makeCallVariantGasCallEIP2929(gasCall, 1) gasDelegateCallEIP2929 = makeCallVariantGasCallEIP2929(gasDelegateCall, 1) gasStaticCallEIP2929 = makeCallVariantGasCallEIP2929(gasStaticCall, 1) gasCallCodeEIP2929 = makeCallVariantGasCallEIP2929(gasCallCode, 1) + + gasCallEIP7904 = makeCallVariantGasCallEIP7904(gasCall, 1) + gasDelegateCallEIP7904 = makeCallVariantGasCallEIP7904(gasDelegateCall, 1) + gasStaticCallEIP7904 = makeCallVariantGasCallEIP7904(gasStaticCall, 1) + gasCallCodeEIP7904 = makeCallVariantGasCallEIP7904(gasCallCode, 1) gasSelfdestructEIP2929 = makeSelfdestructGasFn(true) // gasSelfdestructEIP3529 implements the changes in EIP-3529 (no refunds) gasSelfdestructEIP3529 = makeSelfdestructGasFn(false) @@ -212,11 +293,15 @@ var ( // //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) + gasSStoreEIP2929 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP2200, params.WarmStorageReadCostEIP2929) // gasSStoreEIP3529 implements gas cost for SSTORE according to EIP-3529 // Replace `SSTORE_CLEARS_SCHEDULE` with `SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST` (4,800) - gasSStoreEIP3529 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529) + gasSStoreEIP3529 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529, params.WarmStorageReadCostEIP2929) + + // gasSStoreEIP7904 implements gas cost for SSTORE according to EIP-7904 + // Lowers `WARM_STORAGE_READ_COST`. + gasSStoreEIP7904 = makeGasSStoreFunc(params.SstoreClearsScheduleRefundEIP3529, params.WarmStorageReadCostEIP7904) ) // makeSelfdestructGasFn can create the selfdestruct dynamic gas function for EIP-2929 and EIP-3529 diff --git a/params/protocol_params.go b/params/protocol_params.go index e8b044f450..ab71452e1d 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -69,6 +69,8 @@ const ( ColdSloadCostEIP2929 = uint64(2100) // COLD_SLOAD_COST WarmStorageReadCostEIP2929 = uint64(100) // WARM_STORAGE_READ_COST + WarmStorageReadCostEIP7904 = uint64(5) // WARM_STORAGE_READ_COST + // In EIP-2200: SstoreResetGas was 5000. // In EIP-2929: SstoreResetGas was changed to '5000 - COLD_SLOAD_COST'. // In EIP-3529: SSTORE_CLEARS_SCHEDULE is defined as SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST @@ -119,6 +121,10 @@ const ( // EXP has a dynamic portion depending on the size of the exponent ExpByteFrontier uint64 = 10 // was set to 10 in Frontier ExpByteEIP158 uint64 = 50 // was raised to 50 during Eip158 (Spurious Dragon) + ExpGasEIP7904 uint64 = 2 // lowered to 2 during EIP7904 + ExpByteEIP7904 uint64 = 4 // was lowered to 4 during EIP7904 + + CopyGasEIP7904 uint64 = 1 // lowered // Extcodecopy has a dynamic AND a static cost. This represents only the // static portion of the gas. It was changed during EIP 150 (Tangerine)