@did-btcr2/method 0.33.0 → 0.35.0

package/dist/browser.js

@@ -93157,6 +93157,7 @@ a=end-of-candidates
     AggregationParticipant: () => AggregationParticipant,
     AggregationParticipantError: () => AggregationParticipantError,
     AggregationParticipantRunner: () => AggregationParticipantRunner,
+    AggregationRunner: () => AggregationRunner,
     AggregationService: () => AggregationService,
     AggregationServiceError: () => AggregationServiceError,
     AggregationServiceRunner: () => AggregationServiceRunner,
@@ -93164,7 +93165,6 @@ a=end-of-candidates
     BECH32M_CHARS: () => BECH32M_CHARS,
     BTCR2_DID_DOCUMENT_CONTEXT: () => BTCR2_DID_DOCUMENT_CONTEXT,
     BaseMessage: () => BaseMessage,
-    Beacon: () => Beacon,
     BeaconError: () => BeaconError,
     BeaconFactory: () => BeaconFactory,
     BeaconSignalDiscovery: () => BeaconSignalDiscovery,
@@ -93199,8 +93199,11 @@ a=end-of-candidates
     HttpTransportError: () => HttpTransportError,
     ID_PLACEHOLDER_VALUE: () => ID_PLACEHOLDER_VALUE,
     Identifier: () => Identifier,
+    InMemoryBus: () => InMemoryBus,
     InMemoryRateLimitStore: () => InMemoryRateLimitStore,
+    InMemoryTransport: () => InMemoryTransport,
     InboxBuffer: () => InboxBuffer,
+    KeyPairAggregationSigner: () => KeyPairAggregationSigner,
     NONCE_CONTRIBUTION: () => NONCE_CONTRIBUTION,
     NonceCache: () => NonceCache,
     NostrTransport: () => NostrTransport,
@@ -93221,6 +93224,7 @@ a=end-of-candidates
     ServiceCohortPhase: () => ServiceCohortPhase,
     SigningSessionError: () => SigningSessionError,
     SigningSessionPhase: () => SigningSessionPhase,
+    SinglePartyBeacon: () => SinglePartyBeacon,
     SingletonBeacon: () => SingletonBeacon,
     SingletonBeaconError: () => SingletonBeaconError,
     StaticFeeEstimator: () => StaticFeeEstimator,
@@ -100114,6 +100118,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();
@@ -100700,8 +100711,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();
@@ -102900,6 +102951,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();
@@ -103314,7 +103407,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(
@@ -103611,8 +103704,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;
@@ -103764,22 +103863,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(
@@ -103789,10 +103890,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 */;
@@ -103806,13 +103920,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) {
@@ -103905,7 +104019,7 @@ a=end-of-candidates
         cohortSize: state.config.minParticipants,
         beaconType: state.config.beaconType,
         network: state.config.network,
-        communicationPk: this.keys.publicKey.compressed
+        communicationPk: this.publicKey.compressed
       });
       state.phase = "Advertised" /* Advertised */;
       return [message2];
@@ -104316,12 +104430,17 @@ a=end-of-candidates
   init_utils();
   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
@@ -104410,8 +104529,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];
     }
@@ -104441,7 +104560,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 */;
@@ -104608,9 +104727,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({
@@ -104653,7 +104771,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,
@@ -104666,6 +104787,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
@@ -105422,7 +105574,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",
@@ -105599,7 +105751,7 @@ ${value2}`;
       else signal.addEventListener("abort", onAbort, { once: true });
     });
   }
-  async function safeText(res) {
+  async function safeText2(res) {
     try {
       return await res.text();
     } catch {
@@ -111126,6 +111278,120 @@ ${value2}`;
     }
   };
 
