459 lines
14 KiB
Nim
459 lines
14 KiB
Nim
# Nimbus
|
|
# Copyright (c) 2018 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.
|
|
|
|
## EVM Opcode Handlers: Call Operations
|
|
## ====================================
|
|
##
|
|
|
|
import
|
|
../../../constants,
|
|
../../../db/accounts_cache,
|
|
../../../errors,
|
|
../../compu_helper,
|
|
../../memory,
|
|
../../stack,
|
|
../../state,
|
|
../../types,
|
|
../forks_list,
|
|
../gas_costs,
|
|
../gas_meter,
|
|
../op_codes,
|
|
../utils/utils_numeric,
|
|
./oph_defs,
|
|
chronicles,
|
|
eth/common,
|
|
eth/common/eth_types,
|
|
stint
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private
|
|
# ------------------------------------------------------------------------------
|
|
|
|
type
|
|
LocalParams = tuple
|
|
gas: UInt256
|
|
value: UInt256
|
|
destination: EthAddress
|
|
sender: EthAddress
|
|
memInPos: int
|
|
memInLen: int
|
|
memOutPos: int
|
|
memOutLen: int
|
|
flags: MsgFlags
|
|
memOffset: int
|
|
memLength: int
|
|
contractAddress: EthAddress
|
|
|
|
|
|
proc updateStackAndParams(q: var LocalParams; c: Computation) =
|
|
c.stack.push(0)
|
|
|
|
let
|
|
outLen = calcMemSize(q.memOutPos, q.memOutLen)
|
|
inLen = calcMemSize(q.memInPos, q.memInLen)
|
|
|
|
# get the bigger one
|
|
if outLen < inLen:
|
|
q.memOffset = q.memInPos
|
|
q.memLength = q.memInLen
|
|
else:
|
|
q.memOffset = q.memOutPos
|
|
q.memLength = q.memOutLen
|
|
|
|
# EIP2929: This came before old gas calculator
|
|
# because it will affect `c.gasMeter.gasRemaining`
|
|
# and further `childGasLimit`
|
|
if FkBerlin <= c.fork:
|
|
c.vmState.mutateStateDB:
|
|
if not db.inAccessList(q.destination):
|
|
db.accessList(q.destination)
|
|
|
|
# The WarmStorageReadCostEIP2929 (100) is already deducted in
|
|
# the form of a constant `gasCall`
|
|
c.gasMeter.consumeGas(
|
|
ColdAccountAccessCost - WarmStorageReadCost,
|
|
reason = "EIP2929 gasCall")
|
|
|
|
|
|
proc callParams(c: Computation): LocalParams =
|
|
## Helper for callOp()
|
|
result.gas = c.stack.popInt()
|
|
result.destination = c.stack.popAddress()
|
|
result.value = c.stack.popInt()
|
|
result.memInPos = c.stack.popInt().cleanMemRef
|
|
result.memInLen = c.stack.popInt().cleanMemRef
|
|
result.memOutPos = c.stack.popInt().cleanMemRef
|
|
result.memOutLen = c.stack.popInt().cleanMemRef
|
|
|
|
result.sender = c.msg.contractAddress
|
|
result.flags = c.msg.flags
|
|
result.contractAddress = result.destination
|
|
|
|
result.updateStackAndParams(c)
|
|
|
|
|
|
proc callCodeParams(c: Computation): LocalParams =
|
|
## Helper for callCodeOp()
|
|
result = c.callParams
|
|
result.contractAddress = c.msg.contractAddress
|
|
|
|
|
|
proc delegateCallParams(c: Computation): LocalParams =
|
|
## Helper for delegateCall()
|
|
result.gas = c.stack.popInt()
|
|
result.destination = c.stack.popAddress()
|
|
result.memInPos = c.stack.popInt().cleanMemRef
|
|
result.memInLen = c.stack.popInt().cleanMemRef
|
|
result.memOutPos = c.stack.popInt().cleanMemRef
|
|
result.memOutLen = c.stack.popInt().cleanMemRef
|
|
|
|
result.value = c.msg.value
|
|
result.sender = c.msg.sender
|
|
result.flags = c.msg.flags
|
|
result.contractAddress = c.msg.contractAddress
|
|
|
|
result.updateStackAndParams(c)
|
|
|
|
|
|
proc staticCallParams(c: Computation): LocalParams =
|
|
## Helper for staticCall()
|
|
result.gas = c.stack.popInt()
|
|
result.destination = c.stack.popAddress()
|
|
result.memInPos = c.stack.popInt().cleanMemRef
|
|
result.memInLen = c.stack.popInt().cleanMemRef
|
|
result.memOutPos = c.stack.popInt().cleanMemRef
|
|
result.memOutLen = c.stack.popInt().cleanMemRef
|
|
|
|
result.value = 0.u256
|
|
result.sender = c.msg.contractAddress
|
|
result.flags = emvcStatic
|
|
result.contractAddress = result.destination
|
|
|
|
result.updateStackAndParams(c)
|
|
|
|
|
|
proc execSubCall(k: var Vm2Ctx; childMsg: Message; memPos, memLen: int) =
|
|
## Call new VM -- helper for `Call`-like operations
|
|
|
|
# need to provide explicit <c> and <child> for capturing in chainTo proc()
|
|
# <memPos> and <memLen> are provided by value and need not be captured
|
|
var
|
|
c = k.cpt
|
|
child = newComputation(k.cpt.vmState, childMsg)
|
|
|
|
k.cpt.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(memLen, child.output.len)
|
|
if actualOutputSize > 0:
|
|
c.memory.write(memPos, child.output.toOpenArray(0, actualOutputSize - 1))
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private, op handlers implementation
|
|
# ------------------------------------------------------------------------------
|
|
|
|
const
|
|
callOp: Vm2OpFn = proc(k: var Vm2Ctx) =
|
|
## 0xf1, Message-Call into an account
|
|
|
|
if emvcStatic == k.cpt.msg.flags and k.cpt.stack[^3, UInt256] > 0.u256:
|
|
raise newException(
|
|
StaticContextError,
|
|
"Cannot modify state while inside of a STATICCALL context")
|
|
let
|
|
p = k.cpt.callParams
|
|
|
|
var (gasCost, childGasLimit) = k.cpt.gasCosts[Call].c_handler(
|
|
p.value,
|
|
GasParams(
|
|
kind: Call,
|
|
c_isNewAccount: not k.cpt.accountExists(p.contractAddress),
|
|
c_gasBalance: k.cpt.gasMeter.gasRemaining,
|
|
c_contractGas: p.gas,
|
|
c_currentMemSize: k.cpt.memory.len,
|
|
c_memOffset: p.memOffset,
|
|
c_memLength: p.memLength))
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
if gasCost >= 0:
|
|
k.cpt.gasMeter.consumeGas(gasCost, reason = $Call)
|
|
|
|
k.cpt.returnData.setLen(0)
|
|
|
|
if k.cpt.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure",
|
|
reason = "Stack too deep",
|
|
maximumDepth = MaxCallDepth,
|
|
depth = k.cpt.msg.depth
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
if gasCost < 0 and childGasLimit <= 0:
|
|
raise newException(
|
|
OutOfGas, "Gas not enough to perform calculation (call)")
|
|
|
|
k.cpt.memory.extend(p.memInPos, p.memInLen)
|
|
k.cpt.memory.extend(p.memOutPos, p.memOutLen)
|
|
|
|
let senderBalance = k.cpt.getBalance(p.sender)
|
|
if senderBalance < p.value:
|
|
debug "Insufficient funds",
|
|
available = senderBalance,
|
|
needed = k.cpt.msg.value
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
k.execSubCall(
|
|
memPos = p.memOutPos,
|
|
memLen = p.memOutLen,
|
|
childMsg = Message(
|
|
kind: evmcCall,
|
|
depth: k.cpt.msg.depth + 1,
|
|
gas: childGasLimit,
|
|
sender: p.sender,
|
|
contractAddress: p.contractAddress,
|
|
codeAddress: p.destination,
|
|
value: p.value,
|
|
data: k.cpt.memory.read(p.memInPos, p.memInLen),
|
|
flags: p.flags))
|
|
|
|
# ---------------------
|
|
|
|
callCodeOp: Vm2OpFn = proc(k: var Vm2Ctx) =
|
|
## 0xf2, Message-call into this account with an alternative account's code.
|
|
let
|
|
p = k.cpt.callCodeParams
|
|
|
|
var (gasCost, childGasLimit) = k.cpt.gasCosts[CallCode].c_handler(
|
|
p.value,
|
|
GasParams(
|
|
kind: CallCode,
|
|
c_isNewAccount: not k.cpt.accountExists(p.contractAddress),
|
|
c_gasBalance: k.cpt.gasMeter.gasRemaining,
|
|
c_contractGas: p.gas,
|
|
c_currentMemSize: k.cpt.memory.len,
|
|
c_memOffset: p.memOffset,
|
|
c_memLength: p.memLength))
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
if gasCost >= 0:
|
|
k.cpt.gasMeter.consumeGas(gasCost, reason = $CallCode)
|
|
|
|
k.cpt.returnData.setLen(0)
|
|
|
|
if k.cpt.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure",
|
|
reason = "Stack too deep",
|
|
maximumDepth = MaxCallDepth,
|
|
depth = k.cpt.msg.depth
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
if gasCost < 0 and childGasLimit <= 0:
|
|
raise newException(
|
|
OutOfGas, "Gas not enough to perform calculation (callCode)")
|
|
|
|
k.cpt.memory.extend(p.memInPos, p.memInLen)
|
|
k.cpt.memory.extend(p.memOutPos, p.memOutLen)
|
|
|
|
let senderBalance = k.cpt.getBalance(p.sender)
|
|
if senderBalance < p.value:
|
|
debug "Insufficient funds",
|
|
available = senderBalance,
|
|
needed = k.cpt.msg.value
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
k.execSubCall(
|
|
memPos = p.memOutPos,
|
|
memLen = p.memOutLen,
|
|
childMsg = Message(
|
|
kind: evmcCallCode,
|
|
depth: k.cpt.msg.depth + 1,
|
|
gas: childGasLimit,
|
|
sender: p.sender,
|
|
contractAddress: p.contractAddress,
|
|
codeAddress: p.destination,
|
|
value: p.value,
|
|
data: k.cpt.memory.read(p.memInPos, p.memInLen),
|
|
flags: p.flags))
|
|
|
|
# ---------------------
|
|
|
|
delegateCallOp: Vm2OpFn = proc(k: var Vm2Ctx) =
|
|
## 0xf4, Message-call into this account with an alternative account's
|
|
## code, but persisting the current values for sender and value.
|
|
let
|
|
p = k.cpt.delegateCallParams
|
|
|
|
var (gasCost, childGasLimit) = k.cpt.gasCosts[DelegateCall].c_handler(
|
|
p.value,
|
|
GasParams(
|
|
kind: DelegateCall,
|
|
c_isNewAccount: not k.cpt.accountExists(p.contractAddress),
|
|
c_gasBalance: k.cpt.gasMeter.gasRemaining,
|
|
c_contractGas: p.gas,
|
|
c_currentMemSize: k.cpt.memory.len,
|
|
c_memOffset: p.memOffset,
|
|
c_memLength: p.memLength))
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
if gasCost >= 0:
|
|
k.cpt.gasMeter.consumeGas(gasCost, reason = $DelegateCall)
|
|
|
|
k.cpt.returnData.setLen(0)
|
|
if k.cpt.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure",
|
|
reason = "Stack too deep",
|
|
maximumDepth = MaxCallDepth,
|
|
depth = k.cpt.msg.depth
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
if gasCost < 0 and childGasLimit <= 0:
|
|
raise newException(
|
|
OutOfGas, "Gas not enough to perform calculation (delegateCall)")
|
|
|
|
k.cpt.memory.extend(p.memInPos, p.memInLen)
|
|
k.cpt.memory.extend(p.memOutPos, p.memOutLen)
|
|
|
|
k.execSubCall(
|
|
memPos = p.memOutPos,
|
|
memLen = p.memOutLen,
|
|
childMsg = Message(
|
|
kind: evmcDelegateCall,
|
|
depth: k.cpt.msg.depth + 1,
|
|
gas: childGasLimit,
|
|
sender: p.sender,
|
|
contractAddress: p.contractAddress,
|
|
codeAddress: p.destination,
|
|
value: p.value,
|
|
data: k.cpt.memory.read(p.memInPos, p.memInLen),
|
|
flags: p.flags))
|
|
|
|
# ---------------------
|
|
|
|
staticCallOp: Vm2OpFn = proc(k: var Vm2Ctx) =
|
|
## 0xfa, Static message-call into an account.
|
|
|
|
let
|
|
p = k.cpt.staticCallParams
|
|
|
|
var (gasCost, childGasLimit) = k.cpt.gasCosts[StaticCall].c_handler(
|
|
p.value,
|
|
GasParams(
|
|
kind: StaticCall,
|
|
c_isNewAccount: not k.cpt.accountExists(p.contractAddress),
|
|
c_gasBalance: k.cpt.gasMeter.gasRemaining,
|
|
c_contractGas: p.gas,
|
|
c_currentMemSize: k.cpt.memory.len,
|
|
c_memOffset: p.memOffset,
|
|
c_memLength: p.memLength))
|
|
|
|
# EIP 2046: temporary disabled
|
|
# reduce gas fee for precompiles
|
|
# from 700 to 40
|
|
#
|
|
# when opCode == StaticCall:
|
|
# if k.cpt.fork >= FkBerlin and destination.toInt <= MaxPrecompilesAddr:
|
|
# gasCost = gasCost - 660.GasInt
|
|
if gasCost >= 0:
|
|
k.cpt.gasMeter.consumeGas(gasCost, reason = $StaticCall)
|
|
|
|
k.cpt.returnData.setLen(0)
|
|
|
|
if k.cpt.msg.depth >= MaxCallDepth:
|
|
debug "Computation Failure",
|
|
reason = "Stack too deep",
|
|
maximumDepth = MaxCallDepth,
|
|
depth = k.cpt.msg.depth
|
|
k.cpt.gasMeter.returnGas(childGasLimit)
|
|
return
|
|
|
|
if gasCost < 0 and childGasLimit <= 0:
|
|
raise newException(
|
|
OutOfGas, "Gas not enough to perform calculation (staticCall)")
|
|
|
|
k.cpt.memory.extend(p.memInPos, p.memInLen)
|
|
k.cpt.memory.extend(p.memOutPos, p.memOutLen)
|
|
|
|
k.execSubCall(
|
|
memPos = p.memOutPos,
|
|
memLen = p.memOutLen,
|
|
childMsg = Message(
|
|
kind: evmcCall,
|
|
depth: k.cpt.msg.depth + 1,
|
|
gas: childGasLimit,
|
|
sender: p.sender,
|
|
contractAddress: p.contractAddress,
|
|
codeAddress: p.destination,
|
|
value: p.value,
|
|
data: k.cpt.memory.read(p.memInPos, p.memInLen),
|
|
flags: p.flags))
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public, op exec table entries
|
|
# ------------------------------------------------------------------------------
|
|
|
|
const
|
|
vm2OpExecCall*: seq[Vm2OpExec] = @[
|
|
|
|
(opCode: Call, ## 0xf1, Message-Call into an account
|
|
forks: Vm2OpAllForks,
|
|
name: "call",
|
|
info: "Message-Call into an account",
|
|
exec: (prep: vm2OpIgnore,
|
|
run: callOp,
|
|
post: vm2OpIgnore)),
|
|
|
|
(opCode: CallCode, ## 0xf2, Message-Call with alternative code
|
|
forks: Vm2OpAllForks,
|
|
name: "callCode",
|
|
info: "Message-call into this account with alternative account's code",
|
|
exec: (prep: vm2OpIgnore,
|
|
run: callCodeOp,
|
|
post: vm2OpIgnore)),
|
|
|
|
(opCode: DelegateCall, ## 0xf4, CallCode with persisting sender and value
|
|
forks: Vm2OpHomesteadAndLater,
|
|
name: "delegateCall",
|
|
info: "Message-call into this account with an alternative account's " &
|
|
"code but persisting the current values for sender and value.",
|
|
exec: (prep: vm2OpIgnore,
|
|
run: delegateCallOp,
|
|
post: vm2OpIgnore)),
|
|
|
|
(opCode: StaticCall, ## 0xfa, Static message-call into an account
|
|
forks: Vm2OpByzantiumAndLater,
|
|
name: "staticCall",
|
|
info: "Static message-call into an account",
|
|
exec: (prep: vm2OpIgnore,
|
|
run: staticCallOp,
|
|
post: vm2OpIgnore))]
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|