@did-btcr2/method 0.13.1

package/dist/types/btcr2/beacon/aggregation/messages/base.d.ts

@@ -0,0 +1,36 @@
+import { Maybe } from '@did-btcr2/common';
+export declare const MESSAGE_PREFIX = "https://btcr2.tools/";
+export type BaseBody = {
+    cohortId: string;
+    cohortSize?: number;
+    network?: string;
+    participantPk?: Uint8Array;
+    beaconAddress?: string;
+    cohortKeys?: Array<Uint8Array>;
+};
+export type Base = {
+    type: string;
+    to: string;
+    from: string;
+    threadId?: string;
+    body: BaseBody;
+};
+export declare class BaseMessage {
+    type: string;
+    to: string;
+    from: string;
+    threadId?: string;
+    body: BaseBody;
+    constructor({ type, to, from, threadId, body }: Base);
+    /**
+     * Creates a BaseMessage from a JSON object.
+     * @param {Maybe<Base>} data - The JSON object to initialize the BaseMessage.
+     * @returns {BaseMessage} The initialized BaseMessage.
+     */
+    static fromJSON(data: Maybe<Base>): BaseMessage;
+    /**
+     * Converts a BaseMessage to a JSON object.
+     * @returns {Base} The JSON representation of the BaseMessage.
+     */
+    json(): Base;
+}

package/dist/types/btcr2/beacon/aggregation/messages/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/messages/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,eAAO,MAAM,cAAc,yBAAyB,CAAC;AAErD,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF,qBAAa,WAAW;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;gBAEV,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI;IAQpD;;;;OAIG;WACW,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,WAAW;IAItD;;;OAGG;IACI,IAAI,IAAI,IAAI;CASpB"}

package/dist/types/btcr2/beacon/aggregation/messages/cohort-set.d.ts

@@ -0,0 +1,23 @@
+import { BaseMessage } from './base.js';
+import { COHORT_SET } from './keygen.js';
+export type CohortSet = {
+    type?: typeof COHORT_SET;
+    to: string;
+    from: string;
+    cohortId: string;
+    beaconAddress: string;
+    cohortKeys: Array<Uint8Array>;
+    threadId?: string;
+};
+export declare class CohortSetMessage extends BaseMessage {
+    cohortId: string;
+    beaconAddress: string;
+    cohortKeys: Array<Uint8Array>;
+    constructor({ type, to, from, threadId, cohortId, beaconAddress, cohortKeys }: CohortSet);
+    /**
+     * Initializes an CohortSetMessage from a given OptIn object.
+     * @param {OptIn} data - The OptIn object to initialize the CohortSetMessage.
+     * @returns {object} The serialized CohortSetMessage.
+     */
+    static fromJSON(data: CohortSet): CohortSetMessage;
+}

package/dist/types/btcr2/beacon/aggregation/messages/cohort-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cohort-set.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/messages/cohort-set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,CAAC,EAAE,OAAO,UAAU,CAAC;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,qBAAa,gBAAiB,SAAQ,WAAW;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;gBAEzB,EAAE,IAAiB,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,EAAE,SAAS;IAOrG;;;;OAIG;WACW,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,gBAAgB;CAM1D"}

package/dist/types/btcr2/beacon/aggregation/messages/keygen.d.ts

@@ -0,0 +1,6 @@
+export declare const COHORT_ADVERT = "https://btcr2.tools/musig2/keygen/cohort_advert";
+export declare const COHORT_INVITE = "https://btcr2.tools/musig2/keygen/cohort_invite";
+export declare const OPT_IN = "https://btcr2.tools/musig2/keygen/opt_in";
+export declare const COHORT_SET = "https://btcr2.tools/musig2/keygen/cohort_set";
+export declare const SUBSCRIBE = "https://btcr2.tools/musig2/keygen/subscribe";
+export declare const SUBSCRIBE_ACCEPT = "https://btcr2.tools/musig2/keygen/subscribe_accept";

package/dist/types/btcr2/beacon/aggregation/messages/keygen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keygen.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/messages/keygen.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,oDAAiD,CAAC;AAC5E,eAAO,MAAM,aAAa,oDAAiD,CAAC;AAC5E,eAAO,MAAM,MAAM,6CAA0C,CAAC;AAC9D,eAAO,MAAM,UAAU,iDAA8C,CAAC;AACtE,eAAO,MAAM,SAAS,gDAA6C,CAAC;AACpE,eAAO,MAAM,gBAAgB,uDAAoD,CAAC"}

