@did-btcr2/method 0.34.0 → 0.36.0

package/dist/browser.js

@@ -93203,6 +93203,8 @@ a=end-of-candidates
     InMemoryRateLimitStore: () => InMemoryRateLimitStore,
     InMemoryTransport: () => InMemoryTransport,
     InboxBuffer: () => InboxBuffer,
+    KNOWN_BEACON_TYPES: () => KNOWN_BEACON_TYPES,
+    KeyPairAggregationSigner: () => KeyPairAggregationSigner,
     NONCE_CONTRIBUTION: () => NONCE_CONTRIBUTION,
     NonceCache: () => NonceCache,
     NostrTransport: () => NostrTransport,
@@ -93274,6 +93276,7 @@ a=end-of-candidates
     registerBeaconStrategy: () => registerBeaconStrategy,
     reviveFromWire: () => reviveFromWire,
     signEnvelope: () => signEnvelope,
+    validateCohortConditions: () => validateCohortConditions,
     verifyEnvelope: () => verifyEnvelope,
     verifyRequestAuth: () => verifyRequestAuth
   });
@@ -100117,6 +100120,13 @@ a=end-of-candidates
   // ../keypair/dist/esm/types.js
   init_shim();
 
+  // ../keypair/dist/esm/utils.js
+  init_shim();
+  function wipe(bytes3) {
+    if (bytes3)
+      bytes3.fill(0);
+  }
+
   // ../cryptosuite/dist/esm/multikey/index.js
   init_secp256k1();
   init_utils();
@@ -100703,8 +100713,48 @@ a=end-of-candidates
 
   // src/core/aggregation/cohort.ts
   init_shim();
-  init_secp256k1();
-  init_utils();
+
+  // ../bitcoin/dist/esm/index.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/connection.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rest/index.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rest/address.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rest/block.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/errors.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rest/transaction.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rest/protocol.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/http.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rpc/index.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rpc/json-rpc.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/utils.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/client/rpc/protocol.js
+  init_shim();
+
+  // ../bitcoin/dist/esm/network.js
+  init_shim();
 
   // ../../node_modules/.pnpm/@scure+btc-signer@1.8.1/node_modules/@scure/btc-signer/esm/index.js
   init_shim();
@@ -102903,6 +102953,48 @@ a=end-of-candidates
     }
   };
 
+  // ../bitcoin/dist/esm/network.js
+  var REGTEST_NETWORK = {
+    bech32: "bcrt",
+    pubKeyHash: 111,
+    scriptHash: 196,
+    wif: 239
+  };
+  function getNetwork(network) {
+    switch (network) {
+      case "bitcoin":
+        return NETWORK;
+      case "testnet3":
+      case "testnet4":
+      case "signet":
+      case "mutinynet":
+        return TEST_NETWORK;
+      case "regtest":
+        return REGTEST_NETWORK;
+      default:
+        throw new Error(`Unknown network "${network}"`);
+    }
+  }
+
+  // ../bitcoin/dist/esm/constants.js
+  init_shim();
+  var TXIN_WITNESS_COINBASE = "0000000000000000000000000000000000000000000000000000000000000000";
+  var GENESIS_TX_ID = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
+
+  // ../bitcoin/dist/esm/types.js
+  init_shim();
+  var VerbosityLevel;
+  (function(VerbosityLevel2) {
+    VerbosityLevel2[VerbosityLevel2["hex"] = 0] = "hex";
+    VerbosityLevel2[VerbosityLevel2["json"] = 1] = "json";
+    VerbosityLevel2[VerbosityLevel2["jsonext"] = 2] = "jsonext";
+    VerbosityLevel2[VerbosityLevel2["jsonextprev"] = 3] = "jsonextprev";
+  })(VerbosityLevel || (VerbosityLevel = {}));
+
+  // src/core/aggregation/cohort.ts
+  init_secp256k1();
+  init_utils();
+
   // ../../node_modules/.pnpm/@scure+btc-signer@1.8.1/node_modules/@scure/btc-signer/esm/musig2.js
   init_shim();
   init_modular();
