@did-btcr2/method 0.34.0 → 0.36.0

package/dist/browser.mjs

@@ -99982,6 +99982,13 @@ function compareBytes(a2, b) {
 // ../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();
@@ -100568,8 +100575,48 @@ function getBeaconStrategy(type) {
 
 // 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();
@@ -102768,6 +102815,48 @@ var Transaction = class _Transaction {
   }
 };
 
+// ../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();
@@ -103156,7 +103245,7 @@ var AggregationCohort = class {
   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";
@@ -103182,7 +103271,7 @@ var AggregationCohort = class {
     }
     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(
@@ -103322,6 +103411,57 @@ var AggregationCohort = class {
   }
 };
 
+// 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;
@@ -103479,8 +103619,14 @@ var BeaconSigningSession = class {
   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;
@@ -103632,22 +103778,24 @@ var BeaconSigningSession = class {
   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(
@@ -103657,10 +103805,23 @@ var BeaconSigningSession = class {
       [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 */;
@@ -103674,13 +103835,13 @@ var BeaconSigningSession = class {
 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) {
@@ -103735,6 +103896,14 @@ var AggregationService = class {
    * 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,
@@ -103767,13 +103936,13 @@ var AggregationService = class {
         { 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];
@@ -103832,6 +104001,14 @@ var AggregationService = class {
         { 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);
@@ -103865,6 +104042,14 @@ var AggregationService = class {
         { 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 = [];
@@ -104182,14 +104367,72 @@ var AggregationService = class {
 // 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
@@ -104234,16 +104477,15 @@ var AggregationParticipant = class {
     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 */,
@@ -104268,7 +104510,7 @@ var AggregationParticipant = class {
     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
     });
@@ -104278,8 +104520,8 @@ var AggregationParticipant = class {
       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];
   }
@@ -104309,7 +104551,7 @@ var AggregationParticipant = class {
     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 */;
@@ -104476,9 +104718,8 @@ var AggregationParticipant = class {
       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({
@@ -104521,7 +104762,10 @@ var AggregationParticipant = class {
         { 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,
@@ -104534,6 +104778,37 @@ var AggregationParticipant = class {
   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
@@ -104558,50 +104833,6 @@ var SILENT_LOGGER = {
 // 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([
@@ -105290,7 +105521,7 @@ var HttpClientTransport = class {
       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",
@@ -105467,7 +105698,7 @@ function sleep(ms2, signal) {
     else signal.addEventListener("abort", onAbort, { once: true });
   });
 }
-async function safeText(res) {
+async function safeText2(res) {
   try {
     return await res.text();
   } catch {
@@ -111046,10 +111277,10 @@ var InMemoryTransport = class {
   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) {
@@ -111272,8 +111503,11 @@ var AggregationServiceRunner = class _AggregationServiceRunner extends TypedEven
     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
     });
   }
@@ -111444,6 +111678,11 @@ var AggregationServiceRunner = class _AggregationServiceRunner extends TypedEven
       }
       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);
@@ -111626,7 +111865,10 @@ var AggregationParticipantRunner = class _AggregationParticipantRunner extends T
     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}
@@ -111639,6 +111881,7 @@ var AggregationParticipantRunner = class _AggregationParticipantRunner extends T
   stop() {
     this.#stopped = true;
     this.#unregisterHandlers();
+    this.session.clearSecrets();
   }
   /** Message types this runner listens for on the transport. */
   static #HANDLED_MESSAGE_TYPES = [
@@ -112480,84 +112723,6 @@ init_shim();
 // 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();
 
@@ -129024,6 +129189,8 @@ export {
   InMemoryRateLimitStore,
   InMemoryTransport,
   InboxBuffer,
+  KNOWN_BEACON_TYPES,
+  KeyPairAggregationSigner,
   NONCE_CONTRIBUTION,
   NonceCache,
   NostrTransport,
@@ -129095,6 +129262,7 @@ export {
   registerBeaconStrategy,
   reviveFromWire,
   signEnvelope,
+  validateCohortConditions,
   verifyEnvelope,
   verifyRequestAuth
 };