Enum snarkvm_synthesizer::prelude::Instruction

pub enum Instruction<N>where
    N: Network,{
    Abs(Literals<N, AbsOperation<N>, 1>),
    AbsWrapped(Literals<N, AbsWrappedOperation<N>, 1>),
    Add(Literals<N, AddOperation<N>, 2>),
    AddWrapped(Literals<N, AddWrappedOperation<N>, 2>),
    And(Literals<N, AndOperation<N>, 2>),
    AssertEq(AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertEq::{constant#0}>),
    AssertNeq(AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertNeq::{constant#0}>),
    Async(Async<N>),
    Call(Call<N>),
    Cast(CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::Cast::{constant#0}>),
    CastLossy(CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::CastLossy::{constant#0}>),
    CommitBHP256(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP256::{constant#0}>),
    CommitBHP512(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP512::{constant#0}>),
    CommitBHP768(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP768::{constant#0}>),
    CommitBHP1024(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP1024::{constant#0}>),
    CommitPED64(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED64::{constant#0}>),
    CommitPED128(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED128::{constant#0}>),
    Div(Literals<N, DivOperation<N>, 2>),
    DivWrapped(Literals<N, DivWrappedOperation<N>, 2>),
    Double(Literals<N, DoubleOperation<N>, 1>),
    GreaterThan(Literals<N, GreaterThanOperation<N>, 2>),
    GreaterThanOrEqual(Literals<N, GreaterThanOrEqualOperation<N>, 2>),
    HashBHP256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP256::{constant#0}>),
    HashBHP512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP512::{constant#0}>),
    HashBHP768(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP768::{constant#0}>),
    HashBHP1024(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP1024::{constant#0}>),
    HashKeccak256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak256::{constant#0}>),
    HashKeccak384(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak384::{constant#0}>),
    HashKeccak512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak512::{constant#0}>),
    HashPED64(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED64::{constant#0}>),
    HashPED128(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED128::{constant#0}>),
    HashPSD2(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD2::{constant#0}>),
    HashPSD4(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD4::{constant#0}>),
    HashPSD8(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD8::{constant#0}>),
    HashSha3_256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_256::{constant#0}>),
    HashSha3_384(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_384::{constant#0}>),
    HashSha3_512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_512::{constant#0}>),
    HashManyPSD2(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD2::{constant#0}>),
    HashManyPSD4(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD4::{constant#0}>),
    HashManyPSD8(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD8::{constant#0}>),
    Inv(Literals<N, InvOperation<N>, 1>),
    IsEq(IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsEq::{constant#0}>),
    IsNeq(IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsNeq::{constant#0}>),
    LessThan(Literals<N, LessThanOperation<N>, 2>),
    LessThanOrEqual(Literals<N, LessThanOrEqualOperation<N>, 2>),
    Modulo(Literals<N, ModuloOperation<N>, 2>),
    Mul(Literals<N, MulOperation<N>, 2>),
    MulWrapped(Literals<N, MulWrappedOperation<N>, 2>),
    Nand(Literals<N, NandOperation<N>, 2>),
    Neg(Literals<N, NegOperation<N>, 1>),
    Nor(Literals<N, NorOperation<N>, 2>),
    Not(Literals<N, NotOperation<N>, 1>),
    Or(Literals<N, OrOperation<N>, 2>),
    Pow(Literals<N, PowOperation<N>, 2>),
    PowWrapped(Literals<N, PowWrappedOperation<N>, 2>),
    Rem(Literals<N, RemOperation<N>, 2>),
    RemWrapped(Literals<N, RemWrappedOperation<N>, 2>),
    Shl(Literals<N, ShlOperation<N>, 2>),
    ShlWrapped(Literals<N, ShlWrappedOperation<N>, 2>),
    Shr(Literals<N, ShrOperation<N>, 2>),
    ShrWrapped(Literals<N, ShrWrappedOperation<N>, 2>),
    SignVerify(SignVerify<N>),
    Square(Literals<N, SquareOperation<N>, 1>),
    SquareRoot(Literals<N, SquareRootOperation<N>, 1>),
    Sub(Literals<N, SubOperation<N>, 2>),
    SubWrapped(Literals<N, SubWrappedOperation<N>, 2>),
    Ternary(Literals<N, TernaryOperation<N>, 3>),
    Xor(Literals<N, XorOperation<N>, 2>),
}

Variants

Abs(Literals<N, AbsOperation<N>, 1>)

Compute the absolute value of first, checking for overflow, and storing the outcome in destination.

AbsWrapped(Literals<N, AbsWrappedOperation<N>, 1>)

Compute the absolute value of first, wrapping around at the boundary of the type, and storing the outcome in destination.

Add(Literals<N, AddOperation<N>, 2>)

Adds first with second, storing the outcome in destination.

AddWrapped(Literals<N, AddWrappedOperation<N>, 2>)

Adds first with second, wrapping around at the boundary of the type, and storing the outcome in destination.

And(Literals<N, AndOperation<N>, 2>)

Performs a bitwise and operation on first and second, storing the outcome in destination.

AssertEq(AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertEq::{constant#0}>)

Asserts first and second are equal.

AssertNeq(AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertNeq::{constant#0}>)

Asserts first and second are not equal.

Async(Async<N>)

Calls a finalize asynchronously on the operands.

Call(Call<N>)

Calls a closure or function on the operands.

Cast(CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::Cast::{constant#0}>)

Casts the operands into the declared type.

CastLossy(CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::CastLossy::{constant#0}>)

Casts the operands into the declared type, with lossy truncation if applicable.

CommitBHP256(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP256::{constant#0}>)

Performs a BHP commitment on inputs of 256-bit chunks.

CommitBHP512(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP512::{constant#0}>)

Performs a BHP commitment on inputs of 512-bit chunks.

CommitBHP768(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP768::{constant#0}>)

Performs a BHP commitment on inputs of 768-bit chunks.

CommitBHP1024(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP1024::{constant#0}>)

Performs a BHP commitment on inputs of 1024-bit chunks.

CommitPED64(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED64::{constant#0}>)

Performs a Pedersen commitment on up to a 64-bit input.

CommitPED128(CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED128::{constant#0}>)

Performs a Pedersen commitment on up to a 128-bit input.

Div(Literals<N, DivOperation<N>, 2>)

Divides first by second, storing the outcome in destination.

DivWrapped(Literals<N, DivWrappedOperation<N>, 2>)

Divides first by second, wrapping around at the boundary of the type, and storing the outcome in destination.

Double(Literals<N, DoubleOperation<N>, 1>)

Doubles first, storing the outcome in destination.

GreaterThan(Literals<N, GreaterThanOperation<N>, 2>)

Computes whether first is greater than second as a boolean, storing the outcome in destination.

GreaterThanOrEqual(Literals<N, GreaterThanOrEqualOperation<N>, 2>)

Computes whether first is greater than or equal to second as a boolean, storing the outcome in destination.

HashBHP256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP256::{constant#0}>)

Performs a BHP hash on inputs of 256-bit chunks.

HashBHP512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP512::{constant#0}>)

Performs a BHP hash on inputs of 512-bit chunks.

HashBHP768(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP768::{constant#0}>)

Performs a BHP hash on inputs of 768-bit chunks.

HashBHP1024(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP1024::{constant#0}>)

Performs a BHP hash on inputs of 1024-bit chunks.

HashKeccak256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak256::{constant#0}>)

Performs a Keccak hash, outputting 256 bits.

HashKeccak384(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak384::{constant#0}>)

Performs a Keccak hash, outputting 384 bits.

HashKeccak512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak512::{constant#0}>)

Performs a Keccak hash, outputting 512 bits.

HashPED64(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED64::{constant#0}>)

Performs a Pedersen hash on up to a 64-bit input.

HashPED128(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED128::{constant#0}>)

Performs a Pedersen hash on up to a 128-bit input.

HashPSD2(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD2::{constant#0}>)

Performs a Poseidon hash with an input rate of 2.

HashPSD4(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD4::{constant#0}>)

Performs a Poseidon hash with an input rate of 4.

HashPSD8(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD8::{constant#0}>)

Performs a Poseidon hash with an input rate of 8.

HashSha3_256(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_256::{constant#0}>)

Performs a SHA-3 hash, outputting 256 bits.

HashSha3_384(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_384::{constant#0}>)

Performs a SHA-3 hash, outputting 384 bits.

HashSha3_512(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_512::{constant#0}>)

Performs a SHA-3 hash, outputting 512 bits.

HashManyPSD2(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD2::{constant#0}>)

Performs a Poseidon hash with an input rate of 2.

HashManyPSD4(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD4::{constant#0}>)

Performs a Poseidon hash with an input rate of 4.

HashManyPSD8(HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD8::{constant#0}>)

Performs a Poseidon hash with an input rate of 8.

Inv(Literals<N, InvOperation<N>, 1>)

Computes the multiplicative inverse of first, storing the outcome in destination.

IsEq(IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsEq::{constant#0}>)

Computes whether first equals second as a boolean, storing the outcome in destination.

IsNeq(IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsNeq::{constant#0}>)

Computes whether first does not equals second as a boolean, storing the outcome in destination.

LessThan(Literals<N, LessThanOperation<N>, 2>)

Computes whether first is less than second as a boolean, storing the outcome in destination.

LessThanOrEqual(Literals<N, LessThanOrEqualOperation<N>, 2>)

Computes whether first is less than or equal to second as a boolean, storing the outcome in destination.

Modulo(Literals<N, ModuloOperation<N>, 2>)

Computes first mod second, storing the outcome in destination.

Mul(Literals<N, MulOperation<N>, 2>)

Multiplies first with second, storing the outcome in destination.

MulWrapped(Literals<N, MulWrappedOperation<N>, 2>)

Multiplies first with second, wrapping around at the boundary of the type, and storing the outcome in destination.

Nand(Literals<N, NandOperation<N>, 2>)

Returns false if first and second are true, storing the outcome in destination.

Neg(Literals<N, NegOperation<N>, 1>)

Negates first, storing the outcome in destination.

Nor(Literals<N, NorOperation<N>, 2>)

Returns true if neither first nor second is true, storing the outcome in destination.

Not(Literals<N, NotOperation<N>, 1>)

Flips each bit in the representation of first, storing the outcome in destination.

Or(Literals<N, OrOperation<N>, 2>)

Performs a bitwise or on first and second, storing the outcome in destination.

Pow(Literals<N, PowOperation<N>, 2>)

Raises first to the power of second, storing the outcome in destination.

PowWrapped(Literals<N, PowWrappedOperation<N>, 2>)

Raises first to the power of second, wrapping around at the boundary of the type, storing the outcome in destination.

Rem(Literals<N, RemOperation<N>, 2>)

Divides first by second, storing the remainder in destination.

RemWrapped(Literals<N, RemWrappedOperation<N>, 2>)

Divides first by second, wrapping around at the boundary of the type, storing the remainder in destination.

Shl(Literals<N, ShlOperation<N>, 2>)

Shifts first left by second bits, storing the outcome in destination.

ShlWrapped(Literals<N, ShlWrappedOperation<N>, 2>)

Shifts first left by second bits, wrapping around at the boundary of the type, storing the outcome in destination.

Shr(Literals<N, ShrOperation<N>, 2>)

Shifts first right by second bits, storing the outcome in destination.

ShrWrapped(Literals<N, ShrWrappedOperation<N>, 2>)

Shifts first right by second bits, wrapping around at the boundary of the type, storing the outcome in destination.

SignVerify(SignVerify<N>)

Computes whether signature is valid for the given address and message.

Square(Literals<N, SquareOperation<N>, 1>)

Squares ‘first’, storing the outcome in destination.

SquareRoot(Literals<N, SquareRootOperation<N>, 1>)

Compute the square root of ‘first’, storing the outcome in destination.

Sub(Literals<N, SubOperation<N>, 2>)

Computes first - second, storing the outcome in destination.

SubWrapped(Literals<N, SubWrappedOperation<N>, 2>)

Computes first - second, wrapping around at the boundary of the type, and storing the outcome in destination.

Ternary(Literals<N, TernaryOperation<N>, 3>)

Selects first, if condition is true, otherwise selects second, storing the result in destination.

Xor(Literals<N, XorOperation<N>, 2>)

Performs a bitwise xor on first and second, storing the outcome in destination.

Implementations

impl<N> Instruction<N>where N: Network,

pub const OPCODES: &'static [Opcode] = _

The list of all instruction opcodes.

pub const fn opcode(&self) -> Opcode

Returns the opcode of the instruction.

pub fn operands(&self) -> &[Operand<N>]

Returns the operands of the instruction.

pub fn evaluate( &self, stack: &(impl StackMatches<N> + StackProgram<N>), registers: &mut (impl RegistersSigner<N> + RegistersLoad<N> + RegistersStore<N>) ) -> Result<(), Error>

Evaluates the instruction.

pub fn execute<A>( &self, stack: &(impl StackMatches<N> + StackProgram<N>), registers: &mut (impl RegistersSignerCircuit<N, A> + RegistersLoadCircuit<N, A> + RegistersStoreCircuit<N, A>) ) -> Result<(), Error>where A: Aleo<Network = N>,

Executes the instruction.

pub fn finalize( &self, stack: &(impl StackMatches<N> + StackProgram<N>), registers: &mut (impl RegistersLoad<N> + RegistersStore<N>) ) -> Result<(), Error>

Finalizes the instruction.

pub fn output_types( &self, stack: &impl StackProgram<N>, input_types: &[RegisterType<N>] ) -> Result<Vec<RegisterType<N>>, Error>

Returns the output type from the given input types.

Trait Implementations

impl<N> Clone for Instruction<N>where N: Clone + Network,

fn clone(&self) -> Instruction<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Debug for Instruction<N>where N: Network,

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

Prints the instruction as a string.

impl<N> Display for Instruction<N>where N: Network,

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

Prints the instruction as a string.

impl<N> From<AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertEq::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertEq::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertNeq::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: AssertInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::assert::AssertNeq::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Async<N>> for Instruction<N>where N: Network,

fn from(operation: Async<N>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Call<N>> for Instruction<N>where N: Network,

fn from(operation: Call<N>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::Cast::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::Cast::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::CastLossy::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CastOperation<N, snarkvm_synthesizer_program::::logic::instruction::operation::cast::CastLossy::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP1024::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP1024::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP256::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP256::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP512::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP512::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP768::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitBHP768::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED128::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED128::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED64::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: CommitInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::commit::CommitPED64::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP1024::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP1024::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP256::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP256::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP512::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP512::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP768::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashBHP768::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak256::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak256::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak384::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak384::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak512::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashKeccak512::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD2::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD2::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD4::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD4::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD8::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashManyPSD8::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED128::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED128::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED64::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPED64::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD2::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD2::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD4::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD4::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD8::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashPSD8::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_256::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_256::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_384::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_384::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_512::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: HashInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::hash::HashSha3_512::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsEq::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsEq::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsNeq::{constant#0}>> for Instruction<N>where N: Network,

fn from( operation: IsInstruction<N, snarkvm_synthesizer_program::::logic::instruction::operation::is::IsNeq::{constant#0}> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, AbsOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, AbsOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, AbsWrappedOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, AbsWrappedOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, AddOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, AddOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, AddWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, AddWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, AndOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, AndOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, DivOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, DivOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, DivWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, DivWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, DoubleOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, DoubleOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, GreaterThanOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, GreaterThanOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, GreaterThanOrEqualOperation<N>, 2>> for Instruction<N>where N: Network,

fn from( operation: Literals<N, GreaterThanOrEqualOperation<N>, 2> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, InvOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, InvOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, LessThanOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, LessThanOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, LessThanOrEqualOperation<N>, 2>> for Instruction<N>where N: Network,

fn from( operation: Literals<N, LessThanOrEqualOperation<N>, 2> ) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, ModuloOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, ModuloOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, MulOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, MulOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, MulWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, MulWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, NandOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, NandOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, NegOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, NegOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, NorOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, NorOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, NotOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, NotOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, OrOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, OrOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, PowOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, PowOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, PowWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, PowWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, RemOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, RemOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, RemWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, RemWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, ShlOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, ShlOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, ShlWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, ShlWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, ShrOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, ShrOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, ShrWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, ShrWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, SquareOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, SquareOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, SquareRootOperation<N>, 1>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, SquareRootOperation<N>, 1>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, SubOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, SubOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, SubWrappedOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, SubWrappedOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, TernaryOperation<N>, 3>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, TernaryOperation<N>, 3>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<Literals<N, XorOperation<N>, 2>> for Instruction<N>where N: Network,

fn from(operation: Literals<N, XorOperation<N>, 2>) -> Instruction<N>

Converts to this type from the input type.

impl<N> From<SignVerify<N>> for Instruction<N>where N: Network,

fn from(operation: SignVerify<N>) -> Instruction<N>

Converts to this type from the input type.

impl<N> FromBytes for Instruction<N>where N: Network,

fn read_le<R>(reader: R) -> Result<Instruction<N>, Error>where R: Read,

Reads Self from reader as little-endian bytes.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>where Self: Sized,

Returns Self from a byte array in little-endian order.

impl<N> FromStr for Instruction<N>where N: Network,

fn from_str(string: &str) -> Result<Instruction<N>, Error>

Parses a string into an instruction.

type Err = Error

The associated error which can be returned from parsing.

impl<N> Hash for Instruction<N>where N: Hash + Network,

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<N> InstructionTrait<N> for Instruction<N>where N: Network,

fn destinations(&self) -> Vec<Register<N>>

Returns the destination registers of the instruction.

fn is_reserved_opcode(name: &str) -> bool

Returns true if the given name is a reserved opcode.

impl<N> Parser for Instruction<N>where N: Network,

fn parse( string: &str ) -> Result<(&str, Instruction<N>), Err<VerboseError<&str>>>

Parses a string into an instruction.

impl<N> PartialEq for Instruction<N>where N: PartialEq + Network,

fn eq(&self, other: &Instruction<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<N> ToBytes for Instruction<N>where N: Network,

fn write_le<W>(&self, writer: W) -> Result<(), Error>where W: Write,

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>where Self: Sized,

Returns self as a byte array in little-endian order.

impl<N> Eq for Instruction<N>where N: Eq + Network,

impl<N> StructuralEq for Instruction<N>where N: Network,

impl<N> StructuralPartialEq for Instruction<N>where N: Network,