Skip to content
This repository was archived by the owner on Jul 5, 2024. It is now read-only.

refacor/CALL and OOG_CALL #348

Merged
KimiWu123 merged 11 commits into from
Jan 19, 2023
Merged

refacor/CALL and OOG_CALL #348

Show file tree
Hide file tree
Changes from 7 commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
b24fc30
add call_gadget for CALL and OOG_CALL.
KimiWu123 Dec 24, 2022
75989d5
fix: type check error
KimiWu123 Dec 26, 2022
0f5ca44
feat: add a func, is_empty_code_hash(), in call_gadget
KimiWu123 Dec 26, 2022
2284f65
fix: using common functions instead of class for making spec easy to …
KimiWu123 Dec 28, 2022
ad22495
refactor: align the implementation with zkevm-circuit
KimiWu123 Jan 15, 2023
2abfce9
fix: add balance check
KimiWu123 Jan 16, 2023
0d651a4
fix: type check error
KimiWu123 Jan 16, 2023
0f59667
refactor: using code_hash to determine callee_exists and some clean-up
KimiWu123 Jan 16, 2023
53df9ee
apply comments from review
KimiWu123 Jan 16, 2023
a7d329a
fix: update how non-existing account are handled as suggestions from …
KimiWu123 Jan 17, 2023
7e0fc6e
refactor: move the order of CodeHash read in callop and oog_call test
KimiWu123 Jan 18, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
122 changes: 38 additions & 84 deletions src/zkevm_specs/evm/execution/callop.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,13 +1,8 @@
from zkevm_specs.evm.util.call_gadget import CallGadget
from zkevm_specs.util.param import N_BYTES_GAS
from ...util import (
EMPTY_CODE_HASH,
FQ,
GAS_COST_ACCOUNT_COLD_ACCESS,
GAS_COST_CALL_WITH_VALUE,
GAS_COST_NEW_ACCOUNT,
GAS_COST_WARM_ACCESS,
GAS_STIPEND_CALL_WITH_VALUE,
N_BYTES_ACCOUNT_ADDRESS,
N_BYTES_GAS,
RLC,
)
from ..instruction import Instruction, Transition
Expand Down Expand Up @@ -44,57 +39,35 @@ def callop(instruction: Instruction):
# Verify depth is less than 1024
instruction.range_lookup(depth, 1024)

# Lookup values from stack
gas_rlc = instruction.stack_pop()
code_address_rlc = instruction.stack_pop()
# The third stack pop `value` is not present for both DELEGATECALL and
# STATICCALL opcodes.
value = instruction.stack_pop() if is_call + is_callcode == 1 else RLC(0)
cd_offset_rlc = instruction.stack_pop()
cd_length_rlc = instruction.stack_pop()
rd_offset_rlc = instruction.stack_pop()
rd_length_rlc = instruction.stack_pop()
is_success = instruction.stack_push()

# Verify is_success is a bool
instruction.constrain_bool(is_success)

# Recomposition of random linear combination to integer
code_address = instruction.rlc_to_fq(code_address_rlc, N_BYTES_ACCOUNT_ADDRESS)

call = CallGadget(instruction, FQ(1), is_call, is_callcode, is_delegatecall)
# For opcode CALLCODE:
# - callee_address = caller_address
#
# For opcode DELEGATECALL:
# - callee_address = caller_address
# - caller_address = parent_caller_address
#
# Variable `code_address` will be used to get code hash.
callee_address = instruction.select(is_callcode + is_delegatecall, caller_address, code_address)
callee_address = instruction.select(
is_callcode + is_delegatecall, caller_address, call.callee_address
)
caller_address = instruction.select(is_delegatecall, parent_caller_address, caller_address)

gas = instruction.rlc_to_fq(gas_rlc, N_BYTES_GAS)
gas_is_u64 = instruction.is_zero(instruction.sum(gas_rlc.le_bytes[N_BYTES_GAS:]))
cd_offset, cd_length = instruction.memory_offset_and_length(cd_offset_rlc, cd_length_rlc)
rd_offset, rd_length = instruction.memory_offset_and_length(rd_offset_rlc, rd_length_rlc)

