Operations

​

Quick Summary

​

Table of contents

• Expression support
  • Binary expressions
  • Casts
  • Literals
  • Methods
  • Paths
• Item support
• Pattern support

​

Expression support

​

Binary expressions

​

Cast expressions

​

Function calls

• user-defined function calls (without recursion)
• ArcisRNG::bool() to generate a boolean.
• ArcisRNG::gen_uniform::<T>() to generate a uniform value of type T (bool, integer, or combination). Requires explicit type parameter.
• ArcisRNG::gen_integer_from_width(width: usize) -> u128. Generates a secret integer between 0 and 2^width - 1 included.
• ArcisRNG::gen_public_integer_from_width(width: usize) -> u128. Generates a public integer between 0 and 2^width - 1 included.
• ArcisRNG::gen_integer_in_range(min: u128, max: u128, n_attempts: usize) -> (u128, bool). Generates a random integer in [min, max] using rejection sampling. n_attempts must be compile-time known. Returns (result, success) where success=false indicates all attempts were rejected. With n_attempts=24, failure probability is <2^-24.
• ArcisRNG::shuffle(slice) on slices. Complexity is in O(n*log³(n) + n*log²(n)*sizeof(T)).
• Mxe::get() to be able to create MXE-owned secret data.
• Shared::new(arcis_public_key) to share private data with arcis_public_key.
• ArcisX25519Pubkey::from_base58(base58_byte_string) to create a public key from a base58-encoded address.
• ArcisX25519Pubkey::from_uint8(u8_byte_slice) to create a public key from a Uint8 array.
• SolanaPublicKey::from_serialized(value) to create a Solana public key from serialized form.
• SolanaPublicKey::from_base58(byte_string) to create a Solana public key from base58.
• ArcisMath::sigmoid(x) for the sigmoid activation function.
• LogisticRegression::new(coef, intercept) for logistic regression models.
• LinearRegression::new(coef, intercept) for linear regression models.
• Pack::new(value) to bit-pack data for onchain storage (multiple small values fit into fewer field elements).
• ArcisX25519Pubkey::new_from_x(x: BaseField) to create a public key from its Curve25519 Montgomery X-coordinate.
• ArcisX25519Pubkey::to_x() to extract the Montgomery X-coordinate from a public key.

​

Literal expressions

​

Macros

• debug_assert!, debug_assert_ne!, debug_assert_eq!. They do not change instruction behavior and are only useful for debugging your Rust code.
• eprint!, eprintln!, print!, println!. They do not change instruction behavior and are only useful for debugging your Rust code.
• arcis_static_panic!(message) to fail compilation when the branch is reached. Useful for enforcing constraints that must be known before circuit generation.

const ARRAY_LEN: usize = 3; // Change to 1 and the example will not compile.

fn second_element(arr: &[u8]) -> u8 {
    if arr.len() < 2 {
        arcis_static_panic!("Array must have at least 2 elements");
    }
    arr[1]
}

#[instruction]
fn reveal_second_element(input: Enc<Shared, Pack<[u8; ARRAY_LEN]>>) -> u8 {
    let array = input.to_arcis().unpack();
    second_element(&array).reveal()
}

​

Method calls

• user-defined method calls (with generics but without recursion)
• .clone() on all Clone objects.
• .len(), .is_empty(), .swap(a, b), .fill(value), .reverse(), .iter(), .iter_mut(), .into_iter(), .windows(width), .copy_from_slice(src), .clone_from_slice(src), .split_at(mid), .split_at_mut(mid), .rotate_left(mid), .rotate_right(mid), .contains(item), .starts_with(needle), .ends_with(needle) on arrays and slices.
• .sort() on arrays of integers. Complexity is in O(n*log²(n)*bit_size).
• .enumerate(), .chain(other), .cloned(), .copied(), .count(), .rev(), .zip(other), .map(func), .for_each(func), .fold(init, func), .sum(), .product() on iterators.
• .take(n), .skip(n), .step_by(n) on iterators when n is compile-time known.
• .reveal() if not inside an if or else block where the condition is not a compile-time constant
• .to_arcis() on Encs
• .from_arcis(x) on Owners (objects of types Mxe or Shared) if not inside an if or else block where the condition is not a compile-time constant
• .abs(), .min(x), .max(x) on integers and floats
• .abs_diff(other), .is_positive(), .is_negative(), .div_ceil(other) on integers
• .to_le_bytes(), .to_be_bytes() on typed integers (does not work on integers whose type the interpreter does not know)
• .exp(), .exp2(), .ln(), .log2(), .sqrt() on floats.
• .unpack() on Pack<T> to extract the original value from packed storage.
• .to_arcis_with_pubkey_and_nonce(pubkey, nonce) on EncData<T> to decrypt when the key is shared across inputs (avoids duplicate decryption gates).

