@did-btcr2/method 0.24.1 → 0.25.2

package/dist/types/core/resolver.d.ts

@@ -0,0 +1,167 @@
+import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import { DidDocument } from '../utils/did-document.js';
+import { BeaconService, BeaconSignal, BlockMetadata } from './beacon/interfaces.js';
+import { DidComponents } from './identifier.js';
+import { CASAnnouncement, Sidecar, SidecarData } from './types.js';
+/**
+ * The response object for DID Resolution.
+ */
+export interface DidResolutionResponse {
+    didDocument: DidDocument;
+    metadata: {
+        confirmations?: number;
+        versionId: string;
+        updated?: string;
+        deactivated?: boolean;
+    };
+}
+/** The resolver needs a genesis document whose hash matches genesisHash. */
+export interface NeedGenesisDocument {
+    readonly kind: 'NeedGenesisDocument';
+    /** Base64url-encoded SHA-256 hash from the DID identifier's genesisBytes. */
+    readonly genesisHash: string;
+}
+/** The resolver needs beacon signals for these beacon service addresses. */
+export interface NeedBeaconSignals {
+    readonly kind: 'NeedBeaconSignals';
+    /** The beacon services that need signal data. Pass directly to BeaconSignalDiscovery. */
+    readonly beaconServices: ReadonlyArray<BeaconService>;
+}
+/** The resolver needs a CAS Announcement whose canonical hash matches announcementHash. */
+export interface NeedCASAnnouncement {
+    readonly kind: 'NeedCASAnnouncement';
+    /** Base64url-encoded canonical hash of the CAS Announcement. */
+    readonly announcementHash: string;
+    /** The beacon service that produced this signal. */
+    readonly beaconServiceId: string;
+}
+/** The resolver needs a SignedBTCR2Update whose canonical hash matches updateHash. */
+export interface NeedSignedUpdate {
+    readonly kind: 'NeedSignedUpdate';
+    /** Base64url-encoded canonical hash of the signed update. */
+    readonly updateHash: string;
+    /** The beacon service that produced this signal. */
+    readonly beaconServiceId: string;
+}
+/** Discriminated union of all data the resolver may request from the caller. */
+export type DataNeed = NeedGenesisDocument | NeedBeaconSignals | NeedCASAnnouncement | NeedSignedUpdate;
+/**
+ * Output of {@link Resolver.resolve}. Analogous to Rust's `ResolverState` enum.
+ * Either the resolver needs data from the caller, or resolution is complete.
+ */
+export type ResolverState = {
+    status: 'action-required';
+    needs: ReadonlyArray<DataNeed>;
+} | {
+    status: 'resolved';
+    result: DidResolutionResponse;
+};
+/**
+ * Return type from {@link Beacon.processSignals}.
+ * Contains successfully resolved updates and any data needs that must be
+ * satisfied before the remaining signals can be processed.
+ */
+export interface BeaconProcessResult {
+    updates: Array<[SignedBTCR2Update, BlockMetadata]>;
+    needs: Array<DataNeed>;
+}
+/**
+ * Sans-I/O state machine for did:btcr2 resolution.
+ *
+ * Created by {@link DidBtcr2.resolve} (the factory). The caller drives resolution
+ * by repeatedly calling {@link resolve} and {@link provide}:
+ *
+ * ```typescript
+ * const resolver = DidBtcr2.resolve(did, { sidecar });
+ * let state = resolver.resolve();
+ *
+ * while (state.status === 'action-required') {
+ *   for (const need of state.needs) { ... fetch & provide ... }
+ *   state = resolver.resolve();
+ * }
+ * const { didDocument, metadata } = state.result;
+ * ```
+ *
+ * The Resolver performs **zero I/O**. All external data (Bitcoin signals, CAS
+ * data, genesis documents) flows through the advance/provide protocol.
+ *
+ * @class Resolver
+ */
+export declare class Resolver {
+    #private;
+    /**
+     * @internal — Use {@link DidBtcr2.resolve} to create instances.
+     */
+    constructor(didComponents: DidComponents, sidecarData: SidecarData, currentDocument: DidDocument | null, options?: {
+        versionId?: string;
+        versionTime?: string;
+        genesisDocument?: object;
+    });
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-secp256k1-public-key | 7.2.d.1 if genesis bytes is a secp256k1 Public Key}.
+     * @param {DidComponents} didComponents The decoded components of the did.
+     * @returns {DidDocument} The resolved DID Document object.
+     */
+    static deterministic(didComponents: DidComponents): DidDocument;
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-sha-256-hash | 7.2.d.2 if genesis_bytes is a SHA-256 Hash}.
+     * @param {DidComponents} didComponents BTCR2 DID components used to resolve the DID Document
+     * @param {object} genesisDocument The genesis document for resolving the DID Document.
+     * @returns {DidDocument} The resolved DID Document object
+     * @throws {ResolveError} InvalidDidDocument if not conformant to DID Core v1.1
+     */
+    static external(didComponents: DidComponents, genesisDocument: object): DidDocument;
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
+     * @param {Sidecar} sidecar The sidecar data to process.
+     * @returns {SidecarData} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
+     */
+    static sidecarData(sidecar?: Sidecar): SidecarData;
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-updates | 7.2.f Process updates Array}.
+     * @param {DidDocument} currentDocument The current DID Document to apply the updates to.
+     * @param {Array<[SignedBTCR2Update, BlockMetadata]>} unsortedUpdates The unsorted array of BTCR2 Signed Updates and their associated Block Metadata.
+     * @param {string} [versionTime] The optional version time to limit updates to.
+     * @param {string} [versionId] The optional version id to limit updates to.
+     * @returns {DidResolutionResponse} The updated DID Document, number of confirmations, and version id.
+     */
+    static updates(currentDocument: DidDocument, unsortedUpdates: Array<[SignedBTCR2Update, BlockMetadata]>, versionTime?: string, versionId?: string): DidResolutionResponse;
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.f.1 Confirm Duplicate Update}.
+     * This step confirms that an update with a lower-than-expected targetVersionId is a true duplicate.
+     * @param {SignedBTCR2Update} update The BTCR2 Signed Update to confirm as a duplicate.
+     * @param {string[]} updateHashHistory The accumulated hash history for comparison.
+     * @returns {void} Does not return a value, but throws an error if the update is not a valid duplicate.
+     */
+    private static confirmDuplicate;
+    /**
+     * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#apply-update | 7.2.f.3 Apply Update}.
+     * @param {DidDocument} currentDocument The current DID Document to apply the update to.
+     * @param {SignedBTCR2Update} update The BTCR2 Signed Update to apply.
+     * @returns {DidDocument} The updated DID Document after applying the update.
+     * @throws {ResolveError} If the update is invalid or cannot be applied.
+     */
+    private static applyUpdate;
+    /**
+     * Advance the state machine. Returns either:
+     * - `{ status: 'action-required', needs }` — caller must provide data via {@link provide}
+     * - `{ status: 'resolved', result }` — resolution complete
+     *
+     * Analogous to Rust's `Resolver::resolve()`.
+     */
+    resolve(): ResolverState;
+    /**
+     * Provide data the resolver requested in a previous {@link resolve} call.
+     * Call once per need, then call {@link resolve} again to continue.
+     *
+     * Analogous to Rust's `Resolver::process_responses()`.
+     *
+     * @param need The DataNeed being fulfilled (from the `needs` array).
+     * @param data The data payload corresponding to the need kind.
+     */
+    provide(need: NeedGenesisDocument, data: object): void;
+    provide(need: NeedBeaconSignals, data: Map<BeaconService, Array<BeaconSignal>>): void;
+    provide(need: NeedCASAnnouncement, data: CASAnnouncement): void;
+    provide(need: NeedSignedUpdate, data: SignedBTCR2Update): void;
+}
+//# sourceMappingURL=resolver.d.ts.map

