Confidential computing on Base — encrypted in, computed blind, verified on-chain.
Sealed on the client.
Your user's data is encrypted before it ever leaves their device. What travels the network is ciphertext. Even Glasel cannot read it.
Computed without being seen.
A network of independent nodes runs your program on the encrypted data using multi-party computation. No single node holds enough information to see the plaintext. None of them ever do.
Verified and settled on Base.
The result arrives threshold-signed by the node cluster and verified on-chain before your contract acts on it. You don't have to trust the nodes — the math checks their work for you.
“$3 billion is taken from traders every year by front-running bots — because every on-chain trade is public before it executes.”
Blockchains are public by design. That's what makes them trustworthy — and the wall that has kept every sensitive application out.
A hedge fund can't put its order flow on-chain. Front-running bots see every trade before it executes.
A hospital can't store patient records on a blockchain. Every balance would be public.
An AI company can't run inference on-chain. Every prompt would be readable by anyone.
These aren't edge cases. They're the three largest markets in enterprise software — finance, healthcare, and AI — and none of them can use blockchain today, because there is no such thing as private computation on a public network. Until Glasel.
Three function calls. Fully private. Proven on-chain.
import { GlaselClient, ORDER_SCHEMA } from "@confide/client";
import { createPublicClient, http } from "viem";
import { baseSepolia } from "viem/chains";
const glasel = new GlaselClient({
publicClient: createPublicClient({ chain: baseSepolia, transport: http() }),
addresses: { coordinator, clusterManager, mxeFactory },
});
// 1 — Encrypt a typed value to the cluster's X25519 key.
const clusterKey = await glasel.getClusterPublicKeyForMXE(mxeId);
const { encInputs } = glasel.encrypt({
schema: ORDER_SCHEMA, clusterKey,
value: { price: 1000n, quantity: 7n, side: true, buyerKey },
});
// 2 — Commission on-chain. Inputs are never decrypted on Base.
const computationId = await commission(mxeId, compDefId, encInputs);
// 3 — The network computes, threshold-signs, and settles.
const { encResult } = await glasel.watchComputation({ computationId });
const result = glasel.decryptResult({ encResult, privateKey, schema: ORDER_SCHEMA });The encryption, the MPC execution, and the on-chain verification happen automatically. You write the business logic. Glasel handles the confidentiality.
Deployed and live on Base Sepolia — not a prototype, a full protocol stack.
Foundry unit tests plus 20 checks against the live deployment. Every computation path is covered.
A critical and three high findings — all resolved before this version shipped.
Coordinator at 0x1FbB…8452. The code does what it says.
A complete confidential computing stack.
Everything you need. Nothing you have to trust.
End-to-end encrypted
Your users' data is encrypted on their device with X25519 and Rescue-Prime — a cipher designed to run inside multi-party computation. Plaintext never exists on the network.
The network computes blind
The arxOS node network runs your compiled circuit across a cluster of independent operators. Each holds a fragment of the computation. None — below the threshold — can see the inputs.
Results you don't have to trust
Every result carries a BLS threshold signature from the cluster, verified on-chain before your callback fires. You don't take the network's word for it. The contract checks the math.
Base handles the rules
Eight smart contracts on Base schedule jobs, verify results, distribute fees, and slash misbehaving nodes. Transparent, auditable, and upgradeable — as protocol infrastructure should be.
Nodes have skin in the game
Every Arx node stakes $GLASEL to join a cluster. Miss a deadline or submit a wrong result and the stake is slashed automatically — no committee, no appeals. The incentives enforce themselves.
Write circuits, not crypto.
You define what the computation does. Glasel makes it impossible for anyone to see the data it runs on.
- Simulate locally before you deploy — no nodes needed for testing
- One command from source to testnet
- Typed inputs — write structs, not field elements
- The encryption is identical on client and server — proven byte-for-byte
This is the entire confidential function.
// order_notional.rs — compiled with `confidevm compile`
// The whole body runs inside MPC. No party, and no
// on-chain observer, ever sees `price` or `quantity`.
#[confidential]
fn order_notional(price: u64, quantity: u64) -> u64 {
price * quantity
}The MPC network runs it. Nobody reads the inputs.
If it's sensitive, it belongs on Glasel.
Dark pools
Place large trades without bots seeing your order first. The first private order book on Base.
Sealed auctions
Bidders can't see each other's bids. The highest bid wins. The losing bids stay sealed.
Private voting
On-chain governance where votes are secret until the poll closes — no bandwagon effect, no coercion.
Confidential AI
Run model inference on encrypted inputs. The model never sees your users' prompts. Neither does anyone else.
Compliance scoring
Score wallets or transactions without exposing the criteria — or the results — to anyone but the requester.