Struct CallFrame 

pub struct CallFrame {

    pub gas_limit: u64,
    pub gas_remaining: i64,
    pub pc: usize,
    pub msg_sender: Address,
    pub to: Address,
    pub code_address: Address,
    pub bytecode: Code,
    pub msg_value: U256,
    pub stack: Stack,
    pub memory: Memory,
    pub calldata: Bytes,
    pub output: Bytes,
    pub sub_return_data: Bytes,
    pub is_static: bool,
    pub depth: usize,
    pub is_create: bool,
    pub call_frame_backup: CallFrameBackup,
    pub ret_offset: usize,
    pub ret_size: usize,
    pub should_transfer_value: bool,
    pub state_gas_used_at_entry: i64,
}

A call frame, or execution environment, is the context in which the EVM is currently executing. One context can trigger another with opcodes like CALL or CREATE. Call frames relationships can be thought of as a parent-child relation.

Fields

gas_limit: u64

Max gas a callframe can use

gas_remaining: i64

Keeps track of the remaining gas in the current context.

This is a i64 for performance reasons, to allow faster gas cost substraction and checks.

Additionally, gas limit won’t be a problem since https://eips.ethereum.org/EIPS/eip-7825 limits it to 2^24, which is lower than i64::MAX.

pc: usize

Program Counter

msg_sender: Address

Address of the account that sent the message

to: Address

Address of the recipient of the message

code_address: Address

Address of the code to execute. Usually the same as to, but can be different

bytecode: Code

Bytecode to execute. Its hash field will be bogus for initcodes, as it is inaccessible to the VM unless associated to an account, which doesn’t happen for its initcode.

msg_value: U256

Value sent along the transaction

stack: Stack

memory: Memory

calldata: Bytes

Data sent along the transaction. Empty in CREATE transactions.

output: Bytes

Return data of the CURRENT CONTEXT (see docs for more details)

sub_return_data: Bytes

Return data of the SUB-CONTEXT (see docs for more details)

is_static: bool

Indicates if current context is static (if it is, it can’t alter state)

depth: usize

Call stack current depth

is_create: bool

This is set to true if the function that created this callframe is CREATE or CREATE2

call_frame_backup: CallFrameBackup

Everytime we want to write an account during execution of a callframe we store the pre-write state so that we can restore if it reverts

ret_offset: usize

Return data offset

ret_size: usize

Return data size

should_transfer_value: bool

If true then transfer value from caller to callee

state_gas_used_at_entry: i64

EIP-8037: snapshot of VM.state_gas_used (signed) at child-frame entry. Used to restore parent’s state_gas_used on child revert.

Implementations

impl CallFrame

pub fn new( msg_sender: Address, to: Address, code_address: Address, bytecode: Code, msg_value: U256, calldata: Bytes, is_static: bool, gas_limit: u64, depth: usize, should_transfer_value: bool, is_create: bool, ret_offset: usize, ret_size: usize, stack: Stack, memory: Memory, ) -> Self

pub fn next_opcode(&self) -> u8

pub fn pc(&self) -> usize

pub fn increase_consumed_gas(&mut self, gas: u64) -> Result<(), ExceptionalHalt>

Increases gas consumption of CallFrame and Environment, returning an error if the callframe gas limit is reached.

pub fn check_gas(&self, gas: u64) -> Result<(), ExceptionalHalt>

EELS’ check_gas: assert gas is available without consuming it.

pub fn set_code(&mut self, code: Code) -> Result<(), VMError>

Trait Implementations

impl Debug for CallFrame

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.