Michelson instructions

Base Class

class pytezos.michelson.instructions.base.MichelsonInstruction(stack_items_added: int = 0)

args: List[Type[MichelsonInstruction] | Any] = []

classmethod as_micheline_expr() → dict

classmethod create_type(args: List[Type[Micheline]], annots: list | None = None, **kwargs) → Type[MichelsonInstruction]

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

field_names: List[str] = []

static match(expr) → Type[MichelsonInstruction]

var_names: List[str] = []

class pytezos.michelson.instructions.base.Wildcard

static n(count: int) → List[Wildcard]

pytezos.michelson.instructions.base.dispatch_types(*args: Type[Micheline], mapping: Dict[Tuple[Type[Micheline], ...], Tuple[Any, ...]])

pytezos.michelson.instructions.base.format_stdout(prim: str, inputs: list, outputs: list, arg=None)

ADT operations

class pytezos.michelson.instructions.adt.CarInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CAR'

class pytezos.michelson.instructions.adt.CdrInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CDR'

class pytezos.michelson.instructions.adt.GetnInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'GET'

class pytezos.michelson.instructions.adt.LeftInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LEFT'

class pytezos.michelson.instructions.adt.PairInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'PAIR'

class pytezos.michelson.instructions.adt.PairnInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'PAIR'

class pytezos.michelson.instructions.adt.RightInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'RIGHT'

class pytezos.michelson.instructions.adt.UnpairInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UNPAIR'

class pytezos.michelson.instructions.adt.UnpairnInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UNPAIR'

class pytezos.michelson.instructions.adt.UpdatenInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UPDATE'

pytezos.michelson.instructions.adt.execute_cxr(prim: str, stack: MichelsonStack, stdout: List[str], idx: int)

Arithmetic operations

class pytezos.michelson.instructions.arithmetic.AbsInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'ABS'

class pytezos.michelson.instructions.arithmetic.AddInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'ADD'

class pytezos.michelson.instructions.arithmetic.BytesInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'BYTES'

class pytezos.michelson.instructions.arithmetic.EdivInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EDIV'

class pytezos.michelson.instructions.arithmetic.IntInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'INT'

class pytezos.michelson.instructions.arithmetic.IsNatInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'ISNAT'

class pytezos.michelson.instructions.arithmetic.LslInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LSL'

class pytezos.michelson.instructions.arithmetic.LsrInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LSR'

class pytezos.michelson.instructions.arithmetic.MulInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'MUL'

class pytezos.michelson.instructions.arithmetic.NatInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NAT'

class pytezos.michelson.instructions.arithmetic.NegInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NEG'

class pytezos.michelson.instructions.arithmetic.SubInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SUB'

class pytezos.michelson.instructions.arithmetic.SubMutezInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SUB_MUTEZ'

pytezos.michelson.instructions.arithmetic.execute_shift(prim: str, stack: MichelsonStack, stdout: List[str], shift: Callable[[Tuple[int, int]], int])

Boolean operations

class pytezos.michelson.instructions.boolean.AndInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'AND'

class pytezos.michelson.instructions.boolean.NotInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NOT'

class pytezos.michelson.instructions.boolean.OrInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'OR'

class pytezos.michelson.instructions.boolean.XorInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'XOR'

pytezos.michelson.instructions.boolean.execute_boolean_add(prim: str, stack: MichelsonStack, stdout: List[str], add: Callable)

Comparison operations

class pytezos.michelson.instructions.compare.CompareInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'COMPARE'

class pytezos.michelson.instructions.compare.EqInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EQ'

class pytezos.michelson.instructions.compare.GeInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'GE'

class pytezos.michelson.instructions.compare.GtInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'GT'

class pytezos.michelson.instructions.compare.LeInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LE'

class pytezos.michelson.instructions.compare.LtInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LT'

class pytezos.michelson.instructions.compare.NeqInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NEQ'

pytezos.michelson.instructions.compare.compare(a, b) → int