package/dist/types/btcr2/beacon/aggregation/messages/opt-in.d.ts

@@ -0,0 +1,22 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from './base.js';
+import { OPT_IN } from './keygen.js';
+export type OptIn = {
+    type: typeof OPT_IN;
+    to: string;
+    from: string;
+    cohortId: string;
+    participantPk: Uint8Array;
+    threadId?: string;
+};
+export declare class OptInMessage extends BaseMessage {
+    cohortId: string;
+    participantPk: Uint8Array;
+    constructor({ type, to, from, threadId, cohortId, participantPk }: OptIn);
+    /**
+     * Initializes an OptInMessage from a given OptIn object.
+     * @param {OptIn} data - The OptIn object to initialize the OptInMessage.
+     * @returns {object} The serialized OptInMessage.
+     */
+    static fromJSON(data: Maybe<OptIn>): OptInMessage;
+}

package/dist/types/btcr2/beacon/aggregation/messages/opt-in.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opt-in.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/messages/opt-in.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,OAAO,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,qBAAa,YAAa,SAAQ,WAAW;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,UAAU,CAAC;gBAErB,EAAE,IAAa,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,KAAK;IAMjF;;;;OAIG;WACW,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,YAAY;CAMzD"}

package/dist/types/btcr2/beacon/aggregation/messages/sign.d.ts

@@ -0,0 +1,5 @@
+export declare const REQUEST_SIGNATURE = "https://btcr2.tools/musig2/sign/request_signature";
+export declare const AUTHORIZATION_REQUEST = "https://btcr2.tools/musig2/sign/authorization_request";
+export declare const NONCE_CONTRIBUTION = "https://btcr2.tools/musig2/sign/nonce_contribution";
+export declare const AGGREGATED_NONCE = "https://btcr2.tools/musig2/sign/aggregated_nonce";
+export declare const SIGNATURE_AUTHORIZATION = "https://btcr2.tools/musig2/sign/signature_authorization";

package/dist/types/btcr2/beacon/aggregation/messages/sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/messages/sign.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,sDAAmD,CAAC;AAClF,eAAO,MAAM,qBAAqB,0DAAuD,CAAC;AAC1F,eAAO,MAAM,kBAAkB,uDAAoD,CAAC;AACpF,eAAO,MAAM,gBAAgB,qDAAkD,CAAC;AAChF,eAAO,MAAM,uBAAuB,4DAAyD,CAAC"}

package/dist/types/btcr2/beacon/aggregation/models/cohort/index.d.ts

@@ -0,0 +1,77 @@
+import { COHORT_STATUS_TYPE } from './status.js';
+export type Musig2CohortParams = {
+    id?: string;
+    minParticipants: number;
+    status: COHORT_STATUS_TYPE;
+    network: string;
+    coordinatorDid: string;
+};
+export declare class Musig2Cohort {
+    /**
+     * Unique identifier for the cohort.
+     * @type {string}
+     */
+    id: string;
+    /**
+     * DID of the coordinator.
+     * @type {string}
+     */
+    coordinatorDid: string;
+    /**
+     * Minimum number of participants required to finalize the cohort.
+     * @type {number}
+     */
+    minParticipants: number;
+    /**
+     * Status of the cohort.
+     * @type {string}
+     */
+    status: COHORT_STATUS_TYPE;
+    /**
+     * Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+     * @type {string}
+     */
+    network: string;
+    /**
+     * Pending signature requests, mapping participant DIDs to their pending signatures.
+     * @type {Record<string, string>}
+     */
+    pendingSignatureRequests: Record<string, string>;
+    /**
+     * List of participant DIDs.
+     * @type {Array<string>}
+     */
+    participants: Array<string>;
+    /**
+     * List of cohort keys (public keys).
+     * @type {Array<Uint8Array>}
+     */
+    cohortKeys: Array<Uint8Array>;
+    /**
+     * Taproot Merkle root for the cohort.
+     * @type {Uint8Array}
+     */
+    trMerkleRoot?: Uint8Array;
+    /**
+     * Beacon address for the cohort, calculated from the Taproot multisig.
+     * @type {string}
+     */
+    beaconAddress?: string;
+    /**
+     * Creates a new Musig2Cohort instance.
+     * @param {Musig2CohortParams} params Parameters for initializing the cohort.
+     * @param {string} [params.id] Optional unique identifier for the cohort. If not provided, a random UUID will be generated.
+     * @param {number} params.minParticipants Minimum number of participants required to finalize the cohort.
+     * @param {string} params.coordinatorDid DID of the coordinator managing the cohort.
+     * @param {string} params.status Initial status of the cohort (e.g., 'PENDING', 'COHORT_SET').
+     * @param {string} params.network Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+     */
+    constructor(params: Musig2CohortParams);
+    finalize(): void;
+    /**
+     * Calculates the beacon Taproot multisig address for the cohort using participant keys.
+     * @returns {string} The Taproot address for the cohort.
+     * @throws {Error} If the Taproot address cannot be calculated.
+     */
+    calulateBeaconAddress(): string;
+}