# Verify memory expansion
next_memory_size, memory_expansion_gas_cost = instruction.memory_expansion_dynamic_length(
cd_offset,
cd_length,
rd_offset,
rd_length,
# Add `callee_address` to access list
is_warm_access = instruction.add_account_to_access_list(
tx_id, call.callee_address, reversion_info
)

# Add `code_address` to access list
is_warm_access = instruction.add_account_to_access_list(tx_id, code_address, reversion_info)
# Check not is_static if call has value
has_value = call.has_value
instruction.constrain_zero(has_value * is_static)

# Propagate rw_counter_end_of_reversion and is_persistent
callee_reversion_info = instruction.reversion_info(call_id=callee_call_id)
instruction.constrain_equal(
callee_reversion_info.is_persistent, reversion_info.is_persistent * is_success.expr()
callee_reversion_info.is_persistent,
reversion_info.is_persistent * call.is_success,
)
is_reverted_by_caller = is_success.expr() == FQ(1) and reversion_info.is_persistent == FQ(0)
is_reverted_by_caller = call.is_success == FQ(1) and reversion_info.is_persistent == FQ(0)
if is_reverted_by_caller:
# Propagate rw_counter_end_of_reversion when callee succeeds but one of callers revert at some point.
# Note that we subtract it with current caller's reversible_write_counter as callee's endpoint, where caller's
Expand All @@ -104,16 +77,12 @@ def callop(instruction: Instruction):
reversion_info.rw_counter_of_reversion(),
)

# Check not is_static if call has value
has_value = 1 - instruction.is_zero(value)
instruction.constrain_zero(has_value * is_static)

if is_call == 1:
# For CALL opcode, verify transfer, and get caller balance before
# transfer to constrain it should be greater than or equal to stack
# `value`.
(_, caller_balance), _ = instruction.transfer(
caller_address, callee_address, value, callee_reversion_info
caller_address, callee_address, call.value, callee_reversion_info
)
elif is_callcode == 1:
# For CALLCODE opcode, get caller balance to constrain it should be
Expand All @@ -124,43 +93,28 @@ def callop(instruction: Instruction):
# or equal to stack `value`.
if is_call + is_callcode == 1:
value_lt_caller_balance, value_eq_caller_balance = instruction.compare_word(
value, caller_balance
call.value, caller_balance
)
instruction.constrain_zero(1 - value_lt_caller_balance - value_eq_caller_balance)

callee_code_hash = instruction.account_read(code_address, AccountFieldTag.CodeHash)
# Check calle account existence with code_hash != 0
callee_exists = FQ(1) - instruction.is_zero(callee_code_hash)

if callee_exists == 1:
is_empty_code_hash = instruction.is_equal(
callee_code_hash, instruction.rlc_encode(EMPTY_CODE_HASH, 32)
)
else: # callee_exists == 0
is_empty_code_hash = FQ(1)
# Load callee account `exists` value from auxilary witness data.
callee_exists = instruction.curr.aux_data

# Verify gas cost.
gas_cost = (
instruction.select(
is_warm_access, FQ(GAS_COST_WARM_ACCESS), FQ(GAS_COST_ACCOUNT_COLD_ACCESS)
)
+ has_value
* (
GAS_COST_CALL_WITH_VALUE
# Only CALL opcode could invoke transfer to make empty account into non-empty.
+ is_call * (1 - callee_exists) * GAS_COST_NEW_ACCOUNT
)
+ memory_expansion_gas_cost
gas_cost = call.gas_cost(
instruction,
is_warm_access,
callee_exists,
is_call, # Only CALL opcode could invoke transfer to make empty account into non-empty.
)

# Apply EIP 150.
# Note that sufficient gas_left is checked implicitly by constant_divmod.
gas_available = instruction.curr.gas_left - gas_cost
one_64th_gas, _ = instruction.constant_divmod(gas_available, FQ(64), N_BYTES_GAS)
all_but_one_64th_gas = gas_available - one_64th_gas
callee_gas_left = instruction.select(
gas_is_u64,
instruction.min(all_but_one_64th_gas, gas, N_BYTES_GAS),
call.is_u64_gas,
instruction.min(all_but_one_64th_gas, call.gas, N_BYTES_GAS),
all_but_one_64th_gas,
)

Expand All @@ -171,9 +125,9 @@ def callop(instruction: Instruction):
is_precompile, FQ(instruction.next.execution_state in precompile_execution_states())
)