​

Paths

• IntType::BITS, IntType::MIN and IntType::MAX where IntType is an integer type.
• Paths to user-defined constants, functions and structs, as long as they don’t use the unsupported crate or super.
• std::mem::replace and std::mem::swap

​

Item support

​

Pattern support

• simple idents: let ident = ...;
• mutable idents: let mut ident = ...;
• ref idents: let ref ident = ...;
• mutable ref idents: let ref mut ident = ...;
• parentheses around a supported pattern: let (...) = ...;
• reference of a supported pattern: let &... = ...;
• array of supported patterns: let [...] = ...;
• struct of supported patterns: let MyStruct { ... } = ...;
• tuple of supported patterns: let (...) = ...;
• tuple struct of supported patterns: let MyStruct(...) = ...;
• type pattern of a supported pattern: let ...: ty = ...;
• wild pattern: let _ = ...;

​

Generics

​

Generic Functions

#[encrypted]
mod generics_example {
    use arcis::*;

    // Use a pre-built optimized circuit by name
    // The empty function body is intentional - the circuit implementation is built-in
    #[arcis_circuit = "zero"]
    fn make_zero<T: ArcisType>(a: T) -> T {}

    fn set_zero<T: ArcisType + Copy>(a: &mut T) {
        *a = make_zero(*a);
    }

    #[instruction]
    fn zero_any_type(mut arr: [u8; 10], mut val: u64) -> ([u8; 10], u64) {
        set_zero(&mut arr);
        set_zero::<u64>(&mut val);  // Turbofish syntax works
        (arr, val)
    }
}

​

Generic Structs

struct Wrapper<T>(T);

impl<T> Wrapper<T> {
    fn new(value: T) -> Self {
        Wrapper(value)
    }

    fn into_inner(self) -> T {
        self.0
    }
}

#[instruction]
fn use_generic_struct(a: u8) -> u8 {
    Wrapper::new(a).into_inner()
}

​

Custom Traits

trait Processable {
    type Output;
    fn process(&self) -> Self::Output;
}

impl Processable for u8 {
    type Output = u16;
    fn process(&self) -> u16 {
        *self as u16 * 2
    }
}

fn apply_process<T: Processable>(val: &T) -> T::Output {
    val.process()
}

#[instruction]
fn trait_example(x: u8) -> u16 {
    apply_process(&x)
}

​

Generic Constraints

​

Iterators

​

Supported Iterator Methods

#[instruction]
fn iterator_examples(arr: [u8; 10]) -> u16 {
    // Basic iteration
    let mut sum = 0u16;
    for val in arr.iter() {
        sum += *val as u16;
    }

    // Method chaining
    arr.iter()
       .map(|x| *x as u16)
       .map(|x| x * 2)
       .sum()
}

​

Complete Iterator Support

​

Filter Alternative

// ✗ Not supported
arr.iter().filter(|x| **x > threshold).sum()

// ✓ Manual filter pattern
#[instruction]
fn filter_sum(arr: [u8; 10], threshold: u8) -> u16 {
    let mut sum = 0u16;
    for val in arr.iter() {
        if *val > threshold {
            sum += *val as u16;
        }
    }
    sum
}

​

What’s Next?