package/dist/types/btcr2/beacon/aggregation/models/cohort/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/btcr2/beacon/aggregation/models/cohort/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEhE,MAAM,MAAM,kBAAkB,GAAG;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;CAC1B,CAAA;AAED,qBAAa,YAAY;IACvB;;;OAGG;IACI,EAAE,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACI,cAAc,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACI,eAAe,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACI,MAAM,EAAE,kBAAkB,CAAC;IAElC;;;OAGG;IACI,OAAO,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACI,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAE7D;;;OAGG;IACI,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAuB;IAEzD;;;OAGG;IACI,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAA2B;IAE/D;;;OAGG;IACI,YAAY,CAAC,EAAE,UAAU,CAAC;IAEjC;;;OAGG;IACI,aAAa,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;;OAQG;gBACS,MAAM,EAAE,kBAAkB;IAQ/B,QAAQ,IAAI,IAAI;IAQvB;;;;OAIG;IACI,qBAAqB,IAAI,MAAM;CASvC"}

package/dist/types/btcr2/beacon/aggregation/models/cohort/status.d.ts

@@ -0,0 +1,7 @@
+export type COHORT_STATUS_TYPE = 'ADVERTISED' | 'OPTED_IN' | 'COHORT_SET' | 'FAILED';
+export declare enum COHORT_STATUS {
+    COHORT_ADVERTISED = "ADVERTISED",
+    COHORT_OPTED_IN = "OPTED_IN",
+    COHORT_SET_STATUS = "COHORT_SET",
+    COHORT_FAILED = "FAILED"
+}

package/dist/types/btcr2/beacon/aggregation/models/cohort/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../../../../src/btcr2/beacon/aggregation/models/cohort/status.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,CAAC;AACrF,oBAAY,aAAa;IACvB,iBAAiB,eAAe;IAChC,eAAe,aAAa;IAC5B,iBAAiB,eAAe;IAChC,aAAa,WAAW;CACzB"}

package/dist/types/btcr2/beacon/aggregation/participant.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/btcr2/beacon/aggregation/participant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"participant.d.ts","sourceRoot":"","sources":["../../../../../src/btcr2/beacon/aggregation/participant.ts"],"names":[],"mappings":""}

package/dist/types/btcr2/beacon/aggregation/protocol/nostr.d.ts

@@ -0,0 +1,36 @@
+import { ProtocolService } from './service.js';
+export interface NostrAdapterConfig {
+    keys: {
+        secret?: Uint8Array;
+        public?: Uint8Array;
+    };
+    did?: string;
+    components: {
+        idType?: string;
+        version?: number;
+        network?: string;
+    };
+    relays: string[];
+    [key: string]: any;
+}
+export declare class NostrAdapter implements ProtocolService {
+    name: string;
+    private config;
+    private handlers;
+    constructor(config?: NostrAdapterConfig);
+    start(): Promise<void>;
+    registerMessageHandler(messageType: string, handler: (msg: any) => Promise<void>): void;
+    /**
+     * Sends a message to a recipient using the Nostr protocol.
+     * This method is a placeholder and should be implemented with actual Nostr message sending logic.
+     * @param message
+     * @param recipient
+     * @param sender
+     */
+    sendMessage(message: object, recipient: string, sender: string): Promise<void>;
+    /**
+     * Generates a Nostr identity using the SecretKey and Btc1Identifier classes.
+     * @returns {string} A BTCR2 DID used for communication over the nostr protocol
+     */
+    generateIdentity(): string;
+}

package/dist/types/btcr2/beacon/aggregation/protocol/nostr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nostr.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/protocol/nostr.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE;QACJ,MAAM,CAAC,EAAE,UAAU,CAAC;QACpB,MAAM,CAAC,EAAE,UAAU,CAAC;KACrB,CAAC;IACF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,qBAAa,YAAa,YAAW,eAAe;IAC3C,IAAI,EAAE,MAAM,CAAW;IAC9B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAuD;gBAE3D,MAAM,GAAE,kBAAmF;IAWjG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAU5B,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAIvF;;;;;;OAMG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpF;;;OAGG;IACI,gBAAgB,IAAI,MAAM;CAalC"}

