TRUSTTEE co-processor · settlement-execution layer
← PostCryptum Research

A technology · applications are built on it

A TEE co-processor — not an L2, not a chain.

TRUST runs the work a smart contract would do inside attested enclaves, signs with an M-of-N threshold (threshold Schnorr) that assembles no key in one place, and settles on the chain’s own native primitives — multisig, atomic tx, on-chain data. Code updates activate only when the operator quorum signs a new measurement. Phoenix, XPerp and the bridge are applications of this engine; the next one plugs into the same stack.

// 01  The wedge

Chains without native VMs

Every chain whose settlement layer carries no Turing-complete VM — a meaningful, structurally underserved slice of market cap. Not an EVM/SVM play. On XRPL, TRUST is the intermediate layer: enclave logic today for what the ledger doesn’t do natively — shielded transfers, lending logic, agent-payment policy — and a path to an amendment once it does.

Chain
Native VM
Contracts
TRUST applies?
Ethereum
EVM
Yes
Not the target
Solana
SVM
Yes
Not the target
Bitcoin
None
No
Yes
XRPL
None
No
Yes
Cardano
Plutus (limited)
UTxO-restricted
Candidate

// 02  Composition — three primitives

Remove one and it collapses

Mutually reinforcing, not additive. Drop any one and TRUST collapses into something that already exists — a consortium chain, signing-as-a-service, or attested SaaS compute.

01

Native chain primitives

M-of-N multisig + atomic transactions + on-chain data field + public verifiable ledger. Whatever the chain natively exposes — P2WSH/P2TR, SignerListSet, OP_RETURN.

02

TEE-attested business logic

Matching, settlement math, threshold signing inside hardware-isolated enclaves, measured and remotely attested. Keys never leave silicon.

03

Code / operator separation

Cryptographically enforced. Operators control which code runs without controlling what each operation does — reproducible build → the quorum admits a measurement.

// 03  The stack — technology vs applications

A three-layer stack, not a pattern in the abstract

Layer
What it is
Shipped
L0 · Framework chain- & app-agnostic
Reproducible-build TEE binary, libp2p mesh signing, threshold-signing orchestration, Safe-multisig path, attested key-share transport, audit toolchain
Production
L1 · Chain modules chain-specific
BTC (P2WSH / P2TR / threshold Schnorr), EVM (Safe + V7 registry), XRPL (SignerListSet + escrow + crypto-conditions)
All 3 shipped
L2 · Applications interchangeable
Phoenix · XPerp · Bridge today — and any new app on the same L0/L1
Testnet

L0 + L1 are the technology (production / all shipped). L2 is where applications live — each inherits the trust model, attestation pipeline, multisig settlement and operator quorum. Build an app, don’t rebuild the engine.

// 04  Running today — three flagships (L2)

Phoenix

Prediction markets

  • XRPL: 81,000+ auto-published markets (mirrored from public sources) via the canonical multisig path · t-of-n SignerList · escrow + crypto-conditions
  • Bitcoin: 89,000+ auto-published markets · full E2E on regtest + testnet4 · threshold Schnorr t-of-n / P2WSH · OP_RETURN commitment
  • TEE-resolved markets — preimages & keys never leave hardware; 7-source oracle
  • Native-coin settlement — no wrapped tokens, no IOUs
ph18.io →

Status · testnet MVP

XPerp

Perpetual futures

  • Native XRP collateral, L1 settlement in 3–5s — no bridges, no L2 withdrawal delay
  • Margin engine inside the enclave — operators can’t front-run or see positions
  • Attested key-share transport verified on a real 3-node cluster (full sealed-state migration)
  • 20+ internal adversarial security-review rounds (REQ/RESP) — findings resolved or gated pre-mainnet
xperp.fi →

Status · testnet, relaunch next

TRUST Bridge

Shielded cross-chain

  • Dual light-client / SPV verification against pinned anchors
  • Threshold Schnorr signing on Bitcoin Taproot
  • Release gated by an in-enclave proof of the counter-chain lock, bound to its amount
  • Delivery into Zcash’s shielded (Orchard) pool — in development
Bridge security overview →

Status · testnet · privacy in development

The technology is the product. Applications are interchangeable.

Each new app reuses L0/L1 and inherits everything; the deltas are measured per target. Confidant is our compliant shielded pool for XRPL — encrypted notes and nullifiers with selective disclosure via viewing keys (hackathon build, testnet). Run its pool inside the enclave and you get shielded XRPL on attested hardware — enclave-enforced privacy alongside the zk design.

Confidant → shielded XRPL

Confidant’s private XRPL pool running inside the enclave — same L0/L1, new app logic.

Options DEX

Same M-of-N settlement on BTC / XRPL, different payoff math.

Lending vaults

Native-coin collateral, enclave-margined; very high framework reuse.

Attested oracles / custody-as-service

API over the ceremony toolchain; cross-chain swaps; BTC↔Monero.

// 05  The differentiator

Decentralized from genesis: the update is a threshold ceremony

Most systems decentralize custody but keep a centralized upgrade path — an admin key or a git push that silently changes what every node runs. That path is the one TRUST closes first.

Any change to the enclave code changes its measurement, and the new measurement is admitted only by a quorum ceremony of the physical nodes — the same t-of-n authority that governs funds. Builds are reproducible, so independent operators each rebuild to the identical measurement before they consent. No admin key, no out-of-band push — for every build, test versions included.

Code changeAny enclave build → a new measurement.
→
Quorum ceremonyEach node reproduces + measures the build, then co-signs admission. The old enclave exports sealed state only to a quorum-approved new binary.
→
Then it runsThe cluster admits exactly that measurement — nothing else runs.

// 06  Trust model & trade-offs, declared

“Trustless” is wrong — the truth is specific

What you trust

  • + Enclave manufacturer — the same trust as your own CPU; a per-deployment choice
  • + Reproducible-build pipeline — verifiable by independent operators
  • + Operator quorum — quorum-gated updates, quorum-signed payouts

What you don’t

  • − The dev team — can’t ship code the quorum didn’t sign
  • − Any single operator — no one moves funds or changes code alone
  • − Bridges, wrapped tokens, off-chain custody

Not a strict improvement — a different trade-off point

  • On-chain composability is lost. No flash loans or contract-to-contract calls; bridges needed for cross-protocol.
  • Public state auditability is lost. Privacy is the feature; code attestation stays public via reproducible build.
  • Liveness is compound (chain AND quorum) — but every withdrawal has a time-locked cancel_after; funds are never quorum-captured.
  • Chain coverage is aspirational — ships BTC + XRPL today; each new chain is a per-chain port.

// 07  Not bound to one enclave platform

Enclave platform
Status
Process-level hardware enclaves
Production today
VM-level confidential computing (two CPU vendors)
Migration-ready · analysis complete
Cloud-provider managed enclaves
Migration-ready · analysis complete

The reproducible-build invariant carries across hardware platforms: the dev team cannot ship a binary that doesn’t reproduce, and the operator can refuse to run code they didn’t agree to. A per-platform migration analysis lives in-repo. Closest analog overall: a permissioned chain — TRUST adds execution privacy from the operators themselves and chain independence. Validated 2026-06: 3-peer cluster producing valid commits.

One engine. Any application. No single party that can betray it.