Status: Landed
Type: Standards Track
Category: Core
Created: 2026-04-29
Updated: 2026-10-14
Requires: CIP-2 (off-chain compute), CIP-6 (SDK + entitlements), CIP-9 (CBFS-backed runner storage), CIP-12 (governance)
Related: Secrets Whitepaper, revision v0.1.2, Technical Whitepaper §9 (system-actor registry), CIP-23 (TEE Execution — optional additional gate, not the trust root)
Cowboy Cloud and Cowboy Chain. This CIP specifies the Cowboy protocol. Cowboy Cloud runs on this protocol today. Cowboy Chain, a public network on the same protocol, is under consideration for a future release. Where the two differ, this CIP says so.
Background
Actors need third-party API credentials. Validators replay actor execution, so credentials readable in the PVM are visible on chain. A dispatcher that can unwrap credentials becomes a plaintext custodian.Goal
Specify account-owned secrets, threshold release to authorized runners, and cross-account access.1. Abstract
CIP-24 specifies the Cowboy Secret Service (CBSS): how an account stores third-party API credentials such that- plaintext is never visible on chain or to validators,
- secrets can be deleted forever (no archival ciphertext that becomes decryptable as cryptography ages),
- only the specific keys an actor names at the call site are released to the runner,
- release is just-in-time and the dispatcher is not in the trust path,
- cross-account sharing is supported, and
- the trust root is t-of-n proxy non-collusion, not a hardware enclave.
0x0000…0004 holds on-chain state. Off chain, staked CBSS proxies (SecretsProxy) run the cbssd daemon. Accounts own secrets, not actors. Per-secret ACLs control which actors can consume them. The n proxies establish each per-account release keypair (MPK ∈ G2, MSK ∈ scalar field) in a single threshold BLS DKG ceremony. The ceremony runs once per account. The proxies hold Shamir shares of MSK; they never reconstruct it. At release time, any t proxies return BLS partial signatures on the per-version identity; the runner Lagrange-combines them into the IBE decryption key and unwraps the DEK. Defaults: n = 5, t = 4, BLS12-381. The threshold follows the vetted Commonware N3f1 DKG quorum for the five-proxy default.
For high-value secrets where the per-account blast radius is unacceptable, an owner MAY specify a per-secret committee override at SetSecret time. The override triggers a one-off DKG for that specific secret-version with its own (MPK, MSK, committee, t, n), isolated from the account default. An owner can give STRIPE_LIVE_KEY a separate committee and use the account default for SLACK_API_KEY.
CBSS rejects TEE as the trust root for secret release. CIP-23 TEE attestation remains available as an additional gate per secret (the tee_required flag), but the underlying release is unconditionally non-TEE. Rationale in §10.
CBSS uses BLS12-381 with a threshold identity-based-encryption (IBE) construction, equivalent to drand’s “tlock” scheme. Required libraries include blstrs for curve operations, the pinned Commonware BLS DKG state machine (or an equivalent vetted threshold-BLS DKG), and tlock (drand) for the IBE construction. CBSS adds BLS12-381 as a curve dependency. Account keys continue to use secp256k1; CBSS uses its own cryptography alongside secp256k1. See §3.4.
The owner is offline at job time, and VRF selects the runner at job time. The owner therefore cannot pre-issue runner-specific key material. CBSS binds the key to a stable on-chain identity, the account by default or the secret on override. The committee holds shares of its private key and releases decryption material only through a t-of-n threshold operation. Threshold decryption requires no dispatcher or TEE. A secret can additionally require CIP-23 attestation.
Workload signing amendment
Persistent-workload secret grants add three typed signing purposes:SignFeedPublish (wire tag 2), SignSubmitTransaction (3) and SignCreatorTransaction (4). Tags 0 and 1 keep their meaning. Feed-owner operations do not define a fourth purpose in this amendment. Grant terms MUST NOT mix a signing purpose with a non-signing purpose on one secret, because EgressInject sends the raw secret out.
The three purposes and the manifest’s workload.sign entitlement activate together under WORKLOAD_SIGNING_PURPOSES_ACTIVATION_HEIGHT, a new per-network gate left NOT_SCHEDULED everywhere. Below it, existing EgressInject and WebhookVerify grant bytes and admission behavior remain unchanged. New signing purposes and entitlement declarations are refused below that gate.
workload.sign allowlists signing purposes, publisher keys, targets and a maximum transaction fee. Typed broker signing releases no private key into workload memory and requires a live workload attempt, authorized grant and current lease/fence, rechecked after release. Feed-publish shard selection is u32_be(SHA256(feed_address)[0..4]) % shard_count; creator operations require shard 0. Both generic feed.publish and a listed feed-address publish target must validate the publish envelope. The broker’s within-attempt sequence history does not replace the Feed’s on-chain continuity check.
The feed.subscribe, feed.fund_subscription and feed.unsubscribe signing targets belong under this same gate; broker subscription calls additionally require the subscription codec. A sponsor-only Subscribe MUST carry an empty handler and no reaction. The broker refuses a nonempty handler: the consumer owner sends that Subscribe directly, as CIP-51 §6.6 specifies. The required core check is pending final confirmation there. The CIP-51 target grammar is the full list. Other operations remain on the account owner’s direct signing path. The broker does not enforce an elapsed-block settlement bound: monotone counts and the hire reservation are enforced on chain, and a compromised workload may over-report up to that reservation. CIP-51 §6.11 specifies the listing’s dependencies and open signing-policy work.
2. Motivation
2.1 The problem
Actors call third-party APIs (Slack, OpenAI, GitHub, Stripe, etc.) that require credentials. Hard-coding credentials in actor source, reading a plaintext CBFS file or decrypting in actor PVM Python violates at least one of these requirements:- Validators replay actor execution; anything readable in the PVM is readable on chain.
- Anything written to chain history is decryptable forever as cryptography ages. Secrets leak retroactively.
- An actor that can read
OPENAI_API_KEYshould not also be able to readSTRIPE_LIVE_KEYjust because the same account owns both. - A dispatcher that can unwrap credentials or volume DEKs becomes a plaintext custodian. CBSS keeps the dispatcher off the key path for both.
2.2 Design philosophy
CBSS stores encrypted secrets in CBFS. Registered proxies release them through a threshold operation into an in-memory runner bundle for a single runner-op. Explicit subprocess env maps are used only when required. Application-layer actors implement rotation policies, audit pipelines, HSM-backed wrapping and DAO-controlled secrets, following CIP-13 §2.1. With optionalcbssd ingest enabled, the proxy also
persists encrypted envelope bodies in its local upload queue, including failed
fanout rows after retrying ends. The ingest path does not decrypt the payload.
See Ingest ciphertext retention
for the acknowledgement and deadline lifecycle.
2.3 Why not TEE-rooted release
CIP-23 ships TEE-attested execution. That solves a different problem: bounding the runner host’s introspection of in-flight actor state. Using the same anchor for secret release would mean every secret on the network becomes retroactively exfiltratable on a single CPU-vendor microarchitectural break (Foreshadow / Plundervolt / SGAxe / CipherLeaks have all happened to deployed TEEs). An enclave compromise exposes the secrets it wrapped, whose ciphertext remains available. CBSS relies on t-of-n proxy non-collusion and economic slashing. The failure mode (≥ t simultaneous proxy compromises) is independent of any single hardware vendor and can be reduced through operator diversity policy. §9 quantifies the trade.3. Specification
The key words MUST, MUST NOT, REQUIRED, SHOULD, SHOULD NOT, and MAY in this document are to be interpreted as described in RFC 2119. Parameters marked governance-tunable can be changed by on-chain governance (§4).3.1 New data structures
SecretId
KeyName (plaintext, regex [A-Z][A-Z0-9_]{0,127}, case-sensitive ASCII) appears in CLI / SDK input, in actor manifest entitlements, in a job’s secret_slots (§5.2), and in the runner sandbox during a runner-op. Chain instructions (§3.5) take key_hash directly, never plaintext, so the mempool, tx args, storage paths, and event fields don’t observe literal key names. The CLI computes keccak256(account || key_name) locally before submitting any tx. Plaintext names are still visible in deployed manifests (validator-readable) and dictionary-guessable for common names (e.g., OPENAI_API_KEY); see §3.2 (“H(key) honesty”) for the realistic privacy boundary.
The account field namespaces keys by owning account. Policy grants cross-account access (§3.1.5); the namespace does not.
SecretKeyRef
Jobs carry secret references insecret_refs, the secrets= read set (§5.1/§5.2), and JobPrecondition.secret_ref (§5.5). CBSS uses SecretId to key its on-chain storage. Both types carry the same {account, key_hash} pair as SecretId. The job reference has a separate type because its bytes belong to the versioned JobSpec encoding (CIP-11 §12.6). It MUST use the byte-identical key_hash derivation so a SecretKeyRef in a job resolves to the matching SecretId in CBSS storage:
SecretKeyRef is a plain struct on the wire (positional account then key_hash, no enum tag). It carries no plaintext key name, satisfying the “chain instructions take key_hash directly” rule above. On the SDK interface (§5.2) a caller writes either a bare name (runner.secret("KEY_NAME"), or "KEY_NAME" in a container job’s secrets=) or the explicit cross-account form (runner.secret("KEY_NAME", account=...)); a bare name resolves to the owning account of the actor issuing the runner-op. The actor’s manifest secrets.* entitlements are what authorize the release (§5.1). Implementations MUST NOT resolve a bare name to any other account (e.g. the transaction submitter). In both forms the client library fills account and computes key_hash locally before submitting the job spec, as the CLI does for SecretId. The wire always carries an explicit pair: account is required on every SecretKeyRef, and there is no implicit-account variant on the wire.
SecretMetadata
The on-chain record for a secret. Stored at0x04 keyed by SecretId.
SecretVersionHighWaterMark
This record sets the monotonic floor for version allocation. The chain stores au64 at 0x04 keyed by SecretId (byte layout in §3.2). Every SetSecret writes the version it allocated. The value only increases and is never lowered or deleted. It survives DeleteSecretVersion, DeleteSecret, RotateCommittee force_rekey, and expired override DKGs. This is a committed record, not derived state. Implementations MUST NOT garbage-collect it. The allocation rule and the non-reuse rationale are in §3.2, “Secret version allocation and non-reuse”.
SecretVersion
Immutable per(SecretId, version). Created by SetSecret; deletable by DeleteSecretVersion.
wrapped_dek regardless of ACL size. The ACL is only a runtime gate, not a cryptographic recipient list. Adding or removing an actor updates metadata without a chain re-wrap. Storage cost per version is O(1).
SecretPolicy
actors == None resolves at release time to “any actor whose owning account == this secret’s owning account.” actors == Some([...]) is an explicit allowlist and MAY include actors owned by other accounts (cross-account grant; unilateral, no acknowledgment from the recipient account required).
Effective access = (actor’s CIP-6 manifest declares the key under the entitlement matching the release purpose: secrets.read for the read set (secret_refs) and secrets.verify for a verify= MAC check, §5.5) AND (SecretPolicy allows the actor) AND (if tee_required, runner provides a valid CIP-23 attestation). The purpose is derived from the stored JobSpec, precondition-first: a key named by JobPrecondition.secret_ref releases as the verify key (gated by secrets.verify); a key named in secret_refs releases as a read-set key (gated by secrets.read). The assignment is unambiguous because the §5.5 overlap rule forbids the same {account, key_hash} in both roles within one job. A key held only under secrets.verify is releasable for the MAC check but MUST NOT fill a secret_slots entry (§5.2), and vice-versa.
AccountReleaseKey (default path)
The threshold-shared per-account keypair. Stored at0x04 keyed by Address. Created by the DKG ceremony (§3.6.1); rotated by reshare (§3.6.2). Reused across all of an account’s secrets that don’t specify a per-secret override.
committee_epoch is bookkeeping for the share polynomial. It does not appear in the IBE identity or AEAD AAD. The identity is bound to a per-version wrap_epoch, and the AEAD AAD is that same canonical base plus the per-wrap ephemeral_u (see §3.4.3). PSS preserves MSK across reshare, so a proxy’s current share validly partial-signs any identity ever wrapped under MPK, regardless of the wrap_epoch on the original SecretVersion.
SecretReleaseKey (override path)
Same shape asAccountReleaseKey but scoped to a single (SecretId, version). Stored at 0x04 keyed by that pair. Created lazily when an owner submits SetSecret with committee_override = Some(...). Allows per-secret committee parameters (size, threshold, member preference) for high-value secrets that should not share blast radius with the rest of an account’s secrets.
SecretReleaseKey is single-use in the sense that it is only consumed by its one owning (SecretId, version). Deleting that secret-version (DeleteSecretVersion or DeleteSecret) cascades to the deletion of the corresponding SecretReleaseKey and emits a ShareZeroizationRequested event; share zeroization on committee members is best-effort, not chain-enforced (see DeleteSecret Effects in §3.5).
CbssProxy
The on-chain record of a registered proxy operator. Stored at0x04 keyed by ProxyId.
WrappedDek (IBE envelope)
The existing leading tagversion=2 identifies the current BLS12-381 IBE,
HKDF and AES-256-GCM envelope suite. It is a closed suite selector: decoders and
consensus validation MUST reject every other tag. Decoders cannot accept an
unknown tag as opaque future ciphertext. This tag belongs to the committee-envelope namespace,
separate from CIP-40 signature algorithms and CIP-9 owner/grant algorithms.
CIP-9 §9.1 specifies a fixed 62-byte tagged symmetric owner envelope. Only
§9.2.1’s grant envelope carries bounded variable-length recipient keys and KEM
ciphertext. Neither changes this committee suite or enables a post-quantum
algorithm.
For CIP-9 volume committee envelopes, consensus at CreateVolume and
RewrapVolume MUST use a bounded, fixed-integer bincode decoder, reject trailing
bytes and require version 2, exactly 48 ciphertext bytes and exactly 96
ephemeral_u bytes. Any other envelope is rejected. These stateless admission
checks do not decompress G2 or validate AAD/identity binding; those checks remain
at release time under CIP-9’s volume identity (§9.3 below). This does not change
the committee envelope bytes or the account-secret AAD validation below.
The stored CIP-9 volume committee envelope uses bincode 1 with fixed-integer,
little-endian encoding, in this exact order:
ciphertext, ephemeral_u and aad are length-prefixed byte vectors; only
nonce is an unprefixed array. The [u8; 96] in the WrappedDek struct below
describes the validated value. Its bincode container remains a vector. Admission retains the
512-byte total bound (MAX_SERVICE_VOLUME_WRAPPED_DEK_BYTES)
and rejects trailing bytes. A release-valid volume envelope carries exactly
128 AAD bytes, the 32-byte volume AAD followed by the 96-byte ephemeral_u
(§9.3), and totals
309 bytes. The AAD/identity binding and G2 checks remain release-time checks;
admission does not enforce them.
Private volumes, CBSS account secrets and Cowchat room keys are protected against
classical attackers only. The BLS committee wrap, owner ECDSA derivation and HPKE
X25519 grant wrap are not post-quantum secure.
Algorithm tags allow format changes. They provide no confidentiality against
future quantum decryption of previously collected ciphertext.
The encrypted DEK on chain. AES-256-GCM with the IBE-derived key K (see §3.4.3). There is no public-key envelope per recipient. The IBE construction uses one ciphertext regardless of ACL size. The recipient is implicit in the per-version identity I = hash_to_G1( u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2, domain = "cbss/ibe/v1" ). The encrypted wrap still needs the Boneh-Franklin encryption ephemeral U = r · G2_gen; U is public KEM material, not a recipient key.
U denotes the G2 group element and ephemeral_u = compress(U) denotes its stored 96-byte canonical compressed encoding; formulas over the struct field use ephemeral_u directly. In aad, u64_le(version) is the secret version number (SecretVersion.version, u64). The envelope’s 1-byte format-version tag never enters aad or the key derivation. u64_be(chain_id) is the deploying chain’s 8-byte big-endian chain identifier (the same value bound into tx signatures and release requests), and mpk_g2 is the 96-byte canonical compressed encoding of the resolved release key’s master public key MPK (i.e. compress(MPK), the exact bytes of the mpk field on the AccountReleaseKey/SecretReleaseKey this version is wrapped to). Endianness is deliberate and required: chain_id is big-endian, version and wrap_epoch are little-endian, and mpk_g2 is raw 96-byte compressed G2. Owner-side encryption and chain-side validation MUST agree byte-for-byte; any change here is wire-breaking.
The serialized WrappedDek format version is 2, carried as a leading 1-byte version tag on every serialization (the first byte of the on-chain codec, the leading field of CBOR/JSON forms). Readers MUST reject any other tag value with a typed error (UnsupportedWrappedDekVersion; §5 error table). The tag frames the wire format. It NEVER enters the AEAD aad or the key derivation. Validation compares the full aad for equality:
AadMismatch when len(aad) != 172 + 96 (i.e. != 268), when the prefix is not the canonical 172-byte base_aad the chain re-derives for the (chain_id, SecretId, version, wrap_epoch, mpk_g2) tuple, or when the final 96 bytes do not equal ephemeral_u. (The length condition is exact equality. A longer AAD with a valid prefix and valid ephemeral_u suffix is still malformed, per the full-equality rule above.) The chain derives chain_id (its own) and mpk_g2 (from the resolved release key’s committed mpk, never from the envelope), so an envelope wrapped under a substituted mpk' produces a base_aad that does not match the chain’s re-derivation and is rejected here with AadMismatch, the same fail-closed check that gives the IBE identity its release-key binding (§3.4.3).
3.2 Storage layout in 0x04
The chain omits plaintext key names from storage paths and transaction arguments. The §3.5 instructions all take key_hash: Bytes32 directly. Plaintext key names DO appear in:
- CLI / SDK input (the user types
OPENAI_API_KEYintocowboy secrets set). - Actor manifest entitlements (
secrets.read.keys: [...]). Manifests are owner-deployed and validated by the chain; their entitlement keys are visible to validators, indexers, and any node that fetches the manifest. Owners who require unguessable key names should use random suffixes there too (see §5.1). - The runner sandbox during a single runner-op (as the substituted plaintext value’s identifier).
- A job’s
secret_slots(§5.2): each slot names the key it fills, so the name is visible wherever the job spec is.
key_hash = keccak256(account || key_name). Validators and chain observers see only key_hash in storage paths, tx args, and event fields. Common names remain dictionary-guessable, as described in “H(key) honesty” below. Hashing prevents passive scraping.
The Secrets Whitepaper §2 defines the complete physical key inventory and each family’s creation/deletion lifecycle, including maintenance and co-located TEE rows. The principal secret and evidence keys are:
u64 bytes. Spaces and + above are notation only: literal prefixes concatenate with raw bytes, with the extra literal : only in the evidence-epoch key. The high-water mark key is exactly b"secret_version_hwm:"[19] ‖ account[20] ‖ key_hash[32] (71 bytes). Prior serving-grace epochs are embedded in the release-key records. A tombstone carries deleted_at_block, was_pending and optional public {version, recipient, wrap_epoch} evidence context; it contains no ciphertext. Evidence history has a per-recipient index and one public value per epoch, with the admission/retention rules in §3.5.
Six collection families under physical actor 0x04 use version-1 binary state codecs at the auth-v3 genesis. Every encoded value below fits the 65,536-byte actor-value limit, including at its full admitted shape.
Decoders reject wrong versions, malformed lengths, over-capacity collections, duplicate members and trailing bytes. Receipt committee IDs and receipt-entry proxy IDs are each unique; receipt and partial entry order is preserved. Collateral heights must be strictly increasing. The TEE admission and retention rules are in CIP-23 §3.8.
MAX_CBSS_RELEASE_COMMITTEE_SIZE = 90 is the common storage-fit ceiling for
current, prior, pending, receipt and tlock committees, including retained
release-key evidence. Committee, threshold and VSS-commitment shapes are checked
against that ceiling. It does not change the default committee size of 5 or the
separate spec-only override policy ceiling of 15 (§4.2).
The maximal receipt entry is 1 + (420 + 69) + (133 + 69) = 692 bytes:
its version byte, maximal signed request and signed response, with each
secp256k1 Native slot occupying 69 bytes. A receipt set uses
44 + n × (32 + 692) bytes. At n = 90 it is exactly 65,204 bytes;
n = 91 requires 65,928 bytes and exceeds the 65,536-byte value limit.
The tlock partial-set bound is 11 + 90 × (32 + 48) = 7,211 bytes.
The trusted-key index uses 3 + 640 × 51 = 32,643 bytes with tagged,
compressed P-384 keys as its largest entry.
Secret version allocation and non-reuse follow this rule. Every SetSecret, on both the default and override paths, allocates the next version as next_version = max(SecretMetadata.latest_version, secret_version_hwm) + 1, computed with checked u64 addition. Allocation fails closed only when the floor max(SecretMetadata.latest_version, secret_version_hwm) is already u64::MAX, so no successor fits. The chain then rejects the instruction without writing state. (Allocating the version number u64::MAX itself succeeds, when that floor is u64::MAX - 1.) On success the chain writes three entries in the same state batch: the new SecretVersion, the updated SecretMetadata, and the durable high-water mark secret_version_hwm:{account_hex}:{H(key)_hex} set to next_version.
The high-water mark is monotonic and irreversible: it is only ever advanced, never lowered or deleted. It survives either delete instruction, account force-rekey and override DKG expiry. SecretMetadata.latest_version selects the greatest surviving entry in active_versions for a versionless read; both DeleteSecretVersion and override ExpireDkgPending recompute it. If no active versions remain, the metadata and account secret-index entry are removed. A selected pending version still fails the pending-release gate. This read-selection rule never frees a version for reuse: the next SetSecret allocates strictly above the durable mark.
Producers MUST take the version from the chain and MUST NOT infer latest + 1 or assume 1 after a “not found”. The node exposes a bounded read-only route, GET /cbss/secret-next-version/{account}/{key_hash}, which returns { "next_version": u64 } with the same max(latest_version, secret_version_hwm) + 1 result (failing closed only when that floor is already u64::MAX, so no successor fits). Every SetSecret producer, the cowboy CLI, the SDK, and the dashboard, takes next_version from this route; on the override path the caller-supplied SecretSpecific(SecretId, next_version) MUST equal the chain’s allocated value or the instruction is rejected. A node that does not serve this route is a hard error for a producer, which MUST NOT fall back to a locally guessed version.
Checkpoint and state-restore tooling MUST preserve all CBSS state: the 0x04 actor-storage inventory and the 0x21 CbssPhaseState families described in the Secrets Whitepaper §2. This includes high-water marks, tombstones/evidence context, evidence indexes and epoch values, sweep indexes, reshare-outstanding markers, DKG pending/ceremony records, the reshare sweep cursor, and reshare outbox metadata/chunk pages. Tooling MUST carry each high-water mark verbatim: expired pending override versions are erased without tombstones, so surviving records cannot reconstruct the allocation floor.
The durable allocation floor prevents a recreated (account, key_hash) from reusing an earlier version’s release identity or deletion authority. The CBSS access rows for these writes are in §4.1.
For tee_required secrets, the logical TEE Verifier is 0x05, but node stores the trusted-key rows physically under 0x04: tee_trusted_key_index: plus type length, type bytes and measurement hash. The Secrets Whitepaper §2 gives the value types and lifecycle. TEE release authority comes only from the runner’s verified measurement binding (CIP-23); CBSS does not accept a proxy-supplied TEE assertion.
Plaintext key names appear only in: (a) the owner’s local CLI, (b) actor manifest entitlements (which are owner-controlled and meant to be public anyway), (c) the runner sandbox during a single runner-op, (d) a job’s secret_slots (§5.2). CBSS state never holds them.
H(key) honesty requires accounting for dictionary attacks. Validators and chain observers see only key_hash, not the key name, in the wire format. This MUST NOT be read as a privacy guarantee. key_hash = keccak256(account || key_name) is dictionary-recoverable: account is a public on-chain address that appears in the very same storage path/tx/event as key_hash, and key_name is, by the §3.1 regex, a short, human-chosen, typically low-entropy string (OPENAI_API_KEY, STRIPE_LIVE_KEY, SLACK_SIGNING_SECRET, and similar). There is no salt, per-account or otherwise, in this hash. A validator, or anyone who knows the account address and holds a wordlist of common key names, can recompute keccak256(account || guess) for each candidate and test it against the on-chain key_hash in negligible time; this tests a small set of known inputs, not a preimage attack against keccak256.
Consequently, key-name privacy under CIP-24 is best-effort and depends on high-entropy key names (e.g., an owner-appended random suffix, as suggested in point 2 above). Owners who need confidentiality of which service a secret is for SHOULD NOT rely on a common or guessable name being hidden by key_hash alone. key_hash hides the literal string from passive scraping by indexers, logs and casual observers. An adversary can still guess the account’s key names.
A salted or otherwise name-concealing key_hash construction (a CBSS-keyspace change so key_hash is no longer computable from public inputs plus a guess alone) is follow-up work and out of scope for this CIP.
3.3 Master opcode allocation update
The canonical protocol codec assigns opcodes 68–84 to CBSS. The allocation is:
Opcodes
152, 153, and 158 are the canonical assignments. The opcode-uniqueness test guards allocation conflicts.
TEE Verifier support instructions take opcodes 60–61 and serve the logical 0x05 TEE Verifier, whose trust records are physically stored at 0x04 (§3.2): RegisterTeeTrustedKey (60) and RevokeTeeTrustedKey (61). These are the canonical assignments for these slots; opcodes 62 and 63 are unassigned.
3.4 Cryptography
3.4.1 Vetted-library mandate
CBSS does not implement its own cryptography. It integrates published, externally reviewed cryptographic implementations in ~few hundred lines:
CBSS uses these libraries for identity construction, ciphertext envelopes, validation and share storage. Proactive secret sharing (committee resharing) is the one sub-protocol where a vetted Rust library does not yet exist; CBSS implements a thin wrapper following drand’s published resharing protocol. External crypto review is required before launch.
3.4.2 Curve choice: BLS12-381
CBSS uses BLS12-381. Cowboy account keys use secp256k1. The reasons for this choice are:- Vetted threshold-encryption libraries exist on BLS12-381. Drand, Lit, the Ethereum-adjacent ecosystem, and Filecoin all ship BLS12-381 threshold tooling at production scale. On secp256k1 the equivalent threshold-encryption tooling does not exist in vetted form; a CBSS implementation on secp256k1 would require hand-rolling the DKG, partial decryption, and NIZK glue, exactly the cryptographic engineering anti-pattern this CIP rejects.
- Pairing-friendly groups make threshold IBE possible with the simple Boneh-Franklin construction: encryption to an “identity” plus a threshold BLS signature on that identity is the IBE decryption key. This requires no custom key-switching construction.
- Ethereum’s beacon chain, Filecoin proofs and Drand use BLS12-381 at ≥ million-share scale, so library quality is high and corner cases are well-understood.
3.4.3 Construction: threshold IBE (“tlock” applied to secret release)
The construction is standard Boneh-Franklin-style threshold IBE plus threshold BLS signatures, applied with a CBSS-specific identity binding instead of a future-round binding. As in Boneh-Franklin IBE and drandtlock, each owner-side encryption includes a fresh encryption ephemeral r and publishes U = r · G2_gen in the envelope.
Throughout this CIP, the BLS12-381 pairing is e: G1 × G2 → GT. I lives in G1; MPK, S_i, and U live in G2; σ and σ_i live in G1. Pairings always take G1 first and G2 second.
A SecretVersion is bound at SetSecret time to the wrap_epoch = the release key’s committee_epoch at that moment. wrap_epoch is then immutable. Reshare changes the release key’s committee_epoch and rotates the share polynomial, but PSS preserves MSK, so a proxy’s current share validly partial-signs any identity ever derived under any historical wrap_epoch of the same release key. The IBE identity binds chain_id, wrap_epoch, and mpk_g2; the AEAD AAD binds all of those plus the per-wrap ephemeral_u; neither binds the live committee_epoch.
The binding field is mpk_g2. The base AAD binds raw mpk_g2, not a committee/threshold/VSS commitment, because mpk is the only reshare-invariant piece of release-key material: a reshare provably preserves MPK (the chain rejects a reshare whose new_mpk != prior_release_key.mpk; §3.5 RotateCommittee), while committee membership, threshold, and vss_commitments all rotate under PSS. At release time the identity’s wrap_epoch field is historical (read from the immutable SecretVersion) while the mpk_g2 fed to the pairing comes from the current release-key record. This works because reshare preserves mpk, so the current mpk equals the wrap-time mpk for every epoch the chain will still serve. The one case where they diverge is a force_rekey re-DKG, which installs a fresh MPK and simultaneously strands every ciphertext bound to the old one (§3.5), so the mpk_g2 binding never fails a release that would otherwise have succeeded. Binding any rotating field instead (e.g. release_key_material_hash) would strand a secret the moment its wrap-epoch’s material ages out; account secrets have no re-wrap path, so they MUST bind the invariant mpk. (CIP-9, which has an epoch-scoped re-wrap model, binds release_key_material_hash instead; see §9.3. The retired CIP-7 committee path used that binding too; replacement Watchtower does not use CBSS key delivery. Each family binds the strongest release-key commitment its re-wrap model supports.)
Setup runs per AccountReleaseKey or SecretReleaseKey:
- The n CBSS proxies in the committee run a threshold BLS DKG (the devnet implementation uses the pinned Commonware BLS DKG state machine; an equivalent vetted threshold-BLS DKG may be substituted by governance-reviewed implementation update). Round-2 share payloads are recipient-specific and HPKE-encrypted to each recipient’s on-chain
CbssProxy.hpke_pubkey. If timeout or complaint handling excludes a dealer, the daemon finalizes over an explicit qualified dealer set of at leasttmembers. Output: master public keyMPK ∈ G2, Shamir sharess_1 … s_n ∈ Frof the implicit master secret keyMSK ∈ Fr. Thresholdt.MSKis never reconstructed. MPKand the per-proxy commitmentsS_i = s_i · G2 ∈ G2are published on chain inAccountReleaseKeyorSecretReleaseKey.
cbss/tlock/v1, §3.4.6), CIP-9 volume DEKs (cbss/ibe/cip9-volume-dek/v1, §9.3), or the retired CIP-7 content-key family (cip-7-wd-v1). Each active family uses its own specified identity and AAD; replacement Watchtower key delivery is defined in CIP-7 and does not use CBSS.
The owner stores each secret-version as follows:
- Let
wrap_epoch= the release key’scommittee_epochat SetSecret/FinalizeSecretVersion time, andmpk_g2 = compress(MPK)the 96-byte compressed master public key of that release key (AccountReleaseKey.mpkon the default path,SecretReleaseKey.mpkon the override path). Define the 172-byte base AAD:base_aad = u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2wherecanonical(SecretId) = account(20) || key_hash(32)(§3.5), so the fixed-width layout ischain_id(8) ‖ account(20) ‖ key_hash(32) ‖ version(8) ‖ wrap_epoch(8) ‖ mpk_g2(96) = 172bytes. The leadingchain_idis the chain separation binding: a secret wrapped for chain A is rejected by chain B’s validation and its released σ cannot unwrap it. The trailingmpk_g2is the release-key binding: a secret wrapped under a substitutedmpk'hashes to a different identity, so the real committee’s σ can never open it. Owner derives the per-version identity using this canonical encoding (§3.5 SubmitReleaseReceipt):I = hash_to_G1( base_aad, domain = "cbss/ibe/v1" )(RFC 9380 hash-to-curve).I ∈ G1. The owner, the proxies, and the chain all computeIfrom these same inputs in the same byte encoding.Iis derived from the 172-bytebase_aad, not from the extended AEAD AAD below. - Owner samples a fresh encryption ephemeral scalar
r ←$ Frfrom a CSPRNG for every wrap, withr != 0, and computesU = r · G2_gen ∈ G2(96-byte compressed). The owner MUST NOT reuseracross secret versions. Define the AEAD AAD:aad = base_aad || compress(U). Owner computes the IBE encryption key forI:K = HKDF-SHA256( serialize(e(I, MPK)^r), "cbss/ibe/v1" || aad )wheree(I, MPK)^r ∈ GTis equivalentlye(I, r · MPK)ore(r · I, MPK), andserializeis the canonical compressed GT encoding (exactly 288 bytes;blstrsimplementsCompress for Gt). The notationHKDF-SHA256( ikm, info )is normative throughout this CIP and means RFC 5869 HKDF with salt = the ASCII bytes"cbss/ibe/v1"(the same 11-byte domain string as theinfoprefix, not absent, not empty),infoas written, and output length L = 32 bytes. The salt is required: a derivation withsalt = None/empty produces a differentK, so omitting it makes every wrap undecryptable cross-implementation. - Owner generates a fresh DEK (256 bits, CSPRNG). The owner AES-256-GCM-encrypts the plaintext value with DEK + a fresh nonce + the 172-byte
base_aad(the value envelope bindsbase_aad. It excludes theU-extendedaadbecause the value envelope’s keyDEKis independent ofU, so it binds only the chain- and release-key-bound base). The owner uploads the AES-GCM ciphertext to a private CBFS volume referenced bycbfs_pointer. Because the stored value envelope bindsbase_aad, any change tochain_id,canonical(SecretId),version,wrap_epoch, ormpk_g2invalidates the ciphertext of the secret value itself as well as its DEK wrap. Reconstructing a value envelope with different bound fields requires the plaintext; changing only the DEK wrap is insufficient. - Owner AES-256-GCM-encrypts DEK with
K+ a separate nonce and the 268-byte extendedaadfrom step 4 (base_aad || compress(U)), producingwrapped_dek. Only the DEK wrap binds the extended AAD; the chain re-derives and full-equality-checks all 268 bytes at SetSecret/FinalizeSecretVersion (§3.5). - Owner publishes
wrapped_dek + cbfs_pointer + wrap_epoch + recipient + policyon chain viaSetSecret(default path) orFinalizeSecretVersion(override path; see §3.5).wrapped_dekincludesephemeral_u = compress(U).
- Runner signs the
ReleaseRequestBodydirectly with its runner-registry key (the secp256k1 key registered with0x01Runner Registry, the same key it uses for any other authenticated runner-to-chain interaction). The IBE construction requires no runner-bound ciphertext or per-request runner ephemeral keypair. This is distinct from the owner-chosen Boneh-Franklin encryption ephemeralrin step 4. Both proxies (at PartialSign serve time) and the chain (at SubmitReleaseReceipt validation) verifyrunner_sigagainst the runner registry. - Runner reads the SecretVersion (carrying
wrap_epoch) and the referenced ReleaseKey (carrying current committee +S_is) from chain. Runner sends a release request to t proxies. Each proxy validates ACL/manifest/job-assignment/anti-replay (§3.7). - Each proxy computes the identity exactly as the owner did, using the SecretVersion’s
wrap_epochand the canonical encoding from step 3:I = hash_to_G1( u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2, domain = "cbss/ibe/v1" ), then its partial signature:σ_i = s_i · I ∈ G1(using the proxy’s current share s_i). PSS guarantees this works regardless of the relationship betweenwrap_epochand the proxy’s current share epoch. - Each proxy returns
σ_ito the runner. Verification is the standard BLS partial-signature check: validatee(σ_i, G2_gen) == e(I, S_i)whereS_i ∈ G2is the proxy’s published VSS commitment. Implementations MUST reject identity/point-at-infinityS_iandσ_ibefore the pairing check; otherwisee(0, G2_gen) == e(I, 0)passes vacuously. The BLS pairing equation proves correctness without a custom NIZK. - Runner combines t partial signatures via Lagrange interpolation in G1:
σ = Σ λ_i · σ_i = MSK · I ∈ G1(the full threshold BLS signature onI, equivalently the IBE decryption key forI). - Runner reads
wrapped_dek.ephemeral_u(decoding it toU; §3.1 notation), reconstructs the same extendedaad = base_aad || ephemeral_u, and derivesK = HKDF-SHA256( serialize(e(σ, U)), "cbss/ibe/v1" || aad ). By bilinearity,e(σ, U) = e(MSK · I, r · G2_gen) = e(I, G2_gen)^(MSK · r) = e(I, MPK)^r, the sameKthe owner computed at step 4. - The runner AES-256-GCM-decrypts
wrapped_dekwithKto recover DEK. - The runner fetches the CBFS object via
cbfs_pointerand AES-256-GCM-decrypts it with DEK and the 172-bytebase_aad(the value envelope’s AAD; §3.1) to recover plaintext.
MPK, U, σ, I, S_i, and σ_i; non-canonical compressed encodings; or points outside the prime-order subgroup. blstrs compressed decoding enforces curve/subgroup membership but accepts the identity, so identity rejection is an additional requirement. Implementations MUST also enforce MAX_IBE_AAD_BYTES = 4096 and MAX_IBE_CIPHERTEXT_BYTES = 1 MiB (§4) for every CBSS IBE envelope.
3.4.4 Security properties
- Any t honest proxies can complete a release; t-1 cannot reconstruct
σand therefore cannot deriveK. Given public(I, MPK, U), derivingKwithoutσrequires computinge(I, MPK)^r = e(I, G2_gen)^(MSK · r)from(G2_gen, MPK = MSK · G2_gen, U = r · G2_gen), reducing to the co-BDH assumption on BLS12-381. - For owner-chosen
U, a malformed owner-chosenr/Uweakens or bricks only that owner’s own secret. Bindingcompress(U)into the AAD makes post-publish tampering a hard AEAD failure rather than a silent mis-derivation. - The owner supplies
rfor their own secret. Proxies and runners treatUas opaque KEM material; reshare/PSS properties are unchanged because the committee still releasesσfor the same identityI. - For each
(secret_id, version, wrap_epoch), a leakedσdecrypts only the wrapped DEK for that exact identity. Compromising a different secret version requires a separate t-of-n collusion to derive its σ. Reshare does NOT invalidate σ values for prior identities; PSS preservesMSKand hence preserves σ for any identity I. - BLS partial-signature verification requires no bespoke NIZK. It is a single pairing check, covered by
blstrsand the vetted threshold-BLS implementation. - The proxy validation layer enforces anti-replay, ACL and audit checks (§3.7), together with per-proxy receipts (§3.5). The cryptographic envelope intentionally does NOT bind to a runner ephemeral key. Section §3.4.5 explains why.
- Proactive secret sharing on
MSKrotates shares without changingMPK. Stored secrets remain decryptable. In-flight release requests are NOT invalidated by reshare; a proxy’s freshly-resharded share still produces valid partials for any prior-epoch identity. - Reshare bounds the window during which a specific share-holder’s compromised share is useful. After reshare, that specific s_i is replaced; the attacker must re-compromise the new s_i’ to keep contributing to t-of-n.
3.4.5 Why threshold IBE, not threshold ElGamal with key-switching
The candidate alternative is threshold ElGamal on secp256k1 with a custom “key-switching to runner ephemeral pubkey” construction. Two problems:- No vetted Rust library exists. Threshold ElGamal on secp256k1 requires hand-rolling the DKG, partial-decrypt construction, and Chaum-Pedersen NIZK. BLS12-381 + threshold IBE has vetted equivalents (Commonware BLS DKG,
tlock,blstrs); secp256k1 + threshold ElGamal does not. - The runner is the legitimate recipient of DEK; cryptographically binding the ciphertext to a runner-ephemeral pubkey adds protocol complexity without buying additional security beyond what proxy-side anti-replay/ACL already provide. Threshold IBE produces DEK directly to the runner; the runner zeroizes after use; validation enforces revocation, replay checks and audit, not the envelope.
r and publish U = r · G2_gen in WrappedDek. That ephemeral is independent of runner identity; it is the KEM randomness that makes K unrecoverable from public (I, MPK, U).
The threshold-IBE construction is what drand’s tlock ships in production. CBSS uses the same construction with a CBSS-specific identity binding.
3.4.6 Time-Lock Release mode (height-gated, public identity)
§3.4.3 binds threshold IBE to a CBSS-specific identity. The same committee also supports time-lock release for consumers (e.g. CIP-34 sealed-bid auctions) that need a key which becomes available at a future height, bound to a caller-chosen identity, and released permissionlessly, independent of any participant. It reuses the committee’s existingMPK, shares s_i, and PSS guarantees without new key material, DKG or trust assumptions.
A release
σ for one mode can never derive the key for the other. The identity spaces are disjoint in G1 under RFC 9380 domain separation. A tlock identity MUST NOT be used to wrap an account secret (its key is public at target_height); the domain tag enforces the separation.
The identity uses a caller-chosen tag: Bytes (e.g. a CIP-34 request_id) and reveal height target_height: u64:
identity is the verifier’s trusted ChainIdentity, including both chain ID and
chain instance (CIP-40 §7.6). tag is its raw bounded byte string, without an
additional length prefix inside body; release_key_suite MUST equal 1.
The suite and tag bound are checked before hashing. The framing is CIP-40’s
object_signing_preimage, and hash_to_G1 is the RFC 9380 hash-to-curve used
throughout §3.4.
Encryption reuses the §3.4.3 Boneh-Franklin construction. The encryptor samples a fresh r ←$ Fr, publishes U = r · G2_gen, and derives K = HKDF-SHA256( serialize(e(I_tlock, MPK)^r), "cbss/tlock/v1" || aad ) against the committee’s existing MPK. (The HKDF salt/info domain is "cbss/tlock/v1", matching the identity domain. This is required, as in §3.4.3.)
Time-lock release does NOT inherit the §3.4.3 account-secret AAD. The §3.4.3 pairing/HKDF construction applies with separate AAD contents. Time-lock release keeps its own base AAD,Release is the only structural difference. Once chain height ≥base_aad_tlock = tag ‖ u64_le(target_height)(for CIP-34 sealed bids,tag = request_id, sobase_aad_tlock = request_id(32) ‖ u64_le(reveal_height); CIP-34 §Sealed-Bid), extended toaad = base_aad_tlock ‖ compress(U)for the AEAD. It does not gainchain_idand does not gainmpk_g2; the §3.4.3 chain-separation and release-key bindings apply only to the account-secret family. Base AADs in this CIP are per-family and do not inherit across families (the same rule that keeps CIP-9’s volume path on its own base AAD, §9.3). The tlock/CIP-34 key-substitution exposure is therefore not closed by an AAD change (a submit-time mismatch would arrive too late, and there is no on-chain envelope validation to attach it to); it is addressed by authenticating the committeeMPKat the encryptor against the release key’srelease_key_material_hashbefore sealing and checking the reveal height independently at the committee. Both remain separate work and leave this base AAD unchanged. See CIP-34 for the sealed-bid scoping statement.
target_height, each committee proxy computes its partial on the tlock identity with its current share and posts it on chain:
e(σ_i, G2_gen) == e(I_tlock, S_i) (identity/point-at-infinity rejection as in §3.4.3). The accumulated partials are a public chain artifact: anyone reads ≥ t of them, Lagrange-combines σ = Σ λ_i · σ_i = MSK · I_tlock, and derives K = HKDF-SHA256( serialize(e(σ, U)), "cbss/tlock/v1" || aad ). There is no §3.7 validation (no ACL, no job-assignment, no runner-binding, no anti-replay on the reader). Time-lock release is public; the only gate is the height. Single-epoch quorum (consensus-critical, twin of §9a’s MixedEpochReceipts): the partials MUST all be from one committee_epoch. The Lagrange x-coordinates are proxy positions in that epoch’s committee, so a cross-epoch combine yields the wrong σ. The partial set records the committee_epoch of its first accepted partial as its quorum_epoch; if a reshare advances the committee while the set is below threshold, the set is RESET to the new epoch (stale, now-uncombinable partials discarded) so collection can still complete. A combiner MUST combine only same-quorum_epoch partials; if the live committee has advanced past a threshold-reached set’s quorum_epoch, the release is deterministically not-yet-releasable. The consumer retries or hits its grace fallback (CIP-34 §Sealed-Bid).
A tlock release is registered on chain (RegisterTlockRelease { tag, target_height }, §3.5) so the committee knows what to sign and when. Registration is fee-bearing and bounded: a per-block cap on new registrations, and a registered request (plus its posted partials) is GC’d after target_height + TLOCK_RETENTION (§4). A proxy MUST reject SubmitTlockRelease while head < target_height (premature reveal) and for an unregistered (tag, target_height).
A proxy’s current share s_i validly partial-signs any identity under MPK, tlock identities included (PSS preserves MSK; §3.4.4). Reshare does not invalidate a registered tlock request. A freshly-resharded share still produces a valid partial for I_tlock.
The committee-liveness assumption is identical to secret release. If fewer than t partials are posted by target_height + GRACE, the consumer owns the fallback, e.g. CIP-34 cancels the auction (CancelledGraceExpired) at reveal_height + AUCTION_GRACE (CIP-34 §Sealed-Bid); as built it does not re-open a plaintext OPEN round. CBSS itself adds no time-lock fallback; it exposes the height-gated release and the consumer composes the timeout.
The security argument follows §3.4.3. Confidentiality holds only until target_height (by design); before it, the co-BDH argument of §3.4.4 applies unchanged (t-1 proxies cannot derive σ). Because the identity binds tag, the release for one tag reveals nothing about another tag at the same height, so one auction’s reveal cannot expose another auction’s still-sealed bids. The public-at-height property is exactly why the domain separation from account-secret identities is mandatory.
3.5 New system instructions
Each instruction’sSender column gives who is authorized to submit it. Gas costs in §4.1.
SetSecret (opcode 68)
The recipient type determines the instruction fields. On the override path, the recipientMPK does not exist at SetSecret time. A fresh DKG ceremony must produce it first. The default path stays one-shot; the override path is two-phase, with FinalizeSecretVersion (opcode 78) attaching the ciphertext after DKG finalizes.
-
The default path (
recipient = Account(sender)) must carrycbfs_pointer + wrap_epoch + wrapped_dek(DEK encrypted under the IBE key derived from the account’s existingMPK; nonces,ephemeral_u, and AAD are insideWrappedDekand the CIP-9 CBFS envelope). The instruction is rejected withMissingAccountReleaseKeyif the sender has noAccountReleaseKeyon file (thecowboyCLI auto-issuesRequestAccountDkgon first use). Allocatesversion = max(SecretMetadata.latest_version, secret_version_hwm) + 1(checkedu64add; fails closed only when that floor is alreadyu64::MAX), createsSecretVersion(version)underSecretId(sender, key)withpending = false, and advances the durable high-water mark to that version (see “Secret version allocation and non-reuse” in §3.2). EmitsSecretCreated. -
The override path (
recipient = SecretSpecific(SecretId, next_version)) must NOT carrycbfs_pointer / wrap_epoch / wrapped_dek. It carriescommittee_overrideand has these effects:- Creates
SecretVersion(version = next_version)withpending = true,wrap_epoch = None,cbfs_pointer = None,wrapped_dek = None, wherenext_versionMUST equal the chain’s allocationmax(SecretMetadata.latest_version, secret_version_hwm) + 1(the instruction is rejected otherwise; see “Secret version allocation and non-reuse” in §3.2). Advances the durable high-water mark tonext_version. (The §3.1 invariant requires all three Option fields are None on a pending version.)wrap_epochis populated byFinalizeSecretVersiononceMPKexists. - Locks
DKG_BONDfrom the sender, VRF-selects an n-proxy committee per the override spec, and writes aDkgPending(SecretSpecific(SecretId, next_version), committee, deadline, bond_amount, requester = sender)record. - Off-chain DKG runs (§3.6.1). On commit, the committee submits
RotateCommittee { scope: SecretSpecific(...), new_committee_epoch: 1, ... }, which writes the newSecretReleaseKeyand exposesMPKon chain. - Owner reads
MPK + committee_epochfrom chain, setswrap_epoch = committee_epoch(= 1 here), samples freshr != 0, computesU = r · G2_gen, derivesK = HKDF(serialize(e(I, MPK)^r), "cbss/ibe/v1" || aad)withaad = u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2 || compress(U), encrypts DEK toK, uploads CBFS ciphertext, and submitsFinalizeSecretVersion(opcode 78) to attachcbfs_pointer + wrapped_dek + wrap_epochand clearpending. - Until step 4 lands, release attempts against this version fail closed with
SecretPending.
- Creates
- The default path requires
wrapped_dek.version == 2(§3.1; rejects withUnsupportedWrappedDekVersionotherwise);wrap_epoch == account_release_key.committee_epochat SetSecret block;wrapped_dek.ephemeral_uis the canonical compressed encoding of a non-identity G2 point in the prime-order subgroup (subgroup membership REQUIRED; §3.4.3); andwrapped_dek.aad == u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2 || wrapped_dek.ephemeral_u, wherechain_idis this chain’s identifier andmpk_g2 = compress(account_release_key.mpk), both taken from committed state loaded one step above (theAccountReleaseKeyalready in hand for thewrap_epochcheck), never from the envelope. Rejects withWrapEpochMismatch/AadMismatchotherwise. Awrapped_deksealed under a substitutedmpk'(or for another chain) therefore fails this full-equality check withAadMismatch, the chain-side half of the release-key binding (§3.4.3). - The override path requires
1 <= committee_override.t <= committee_override.n <= MAX_CBSS_RELEASE_COMMITTEE_SIZE(90). The selected committee must contain exactlynunique eligible proxies. The narrowerMIN_OVERRIDE_T/MAX_OVERRIDE_Npolicy in §4.2 remains spec-only. - Both paths require
key_hashto be a well-formed 32-byte value and reject exceeded quotas. (PlaintextKeyNameregex enforcement is CLI/SDK-side, since the chain never sees plaintext.)
SecretCreated { id, version, recipient_kind, pending: bool, ... }.
FinalizeSecretVersion (opcode 78)
Attaches ciphertext to apending = true SecretVersion after its DKG ceremony has committed. Used only on the override path.
SecretVersionexists, haspending = true, andrecipient = SecretSpecific(_, version).- The corresponding
SecretReleaseKeyis committed (exists on chain) and itscommittee_epoch ≥ 1. wrap_epoch == secret_release_key.committee_epochat FinalizeSecretVersion block (no resharing in between, OR the owner explicitly accepts re-wrapping under the new epoch).wrapped_dek.version == 2(§3.1); rejects withUnsupportedWrappedDekVersionotherwise.wrapped_dek.ephemeral_uis the canonical compressed encoding of a non-identity G2 point in the prime-order subgroup (subgroup membership REQUIRED; §3.4.3).wrapped_dek.aad == u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2 || wrapped_dek.ephemeral_u, withchain_idthis chain’s identifier andmpk_g2 = compress(secret_release_key.mpk)derived from committed state (the override path’sSecretReleaseKey), never from the envelope; a substitutedmpk'or wrong-chain wrap fails withAadMismatch.
cbfs_pointer, wrap_epoch, wrapped_dek on the SecretVersion and clears pending. From this point release proceeds normally.
Emits SecretVersionFinalized { id, version }.
An installed but unfinalized version remains pending and consumes a quota slot until finalized or deleted. If its key has not been installed, ExpireDkgPending is the cancellation path (§3.5).
UpdateSecretPolicy (opcode 69)
SecretVersion. No re-wrap is required because the cryptographic recipient is the account or per-secret override key, not the individual ACL actors. ACL changes are pure metadata and propagate atomically to all subsequent release attempts. The new policy fully replaces the old policy.
Granting or revoking an actor’s access takes a single chain transaction. It requires no proxy round-trips or re-encryption and creates no additional chain-storage records.
Emits SecretPolicyUpdated.
DeleteSecretVersion (opcode 70)
SecretVersionTombstone with deleted_at_block, was_pending and public evidence context (§3.2). For an installed override it retains public committee evidence, then removes the dedicated SecretReleaseKey, its rksweep: entry and its cbss_reshare_outstanding: marker. Shared account release keys and their sweep/reshare state survive, as do per-proxy reverse-index entries, retained evidence and the high-water mark. Metadata and the account secret index follow the release-selection rule in §3.2. Removing the version removes its on-chain CBFS pointer; this handler does not issue a CBFS object-drop instruction.
A pending override whose dedicated key is not yet installed is rejected: the owner cancels it through ExpireDkgPending. An installed but unfinalized override can be deleted; its tombstone has was_pending = true and no evidence context because it was never releasable. Subsequent release authorization rejects a deleted version.
The chain emits cbss.secret.version_deleted with account[20] ‖ key_hash[32] ‖ version u64 BE. For override keys it also emits cbss.share.zeroization_requested: exactly 68 bytes, account[20] ‖ key_hash[32] ‖ version u64 BE ‖ epoch u64 BE. Epochs are deduplicated and sorted; whole-secret deletion visits versions in ascending order, giving version-then-epoch ordering. At most 256 zeroization hints are emitted per transaction. Hints are best-effort: the committed tombstone is authoritative even when further hints are omitted. The daemon treats a finalized tombstone as authoritative revocation of that version. Tombstone reconciliation selects local shares for erasure only when their complete public epoch matches the committed observation; a was_pending tombstone supplies no erasure epochs, and unmatched material remains untouched. A direct zeroization hint separately targets a local share with the exact secret-version scope and epoch. Revocation therefore does not imply unconditional erasure of pending or unmatched material, and chain execution cannot prove that every operator erased its copies.
DeleteSecret (opcode 71)
SecretMetadata and its account secret-index entry. If any version cannot be deleted, the whole transaction rolls back, including prior version writes and events. Shared account keys and the durable high-water mark survive. The chain emits the bounded zeroization hints above and cbss.secret.deleted with account[20] ‖ key_hash[32] ‖ latest_version u64 BE, using the metadata value read for the deletion; it does not emit a separate cbss.secret.version_deleted for each version.
RegisterCbssProxy (opcode 72)
stake_amount CBY in the proxy’s escrow, mints a fresh ProxyId, writes CbssProxy with eligible_after = current_block + PROXY_SOAK_PERIOD. The proxy is not VRF-eligible until soak completes.
DeregisterCbssProxy (opcode 73)
unbond_at = current_block. Stake remains locked for UNBOND_COOLDOWN. If the proxy is currently a member of any AccountReleaseKey.committee or SecretReleaseKey.committee, RotateCommittee is enqueued for each affected release key. After cooldown elapses with no slashing case, stake is returned and the CbssProxy record is purged.
RotateCommittee (opcode 74)
RotateCommitteeArgs signature entry is (signer_index: u16, slot: SignatureSlot).
Indices are 1-based, strictly ascending and unique within each signature
vector; zero and values beyond the corresponding committee’s length MUST reject.
new_committee_sigs indexes new_committee; prior_committee_sigs indexes the
prior committee being replaced. The verifier MUST validate the complete index
sets and resolve each authorized operator address from the corresponding
committee snapshot before any cryptography. An installed committee uses its
persisted operator snapshot; the new committee uses the operator vector captured
for installation. Registry changes cannot substitute a new operator for a prior
snapshot member. Each resolved address verifies only its indexed slot under
CIP-40 §7.6 row 13; recovered addresses do not select committee membership.
The complete roster and every slot pass preflight before any verification
charge or cryptography. Each iteration selects operators[signer_index - 1],
charges OBJECT_VERIFY_CYCLES[slot.algorithm()], then verifies against that
address. Conformance tests pin snapshot selection and per-slot charges,
count verification calls, and require zero for malformed rosters or a failed
initial charge.
Any member of the new committee can submit this instruction on its behalf. The submitter’s authority comes from the threshold signature set in new_committee_sigs, not from being the lone submitter.
The instruction verifies release-key material and threshold committee signatures. A completed rotation installs the targeted AccountReleaseKey or SecretReleaseKey with its new committee epoch. On normal reshare, the previous committee and commitments are appended to the release key’s embedded prior_committee_epochs, with expires_at = current_block + RESHARE_GRACE_BLOCKS; entries with expires_at < current_block are pruned first. If the vector would exceed MAX_PRIOR_COMMITTEE_EPOCHS (4), rotation is rejected until enough prior epochs expire. Account force-rekey clears serving grace; overrides reject force-rekey. Rotated-out public material is separately retained for slashing under the evidence rules below.
For epoch selection, a receipt may use a retained prior committee only when committee_epoch_at_serve matches its entry in prior_committee_epochs and submission is at or before expires_at; an expired or missing epoch is rejected. Old committee members MUST zeroize their old shares before signing the quorum attestation; failure to do so is not directly slashable but the signing under false attestation is future-evidence for a leak case. Existing SecretVersion records keep their original wrap_epoch (immutable per version); the IBE identity for those versions is unchanged. New SetSecret calls after this RotateCommittee bind to the new committee_epoch as their wrap_epoch.
mpk is preserved across reshare (proactive secret sharing); only the share polynomial changes. This is true for both account-scoped and secret-scoped keys.
This instruction is also used to commit the result of an initial DKG ceremony triggered by RequestAccountDkg or by the override path of SetSecret. In that case, prior_committee_sigs is empty (there is no prior committee to attest zeroization from), but new_committee_sigs is still required: at least t signatures from members of the freshly-DKG’d new committee over the canonical DKG-commit payload (see the field comments in the struct above). This is what authenticates the initial DKG output; without it, a single nominated proxy could commit an arbitrary (MPK, S_i) set.
SlashCbssProxy (opcode 75)
On-chain-provable fault classes are limited to those that admit objective, on-chain evidence. Liveness is excluded from automatic slashing entirely. Packet-delivery non-receipt is fundamentally not provable on chain (a malicious or broken runner can submit a valid signed request without ever delivering it to the proxy; the proxy cannot prove a network negative). Liveness instead drives a health score (§4.4) that affects VRF selection weight, and persistent extreme degradation triggers governance review (CIP-12 Tier 1ForcedDeregisterCbssProxy). The on-chain SubmitLivenessChallenge / LivenessChallengeResponse remain as the audit trail that feeds the health score, but they do not by themselves cause stake loss.
PlaintextLeak is also removed from protocol-level slashing because its evidence (“here is the recovered DEK plus t-1 partials”) would publish the secret on chain. Off-chain disclosure goes through governance, which can call ForcedDeregisterCbssProxy.
CbssProxy.stake, sets suspended = true pending governance review.
For invalid-partial evidence admission, the V4 evidence contains the runner-signed request and proxy-signed blinded response. Let R = request_block, S = served_at_block and anchor = clamp(S, R, R + REQUEST_FRESHNESS_BLOCKS), with REQUEST_FRESHNESS_BLOCKS = 384. Submission is admissible from R through anchor + CBSS_EVIDENCE_WINDOW_BLOCKS (512 blocks), inclusive. Height addition saturates at u64::MAX. The verifier authenticates the request, blinding authorization, proxy response and committee position before accepting a fault. An authenticated stamp outside [R, R + 384], in either direction, is itself a fault even if the partial’s pairing is valid. Inside that range only an invalid/malformed partial is slashable; a valid pairing with an in-range stamp is never slashable, regardless of submission time.
For a deleted version, the verifier uses its public tombstone context and requires R ≤ deleted_at_block and was_pending == false. If the serving epoch is no longer current, the verifier point-reads its retained public ReleaseKeyEvidenceEpoch, requires R ≤ last_served_at, and also requires submission at or before last_served_at + 512. Both deletion and historical-epoch eligibility compare the runner-signed request block, never the accused proxy’s stamp. Retention ends at the committed epoch cutoff plus 512; clamping the stamp does not extend it.
Rotation and override deletion retain a sorted per-recipient epoch index plus one public value per epoch, at most 64 epochs. Each value contains the MPK, ordered committee, threshold, epoch, VSS commitments and last_served_at. History pruning removes expired values and rewrites the index when history is next retained. A live override key has at most 28 indexed historical epochs before deletion because force-rekey is rejected for overrides and serving grace permits only four prior epochs within each inclusive 100-block window. The delete cascade also snapshots the current epoch, so post-delete evidence can contain 29 epochs. Evidence history never authorizes serving. Equivocation verification authenticates the request and two conflicting proxy responses directly and needs no release-key history.
SubmitLivenessChallenge (opcode 79)
Anchors on chain that a runner experienced a non-response from a proxy. Feeds the proxy’s health score; does NOT by itself trigger slashing.challenged_at, which is not a transaction argument, to the inclusion block height when the instruction is processed. This prevents future-dating or backdating attacks on the response-deadline timing.
The runner identified by runner_request.body.context.runner_id signs the request.
The instruction authenticates the request and challenge, then validates the accepted receipt snapshot:
- The request’s
chain_idmatches this chain. The V4 request signature and outerchallenge_sigeach recover the runner address named in the request. request_block + MIN_CHALLENGE_DELAY_BLOCKS ≤ submission_block ≤ request_block + LIVENESS_CHALLENGE_MAX_AGE_BLOCKS, with saturating height addition. The handler setschallenged_at = submission_block.- An accepted
release_receipt:{release_id}set exists for the exact request hash and serve epoch, with a nonzero threshold and at least that many receipts and eligible committee members. The challenged proxy belongs to that stored committee snapshot. Every receipt matches the request hash and epoch, and its proxy index matches its committee position; indices are strictly increasing and proxy IDs are unique. This authenticated attempt proof remains valid across later reshares; admission does not re-evaluate current ACL, manifest, job assignment orSecretVersionstate. - No
liveness_challenge_index:{release_id}:{proxy_id}entry exists. While the index exists, another challenge for that pair is rejected. A response to a pending challenge and expiry of a pending challenge delete the index; the retained challenge record alone is not a permanent dedup guard. A challenge resolved at admission keeps its index. - If the accepted receipt set already contains a receipt from the challenged proxy, the challenge is immediately
Resolvedand the runner forfeits the bond to that proxy.
LIVENESS_CHALLENGE_BOND from the runner’s account and writes liveness_challenge_index:{release_id}:{proxy_id} → challenge_id so duplicate challenges are rejected while that index remains. If a receipt for (release_id, proxy_id) already exists, the handler writes LivenessChallenge { id, runner_request, bond_amount, challenged_at = submission_block, status: Resolved, deadline = submission_block } and transfers the bond to the challenged proxy. Otherwise it writes LivenessChallenge { id, runner_request, bond_amount, challenged_at = submission_block, status: Pending, deadline = submission_block + LIVENESS_RESPONSE_BLOCKS }. The proxy has until deadline to dispute.
Because MIN_CHALLENGE_DELAY_BLOCKS is strictly greater than REQUEST_FRESHNESS_BLOCKS, every receipt that can pass receipt freshness validation is already either on chain or impossible to submit by the time a liveness challenge is admissible. Runners are expected to check release_receipt:{release_id}.entries[proxy_id] before challenging. If they challenge despite an existing receipt, the chain resolves the challenge immediately and transfers the bond to the proxy. The receipt itself does NOT need to be fresh per REQUEST_FRESHNESS_BLOCKS for this purpose. Persistent release_receipt state is the authoritative record of “did the proxy ever submit a paid receipt for this release_id.” Resolved is therefore an admission-time state, not a response-time state.
If a proxy served but failed to submit a receipt before the receipt freshness window closed, it cannot later create chain-verifiable receipt evidence. Its only on-chain response path is an Unverifiable reason (typically NeverReceived or structured local-failure evidence), which is health-neutral but does not produce a positive liveness signal.
After deadline, a still-Pending challenge transitions to Unanswered, refunds the bond to the runner, and applies the standard negative health-score decrement to the proxy. No automatic slash follows. The challenge is recorded in the proxy’s audit history. Persistent unanswered challenges may justify a governance proposal under CIP-12.
LivenessChallengeResponse (opcode 80)
A proxy’s structured response to a liveness challenge. Records chain-unverifiable response evidence; does NOT by itself prevent governance action.proxy_sig over the exact byte layout above against CbssProxy.pubkey, then evaluates evidence per reason. The chain transitions the challenge to a terminal state with bond disposition that matches the chain’s view of who was right:
Resolved: not produced byLivenessChallengeResponse; produced only by the admission-time receipt check inSubmitLivenessChallenge. Chain dereferencesrelease_receipt:{release_id}and confirms the entry exists withproxy_idmatching. Health-score impact on the proxy: small positive (proved liveness via receipt). Bond disposition: forfeited to the challenged proxy.Unverifiable: proxy submitsLivenessChallengeResponsewithInvalidRequest/RateLimited/NeverReceivedbefore deadline. Chain cannot re-derive any of these. The bond is refunded to the runner (the runner submitted a good-faith challenge; whether the proxy’s response is honest is unknowable on-chain). Health-score impact on the proxy: NEUTRAL, no automatic decrement. Pattern detection lives in off-chain governance.Unanswered: proxy submits no response bydeadline. The runner was right; the proxy is genuinely silent. The bond is refunded to the runner. Health-score impact on the proxy: standard negative decrement. Persistent unanswered patterns flag the proxy for governance review per §4.4.
Resolved via an existing receipt); in all other cases (proxy went silent or proxy gave an unverifiable response) the runner gets the bond back.
A runner could still try to challenge proxies before they’ve had time to submit their receipts. To prevent this, SubmitLivenessChallenge enforces body.request_block + MIN_CHALLENGE_DELAY_BLOCKS ≤ submission_block (see §4.2). Challenges submitted too soon after the original request are rejected with ChallengePremature. The default delay is REQUEST_FRESHNESS_BLOCKS + 32 (~12 min), giving proxies time to serve and submit a receipt, which resolves a later challenge at admission, or report failure.
Only the admission-time receipt check is chain-verifiable and resolves to Resolved. Unverifiable captures “the proxy responded with chain-unverifiable evidence” without penalizing either party. Repeated Unverifiable patterns by the same proxy escalate via off-chain governance, not protocol-level slashing or health-score automation.
SubmitReleaseReceipt (opcode 76)
Each proxy submits a V4 receipt that carries the runner’s signed blinded request and the proxy’s signed blinded response. The chain authenticates both signatures, verifies the blinding authorization and checkse(tau, G2_gen) == e(blinded_identity, S_i) against the public share derived from the committed VSS polynomial and the proxy’s committee index. The receipt does not publish the unblinded partial sigma_i.
tee_attested is not a receipt argument. release_id omits request_block, while request_hash binds the complete encoded V4 body.
All signatures use a domain-string prefix to prevent cross-protocol replay; implementations MUST sign exactly these byte layouts:
base_aad := u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2
I := hash_to_G1( base_aad, domain = "cbss/ibe/v1" )
The owner (at SetSecret/FinalizeSecretVersion), the proxy (at PartialSign), and the chain (at SubmitReleaseReceipt pairing-check) all compute I from the same 172-byte base_aad in the same encoding. Here chain_id is the chain’s own identifier and mpk_g2 = compress(MPK) is taken from the release key the chain resolves for the pairing check (§3.6.2 reshare-aware lookup), not from any client input, so the identity all parties hash is bound to the exact release key. AAD on the AES-GCM wrapped_dek envelope extends the same canonical encoding with the Boneh-Franklin encryption ephemeral: aad = base_aad || wrapped_dek.ephemeral_u. The chain and runner MUST reject the envelope with AadMismatch unless this full equality holds; len(aad) != 172 + 96 (i.e. != 268) is malformed AAD.
The operator of response.proxy_id signs the response. The signature must recover that registered operator address.
The chain validates each receipt as follows:
- Authenticate
runner_request.runner_signatureagainst the runner address in the V4 context; recomputerequest_hashandrelease_idas above. - Check the existing
(release_id, response.proxy_id)receipt. An exact replay of an accepted receipt returns success, including after freshness expires; a conflicting receipt is rejected. - For a new receipt, require
request_block ≤ submission_block ≤ request_block + REQUEST_FRESHNESS_BLOCKS, using saturating addition, andrequest_block ≤ served_at_block ≤ submission_block. The response hash must match the request, andcommittee_epoch_at_servemust equal the runner’sserve_epoch. - Evaluate current release authorization, including the version, policy, manifest and job/session authority. Authenticate the proxy response and resolve the serving epoch’s release key and committee. A retained prior epoch is usable only through its inclusive
expires_atboundary (§3.5). - Require the response’s nonzero
proxy_indexto equal the proxy’s one-based position in the resolved committee. Verify the runner’s blinding authorization against the committedwrap_epochand MPK, deriveS_ifrom the VSS polynomial at that index, and check the blinded partial’s pairing. Malformed points and failed proofs are rejected. - Require every receipt in the set to share the same request hash, epoch, threshold and ordered eligible committee snapshot. A new receipt is rejected once the threshold has already been reached.
- TEE eligibility is chain-derived. The release evaluator checks the required TEE authority in the logical TEE Verifier’s records, physically stored at
0x04(§3.2). It checks the runner’s measurement binding. The proxy cannot supply atee_attestedoverride.
ReleaseReceiptSet with its request/committee snapshot and sort entries by proxy index. Charge the release receipt to the actor and credit the submitting proxy under the payment rules below.
If actor.account.balance < RELEASE_FEE_PER_RECEIPT, the receipt is still recorded and the proxy is still credited, with the actor’s release-payment balance going negative (capped at MAX_RELEASE_OVERDRAFT, governance-tunable, default 16 × RELEASE_FEE_PER_RECEIPT). Implementations whose base account codec cannot represent negative balances MAY store the negative portion in a separate release-debt ledger; the Cowboy node currently stores this as CBSS ActorReleaseDebt. The actor account transitions to delinquent status, which suspends new job dispatching to that actor until the negative balance is repaid. On Cowboy, JobSubmit rejects outstanding ActorReleaseDebt; FundActor repays that debt before any newly funded balance becomes spendable and emits cbss.actor.debt_repaid when repayment is applied. If overdraft would exceed MAX_RELEASE_OVERDRAFT, the receipt is rejected with ActorAccountInsufficient and no payment occurs. Proxies that observe this on chain SHOULD stop accepting PartialSign requests from this actor until repayment is observed. The overdraft cap allows payment to the proxy while delinquency suspends new dispatch until the actor repays.
Each receipt emits one event:
SecretReleased (quorum event) is emitted when the t-th receipt for a given release_id lands, carrying the actual proxy_set: [ProxyId; t] accumulated in release_receipt:{release_id}:
t from the referenced release key to detect quorum deterministically.
RequestAccountDkg (opcode 77)
SetSecret if no AccountReleaseKey exists yet.
The instruction locks DKG_BOND from the requesting account. VRF-selects n = DEFAULT_N proxies from the eligible set, weighted by stake × health_score (see §4.4). Writes a DkgPending { scope, force_rekey, committee, threshold, deadline = current_block + DKG_FINALIZE_BLOCKS, bond_amount, requester } record at dkg_pending:{scope_serialized} (the record persists force_rekey and threshold so the off-chain ceremony and any later RotateCommittee see the quorum size and re-key intent). Off-chain, the selected committee runs the DKG ceremony (§3.6.1) and posts the result via RotateCommittee with scope = Account(sender) and new_committee_epoch = 1. On successful RotateCommittee, the chain refunds DKG_BOND in full and clears the DkgPending record.
If the DKG ceremony fails to commit by deadline, the DkgPending record stays on chain until expired by ExpireDkgPending (see below).
Both RequestAccountDkg and the governance path below emit a cbss.dkg.requested event with payload DkgRequestedEventData { scope, epoch, force_rekey, threshold, committee_metadata }. epoch is the ceremony epoch, committee_metadata carries the selected proxies’ connection details (id / operator / network address / HPKE + DKG public keys), and force_rekey signals a re-key vs first bootstrap. Note the event does not carry deadline (a consumer needing the ceremony deadline reads the DkgPending record, not the event). The off-chain committee daemon consumes this event to run the ceremony (§3.6.1).
GovRequestSystemDkg (opcode 158, provisional)
GOVERNANCE_SYSTEM_ACTOR (0x09) can submit this instruction. Any other tx.from is rejected with Unauthorized.
Governance produces a 0x09-origin transaction. 0x09 is keyless. Like every 0x09-authorized instruction (UpdateSettlementConfig, SetGovParam), a GovRequestSystemDkg transaction has no external signature. It is produced by CIP-12 governance-proposal enactment: a passed proposal’s payload is applied deterministically by 0x09 with tx.from = 0x09 (CIP-12 §“payloads are executed deterministically by 0x09”). This uses the CIP-12 ProposalPayloadKind (SystemDkgBootstrap { scope, force_rekey }) that ExecuteProposal maps to this instruction.
RequestAccountDkg derives its scope from sender (scope = Account(sender)) and is authorized by the account’s own signature. A keyless system actor, one whose address holds native ledger/registry state but has no private key and therefore can never be tx.from, cannot use it. The concrete instance is the CIP-34 sealed-bid INTENT_SETTLEMENT committee (Account(0x14)): sealed-bid reveal (CIP-34 §Sealed-Bid) decrypts every bid against 0x14’s CBSS committee, so that committee’s AccountReleaseKey (committee + MPK + shares) MUST exist before any sealed auction can clear, but 0x14 cannot self-issue RequestAccountDkg. GovRequestSystemDkg is the only path that establishes a committee for such a scope, authorized by governance rather than by an owner signature.
This instruction matches RequestAccountDkg exactly, with three differences: (i) tx.from MUST equal GOVERNANCE_SYSTEM_ACTOR; (ii) the scope comes from args.scope; this replaces derivation from sender; (iii) no DKG_BOND is locked (bond_amount = 0). Governance has no user account to debit. ExpireDkgPending on a zero-bond pending refunds/slashes nothing and pays no cleanup-caller reward. Cleanup rewards are funded only from the amount actually slashed (min(bond_amount, DKG_TIMEOUT_SLASH)); a zero-bond ceremony has no reward pool. Zero-amount refunds perform no Account read or write. Both expiry and commit therefore work without a requester Account row and do not create one. Concretely, on a valid request the chain: VRF-selects n = DEFAULT_N proxies weighted by stake × health_score; writes DkgPending { scope, force_rekey, committee, threshold = DEFAULT_T, deadline = current_block + DKG_FINALIZE_BLOCKS, bond_amount = 0, requester } at dkg_pending:{scope_serialized} (requester is the scope’s account, used only for bond accounting, which is zero here); persists the ceremony record so a sabotaging dealer stays slashable after the pending clears; and emits cbss.dkg.requested. Off-chain, the selected committee runs the DKG (§3.6.1). First bootstrap (force_rekey = false) commits via the initial RotateCommittee path with new_committee_epoch = 1 and empty prior_committee_sigs; re-DKG (force_rekey = true) uses the existing-key path at the current committee epoch plus one. After deadline, ExpireDkgPending (opcode 81) can clean up a zero-bond ceremony even when the keyless requester has no Account row.
The request is rejected with InvalidData if (a) a DkgPending already exists for scope (dedup, one ceremony in flight per scope); (b) a release key already exists for scope and force_rekey == false; or (c) no release key exists for scope and force_rekey == true. In other words force_rekey MUST be set iff the scope already has a live committee. First-time bootstrap uses force_rekey = false. Re-establishment uses force_rekey = true.
The scope MUST be a keyless system actor. scope MUST resolve to a keyless system-actor address, i.e. an address in the reserved system-actor range (< 0x20, per WP §9.1) that has no private key, such as Account(0x14). The handler MUST reject any other scope (e.g. Account(<user>), or a SecretSpecific under a user account) with Unauthorized. Rationale: without this bound, a passed proposal could GovRequestSystemDkg { scope: Account(<user>), force_rekey: true } and re-DKG a normal user’s account committee, installing a fresh MPK that permanently strands every secret that user ever wrapped. Keyed accounts never need this path (they self-issue RequestAccountDkg), so restricting scope to keyless system actors costs nothing and removes an unnecessary governance power over user secrets. (This is a validation the chain can check locally, unlike the force_rekey-during-open-auction hazard below.)
A force_rekey re-DKG produces a fresh, independent MPK (via the RotateCommittee existing-key path, new_committee_epoch = old.committee_epoch + 1). It is not a reshare of the existing MSK. Every ciphertext bound to the old MPK becomes permanently undecryptable, as described in §10.7 (MPK is preserved only on reshare, never on a fresh DKG). For the 0x14 sealed-auction committee this means any in-flight sealed bid (a WrappedDek encrypted to the old MPK under identity = request_id) can no longer be revealed, and its auction cancels with no funds moved (both cancel terminals delete state only). The exact terminal depends on the new committee: if it posts partials for the pre-existing tlock request, reveal_auction combines σ under the new MPK, every old-MPK bid fails AEAD, and the auction ends CancelledNoValidBid at reveal_height; if it posts nothing, the reveal stays TlockNotReleased and cancels CancelledGraceExpired after reveal_height + AUCTION_GRACE (CIP-34 §Sealed-Bid). Therefore governance MUST NOT force_rekey the 0x14 committee while any sealed auction is open (i.e. any OpenAuction whose reveal_height + AUCTION_GRACE has not passed); doing so silently cancels those auctions. Routine committee refresh that must preserve decryptability MUST use RequestReshare (opcode 83), which rotates the share polynomial while holding MPK fixed (§10.7); force_rekey is reserved for deliberate key replacement (e.g. a disclosed-MSK incident) where stranding old ciphertext is the intent. A SystemDkgBootstrap proposal with force_rekey requires at least Tier 3 (CIP-12 §5.1). There is currently no on-chain open-auction check, so the auction restriction remains a governance-procedure invariant.
ExpireDkgPending (opcode 81)
Permissionless cleanup of an expiredDkgPending record. Settles the bond and emits a public failure event so the requester can retry.
dkg_pending:{scope_serialized}exists.current_block >= DkgPending.deadline, or the sender is the requester cancelling before the deadline.- No
RotateCommitteefor this scope has landed (i.e., the DKG didn’t complete in some other path).
dkg_pending: for the scope. An override’s pending SecretVersion is erased without a tombstone; metadata and the account secret index follow §3.2’s selection rule, while the high-water mark is retained. The ceremony record survives for sabotage evidence. An outstanding-reshare marker is removed only if its fingerprint binds it to this exact pending ceremony; unrelated reshare state survives. The chain emits cbss.dkg.expired with the canonical binary ReleaseKeyScope.
The requester may retry by submitting a fresh RequestAccountDkg (default path) or SetSecret with committee_override (override path). VRF re-selects a committee, likely overlapping but possibly different given health-score and stake updates.
Per-secret DKG (override path) is initiated by SetSecret itself with committee_override; there is no separate instruction for it. The same DkgPending record is created (keyed by (SecretId, version) instead of account) and the same off-chain ceremony commits via RotateCommittee with scope = SecretSpecific(...).
ExpireLivenessChallenge (opcode 82)
- Charge
CBSS_GAS_EXPIRE_LIVENESS_CHALLENGE = 5_000. - Load the challenge; require
status == PendingANDcurrent_block > challenge.deadline, elseInvalidData. - Transition
status → Unansweredand clear the response fields. proxy.health.unanswered_challenges += 1; apply the capped liveness-attrition penalty (CBSS_LIVENESS_HEALTH_PENALTY_BPS = 100per unanswered, bounded byCBSS_MAX_HEALTH_LOSS_PER_EPOCH_BPS = 1000) tohealth.score_bps.- If the penalty crosses below
MIN_HEALTH_FLOOR_BPS(or sustained sub-threshold ≥GOVERNANCE_REVIEW_BLOCKS), write aProxyGovernanceReviewFlagand emitcbss.proxy.governance_review_required. - Refund the challenge bond to
runner_request.body.runner_id. - Delete the liveness dedup-index entry; emit
cbss.liveness.expired { challenge_id }.
RequestReshare (opcode 83)
handle_cbss_request_reshare) proceeds as follows:
- Charge
CBSS_GAS_REQUEST_RESHARE = 30_000;ensure_cbss_actor_exists. - Load the release-key material for
scope;InvalidDataif absent. - Require
tx.from == material.owner, elseUnauthorized. - Push a
reshare_requestedevent into the CBSS actor event log (whichcbssdpolls; this is the third reshare trigger alongside the churn and deregister paths). No bond is locked and the committee state is not mutated on-chain; the event signalscbssdto orchestrate the off-chain reshare, which lands via a subsequentRotateCommittee.
ForcedDeregisterCbssProxy (opcode 84)
tx.from == GOVERNANCE_SYSTEM_ACTOR = 0x09). CIP-12 Tier-1 uses it to remedy persistent faults or disclosed leaks (§4.3, §5.2). The handler (handle_cbss_forced_deregister_proxy) proceeds as follows:
- Charge
CBSS_GAS_DEREGISTER_PROXY = 8_000. - Require
tx.from == GOVERNANCE_SYSTEM_ACTOR, elseUnauthorized. - Load the proxy (
InvalidDataif absent); setproxy.suspended = trueandproxy.unbond_at = Some(current_block), immediate unbond, no delay (contrast the voluntaryDeregisterCbssProxypath, which still respects the cooldown). If the proxy sits on any live committee,RotateCommitteeis enqueued for each affected release key (as in voluntary deregister). - Emit
cbss.proxy.forced_deregistered { proxy_id }.
RegisterTlockRelease (opcode 152, provisional)
Registers a time-lock release request (§3.4.6) so the committee knows what identity to sign and when. Permissionless (any account), fee-bearing, rate-limited per block.TlockRequest { scope, tag, target_height, registered_at } keyed by (scope, tag, target_height); a duplicate key is rejected. The record (and any partials posted against it, below) is GC’d at target_height + TLOCK_RETENTION (§4). MIN_TLOCK_LEAD_BLOCKS ensures the committee has time to observe the request before the reveal height.
SubmitTlockRelease (opcode 153, provisional)
A committee proxy posts its partial signature on a registered tlock identity, only once chain head ≥target_height. Permissionless to read the result; only committee members may submit.
TlockRequest exists for (scope, tag, target_height); (b) head >= target_height (reject TlockNotYetReleasable otherwise); (c) proxy_id is a current member of the referenced release key’s committee; (d) the BLS partial check e(partial, G2_gen) == e(I_tlock, S_proxy) with identity/point-at-infinity rejection, where I_tlock is computed from the trusted chain identity, suite and framed body in §3.4.6; (e) (scope, tag, target_height, proxy_id) not already submitted (per-proxy dedup). Accumulated partials are public; once ≥ t are posted, any reader Lagrange-combines them into σ = MSK · I_tlock (§3.4.6) with no further authorization. No per-proxy receipt/audit record is written (unlike SubmitReleaseReceipt): time-lock release is public, so there is no access to audit.
3.6 Threshold ceremonies
3.6.1 DKG (initial keypair establishment)
Triggered byRequestAccountDkg (account-scoped) or by SetSecret with committee_override (secret-scoped). Off-chain protocol:
The protocol is the standard threshold BLS DKG (FROST-derived for BLS sigs) as exposed by the chosen vetted library. The devnet implementation uses the pinned Commonware BLS DKG state machine. Sketch:
- In round 1, each proxy
isamples a random degree-t-1polynomialf_i(x)over the BLS12-381 scalar field and broadcasts Feldman/Pedersen commitments to its coefficients (peer-to-peer over the committee mesh; no on-chain anchor). - In round 2, each proxy
isendsf_i(j)to each peerj, encrypted underj’s registry pubkey. Recipients verify the share against the broadcast commitments using a single G2 multi-scalar multiplication. - Each proxy computes its share
s_i = Σ_j f_j(i)(a scalar), summing only the qualified dealers when timeout/complaint handling excluded a dealer. The groupMPK = Σ_j C_{j,0}∈ G2 (sum of each qualified polynomial’s constant-term commitment in G2). Each proxy’s published VSS commitmentS_i = s_i · G2is computable from the aggregated polynomial commitments at indexi. - Once each proxy has its share
s_iand the groupMPK, the committee assemblesnew_committee_sigs, t-of-n signatures over the canonical DKG-commit payload (see RotateCommittee). One proxy postsRotateCommittee(scope, new_committee_epoch = 1, new_mpk, vss_commitments = [S_1..S_n], new_committee_sigs). The chain verifies: (a) eachS_iis a valid G2 point, (b)new_committee_sigs.len() >= thresholdand all sigs are from members ofnew_committeeover the canonical payload, (c) on a reshare,new_mpk == prior_release_key.mpk. The chain does NOT verify Shamir consistency. The committee verifies it off chain via VSS during DKG and attests to it with threshold signatures. (A naive “sum(S_i) == MPK” check would be mathematically wrong since S_i are polynomial evaluations, not coefficient commitments.)
DkgSabotage (§4.3) by any party submitting the equivocation evidence.
cbss-crypto exposes qualified-set finalization so the ceremony can complete when a dealer is offline or excluded. The final DKG must still be vetted and bias-free. Qualified-set finalization does not replace the audited DKG protocol.
3.6.2 Reshare (proactive secret sharing)
Resharing starts in any of these cases:- The schedule calls for reshare every
RESHARE_INTERVAL_BLOCKS(default ~6 months) for bothAccountReleaseKeyandSecretReleaseKeyrecords. - The count of healthy committee members drops to
t + RESHARE_SAFETY_MARGIN. - The account owner, or secret owner on the override path, pays for an immediate reshare.
MPK produces a fresh share polynomial of the same secret for a possibly different committee of n proxies. MPK is preserved; committee_epoch increments. Existing SecretVersions retain their wrap_epoch. Reshare does not invalidate stored ciphertext or in-flight release requests; PSS guarantees the new shares produce valid partials for any historical identity under the same MPK. The prior epoch’s release-key material is retained for a grace window, so CIP-9 volume wraps keep serving across a reshare for that window; a volume’s epoch-pinned material hash means it must re-wrap to a current epoch before the window closes (contrast the immediate re-wrap forced by a re-key, §9.3.1).
3.6.3 Threshold partial signature (release)
The runtime release operation, per the threshold-IBE construction in §3.4.3. Inputs at the proxy:- The runner’s release request (signed; carries
recipient,job_id,request_block,serve_epoch, and request-binding fields).serve_epochpins which share-polynomial epoch the runner expects partials from; proxies reject withEpochMismatchif their current release-keycommittee_epochdiffers. The IBE identity still comes from the SecretVersion’s immutablewrap_epoch, not fromserve_epoch. - The proxy’s local Shamir share
s_i ∈ scalar field of BLS12-381of the implicitMSK.
- Validates the request (§3.7), looking up the relevant
AccountReleaseKeyorSecretReleaseKeyper the request’srecipientfield and checkingbody.serve_epoch == release_key.committee_epochat current head. - Reads
wrap_epochfrom the SecretVersion on chain andmpk_g2 = compress(MPK)from the release key looked up in step 1. Computes the identity using the canonical encoding:I = hash_to_G1( u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2, domain = "cbss/ibe/v1" ). - Computes its partial BLS signature on the identity:
σ_i = s_i · I(a point in G1). - Returns the canonical
PartialSignResponsewire shape:The proxy does NOT include its own VSS commitment in the response. The chain looks upS_ifrom the release key’svss_commitments(current or retained-prior epoch) keyed byproxy_id+committee_epoch_at_serve. This prevents a malicious proxy from substituting a different commitment.
e(σ_i, G2_gen) == e(I, S_i) against the on-chain VSS commitment S_i ∈ G2.
The runner rejects identity/point-at-infinity σ_i partials before combining. It combines t partials via Lagrange interpolation in G1 to obtain the threshold signature σ = MSK · I ∈ G1, reads wrapped_dek.ephemeral_u (decoding it to U), reconstructs aad = u64_be(chain_id) || canonical(SecretId) || u64_le(version) || u64_le(wrap_epoch) || mpk_g2 || ephemeral_u, then derives the IBE key K = HKDF(serialize(e(σ, U)), "cbss/ibe/v1" || aad) and AES-GCM-decrypts wrapped_dek with K.
3.7 Proxy-side validation of release requests
Under release authorization (D11), the node exposes two routes with distinct contracts; they are not unified:
Every V4 request that needs a new partial goes through
cbssd’s serve-time check first and, if it allows with a valid context, the finalized-authority check next, including for ordinary jobs. Both must allow before a share is used. The daemon matches chain, job, actor, runner, secret, version, derived purpose and finalized height across the responses/request; mismatches fail closed. The serve-time route accepts verifier-supplied identity, not a caller-selected purpose or a substitute for authenticating the signed V4 request. Exact retries can return an already-recorded response after local deletion/readiness checks; they do not use the share again.
When creating a new partial, each proxy applies the following validation against chain state at the current head. An exact retry may instead return the already-recorded response after the local deletion/readiness checks described above; it does not repeat the new-partial checklist or use the share again.
Each successful V4 authorization requires both node routes in the order above. The daemon also checks local deletion state and reconciles finalized deletion authority; a stale queued request cannot authorize a deleted version.
Failures are reported with structured error codes (
StaleRequestBlock, SecretAccessDenied, SecretPending, SecretCommitteeUnavailable, etc.); the runner retries with corrected inputs.
3.8 Runner pull flow
3.9 Runtime sandbox: in-memory secret bundle (default), env vars only for spawned subprocesses
The default path fills in-memory slots without process environment variables. Other threads, libraries, signal handlers,/proc/$pid/environ reads, and crash dumps can all observe process-wide environment variables. Serialization mutexes only help cooperating code. The default release path therefore:
- Holds plaintext in a
Zeroizing<Vec<u8>>SecretBundlekeyed by KeyName. - Fills the job’s
secret_slots(§5.2) at request-construction time insiderunner-http/runner-mcp: each secret goes at its slot’s byte offset in the URL, header value, body string or tool-argument string the slot’s pointer names, and nothing else is filled. The runner never reads${out of text. The filling layer reads the bundle directly without touching the process environment. - Drops the bundle (zeroizes) at the end of the runner-op.
- Never sets
os.environ[KEY]for HTTP / MCP / LLM tool calls.
- Build an explicit
env: HashMap<String, Zeroizing<String>>for the child. - Pass via
Command::env_clear().envs(env). The child inherits only the named entries, not the parent’s environment. - The parent’s process environment is never mutated.
- Drop the
Commandbuilder immediately after spawn and zeroize the source env map. - Rust’s
std::process::Commandcopies env values into its own platform-specific storage before spawning, and the standard library does not guarantee that copy is zeroized. Treat subprocess env delivery as an explicit compatibility exception, not the default secret path.
secret_env applies the subprocess path to containers. A container job names its read set outright in RuntimeConfig.secret_env (no slots). The runner resolves each name from the bundle, refuses a name the bundle does not carry or a value that cannot be an environment string (non-UTF-8, or containing NUL), and hands the executor an in-process ContainerSecretEnv, a BTreeMap<String, Zeroizing<String>> whose Debug prints names only. The executor places the entries in the sandbox’s OCI process environment under the declared names, refusing any that would shadow a constructed COWBOY_* variable, and wipes its copy the moment the run ends. Nothing is written into the JobSpec. Inside the sandbox the value is an ordinary environment variable, observable by the whole process tree, which is why the intended user is a single-purpose signing bundle (CIP-10 §18.3), not a general application image.
The PVM Python sandbox enforces these limits:
- The actor’s PVM Python code observes only the key names it marks with
runner.secret(). The PVM does not have aSecretBundlereference; substitution happens at the runner layer, after the syscall boundary. - Direct
os.environ[KEY]reads from PVM Python are blocked by the sandbox for any key declared in the actor’ssecrets.readentitlement (deny-list installed at sandbox init). - Logging adapters scrub strings matching active bundle values from spans and trace events on a best-effort basis. The primary defense is preventing PVM Python from ever holding the value.
4. Parameters
All parameters governance-tunable via CIP-12 Tier 0 proposals.4.1 Gas
Cycle costs below do not determine an access limit. The CBSS access rows are below in CIP-43 notation:Rk(k) is k committed point reads and Wk(k) is k writes, in structural units before the access-weight scalar. They are access-weight table version 43. Every row includes the common CBSS pause read. Terms after “then” are charged as committed state is read.
c is new_committee.len. P is the committed proxy-registry entries read and C the old-committee members. V is committed active versions or volume-cursor entries. For evidence history, E ≤ 64 indexed epochs are read, U epoch values are changed or created and D expired values are deleted. For a slash, S is the indexed scopes and A the member scopes; C_i and P_i are the old-committee size and proxy-registry reads for scope i. Each reshare-outbox append costs one metadata read and write plus one write per page. The daemon estimates RotateCommittee against committed state before signing each attempt, including retained history and any account force-rekey volume page; it uses a bounded history-aware fallback if estimation is unavailable or unusable. An args-only formula is insufficient.
4.2 Stake / committee
This chain runs at 1 second per block (BLOCKS_PER_YEAR = 31_536_000,1 day = 86_400 blocks). Every duration-in-blocks below is computed against 1 s/block. In 2026-07, a few defaults below are governance-tunable and the deployed value differs; the deployed value is authoritative until governance sets otherwise.PROXY_SOAK_PERIOD, deployed 100 (a devnet/launch-short soak), vs the ~30-day mainnet target.RESHARE_INTERVAL_BLOCKS, deployed 1_296_000 (~15 days, a deliberate demo-scale cadence), vs the ~6-month production default.MIN_PROXY_STAKE, deployed 1_000 CBY (CBSS_MIN_PROXY_STAKE), not 10,000, pending a governance decision.GOVERNANCE_REVIEW_BLOCKS, 2_592_000 in code. Governance decides these economic/launch values.
4.3 Slashing schedule
Provable on-chain only.PlaintextLeak and liveness non-receipt are NOT auto-slash:
- PlaintextLeak evidence requires publishing the secret. Off-chain disclosure can lead to CIP-12 Tier 1
ForcedDeregisterCbssProxy. - Liveness non-receipt cannot be proven on chain because packet delivery is not chain-witnessable. The §4.4 health score can lead to governance review.
A disclosed leak triggers a CIP-12 Tier 1 proposal that, if passed, calls
ForcedDeregisterCbssProxy(proxy_id) and routes the entire stake to a remediation pool. The remediation-pool payout itself is governance-mediated (lean: capped at MAX_LEAK_REIMBURSEMENT = 100,000 CBY per incident).
Liveness affects the health score (§4.4). No automatic stake loss on liveness; persistent degradation drives governance review.
4.4 Health score
Each proxy carries a health score in[0.0, 1.0], decayed and updated based on observable behavior. Used as a multiplier on VRF selection weight; persistent low scores escalate to governance review.
Concrete coefficients are governance parameters (CIP-12). The protocol enforces only that VRF weight =
stake × max(MIN_HEALTH_FLOOR, health_score), where MIN_HEALTH_FLOOR (default 0.05) prevents complete exclusion that would block reshare unanimity.
Persistent extreme degradation (health < 0.1 for ≥ GOVERNANCE_REVIEW_BLOCKS ≈ 30 days) flags the proxy for an automatic CIP-12 Tier 1 deregistration proposal. Governance vote follows.
4.5 Quotas / limits
The quotas follow §5.4 of the design notes:5. SDK surface (CIP-6 extension)
5.1 New entitlement
{"account", "key"} is the canonical wire shape.
secrets.verify (§5.5) grants verify-only use of a key as an inbound-MAC key. Same keys shape and subset-upgrade rule. A key listed under secrets.verify is releasable for a verify= MAC check but is not readable through a runner.secret() slot unless also listed under secrets.read. This stops an actor from exfiltrating a signing secret it can only verify with. A key MAY hold both grants; within a single job the §5.5 overlap rule still forbids the same key serving both roles.
5.2 Runner-op secret slots
runner.secret(key, prefix="", suffix="", account=None) marks the one string a secret fills: an Http job’s url=, a header value or a string inside a dict or list body=, or a string in an Mcp job’s tool arguments. The runner sends prefix + <secret> + suffix there and fills nothing else; any other ${NAME} in the job, including one in caller or model text, is sent as literal text. account defaults to the owning account of the actor issuing the runner-op. The SDK adds the [account, key] grant to the job’s secrets (its secret_refs) and writes the job’s secret_slots; a hand-written secret_slots is refused, and a runner.secret() anywhere else fails to encode.
On the wire (JobSpec v7) each slot is SecretSlot { pointer, account, key, offset }: an RFC 6901 pointer into the job, the account and key name, and the byte offset the secret goes at (the prefix’s UTF-8 length). validate() allows at most 16 slots, strictly ascending by pointer, each granted by a secret_refs entry and rooted at /url, /headers/<name> or /body/... of an Http job or /arguments/... of an Mcp job; a url or header slot’s offset is a char boundary inside its string. job_spec_hash covers the slots, so where a secret goes is a term of the job. A slot on any other job type is refused, and the runner fills no LLM prompt.
5.3 Errors
Implementations MUST use these canonical error names to avoid divergent vocabularies. SDK / runner / proxy / chain handlers all map their failure modes to this set.5.4 CLI
5.5 Inbound-verification precondition (verify=)
Some runner-ops receive an inbound, externally-signed request (e.g., a Slack slash-command callback) and need to check the caller’s signature before proceeding, without pulling the underlying secret’s plaintext into the actor’s own code, only into the runner sandbox that already holds it for the op. CIP-24 adds an optional inbound-verification precondition to a job, exposed to callers as a verify= kwarg alongside secrets= (§5.2):
verify= normalizes to an optional JobPrecondition on the job spec:
VerifyAlgo carries provider-neutral cryptographic operations only, never a provider name. This is the two-layer split: the provider-specific parts (the message preimage construction and the prefix choice) live in the actor / the connector’s integration definition at the control plane; the wire and consensus carry only neutral crypto. The single scheme today is Hmac:
[prefix ‖] encoding(HMAC-<hash>(secret, message)) and compares it constant-time to signature. prefix is a small scheme-version tag (≤ 16 bytes), None for a bare encoded MAC. Provider profiles are just field values:
An actor adds an HMAC-based webhook provider by choosing new field values. This requires no protocol change. Implementations MUST reject any unknown
MacHash/SigEncoding/VerifyAlgo tag (fail-closed, same discipline as HttpMethod) and an over-cap prefix. A new cryptographic scheme, such as ed25519 / RSA webhook signatures, would add a new VerifyAlgo variant (tag 1+) via a CIP-24 amendment.
Both admission checks below are pure (no chain/registry state) and MUST be enforced in the same admission gate as the job spec’s other structural checks, before any secret lookup or release is attempted:
len(precondition.message)MUST NOT exceed 64 KiB (65536 bytes). Averify=request whosemessageexceeds the cap is rejected at admission, before verification is attempted.precondition.secret_refMUST NOT overlap with any entry in the job’s read set. It MUST NOT name the same{account, key_hash}pair as an entry insecret_refs, thesecrets=read set (§5.1/§5.2). A job uses a given secret for either signature verification or plaintext reading into the sandbox. It cannot use the same{account, key_hash}for both roles.
verify= folds verification into the front of the runner op the actor was already going to dispatch.
secrets.verify restricts use to signature verification. The signing secret is not an outbound credential for secrets.read. With a secrets.read grant, an actor could mark it with runner.secret() in a request header or body and exfiltrate it. secrets.verify grants only the right to use a key as a verify= MAC key (§5.1): validate() keeps the verify key out of the job’s secret_refs, so no slot can fetch it, and the release authorizer denies any reference whose purpose does not match the key’s grant (§3.1, SecretAccessDenied). A key MAY hold both grants; the overlap rule above still forbids both roles for the same key within one job.
Within a runner op carrying verify=, the runner MUST, in order: (1) release verify.secret_ref under the secrets.verify purpose (the key’s name comes from the actor manifest’s secrets.verify entry); (2) compute the MAC over message and compare it constant-time to signature; (3) on mismatch, abort with JobPreconditionFailed and invoke no executor, no HTTP request, no agent loop, no MCP call, no outbound side effect; (4) only on match, release the read set (secret_refs), fill the job’s secret_slots, and execute. The runner MAY prefetch read-set secret metadata and plan committee fanout before the MAC check, but MUST NOT release or fill any read-set plaintext until the MAC passes. A forged webhook never triggers a read-set release. The verify plaintext is confined to a verify-only ephemeral: it MUST be zeroized before the executor runs, and it never enters the read-set SecretBundle (§3.9). JobPreconditionFailed is terminal: the assignment MUST NOT be retried or reassigned on MAC failure.
message is opaque bytes on the wire (base64 in the SDK JSON interface; the runner decodes to exact bytes and never parses or re-serializes them). The runner computes the MAC over the bytes it receives, so the actor MUST construct message as the provider’s exact canonical preimage over the verbatim received body. For the Slack profile (Hmac{Sha256, Hex, "v0="}), the actor constructs message as exactly b"v0:" + ascii(timestamp) + b":" + raw_body and the runner accepts iff signature == "v0=" + lowerhex(HMAC_SHA256(secret, message)). For the Twilio profile (Hmac{Sha1, Base64, none}), message is the URL followed by each POST param name+value in sorted order, and the runner accepts iff signature == base64(HMAC_SHA1(secret, message)). Any JSON re-encode, unicode round-trip, or whitespace normalization changes the bytes and MUST fail; a conformance test SHOULD sign a body with duplicate keys, trailing whitespace, and non-ASCII to ensure a reparsing implementation cannot pass by accident. New HMAC-based providers (GitHub sha256=, Stripe, …) are new Hmac field values chosen by the actor, never new protocol variants.
The precondition authenticates the payload. It does not authenticate the dispatch: the actor dispatches on an unverified inbound request, so a forged webhook costs one chain dispatch plus at most one verify-release attempt per assigned runner before the MAC fails and the op aborts terminally, and nothing more: no read-set release, no executor work, no outbound side effect, no plaintext leak. Because adaptive committee sizing MAY assign M runners to an op, verify-precondition ops SHOULD execute single-runner (redundancy buys nothing for a fail-closed gate), and JobPreconditionFailed being terminal prevents reassignment from multiplying attempts. Actors SHOULD further bound the residual with four on-chain, secret-free prefilters applied before dispatch: a message-size cap, a timestamp-freshness window, exact-replay suppression keyed on (ts, signature, body_hash) (the only fields fixed before the MAC), and actor-level per-interval rate and spend caps. Replay suppression drops byte-identical resends but does not prevent forgery. Per-channel / per-user limits are best-effort only: the attacker controls the body before the MAC passes, so sender identity cannot be authenticated pre-verification. The guarantee verify= provides is that no forged request ever produces an authenticated side effect or a read-set release; the cost it does not eliminate is the bounded dispatch + verify-release attempt(s), which the spend cap limits.
6. Implementation notes
6.1 Status
Devnet implements the runner-side secrets client, the cryptography layer, thecbssd operator daemon, the on-chain handlers for the §3.5 instructions, the CBSS RPC methods, the cowboy secrets / cowboy proxy CLI commands, and the CBFS /v1/cbss/blob route.
CIP-2 describes off-chain
compute and system actors; CIP-6 §14.3
lists the SDK entitlements; the Technical Whitepaper §9
defines system-actor addresses. CBSS opcode assignments are listed in §3.3.
6.2 Runner-side SecretsClient trait
PartialSign RPCs over QUIC+bincode. It verifies the BLS partial signatures with pairing checks, combines them with Lagrange interpolation, and IBE-decrypts wrapped_dek using K = HKDF(serialize(e(σ, U)), "cbss/ibe/v1" || aad). It fetches the CBFS object, AES-GCM-decrypts it with DEK, and returns Zeroizing<Vec<u8>> per key. The bundle drops at the end of the runner-op. The default path injects no environment variables. HTTP and MCP executors fill secret_slots from the bundle when constructing requests (§3.9). Only spawned subprocesses receive environment variables through an explicit map on a cleared environment.
6.3 No persistent owner-side DEK cache
The per-account anchoring + IBE construction means owners do not need a local DEK cache. ACL changes (UpdateSecretPolicy) are pure metadata and require no re-wrapping. The cowboy secrets set CLI holds a DEK in process memory only for the duration of one set/finalize operation, and zeroizes on exit. There is no on-disk cache to manage, prune, or seal.
6.4 RPC additions
Release-key discovery MUST exposerelease_key_suite: u8. The only supported
value is 1, identifying BLS12-381 G2 release-key material. Clients MUST refuse
records with a missing tag, 0, 2, or any other unsupported value before
using the MPK or commitments; they MUST NOT infer the suite from point length.
This tag is separate from CIP-40’s signing-algorithm IDs.
The stored record AccountReleaseKeyV1 lives under 0x04 at
b"account_release_key:" ‖ account[20]. Its value is compact JSON
(serde_json::to_vec) with the fields below in this order:
Readers MUST reject unknown fields and any value over 65,536 bytes. They MUST
re-serialize the decoded value and require byte equality, which rejects
reordered keys, whitespace, alternate escapes and duplicate fields.
committee_operators and prior_committee_epochs default to empty when absent.
GET /cbss/account-release-key/{account} returns this record as a JSON object
with release_key_suite, account, threshold, committee_epoch,
release_key_material_hash, mpk_g2, vss_commitments_g2, committee and
prior_committee_epochs ([{epoch, expires_at}]). Byte fields there are
0x hex strings. Clients MUST recompute release_key_material_hash from the
returned fields and the trusted chain identity, and MUST refuse a response
where it is missing or does not match.
The same discovery requirement applies to account and secret-specific release keys. Both account and secret-specific RPC responses copy release_key_suite from the stored release key; the snapshot response also requires the field.
The node serves these read-only REST routes; there is no JSON-RPC secrets_* or proxy_* method:
key_hash is the hash of the key name; SDK and CLI wrappers hash plaintext names before calling.
7. Implementation status
External crypto review is required before launch. The CIP-9 volume-DEK integration (§9.3) on the committee-seal path includes thecbssd volume seal service, release-key material-hash binding, re-wrap-after-re-key flow, share finality, and the node’s hold-until-key-delivery gate. It uses the WrappedDek format version 2 specified here. Governance enactment provides the system-scope DKG bootstrap (§3.5).
Remaining validation work covers full Intel DCAP/TDX and AMD SEV-SNP/VLEK
vendor-collateral validation, the full §5.9 DKG proof matrix, high-rate stress
against a spawned validator, a Byzantine proxy over QUIC, and broader
real-validator negative/recovery scenario coverage.
8. Security considerations
8.1 The t-collusion question
For the default(n, t) = (5, 4), an attacker needs to compromise 4 of 5 specific operators simultaneously. With per-account anchoring (§10.2), a successful t-collusion exposes all of the account’s default-path secrets for the duration of the compromise window, retroactively decrypting any wrapped DEKs the colluding proxies could observe at release time. Hardening levers:
- Governance can require jurisdictional, software-version, hardware-source and organizational diversity. It MAY refuse to admit registrations that concentrate the proxy set.
- PlaintextLeak is NOT auto-slashable on chain (§4.3) because objective on-chain evidence would publish the secret. A disclosed leak triggers a CIP-12 Tier 1 governance proposal that, if passed, calls
ForcedDeregisterCbssProxy(proxy_id)and routes the offending proxy’s stake to a remediation pool (default capMAX_LEAK_REIMBURSEMENT). WithMIN_PROXY_STAKE = 10,000 CBYand defaultt = 4, t-collusion still risks at leastt × MIN_PROXY_STAKEplus permanent ban, but the slash is governance-mediated, not protocol-automatic. - VRF determines committee membership per account at DKG time, so an attacker cannot pre-position.
- Proactive reshare (insider rotation, with old shares NOT cryptographically invalidated): every
RESHARE_INTERVAL_BLOCKS, the share polynomial rotates. PSS preservesMSK, so a retained old share can still partial-sign any historical-wrap_epochidentity off-chain. There is no cryptographic invalidation of old share material. What reshare DOES do: (a) replaces the share at-rest in cbssd’s storage (an honest proxy zeroizes perDeleteSecretVersion/reshare protocol), (b) rotates committee membership so previously-compromised proxies must be re-compromised under the new committee_epoch to keep contributing to t-of-n, (c) makes the prior committee no longer accepted by the chain for receipts pastRESHARE_GRACE_BLOCKS. The honest-share-zeroization assumption is operational, not cryptographic. An exfiltrated share retains its contribution to offline threshold operations over historical identities.DeleteSecretremoves the on-chain version rows and pointer and revokes subsequent chain-authorized release; it does not cryptographically invalidate copied shares, wrapped DEKs or ciphertext. - For secrets where the per-account blast radius is unacceptable, the
committee_overridepath triggers a one-off DKG with its own committee, isolating that secret’s exposure to compromise from the rest of the account. Owners SHOULD use override forSTRIPE_LIVE_KEY-class secrets and use the account default for routine credentials.
8.2 Owner key compromise
If the owner’s account key is compromised, the attacker can issueUpdateSecretPolicy to add an attacker-controlled actor to the ACL, then fetch any of that owner’s secrets. CBSS does not defend against account-key compromise. Recovery happens out of band. Account-recovery flows are out of scope for this CIP.
8.3 Compromised runner
A compromised runner can exfiltrate the plaintext for the secrets it is currently authorized to fetch. It cannot:- Fetch secrets retroactively (release is anti-replayed per
(job_id, secret_id, runner)). - Impersonate other runners (signatures over runner registry key).
- Fetch secrets for jobs it isn’t currently assigned to (proxy validates dispatcher’s on-chain assignment).
8.4 Validator / dispatcher / chain-observer privacy
8.5 Anti-replay and freshness
- Each release uses
(release_id, proxy_id)as the dedup key.release_idis defined canonically in §3.5 next toReleaseRequestBody; it is stable acrossrequest_blockre-pinning and includesrelease_nonce, so legitimate second pulls within a job get a distinct release_id. Proxies maintain a 24-hour bloom keyed on(release_id, proxy_id); chainrelease_receipt:{release_id} → { quorum_epoch, entries: Map<ProxyId, ReleaseReceipt> }provides eventual-finality dedup and single-epoch quorum enforcement.request_hash(which includesrequest_block) is used only for sig verification on the specific request, not for dedup. - Pinned-version pulls fail closed if the version was deleted (
SecretVersionDeleted). wrap_epochis read from the SecretVersion on chain (immutable per version); reshare does NOT invalidate in-flight requests since PSS preserves MSK and the proxy’s current share validly partial-signs any historical identity.
8.6 DKG correctness and liveness
- Pedersen VSS commitments allow any party to verify share validity. A proxy submitting a malformed share is detectable and slashable for
DkgSabotage. - If the ceremony fails to finalize within
DKG_FINALIZE_BLOCKS, the requesting tx’s DKG bond is partially slashed and refunded; the owner may retry. To improve ceremony liveness, VRF-selectn + 2proxies and requirento complete (over-sample for ceremony liveness).
8.7 Future-shock: cryptographic break
A break of BLS12-381, through co-BDH for IBE wrap confidentiality (§3.4.4) or co-CDH for BLS signature unforgeability, compromises the platform. So does a break of AES-256-GCM or secp256k1 ECDLP. Ethereum, Filecoin and Cowboy share these cryptographic dependencies. As in §8.1,DeleteSecret revokes chain-authorized release; deletion does not cryptographically invalidate copied ciphertext or key material. Curve agility (e.g., upgrading the IBE construction to BLS12-461 or a post-quantum threshold scheme) is a future CIP, out of scope here.
8.8 Comparison vs TEE-based release
CIP-24 picks the right column. CIP-23 keeps the left column available for execution (and as an additional gate via
tee_required); the two layer cleanly.
9. Interaction with other CIPs
9.1 CIP-2 (Off-chain compute)
CBSS state belongs to system actor0x0000…0004 (CIP-2 §Specification; storage keys and lifecycle in §3.2).
9.2 CIP-6 (SDK + entitlements)
secrets.read is registered in the entitlement registry. The subset-on-upgrade invariant (CIP-6 §12.1) applies: an actor cannot expand the keys it can request without redeploying.
9.3 CIP-9 (Runner storage)
CIP-24 provides the committee-seal delivery path for CIP-9 private volumes that carry a committee wrap. On this path, the runner obtains the volume’s data-encryption key (DEK) through a committee seal; the Dispatcher never handles the plaintext DEK. CIP-9 §9.2 also defines the dispatched-grant path: a matching grant lets the runner open an off-chain-sealed package without a committee wrap,SealRequest or CBSS release-key material. An owner-wrap-only volume is therefore
runner-mountable only through a matching grant. The committee requirements below
apply only to committee-seal delivery.
When committee wrapping is selected at volume creation, the DEK is IBE-wrapped to the owner account’s CBSS master public key (MPK), like any SecretVersion (§3.4). The wrap is stored on the volume’s StorageCommitment as wrapped_dek, bound to the account’s cbss_committee_epoch. StorageCommitment.wrapped_dek uses the same WrappedDek format version 2: it carries ephemeral_u, uses K = HKDF(serialize(e(I, MPK)^r), "cbss/ibe/v1" || aad) owner-side, and validates/decrypts with K = HKDF(serialize(e(σ, U)), "cbss/ibe/v1" || aad) runner-side.
The volume path uses CIP-9’s identity and base AAD. The 172-byte secret base_aad of §3.4.3 applies only to account secrets. The IBE identity is I_vol = hash_to_G1( volume_dek_identity, domain = "cbss/ibe/cip9-volume-dek/v1" ), and the base AAD is base_aad = cip9_hash( "cowboy.cip-9.volume-dek-aad.v1", volume_dek_identity ), a 32-byte value, where volume_dek_identity is CIP-9’s 32-byte volume-DEK identity hash (“Release at mount” below). The full AEAD AAD is base_aad || compress(U) (32 + 96 = 128 bytes), validated by full equality exactly as in §3.1 (len(aad) != 32 + 96 is malformed and MUST be rejected with AadMismatch). The HKDF salt and info prefix remain "cbss/ibe/v1" (§3.4.3); only the hash-to-curve domain and base AAD differ on the volume path.
When a storage-attached job is dispatched with committee-seal delivery, the node builds a SealRequest for the volume carrying owner, volume_id, dek_version, committee_epoch, and the material hash below. The node does not unwrap the DEK. The committee serves threshold partials per §3.6.3 against the volume-DEK identity volume_dek_identity(chain_id, owner, volume_id, dek_version, committee_epoch, release_key_material_hash, committee_override_hash); the runner Lagrange-combines t partials to recover the DEK. The node holds the job until the committee release finalizes. It does not expose the job to a runner before that point, and duplicate delivery is idempotent. A dispatched-grant attachment needs no committee key delivery and does not introduce this hold.
CIP-33 conditions release on Trading Post state. For a volume registered as a CIP-33 serving artifact, this release rule gains one additional condition: the SealRequest is honored only when the CIP-33 §2.5.1 issuance predicate (hire, term, and lifecycle state) also passes. The hire/artifact identities remain outside the request fields. SealRequest is unchanged, byte for byte: cbssd recovers them deterministically from the authenticated JobSpec the request’s job_id resolves to (the job binding to (hire_id, artifact) is consensus state written at dispatch, per CIP-33 §2.5.1), and evaluates the predicate against chain state at the current block. A request whose job carries no hire binding for a Trading-Post-registered volume is refused. Replay tests verify that a stale SealRequest re-presented after hire revocation or lease-epoch advance is refused by the same state read. The request asserts nothing the state does not confirm. Identity derivation, DST, AAD, material-hash binding, and rewrap semantics are unchanged.
9.3.1 Release-key material-hash binding (re-key safety)
A volume’s committee wrap is pinned to the exact committee key material it was created against, via a 32-byte release-key material hash:cip9_hash("cowboy.cip-9.release-key-material.v1", chain_id ‖ account ‖ committee_epoch ‖ threshold ‖ committee ‖ MPK ‖ VSS_commitments). The volume’s StorageCommitment records cbss_release_key_material_hash (the material the DEK is wrapped against) and cbss_rewrap_required.
At mount, a private attachment using committee-seal delivery requires:
cbss_release_key_material_hashis set (a zero hash is rejected);cbss_rewrap_required == false;- the recorded hash equals the release-key material retained for the volume’s
committee_epoch(release_key_view.material_hash).
cbss_rewrap_required only
when a committee wrap is present and clears all grants; the new owner can
authorize a new matching grant without a committee rewrap (CIP-9 §13.4).
A reshare (§3.6.2) preserves MPK and increments committee_epoch. A volume’s committee wrap is pinned to a specific epoch’s material hash (unlike a general SecretVersion, whose wrap_epoch-bound identity makes reshare fully transparent, §10.7), so reshare is transparent to committee-seal delivery only while the prior epoch’s material is retained, during the grace window: the committee keeps serving against the volume’s recorded epoch for that window, after which its wrap is stale and must be re-wrapped to a current epoch. An account re-key (recovery: the release-key material fundamentally changes) changes the release key. Existing committee wraps can no longer be served, so affected volumes are flagged cbss_rewrap_required = true immediately and committee-seal mounts are blocked until the owner re-wraps. Either path resolves the same way: re-wrapping the DEK to the current material updates cbss_release_key_material_hash and clears cbss_rewrap_required (the CBFS CLI ships the flow). A matching dispatched grant remains independent of these committee-seal requirements.
Proxies finalize their shares before serving partials (bounded pending share promotions), so a release never combines partials against a half-promoted share across a ceremony boundary.
9.4 Protocol opcode allocation and system-actor registry
The canonical protocol codec assigns opcodes 68–84 to CBSS and 60–63 to the trusted-key TEE attestation instructions. See §3.3 for the instruction list and the Technical Whitepaper §9 for the system-actor registry.9.5 CIP-23 (TEE Execution)
CIP-23 attestation is optional per secret via thetee_required flag. When set, the runner MUST present a CIP-23 attestation valid for the active job_id; the chain validates TEE eligibility at receipt submission using the logical TEE Verifier records physically stored at 0x04 (§3.2), and proxy serving must fail closed unless the node authorizer path can confirm a live attestation. The current devnet TEE Verifier validates registered P-256/P-384 ECDSA attestation keys over canonical CBSS attestation bytes. It does not yet validate Intel DCAP/TDX or AMD SEV-SNP/VLEK vendor collateral; that remains TEE verification work. TEE here is defense-in-depth on top of threshold release, not the trust root.
9.6 CIP-34 (Intent Settlement)
CIP-34’s sealed-bid auctions use time-lock release (§3.4.6). A bid is IBE-encrypted to identityrequest_id with target_height = reveal_height, and the committee posts the height-gated release at reveal_height so the native reveal handler and any observer can decrypt all bids at once. The key becomes available independently of any bidder. This supplies the caller-chosen auction identity and automatic height-based release required by CIP-34 §Sealed-Bid. No new committee, key, or trust is introduced. Sealed auctions use the same staked CBSS committee. CIP-34 owns the liveness fallback (expiry of AUCTION_GRACE cancels the auction with CancelledGraceExpired; no OPEN re-open, no escrow held) if the committee fails to release by reveal_height + AUCTION_GRACE.
Bootstrapping establishes the 0x14 committee. The sealed-bid path presumes Account(0x14) already has a live CBSS committee / MPK, but 0x14 is keyless and cannot self-issue RequestAccountDkg. GovRequestSystemDkg (opcode 158, §3.5) closes this: governance (0x09) issues one GovRequestSystemDkg { scope: Account(0x14), force_rekey: false } to establish the committee through an ordinary DKG followed by RotateCommittee (no bond, no new trust). This MUST happen before the first OpenAuction. Governance MUST NOT force_rekey the 0x14 committee while auctions are in flight (see §3.5: a re-DKG installs a new MPK and strands in-flight bids); routine refresh uses RequestReshare (§10.7).
10. Rationale
10.1 Why threshold IBE on BLS12-381
As described in §3.4.5, vetted libraries exist for threshold BLS signatures and IBE on BLS12-381 (blstrs, Commonware BLS DKG, tlock); they do not exist for threshold ElGamal on secp256k1. Using vetted cryptographic implementations takes priority over reusing the account-signature curve.
The IBE construction does not use kfrags or proxy re-encryption; it uses BLS signature shares as IBE decryption keys. The recipient-targeting problem that kfrag-based PRE designs address is solved here by binding the IBE identity to per-version metadata that all parties can compute deterministically.
10.2 Why per-account by default, with per-secret override
- Per-secret committees scale
O(num_secrets × n)system-wide with a fresh DKG every time someone stores a credential. The bootstrap cost is prohibitive. - Per-actor committees isolate an actor’s secrets from the rest of an account’s secrets, but the isolation only materializes when ACLs are narrow. Once a secret’s ACL fans out across multiple actors, an attacker just attacks the weakest of those committees. Per-actor is no better than per-account in the wide-ACL case. Per-actor also pays a DKG every time you deploy a new actor, and forces a chain re-wrap on every ACL edit (since each ACL actor needs its own wrapped DEK). This adds operational work with limited security gain when ACLs are broad.
- Per-account committees match the practical sharing patterns of production secret management (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault are all account/project-scoped). Bootstrap is one DKG amortized over the account’s lifetime. ACL edits are pure metadata. Storage is
O(1)wrapped DEK per version regardless of ACL size.
MPK. Mitigations:
- High-value accounts can tune
(n, t)by raisingnandtthrough governance-supported account parameters once larger vetted DKG quorums are enabled. The default is(5, 4). - A single high-value secret (
STRIPE_LIVE_KEY) can opt into its own committee atSetSecrettime, isolating its blast radius from the rest of the account’s secrets. - Every
RESHARE_INTERVAL_BLOCKS, the share polynomial rotates. An attacker has a finite window. - Committee admission policy can require jurisdictional / vendor / org diversity.
10.3 Why a new operator role, not extending Relay Nodes
Different failure semantics, slashing math, and operator profile (§3.1). A node can register as both Relay and Proxy; the protocol roles stay distinct.10.4 Why in-memory bundle by default (and explicit subprocess env when required)
Plaintext exists only in the runner-op execution context, only as the substituted final-form request. It never enters PVM Python state and cannot be accidentally logged, persisted or echoed in error messages.10.5 Why two-layer access control (manifest ∩ ACL)
Manifest is the actor’s advertised need (caught at deploy-time review). ACL is the owner’s consent (caught at the runtime gate). Both layers answer different threats: a malicious actor lying about its needs is caught at deploy time; a compromised owner key that grants too broadly is at least bounded by the manifest of each individual recipient actor.10.7 Why MPK is preserved on reshare
Owners encrypt to MPK. If reshare changed MPK, every existing wrapped DEK on chain would become un-decryptable, forcing owner re-encryption en masse. Preserving MPK across reshare (proactive secret sharing on the same MSK) means reshare is invisible to owners. Only the share polynomial rotates.
The per-version IBE identity binds the SecretVersion’s immutable wrap_epoch. The live committee_epoch does not determine this identity. Reshare changes committee_epoch but does NOT change any existing version’s wrap_epoch. New SetSecret calls after a reshare bind to the then-current committee_epoch as their wrap_epoch. The threshold-sig math works for any historical identity because PSS preserves MSK across reshare.
10.8 Why per-proxy receipts, not a single aggregate RecordSecretRelease
A single aggregate audit/payment instruction submitted “by the runner or any participating proxy” would leave payment dependent on either runner cooperation (which the runner has no incentive to provide once it has the plaintext) or implicit proxy coordination (unspecified, and prone to gas-bidding wars or dropped submissions).
SubmitReleaseReceipt (opcode 76) instead makes each proxy submit its own receipt independently. Each accepted receipt debits RELEASE_FEE_PER_RECEIPT from the actor’s account (subject to overdraft cap) and credits the submitting proxy. Payment is capped at quorum: only the first t receipts per release_id are paid; receipts t+1..n (which a runner may have triggered by over-fanning out) are rejected with QuorumAlreadyReached. Properties:
- The runner cannot withhold submission to prevent proxy payment.
- Proxies need no coordination. Each proxy decides independently when to submit; the first t proxies to land on chain are paid; later submissions for the same release_id (whether from the n-t over-fanout or from the same proxy on a re-pin) are rejected. Proxies SHOULD watch
release_receipt:{release_id}.entriesand stop attempting onceentries.len() == t. - The record
release_receipt:{release_id} → { quorum_epoch, entries: Map<ProxyId, ReleaseReceipt> }accumulates the full t-of-n proof of release on chain, each entry carrying the verbatim runner-signed request and the verifiedσ_i. TheSecretReleasedevent fires when the t-th entry lands, carrying the actualproxy_setof t contributors. - Each release costs t transactions. A single aggregate instruction would cost one. The default release rate is O(1 per actor-job). High-frequency users could add an aggregator later without changing the on-chain interface.