package/dist/types/btcr2/beacon/aggregation/protocol/service.d.ts

@@ -0,0 +1,6 @@
+export interface ProtocolService {
+    start(): Promise<void>;
+    registerMessageHandler(messageType: string, handler: (msg: any) => Promise<void>): void;
+    sendMessage(message: object, recipient: string, sender: string): Promise<void>;
+    generateIdentity(): string;
+}

package/dist/types/btcr2/beacon/aggregation/protocol/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../src/btcr2/beacon/aggregation/protocol/service.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxF,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/E,gBAAgB,IAAI,MAAM,CAAC;CAC5B"}

package/dist/types/btcr2/beacon/cid-aggregate.d.ts

@@ -0,0 +1,103 @@
+import { DidUpdateInvocation, DidUpdatePayload } from '@did-btcr2/common';
+import { DidServiceEndpoint } from '@web5/dids';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { RawTransactionV2 } from '../../types/bitcoin.js';
+import { BeaconSidecarData, CIDAggregateSidecar, SignalsMetadata } from '../../types/crud.js';
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#cidaggregate-beacon | 5.2 CIDAggregate Beacon}.
+ *
+ * A Beacon of the type CIDAggregatoBeacon is a Beacon that publishes Bitcoin transactions containing a Content
+ * Identifier (CID) announcing an Aggregated DID Update Bundle. An Aggregated DID Update Bundle is a JSON object that
+ * maps did:btcr2 identifiers to CID values for the individual DID Update Payloads. The Aggregated DID Update Bundle CID
+ * (bundleCID) SHOULD be resolvable against a Content Addressable Storage (CAS) system such as IPFS, while the CID for
+ * the DID Update Payload (payloadCID) MAY be resolvable against a CAS or provided through a Sidecar mechanism. It is
+ * RECOMMENDED that this type of Beacon is only included in a DID document if the DID controller is REQUIRED to
+ * participate in authorizing Bitcoin transactions from this Beacon. In other words, this Beacon SHOULD identify an
+ * n-of-n P2TR Bitcoin address where n is the number of unique DID controllers submitting updates through the Beacon.
+ *
+ * @class CIDAggregateBeacon
+ * @type {CIDAggregateBeacon}
+ * @extends {Beacon}
+ */
+export declare class CIDAggregateBeacon extends Beacon {
+    /**
+     * Creates an instance of CIDAggregateBeacon.
+     * @param {BeaconService} service The service of the Beacon.
+     * @param {?BeaconSidecarData} [sidecar] The sidecar data of the Beacon.
+     */
+    constructor(service: BeaconService, sidecar?: BeaconSidecarData<CIDAggregateSidecar>);
+    get service(): BeaconService;
+    /**
+     * TODO: Finish implementation
+     *
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-cidaggregate-beacon | 5.2.1 Establish CIDAggregate Beacon}.
+     *
+     * To establish a CIDAggregatorBeacon, a cohort of cooperating parties SHOULD generate an n-of-n P2TR Bitcoin address
+     * where each party contributes a public key. Furthermore, each party SHOULD verify that their key is part of the
+     * address and all other keys that are part of the address are keys with controllers able to produce valid signatures.
+     * To establish a Beacon there are two roles. One is the cohort participant, they want to join a Beacon cohort and
+     * submit a request to do so with a key and proof of control over that key. The other is the Beacon coordinator, they
+     * advertise and curate Beacon cohorts by combining Beacon participants into cohorts, verifying proofs of control, and
+     * producing Beacon addresses.
+     *
+     * @param {string} id The identifier of the Beacon.
+     * @param {string} type The type of the Beacon.
+     * @param {DidServiceEndpoint} serviceEndpoint The service endpoint of the Beacon.
+     * @returns {CIDAggregateBeacon} The established CIDAggregate Beacon.
+     */
+    static establish(id: string, type: string, serviceEndpoint: DidServiceEndpoint): CIDAggregateBeacon;
+    /**
+     * TODO: Figure out if this is necessary or not.
+     * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
+     * @returns {BeaconSignal} The generated signal.
+     * @throws {Btcr2Error} if the signal is invalid.
+     */
+    generateSignal(didUpdatePayload: string): BeaconSignal;
+    /**
+     * TODO: Finish implementation
+     *
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-cidaggregate-beacon-signal | 5.2.3 Process CIDAggregate Beacon Signal}.
+     *
+     * A Beacon Signal from a CIDAggregate Beacon is a Bitcoin transaction that contains the hashBytes of a DID Update
+     * Bundle in its first transaction output. The corresponding DID Update Bundle MUST either be provided through Sidecar
+     * Data or by converting hashBytes into a IPFS v1 Content Identifier and attempting to retrieve it from Content
+     * Addressable Storage. The DID Update Bundle maps from did:btcr2 identifiers to hashes of DID Update payloads
+     * applicable for that identifier. Again this algorithm attempts to retrieve and validate the DID Update Payload
+     * identified for the identifier being resolved. If successful, the DID Update Payload is returned.
+     *
+     * The Process CIDAggregate Beacon Signal algorithm is called by the Process Beacon Signals algorithm as part of the
+     * Read operation.
+     *
+     * It takes as inputs a did:btcr2 identifier, btc1Identifier, a Beacon Signal, tx, and a optional
+     * object, signalSidecarData, containing any sidecar data provided to the resolver for the Beacon Signal identified by
+     * the Bitcoin transaction identifier.
+     *
+     * It returns the DID Update payload announced by the Beacon Signal for the
+     * did:btcr2 identifier being resolved or throws an error.
+     *
+     * @param {RawTransactionV2} signal Bitcoin transaction representing a Beacon Signal.
+     * @param {SignalsMetadata} signalsMetadata Optional sidecar data for the Beacon Signal.
+     * @returns {Promise<DidUpdatePayload | undefined>} The DID Update payload announced by the Beacon Signal.
+     * @throws {DidError} if the signalTx is invalid or the signalsMetadata is invalid.
+     */
+    processSignal(signal: RawTransactionV2, signalsMetadata: SignalsMetadata): Promise<DidUpdateInvocation | undefined>;
+    /**
+     * TODO: Finish implementation
+     *
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-cidaggregate-beacon-signal | 5.2.2 Broadcast CIDAggregate Beacon Signal}.
+     *
+     * The Broadcast CIDAggregate Beacon Signal algorithm involving two roles: a set of cohort participants and a Beacon
+     * coordinator. The Beacon coordinator collects individual DID Update Payload Content Identifiers (CIDs) for specific
+     * did:btc1s and aggregates them into a DID Update Bundle, which is then published to a Content Addressable Storage
+     * (CAS). The CID for the DID Update Bundle is included in a Partially Signed Bitcoin Transaction (PSBT) transaction
+     * output spent from the Beacon’s n-of-n address. Each of the n cohort participants in the Beacon MUST sign the
+     * transaction before it can be broadcast to the network. It is RECOMMENDED that cohort participants keep a copy of
+     * the DID Update Bundle and separately pin it to the CAS.
+     *
+     * @param {DidUpdatePayload} didUpdatePayload The verificationMethod object to be used for signing.
+     * @returns {SignalsMetadata} Successful output of a bitcoin transaction.
+     * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
+     */
+    broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata>;
+}