+  // src/core/aggregation/transport/in-memory.ts
+  init_shim();
+  init_utils();
+  var InMemoryBus = class {
+    #transports = /* @__PURE__ */ new Set();
+    /** Attach a transport to this bus. Called by the transport's constructor. */
+    register(transport) {
+      this.#transports.add(transport);
+    }
+    /** Detach a transport from this bus. */
+    unregister(transport) {
+      this.#transports.delete(transport);
+    }
+    /**
+     * Deliver a message. With no `recipient` the message is broadcast to every
+     * actor on the bus; otherwise it is routed to the single transport that owns
+     * the recipient DID.
+     */
+    async deliver(message2, _sender, recipient) {
+      const type = message2.type;
+      if (!type) return;
+      const replacer = (_k, v) => v instanceof Uint8Array ? { __bytes: bytesToHex(v) } : v;
+      const reviver = (_k, v) => v && typeof v === "object" && "__bytes" in v ? hexToBytes(v.__bytes) : v;
+      const raw = JSON.parse(JSON.stringify(message2, replacer), reviver);
+      const serialized = { ...raw, ...raw.body ?? {} };
+      if (!recipient) {
+        for (const t2 of this.#transports) {
+          await t2.dispatchBroadcast(type, serialized);
+        }
+        return;
+      }
+      for (const t2 of this.#transports) {
+        if (t2.hasActor(recipient)) {
+          await t2.dispatchDirected(recipient, type, serialized);
+          return;
+        }
+      }
+    }
+  };
+  var InMemoryTransport = class {
+    name = "in-memory";
+    bus;
+    #actors = /* @__PURE__ */ new Map();
+    #peers = /* @__PURE__ */ new Map();
+    /** @param bus Shared bus. Pass the same bus to connect multiple transports. */
+    constructor(bus = new InMemoryBus()) {
+      this.bus = bus;
+      this.bus.register(this);
+    }
+    start() {
+    }
+    registerActor(did, keys) {
+      this.#actors.set(did, { publicKey: keys.publicKey.compressed, handlers: /* @__PURE__ */ new Map() });
+    }
+    getActorPk(did) {
+      return this.#actors.get(did)?.publicKey;
+    }
+    /** True if `did` is registered on this transport. Used by the bus for routing. */
+    hasActor(did) {
+      return this.#actors.has(did);
+    }
+    registerPeer(did, communicationPk) {
+      this.#peers.set(did, communicationPk);
+    }
+    getPeerPk(did) {
+      return this.#peers.get(did);
+    }
+    registerMessageHandler(actorDid, messageType, handler) {
+      const actor = this.#actors.get(actorDid);
+      if (actor) actor.handlers.set(messageType, handler);
+    }
+    unregisterMessageHandler(actorDid, messageType) {
+      const actor = this.#actors.get(actorDid);
+      if (actor) actor.handlers.delete(messageType);
+    }
+    unregisterActor(did) {
+      const actor = this.#actors.get(did);
+      if (!actor) return;
+      actor.handlers.clear();
+      this.#actors.delete(did);
+      this.#peers.delete(did);
+    }
+    async sendMessage(message2, sender, recipient) {
+      await this.bus.deliver(message2, sender, recipient);
+    }
+    publishRepeating(message2, sender, intervalMs, recipient) {
+      let stopped = false;
+      void this.sendMessage(message2, sender, recipient).catch(() => {
+      });
+      const timer = setInterval(() => {
+        if (stopped) return;
+        void this.sendMessage(message2, sender, recipient).catch(() => {
+        });
+      }, intervalMs);
+      return () => {
+        if (stopped) return;
+        stopped = true;
+        clearInterval(timer);
+      };
+    }
+    /** Deliver a broadcast message to every actor on this transport that handles `type`. */
+    async dispatchBroadcast(type, message2) {
+      for (const actor of this.#actors.values()) {
+        const handler = actor.handlers.get(type);
+        if (handler) await handler(message2);
+      }
+    }
+    /** Deliver a directed message to the recipient actor's handler for `type`. */
+    async dispatchDirected(recipientDid, type, message2) {
+      const handler = this.#actors.get(recipientDid)?.handlers.get(type);
+      if (handler) await handler(message2);
+    }
+  };
+
   // src/core/aggregation/transport/didcomm.ts
   init_shim();
   var DidCommTransport = class {
@@ -111290,8 +111556,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
       });
     }
@@ -111644,7 +111913,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}
@@ -111657,6 +111929,7 @@ ${value2}`;
     stop() {
       this.#stopped = true;
       this.#unregisterHandlers();
+      this.session.clearSecrets();
     }
     /** Message types this runner listens for on the transport. */
     static #HANDLED_MESSAGE_TYPES = [
@@ -111866,6 +112139,63 @@ ${value2}`;
     }
   };
 
+  // src/core/aggregation/runner/aggregation-runner.ts
+  init_shim();
+  var AggregationRunner = class {
+    /**
+     * Run a cohort of ONE participant entirely in-process and return the
+     * aggregated MuSig2 result.
+     *
+     * One party plays both the coordinating service and the lone participant,
+     * connected over an {@link InMemoryTransport} (no relay or HTTP server). This
+     * makes the single-participant aggregate-beacon path — the N=1 corner of the
+     * two-axis beacon matrix (see ADR 037) — first-class, useful for generating
+     * and reproducing single-participant aggregate test vectors.
+     *
+     * The service advertises a cohort with `minParticipants: 1`; the participant
+     * joins, submits its update, and the two complete keygen, data distribution,
+     * validation, and a one-signer MuSig2 P2TR key-path signing round.
+     *
+     * @param options Service + participant identities, cohort config, and the
+     *   update / tx-data callbacks.
+     * @returns The {@link AggregationResult} (cohort id, aggregated signature, signed tx).
+     */
+    static async solo(options2) {
+      const transport = new InMemoryTransport(new InMemoryBus());
+      transport.registerActor(options2.service.did, options2.service.keys);
+      transport.registerActor(options2.participant.did, options2.participant.keys);
+      transport.registerPeer(options2.participant.did, options2.participant.keys.publicKey.compressed);
+      transport.registerPeer(options2.service.did, options2.service.keys.publicKey.compressed);
+      transport.start();
+      const service = new AggregationServiceRunner({
+        transport,
+        did: options2.service.did,
+        keys: options2.service.keys,
+        config: { minParticipants: 1, network: options2.config.network, beaconType: options2.config.beaconType },
+        onProvideTxData: options2.onProvideTxData,
+        cohortTtlMs: options2.cohortTtlMs,
+        phaseTimeoutMs: options2.phaseTimeoutMs,
+        // In-process bus with the participant already listening: a single advert
+        // suffices, so disable the republish loop (no dangling interval).
+        advertRepeatIntervalMs: 0
+      });
+      const participant = new AggregationParticipantRunner({
+        transport,
+        did: options2.participant.did,
+        keys: options2.participant.keys,
+        shouldJoin: async () => true,
+        onProvideUpdate: options2.onProvideUpdate
+      });
+      await participant.start();
+      try {
+        return await service.run();
+      } finally {
+        participant.stop();
+        service.stop();
+      }
+    }
+  };
+
   // src/core/beacon/beacon.ts
   init_shim();
   init_utils();
