Private
value transfer
on a real L2.
BLOX produces its own blocks on a fixed 500 ms slot, executes standard transactions through an unmodified VM pipeline, and anchors a multi-asset shielded pool natively in the node — amounts and ownership stay private between deposit and withdrawal.
Sequencer-signed blocks at a fixed 500ms slot. Not an indexer, not a wrapper — its own ledger.
System, token, and user-deployed programs execute unmodified. If your code runs on the base layer, it runs here.
A multi-asset shielded pool is native in the node. Proofs verify on the node's CPU budget, not inside a contract VM.
RECENT TRANSACTIONS
VIEW ALL →From signed tx to settled block.
Client signs a tx. Shielded txs carry a Groth16 proof generated locally.
Tx enters the mempool over the node's p2p layer. No external sequencer.
A leader assembles the next 500ms slot, orders txs, signs the block header.
Standard VM runs program logic. Shielded txs verify against the commitment tree.
Block root is anchored to the base layer; DA is replayable from any full node.
Notes, not accounts.
Every shielded deposit mints a commitment into an append-only Merkle tree. Spending a note publishes a nullifier — the network learns nothing about which leaf was consumed, only that it was consumed exactly once.
One unit, paid in BLOX.
Execution and proof verification meter against a single compute-unit budget. Fees burn 50% and route 50% to the active sequencer set — no separate proving market, no off-protocol relayers.
A familiar RPC surface.
import { BloxClient } from "@blox/sdk";
const blox = new BloxClient("https://rpc.testnet.blox.run");
const wallet = await blox.wallet.fromMnemonic(MNEMONIC);
// 1. fetch unspent notes owned by this viewing key
const notes = await blox.shielded.listNotes(wallet.viewingKey);
// 2. build a 2-in / 2-out shielded transfer
const tx = await blox.shielded.transfer({
inputs: [notes[0], notes[1]],
outputs: [
{ to: RECIPIENT, asset: "BLOX", amount: 12_500_000n },
{ to: wallet.changeAddr, asset: "BLOX",
amount: notes[0].amount + notes[1].amount - 12_500_000n - FEE },
],
});
// 3. proof generated client-side; node only verifies it
const sig = await blox.sendTransaction(tx);
await blox.confirm(sig, "finalized");Where we are. Where we're going.
Sequencer-signed blocks, shielded pool, bridge UI, explorer, indexer.
Open the sequencer set; BFT consensus over 500ms slots; slashing.
Anchor block roots to the base layer; full data-availability proofs.
User-deployed circuits sharing the shielded pool's anonymity set.
Questions we get
most often.
Is BLOX a rollup?+
BLOX produces its own blocks and settles roots to a base layer. It is closer to a sovereign L2 than a smart-contract rollup — execution is native, not re-executed by a verifier contract.
Who runs the sequencer today?+
During Stage 0 the sequencer set is operated by the core team. Stage 1 opens it permissionlessly with stake-weighted leader rotation.
Do I need a special wallet?+
No. Standard signing works for transparent txs. Shielded txs need a viewing key and a local prover — both are bundled in @blox/sdk and the reference wallet.
Can the team see my balance?+
No. Amounts, asset types and ownership inside the shielded pool are hidden by the Groth16 circuit. The node only ever sees commitments and nullifiers.
What if the sequencer goes down?+
Testnet halts until the sequencer restarts and replays from the last finalized slot. Stage 1+ uses a BFT set, so liveness survives single-node failure.
Bridge in. Send privately.
Withdraw whenever.
Testnet BLOX is free. The bridge, the shielded pool and the explorer are all live right now — no waitlist, no allowlist.