package/dist/types/btcr2/beacon/cid-aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cid-aggregate.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/beacon/cid-aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE9F;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C;;;;OAIG;gBACS,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC;IAGpF,IAAI,OAAO,IAAI,aAAa,CAM3B;IAGD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,kBAAkB,GAAG,kBAAkB;IAKnG;;;;;OAKG;IACH,cAAc,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY;IAKtD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAInH;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;CA8B9E"}

package/dist/types/btcr2/beacon/factory.d.ts

@@ -0,0 +1,17 @@
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService } from '../../interfaces/ibeacon.js';
+import { SidecarData } from '../../types/crud.js';
+/**
+ * Beacon Factory pattern to create Beacon instances.
+ * @class BeaconFactory
+ * @type {BeaconFactory}
+ */
+export declare class BeaconFactory {
+    /**
+     * Establish a Beacon instance based on the provided service and optional sidecar data.
+     * @param {BeaconService} service - The beacon service configuration.
+     * @param {SidecarData} [sidecar] - The optional sidecar data.
+     * @returns {Beacon} The established Beacon instance.
+     */
+    static establish(service: BeaconService, sidecar?: SidecarData): Beacon;
+}

package/dist/types/btcr2/beacon/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/beacon/factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAuB,WAAW,EAAuB,MAAM,qBAAqB,CAAC;AAK5F;;;;GAIG;AACH,qBAAa,aAAa;IACxB;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM;CAexE"}

package/dist/types/btcr2/beacon/singleton.d.ts

