Enum BlackBoxOp

pub enum BlackBoxOp {
    AES128Encrypt {
        inputs: HeapVector,
        iv: HeapArray,
        key: HeapArray,
        outputs: HeapVector,
    },
    Blake2s {
        message: HeapVector,
        output: HeapArray,
    },
    Blake3 {
        message: HeapVector,
        output: HeapArray,
    },
    Keccakf1600 {
        input: HeapArray,
        output: HeapArray,
    },
    EcdsaSecp256k1 {
        hashed_msg: HeapVector,
        public_key_x: HeapArray,
        public_key_y: HeapArray,
        signature: HeapArray,
        result: MemoryAddress,
    },
    EcdsaSecp256r1 {
        hashed_msg: HeapVector,
        public_key_x: HeapArray,
        public_key_y: HeapArray,
        signature: HeapArray,
        result: MemoryAddress,
    },
    MultiScalarMul {
        points: HeapVector,
        scalars: HeapVector,
        outputs: HeapArray,
    },
    EmbeddedCurveAdd {
        input1_x: MemoryAddress,
        input1_y: MemoryAddress,
        input1_infinite: MemoryAddress,
        input2_x: MemoryAddress,
        input2_y: MemoryAddress,
        input2_infinite: MemoryAddress,
        result: HeapArray,
    },
    BigIntAdd {
        lhs: MemoryAddress,
        rhs: MemoryAddress,
        output: MemoryAddress,
    },
    BigIntSub {
        lhs: MemoryAddress,
        rhs: MemoryAddress,
        output: MemoryAddress,
    },
    BigIntMul {
        lhs: MemoryAddress,
        rhs: MemoryAddress,
        output: MemoryAddress,
    },
    BigIntDiv {
        lhs: MemoryAddress,
        rhs: MemoryAddress,
        output: MemoryAddress,
    },
    BigIntFromLeBytes {
        inputs: HeapVector,
        modulus: HeapVector,
        output: MemoryAddress,
    },
    BigIntToLeBytes {
        input: MemoryAddress,
        output: HeapVector,
    },
    Poseidon2Permutation {
        message: HeapVector,
        output: HeapArray,
        len: MemoryAddress,
    },
    Sha256Compression {
        input: HeapArray,
        hash_values: HeapArray,
        output: HeapArray,
    },
    ToRadix {
        input: MemoryAddress,
        radix: MemoryAddress,
        output_pointer: MemoryAddress,
        num_limbs: MemoryAddress,
        output_bits: MemoryAddress,
    },
}

These opcodes provide an equivalent of ACIR blackbox functions. They are implemented as native functions in the VM.

Variants

AES128Encrypt

Encrypts a message using AES128.

Fields

inputs: HeapVector

iv: HeapArray

key: HeapArray

outputs: HeapVector

Blake2s

Calculates the Blake2s hash of the inputs.

Fields

message: HeapVector

output: HeapArray

Blake3

Calculates the Blake3 hash of the inputs.

Fields

message: HeapVector

output: HeapArray

Keccakf1600

Keccak Permutation function of 1600 width

Fields

input: HeapArray

output: HeapArray

EcdsaSecp256k1

Verifies a ECDSA signature over the secp256k1 curve.

Fields

hashed_msg: HeapVector

public_key_x: HeapArray

public_key_y: HeapArray

signature: HeapArray

result: MemoryAddress

EcdsaSecp256r1

Verifies a ECDSA signature over the secp256r1 curve.

Fields

hashed_msg: HeapVector

public_key_x: HeapArray

public_key_y: HeapArray

signature: HeapArray

result: MemoryAddress

MultiScalarMul

Performs multi scalar multiplication over the embedded curve.

Fields

points: HeapVector

scalars: HeapVector

outputs: HeapArray

EmbeddedCurveAdd

Performs addition over the embedded curve.

Fields

input1_x: MemoryAddress

input1_y: MemoryAddress

input1_infinite: MemoryAddress

input2_x: MemoryAddress

input2_y: MemoryAddress

input2_infinite: MemoryAddress

result: HeapArray

BigIntAdd

BigInt addition

Fields

lhs: MemoryAddress

rhs: MemoryAddress

output: MemoryAddress

BigIntSub

BigInt subtraction

Fields

lhs: MemoryAddress

rhs: MemoryAddress

output: MemoryAddress

BigIntMul

BigInt multiplication

Fields

lhs: MemoryAddress

rhs: MemoryAddress

output: MemoryAddress

BigIntDiv

BigInt division

Fields

lhs: MemoryAddress

rhs: MemoryAddress

output: MemoryAddress

BigIntFromLeBytes

BigInt from le bytes

Fields

inputs: HeapVector

modulus: HeapVector

output: MemoryAddress

BigIntToLeBytes

BigInt to le bytes

Fields

input: MemoryAddress

output: HeapVector

Poseidon2Permutation

Applies the Poseidon2 permutation function to the given state, outputting the permuted state.

Fields

message: HeapVector

output: HeapArray

len: MemoryAddress

Sha256Compression

Applies the SHA-256 compression function to the input message

Fields

input: HeapArray

hash_values: HeapArray

output: HeapArray

ToRadix

Returns a decomposition in num_limbs limbs of the given input over the given radix.

• The value stored in radix must be in the range [2, 256]
• num_limbs must be at least one if the value stored in input is not zero.
• The value stored in output_bits must have a bit_size of one. That value specifies whether we should decompose into bits. The value stored in the radix address must be two if the value stored in output_bits is equal to one.

Native to the Brillig VM and not supported as an ACIR black box function.

Fields

input: MemoryAddress

radix: MemoryAddress

output_pointer: MemoryAddress

num_limbs: MemoryAddress

output_bits: MemoryAddress

Trait Implementations

impl Clone for BlackBoxOp

fn clone(&self) -> BlackBoxOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BlackBoxOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlackBoxOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for BlackBoxOp

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

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 PartialEq for BlackBoxOp

fn eq(&self, other: &BlackBoxOp) -> 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 Serialize for BlackBoxOp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BlackBoxOp

impl Eq for BlackBoxOp

impl StructuralPartialEq for BlackBoxOp