View Source Signet.VM (Signet v1.3.8)

An Ethereum VM in Signet, that can only execute pure functions.

Summary

Types

address()

code()

context_result()

exec_opts()

ffis()

opcode()

signed()

unsigned()

vm_error()

word()

Functions

cap_to_range(x, min, max)

exec(code, calldata, opts \\ [])

Executes the Ethereum Virtual Machine (EVM) with the given code and input.

exec_call(code, calldata, opts \\ [])

Runs the given EVM, returning the RETURN data or the REVERT data.

inc_pc(context_result, operation)

pad_to_word(bin)

peek(context, n)

pop2(context)

pop2_unsigned(context)

pop2_unsigned_word(context)

pop3(context)

pop3_unsigned(context)

pop(context)

pop_unsigned(context)

push_word(context, v)

run_single_op(context, input, opts)

sint_to_word(v)

uint_to_word(v)

word_to_sint(arg1)

word_to_uint(v)

Types

address()

@type address() :: <<_::160>>

code()

@type code() :: [opcode()]

context_result()

@type context_result() :: {:ok, Context.t()} | {:error, vm_error()}

exec_opts()

@type exec_opts() :: [callvalue: integer(), ffis: ffis()]

ffis()

@type ffis() :: %{required(address()) => code()}

opcode()

@type opcode() :: Signet.Assembly.opcode()

signed()

@type signed() :: integer()

unsigned()

@type unsigned() :: non_neg_integer()

vm_error()

@type vm_error() ::
  :pc_out_of_bounds
  | :value_overflow
  | :stack_underflow
  | :signed_integer_out_of_bounds
  | :out_of_memory
  | :invalid_operation
  | {:unknown_ffi, address()}
  | {:invalid_push, integer(), binary()}
  | {:impure, opcode()}
  | {:not_implemented, opcode()}

word()

@type word() :: <<_::256>>

Functions

cap_to_range(x, min, max)

@spec cap_to_range(integer(), integer(), integer()) :: integer()

exec(code, calldata, opts \\ [])

@spec exec(code() | binary(), binary(), exec_opts()) ::
  {:ok, Signet.VM.ExecutionResult.t()} | {:error, vm_error()}

Executes the Ethereum Virtual Machine (EVM) with the given code and input.

Parameters

code: The bytecode to be executed, either as a binary or decoded.
calldata: The call data for the execution.
opts: Execution options (see below)

Options

:callvalue: value passed as callvalue for the execution.
:ffis: A mapping of address to functions to run as natively implemented ffis

Returns the result of the execution.

exec_call(code, calldata, opts \\ [])

@spec exec_call(code() | binary(), binary(), exec_opts()) ::
  {:ok, binary()} | {:revert, binary()}

Runs the given EVM, returning the RETURN data or the REVERT data.

Raises on any other exceptional state.

Parameters

code: The bytecode to be executed, either as a binary or decoded.
calldata: The call data for the execution.
opts: Execution options (see below)

Options

:callvalue: value passed as callvalue for the execution.
:ffis: A mapping of address to functions to run as natively implemented ffis

inc_pc(context_result, operation)

@spec inc_pc(context_result(), opcode()) :: context_result()

pad_to_word(bin)

@spec pad_to_word(binary()) :: {:ok, <<_::256>>} | {:error, vm_error()}

peek(context, n)

@spec peek(Signet.VM.Context.t(), integer()) :: {:ok, word()} | {:error, vm_error()}

pop2(context)

@spec pop2(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), word(), word()} | {:error, vm_error()}

pop2_unsigned(context)

@spec pop2_unsigned(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), unsigned(), unsigned()} | {:error, vm_error()}

pop2_unsigned_word(context)

@spec pop2_unsigned_word(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), unsigned(), word()} | {:error, vm_error()}

pop3(context)

@spec pop3(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), word(), word(), word()} | {:error, vm_error()}

pop3_unsigned(context)

@spec pop3_unsigned(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), unsigned(), unsigned(), unsigned()}
  | {:error, vm_error()}

pop(context)

@spec pop(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), word()} | {:error, vm_error()}

pop_unsigned(context)

@spec pop_unsigned(Signet.VM.Context.t()) ::
  {:ok, Signet.VM.Context.t(), unsigned()} | {:error, vm_error()}

push_word(context, v)

@spec push_word(Signet.VM.Context.t(), word()) ::
  {:ok, Signet.VM.Context.t()} | {:error, vm_error()}

run_single_op(context, input, opts)

@spec run_single_op(Signet.VM.Context.t(), Signet.VM.Input.t(), Keyword.t()) ::
  context_result()

sint_to_word(v)

@spec sint_to_word(signed()) :: {:ok, binary()} | {:error, atom()}

uint_to_word(v)

@spec uint_to_word(unsigned()) :: {:ok, binary()} | {:error, vm_error()}

word_to_sint(arg1)

@spec word_to_sint(binary()) :: {:ok, signed()} | {:error, vm_error()}

word_to_uint(v)

@spec word_to_uint(binary()) :: {:ok, unsigned()} | {:error, vm_error()}