package/dist/types/core/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/core/resolver.ts"],"names":[],"mappings":"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"}

package/dist/types/core/update.d.ts

@@ -23,10 +23,10 @@ export declare class Update {
      * @param {Btcr2DidDocument} sourceDocument The source DID document to be updated.
      * @param {PatchOperation[]} patches The array of JSON Patch operations to apply to the sourceDocument.
      * @param {number} sourceVersionId The version ID of the source document.
-     * @returns {Promise<SignedBTCR2Update>} The constructed SignedBTCR2Update object.
+     * @returns {UnsignedBTCR2Update} The constructed UnsignedBTCR2Update object.
      * @throws {UpdateError} InvalidDid if sourceDocument.id does not match identifier.
      */
-    static construct(sourceDocument: Btcr2DidDocument, patches: PatchOperation[], sourceVersionId: number): Promise<UnsignedBTCR2Update>;
+    static construct(sourceDocument: Btcr2DidDocument, patches: PatchOperation[], sourceVersionId: number): UnsignedBTCR2Update;
     /**
      * Implements subsection {@link http://dcdpr.github.io/did-btcr2/operations/update.html#construct-btcr2-signed-update | 7.3.c Construct BTCR2 Signed Update }.
      * This process constructs a BTCR2 Signed Update from a BTCR2 Unsigned Update.
@@ -37,7 +37,7 @@ export declare class Update {
      * @returns {SignedBTCR2Update} Did update payload secured with a proof => SignedBTCR2Update
      * @throws {UpdateError} if the privateKeyBytes are invalid
      */
-    static sign(did: string, unsignedUpdate: UnsignedBTCR2Update, verificationMethod: DidVerificationMethod, secretKey: KeyBytes): Promise<SignedBTCR2Update>;
+    static sign(did: string, unsignedUpdate: UnsignedBTCR2Update, verificationMethod: DidVerificationMethod, secretKey: KeyBytes): SignedBTCR2Update;
     /**
      * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/update.html#announce-did-update | 7.3.d Announce DID Update}.
      * BTCR2 Signed Updates are announced to the Bitcoin blockchain depending on the Beacon Type.

package/dist/types/core/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/core/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EACR,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAe,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEhG,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB;;;;;;;;;OASG;WACU,SAAS,CACpB,cAAc,EAAE,gBAAgB,EAChC,OAAO,EAAE,cAAc,EAAE,EACzB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,mBAAmB,CAAC;IAoC/B;;;;;;;;;OASG;WACU,IAAI,CACf,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,mBAAmB,EACnC,kBAAkB,EAAE,qBAAqB,EACzC,SAAS,EAAE,QAAQ,GAClB,OAAO,CAAC,iBAAiB,CAAC;IAgC7B;;;;;;;;OAQG;WACU,QAAQ,CACnB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,QAAQ,EACnB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,iBAAiB,CAAC;CAU9B"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/core/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EACR,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAe,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEhG,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,CACd,cAAc,EAAE,gBAAgB,EAChC,OAAO,EAAE,cAAc,EAAE,EACzB,eAAe,EAAE,MAAM,GACtB,mBAAmB;IAoCtB;;;;;;;;;OASG;IACH,MAAM,CAAC,IAAI,CACT,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,mBAAmB,EACnC,kBAAkB,EAAE,qBAAqB,EACzC,SAAS,EAAE,QAAQ,GAClB,iBAAiB;IAgCpB;;;;;;;;OAQG;WACU,QAAQ,CACnB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,QAAQ,EACnB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,iBAAiB,CAAC;CAU9B"}

package/dist/types/did-btcr2.d.ts

@@ -1,10 +1,10 @@
 import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import { DocumentBytes, HexString, KeyBytes, PatchOperation } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
-import { DidMethod, DidResolutionResult } from '@web5/dids';
+import { DidMethod } from '@web5/dids';
 import { ResolutionOptions } from './core/interfaces.js';
+import { Resolver } from './core/resolver.js';
 import { Btcr2DidDocument, DidVerificationMethod } from './utils/did-document.js';
-export type Btcr2Identifier = string;
 export interface DidCreateOptions {
     /** Type of identifier to create (key or external) */
     idType: string;
@@ -39,7 +39,7 @@ export declare class DidBtcr2 implements DidMethod {
      * @param {string} options.idType The type of identifier to create, either 'KEY' or 'EXTERNAL'. Defaults to 'KEY'.
      * @param {number} options.version The version number of the did:btcr2 specification to use for creating the identifier. Defaults to 1.
      * @param {string} options.network The Bitcoin network to use for the identifier, e.g. 'bitcoin', 'testnet', etc. Defaults to 'bitcoin'.
-     * @returns {Promise<Btcr2Identifier>} Promise resolving to a Btcr2Identifier string.
+     * @returns {Promise<string>} Promise resolving to an identifier string.
      * @throws {MethodError} if any of the checks fail
      * @example
      * ```ts
@@ -47,29 +47,29 @@ export declare class DidBtcr2 implements DidMethod {
      * const did = DidBtcr2.create(genesisBytes, { idType: 'KEY', network: 'regtest' });
      * ```
      */
-    static create(genesisBytes: KeyBytes | DocumentBytes, options?: DidCreateOptions): Btcr2Identifier;
+    static create(genesisBytes: KeyBytes | DocumentBytes, options?: DidCreateOptions): string;
     /**
      * Entry point for section {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html | 7.2 Resolve}.
-     * See specification for the {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process | Resolve Process}.
-     * See {@link Resolve | Resolve (class)} for class implementation.
      *
-     * Resolving a did:btcr2 identifier iteratively builds a DID document by applying
-     * BTCR2 Updates to an Initial DID Document that have been committed to the Bitcoin
-     * blockchain by Authorized Beacon Signals. The Initial DID Document is either
-     * deterministically created from the DID or provided by Sidecar Data.
+     * Factory method that performs pure setup and returns a {@link Resolver} state machine.
+     * The caller drives resolution by calling `resolver.resolve()` and `resolver.provide()`.
+     * Analogous to Rust's `Document::read()`.
      *
      * @param {string} did The did:btcr2 identifier to be resolved.
      * @param {ResolutionOptions} resolutionOptions Options used during the resolution process.
-     * @returns {Promise<DidResolutionResult>} Promise resolving to a DID Resolution Result containing the `targetDocument`
-     * @throws {ResolveError} If the resolution process fails at any step.
+     * @returns {Resolver} A sans-I/O state machine the caller drives to completion.
      * @example
      * ```ts
-     * const resolution = await DidBtcr2.resolve(
-     *  'did:btcr2:k1qgpr45cheptyjekl3cex80xfnkwhxnlclecwwf92gvdjrszm2uwhzlcxu5xte'
-     * )
+     * const resolver = DidBtcr2.resolve(did, { sidecar });
+     * let state = resolver.resolve();
+     * while (state.status === 'action-required') {
+     *   for (const need of state.needs) { ... provide data ... }
+     *   state = resolver.resolve();
+     * }
+     * const { didDocument, metadata } = state.result;
      * ```
      */
-    static resolve(did: string, resolutionOptions?: ResolutionOptions): Promise<DidResolutionResult>;
+    static resolve(did: string, resolutionOptions?: ResolutionOptions): Resolver;
     /**
      * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#read | 7.3 Update}.
      * See specification for the {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process | Resolve Process}.

package/dist/types/did-btcr2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"did-btcr2.d.ts","sourceRoot":"","sources":["../../src/did-btcr2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EACL,aAAa,EACb,SAAS,EAIT,QAAQ,EAKR,cAAc,EAGf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAIL,SAAS,EACT,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAElF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAErC,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAS,YAAW,SAAS;IACxC;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,CAAW;IAEpC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,eAAe;IAelG;;;;;;;;;;;;;;;;;;;;OAoBG;WACU,OAAO,CAClB,GAAG,EAAE,MAAM,EACX,iBAAiB,GAAE,iBAAsB,GACxC,OAAO,CAAC,mBAAmB,CAAC;IAyG/B;;;;;;;;;;;;;;;;;;;OAmBG;WACU,MAAM,CAAC,EAClB,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,QAAQ,EACR,eAAe,EACf,OAAO,GACR,EAAE;QACD,cAAc,EAAE,gBAAgB,CAAC;QACjC,OAAO,EAAE,cAAc,EAAE,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QACvC,OAAO,CAAC,EAAE,iBAAiB,CAAC;KAC7B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoF9B;;;;;;;;;OASG;IACH,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,EAAG,QAAQ,CAAC,EAAE,MAAM,GAAG,qBAAqB;CA0BlG"}
+{"version":3,"file":"did-btcr2.d.ts","sourceRoot":"","sources":["../../src/did-btcr2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EACL,aAAa,EACb,SAAS,EAIT,QAAQ,EAGR,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAIL,SAAS,EACV,MAAM,YAAY,CAAC;AAMpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG9C,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAElF,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAS,YAAW,SAAS;IACxC;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,CAAW;IAEpC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAezF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CACZ,GAAG,EAAE,MAAM,EACX,iBAAiB,GAAE,iBAAsB,GACxC,QAAQ;IAsBX;;;;;;;;;;;;;;;;;;;OAmBG;WACU,MAAM,CAAC,EAClB,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,QAAQ,EACR,eAAe,EACf,OAAO,GACR,EAAE;QACD,cAAc,EAAE,gBAAgB,CAAC;QACjC,OAAO,EAAE,cAAc,EAAE,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QACvC,OAAO,CAAC,EAAE,iBAAiB,CAAC;KAC7B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoF9B;;;;;;;;;OASG;IACH,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,EAAG,QAAQ,CAAC,EAAE,MAAM,GAAG,qBAAqB;CA0BlG"}

package/dist/types/index.d.ts

@@ -28,12 +28,12 @@ export * from './core/beacon/error.js';
 export * from './core/beacon/factory.js';
 export * from './core/beacon/interfaces.js';
 export * from './core/beacon/signal-discovery.js';
-export * from './core/beacon/singleton.js';
+export * from './core/beacon/singleton-beacon.js';
 export * from './core/beacon/smt-beacon.js';
 export * from './core/beacon/utils.js';
 export * from './core/identifier.js';
 export * from './core/interfaces.js';
-export * from './core/resolve.js';
+export * from './core/resolver.js';
 export * from './core/types.js';
 export * from './core/update.js';
 export * from './utils/appendix.js';

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,mDAAmD,CAAC;AAClE,cAAc,wDAAwD,CAAC;AACvE,cAAc,oDAAoD,CAAC;AACnE,cAAc,gEAAgE,CAAC;AAC/E,cAAc,mEAAmE,CAAC;AAClF,cAAc,kEAAkE,CAAC;AACjF,cAAc,mEAAmE,CAAC;AAClF,cAAc,4DAA4D,CAAC;AAC3E,cAAc,oEAAoE,CAAC;AACnF,cAAc,yEAAyE,CAAC;AACxF,cAAc,sEAAsE,CAAC;AACrF,cAAc,qEAAqE,CAAC;AACpF,cAAc,2EAA2E,CAAC;AAE1F,cAAc,6DAA6D,CAAC;AAC5E,cAAc,0DAA0D,CAAC;AAEzE,cAAc,kDAAkD,CAAC;AACjE,cAAc,oDAAoD,CAAC;AACnE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,6CAA6C,CAAC;AAE5D,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AAEvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AAExC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,mDAAmD,CAAC;AAClE,cAAc,wDAAwD,CAAC;AACvE,cAAc,oDAAoD,CAAC;AACnE,cAAc,gEAAgE,CAAC;AAC/E,cAAc,mEAAmE,CAAC;AAClF,cAAc,kEAAkE,CAAC;AACjF,cAAc,mEAAmE,CAAC;AAClF,cAAc,4DAA4D,CAAC;AAC3E,cAAc,oEAAoE,CAAC;AACnF,cAAc,yEAAyE,CAAC;AACxF,cAAc,sEAAsE,CAAC;AACrF,cAAc,qEAAqE,CAAC;AACpF,cAAc,2EAA2E,CAAC;AAE1F,cAAc,6DAA6D,CAAC;AAC5E,cAAc,0DAA0D,CAAC;AAEzE,cAAc,kDAAkD,CAAC;AACjE,cAAc,oDAAoD,CAAC;AACnE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,6CAA6C,CAAC;AAE5D,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AAEvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AAExC,cAAc,gBAAgB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@did-btcr2/method",
-  "version": "0.24.1",
+  "version": "0.25.2",
   "type": "module",
   "description": "Reference implementation for the did:btcr2 DID method written in TypeScript and JavaScript. did:btcr2 is a censorship resistant DID Method using the Bitcoin blockchain as a Verifiable Data Registry to announce changes to the DID document. This is the core method implementation for the did-btcr2-js monorepo.",
   "main": "./dist/cjs/index.js",
@@ -82,11 +82,10 @@
     "helia": "^5.2.1",
     "multiformats": "^13.3.1",
     "nostr-tools": "^2.15.0",
-    "tiny-secp256k1": "^2.2.3",
-    "@did-btcr2/common": "7.0.0",
-    "@did-btcr2/cryptosuite": "6.0.2",
-    "@did-btcr2/keypair": "0.11.0",
-    "@did-btcr2/bitcoin": "0.5.0"
+    "@did-btcr2/common": "8.0.0",
+    "@did-btcr2/cryptosuite": "6.0.4",
+    "@did-btcr2/keypair": "0.11.2",
+    "@did-btcr2/bitcoin": "0.5.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",

package/src/core/beacon/aggregation/cohort/index.ts

@@ -1,3 +1,4 @@
+import { hexToBytes } from '@noble/hashes/utils';
 import { keyAggExport, keyAggregate, sortKeys } from '@scure/btc-signer/musig2';
 import { payments, Transaction } from 'bitcoinjs-lib';
 import { BeaconCoordinatorError } from '../../error.js';
@@ -133,7 +134,7 @@ export class AggregateBeaconCohort implements BeaconCohort {
         );
       }
     }
-    this.cohortKeys = cohortKeys.map(key => Buffer.from(key, 'hex'));
+    this.cohortKeys = cohortKeys.map(key => hexToBytes(key));
     const calculatedAddress = this.calulateBeaconAddress();
     if (calculatedAddress !== beaconAddress) {
       this.status = COHORT_STATUS.COHORT_FAILED;

package/src/core/beacon/aggregation/communication/adapter/nostr.ts

@@ -2,6 +2,7 @@
 
 import { Did } from '@did-btcr2/common';
 import { CompressedSecp256k1PublicKey, RawSchnorrKeyPair, SchnorrKeyPair, Secp256k1SecretKey } from '@did-btcr2/keypair';
+import { bytesToHex } from '@noble/hashes/utils';
 import { nonceGen } from '@scure/btc-signer/musig2';
 import { Event, EventTemplate, Filter, finalizeEvent, nip44 } from 'nostr-tools';
 import { SimplePool } from 'nostr-tools/pool';
@@ -217,10 +218,10 @@ export class NostrAdapter implements CommunicationService {
     //   this.config.coordinatorDids.push(recipient);
     // }
 
-    const tags = [['p', Buffer.from(sender.x).toString('hex')]];
+    const tags = [['p', bytesToHex(sender.x)]];
     if(to) {
       const recipient = new CompressedSecp256k1PublicKey(Identifier.decode(to).genesisBytes);
-      tags.push(['p', Buffer.from(recipient.x).toString('hex')]);
+      tags.push(['p', bytesToHex(recipient.x)]);
     }
     const { type } = message as any ?? {};
     if(!type) {

package/src/core/beacon/aggregation/coordinator.ts

@@ -1,5 +1,6 @@
 import { Maybe } from '@did-btcr2/common';
 import { RawSchnorrKeyPair } from '@did-btcr2/keypair';
+import { bytesToHex } from '@noble/hashes/utils';
 import { BeaconCoordinatorError } from '../error.js';
 import { AggregateBeaconCohort } from './cohort/index.js';
 import {
@@ -253,7 +254,7 @@ export class BeaconCoordinator {
 
     if (signingSession.status === SIGNING_SESSION_STATUS.PARTIAL_SIGNATURES_RECEIVED) {
       const signature = await signingSession.generateFinalSignature();
-      console.info(`Final signature ${Buffer.from(signature).toString('hex')} generated for session ${signingSession.id}`);
+      console.info(`Final signature ${bytesToHex(signature)} generated for session ${signingSession.id}`);
     }
   }
 

package/src/core/beacon/aggregation/participant.ts

@@ -1,4 +1,5 @@
 import { KeyBytes, Maybe } from '@did-btcr2/common';
+import { bytesToHex } from '@noble/hashes/utils';
 import { HDKey } from '@scure/bip32';
 import { mnemonicToSeedSync } from '@scure/bip39';
 import * as musig2 from '@scure/btc-signer/musig2';
@@ -280,7 +281,7 @@ export class BeaconParticipant {
       console.error(`Failed to derive public key for cohort ${cohortId}`);
       return;
     }
-    const participantPk = Buffer.from(participantPkBytes).toString('hex');
+    const participantPk = bytesToHex(participantPkBytes);
     const beaconAddress = cohortSetMessage.body?.beaconAddress;
     if(!beaconAddress) {
       console.error(`Beacon address not provided in cohort set message for ${cohortId}`);
@@ -291,7 +292,7 @@ export class BeaconParticipant {
       console.error(`Cohort keys not provided in cohort set message for ${cohortId}`);
       return;
     }
-    const keys = cohortKeys.map(key => Buffer.from(key).toString('hex'));
+    const keys = cohortKeys.map(key => bytesToHex(new Uint8Array(key)));
     cohort.validateCohort([participantPk], keys, beaconAddress);
     console.info(`BeaconParticipant w/ pk ${participantPk} successfully joined cohort ${cohortId} with beacon address ${beaconAddress}.`);
     console.info(`Cohort status: ${cohort.status}`);

package/src/core/beacon/beacon.ts

@@ -1,8 +1,9 @@
 import { KeyBytes } from '@did-btcr2/common';
 import { BitcoinConnection } from '@did-btcr2/bitcoin';
-import { SignedBTCR2Update } from '../../../../cryptosuite/dist/types/data-integrity-proof/interface.js';
+import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import type { BeaconProcessResult } from '../resolver.js';
 import { SidecarData } from '../types.js';
-import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
+import { BeaconService, BeaconSignal } from './interfaces.js';
 
 /**
  * Abstract base class for all BTCR2 Beacon types.
@@ -32,15 +33,18 @@ export abstract class Beacon {
   /**
    * Processes an array of Beacon Signals to extract BTCR2 Signed Updates.
    * Used during the resolve path.
+   *
+   * Returns successfully resolved updates and any data needs that must be
+   * satisfied before remaining signals can be processed.
+   *
    * @param {Array<BeaconSignal>} signals The beacon signals discovered on-chain.
    * @param {SidecarData} sidecar The processed sidecar data containing update/CAS/SMT maps.
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The updates announced by the signals.
+   * @returns {BeaconProcessResult} The updates and any data needs.
    */
   abstract processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData,
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>>;
-
+  ): BeaconProcessResult;
 
   /**
    * Broadcasts a signed update as a Beacon Signal to the Bitcoin network.

package/src/core/beacon/cas-beacon.ts

@@ -1,6 +1,10 @@
-import { BitcoinConnection } from '@did-btcr2/bitcoin';
-import { KeyBytes } from '@did-btcr2/common';
+import { AddressUtxo, BitcoinConnection } from '@did-btcr2/bitcoin';
+import { canonicalHash, canonicalize, decode, encode, hash, KeyBytes } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import { SchnorrKeyPair } from '@did-btcr2/keypair';
+import { hexToBytes } from '@noble/hashes/utils';
+import { opcodes, Psbt, script } from 'bitcoinjs-lib';
+import type { BeaconProcessResult, DataNeed } from '../resolver.js';
 import { SidecarData } from '../types.js';
 import { Beacon } from './beacon.js';
 import { CASBeaconError } from './error.js';
@@ -8,6 +12,13 @@ import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
 
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/terminology.html#cas-beacon | CAS Beacon}.
+ *
+ * A CAS (Content-Addressed Store) Beacon aggregates updates for multiple DIDs
+ * into a single CAS Announcement — a mapping of DIDs to their update hashes.
+ * The hash of the CAS Announcement is broadcast on-chain via OP_RETURN.
+ * During resolution, the CAS Announcement is retrieved from the sidecar (or CAS)
+ * and used to look up the individual signed update for the DID being resolved.
+ *
  * @class CASBeacon
  * @type {CASBeacon}
  * @extends {Beacon}
@@ -23,31 +34,167 @@ export class CASBeacon extends Beacon {
 
   /**
    * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-cas-beacon | 7.2.e.1 Process CAS Beacon}.
+   *
+   * For each signal, the signalBytes contain the hex-encoded hash of a CAS Announcement.
+   * The CAS Announcement maps DIDs to their base64url-encoded update hashes.
+   * This method looks up the CAS Announcement from the sidecar, extracts the update
+   * hash for the DID being resolved, and retrieves the corresponding signed update.
+   *
    * @param {Array<BeaconSignal>} signals The array of Beacon Signals to process.
    * @param {SidecarData} sidecar The sidecar data associated with the CAS Beacon.
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The processed signals.
-   * @throws {CASBeaconError} if processing fails.
+   * @returns {BeaconProcessResult} Successfully resolved updates and any data needs.
+   * @throws {CASBeaconError} if hash verification fails (validation errors only).
    */
   processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
-    throw new CASBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { signals, sidecar });
+  ): BeaconProcessResult {
+    const updates = new Array<[SignedBTCR2Update, BlockMetadata]>();
+    const needs = new Array<DataNeed>();
+
+    // Extract the DID from the beacon service id (strip the #fragment)
+    const did = this.service.id.split('#')[0];
+
+    for(const signal of signals) {
+      // Decode signal bytes from hex and re-encode to base64url for sidecar lookup
+      const announcementHash = encode(decode(signal.signalBytes, 'hex'));
+
+      // Look up the CAS Announcement in sidecar casMap
+      const casAnnouncement = sidecar.casMap.get(announcementHash);
+
+      if(!casAnnouncement) {
+        // CAS Announcement not available — emit a need
+        needs.push({
+          kind              : 'NeedCASAnnouncement',
+          announcementHash,
+          beaconServiceId   : this.service.id
+        });
+        continue;
+      }
+
+      // Look up this DID's update hash in the CAS Announcement
+      const updateHash = casAnnouncement[did];
+
+      // If no entry for this DID, this announcement doesn't contain an update for us — skip
+      if(!updateHash) {
+        continue;
+      }
+
+      // Look up the signed update in sidecar updateMap
+      const signedUpdate = sidecar.updateMap.get(updateHash);
+
+      if(!signedUpdate) {
+        // Signed update not available — emit a need
+        needs.push({
+          kind             : 'NeedSignedUpdate',
+          updateHash,
+          beaconServiceId  : this.service.id
+        });
+        continue;
+      }
+
+      updates.push([signedUpdate, signal.blockMetadata]);
+    }
+
+    return { updates, needs };
   }
 
   /**
-   * Broadcast CAS Beacon signal to the Bitcoin network.
+   * Broadcasts a CAS Beacon signal to the Bitcoin network.
+   *
+   * Creates a CAS Announcement mapping the DID to the update hash, then broadcasts
+   * the hash of the announcement via OP_RETURN. The CAS Announcement is distributed
+   * to resolvers via sidecar data.
+   *
    * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
    * @param {KeyBytes} secretKey The secret key for signing the Bitcoin transaction.
    * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
-   * @return {Promise<SignedBTCR2Update>} The signed update that was broadcasted.
-   * @throws {CASBeaconError} if broadcasting fails.
+   * @returns {Promise<SignedBTCR2Update>} The signed update that was broadcast.
+   * @throws {CASBeaconError} if the bitcoin address is invalid or unfunded.
    */
   async broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
     bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
