The Council’s key, its members’ verification keys, the whole transcript of its key generation, every rotation and every share a member posts are on chain, so anyone can recompute the Council from its transcript, confirm it is the one installed, follow each rotation to the current members, and re-verify each share. What the Council is and when it acts is on Council.
Where the Council is recorded#
The CouncilConfig account holds the Council epoch, the Council key , the member count , the threshold , one verification key per member, where is that member’s share of the Council secret, and one Ed25519 signing key per member. With and : any four members together learn nothing about the secret, and the Escape completes with four offline. initialize_council wrote it once at epoch 0, and only rotate_council changes it (Checking a rotation).
/trust shows , and each verification key. The account layout is in Accounts, and the API serves the same values in Registry, Council and liveness. The Council’s transcript is listed under the same address: every council_log transaction names it.
The Council never decrypts in public. It only re-encrypts, toward a key the chain has verified.
A check from the account alone#
The verification keys are shares of one secret , with for the second ristretto255 generator , which is derived by hashing so that no one knows its discrete logarithm to base . For any members , with Lagrange coefficients :
A set of keys for which every choice of gives is a -of- sharing of the secret behind . The program runs this check itself: initialize_council and rotate_council accept a set only if the first keys interpolate to , every other key lies on the same sharing, and . The key came from a distributed key generation in which no party ever held , and the next section recomputes it from its transcript.
Checking the key generation transcript#
Every message of key generation is a council_log payload under the Council’s address, signed by the member that sent it. The transcript alone yields the Council key and every verification key, so a checker compares them with the Council initialize_council installed without trusting any node.
Reading it#
List the transactions under the Council’s address with getSignaturesForAddress and read each with getTransaction. In each council_log instruction’s payload argument, or the same bytes in its CouncilTranscript event, a payload that starts with PVCD1 is one chunk of a message:
| Bytes | Holds |
|---|---|
| 0..5 | PVCD1 |
| 5..37 | SHA256 of the whole message |
| 37..41 | chunk index, u32 |
| 41..45 | message length in bytes, u32 |
| 45.. | the chunk, up to 1,600 bytes |
The chunks of one digest join in index order. The message stands when its length and SHA256 match, and it lands at the latest slot of its chunks. A message is JSON { "member", "body", "signature" }: body holds kind, phase (the sharing, secret, mask or zero, or null), session, deadline (a slot) and data, and signature is the member’s Ed25519 signature over privium/council-transcript/v1 followed by body as compact JSON with its keys sorted. Byte strings are arrays of numbers.
kind |
Per sharing | data |
|---|---|---|
deal |
yes | The dealer’s Pedersen commitments and one HPKE-sealed share pair per member |
complaints |
yes | The dealers whose pair failed for this member |
answers |
yes | The pairs a dealer posts in answer to complaints against it |
qualified |
yes | The qualified dealers, as this member computed them |
reveal |
yes | The dealer’s Feldman commitments |
reveal-complaints |
yes | Pairs this member discloses against a reveal its pair fails |
reconstruction |
yes | This member’s pairs from dealers proven to have revealed falsely |
finished |
yes | The reveals after reconstruction |
product |
no | The member’s masked product with its proof |
verification |
no | The member’s with its proof |
installed |
no | The Council as the member installed it |
What it proves#
Authenticate each message#
Member ‘s key is
signer_keys[j - 1]inCouncilConfig. A message counts when its signature verifies under its member’s key, it carries the run’s one session id, it landed no later than its deadline slot, and its data is the member’s own: the dealer of its deal, reveal and answers, the recipient of its complaints, reveal complaints and reconstruction shares, the member of its product and verification. No member has two different messages of one kind and phase; the nodes themselves stop on a transcript where one does.Fix the qualified sets#
For each sharing, a dealer is qualified when every complaint against it has an answer whose pair satisfies its Pedersen commitments, for the secret, with and swapped for the mask and the zero sharing. Every member’s
qualifiedmessage states the same set.Rebuild the public shares#
Each qualified dealer’s
revealgives Feldman commitments on the sharing’s base: for the secret, for the mask and the zero sharing. A pair inreveal-complaintsthat satisfies the dealer’s Pedersen commitments while times the base differs from marks the dealer, whose coefficients thereconstructionpairs rebuild by interpolation; thefinishedmessages state the corrected reveals. Summing over the qualified dealers gives , and for every member, and from the mask’s constant terms. The zero sharing’s constant commitment is the identity.Recompute the Council key#
Each
productcarries and a Chaum-Pedersen proof that . Interpolating all values at zero gives , and equals thejoint_keythatinitialize_councilinstalled.Match the verification keys#
Each
verificationcarries and a Chaum-Pedersen proof that , and each equalsverification_keys[j - 1]ininitialize_council’s arguments. Theinstalledmessages state the Council every member installed: epoch 0, , , the Council key, the verification keys and the members’ signing keys.
Both proofs take their challenge from SHA256 over a domain tag (privium/council-product/v1, privium/council-key/v1), the two bases, the two images, the two commitments and the session id, reduced to a scalar.
Checking a rotation#
initialize_council and every rotate_council name the Council’s address and carry the Council they install as CouncilArgs in their instruction data: the epoch, the Council key, the verification keys, the signing keys and . Listing the address with getSignaturesForAddress therefore gives the Council’s whole history in order. Check each rotate_council against the Council before it:
Check the signers#
At least of the previous Council’s signing keys sign the transaction, with the previous Council’s threshold.
Check the epoch and the key#
epochis the previous epoch plus one, andjoint_keyis the previous Council key.Check the new sharing#
The new verification keys pass the check from the account alone with the new . With unchanged, interpolating to again shows that the new shares are shares of the same secret .
The last Council in the history equals CouncilConfig. An Escape records the Council epoch when it is triggered, rotate_council fails from then on, and every Escape share is checked against that epoch’s verification keys.
Checking the data key release#
The wrapped Ledger data key and every release of it are in the same transcript (The Ledger data key).
- The wrapper is one payload: JSON
{ "kind": "ledger-wrapper", "data": { "wrapper", "enclave" }, "signature" }, withsignaturean Ed25519 signature overprivium/ledger-wrap/v1followed by the JSON ofdata, under the signing key of theEnclaveKeyaccount thatenclavenames. A valid wrapper comes from a record admitted at stage 2 whose interval holds the slot the wrapper landed in, names this program andjoint_key, carries a handle that is a valid point other than the identity, and seals a 48-byte ciphertext. The first valid wrapper is the Pool’s. - Each release is a
key-releasemessage signed by its member, with no session or deadline: the member’s , and proof toward the enclave’s . The transcript shows which members released the key and at which slot; the enclave checks each proof against the member’s before it combines of them. - Its recipients hold a from an admitted Registry record, bound by the quote that admitted it (Attestation).
What a share proof proves#
A member’s share toward a recipient key (an owner’s escape key , or an enclave’s ) for a handle (a leaf’s Council handle, or the wrapper’s ) is the pair
with a fresh random , and a proof of knowledge of satisfying , and . The proof is commitments and responses , checked by
where the challenge hashes a domain tag, the whole statement and a context: in an Escape, the program id and the request’s address; in a data key release, the program id, the enclave’s record, the wrapper and the enclave’s fresh challenge. An accepted share therefore:
- was made with the member’s registered share and no other value;
- re-encrypts toward exactly this recipient key, for exactly this request;
- tells nothing about the balance to anyone without the recipient’s secret key.
Shares that fail their proof are rejected one by one, so any valid shares complete the combination. Combined with the Lagrange coefficients of their members, they give and , from which only the holder of ‘s secret recovers the value.
Checking an Escape’s shares#
Everything an Escape uses is on chain, so anyone can re-verify a payout end to end:
Read the request#
The
EscapeRequestaccount holds the leaf’s commitment and Council handle , the owner’s escape key and the leaf index, all verified against the frozen root when the request opened.Verify each share#
Each
escape_sharetransaction carries a member’s , and proof. Recompute with the request’s address in the context, and check the three equations against that member’s inCouncilConfigand the request’s and .Recombine#
Combine the first valid shares with their Lagrange coefficients and compare the result with the the program stored on the request.
Check the claim#
The
escape_claimtransaction carries the amount , the destination, and the owner’s proof that for , with the program, the request, its mint and the destination in its context. A passing proof shows that is the leaf’s committed balance and that the holder of the escape key chose the destination. The payout follows the settlement rule on Escape.
While an Escape is active, /trust shows its state, and the Escape panel on /account shows the shares arriving against .