Docs - Velum

§04Documentation

Build against sealed state.

What exists today: the testnet SDK, the encrypted state layout, and the parameters the network runs on.

Architecture

A confidential instruction crosses four boundaries. Exactly one of them can turn ciphertext back into a value, and it needs 64 independent parties to agree to do it.

Client keyring

Keys never leave the device. The client encrypts inputs and holds the only path to a plaintext result.

Robinhood Chain

Ordering, fees and asset ownership stay on Robinhood Chain. Velum adds a ciphertext field, not a new chain.

Evaluator mesh

Stateless workers that apply homomorphic circuits to ciphertext. They can compute; they cannot read.

Threshold committee

A t-of-n committee holds shares of the decryption key. Output is revealed only to the address that owns it.

Quickstart

The client SDK handles keygen, encryption and the re-keying dance for private outputs. Programs declare their circuit in Rust and compile to Stylus WASM against a homomorphic instruction set.

TypeScript · client

transfer.ts

import { Velum, seal } from "@velum/sdk";

const velum = await Velum.connect("robinhood-testnet");
const keyring = await velum.keyring();           // stays in the browser

// positions are sealed under the committee key
const amount = seal(75n, keyring.publicKey);

const tx = await velum.call(vault, "transfer", {
  to: recipient,
  amount,                                        // ciphertext, 3.1 KB
});

// only the owner can open the resulting balance
const balance = await velum.reveal(tx, keyring);
console.log(balance);                            // 337n

Rust · Stylus program

lib.rs

use velum_sdk::prelude::*;

#[velum::circuit(depth = 3)]
#[public]
impl Vault {
    pub fn transfer(&mut self, to: Address, amount: Enc<u64>) -> Result<()> {
        let src = self.sealed.get(msg::sender());
        let dst = self.sealed.get(to);

        // evaluated on ciphertext; no branch observes a value
        let ok = fhe::ge(&src, &amount);
        self.sealed.set(msg::sender(), fhe::sub(&src, &fhe::mul(&amount, &ok)));
        self.sealed.set(to,            fhe::add(&dst, &fhe::mul(&amount, &ok)));

        Ok(())
    }
}

Shell

install

npm i @velum/sdk
cargo add velum-sdk
velum dev --network robinhood-testnet

Network parameters

Scheme	TFHE (CGGI)	torus-based, programmable bootstrapping
LWE dimension	n = 1024	128-bit classical security
Ciphertext	3,128 B	packed 64-bit integer
Noise budget	128 bits	fresh ciphertext
Bootstrap cost	~170 ms	single-threaded evaluator, testnet
Committee	t = 64, n = 128	proactive re-sharing per epoch
Epoch	8 hours	committee rotation interval
Settlement	Robinhood Chain	ordering, gas, asset ownership
Runtime	Stylus (WASM)	Rust programs, EVM-compatible calls

Roadmap

P0TestnetTFHE evaluator, 32-node threshold committee, encrypted ERC-20-compatible transfers.shipped
P1Sealed programsRust SDK for encrypted contract state; homomorphic ALU exposed as a Stylus precompile.active
P2Encrypted inferenceQuantised transformer blocks over ciphertext; model weights sealed to the committee.next
P3Mainnet128-node committee, hardware acceleration, permissionless evaluator onboarding.planned

Questions

Is this a new chain?: No. Velum is an execution layer attached to Robinhood Chain. Accounts, signatures, gas and ordering belong to the chain; Velum adds an encrypted data path and the machinery to compute on it.
Who can decrypt my state?: Only the key holder for private outputs. Public outputs are opened by a threshold committee where no member holds a complete key and at least 64 of 128 must cooperate.
What happens if the noise budget runs out?: The plaintext is unrecoverable. Programs declare their circuit depth statically, and the runtime inserts bootstraps so this cannot happen in a deployed program.
Can I run an evaluator?: On testnet, by request. Permissionless onboarding is gated on the P3 milestone, together with the slashing conditions for circuit-proof failures.