Types - Arcium Docs

The following types are supported:

u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize
f64, f32 (emulated as fixed-point with 52 fractional bits; supported range is [-2^75, 2^75). Values outside this range are unsupported.)
tuples of supported types, including ()
fixed-length arrays of a supported type
slices with compile-time known length (e.g., &arr[..] from fixed arrays, or &[u8] parameters in stdlib APIs like SHA3)
compile-time known ranges
(mutable) references to a supported type
user-defined structs of supported types
user-defined enums of supported types (but not as input or output of an encrypted instruction; explicit discriminants are unsupported)
Option<T> of a supported type (but not as input or output of an encrypted instruction)
functions (but not as input or output of an encrypted instruction)
ArcisX25519Pubkey, an Arcis public key wrapper.
Arcis-defined Enc, Mxe and Shared.
Pack<T>, a wrapper for bit-packing data into fewer field elements for onchain storage.
EncData<T>, encrypted data without embedded cipher info. Use with .to_arcis_with_pubkey_and_nonce() when multiple values share the same key.
BaseField25519, integers modulo 2^255 - 19. The native field element for Arcis MPC circuits. Supports arithmetic (+, -, *, negation), unsigned comparisons, and field division methods. Construct via BaseField25519::from_u64(x) (and similar from_* methods); extract via .to_u64_unchecked() (only when the value fits the target type — out-of-range values silently produce incorrect results). See Primitives.

Float emulation: Arcis emulates f64/f32 as fixed-point with 52 fractional bits. This differs from IEEE 754 floats:

Different precision characteristics than standard floats
Supported range: [-2^75, 2^75)
Float literals outside this range produce a compile-time error: "Arcis only supports inputs in the range [-2**75, 2**75)"
Computed values outside this range are silently clamped to the boundary values

Encryption types

Type	Description
`Enc<Shared, T>`	Encrypted data shared between client and MXE
`Enc<Mxe, T>`	Encrypted data for MXE only
`EncData<T>`	Raw encrypted data (advanced use, see below)
`Shared`	Owner type for client-shared encryption
`Mxe`	Owner type for MXE-only encryption

The Owner type parameter determines who can decrypt:

Shared: Both client and MXE can decrypt. Use for user inputs/outputs that need client-side verification.
Mxe: Only the MXE cluster can decrypt. Use for internal protocol state that users should not access.

Public key types

Type	Description
`ArcisX25519Pubkey`	Arcis X25519 public key wrapper
`SolanaPublicKey`	Solana public key (32 bytes)
`SerializedSolanaPublicKey`	Serialized form using `{lo: u128, hi: u128}`

Example

use arcis::*;

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

    #[derive(Copy, Clone)]
    struct GameState {
        score: u64,
        level: u8,
    }

    #[instruction]
    fn example(
        user_data: Enc<Shared, u64>,
        state: Enc<Mxe, GameState>,
    ) -> Enc<Shared, u64> {
        let value = user_data.to_arcis();
        user_data.owner.from_arcis(value * 2)
    }
}

Advanced: EncData<T>

EncData<T> stores just the encrypted ciphertext without encryption metadata (pubkey + nonce).

Type	Contains	Size
`Enc<Shared, bool>`	pubkey (32B) + nonce (16B) + ciphertext (32B)	~80 bytes
`EncData<bool>`	ciphertext only	~32 bytes

EncData<T> omits pubkey and nonce metadata, useful for multiple outputs where callback payload size matters.

Primary use: smaller callback payloads

Use EncData<T> when returning encrypted data to observers to reduce callback payload size:

#[instruction]
pub fn check_solana_public_key_equality(
    encrypted_pk1: Enc<Shared, SerializedSolanaPublicKey>,
    encrypted_pk2: Enc<Shared, SerializedSolanaPublicKey>,
    observer: Shared,
) -> EncData<bool> {
    let pk1 = SolanaPublicKey::from_serialized(encrypted_pk1.to_arcis());
    let pk2 = SolanaPublicKey::from_serialized(encrypted_pk2.to_arcis());
    let res = pk1 == pk2;
    observer.from_arcis(res).data  // Extract .data from Enc
}

When to use EncData output: Multiple return values where encryption metadata would be redundant.

When returned from circuits, EncData<T> generates EncDataStruct<N> in your Solana program, where N is the number of field elements in T (e.g., EncData<bool> → EncDataStruct<1>). See Callback type generation.

The MXE encrypts outputs with nonce + 1. See Encryption overview for nonce handling.

Secondary use: shared key input optimization

When multiple inputs share the same encryption key, Enc<Shared, T> duplicates the key-derivation circuit for each input. Use EncData<T> with explicit key/nonce to avoid this:

#[instruction]
fn optimized_sum(
    key: ArcisX25519Pubkey,
    t_nonce: u128, t: EncData<u64>,
    u_nonce: u128, u: EncData<u64>,
) -> u64 {
    let t_val = t.to_arcis_with_pubkey_and_nonce(key, t_nonce);
    let u_val = u.to_arcis_with_pubkey_and_nonce(key, u_nonce);
    (t_val + u_val).reveal()
}

EncData<T> is an advanced optimization with security implications:

Nonce uniqueness: Each (key, nonce) pair must be unique. Reusing nonces compromises security.
Silent failures: Using the wrong key or nonce produces garbage data without error; MPC cannot add runtime validation since that would leak information.

For most use cases, use Enc<Shared, T> or Enc<Mxe, T>, which handle key management automatically.

Unsupported types

Arcis does not currently support HashMap, Vec, or String because these types have variable length. Constant-size byte strings, such as b"hello_world", are supported. The Enc type defines encrypted data input as Enc<Owner, T>, where Owner can be either Mxe or Shared. Owner determines which party can decrypt data of type T. See Input/output for encrypted input and output patterns.

Storage representation: All values are stored as 256-bit Curve25519 field elements. A u8 uses the same storage as a u128; integer type bounds are enforced at compile time, not by storage size. Use Pack<T> to compress multiple small values into fewer field elements for onchain efficiency.

What’s next?

Input/output

Working with Enc<Owner, T> for encrypted inputs and outputs.

Thinking in MPC

MPC constraints and the operation cost model.

​Encryption types

​Public key types

​Example

​Advanced: EncData<T>

​Primary use: smaller callback payloads

​Secondary use: shared key input optimization

​Unsupported types

​What’s next?

Input/output

Thinking in MPC

Encryption types

Public key types

Example

Advanced: EncData<T>

Primary use: smaller callback payloads

Secondary use: shared key input optimization

Unsupported types

What’s next?