@@ -103291,7 +103383,7 @@ a=end-of-candidates
     validationRejections = /* @__PURE__ */ new Set();
     constructor({ id, minParticipants, serviceDid, network, beaconType }) {
       this.id = id || crypto.randomUUID();
-      this.minParticipants = minParticipants || 2;
+      this.minParticipants = minParticipants ?? 2;
       this.serviceDid = serviceDid || "";
       this.network = network;
       this.beaconType = beaconType || "CASBeacon";
@@ -103317,7 +103409,7 @@ a=end-of-candidates
       }
       const keyAggContext = keyAggregate(this.#cohortKeys);
       const aggPubkey = keyAggExport(keyAggContext);
-      const payment = p2tr(aggPubkey);
+      const payment = p2tr(aggPubkey, void 0, getNetwork(this.network));
       this.tapTweak = schnorr2.utils.taggedHash("TapTweak", aggPubkey);
       if (!payment.address) {
         throw new AggregationCohortError(
@@ -103457,6 +103549,57 @@ a=end-of-candidates
     }
   };
 
+  // src/core/aggregation/conditions.ts
+  init_shim();
+  var KNOWN_BEACON_TYPES = ["CASBeacon", "SMTBeacon"];
+  function checkPair(problems, label, min, max) {
+    if (min !== void 0 && (!Number.isInteger(min) || min < 0)) {
+      problems.push(`min${label} must be an integer >= 0`);
+    }
+    if (max !== void 0 && (!Number.isInteger(max) || max < 0)) {
+      problems.push(`max${label} must be an integer >= 0`);
+    }
+    if (min !== void 0 && max !== void 0 && Number.isInteger(min) && Number.isInteger(max) && max < min) {
+      problems.push(`max${label} must be >= min${label}`);
+    }
+  }
+  function checkCost(problems, label, cost) {
+    if (cost === void 0) return;
+    if (typeof cost.amount !== "number" || !Number.isFinite(cost.amount) || cost.amount < 0) {
+      problems.push(`${label}.amount must be a finite number >= 0`);
+    }
+    if (typeof cost.unit !== "string" || cost.unit.length === 0) {
+      problems.push(`${label}.unit must be a non-empty string`);
+    }
+    if (cost.basis !== void 0 && cost.basis !== "per-did" && cost.basis !== "per-participant") {
+      problems.push(`${label}.basis must be 'per-did' or 'per-participant'`);
+    }
+  }
+  function validateCohortConditions(c2) {
+    const problems = [];
+    if (!KNOWN_BEACON_TYPES.includes(c2.beaconType)) {
+      problems.push(`beaconType must be one of ${KNOWN_BEACON_TYPES.join(", ")}`);
+    }
+    if (!Number.isInteger(c2.minParticipants) || c2.minParticipants < 1) {
+      problems.push("minParticipants must be an integer >= 1");
+    }
+    if (c2.maxParticipants !== void 0) {
+      if (!Number.isInteger(c2.maxParticipants) || c2.maxParticipants < 1) {
+        problems.push("maxParticipants must be an integer >= 1");
+      } else if (Number.isInteger(c2.minParticipants) && c2.maxParticipants < c2.minParticipants) {
+        problems.push("maxParticipants must be >= minParticipants");
+      }
+    }
+    checkPair(problems, "DidsPerParticipant", c2.minDidsPerParticipant, c2.maxDidsPerParticipant);
+    checkPair(problems, "SecondsBetweenAnnouncements", c2.minSecondsBetweenAnnouncements, c2.maxSecondsBetweenAnnouncements);
+    if (c2.pendingUpdateTrigger !== void 0 && (!Number.isInteger(c2.pendingUpdateTrigger) || c2.pendingUpdateTrigger < 1)) {
+      problems.push("pendingUpdateTrigger must be an integer >= 1");
+    }
+    checkCost(problems, "costOfEnrollment", c2.costOfEnrollment);
+    checkCost(problems, "costPerAnnouncement", c2.costPerAnnouncement);
+    return problems;
+  }
+
   // src/core/aggregation/messages/base.ts
   init_shim();
   var AGGREGATION_WIRE_VERSION = 1;
@@ -103614,8 +103757,14 @@ a=end-of-candidates
     signature;
     /** Current signing session phase. */
     phase;
-    /** Participant's secret nonce (held only by the participant during signing). */
-    secretNonce;
+    /**
+     * Participant's MuSig2 secret nonce, held only on the participant side
+     * between {@link generateNonceContribution} and {@link generatePartialSignature}.
+     * Private and cleared on every terminal path (success, failure, or teardown
+     * via {@link clearSecrets}) so a spent or abandoned nonce cannot be reused or
+     * serialized.
+     */
+    #secretNonce;
     constructor({ id, cohort, pendingTx, prevOutScripts, prevOutValues }) {
       this.id = id || crypto.randomUUID();
       this.cohort = cohort;
@@ -103767,22 +103916,24 @@ a=end-of-candidates
     generateNonceContribution(participantPublicKey, participantSecretKey) {
       const aggPublicKey = keyAggExport(keyAggregate(this.cohort.cohortKeys));
       const nonces = nonceGen(participantPublicKey, participantSecretKey, aggPublicKey);
-      this.secretNonce = nonces.secret;
+      this.#secretNonce = nonces.secret;
       return nonces.public;
     }
     /**
      * Generates a partial signature using the participant's secret key + secret nonce.
      * Requires the aggregated nonce to have been set first (via the service).
      *
-     * Zeros the stored `secretNonce` after use. JS cannot truly erase memory (GC
-     * and immutable strings), but overwriting the bytes shortens the exposure
-     * window and prevents accidental reuse or serialization of a spent nonce.
+     * Clears the stored secret nonce after use on every path (success or throw)
+     * via {@link clearSecrets}. JS cannot truly erase memory (GC may relocate
+     * buffers), but overwriting the bytes shortens the exposure window and
+     * prevents accidental reuse or serialization of a spent nonce - reuse of a
+     * MuSig2 nonce leaks the secret key.
      */
     generatePartialSignature(participantSecretKey) {
       if (!this.aggregatedNonce) {
         throw new SigningSessionError("Aggregated nonce not available.", "MISSING_AGGREGATED_NONCE");
       }
-      if (!this.secretNonce) {
+      if (!this.#secretNonce) {
         throw new SigningSessionError("Secret nonce not available \u2014 generateNonceContribution() must be called first.", "MISSING_SECRET_NONCE");
       }
       const session = new Session(
@@ -103792,10 +103943,23 @@ a=end-of-candidates
         [this.cohort.tapTweak],
         [true]
       );
-      const partialSig = session.sign(this.secretNonce, participantSecretKey);
-      this.secretNonce.fill(0);
-      this.secretNonce = void 0;
-      return partialSig;
+      try {
+        return session.sign(this.#secretNonce, participantSecretKey);
+      } finally {
+        this.clearSecrets();
+      }
+    }
+    /**
+     * Zeroize any retained secret nonce. Safe to call repeatedly and on any path
+     * (completion, failure, or teardown of an abandoned session). Callers that
+     * drop a session before it reaches a partial signature should invoke this so
+     * the secret nonce does not linger on the live object.
+     */
+    clearSecrets() {
+      if (this.#secretNonce) {
+        wipe(this.#secretNonce);
+        this.#secretNonce = void 0;
+      }
     }
     isComplete() {
       return this.phase === "Complete" /* Complete */;
@@ -103809,13 +103973,13 @@ a=end-of-candidates
   var DEFAULT_MAX_UPDATE_SIZE_BYTES = 256 * 1024;
   var AggregationService = class {
     did;
-    keys;
+    publicKey;
     maxUpdateSizeBytes;
     /** Per-cohort state, keyed by cohortId. */
     #cohortStates = /* @__PURE__ */ new Map();
-    constructor({ did, keys, maxUpdateSizeBytes }) {
+    constructor({ did, publicKey: publicKey2, maxUpdateSizeBytes }) {
       this.did = did;
-      this.keys = keys;
+      this.publicKey = publicKey2;
       this.maxUpdateSizeBytes = maxUpdateSizeBytes ?? DEFAULT_MAX_UPDATE_SIZE_BYTES;
     }
     receive(message2) {
@@ -103870,6 +104034,14 @@ a=end-of-candidates
      * Cohort starts in `Created` phase — call `advertise()` to broadcast.
      */
     createCohort(config) {
+      const problems = validateCohortConditions(config);
+      if (problems.length > 0) {
+        throw new AggregationServiceError(
+          `Invalid cohort conditions: ${problems.join("; ")}`,
+          "INVALID_COHORT_CONDITIONS",
+          { problems }
+        );
+      }
       const cohort = new AggregationCohort({
         serviceDid: this.did,
         minParticipants: config.minParticipants,
@@ -103902,13 +104074,13 @@ a=end-of-candidates
           { cohortId, phase: state.phase }
         );
       }
+      const { network, ...conditions } = state.config;
       const message2 = createCohortAdvertMessage({
         from: this.did,
         cohortId,
-        cohortSize: state.config.minParticipants,
-        beaconType: state.config.beaconType,
-        network: state.config.network,
-        communicationPk: this.keys.publicKey.compressed
+        network,
+        communicationPk: this.publicKey.compressed,
+        ...conditions
       });
       state.phase = "Advertised" /* Advertised */;
       return [message2];
@@ -103967,6 +104139,14 @@ a=end-of-candidates
           { cohortId, participantDid }
         );
       }
+      const maxParticipants = state.config.maxParticipants;
+      if (maxParticipants !== void 0 && state.acceptedParticipants.size >= maxParticipants) {
+        throw new AggregationServiceError(
+          `Cohort ${cohortId} is full: ${maxParticipants} participants already accepted.`,
+          "COHORT_FULL",
+          { cohortId, maxParticipants }
+        );
+      }
       state.acceptedParticipants.add(participantDid);
       state.cohort.participants.push(participantDid);
       state.cohort.participantKeys.set(participantDid, optIn.participantPk);
@@ -104000,6 +104180,14 @@ a=end-of-candidates
           { cohortId }
         );
       }
+      const maxParticipants = state.config.maxParticipants;
+      if (maxParticipants !== void 0 && state.acceptedParticipants.size > maxParticipants) {
+        throw new AggregationServiceError(
+          `Cohort ${cohortId} has ${state.acceptedParticipants.size} accepted participants, exceeds max ${maxParticipants}.`,
+          "TOO_MANY_PARTICIPANTS",
+          { cohortId, maxParticipants }
+        );
+      }
       const beaconAddress = state.cohort.computeBeaconAddress();
       state.phase = "CohortSet" /* CohortSet */;
       const messages2 = [];
@@ -104317,14 +104505,72 @@ a=end-of-candidates
   // src/core/aggregation/participant.ts
   init_shim();
   init_utils();
+
+  // src/core/aggregation/messages/bodies.ts
+  init_shim();
+  var hasStr = (b, k) => !!b && typeof b[k] === "string";
+  var hasIntMin = (b, k, min) => {
+    const v = b ? b[k] : void 0;
+    return typeof v === "number" && Number.isInteger(v) && v >= min;
+  };
+  var optIntMin = (b, k, min) => {
+    const v = b ? b[k] : void 0;
+    return v === void 0 || typeof v === "number" && Number.isInteger(v) && v >= min;
+  };
+  var hasBool = (b, k) => !!b && typeof b[k] === "boolean";
+  var hasBytes = (b, k) => !!b && b[k] instanceof Uint8Array;
+  var hasBytesArray = (b, k) => {
+    const v = b ? b[k] : void 0;
+    return Array.isArray(v) && v.every((x) => x instanceof Uint8Array);
+  };
+  function isCohortAdvertMessage(m2) {
+    return m2.type === COHORT_ADVERT && hasStr(m2.body, "cohortId") && hasIntMin(m2.body, "minParticipants", 1) && optIntMin(m2.body, "maxParticipants", 1) && hasStr(m2.body, "beaconType") && hasStr(m2.body, "network") && hasBytes(m2.body, "communicationPk");
+  }
+  function isCohortOptInMessage(m2) {
+    return m2.type === COHORT_OPT_IN && hasStr(m2.body, "cohortId") && hasBytes(m2.body, "participantPk") && hasBytes(m2.body, "communicationPk");
+  }
+  function isCohortOptInAcceptMessage(m2) {
+    return m2.type === COHORT_OPT_IN_ACCEPT && hasStr(m2.body, "cohortId");
+  }
+  function isCohortReadyMessage(m2) {
+    return m2.type === COHORT_READY && hasStr(m2.body, "cohortId") && hasStr(m2.body, "beaconAddress") && hasBytesArray(m2.body, "cohortKeys");
+  }
+  function isSubmitUpdateMessage(m2) {
+    return m2.type === SUBMIT_UPDATE && hasStr(m2.body, "cohortId") && !!m2.body && typeof m2.body.signedUpdate === "object";
+  }
+  function isDistributeAggregatedDataMessage(m2) {
+    return m2.type === DISTRIBUTE_AGGREGATED_DATA && hasStr(m2.body, "cohortId") && hasStr(m2.body, "beaconType") && hasStr(m2.body, "signalBytesHex");
+  }
+  function isValidationAckMessage(m2) {
+    return m2.type === VALIDATION_ACK && hasStr(m2.body, "cohortId") && hasBool(m2.body, "approved");
+  }
+  function isAuthorizationRequestMessage(m2) {
+    return m2.type === AUTHORIZATION_REQUEST && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasStr(m2.body, "pendingTx") && hasStr(m2.body, "prevOutScriptHex") && hasStr(m2.body, "prevOutValue");
+  }
+  function isNonceContributionMessage(m2) {
+    return m2.type === NONCE_CONTRIBUTION && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "nonceContribution");
+  }
+  function isAggregatedNonceMessage(m2) {
+    return m2.type === AGGREGATED_NONCE && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "aggregatedNonce");
+  }
+  function isSignatureAuthorizationMessage(m2) {
+    return m2.type === SIGNATURE_AUTHORIZATION && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "partialSignature");
+  }
+
+  // src/core/aggregation/participant.ts
   var AggregationParticipant = class {
     did;
-    keys;
+    /** MuSig2 signing capability. The raw secret never lives as a field here. */
+    #signer;
     /** Per-cohort state, keyed by cohortId. */
     #cohortStates = /* @__PURE__ */ new Map();
-    constructor({ did, keys }) {
+    constructor({ did, signer }) {
       this.did = did;
-      this.keys = keys;
+      this.#signer = signer;
+    }
+    /** The participant's compressed (33-byte) MuSig2 public key. Not secret. */
+    get publicKey() {
+      return this.#signer.publicKey;
     }
     /**
      * Process an incoming message. Updates internal state but never produces
@@ -104369,16 +104615,15 @@ a=end-of-candidates
       return map3;
     }
     #handleCohortAdvert(message2) {
-      const cohortId = message2.body?.cohortId;
-      if (!cohortId) return;
+      if (!isCohortAdvertMessage(message2)) return;
+      const { cohortId, network, communicationPk, ...conditions } = message2.body;
       if (this.#cohortStates.has(cohortId)) return;
       const advert = {
         cohortId,
         serviceDid: message2.from,
-        cohortSize: message2.body?.cohortSize ?? 0,
-        network: message2.body?.network ?? "",
-        beaconType: message2.body?.beaconType ?? "CASBeacon",
-        serviceCommunicationPk: message2.body?.communicationPk ?? new Uint8Array()
+        network,
+        serviceCommunicationPk: communicationPk,
+        ...conditions
       };
       this.#cohortStates.set(cohortId, {
         phase: "Discovered" /* Discovered */,
@@ -104403,7 +104648,7 @@ a=end-of-candidates
       const cohort = new AggregationCohort({
         id: cohortId,
         serviceDid: state.serviceDid,
-        minParticipants: state.advert.cohortSize,
+        minParticipants: state.advert.minParticipants,
         network: state.advert.network,
         beaconType: state.advert.beaconType
       });
@@ -104413,8 +104658,8 @@ a=end-of-candidates
         from: this.did,
         to: state.serviceDid,
         cohortId,
-        participantPk: this.keys.publicKey.compressed,
-        communicationPk: this.keys.publicKey.compressed
+        participantPk: this.publicKey,
+        communicationPk: this.publicKey
       });
       return [optInMessage];
     }
@@ -104444,7 +104689,7 @@ a=end-of-candidates
       const beaconAddress = message2.body?.beaconAddress;
       const cohortKeys = message2.body?.cohortKeys;
       if (!beaconAddress || !cohortKeys) return;
-      const participantPkHex = bytesToHex(this.keys.publicKey.compressed);
+      const participantPkHex = bytesToHex(this.publicKey);
       const cohortKeysHex = cohortKeys.map((k) => bytesToHex(new Uint8Array(k)));
       state.cohort.validateMembership(participantPkHex, cohortKeysHex, beaconAddress);
       state.phase = "CohortReady" /* CohortReady */;
@@ -104611,9 +104856,8 @@ a=end-of-candidates
         prevOutValues
       });
       state.signingSession = session;