if is_empty_code_hash == FQ(1) and is_precompile == FQ(0):
if call.is_empty_code_hash == FQ(1) and is_precompile == FQ(0):

@ed255 ed255 Jan 16, 2023

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Recently the case of *CALL* without code execution has been updated due to how non-existing accounts are handled.
Non-existing accounts are now identified by having code_hash = 0, which is not the empty hash value. But those cases should still be handled as no code execution.
So I think it would be better to define:

no_callee_code = call.is_empty_code_hash + call.callee_not_exists

And then in this if replace the first check by no_callee_code == FQ(1)

I notice that call.callee_not_exists is missing from the CallGadget in this PR. I introduced that in a very recent PR in the circuits. See privacy-ethereum/zkevm-circuits@aaaf13e#diff-08d58ebc59ab6c11bf7c049e859441eed2319a03feb3fdffaddaba73f8a8c829

@KimiWu123 KimiWu123 Jan 17, 2023

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

fixed in a7d329a

# Make sure call is successful
instruction.constrain_equal(is_success, FQ(1))
instruction.constrain_equal(call.is_success, FQ(1))

# Empty return_data
for (field_tag, expected_value) in [
Expand All @@ -198,7 +152,7 @@ def callop(instruction: Instruction):
program_counter=Transition.delta(1),
stack_pointer=Transition.delta(stack_pointer_delta),
gas_left=Transition.delta(has_value * GAS_STIPEND_CALL_WITH_VALUE - gas_cost),
memory_size=Transition.to(next_memory_size),
memory_size=Transition.to(call.next_memory_size),
reversible_write_counter=Transition.delta(3),
# Always stay same
call_id=Transition.same(),
Expand All @@ -219,7 +173,7 @@ def callop(instruction: Instruction):
instruction.curr.stack_pointer + stack_pointer_delta,
),
(CallContextFieldTag.GasLeft, instruction.curr.gas_left - gas_cost - callee_gas_left),
(CallContextFieldTag.MemorySize, next_memory_size),
(CallContextFieldTag.MemorySize, call.next_memory_size),
(
CallContextFieldTag.ReversibleWriteCounter,
instruction.curr.reversible_write_counter + 1,
Expand All @@ -238,22 +192,22 @@ def callop(instruction: Instruction):
(CallContextFieldTag.Depth, depth.expr() + 1),
(CallContextFieldTag.CallerAddress, caller_address.expr()),
(CallContextFieldTag.CalleeAddress, callee_address.expr()),
(CallContextFieldTag.CallDataOffset, cd_offset),
(CallContextFieldTag.CallDataLength, cd_length),
(CallContextFieldTag.ReturnDataOffset, rd_offset),
(CallContextFieldTag.ReturnDataLength, rd_length),
(CallContextFieldTag.CallDataOffset, call.cd_offset),
(CallContextFieldTag.CallDataLength, call.cd_length),
(CallContextFieldTag.ReturnDataOffset, call.rd_offset),
(CallContextFieldTag.ReturnDataLength, call.rd_length),
(
CallContextFieldTag.Value,
instruction.select(is_delegatecall, parent_call_value.expr(), value.expr()),
instruction.select(is_delegatecall, parent_call_value.expr(), call.value.expr()),
),
(CallContextFieldTag.IsSuccess, is_success.expr()),
(CallContextFieldTag.IsSuccess, call.is_success),
(CallContextFieldTag.IsStatic, is_static.expr()),
(CallContextFieldTag.LastCalleeId, FQ(0)),
(CallContextFieldTag.LastCalleeReturnDataOffset, FQ(0)),
(CallContextFieldTag.LastCalleeReturnDataLength, FQ(0)),
(CallContextFieldTag.IsRoot, FQ(False)),
(CallContextFieldTag.IsCreate, FQ(False)),
(CallContextFieldTag.CodeHash, callee_code_hash.expr()),
(CallContextFieldTag.CodeHash, call.callee_code_hash),
]:
instruction.constrain_equal(
instruction.call_context_lookup(field_tag, call_id=callee_call_id),
Expand All @@ -268,7 +222,7 @@ def callop(instruction: Instruction):
call_id=Transition.to(callee_call_id),
is_root=Transition.to(False),
is_create=Transition.to(False),
code_hash=Transition.to(callee_code_hash),
code_hash=Transition.to(call.callee_code_hash),
gas_left=Transition.to(callee_gas_left),
reversible_write_counter=Transition.to(2),
log_id=Transition.same(),
Expand Down
65 changes: 11 additions & 54 deletions src/zkevm_specs/evm/execution/oog_call.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,14 +1,7 @@
from ...util import (
FQ,
N_BYTES_ACCOUNT_ADDRESS,
EMPTY_CODE_HASH,
GAS_COST_WARM_ACCESS,
GAS_COST_ACCOUNT_COLD_ACCESS,
GAS_COST_CALL_WITH_VALUE,
GAS_COST_NEW_ACCOUNT,
)
from zkevm_specs.evm.util.call_gadget import CallGadget
from ...util import FQ
from ..instruction import Instruction, Transition
from ..table import CallContextFieldTag, AccountFieldTag
from ..table import AccountFieldTag, CallContextFieldTag
from ..execution_state import ExecutionState
from ...util import N_BYTES_GAS
from ..opcode import Opcode
Expand All @@ -22,55 +15,19 @@ def oog_call(instruction: Instruction):

tx_id = instruction.call_context_lookup(CallContextFieldTag.TxId)
instruction.call_context_lookup(CallContextFieldTag.IsStatic)
# Lookup values from stack
instruction.stack_pop()
callee_address_rlc = instruction.stack_pop()
value = instruction.stack_pop()
cd_offset_rlc = instruction.stack_pop()
cd_length_rlc = instruction.stack_pop()
rd_offset_rlc = instruction.stack_pop()
rd_length_rlc = instruction.stack_pop()
is_success = instruction.stack_push()
instruction.constrain_zero(is_success)

cd_offset, cd_length = instruction.memory_offset_and_length(cd_offset_rlc, cd_length_rlc)
rd_offset, rd_length = instruction.memory_offset_and_length(rd_offset_rlc, rd_length_rlc)

# Verify memory expansion
next_memory_size, memory_expansion_gas_cost = instruction.memory_expansion_dynamic_length(
cd_offset,
cd_length,
rd_offset,
rd_length,
)

has_value = 1 - instruction.is_zero(value)
callee_address = instruction.rlc_to_fq(callee_address_rlc, N_BYTES_ACCOUNT_ADDRESS)
call = CallGadget(instruction, FQ(0), FQ(1), FQ(0), FQ(0))

# TODO: handle PrecompiledContract oog cases

# Add callee to access list
is_warm_access = instruction.read_account_to_access_list(tx_id, callee_address)
# Add callee to access list``
Comment thread
ChihChengLiang marked this conversation as resolved.
Outdated
is_warm_access = instruction.read_account_to_access_list(tx_id, call.callee_address)

# lookup balance of callee
callee_balance = instruction.account_read(callee_address, AccountFieldTag.Balance)
# Verify gas cost
callee_nonce = instruction.account_read(callee_address, AccountFieldTag.Nonce)
callee_code_hash = instruction.account_read(callee_address, AccountFieldTag.CodeHash)
instruction.account_read(call.callee_address, AccountFieldTag.Balance)

is_empty_code_hash = instruction.is_equal(
callee_code_hash, instruction.rlc_encode(EMPTY_CODE_HASH, 32)
)
is_account_empty = (
instruction.is_zero(callee_nonce) * instruction.is_zero(callee_balance) * is_empty_code_hash
)
gas_cost = (
instruction.select(
is_warm_access, FQ(GAS_COST_WARM_ACCESS), FQ(GAS_COST_ACCOUNT_COLD_ACCESS)
)
+ has_value * (GAS_COST_CALL_WITH_VALUE + is_account_empty * GAS_COST_NEW_ACCOUNT)
+ memory_expansion_gas_cost
)
# Load callee account `exists` value from auxilary witness data.
callee_exists = instruction.curr.aux_data
gas_cost = call.gas_cost(instruction, is_warm_access, callee_exists)

# verify gas is insufficient
gas_not_enough, _ = instruction.compare(instruction.curr.gas_left, gas_cost, N_BYTES_GAS)
Expand All @@ -89,7 +46,7 @@ def oog_call(instruction: Instruction):
if instruction.curr.is_root:
# Do step state transition
instruction.constrain_step_state_transition(
rw_counter=Transition.delta(15),
rw_counter=Transition.delta(14),
call_id=Transition.same(),
)
else:
Expand Down
Loading