-    throw new CASBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signedUpdate, secretKey, bitcoin});
+    // Extract the DID from the beacon service id (strip the #fragment)
+    const did = this.service.id.split('#')[0];
+
+    // Hash the signed update (base64url for the CAS Announcement entry)
+    const updateHash = canonicalHash(signedUpdate);
+
+    // Create the CAS Announcement mapping this DID to its update hash
+    const casAnnouncement = { [did]: updateHash };
+
+    // TODO: Publish CAS Announcement to content-addressed store (e.g., IPFS via Helia)
+
+    // Canonicalize and hash the CAS Announcement for the OP_RETURN output
+    const announcementHash = hash(canonicalize(casAnnouncement));
+
+    // Convert the serviceEndpoint to a bitcoin address by removing the 'bitcoin:' prefix
+    const bitcoinAddress = this.service.serviceEndpoint.replace('bitcoin:', '');
+
+    // Query the Bitcoin network for UTXOs associated with the bitcoinAddress
+    const utxos = await bitcoin.rest.address.getUtxos(bitcoinAddress);
+
+    // If no utxos are found, throw an error indicating the address is unfunded.
+    if(!utxos.length) {
+      throw new CASBeaconError(
+        'No UTXOs found, please fund address!',
+        'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress }
+      );
+    }
+
+    // Sort utxos by block height and take the most recent one
+    const utxo: AddressUtxo | undefined = utxos.sort(
+      (a, b) => b.status.block_height - a.status.block_height
+    ).shift();
+
+    // If no utxos are found, throw an error.
+    if(!utxo) {
+      throw new CASBeaconError(
+        'Beacon bitcoin address unfunded or utxos unconfirmed.',
+        'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress }
+      );
+    }
+
+    // Get the previous tx to the utxo being spent
+    const prevTx = await bitcoin.rest.transaction.getHex(utxo.txid);
+
+    // Construct a spend transaction
+    const spendTx = new Psbt({ network: bitcoin.data })
+      // Spend tx contains the utxo as its input
+      .addInput({
+        hash           : utxo.txid,
+        index          : utxo.vout,
+        nonWitnessUtxo : hexToBytes(prevTx)
+      })
+      // Add a change output minus a fee of 500 sats
+      // TODO: calculate fee based on transaction vsize and current fee rates
+      .addOutput({ address: bitcoinAddress, value: BigInt(utxo.value) - BigInt(500) })
+      // Add an OP_RETURN output containing the CAS Announcement hash
+      .addOutput({ script: script.compile([opcodes.OP_RETURN, announcementHash]), value: 0n });
+
+    // Construct a key pair and PSBT signer from the secret key
+    const keyPair = SchnorrKeyPair.fromSecret(secretKey);
+    const signer = {
+      publicKey : keyPair.publicKey.compressed,
+      sign      : (hash: Uint8Array) => keyPair.secretKey.sign(hash, { scheme: 'ecdsa' }),
+    };
+
+    // Sign 0th input, finalize extract to hex in prep for broadcast
+    const signedTx = spendTx.signInput(0, signer)
+      .finalizeAllInputs()
+      .extractTransaction()
+      .toHex();
+
+    // Broadcast spendTx to the Bitcoin network.
+    const txid = await bitcoin.rest.transaction.send(signedTx);
+
+    // Log the txid of the broadcasted transaction
+    console.info(`CAS Beacon Signal Broadcasted with txid: ${txid}`);
+
+    // Return the signed update
+    return signedUpdate;
   }
 }