pytezos.michelson.instructions.compare.execute_zero_compare(prim: str, stack: MichelsonStack, stdout: List[str], compare: Callable[[int], bool])

Control flow operations

class pytezos.michelson.instructions.control.ApplyInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'APPLY'

class pytezos.michelson.instructions.control.DipInstruction(item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DIP'

class pytezos.michelson.instructions.control.DipnInstruction(item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DIP'

class pytezos.michelson.instructions.control.ExecInstruction(item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EXEC'

class pytezos.michelson.instructions.control.FailwithInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'FAILWITH'

class pytezos.michelson.instructions.control.IfConsInstruction(stack_items_added: int, item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'IF_CONS'

class pytezos.michelson.instructions.control.IfInstruction(item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'IF'

class pytezos.michelson.instructions.control.IfLeftInstruction(item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'IF_LEFT'

class pytezos.michelson.instructions.control.IfNoneInstruction(stack_items_added: int, item: MichelsonInstruction)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'IF_NONE'

class pytezos.michelson.instructions.control.IterInstruction(stack_items_added: int, items: List[MichelsonInstruction])

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'ITER'

class pytezos.michelson.instructions.control.LambdaInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LAMBDA'

class pytezos.michelson.instructions.control.LambdaRecInstruction(stack_items_added: int = 0)

depth = 0

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LAMBDA_REC'

class pytezos.michelson.instructions.control.LoopInstruction(items: List[MichelsonInstruction])

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LOOP'

class pytezos.michelson.instructions.control.LoopLeftInstruction(stack_items_added: int, items: List[MichelsonInstruction])

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LOOP_LEFT'

class pytezos.michelson.instructions.control.MapInstruction(stack_items_added: int, items: List[MichelsonInstruction])

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'MAP'

pytezos.michelson.instructions.control.execute_dip(prim: str, stack: MichelsonStack, stdout: List[str], count: int, body: Type[MichelsonInstruction], context: AbstractContext) → MichelsonInstruction

Crypto operations

class pytezos.michelson.instructions.crypto.Blake2bInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'BLAKE2B'

class pytezos.michelson.instructions.crypto.CheckSignatureInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CHECK_SIGNATURE'

class pytezos.michelson.instructions.crypto.HashKeyInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'HASH_KEY'

class pytezos.michelson.instructions.crypto.KeccakInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'KECCAK'

class pytezos.michelson.instructions.crypto.PairingCheckInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'PAIRING_CHECK'

class pytezos.michelson.instructions.crypto.SaplingEmptyStateInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SAPLING_EMPTY_STATE'

class pytezos.michelson.instructions.crypto.SaplingVerifyUpdateInstruction(stack_items_added: int = 0)

prim: str | None = 'SAPLING_VERIFY_UPDATE'

class pytezos.michelson.instructions.crypto.Sha256Instruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SHA256'

class pytezos.michelson.instructions.crypto.Sha3Instruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SHA3'

class pytezos.michelson.instructions.crypto.Sha512Instruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SHA512'

pytezos.michelson.instructions.crypto.execute_hash(prim: str, stack: MichelsonStack, stdout: List[str], hash_digest: Callable[[bytes], bytes])

Generic operations

class pytezos.michelson.instructions.generic.ConcatInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CONCAT'

class pytezos.michelson.instructions.generic.NeverInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NEVER'

class pytezos.michelson.instructions.generic.PackInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'PACK'

class pytezos.michelson.instructions.generic.SizeInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SIZE'

class pytezos.michelson.instructions.generic.SliceInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SLICE'

class pytezos.michelson.instructions.generic.UnitInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UNIT'

class pytezos.michelson.instructions.generic.UnpackInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UNPACK'

Stack operations

class pytezos.michelson.instructions.stack.CastIntruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CAST'

class pytezos.michelson.instructions.stack.DigInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DIG'

class pytezos.michelson.instructions.stack.DropInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DROP'

class pytezos.michelson.instructions.stack.DropnInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DROP'

class pytezos.michelson.instructions.stack.DugInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DUG'

class pytezos.michelson.instructions.stack.DupInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DUP'

class pytezos.michelson.instructions.stack.DupnInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'DUP'

class pytezos.michelson.instructions.stack.PushInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'PUSH'

class pytezos.michelson.instructions.stack.RenameInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'RENAME'

class pytezos.michelson.instructions.stack.SwapInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SWAP'

Operations with structures

class pytezos.michelson.instructions.struct.ConsInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CONS'

class pytezos.michelson.instructions.struct.EmptyBigMapInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EMPTY_BIG_MAP'

class pytezos.michelson.instructions.struct.EmptyMapInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EMPTY_MAP'

class pytezos.michelson.instructions.struct.EmptySetInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EMPTY_SET'

class pytezos.michelson.instructions.struct.GetAndUpdateInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'GET_AND_UPDATE'

class pytezos.michelson.instructions.struct.GetInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'GET'

class pytezos.michelson.instructions.struct.MemInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'MEM'

class pytezos.michelson.instructions.struct.NilInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NIL'

class pytezos.michelson.instructions.struct.NoneInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NONE'

class pytezos.michelson.instructions.struct.SomeInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SOME'

class pytezos.michelson.instructions.struct.UpdateInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'UPDATE'

Tezos-specific operations

class pytezos.michelson.instructions.tezos.AddressInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'ADDRESS'

class pytezos.michelson.instructions.tezos.AmountInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'AMOUNT'

class pytezos.michelson.instructions.tezos.BalanceInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'BALANCE'

class pytezos.michelson.instructions.tezos.ChainIdInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CHAIN_ID'

class pytezos.michelson.instructions.tezos.ContractInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CONTRACT'

class pytezos.michelson.instructions.tezos.CreateContractInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'CREATE_CONTRACT'

class pytezos.michelson.instructions.tezos.EmitInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'EMIT'

class pytezos.michelson.instructions.tezos.ImplicitAccountInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'IMPLICIT_ACCOUNT'

class pytezos.michelson.instructions.tezos.LevelInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'LEVEL'

class pytezos.michelson.instructions.tezos.MinBlockTimeInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'MIN_BLOCK_TIME'

class pytezos.michelson.instructions.tezos.NowInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'NOW'

class pytezos.michelson.instructions.tezos.OpenChestInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'OPEN_CHEST'

class pytezos.michelson.instructions.tezos.SelfAddressInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SELF_ADDRESS'

class pytezos.michelson.instructions.tezos.SelfInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SELF'

class pytezos.michelson.instructions.tezos.SenderInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SENDER'

class pytezos.michelson.instructions.tezos.SetDelegateInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SET_DELEGATE'

class pytezos.michelson.instructions.tezos.SourceInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SOURCE'

class pytezos.michelson.instructions.tezos.TotalVotingPowerInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'TOTAL_VOTING_POWER'

class pytezos.michelson.instructions.tezos.TransferTokensInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'TRANSFER_TOKENS'

class pytezos.michelson.instructions.tezos.ViewInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'VIEW'

class pytezos.michelson.instructions.tezos.VotingPowerInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'VOTING_POWER'

pytezos.michelson.instructions.tezos.get_entrypoint_type(context: AbstractContext, name: str, address=None) → Type[MichelsonType] | None

Ticket operations

class pytezos.michelson.instructions.ticket.JoinTicketsInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'JOIN_TICKETS'

class pytezos.michelson.instructions.ticket.ReadTicketInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'READ_TICKET'

class pytezos.michelson.instructions.ticket.SplitTicketInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'SPLIT_TICKET'

class pytezos.michelson.instructions.ticket.TicketDeprecatedInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'TICKET_DEPRECATED'

class pytezos.michelson.instructions.ticket.TicketInstruction(stack_items_added: int = 0)

classmethod execute(stack: MichelsonStack, stdout: List[str], context: AbstractContext)

prim: str | None = 'TICKET'