@@ -0,0 +1,93 @@
+import { DidUpdatePayload } from '@did-btcr2/common';
+import { RawTransactionRest } from '../../bitcoin/rest-client.js';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { RawTransactionV2 } from '../../types/bitcoin.js';
+import { BeaconSidecarData, SignalsMetadata, SingletonSidecar } from '../../types/crud.js';
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#singleton-beacon | 5.1 Singleton Beacon}.
+ *
+ * A Singleton Beacon enables a single entity to independently post a DID Update Payload in a Beacon Signal. Its is a
+ * Beacon that can be used to publish a single DID Update Payload targeting a single DID document. The serviceEndpoint
+ * for this Beacon Type is a Bitcoin address represented as a URI following the BIP21 scheme. It is recommended that
+ * this Bitcoin address be under the sole control of the DID controller. How the Bitcoin address and the cryptographic
+ * material that controls it are generated is left to the implementation.
+ *
+ * @class SingletonBeacon
+ * @type {SingletonBeacon}
+ * @extends {Beacon}
+ */
+export declare class SingletonBeacon extends Beacon {
+    /**
+     * Creates an instance of SingletonBeacon.
+     * @param {BeaconService} service The Beacon service.
+     * @param {?BeaconSidecarData} [sidecar] Optional sidecar data.
+     */
+    constructor(service: BeaconService, sidecar?: BeaconSidecarData<SingletonSidecar>);
+    /**
+     * Get the Beacon service.
+     * @readonly
+     * @type {BeaconService} The Beacon service.
+     */
+    get service(): BeaconService;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-singleton-beacon | 5.1.1 Establish Singleton Beacon}.
+     *
+     * Static, convenience method for establishing a Beacon object.
+     *
+     * A Singleton Beacon is a Beacon that can be used to publish a single DID Update Payload targeting a single DID
+     * document. The serviceEndpoint for this Beacon Type is a Bitcoin address represented as a URI following the BIP21
+     * scheme. It is RECOMMENDED that this Bitcoin address be under the sole control of the DID controller. How the
+     * Bitcoin address and the cryptographic material that controls it are generated is left to the implementation.
+     * The Establish Singleton Beacon algorithm takes in a Bitcoin address and a serviceId and returns a Singleton Beacon service.
+     * It returns a SignletonBeacon object with the given id, type, and serviceEndpoint.
+     *
+     * @param {string} service The Beacon service.
+     * @param {BeaconSidecarData<SingletonSidecar>} sidecar The sidecar data.
+     * @returns {SingletonBeacon} The Singleton Beacon.
+     */
+    static establish(service: BeaconService, sidecar: BeaconSidecarData<SingletonSidecar>): SingletonBeacon;
+    /**
+     * TODO: Figure out if this is necessary or not.
+     * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
+     * @returns {BeaconSignal} The generated signal.
+     * @throws {Btcr2Error} if the signal is invalid.
+     */
+    generateSignal(didUpdatePayload: string): BeaconSignal;
+    /**
+     * TODO: Finish implementation per spec
+     *
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-singleton-beacon-signal | 5.1.3 Process Singleton Beacon Signal}.
+     * See {@link Beacon.processSignal | Abstract Beacon Interface Method processSignal} for more details.
+     *
+     * The Process Singleton Beacon Signal algorithm is called by the Process Beacon Signals algorithm as part of the Read
+     * operation. It takes a Bitcoin transaction representing a Beacon Signal and optional signalSidecarData containing
+     * any sidecar data provided to the resolver for the Beacon Signal identified by the Bitcoin transaction identifier.
+     * It returns the DID Update payload announced by the Beacon Signal or throws an error.
+     *
+     * @param {RawTransactionV2} signal Bitcoin transaction representing a Beacon Signal.
+     * @param {SignalsMetadata} signalsMetadata: SignalsMetadata Optional sidecar data for the Beacon Signal.
+     * @returns {Promise<DidUpdatePayload | undefined>} The DID Update payload announced by the Beacon Signal.
+     * @throws {DidError} if the signalTx is invalid or the signalSidecarData is invalid.
+     */
+    processSignal(signal: RawTransactionV2 | RawTransactionRest, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload | undefined>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-singleton-beacon-signal | 5.1.2 Broadcast Singleton Beacon Signal}.
+     *
+     * The Broadcast Singleton Beacon Signal algorithm is called by the Announce DID Update algorithm as part of the
+     * Update operation, if the Beacon being used is of the type SingletonBeacon. It takes as input a Beacon service and a
+     * secured didUpdatePayload. The algorithm constructs a Bitcoin transaction that spends from the Beacon address
+     * identified in the service and contains a transaction output of the format [OP_RETURN, OP_PUSH32, <hashBytes>],
+     * where hashBytes is the SHA256 hash of the canonical didUpdatePayload. The Bitcoin transaction is then signed and
+     * broadcast to the Bitcoin network, thereby publicly announcing a DID update in a Beacon Signal. It returns a
+     * signalMetadata object mapping the Bitcoin transaction identifier of the Beacon Signal to the necessary data needed
+     * to verify the signal announces a specific DID Update Payload.
+     *
+     * TODO: Design and implement a way to construct, sign and send via RPC
+     *
+     * @param {DidUpdatePayload} didUpdatePayload The verificationMethod object to be used for signing.
+     * @returns {SignedRawTx} Successful output of a bitcoin transaction.
+     * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
+     */
+    broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata>;
+}

