The Pool accepts a Commit only under a key in the Registry, and the Registry admits a key only from an Intel TDX quote showing that a Trust Domain with an admitted measurement generated it. Anyone can rebuild each measurement from the tagged source, and a new one joins the admitted set only after two liveness windows on chain.
The measurement#
The Coprocessor boots as an Intel TDX Trust Domain (TD) by Canonical’s direct boot: the TDVF virtual firmware loads a kernel and an initramfs, and there is no writable root disk. The initramfs holds the Coprocessor binary with its dynamic loader and shared libraries, the public configuration it reads at boot, and a minimal /init that mounts the TD’s own tmpfs and starts only the Coprocessor. The CPU records each stage into SHA-384 registers that can be extended but never rewritten, so the final values commit to the whole ordered boot sequence. Privium’s measurement is the vector
MRTD covers the TD’s initial contents, the virtual firmware. RTMR0 to RTMR2 are the runtime registers the firmware extends with the TD’s configuration (its ACPI tables and CPU topology among it), the kernel, its command line and the initramfs. XFAM names the CPU features the TD may use. The Coprocessor never extends RTMR3 and takes no owner configuration at launch, so RTMR3, MRCONFIGID, MROWNER and MROWNERCONFIG are zero in every admitted quote, and the DEBUG attribute is clear.
The Registry holds the admitted measurements, up to eight, each the digest . initialize_registry sets the initial ones, and each later one arrives through a proposal that waits on chain (How a measurement is added). /trust shows the current enclave’s measurement, its platform, the key epoch and the slot its attestation was verified. The enclave image rebuilds the measurement from source.
What a quote proves#
A TD quote is signed by an Attestation Key that Intel’s TD Quoting Enclave generated. That enclave’s report is signed by the processor’s Provisioning Certification Key (PCK), whose certificate chains to the Intel SGX Root CA. Intel-signed collateral (TCB Info, QE Identity, revocation lists) states which platform firmware levels and quoting enclave builds are current. A quote is admitted only if every check holds:
| Check | Establishes |
|---|---|
| Header: version 4, ECDSA P-256 attestation key, TEE type TDX | a TDX quote in the format the program parses |
PCK chain to the Intel root whose hash VerifierConfig holds, nothing revoked, TCB level current, proven once per platform by the DCAP guest’s Groth16 proof in admit_platform, which the admin signs |
a genuine, up-to-date Intel processor produced it |
| Quoting enclave report signed by the PCK and matching QE Identity | an Intel quoting enclave certified the Attestation Key |
| Attestation Key digest equals the one in the quoting enclave’s report | the key that signed the quote is that certified key |
| Quote signature verifies under the Attestation Key | the measurement and report data are the TD’s own |
| Every TEE_TCB_SVN byte at least the floor the platform’s proof set | the TDX module runs at the proven TCB level |
| DEBUG clear; owner fields and RTMR3 zero; in the admitted set | the TD runs admitted code, its memory closed to the host |
| Report data equals the value the program computes | the quote names exactly the keys being registered |
Report data binds the keys#
At the start of each key epoch the Coprocessor generates three key pairs inside the TD:
| Key | Type | Used for |
|---|---|---|
| Ed25519 | signing open_crossing, vault consolidations, Residual orders, Commits and Receipts, each under its own domain tag |
|
| X25519 | the HPKE key traders seal Intents, deposit notes and account registration to | |
| ristretto255 | the key the Council re-encrypts the Ledger data key to |
It places their hash in the quote’s 64-byte report data:
is the Pool program id and a recent slot and its slot hash. The program recomputes from the submitted keys, so one quote binds one deployment, one epoch and exactly these three keys. It checks against the SlotHashes sysvar when registration starts, so the quote was produced after slot existed.
stage_enclave takes any fee payer, and the record it writes sits at an address derived from the signing key alone. Before the Coprocessor asks the TD for a quote, it reads the staged record back and compares its epoch, its three keys, its platform and its validity interval with the keys it generated. On any difference it discards those keys, generates a fresh set and stages again, so every quote it produces carries report data over keys it holds.
Registration and the Registry#
Registration runs the checks above on chain. The processor’s certificate chain and Intel’s collateral are admitted once per processor by admit_platform, through a Groth16 proof of Intel’s standard collateral checks that the program verifies; it admits only an UpToDate TCB status, and the platform record it writes serves registrations until the collateral’s earliest expiry. The admin signs every admission and every renewal, so a platform enters with the admin’s approval as well as the proof. A newer proof for the same processor, over fresh collateral with a later expiry, renews the record through admit_platform: the same checks run, the expiry and the TCB and Quoting Enclave fields are rewritten, and the PCK, the verifier and the development classification stay as they were. A proof whose expiry is not later is refused with PlatformRenewal. Each enclave and epoch then registers in three instructions: stage_enclave records the keys and computes the report data against SlotHashes, verify_enclave_qe checks the quoting enclave’s report under the platform’s PCK and records the Attestation Key’s digest, and register_enclave checks the quote under the Attestation Key, its contents and the report data. Solana’s secp256r1 precompile verifies both P-256 signatures. Accounts and transactions are in Instructions.
Each registration writes an EnclaveKey account of its own, at the address derived from enclave and the signing key: the epoch , , , , the platform, the measurement, and the validity interval in slots. An admitted quote also enters the keys, the interval and the platform in the Registry, which is what the program reads on every signature check. The Registry holds up to four keys, at most one per platform and key epoch, and admits keys only for the current epoch or the next. A key a platform registers for an epoch supersedes that platform’s earlier key for the same epoch in its slot at once, and the superseded key signs nothing from then on. Each registration also clears the platform’s keys of earlier epochs whose intervals have ended, and a key with no slot of its platform’s to take fills a free slot or one whose interval has ended. A platform’s current key and its next epoch’s key stand side by side across the boundary. EnclaveKey accounts stay on chain after their epoch ends, so a Commit or Receipt signed under an earlier key stays checkable.
From then on each Commit needs one Ed25519 check. The signature travels in an Ed25519 program instruction placed just before commit; the program reads the key and the message back from that instruction and accepts only a key the Registry admitted whose interval contains the current slot. The enclave’s key is not a transaction signer, so any relayer can submit the Commit.
Key epochs and rotation#
Keys live for one epoch of slots, about 12 hours, the length the Registry was initialized with. Rotation is re-attestation: before an epoch ends, the Coprocessor generates the next epoch’s keys and registers them with a fresh quote, so its current and next keys are both in the Registry across the boundary, and each signs only inside its own interval. The next epoch’s first Commit chains from the last root signed under the previous key.
The SDK reads from the Registry. Every Intent’s HPKE context names the program and the key epoch, so an Intent opens only under the key of the epoch it names.
A newly admitted enclave obtains the Ledger data key from the Council, which re-encrypts it only to a in an admitted Registry record (The Council).
How a measurement is added#
New Coprocessor code reaches the Registry as a new measurement , through two instructions:
Propose#
propose_measurementis signed by the program’s upgrade authority, which the program reads from the ProgramData account at that moment. It writes aMeasurementProposalaccount at["measurement", M']holding , a digest of its source commit, a digest of its build manifest, the proposal slot and the activation slot: the proposal slot plus twice the Pool’s liveness window at that time, slots at , about one hour. A measurement already in the Registry is refused, and each measurement is proposed once.Wait#
Until the activation slot, is pending.
activate_measurementis refused withMeasurementPending, and a quote of fails registration like any measurement outside the admitted set.Activate#
From the activation slot on, anyone can send
activate_measurement, which appends to the Registry and marks the proposal activated. Quotes of then admit keys by the checks above, and those enclaves receive the Ledger data key from the Council.
Activation changes nothing else in the Registry: keys already admitted keep their epochs and validity intervals, and the earlier measurements stay admitted. The upgrade authority is a governance multisig whose execution enforces its own time lock (Upgrade authority), so a proposal passes that time lock before it lands and then stays pending on chain for , time for anyone to rebuild from its source and compare, and for a trader to Exit under the current code. With an honest threshold of the Council releasing the data key, every enclave that holds the Ledger data key or signs an accepted Commit therefore runs code whose measurement was set at the Registry’s initialization or was on chain for before it could admit a key.
Each proposal and activation also emits an event, MeasurementProposed and MeasurementActivated (Events), so a watcher sees a pending measurement the slot it lands.
Check it yourself#
Read the Registry#
Open /trust, or read the Registry account (Accounts, Registry, Council and liveness): the admitted measurements and the registered keys with their validity intervals and platforms, and each key’s
EnclaveKeyaccount with its epoch, platform and measurement. For each measurement added after initialization, itsMeasurementProposalshows when it was proposed and from which slot it could activate.Rebuild and measure the image#
Check out the source commit of the measurement and build and measure the enclave image as The enclave image sets out. The measurement tool replays the firmware’s extend sequence over the built image and prints the registers and the Registry digest a quote of it reports.
Compare#
The Registry digest you built is in the Registry and, for the current enclave, equals the measurement on /trust. The registers you built equal the ones in the quote that each
register_enclavetransaction of that measurement carries.Follow the keys to the Commits#
Each
committransaction carries its Ed25519 instruction with the signing key. That key belongs to anEnclaveKeyof an admitted measurement, and the Commit’s slot falls inside its validity interval.
The program’s verifiable build#
The Pool program is checked the same way: its deployed bytecode rebuilds from the tagged source with the Solana Verify CLI, which builds in Docker, and the verification record sits in a program-derived account anyone can recheck. Reproducing the builds carries the commands for the program, the enclave image and the attestation guest.