@@ -112036,7 +112366,7 @@ ${value2}`;
     tx.finalize();
     return tx.hex;
   }
-  var Beacon = class {
+  var SinglePartyBeacon = class {
     /**
      * The Beacon service configuration parsed from the DID Document.
      */
@@ -112173,7 +112503,7 @@ ${value2}`;
 
   // src/core/beacon/cas-beacon.ts
   init_shim();
-  var CASBeacon = class extends Beacon {
+  var CASBeacon = class extends SinglePartyBeacon {
     /**
      * Creates an instance of CASBeacon.
      * @param {BeaconService} service The service of the Beacon.
@@ -112233,7 +112563,7 @@ ${value2}`;
      * Creates a CAS Announcement mapping the DID to the update hash, broadcasts the hash of the
      * announcement via OP_RETURN, and optionally publishes the announcement off-chain via the
      * supplied `casPublish` callback. UTXO selection, PSBT construction, fee estimation, signing,
-     * and broadcast are delegated to {@link Beacon.buildSignAndBroadcast}.
+     * and broadcast are delegated to {@link SinglePartyBeacon.buildSignAndBroadcast}.
      *
      * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
      * @param {Signer} signer Signer that produces the ECDSA signature for the Bitcoin transaction.
@@ -112261,7 +112591,7 @@ ${value2}`;
 
   // src/core/beacon/singleton-beacon.ts
   init_shim();
-  var SingletonBeacon = class extends Beacon {
+  var SingletonBeacon = class extends SinglePartyBeacon {
     /**
      * Creates an instance of SingletonBeacon.
      * @param {BeaconService} service The BeaconService object representing the funded beacon to announce the update to.
@@ -112298,7 +112628,7 @@ ${value2}`;
      *
      * The signal bytes embedded in OP_RETURN are the SHA-256 canonical hash of the signed update.
      * UTXO selection, PSBT construction, fee estimation, signing, and broadcast are delegated to
-     * {@link Beacon.buildSignAndBroadcast}.
+     * {@link SinglePartyBeacon.buildSignAndBroadcast}.
      *
      * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
      * @param {Signer} signer Signer that produces the ECDSA signature for the Bitcoin transaction.
@@ -112317,7 +112647,7 @@ ${value2}`;
   // src/core/beacon/smt-beacon.ts
   init_shim();
   init_utils();
-  var SMTBeacon = class extends Beacon {
+  var SMTBeacon = class extends SinglePartyBeacon {
     /**
      * Creates an instance of SMTBeacon.
      * @param {BeaconService} service The Beacon service.
@@ -112393,7 +112723,7 @@ ${value2}`;
      * Builds a single-entry Sparse Merkle Tree from the signed update, then broadcasts the tree's
      * root hash via OP_RETURN. For multi-party aggregation, use the {@link AggregationService}
      * subsystem directly instead of this method. UTXO selection, PSBT construction, fee estimation,
-     * signing, and broadcast are delegated to {@link Beacon.buildSignAndBroadcast}.
+     * signing, and broadcast are delegated to {@link SinglePartyBeacon.buildSignAndBroadcast}.
      *
      * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
      * @param {Signer} signer Signer that produces the ECDSA signature for the Bitcoin transaction.
@@ -112419,7 +112749,7 @@ ${value2}`;
     /**
      * Establish a Beacon instance based on the provided service and optional sidecar data.
      * @param {BeaconService} service The beacon service configuration.
-     * @returns {Beacon} The established Beacon instance.
+     * @returns {SinglePartyBeacon} The established Beacon instance.
      */
     static establish(service) {
       switch (service.type) {
@@ -112441,84 +112771,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();