-      const nonceContribution = session.generateNonceContribution(
-        this.keys.publicKey.compressed,
-        this.keys.secretKey.bytes
+      const nonceContribution = this.#signer.withSecret(
+        (secretKey) => session.generateNonceContribution(this.publicKey, secretKey)
       );
       state.phase = "NonceSent" /* NonceSent */;
       return [createNonceContributionMessage({
@@ -104656,7 +104900,10 @@ a=end-of-candidates
           { cohortId }
         );
       }
-      const partialSig = state.signingSession.generatePartialSignature(this.keys.secretKey.bytes);
+      const signingSession = state.signingSession;
+      const partialSig = this.#signer.withSecret(
+        (secretKey) => signingSession.generatePartialSignature(secretKey)
+      );
       state.phase = "Complete" /* Complete */;
       return [createSignatureAuthorizationMessage({
         from: this.did,
@@ -104669,6 +104916,37 @@ a=end-of-candidates
     getCohortPhase(cohortId) {
       return this.#cohortStates.get(cohortId)?.phase;
     }
+    /**
+     * Zeroize any retained MuSig2 secret nonces across all cohorts. The raw
+     * signing key is never held here (it lives behind the {@link AggregationSigner}
+     * and is wiped per-operation), but an abandoned signing session can still hold
+     * a secret nonce; call this on teardown to clear it deterministically.
+     */
+    clearSecrets() {
+      for (const state of this.#cohortStates.values()) {
+        state.signingSession?.clearSecrets();
+      }
+    }
+  };
+
+  // src/core/aggregation/signer.ts
+  init_shim();
+  var KeyPairAggregationSigner = class {
+    publicKey;
+    #keys;
+    /** @param {SchnorrKeyPair} keys The keypair whose secret backs this signer. */
+    constructor(keys) {
+      this.#keys = keys;
+      this.publicKey = keys.publicKey.compressed;
+    }
+    withSecret(fn) {
+      const secretKey = this.#keys.secretKey.bytes;
+      try {
+        return fn(secretKey);
+      } finally {
+        wipe(secretKey);
+      }
+    }
   };
 
   // src/core/aggregation/logger.ts
@@ -104693,50 +104971,6 @@ a=end-of-candidates
   // src/core/aggregation/messages/index.ts
   init_shim();
 
-  // src/core/aggregation/messages/bodies.ts
-  init_shim();
-  var hasStr = (b, k) => !!b && typeof b[k] === "string";
-  var hasNum = (b, k) => !!b && typeof b[k] === "number";
-  var hasBool = (b, k) => !!b && typeof b[k] === "boolean";
-  var hasBytes = (b, k) => !!b && b[k] instanceof Uint8Array;
-  var hasBytesArray = (b, k) => {
-    const v = b ? b[k] : void 0;
-    return Array.isArray(v) && v.every((x) => x instanceof Uint8Array);
-  };
-  function isCohortAdvertMessage(m2) {
-    return m2.type === COHORT_ADVERT && hasStr(m2.body, "cohortId") && hasNum(m2.body, "cohortSize") && hasStr(m2.body, "beaconType") && hasStr(m2.body, "network") && hasBytes(m2.body, "communicationPk");
-  }
-  function isCohortOptInMessage(m2) {
-    return m2.type === COHORT_OPT_IN && hasStr(m2.body, "cohortId") && hasBytes(m2.body, "participantPk") && hasBytes(m2.body, "communicationPk");
-  }
-  function isCohortOptInAcceptMessage(m2) {
-    return m2.type === COHORT_OPT_IN_ACCEPT && hasStr(m2.body, "cohortId");
-  }
-  function isCohortReadyMessage(m2) {
-    return m2.type === COHORT_READY && hasStr(m2.body, "cohortId") && hasStr(m2.body, "beaconAddress") && hasBytesArray(m2.body, "cohortKeys");
-  }
-  function isSubmitUpdateMessage(m2) {
-    return m2.type === SUBMIT_UPDATE && hasStr(m2.body, "cohortId") && !!m2.body && typeof m2.body.signedUpdate === "object";
-  }
-  function isDistributeAggregatedDataMessage(m2) {
-    return m2.type === DISTRIBUTE_AGGREGATED_DATA && hasStr(m2.body, "cohortId") && hasStr(m2.body, "beaconType") && hasStr(m2.body, "signalBytesHex");
-  }
-  function isValidationAckMessage(m2) {
-    return m2.type === VALIDATION_ACK && hasStr(m2.body, "cohortId") && hasBool(m2.body, "approved");
-  }
-  function isAuthorizationRequestMessage(m2) {
-    return m2.type === AUTHORIZATION_REQUEST && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasStr(m2.body, "pendingTx") && hasStr(m2.body, "prevOutScriptHex") && hasStr(m2.body, "prevOutValue");
-  }
-  function isNonceContributionMessage(m2) {
-    return m2.type === NONCE_CONTRIBUTION && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "nonceContribution");
-  }
-  function isAggregatedNonceMessage(m2) {
-    return m2.type === AGGREGATED_NONCE && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "aggregatedNonce");
-  }
-  function isSignatureAuthorizationMessage(m2) {
-    return m2.type === SIGNATURE_AUTHORIZATION && hasStr(m2.body, "cohortId") && hasStr(m2.body, "sessionId") && hasBytes(m2.body, "partialSignature");
-  }
-
   // src/core/aggregation/messages/guards.ts
   init_shim();
   var KEYGEN_VALUES = /* @__PURE__ */ new Set([
@@ -105425,7 +105659,7 @@ ${value2}`;
         body: JSON.stringify(envelope)
       });
       if (!res.ok) {
-        const body = await safeText(res);
+        const body = await safeText2(res);
         throw new HttpTransportError(
           `sendMessage failed: HTTP ${res.status}`,
           "SEND_MESSAGE_HTTP",
@@ -105602,7 +105836,7 @@ ${value2}`;
       else signal.addEventListener("abort", onAbort, { once: true });
     });
   }