package/dist/types/btcr2/beacon/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/beacon/singleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAqE,MAAM,mBAAmB,CAAC;AAIxH,OAAO,EAAe,kBAAkB,EAAQ,MAAM,8BAA8B,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAS,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAY,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIrG;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAgB,SAAQ,MAAM;IAEzC;;;;OAIG;gBACS,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,gBAAgB,CAAC;IAIjF;;;;OAIG;IACH,IAAI,OAAO,IAAI,aAAa,CAM3B;IAED;;;;;;;;;;;;;;;OAeG;WACW,SAAS,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,GAAG,eAAe;IAI9G;;;;;OAKG;IACI,cAAc,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY;IAI7D;;;;;;;;;;;;;;;OAeG;IACU,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,kBAAkB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAiElJ;;;;;;;;;;;;;;;;;OAiBG;IACU,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;CA8E3F"}

package/dist/types/btcr2/beacon/smt-aggregate.d.ts

@@ -0,0 +1,112 @@
+import { DidUpdatePayload } from '@did-btcr2/common';
+import { DidServiceEndpoint } from '@web5/dids';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { RawTransactionV2 } from '../../types/bitcoin.js';
+import { BeaconSidecarData, SignalsMetadata, SMTAggregateSidecar } from '../../types/crud.js';
+/**
+ * TODO: Finish implementation
+ *
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#smtaggregate-beacon | 5.3 SMTAggregate Beacon}.
+ *
+ * A SMTAggregate Beacon is a Beacon whose Beacon Signals are Bitcoin transactions containing the root of a Sparse
+ * Merkle Tree (SMT). The SMT root attests to a set of DID Update Payloads, however, the updates themselves MUST be
+ * provided along with a proof of inclusion against the SMT root through a Sidecar mechanism during resolution. Using
+ * the SMT root a resolver can then verify the inclusion proof for the given DID Update Payload. If a DID document
+ * includes a SMTAggregator Beacon in their set of Beacon services, then they MUST provide proofs for each signal that
+ * the Beacon broadcasts. If they did not submit an update to their DID in a signal, then they MUST provide a proof of
+ * non-inclusion for that signal.
+ *
+ * @class SMTAggregateBeacon
+ * @type {SMTAggregateBeacon}
+ * @extends {Beacon}
+ */
+export declare class SMTAggregateBeacon extends Beacon {
+    /**
+     * Creates an instance of SMTAggregateBeacon.
+     * @param {BeaconService} service The Beacon service.
+     * @param {?BeaconSidecarData} [sidecar] Optional sidecar data.
+     */
+    constructor(service: BeaconService, sidecar?: BeaconSidecarData<SMTAggregateSidecar>);
+    /**
+     * Get the Beacon service.
+     * @readonly
+     * @type {BeaconService} The Beacon service.
+     */
+    get service(): BeaconService;
+    /**
+     * TODO: Figure out if this is necessary or not.
+     * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
+     * @returns {BeaconSignal} The generated signal.
+     * @throws {Btcr2Error} if the signal is invalid.
+     */
+    generateSignal(didUpdatePayload: string): BeaconSignal;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-beacon | 5.3.1 Establish Beacon}.
+     *
+     * The Establish Beacon algorithm is essentially the same as for the CIDAggregate Beacon in Establish CIDAggregate
+     * Beacon. A cohort of DID controllers need to coordinate to produce a Bitcoin address that will act as the Beacon.
+     * It is RECOMMENDED this is an n-of-n P2TR address, with n being the set of DID controllers in the cohort. Once the
+     * address has been created, and all parties in the cohort acknowledge their intention to participate in that Beacon,
+     * each DID controller SHOULD add the Beacon as a service to their DID document.
+     *
+     * Additionally, the SMTAggregate Beacon cohort participants MUST register the did:btcr2 identifiers they intend use
+     * this Beacon with. This is so the Beacon coordinator can generate the necessary proofs of both inclusion and
+     * non-inclusion for each DID.
+     *
+     * Static, convenience method for establishing a Beacon object.
+     *
+     * @param {string} id The Beacon ID.
+     * @param {string} type The Beacon type.
+     * @param {DidServiceEndpoint} serviceEndpoint The service endpoint.
+     * @returns {Beacon} The Beacon.
+     */
+    static establish(id: string, type: string, serviceEndpoint: DidServiceEndpoint): SMTAggregateBeacon;
+    /**
+     *
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-smtaggregate-beacon-signal | 5.3.2 Broadcast SMTAggregate Beacon Signal}.
+     *
+     * See {@link Beacon.broadcastSignal | Beacon Interface Method broadcastSignal} for more information.
+     *
+     * To publish a DID Update Payload, the DID controller MUST get a hash of the DID Update Payload included at the leaf
+     * of the Sparse Merkle Tree (SMT) identified by their did:btcr2 identifier and receive an inclusion proof for this
+     * data. If a member of the Beacon cohort does not wish to announce an update in a Beacon Signal, they MUST receive
+     * and verify a proof of non-inclusion for their DID. Upon verifying the non-inclusion proof against the SMT root
+     * contained in the Beacon Signal, they SHOULD accept and authorize the signal following the MuSig2 protocol. Once all
+     * members of the cohort have authorized the signal, it can be broadcast as a transaction to the Bitcoin network. DID
+     * controllers are responsible for persisting their DID updates and proofs, these will need to be provided through a
+     * Sidecar mechanism during a resolution process.
+     *
+     * @param {DidUpdatePayload} didUpdatePayload The DID Update Payload to broadcast.
+     * @returns {Promise<SignalMetadata>} The signal metadata.
+     * @throws {Btcr2Error} if the signal is invalid.
+     */
+    broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-smtaggregate-beacon-signal | 5.3.3 Process SMTAggregate Beacon Signal}.
+     *
+     * See {@link Beacon.processSignal | Beacon Interface Method processSignal} for more information.
+     *
+     * A Beacon Signal from a SMTAggregate Beacon is a Bitcoin transaction with the first transaction output of the format
+     * [OP_RETURN, OP_PUSH32, <32bytes>]. The 32 bytes of data contained within this transaction output represent the root
+     * of a Sparse Merkle Tree (SMT). This SMT aggregates a set of hashes of DID Update payloads. In order to process
+     * these Beacon Signals, the resolver MUST have been passed Sidecar data for this signal containing either the DID
+     * Update payload object and a SMT proof that the hash of this object is in the SMT at the leaf indexed by the
+     * did:btc1identifier being resolved. Or theSidecar data:: MUST contain a proof that the leaf indexed by the
+     * did:btc1identifier is empty, thereby proving that theSMT:: does not contain an update for their identifier.
+     *
+     * The Process SMTAggregate Beacon Signal is called by the Process Beacon Signals algorithm as part of the Read
+     * operation. It takes as inputs a did:btcr2 identifier, btc1Identifier, a Beacon Signal, tx, and a optional object,
+     * signalSidecarData, containing any sidecar data provided to the resolver for the Beacon Signal identified by the
+     * Bitcoin transaction identifier.
+     *
+     * It returns the DID Update payload announced by the Beacon Signal for the did:btcr2 identifier being resolved or
+     * throws an error.
+     *
+     * @param {RawTransactionV2} signal The raw transaction signal.
+     * @param {SignalsMetadata} signalsMetadata The signals metadata.
+     * @returns {Promise<DidUpdatePayload | undefined>} The updated DID document.
+     * @throws {Btcr2Error} if the signal is invalid.
+     */
+    processSignal(signal: RawTransactionV2, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload | undefined>;
+}

package/dist/types/btcr2/beacon/smt-aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smt-aggregate.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/beacon/smt-aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE9F;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C;;;;OAIG;gBACS,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC;IAIpF;;;;OAIG;IACH,IAAI,OAAO,IAAI,aAAa,CAO3B;IAED;;;;;OAKG;IACI,cAAc,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY;IAI7D;;;;;;;;;;;;;;;;;;;OAmBG;WACW,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,kBAAkB,GAAG,kBAAkB;IAI1G;;;;;;;;;;;;;;;;;;OAkBG;IACI,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKpF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;CAGxH"}