Enum UsonicInstr

#[non_exhaustive]
pub enum UsonicInstr {
    CkNxIRo,
    CkNxIAo,
    CkNxORo,
    CkNxOAo,
    LdW,
    LdIRo,
    LdIAo,
    LdORo,
    LdOAo,
    LdIW,
    LdIL,
    LdIT,
    RstIRo,
    RstIAo,
    RstORo,
    RstOAo,
}

The instruction set uses iterator semantics and not random access semantic to correspond to the RISC type of the machine and not to add assumptions about abilities to access the operation state randomly. Operation state is always iterated, such that not a single state element can be missed (as long as the iterator runs to the end).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CkNxIRo

Checks whether there is a next destructible memory cell in the contract state listed in the operation input and sets CO register accordingly.

CkNxIAo

Checks whether there is a next immutable memory cell in the contract state listed in the operation input and sets CO register accordingly.

CkNxORo

Checks whether there is a next destructible memory cell defined by the operation and sets CO register accordingly.

CkNxOAo

Checks whether there is a next immutable memory cell defined by the operation and sets CO register accordingly.

LdW

Load operation witness [StateValue] to EA-ED registers.

LdIRo

Load next [StateValue] from the current destructible memory cell input to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdIAo

Load next [StateValue] from the current immutable memory cell input to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdORo

Load next [StateValue] from the current destructible memory cell output to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdOAo

Load next [StateValue] from the current immutable memory cell output to EA-ED registers.

If the next state value is absent, sets CO to a failed state. Otherwise, resets CO.

LdIW

Load destructible input witness [StateValue] for the current input number (determined by the value in UI register) to EA-ED registers.

The operation is idempotent.

Does not update the value of UI register.

If the input matching UI index is absent, sets CO to a failed state. Otherwise, resets CO.

LdIL

Load a lock conditions value for the current input number (determined by the value in UI register) to EA-ED registers.

The operation is idempotent.

Does not update the value of UI register.

If the input matching UI index is absent, sets CO to a failed state. Otherwise, resets CO.

LdIT

Load a destructible input authorization token [AuthToken] for the current input number (determined by the value in UI register) to EA register.

The operation also sets EB to either 0 (if a custom lock script is not present) or 1, if it is present.

The operation is idempotent.

Does not update the value of UI register.

If the input matching UI index is absent, sets CO to a failed state. Otherwise, resets CO.

RstIRo

Resets iterator over the input destructible memory cells by setting the corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstIAo

Resets iterator over the input immutable memory cells by setting the corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstORo

Resets iterator over the output destructible memory cells by setting the corresponding UI value to zero.

Does not affect the value of CO or CK registers.

RstOAo

Resets iterator over the output immutable memory cells by setting the corresponding UI value to zero.

Does not affect the value of CO or CK registers.

Trait Implementations

impl<Id> Bytecode<Id> for UsonicInstr

where Id: SiteId,

fn op_range() -> RangeInclusive<u8>

Returns the range of instruction bytecodes covered by a set of operations.

fn opcode_byte(&self) -> u8

Returns byte representing instruction code (without its arguments).

fn code_byte_len(&self) -> u16

Returns the number of bytes used by the instruction and its arguments when serialized into the code segment.

fn external_ref(&self) -> Option<Id>

If the instruction calls or references any external program, returns a reference to it.

fn encode_operands<W>( &self, _writer: &mut W, ) -> Result<(), <W as BytecodeWrite<Id>>::Error>

where W: BytecodeWrite<Id>,

Writes an instruction operands as bytecode, omitting opcode byte.

fn decode_operands<R>( _reader: &mut R, opcode: u8, ) -> Result<UsonicInstr, CodeEofError>

where UsonicInstr: Sized, R: BytecodeRead<Id>,

Reads an instruction operands from bytecode, provided the opcode byte.

fn encode_instr<W>( &self, writer: &mut W, ) -> Result<(), <W as BytecodeWrite<Id>>::Error>

where W: BytecodeWrite<Id>,

Write an instruction as bytecode.

fn decode_instr<R>(reader: &mut R) -> Result<Self, CodeEofError>

where Self: Sized, R: BytecodeRead<Id>,

Reads an instruction from bytecode.

impl Clone for UsonicInstr

fn clone(&self) -> UsonicInstr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UsonicInstr

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

Formats the value using the given formatter.

impl Display for UsonicInstr

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

Formats the value using the given formatter.

impl<Id> From<UsonicInstr> for Instr<Id>

where Id: SiteId,

fn from(v: UsonicInstr) -> Instr<Id>

Converts to this type from the input type.

impl Hash for UsonicInstr

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Id> Instruction<Id> for UsonicInstr

where Id: SiteId,

const ISA_EXT: &'static [&'static str]

The names of the ISA extension set these instructions cover.

type Core = UsonicCore

Extensions to the AluVM core unit provided by this instruction set.

type Context<'ctx> = VmContext<'ctx>

Context: external data which are accessible to the ISA.

fn is_goto_target(&self) -> bool

Whether the instruction can be used as a goto-target.

fn local_goto_pos(&mut self) -> GotoTarget<'_>

If an instruction is a jump operation inside the library, it should return its goto target position number.

fn remote_goto_pos(&mut self) -> Option<&mut Site<Id>>

If an instruction is a jump operation into an external library, it should return its remote target.

fn src_regs(&self) -> BTreeSet<RegE>

List of registers which value is taken into account by the instruction.

fn dst_regs(&self) -> BTreeSet<RegE>

List of registers which value may be changed by the instruction.

fn op_data_bytes(&self) -> u16

The size of the data coming as an instruction operand (i.e., except data coming from registers or read from outside the instruction operands).

fn ext_data_bytes(&self) -> u16

The size of the data read by the instruction from outside the registers (except data coming as a parameter).

fn exec( &self, _site: Site<Id>, core: &mut Core<Id, <UsonicInstr as Instruction<Id>>::Core>, context: &<UsonicInstr as Instruction<Id>>::Context<'_>, ) -> ExecStep<Site<Id>>

Executes the given instruction taking all registers as input and output.

fn isa_ext() -> Confined<BTreeSet<IsaId>, amplify::::collection::confinement::TinyOrdSet::{constant#0}, amplify::::collection::confinement::TinyOrdSet::{constant#1}>

Convert the set of ISA extensions from Self::ISA_EXT into a set of IsaId.

fn regs(&self) -> BTreeSet<<Self::Core as CoreExt>::Reg>

Lists all registers which are used by the instruction.

fn src_reg_bytes(&self) -> u16

The number of bytes in the source registers.

fn dst_reg_bytes(&self) -> u16

The number of bytes in the destination registers.

fn base_complexity(&self) -> u64

Computes base (non-adjusted) complexity of the instruction.

fn complexity(&self) -> u64

Returns computational complexity of the instruction.

impl PartialEq for UsonicInstr

fn eq(&self, other: &UsonicInstr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for UsonicInstr

impl Eq for UsonicInstr

impl StructuralPartialEq for UsonicInstr