-  async function safeText(res) {
+  async function safeText2(res) {
     try {
       return await res.text();
     } catch {
@@ -111181,10 +111415,10 @@ ${value2}`;
     start() {
     }
     registerActor(did, keys) {
-      this.#actors.set(did, { keys, handlers: /* @__PURE__ */ new Map() });
+      this.#actors.set(did, { publicKey: keys.publicKey.compressed, handlers: /* @__PURE__ */ new Map() });
     }
     getActorPk(did) {
-      return this.#actors.get(did)?.keys.publicKey.compressed;
+      return this.#actors.get(did)?.publicKey;
     }
     /** True if `did` is registered on this transport. Used by the bus for routing. */
     hasActor(did) {
@@ -111407,8 +111641,11 @@ ${value2}`;
       this.#phaseTimeoutMs = options2.phaseTimeoutMs;
       this.#advertRepeatIntervalMs = options2.advertRepeatIntervalMs ?? DEFAULT_ADVERT_REPEAT_INTERVAL_MS;
       this.session = new AggregationService({
+        // The coordinator never signs, so the state machine receives only the
+        // public half of the operator's keypair (see ADR 038). The full keypair
+        // remains the operator's transport/communication identity.
         did: options2.did,
-        keys: options2.keys,
+        publicKey: options2.keys.publicKey,
         maxUpdateSizeBytes: options2.maxUpdateSizeBytes
       });
     }
@@ -111579,6 +111816,11 @@ ${value2}`;
         }
         const decision = await this.#onOptInReceived(optIn);
         if (!decision.accepted) return;
+        const maxParticipants = this.#config.maxParticipants;
+        const cohortNow = this.session.getCohort(this.#cohortId);
+        if (maxParticipants !== void 0 && cohortNow && cohortNow.participants.length >= maxParticipants) {
+          return;
+        }
         await this.#sendAll(this.session.acceptParticipant(this.#cohortId, msg.from));
         this.emit("participant-accepted", { participantDid: msg.from });
         const cohort = this.session.getCohort(this.#cohortId);
@@ -111761,7 +112003,10 @@ ${value2}`;
       this.#onProvideUpdate = options2.onProvideUpdate;
       this.#onValidateData = options2.onValidateData ?? (async (info) => ({ approved: info.matches }));
       this.#onApproveSigning = options2.onApproveSigning ?? (async () => ({ approved: true }));
-      this.session = new AggregationParticipant({ did: options2.did, keys: options2.keys });
+      this.session = new AggregationParticipant({
+        did: options2.did,
+        signer: new KeyPairAggregationSigner(options2.keys)
+      });
     }
     /**
      * Start listening for cohorts. The runner stays active until {@link stop}
@@ -111774,6 +112019,7 @@ ${value2}`;
     stop() {
       this.#stopped = true;
       this.#unregisterHandlers();
+      this.session.clearSecrets();
     }
     /** Message types this runner listens for on the transport. */
     static #HANDLED_MESSAGE_TYPES = [
@@ -112615,84 +112861,6 @@ ${value2}`;
   // src/core/beacon/signal-discovery.ts
   init_shim();
 
-  // ../bitcoin/dist/esm/index.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/connection.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rest/index.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rest/address.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rest/block.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/errors.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rest/transaction.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rest/protocol.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/http.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rpc/index.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rpc/json-rpc.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/utils.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/client/rpc/protocol.js
-  init_shim();
-
-  // ../bitcoin/dist/esm/network.js
-  init_shim();
-  var REGTEST_NETWORK = {
-    bech32: "bcrt",
-    pubKeyHash: 111,
-    scriptHash: 196,
-    wif: 239
-  };
-  function getNetwork(network) {
-    switch (network) {
-      case "bitcoin":
-        return NETWORK;
-      case "testnet3":
-      case "testnet4":
-      case "signet":
-      case "mutinynet":
-        return TEST_NETWORK;
-      case "regtest":
-        return REGTEST_NETWORK;
-      default:
-        throw new Error(`Unknown network "${network}"`);
-    }
-  }
-
-  // ../bitcoin/dist/esm/constants.js
-  init_shim();
-  var TXIN_WITNESS_COINBASE = "0000000000000000000000000000000000000000000000000000000000000000";
-  var GENESIS_TX_ID = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
-
-  // ../bitcoin/dist/esm/types.js
-  init_shim();
-  var VerbosityLevel;
-  (function(VerbosityLevel2) {
-    VerbosityLevel2[VerbosityLevel2["hex"] = 0] = "hex";
-    VerbosityLevel2[VerbosityLevel2["json"] = 1] = "json";
-    VerbosityLevel2[VerbosityLevel2["jsonext"] = 2] = "jsonext";
-    VerbosityLevel2[VerbosityLevel2["jsonextprev"] = 3] = "jsonextprev";
-  })(VerbosityLevel || (VerbosityLevel = {}));
-
   // src/core/beacon/utils.ts
   init_shim();