564 lines
19 KiB
Nim
564 lines
19 KiB
Nim
# Nimbus
|
|
# Copyright (c) 2018-2019 Status Research & Development GmbH
|
|
# Licensed under either of
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
|
|
# at your option. This file may not be copied, modified, or distributed except according to those terms.
|
|
|
|
import
|
|
strformat, times, sets, sequtils, options,
|
|
chronicles, stint, nimcrypto, eth/common,
|
|
./utils/[macros_procs_opcodes, v2utils_numeric],
|
|
./gas_meter, ./v2gas_costs, ./v2opcode_values, ./v2forks,
|
|
../v2memory, ../stack, ../code_stream, ../v2computation, ../v2state, ../v2types,
|
|
../../errors, ../../constants,
|
|
../../db/[db_chain, accounts_cache]
|
|
|
|
# verify that experimental op table compiles
|
|
import
|
|
./op_handlers, ./op_handlers/oph_defs
|
|
|
|
logScope:
|
|
topics = "opcode impl"
|
|
|
|
# ##################################
|
|
# Syntactic sugar
|
|
|
|
proc gasEip2929AccountCheck(c: Computation, address: EthAddress, prevCost = 0.GasInt) =
|
|
c.vmState.mutateStateDB:
|
|
let gasCost = if not db.inAccessList(address):
|
|
db.accessList(address)
|
|
ColdAccountAccessCost
|
|
else:
|
|
WarmStorageReadCost
|
|
|
|
c.gasMeter.consumeGas(gasCost - prevCost, reason = "gasEIP2929AccountCheck")
|
|
|
|
template push(x: typed) {.dirty.} =
|
|
## Push an expression on the computation stack
|
|
c.stack.push x
|
|
|
|
proc writePaddedResult(mem: var Memory,
|
|
data: openarray[byte],
|
|
memPos, dataPos, len: Natural,
|
|
paddingValue = 0.byte) =
|
|
|
|
mem.extend(memPos, len)
|
|
let dataEndPosition = dataPos.int64 + len - 1
|
|
let sourceBytes = data[min(dataPos, data.len) .. min(data.len - 1, dataEndPosition)]
|
|
mem.write(memPos, sourceBytes)
|
|
|
|
# Don't duplicate zero-padding of mem.extend
|
|
let paddingOffset = min(memPos + sourceBytes.len, mem.len)
|
|
let numPaddingBytes = min(mem.len - paddingOffset, len - sourceBytes.len)
|
|
if numPaddingBytes > 0:
|
|
# TODO: avoid unnecessary memory allocation
|
|
mem.write(paddingOffset, repeat(paddingValue, numPaddingBytes))
|
|
|
|
template sstoreNetGasMeteringImpl(c: Computation, slot, newValue: Uint256) =
|
|
let stateDB = c.vmState.readOnlyStateDB
|
|
let currentValue {.inject.} = c.getStorage(slot)
|
|
|
|
let
|
|
gasParam = GasParams(
|
|
kind: Op.Sstore,
|
|
s_currentValue: currentValue,
|
|
s_originalValue: stateDB.getCommittedStorage(c.msg.contractAddress, slot))
|
|
(gasCost, gasRefund) = c.gasCosts[Sstore].c_handler(newValue, gasParam)
|
|
|
|
c.gasMeter.consumeGas(gasCost, &"SSTORE EIP2200: {c.msg.contractAddress}[{slot}] -> {newValue} ({currentValue})")
|
|
|
|
if gasRefund != 0:
|
|
c.gasMeter.refundGas(gasRefund)
|
|
|
|
c.vmState.mutateStateDB:
|
|
db.setStorage(c.msg.contractAddress, slot, newValue)
|
|
|
|
# ##################################
|
|
# re-implemented OP handlers
|
|
|
|
var gdbBPHook_counter = 0
|
|
proc gdbBPHook*() =
|
|
gdbBPHook_counter.inc
|
|
stderr.write &"*** Hello {gdbBPHook_counter}\n"
|
|
stderr.flushFile
|
|
|
|
template opHandlerX(callName: untyped; opCode: Op; fork = FkBerlin) =
|
|
proc callName*(c: Computation) =
|
|
gdbBPHook()
|
|
var desc: Vm2Ctx
|
|
desc.cpt = c
|
|
vm2OpHandlers[fork][opCode].exec.run(desc)
|
|
|
|
template opHandler(callName: untyped; opCode: Op; fork = FkBerlin) =
|
|
proc callName*(c: Computation) =
|
|
var desc: Vm2Ctx
|
|
desc.cpt = c
|
|
vm2OpHandlers[fork][opCode].exec.run(desc)
|
|
|
|
opHandler add, Op.Add
|
|
opHandler mul, Op.Mul
|
|
opHandler sub, Op.Sub
|
|
opHandler divide, Op.Div
|
|
opHandler sdiv, Op.Sdiv
|
|
opHandler modulo, Op.Mod
|
|
opHandler smod, Op.Smod
|
|
opHandler addmod, Op.AddMod
|
|
opHandler mulmod, Op.MulMod
|
|
opHandler exp, Op.Exp
|
|
opHandler signExtend, Op.SignExtend
|
|
opHandler lt, Op.Lt
|
|
opHandler gt, Op.Gt
|
|
opHandler slt, Op.Slt
|
|
opHandler sgt, Op.Sgt
|
|
opHandler eq, Op.Eq
|
|
opHandler isZero, Op.IsZero
|
|
opHandler andOp, Op.And
|
|
opHandler orOp, Op.Or
|
|
opHandler xorOp, Op.Xor
|
|
opHandler notOp, Op.Not
|
|
opHandler byteOp, Op.Byte
|
|
opHandler sha3, Op.Sha3
|
|
opHandler address, Op.Address
|
|
opHandler balance, Op.Balance
|
|
opHandler origin, Op.Origin
|
|
opHandler caller, Op.Caller
|
|
opHandler callValue, Op.CallValue
|
|
opHandler callDataLoad, Op.CallDataLoad
|
|
opHandler callDataSize, Op.CallDataSize
|
|
opHandler callDataCopy, Op.CallDataCopy
|
|
opHandler codeSize, Op.CodeSize
|
|
opHandler codeCopy, Op.CodeCopy
|
|
opHandler gasprice, Op.GasPrice
|
|
opHandler extCodeSize, Op.ExtCodeSize
|
|
opHandler extCodeCopy, Op.ExtCodeCopy
|
|
opHandler returnDataSize, Op.ReturnDataSize
|
|
opHandler returnDataCopy, Op.ReturnDataCopy
|
|
opHandler blockhash, Op.Blockhash
|
|
opHandler coinbase, Op.Coinbase
|
|
opHandler timestamp, Op.Timestamp
|
|
opHandler blocknumber, Op.Number
|
|
opHandler difficulty, Op.Difficulty
|
|
opHandler gasLimit, Op.GasLimit
|
|
opHandler chainId, Op.ChainId
|
|
opHandler selfBalance, Op.SelfBalance
|
|
opHandler pop, Op.Pop
|
|
opHandler mload, Op.Mload
|
|
opHandler mstore, Op.Mstore
|
|
opHandler mstore8, Op.Mstore8
|
|
opHandler sload, Op.Sload
|
|
opHandler sstore, Op.Sstore, FkFrontier
|
|
opHandler sstoreEIP1283, Op.Sstore, FkConstantinople
|
|
opHandler sstoreEIP2200, Op.Sstore
|
|
opHandler jump, Op.Jump
|
|
opHandler jumpI, Op.JumpI
|
|
opHandler pc, Op.Pc
|
|
opHandler msize, Op.Msize
|
|
opHandler gas, Op.Gas
|
|
opHandler jumpDest, Op.JumpDest
|
|
opHandler beginSub, Op.BeginSub
|
|
opHandler returnSub, Op.ReturnSub
|
|
opHandler jumpSub, Op.JumpSub
|
|
|
|
# ##########################################
|
|
# 60s & 70s: Push Operations.
|
|
# 80s: Duplication Operations
|
|
# 90s: Exchange Operations
|
|
# a0s: Logging Operations
|
|
|
|
genPush()
|
|
genDup()
|
|
genSwap()
|
|
genLog()
|
|
|
|
# ##########################################
|
|
# f0s: System operations.
|
|
template genCreate(callName: untyped, opCode: Op): untyped =
|
|
op callName, inline = false:
|
|
checkInStaticContext(c)
|
|
let
|
|
endowment = c.stack.popInt()
|
|
memPos = c.stack.popInt().safeInt
|
|
|
|
when opCode == Create:
|
|
const callKind = evmcCreate
|
|
let memLen {.inject.} = c.stack.peekInt().safeInt
|
|
let salt = 0.u256
|
|
else:
|
|
const callKind = evmcCreate2
|
|
let memLen {.inject.} = c.stack.popInt().safeInt
|
|
let salt = c.stack.peekInt()
|
|
|
|
c.stack.top(0)
|
|
|
|
let gasParams = GasParams(kind: Create,
|
|
cr_currentMemSize: c.memory.len,
|
|
cr_memOffset: memPos,
|
|
cr_memLength: memLen
|
|
)
|
|
var gasCost = c.gasCosts[Create].c_handler(1.u256, gasParams).gasCost
|
|
when opCode == Create2:
|
|
gasCost = gasCost + c.gasCosts[Create2].m_handler(0, 0, memLen)
|
|
|
|
let reason = &"CREATE: GasCreate + {memLen} * memory expansion"
|
|
c.gasMeter.consumeGas(gasCost, reason = reason)
|
|
c.memory.extend(memPos, memLen)
|
|
c.returnData.setLen(0)
|
|
|
|
if c.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure", reason = "Stack too deep", maxDepth = MaxCallDepth, depth = c.msg.depth
|
|
return
|
|
|
|
if endowment != 0:
|
|
let senderBalance = c.getBalance(c.msg.contractAddress)
|
|
if senderBalance < endowment:
|
|
debug "Computation Failure", reason = "Insufficient funds available to transfer", required = endowment, balance = senderBalance
|
|
return
|
|
|
|
var createMsgGas = c.gasMeter.gasRemaining
|
|
if c.fork >= FkTangerine:
|
|
createMsgGas -= createMsgGas div 64
|
|
c.gasMeter.consumeGas(createMsgGas, reason="CREATE")
|
|
|
|
block:
|
|
let childMsg = Message(
|
|
kind: callKind,
|
|
depth: c.msg.depth + 1,
|
|
gas: createMsgGas,
|
|
sender: c.msg.contractAddress,
|
|
value: endowment,
|
|
data: c.memory.read(memPos, memLen)
|
|
)
|
|
|
|
var child = newComputation(c.vmState, childMsg, salt)
|
|
c.chainTo(child):
|
|
if not child.shouldBurnGas:
|
|
c.gasMeter.returnGas(child.gasMeter.gasRemaining)
|
|
|
|
if child.isSuccess:
|
|
c.merge(child)
|
|
c.stack.top child.msg.contractAddress
|
|
else:
|
|
c.returnData = child.output
|
|
|
|
genCreate(create, Create)
|
|
genCreate(create2, Create2)
|
|
|
|
proc callParams(c: Computation): (UInt256, UInt256, EthAddress, EthAddress, CallKind, int, int, int, int, MsgFlags) =
|
|
let gas = c.stack.popInt()
|
|
let destination = c.stack.popAddress()
|
|
let value = c.stack.popInt()
|
|
|
|
result = (gas,
|
|
value,
|
|
destination,
|
|
c.msg.contractAddress, # sender
|
|
evmcCall,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.msg.flags)
|
|
|
|
proc callCodeParams(c: Computation): (UInt256, UInt256, EthAddress, EthAddress, CallKind, int, int, int, int, MsgFlags) =
|
|
let gas = c.stack.popInt()
|
|
let destination = c.stack.popAddress()
|
|
let value = c.stack.popInt()
|
|
|
|
result = (gas,
|
|
value,
|
|
destination,
|
|
c.msg.contractAddress, # sender
|
|
evmcCallCode,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.msg.flags)
|
|
|
|
proc delegateCallParams(c: Computation): (UInt256, UInt256, EthAddress, EthAddress, CallKind, int, int, int, int, MsgFlags) =
|
|
let gas = c.stack.popInt()
|
|
let destination = c.stack.popAddress()
|
|
|
|
result = (gas,
|
|
c.msg.value, # value
|
|
destination,
|
|
c.msg.sender, # sender
|
|
evmcDelegateCall,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.msg.flags)
|
|
|
|
proc staticCallParams(c: Computation): (UInt256, UInt256, EthAddress, EthAddress, CallKind, int, int, int, int, MsgFlags) =
|
|
let gas = c.stack.popInt()
|
|
let destination = c.stack.popAddress()
|
|
|
|
result = (gas,
|
|
0.u256, # value
|
|
destination,
|
|
c.msg.contractAddress, # sender
|
|
evmcCall,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
c.stack.popInt().cleanMemRef,
|
|
emvcStatic) # is_static
|
|
|
|
template genCall(callName: untyped, opCode: Op): untyped =
|
|
op callName, inline = false:
|
|
## CALL, 0xf1, Message-Call into an account
|
|
## CALLCODE, 0xf2, Message-call into this account with an alternative account's code.
|
|
## DELEGATECALL, 0xf4, Message-call into this account with an alternative account's code, but persisting the current values for sender and value.
|
|
## STATICCALL, 0xfa, Static message-call into an account.
|
|
when opCode == Call:
|
|
if emvcStatic == c.msg.flags and c.stack[^3, Uint256] > 0.u256:
|
|
raise newException(StaticContextError, "Cannot modify state while inside of a STATICCALL context")
|
|
|
|
let (gas, value, destination, sender, callKind,
|
|
memInPos, memInLen, memOutPos, memOutLen, flags) = `callName Params`(c)
|
|
|
|
push: 0
|
|
|
|
let (memOffset, memLength) = if calcMemSize(memInPos, memInLen) > calcMemSize(memOutPos, memOutLen):
|
|
(memInPos, memInLen)
|
|
else:
|
|
(memOutPos, memOutLen)
|
|
|
|
# EIP2929
|
|
# This came before old gas calculator
|
|
# because it will affect `c.gasMeter.gasRemaining`
|
|
# and further `childGasLimit`
|
|
if c.fork >= FkBerlin:
|
|
c.vmState.mutateStateDB:
|
|
if not db.inAccessList(destination):
|
|
db.accessList(destination)
|
|
# The WarmStorageReadCostEIP2929 (100) is already deducted in the form of a constant `gasCall`
|
|
c.gasMeter.consumeGas(ColdAccountAccessCost - WarmStorageReadCost, reason = "EIP2929 gasCall")
|
|
|
|
let contractAddress = when opCode in {Call, StaticCall}: destination else: c.msg.contractAddress
|
|
var (gasCost, childGasLimit) = c.gasCosts[opCode].c_handler(
|
|
value,
|
|
GasParams(kind: opCode,
|
|
c_isNewAccount: not c.accountExists(contractAddress),
|
|
c_gasBalance: c.gasMeter.gasRemaining,
|
|
c_contractGas: gas,
|
|
c_currentMemSize: c.memory.len,
|
|
c_memOffset: memOffset,
|
|
c_memLength: memLength
|
|
))
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
#when opCode == StaticCall:
|
|
# if c.fork >= FkBerlin and destination.toInt <= MaxPrecompilesAddr:
|
|
# gasCost = gasCost - 660.GasInt
|
|
|
|
if gasCost >= 0:
|
|
c.gasMeter.consumeGas(gasCost, reason = $opCode)
|
|
|
|
c.returnData.setLen(0)
|
|
|
|
if c.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure", reason = "Stack too deep", maximumDepth = MaxCallDepth, depth = c.msg.depth
|
|
# return unused gas
|
|
c.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
if gasCost < 0 and childGasLimit <= 0:
|
|
raise newException(OutOfGas, "Gas not enough to perform calculation (" & callName.astToStr & ")")
|
|
|
|
c.memory.extend(memInPos, memInLen)
|
|
c.memory.extend(memOutPos, memOutLen)
|
|
|
|
when opCode in {CallCode, Call}:
|
|
let senderBalance = c.getBalance(sender)
|
|
if senderBalance < value:
|
|
debug "Insufficient funds", available = senderBalance, needed = c.msg.value
|
|
# return unused gas
|
|
c.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
block:
|
|
let msg = Message(
|
|
kind: callKind,
|
|
depth: c.msg.depth + 1,
|
|
gas: childGasLimit,
|
|
sender: sender,
|
|
contractAddress: contractAddress,
|
|
codeAddress: destination,
|
|
value: value,
|
|
data: c.memory.read(memInPos, memInLen),
|
|
flags: flags)
|
|
|
|
var child = newComputation(c.vmState, msg)
|
|
c.chainTo(child):
|
|
if not child.shouldBurnGas:
|
|
c.gasMeter.returnGas(child.gasMeter.gasRemaining)
|
|
|
|
if child.isSuccess:
|
|
c.merge(child)
|
|
c.stack.top(1)
|
|
|
|
c.returnData = child.output
|
|
let actualOutputSize = min(memOutLen, child.output.len)
|
|
if actualOutputSize > 0:
|
|
c.memory.write(memOutPos,
|
|
child.output.toOpenArray(0, actualOutputSize - 1))
|
|
|
|
genCall(call, Call)
|
|
genCall(callCode, CallCode)
|
|
genCall(delegateCall, DelegateCall)
|
|
genCall(staticCall, StaticCall)
|
|
|
|
op returnOp, inline = false, startPos, size:
|
|
## 0xf3, Halt execution returning output data.
|
|
let (pos, len) = (startPos.cleanMemRef, size.cleanMemRef)
|
|
|
|
c.gasMeter.consumeGas(
|
|
c.gasCosts[Return].m_handler(c.memory.len, pos, len),
|
|
reason = "RETURN"
|
|
)
|
|
|
|
c.memory.extend(pos, len)
|
|
c.output = c.memory.read(pos, len)
|
|
|
|
op revert, inline = false, startPos, size:
|
|
## 0xfd, Halt execution reverting state changes but returning data and remaining gas.
|
|
let (pos, len) = (startPos.cleanMemRef, size.cleanMemRef)
|
|
c.gasMeter.consumeGas(
|
|
c.gasCosts[Revert].m_handler(c.memory.len, pos, len),
|
|
reason = "REVERT"
|
|
)
|
|
|
|
c.memory.extend(pos, len)
|
|
c.output = c.memory.read(pos, len)
|
|
# setError(msg, false) will signal cheap revert
|
|
c.setError("REVERT opcode executed", false)
|
|
|
|
op selfDestruct, inline = false:
|
|
## 0xff Halt execution and register account for later deletion.
|
|
let beneficiary = c.stack.popAddress()
|
|
c.selfDestruct(beneficiary)
|
|
|
|
op selfDestructEip150, inline = false:
|
|
let beneficiary = c.stack.popAddress()
|
|
|
|
let gasParams = GasParams(kind: SelfDestruct,
|
|
sd_condition: not c.accountExists(beneficiary)
|
|
)
|
|
|
|
let gasCost = c.gasCosts[SelfDestruct].c_handler(0.u256, gasParams).gasCost
|
|
c.gasMeter.consumeGas(gasCost, reason = "SELFDESTRUCT EIP150")
|
|
c.selfDestruct(beneficiary)
|
|
|
|
op selfDestructEip161, inline = false:
|
|
checkInStaticContext(c)
|
|
|
|
let
|
|
beneficiary = c.stack.popAddress()
|
|
isDead = not c.accountExists(beneficiary)
|
|
balance = c.getBalance(c.msg.contractAddress)
|
|
|
|
let gasParams = GasParams(kind: SelfDestruct,
|
|
sd_condition: isDead and not balance.isZero
|
|
)
|
|
|
|
let gasCost = c.gasCosts[SelfDestruct].c_handler(0.u256, gasParams).gasCost
|
|
c.gasMeter.consumeGas(gasCost, reason = "SELFDESTRUCT EIP161")
|
|
c.selfDestruct(beneficiary)
|
|
|
|
# Constantinople's new opcodes
|
|
|
|
opHandler shlOp, Op.Shl
|
|
opHandler shrOp, Op.Shr
|
|
opHandler sarOp, Op.Sar
|
|
|
|
op extCodeHash, inline = true:
|
|
let address = c.stack.popAddress()
|
|
push: c.getCodeHash(address)
|
|
|
|
op balanceEIP2929, inline = true:
|
|
## 0x31, Get balance of the given account.
|
|
let address = c.stack.popAddress()
|
|
|
|
c.gasEip2929AccountCheck(address, gasFees[c.fork][GasBalance])
|
|
push: c.getBalance(address)
|
|
|
|
op extCodeHashEIP2929, inline = true:
|
|
let address = c.stack.popAddress()
|
|
c.gasEip2929AccountCheck(address, gasFees[c.fork][GasExtCodeHash])
|
|
push: c.getCodeHash(address)
|
|
|
|
op extCodeSizeEIP2929, inline = true:
|
|
## 0x3b, Get size of an account's code
|
|
let address = c.stack.popAddress()
|
|
c.gasEip2929AccountCheck(address, gasFees[c.fork][GasExtCode])
|
|
push: c.getCodeSize(address)
|
|
|
|
op extCodeCopyEIP2929, inline = true:
|
|
## 0x3c, Copy an account's code to memory.
|
|
let address = c.stack.popAddress()
|
|
let (memStartPos, codeStartPos, size) = c.stack.popInt(3)
|
|
let (memPos, codePos, len) = (memStartPos.cleanMemRef, codeStartPos.cleanMemRef, size.cleanMemRef)
|
|
|
|
c.gasMeter.consumeGas(
|
|
c.gasCosts[ExtCodeCopy].m_handler(c.memory.len, memPos, len),
|
|
reason="ExtCodeCopy fee")
|
|
|
|
c.gasEip2929AccountCheck(address, gasFees[c.fork][GasExtCode])
|
|
|
|
let codeBytes = c.getCode(address)
|
|
c.memory.writePaddedResult(codeBytes, memPos, codePos, len)
|
|
|
|
op selfDestructEIP2929, inline = false:
|
|
checkInStaticContext(c)
|
|
|
|
let
|
|
beneficiary = c.stack.popAddress()
|
|
isDead = not c.accountExists(beneficiary)
|
|
balance = c.getBalance(c.msg.contractAddress)
|
|
|
|
let gasParams = GasParams(kind: SelfDestruct,
|
|
sd_condition: isDead and not balance.isZero
|
|
)
|
|
|
|
var gasCost = c.gasCosts[SelfDestruct].c_handler(0.u256, gasParams).gasCost
|
|
|
|
c.vmState.mutateStateDB:
|
|
if not db.inAccessList(beneficiary):
|
|
db.accessList(beneficiary)
|
|
gasCost = gasCost + ColdAccountAccessCost
|
|
|
|
c.gasMeter.consumeGas(gasCost, reason = "SELFDESTRUCT EIP161")
|
|
c.selfDestruct(beneficiary)
|
|
|
|
op sloadEIP2929, inline = true, slot:
|
|
## 0x54, Load word from storage.
|
|
c.vmState.mutateStateDB:
|
|
let gasCost = if not db.inAccessList(c.msg.contractAddress, slot):
|
|
db.accessList(c.msg.contractAddress, slot)
|
|
ColdSloadCost
|
|
else:
|
|
WarmStorageReadCost
|
|
c.gasMeter.consumeGas(gasCost, reason = "sloadEIP2929")
|
|
|
|
push: c.getStorage(slot)
|
|
|
|
op sstoreEIP2929, inline = false, slot, newValue:
|
|
checkInStaticContext(c)
|
|
const SentryGasEIP2200 = 2300 # Minimum gas required to be present for an SSTORE call, not consumed
|
|
|
|
if c.gasMeter.gasRemaining <= SentryGasEIP2200:
|
|
raise newException(OutOfGas, "Gas not enough to perform EIP2200 SSTORE")
|
|
|
|
c.vmState.mutateStateDB:
|
|
if not db.inAccessList(c.msg.contractAddress, slot):
|
|
db.accessList(c.msg.contractAddress, slot)
|
|
c.gasMeter.consumeGas(ColdSloadCost, reason = "sstoreEIP2929")
|
|
|
|
block:
|
|
sstoreNetGasMeteringImpl(c, slot, newValue)
|