From 2334cb7275ec49d190d0a95077ff9ff9c2b2a166 Mon Sep 17 00:00:00 2001 From: Guillaume Ballet <3272758+gballet@users.noreply.github.com> Date: Mon, 15 Apr 2024 21:30:17 +0200 Subject: [PATCH] rename access witness functions --- consensus/beacon/consensus.go | 2 +- core/state/access_witness.go | 40 +++++++++++++++++------------------ core/state_transition.go | 6 +++--- core/vm/evm.go | 8 +++---- core/vm/gas_table.go | 4 ++-- core/vm/instructions.go | 10 ++++----- core/vm/interpreter.go | 2 +- core/vm/operations_verkle.go | 32 ++++++++++++++-------------- 8 files changed, 52 insertions(+), 52 deletions(-) diff --git a/consensus/beacon/consensus.go b/consensus/beacon/consensus.go index 59bbba9fd1..4f518529f7 100644 --- a/consensus/beacon/consensus.go +++ b/consensus/beacon/consensus.go @@ -364,7 +364,7 @@ func (beacon *Beacon) Finalize(chain consensus.ChainHeaderReader, header *types. // Add the balance of each withdrawal to the witness, no gas will // be charged. if chain.Config().IsEIP4762(header.Number, header.Time) { - state.Witness().TouchBalance(w.Address[:], true) + state.Witness().BalanceGas(w.Address[:], true) } } // No block reward which is issued by consensus layer instead. diff --git a/core/state/access_witness.go b/core/state/access_witness.go index 2ad89b21c2..88fbdf3a58 100644 --- a/core/state/access_witness.go +++ b/core/state/access_witness.go @@ -89,9 +89,9 @@ func (aw *AccessWitness) Copy() *AccessWitness { return naw } -// TouchFullAccount returns the gas to be charged for each of the currently cold +// AddAccount returns the gas to be charged for each of the currently cold // member fields of an account. -func (aw *AccessWitness) TouchFullAccount(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) AddAccount(addr []byte, isWrite bool) uint64 { var gas uint64 for i := utils.VersionLeafKey; i <= utils.CodeSizeLeafKey; i++ { gas += aw.touchAddressAndChargeGas(addr, zeroTreeIndex, byte(i), isWrite) @@ -99,28 +99,28 @@ func (aw *AccessWitness) TouchFullAccount(addr []byte, isWrite bool) uint64 { return gas } -// TouchAndChargeMessageCall returns the gas to be charged for each of the currently +// MessageCallGas returns the gas to be charged for each of the currently // cold member fields of an account, that need to be touched when making a message // call to that account. -func (aw *AccessWitness) TouchAndChargeMessageCall(destination []byte) uint64 { +func (aw *AccessWitness) MessageCallGas(destination []byte) uint64 { var gas uint64 gas += aw.touchAddressAndChargeGas(destination, zeroTreeIndex, utils.VersionLeafKey, false) gas += aw.touchAddressAndChargeGas(destination, zeroTreeIndex, utils.CodeSizeLeafKey, false) return gas } -// TouchAndChargeValueTransfer returns the gas to be charged for each of the currently +// ValueTransferGas returns the gas to be charged for each of the currently // cold balance member fields of the caller and the callee accounts. -func (aw *AccessWitness) TouchAndChargeValueTransfer(callerAddr, targetAddr []byte) uint64 { +func (aw *AccessWitness) ValueTransferGas(callerAddr, targetAddr []byte) uint64 { var gas uint64 gas += aw.touchAddressAndChargeGas(callerAddr, zeroTreeIndex, utils.BalanceLeafKey, true) gas += aw.touchAddressAndChargeGas(targetAddr, zeroTreeIndex, utils.BalanceLeafKey, true) return gas } -// TouchAndChargeContractCreateInit returns the access gas costs for the initialization of +// ContractCreateInitGas returns the access gas costs for the initialization of // a contract creation. -func (aw *AccessWitness) TouchAndChargeContractCreateInit(addr []byte, createSendsValue bool) uint64 { +func (aw *AccessWitness) ContractCreateInitGas(addr []byte, createSendsValue bool) uint64 { var gas uint64 gas += aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.VersionLeafKey, true) gas += aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.NonceLeafKey, true) @@ -130,24 +130,24 @@ func (aw *AccessWitness) TouchAndChargeContractCreateInit(addr []byte, createSen return gas } -// TouchTxOrigin adds the member fields of the sender account to the witness, +// AddTxOrigin adds the member fields of the sender account to the witness, // so that cold accesses are not charged, since they are covered by the 21000 gas. -func (aw *AccessWitness) TouchTxOrigin(originAddr []byte) { +func (aw *AccessWitness) AddTxOrigin(originAddr []byte) { for i := utils.VersionLeafKey; i <= utils.CodeSizeLeafKey; i++ { aw.touchAddressAndChargeGas(originAddr, zeroTreeIndex, byte(i), i == utils.BalanceLeafKey || i == utils.NonceLeafKey) } } -// TouchTxDestination adds the member fields of the sender account to the witness, +// AddTxDestination adds the member fields of the sender account to the witness, // so that cold accesses are not charged, since they are covered by the 21000 gas. -func (aw *AccessWitness) TouchTxDestination(targetAddr []byte, sendsValue bool) { +func (aw *AccessWitness) AddTxDestination(targetAddr []byte, sendsValue bool) { for i := utils.VersionLeafKey; i <= utils.CodeSizeLeafKey; i++ { aw.touchAddressAndChargeGas(targetAddr, zeroTreeIndex, byte(i), i == utils.VersionLeafKey && sendsValue) } } -// TouchSlotAndChargeGas returns the amount of gas to be charged for a cold storage access. -func (aw *AccessWitness) TouchSlotAndChargeGas(addr []byte, slot common.Hash, isWrite bool) uint64 { +// SlotGas returns the amount of gas to be charged for a cold storage access. +func (aw *AccessWitness) SlotGas(addr []byte, slot common.Hash, isWrite bool) uint64 { treeIndex, subIndex := utils.StorageIndex(slot.Bytes()) return aw.touchAddressAndChargeGas(addr, *treeIndex, subIndex, isWrite) } @@ -238,7 +238,7 @@ func newChunkAccessKey(branchKey branchAccessKey, leafKey byte) chunkAccessKey { } // touchCodeChunksRangeOnReadAndChargeGas is a helper function to touch every chunk in a code range and charge witness gas costs -func (aw *AccessWitness) TouchCodeChunksRangeAndChargeGas(contractAddr []byte, startPC, size uint64, codeLen uint64, isWrite bool) uint64 { +func (aw *AccessWitness) CodeChunksRangeGas(contractAddr []byte, startPC, size uint64, codeLen uint64, isWrite bool) uint64 { // note that in the case where the copied code is outside the range of the // contract code but touches the last leaf with contract code in it, // we don't include the last leaf of code in the AccessWitness. The @@ -272,22 +272,22 @@ func (aw *AccessWitness) TouchCodeChunksRangeAndChargeGas(contractAddr []byte, s return statelessGasCharged } -func (aw *AccessWitness) TouchVersion(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) VersionGas(addr []byte, isWrite bool) uint64 { return aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.VersionLeafKey, isWrite) } -func (aw *AccessWitness) TouchBalance(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) BalanceGas(addr []byte, isWrite bool) uint64 { return aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.BalanceLeafKey, isWrite) } -func (aw *AccessWitness) TouchNonce(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) NonceGas(addr []byte, isWrite bool) uint64 { return aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.NonceLeafKey, isWrite) } -func (aw *AccessWitness) TouchCodeSize(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) CodeSizeGas(addr []byte, isWrite bool) uint64 { return aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeSizeLeafKey, isWrite) } -func (aw *AccessWitness) TouchCodeHash(addr []byte, isWrite bool) uint64 { +func (aw *AccessWitness) CodeHashGas(addr []byte, isWrite bool) uint64 { return aw.touchAddressAndChargeGas(addr, zeroTreeIndex, utils.CodeKeccakLeafKey, isWrite) } diff --git a/core/state_transition.go b/core/state_transition.go index eb81509423..c923d1c7d7 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -422,10 +422,10 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) { targetAddr := msg.To originAddr := msg.From - st.evm.Accesses.TouchTxOrigin(originAddr.Bytes()) + st.evm.Accesses.AddTxOrigin(originAddr.Bytes()) if msg.To != nil { - st.evm.Accesses.TouchTxDestination(targetAddr.Bytes(), msg.Value.Sign() != 0) + st.evm.Accesses.AddTxDestination(targetAddr.Bytes(), msg.Value.Sign() != 0) // ensure the code size ends up in the access witness st.evm.StateDB.GetCodeSize(*targetAddr) @@ -488,7 +488,7 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) { // add the coinbase to the witness iff the fee is greater than 0 if rules.IsEIP4762 && fee.Sign() != 0 { - st.evm.Accesses.TouchBalance(st.evm.Context.Coinbase[:], true) + st.evm.Accesses.BalanceGas(st.evm.Context.Coinbase[:], true) } } diff --git a/core/vm/evm.go b/core/vm/evm.go index c6195c2f35..85474da08a 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -211,7 +211,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas if !evm.StateDB.Exist(addr) { if !isPrecompile && evm.chainRules.IsEIP4762 { // add proof of absence to witness - wgas := evm.Accesses.TouchFullAccount(addr.Bytes(), false) + wgas := evm.Accesses.AddAccount(addr.Bytes(), false) if gas < wgas { evm.StateDB.RevertToSnapshot(snapshot) return nil, 0, ErrOutOfGas @@ -510,7 +510,7 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, // Charge the contract creation init gas in verkle mode if evm.chainRules.IsEIP4762 { - if !contract.UseGas(evm.Accesses.TouchAndChargeContractCreateInit(address.Bytes(), value.Sign() != 0), evm.Config.Tracer, tracing.GasChangeWitnessContractInit) { + if !contract.UseGas(evm.Accesses.ContractCreateInitGas(address.Bytes(), value.Sign() != 0), evm.Config.Tracer, tracing.GasChangeWitnessContractInit) { err = ErrOutOfGas } } @@ -541,11 +541,11 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, } } else { // Contract creation completed, touch the missing fields in the contract - if !contract.UseGas(evm.Accesses.TouchFullAccount(address.Bytes()[:], true), evm.Config.Tracer, tracing.GasChangeWitnessContractCreation) { + if !contract.UseGas(evm.Accesses.AddAccount(address.Bytes()[:], true), evm.Config.Tracer, tracing.GasChangeWitnessContractCreation) { err = ErrCodeStoreOutOfGas } - if err == nil && len(ret) > 0 && !contract.UseGas(evm.Accesses.TouchCodeChunksRangeAndChargeGas(address.Bytes(), 0, uint64(len(ret)), uint64(len(ret)), true), evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) { + if err == nil && len(ret) > 0 && !contract.UseGas(evm.Accesses.CodeChunksRangeGas(address.Bytes(), 0, uint64(len(ret)), uint64(len(ret)), true), evm.Config.Tracer, tracing.GasChangeWitnessCodeChunk) { err = ErrCodeStoreOutOfGas } } diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index 28bde5121b..dc9a7f34ee 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -404,7 +404,7 @@ func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize } if evm.chainRules.IsEIP4762 { if transfersValue { - gas, overflow = math.SafeAdd(gas, evm.Accesses.TouchAndChargeValueTransfer(contract.Address().Bytes()[:], address.Bytes()[:])) + gas, overflow = math.SafeAdd(gas, evm.Accesses.ValueTransferGas(contract.Address().Bytes()[:], address.Bytes()[:])) if overflow { return 0, ErrGasUintOverflow } @@ -440,7 +440,7 @@ func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memory address := common.Address(stack.Back(1).Bytes20()) transfersValue := !stack.Back(2).IsZero() if transfersValue { - gas, overflow = math.SafeAdd(gas, evm.Accesses.TouchAndChargeValueTransfer(contract.Address().Bytes()[:], address.Bytes()[:])) + gas, overflow = math.SafeAdd(gas, evm.Accesses.ValueTransferGas(contract.Address().Bytes()[:], address.Bytes()[:])) if overflow { return 0, ErrGasUintOverflow } diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 7246a363fd..0771c5f052 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -389,7 +389,7 @@ func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) self: AccountRef(addr), } paddedCodeCopy, copyOffset, nonPaddedCopyLength := getDataAndAdjustedBounds(code, uint64CodeOffset, length.Uint64()) - statelessGas := interpreter.evm.Accesses.TouchCodeChunksRangeAndChargeGas(addr[:], copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false) + statelessGas := interpreter.evm.Accesses.CodeChunksRangeGas(addr[:], copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false) if !scope.Contract.UseGas(statelessGas, interpreter.evm.Config.Tracer, tracing.GasChangeUnspecified) { scope.Contract.Gas = 0 return nil, ErrOutOfGas @@ -606,7 +606,7 @@ func opCreate(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]b if interpreter.evm.chainRules.IsEIP4762 { contractAddress := crypto.CreateAddress(scope.Contract.Address(), interpreter.evm.StateDB.GetNonce(scope.Contract.Address())) - statelessGas := interpreter.evm.Accesses.TouchAndChargeContractCreateInit(contractAddress.Bytes()[:], value.Sign() != 0) + statelessGas := interpreter.evm.Accesses.ContractCreateInitGas(contractAddress.Bytes()[:], value.Sign() != 0) if !scope.Contract.UseGas(statelessGas, interpreter.evm.Config.Tracer, tracing.GasChangeUnspecified) { return nil, ErrExecutionReverted } @@ -655,7 +655,7 @@ func opCreate2(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([] if interpreter.evm.chainRules.IsEIP4762 { codeAndHash := &codeAndHash{code: input} contractAddress := crypto.CreateAddress2(scope.Contract.Address(), salt.Bytes32(), codeAndHash.Hash().Bytes()) - statelessGas := interpreter.evm.Accesses.TouchAndChargeContractCreateInit(contractAddress.Bytes()[:], endowment.Sign() != 0) + statelessGas := interpreter.evm.Accesses.ContractCreateInitGas(contractAddress.Bytes()[:], endowment.Sign() != 0) if !scope.Contract.UseGas(statelessGas, interpreter.evm.Config.Tracer, tracing.GasChangeUnspecified) { return nil, ErrExecutionReverted } @@ -918,7 +918,7 @@ func opPush1(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]by // touch next chunk if PUSH1 is at the boundary. if so, *pc has // advanced past this boundary. contractAddr := scope.Contract.Address() - statelessGas := interpreter.evm.Accesses.TouchCodeChunksRangeAndChargeGas(contractAddr[:], *pc+1, uint64(1), uint64(len(scope.Contract.Code)), false) + statelessGas := interpreter.evm.Accesses.CodeChunksRangeGas(contractAddr[:], *pc+1, uint64(1), uint64(len(scope.Contract.Code)), false) if !scope.Contract.UseGas(statelessGas, interpreter.evm.Config.Tracer, tracing.GasChangeUnspecified) { scope.Contract.Gas = 0 return nil, ErrOutOfGas @@ -947,7 +947,7 @@ func makePush(size uint64, pushByteSize int) executionFunc { if !scope.Contract.IsDeployment && interpreter.evm.chainRules.IsEIP4762 { contractAddr := scope.Contract.Address() - statelessGas := interpreter.evm.Accesses.TouchCodeChunksRangeAndChargeGas(contractAddr[:], uint64(start), uint64(pushByteSize), uint64(len(scope.Contract.Code)), false) + statelessGas := interpreter.evm.Accesses.CodeChunksRangeGas(contractAddr[:], uint64(start), uint64(pushByteSize), uint64(len(scope.Contract.Code)), false) if !scope.Contract.UseGas(statelessGas, interpreter.evm.Config.Tracer, tracing.GasChangeUnspecified) { scope.Contract.Gas = 0 return nil, ErrOutOfGas diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index a10363b7f3..105ef860fc 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -227,7 +227,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) ( // if the PC ends up in a new "chunk" of verkleized code, charge the // associated costs. contractAddr := contract.Address() - contract.Gas -= in.evm.TxContext.Accesses.TouchCodeChunksRangeAndChargeGas(contractAddr[:], pc, 1, uint64(len(contract.Code)), false) + contract.Gas -= in.evm.TxContext.Accesses.CodeChunksRangeGas(contractAddr[:], pc, 1, uint64(len(contract.Code)), false) } // Get the operation from the jump table and validate the stack to ensure there are diff --git a/core/vm/operations_verkle.go b/core/vm/operations_verkle.go index f8dbd6de40..3ba6411bc0 100644 --- a/core/vm/operations_verkle.go +++ b/core/vm/operations_verkle.go @@ -23,7 +23,7 @@ import ( ) func gasSStore4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - gas := evm.Accesses.TouchSlotAndChargeGas(contract.Address().Bytes(), common.Hash(stack.peek().Bytes32()), true) + gas := evm.Accesses.SlotGas(contract.Address().Bytes(), common.Hash(stack.peek().Bytes32()), true) if gas == 0 { gas = params.WarmStorageReadCostEIP2929 } @@ -31,7 +31,7 @@ func gasSStore4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memo } func gasSLoad4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { - gas := evm.Accesses.TouchSlotAndChargeGas(contract.Address().Bytes(), common.Hash(stack.peek().Bytes32()), false) + gas := evm.Accesses.SlotGas(contract.Address().Bytes(), common.Hash(stack.peek().Bytes32()), false) if gas == 0 { gas = params.WarmStorageReadCostEIP2929 } @@ -40,7 +40,7 @@ func gasSLoad4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memor func gasBalance4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { address := stack.peek().Bytes20() - gas := evm.Accesses.TouchBalance(address[:], false) + gas := evm.Accesses.BalanceGas(address[:], false) if gas == 0 { gas = params.WarmStorageReadCostEIP2929 } @@ -52,8 +52,8 @@ func gasExtCodeSize4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, if _, isPrecompile := evm.precompile(address); isPrecompile { return 0, nil } - wgas := evm.Accesses.TouchVersion(address[:], false) - wgas += evm.Accesses.TouchCodeSize(address[:], false) + wgas := evm.Accesses.VersionGas(address[:], false) + wgas += evm.Accesses.CodeSizeGas(address[:], false) if wgas == 0 { wgas = params.WarmStorageReadCostEIP2929 } @@ -65,7 +65,7 @@ func gasExtCodeHash4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, if _, isPrecompile := evm.precompile(address); isPrecompile { return 0, nil } - codehashgas := evm.Accesses.TouchCodeHash(address[:], false) + codehashgas := evm.Accesses.CodeHashGas(address[:], false) if codehashgas == 0 { codehashgas = params.WarmStorageReadCostEIP2929 } @@ -81,7 +81,7 @@ func makeCallVariantGasEIP4762(oldCalculator gasFunc) gasFunc { if _, isPrecompile := evm.precompile(contract.Address()); isPrecompile { return gas, nil } - wgas := evm.Accesses.TouchAndChargeMessageCall(contract.Address().Bytes()) + wgas := evm.Accesses.MessageCallGas(contract.Address().Bytes()) if wgas == 0 { wgas = params.WarmStorageReadCostEIP2929 } @@ -102,17 +102,17 @@ func gasSelfdestructEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Mem return 0, nil } contractAddr := contract.Address() - statelessGas := evm.Accesses.TouchVersion(contractAddr[:], false) - statelessGas += evm.Accesses.TouchCodeSize(contractAddr[:], false) - statelessGas += evm.Accesses.TouchBalance(contractAddr[:], false) + statelessGas := evm.Accesses.VersionGas(contractAddr[:], false) + statelessGas += evm.Accesses.CodeSizeGas(contractAddr[:], false) + statelessGas += evm.Accesses.BalanceGas(contractAddr[:], false) if contractAddr != beneficiaryAddr { - statelessGas += evm.Accesses.TouchBalance(beneficiaryAddr[:], false) + statelessGas += evm.Accesses.BalanceGas(beneficiaryAddr[:], false) } // Charge write costs if it transfers value if evm.StateDB.GetBalance(contractAddr).Sign() != 0 { - statelessGas += evm.Accesses.TouchBalance(contractAddr[:], true) + statelessGas += evm.Accesses.BalanceGas(contractAddr[:], true) if contractAddr != beneficiaryAddr { - statelessGas += evm.Accesses.TouchBalance(beneficiaryAddr[:], true) + statelessGas += evm.Accesses.BalanceGas(beneficiaryAddr[:], true) } } return statelessGas, nil @@ -133,7 +133,7 @@ func gasCodeCopyEip4762(evm *EVM, contract *Contract, stack *Stack, mem *Memory, } _, copyOffset, nonPaddedCopyLength := getDataAndAdjustedBounds(contract.Code, uint64CodeOffset, length.Uint64()) if !contract.IsDeployment { - gas += evm.Accesses.TouchCodeChunksRangeAndChargeGas(contract.Address().Bytes(), copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false) + gas += evm.Accesses.CodeChunksRangeGas(contract.Address().Bytes(), copyOffset, nonPaddedCopyLength, uint64(len(contract.Code)), false) } return gas, nil } @@ -145,8 +145,8 @@ func gasExtCodeCopyEIP4762(evm *EVM, contract *Contract, stack *Stack, mem *Memo return 0, err } addr := common.Address(stack.peek().Bytes20()) - wgas := evm.Accesses.TouchVersion(addr[:], false) - wgas += evm.Accesses.TouchCodeSize(addr[:], false) + wgas := evm.Accesses.VersionGas(addr[:], false) + wgas += evm.Accesses.CodeSizeGas(addr[:], false) if wgas == 0 { wgas = params.WarmStorageReadCostEIP2929 }