@did-btcr2/method 0.33.0 → 0.34.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,7 +93199,9 @@ a=end-of-candidates
     HttpTransportError: () => HttpTransportError,
     ID_PLACEHOLDER_VALUE: () => ID_PLACEHOLDER_VALUE,
     Identifier: () => Identifier,
+    InMemoryBus: () => InMemoryBus,
     InMemoryRateLimitStore: () => InMemoryRateLimitStore,
+    InMemoryTransport: () => InMemoryTransport,
     InboxBuffer: () => InboxBuffer,
     NONCE_CONTRIBUTION: () => NONCE_CONTRIBUTION,
     NonceCache: () => NonceCache,
@@ -93221,6 +93223,7 @@ a=end-of-candidates
     ServiceCohortPhase: () => ServiceCohortPhase,
     SigningSessionError: () => SigningSessionError,
     SigningSessionPhase: () => SigningSessionPhase,
+    SinglePartyBeacon: () => SinglePartyBeacon,
     SingletonBeacon: () => SingletonBeacon,
     SingletonBeaconError: () => SingletonBeaconError,
     StaticFeeEstimator: () => StaticFeeEstimator,
@@ -111126,6 +111129,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, { keys, handlers: /* @__PURE__ */ new Map() });
+    }
+    getActorPk(did) {
+      return this.#actors.get(did)?.keys.publicKey.compressed;
+    }
+    /** 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 {
@@ -111866,6 +111983,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 +112210,7 @@ ${value2}`;
     tx.finalize();
     return tx.hex;
   }
-  var Beacon = class {
+  var SinglePartyBeacon = class {
     /**
      * The Beacon service configuration parsed from the DID Document.
      */
@@ -112173,7 +112347,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 +112407,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 +112435,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 +112472,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 +112491,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 +112567,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 +112593,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) {

package/dist/browser.mjs

@@ -110994,6 +110994,120 @@ var TransportFactory = class {
   }
 };
 
+// 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, { keys, handlers: /* @__PURE__ */ new Map() });
+  }
+  getActorPk(did) {
+    return this.#actors.get(did)?.keys.publicKey.compressed;
+  }
+  /** 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 {
@@ -111734,6 +111848,63 @@ var AggregationParticipantRunner = class _AggregationParticipantRunner extends T
   }
 };
 
+// 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();
@@ -111904,7 +112075,7 @@ async function signSingletonInput(tx, inputIdx, kind, signer, prevOutScript, amo
   tx.finalize();
   return tx.hex;
 }
-var Beacon = class {
+var SinglePartyBeacon = class {
   /**
    * The Beacon service configuration parsed from the DID Document.
    */
@@ -112041,7 +112212,7 @@ var Beacon = class {
 
 // 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.
@@ -112101,7 +112272,7 @@ var CASBeacon = class extends Beacon {
    * 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.
@@ -112129,7 +112300,7 @@ init_shim();
 
 // 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.
@@ -112166,7 +112337,7 @@ var SingletonBeacon = class extends Beacon {
    *
    * 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.
@@ -112185,7 +112356,7 @@ var SingletonBeacon = class extends Beacon {
 // 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.
@@ -112261,7 +112432,7 @@ var SMTBeacon = class extends Beacon {
    * 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.
@@ -112287,7 +112458,7 @@ var BeaconFactory = class {
   /**
    * 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) {
@@ -128807,6 +128978,7 @@ export {
   AggregationParticipant,
   AggregationParticipantError,
   AggregationParticipantRunner,
+  AggregationRunner,
   AggregationService,
   AggregationServiceError,
   AggregationServiceRunner,
@@ -128814,7 +128986,6 @@ export {
   BECH32M_CHARS,
   BTCR2_DID_DOCUMENT_CONTEXT,
   BaseMessage,
-  Beacon,
   BeaconError,
   BeaconFactory,
   BeaconSignalDiscovery,
@@ -128849,7 +129020,9 @@ export {
   HttpTransportError,
   ID_PLACEHOLDER_VALUE,
   Identifier,
+  InMemoryBus,
   InMemoryRateLimitStore,
+  InMemoryTransport,
   InboxBuffer,
   NONCE_CONTRIBUTION,
   NonceCache,
@@ -128871,6 +129044,7 @@ export {
   ServiceCohortPhase,
   SigningSessionError,
   SigningSessionPhase,
+  SinglePartyBeacon,
   SingletonBeacon,
   SingletonBeaconError,
   StaticFeeEstimator,