Michelson REPL

Interpreter

class pymavryk.michelson.repl.Interpreter(extra_primitives: List[str] | None = None, debug: bool = False)

Michelson interpreter reimplemented in Python. Based on the following reference: https://tezos.gitlab.io/michelson-reference/

execute(code: str) → InterpreterResult

Execute some code preserving current context and stack

Parameters:

code – Michelson code

reset() → None

Reset interpreter’s stack and context

static run_callback(entrypoint: str, parameter, storage, context: ExecutionContext) → Tuple[Any, Any, List[str], Exception | None]

Execute view entrypoint of the contract loaded into the context

Parameters:

• entrypoint – contract entrypoint

• parameter – parameter section

• storage – storage section

• context – execution context

Returns:

[operations, storage, stdout, error]

static run_code(parameter, storage, script: str, entrypoint='default', output_mode='readable', amount=None, chain_id=None, source=None, sender=None, balance=None, block_id=None, **kwargs) → Tuple[List[dict], Any, List[dict], List[str], Exception | None]

Execute contract in interpreter

Parameters:

• parameter – parameter expression

• storage – storage expression

• script – contract’s Michelson code

• entrypoint – contract entrypoint

• output_mode – one of readable/optimized/legacy_optimized

• amount – patch AMOUNT

• chain_id – patch CHAIN_ID

• source – patch SOURCE

• sender – patch SENDER

• balance – patch BALANCE

• block_id – set block ID

static run_tzt(script: str, amount=None, chain_id=None, source=None, sender=None, balance=None, block_id=None, **kwargs) → None

Execute TZT test suite code

Parameters:

• script – test contract’s Michelson code

• amount – patch AMOUNT

• chain_id – patch CHAIN_ID

• source – patch SOURCE

• sender – patch SENDER

• balance – patch BALANCE

• block_id – set block ID

static run_view(name: str, parameter, storage, context: ExecutionContext) → Tuple[Any, Any, Exception | None]

class pymavryk.michelson.repl.InterpreterResult(*, stdout: List[str], error: Exception | None = None, instructions: MichelineSequence | None = None, stack: MichelsonStack | None = None)

Result of running contract in interpreter

error: Exception | None

instructions: MichelineSequence | None

lazy_diff = None

operations = None

stack: MichelsonStack | None

stdout: List[str]

storage = None

Michelson stack

class pymavryk.michelson.stack.MichelsonStack(items: List[MichelsonType] | None = None)

clear() → None

dump(count: int) → List[MichelsonType] | None

classmethod from_items(items: List[MichelsonType]) → MichelsonStack

peek() → MichelsonType

pop(count: int) → List[MichelsonType]

pop1() → MichelsonType

pop2() → Tuple[MichelsonType, MichelsonType]

pop3() → Tuple[MichelsonType, MichelsonType, MichelsonType]

protect(count: int) → None

push(item: MichelsonType)

restore(count: int) → None

Execution context

class pymavryk.context.impl.ExecutionContext(amount=None, chain_id=None, protocol=None, source=None, sender=None, balance=None, block_id=None, now=None, level=None, voting_power=None, total_voting_power=None, min_block_time=None, key=None, shell=None, address=None, counter=None, script=None, tzt=False, mode=None, ipfs_gateway=None, global_constants=None, view_results=None)

get_amount() → int

get_amount_expr()

get_balance() → int

get_balance_expr()

get_big_map_diff(ptr: int) → Tuple[int | None, int, str]

get_big_map_value(ptr: int, key_hash: str)

get_big_maps_expr()

get_chain_id() → str

get_chain_id_expr()

get_code_expr()

get_counter() → int

get_counter_offset() → int

Return current count of pending transactions in mempool.

get_dummy_address() → str

get_dummy_chain_id() → str

get_dummy_key_hash() → str

get_dummy_lambda()

get_dummy_public_key() → str

get_dummy_signature() → str

get_dummy_txr_address() → str

get_input_expr()

get_level() → int

get_min_block_time() → int

get_now() → int

get_now_expr()

get_operations_ttl() → int

get_originated_address() → str

get_output_expr()

get_parameter_expr(address=None) → dict | None

get_protocol() → str

get_sapling_state_diff(offset_commitment=0, offset_nullifier=0) → Tuple[int, list]

get_self_address() → str

get_self_expr()

get_sender() → str

get_sender_expr()

get_source() → str

get_source_expr()

get_storage_expr(address=None) → dict | None

get_storage_value(address=None) → dict | None

get_tmp_big_map_id() → int

get_tmp_sapling_state_id() → int

get_total_voting_power() → int

get_view_expr(name, address=None) → dict | None

get_view_result(name, address=None) → Any | None

get_views_expr() → List[dict]

get_voting_power(address: str) → int

register_big_map(ptr: int, copy=False) → int

register_global_constant(expression)

Register global constant :param expression: Micheline expression

register_sapling_state(ptr: int)

reset()

resolve_global_constants(expression)

Replace global constants with their respectful values or throw an error if the constant is not defined :param expression: Micheline expression

property sandboxed: bool

property script: dict | None

set_big_maps_expr(expr)

set_chain_id_expr(expr)

set_code_expr(expr)

set_counter(counter: int)

set_input_expr(expr)

set_output_expr(expr)

set_parameter_expr(expr)

set_source_expr(expr)

set_storage_expr(expr)

set_total_voting_power(total_voting_power: int)

set_voting_power(address: str, voting_power: int)

spend_balance(amount: int)