@did-btcr2/method 0.18.1 → 0.20.0

package/src/did-btcr2.ts

@@ -1,154 +1,229 @@
+import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
 import {
+  Canonicalization,
   DocumentBytes,
+  HexString,
+  IdentifierHrp,
   INVALID_DID_DOCUMENT,
+  INVALID_DID_UPDATE,
   KeyBytes,
   METHOD_NOT_SUPPORTED,
   MethodError,
+  MISSING_UPDATE_DATA,
   PatchOperation,
-  W3C_DID_RESOLUTION_V1,
+  ResolveError,
+  UpdateError
 } from '@did-btcr2/common';
-import type { DidResolutionResult } from '@web5/dids';
+import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
 import {
   Did,
   DidError,
   DidErrorCode,
   DidMethod,
+  DidResolutionResult,
   EMPTY_DID_RESOLUTION_RESULT
 } from '@web5/dids';
 import { initEccLib } from 'bitcoinjs-lib';
 import * as tinysecp from 'tiny-secp256k1';
-import { Resolve } from './core/crud/read.js';
-import { Update } from './core/crud/update.js';
-import { DidResolutionOptions } from './interfaces/crud.js';
-import { DidDocument, DidVerificationMethod } from './utils/did-document.js';
-import { SignalsMetadata } from './utils/types.js';
+import { BeaconService } from './core/beacon/interfaces.js';
+import { BeaconUtils } from './core/beacon/utils.js';
 import { Identifier } from './core/identifier.js';
+import { ResolutionOptions } from './core/interfaces.js';
+import { Resolve } from './core/resolve.js';
+import { Update } from './core/update.js';
 import { Appendix } from './utils/appendix.js';
+import { Btcr2DidDocument, DidVerificationMethod } from './utils/did-document.js';
+
+// TODO: convert to API driver?
+export const canonicalization = new Canonicalization();
 
 export type Btcr2Identifier = string;
 
 export interface DidCreateOptions {
+  /** Type of identifier to create (key or external) */
+  idType: 'KEY' | 'EXTERNAL';
   /** DID BTCR2 Version Number */
   version?: number;
   /** Bitcoin Network */
   network?: string;
 }
 
+// TODO: convert to API driver?
 /** Initialize tiny secp256k1 */
 initEccLib(tinysecp);
 
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2 | did:btcr2 DID Method Specification}.
- * did:btcr2 is a censorship resistant DID Method using the Bitcoin blockchain as a Verifiable Data Registry to announce
- * changes to the DID document. It improves on prior work by allowing: zero-cost off-chain DID creation; aggregated
- * updates for scalable on-chain update costs; long-term identifiers that can support frequent updates; private
- * communication of the DID document; private DID resolution; and non-repudiation appropriate for serious contracts.
+ * did:btcr2 is a censorship-resistant Decentralized Identifier (DID) method using
+ * the Bitcoin blockchain as a Verifiable Data Registry to announce changes to the
+ * DID document. It supports zero-cost off-chain DID creation; aggregated updates
+ * for scalable on-chain update costs; long-term identifiers that can support
+ * frequent updates; private communication of the DID document; private DID resolution;
+ * and non-repudiation.
  *
  * @class DidBtcr2
  * @type {DidBtcr2}
  * @implements {DidMethod}
  */
 export class DidBtcr2 implements DidMethod {
-  /** @type {string} Name of the DID method, as defined in the DID BTCR2 specification */
-  public static methodName: string = 'btcr2';
-
   /**
-   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#create | 4.1 Create}.
-   * See {@link Create} for implementation details.
-   *
-   * A did:btcr2 identifier and associated DID document can either be created deterministically from a cryptographic
-   * seed, or it can be created from an arbitrary genesis intermediate DID document representation. In both cases,
-   * DID creation can be undertaken in an offline manner, i.e., the DID controller does not need to interact with the
-   * Bitcoin network to create their DID.
-   * @param {CreateParams} params See {@link CreateParams} for details.
-   * @param {IdType} params.idType Type of identifier to create (key or external).
-   * @param {KeyBytes} params.pubKeyBytes Public key byte array used to create a btcr2 "key" identifier.
-   * @param {IntermediateDocument} params.intermediateDocument DID Document used to create a btcr2 "external" identifier.
-   * @param {DidCreateOptions} params.options See {@link DidCreateOptions} for create options.
-   * @param {number} params.options.version Version number of the btcr2 method.
-   * @param {string} params.options.network Bitcoin network name (mainnet, testnet, signet, regtest).
-   * @returns {Promise<CreateResponse>} Promise resolving to a CreateResponse object.
-   * @throws {DidBtcr2Error} if any of the checks fail
+   * Name of the DID method, as defined in the DID BTCR2 specification
    */
-  public static async create(params: {
-    idType: 'KEY' | 'EXTERNAL';
-    genesisBytes: KeyBytes | DocumentBytes;
-    options?: DidCreateOptions;
-  }): Promise<Btcr2Identifier> {
-    // Deconstruct the idType and options from the params
-    const { idType, options = {} } = params;
+  static methodName: string = 'btcr2';
 
-    // Deconstruct the version and network from the options, setting defaults if not given
-    const { version = 1, network = 'bitcoin' } = options;
+  /**
+   * Implements section {@link https://dcdpr.github.io/did-btcr2/operations/create.html | 7.1 Create}.
+   * @param {KeyBytes | DocumentBytes} genesisBytes The bytes used to create the genesis document for a did:btcr2 identifier.
+   * This can be either the bytes of the genesis document itself or the bytes of a key that will be used to create the genesis document.
+   * @param {DidCreateOptions} options Options for creating the identifier, including the idType (key or external), version, and network.
+   * @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.
+   * @throws {MethodError} if any of the checks fail
+   */
+  static async create(
+    genesisBytes: KeyBytes | DocumentBytes,
+    options?: DidCreateOptions
+  ): Promise<Btcr2Identifier> {
+    // Deconstruct the idType, version and network from the options, setting defaults if not given
+    const { idType, version = 1, network = 'bitcoin' } = options || {};
 
-    // Set the genesisBytes from the params
-    const genesisBytes = params.genesisBytes;
+    if(!idType) {
+      throw new MethodError(
+        'idType is required for creating a did:btcr2 identifier',
+        INVALID_DID_DOCUMENT, options
+      );
+    }
 
+    // Call identifier encoding algorithm
     return Identifier.encode({ idType, genesisBytes, version, network });
   }
 
   /**
-   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#read | 7.2 Read}.
-   * See {@link Resolve} for implementation details.
+   * 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.
    *
-   * The Read operation is an algorithm consisting of a series of subroutine algorithms executed by a resolver after a
-   * resolution request identifying a specific did:btcr2 identifier is received from a client at Resolution Time. The
-   * request MUST always contain the resolutionOptions object containing additional information to be used in resolution.
-   * This object MAY be empty. See the DID Resolution specification for further details about the DID Resolution Options
-   * object. The resolver then attempts to resolve the DID document of the identifier at a specific Target Time. The
-   * Target Time is either provided in resolutionOptions or is set to the Resolution Time of the request.
+   * 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.
    *
-   * @param {string} identifier a valid did:btcr2 identifier to be resolved
-   * @param {DidResolutionOptions} [resolutionsOptions] see {@link https://www.w3.org/TR/did-1.0/#did-resolution-options | DidResolutionOptions}
-   * @param {number} options.versionId the version of the identifier and/or DID document
-   * @param {number} options.versionTime a timestamp used during resolution as a bound for when to stop resolving
-   * @param {DidDocument} options.sidecarData data necessary for resolving a DID
-   * @param {string} options.network Bitcoin network name (mainnet, testnet, signet, regtest).
-   * @returns {DidResolutionResult} Promise resolving to a DID Resolution Result containing the `targetDocument`
-   * @throws {Error} if the resolution fails for any reason
-   * @throws {DidError} InvalidDid if the identifier is invalid
+   * @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.
    * @example
    * ```ts
-   * const resolution = await DidBtcr2.resolve('did:btcr2:k1q0dygyp3gz969tp46dychzy4q78c2k3js68kvyr0shanzg67jnuez2cfplh')
+   * const resolution = await DidBtcr2.resolve(
+   *  'did:btcr2:k1q0dygyp3gz969tp46dychzy4q78c2k3js68kvyr0shanzg67jnuez2cfplh'
+   * )
    * ```
    */
-  public static async resolve(identifier: string, resolutionsOptions: DidResolutionOptions = {}): Promise<DidResolutionResult> {
+  static async resolve(
+    did: string,
+    resolutionOptions: ResolutionOptions = { drivers: {} }
+  ): Promise<DidResolutionResult> {
     try {
-      // 1. Pass identifier to the did:btcr2 Identifier Decoding algorithm, retrieving idType, version, network, and genesisBytes.
-      // 2. Set identifierComponents to a map of idType, version, network, and genesisBytes.
-      const identifierComponents = Identifier.decode(identifier);
-
-      // Set the network based on the decoded identifier
-      resolutionsOptions.network ??= identifierComponents.network;
-
-      // 3. Set initialDocument to the result of running the algorithm in Resolve Initial Document passing in the
-      //    identifier, identifierComponents and resolutionOptions.
-      const initialDocument = await Resolve.initialDocument({ identifier, identifierComponents, resolutionsOptions });
 
-      // 4. Set targetDocument to the result of running the algorithm in Resolve Target Document passing in
-      //    initialDocument and resolutionOptions.
-      const targetDocument = await Resolve.targetDocument({ initialDocument, resolutionsOptions });
-
-      // 5. Return targetDocument.
+      // Initialize an empty DID Resolution Result
       const didResolutionResult: DidResolutionResult = {
-        '@context'            : W3C_DID_RESOLUTION_V1,
+        '@context'            : 'https://w3id.org/did-resolution/v1',
         didResolutionMetadata : { contentType: 'application/ld+json' },
-        didDocumentMetadata   : { created: new Date().getUTCDateTime() },
-        didDocument           : targetDocument,
+        didDocumentMetadata   : {
+          deactivated   : false,
+          updated       : undefined,
+          versionId     : resolutionOptions.versionId,
+          confirmations : undefined,
+        },
+        didDocument : null,
       };
 
+      // Decode the did to be resolved
+      const didComponents = Identifier.decode(did);
+
+      // Process sidecar if provided
+      const sidecarData = Resolve.sidecarData(resolutionOptions.sidecar);
+
+      // Check if bitcoin driver provided
+      if(!resolutionOptions?.drivers?.bitcoin) {
+        // If not, initialize default drivers
+        resolutionOptions.drivers = resolutionOptions.drivers || {};
+        // Set bitcoin driver to default BitcoinNetworkConnection
+        resolutionOptions.drivers.bitcoin = new BitcoinNetworkConnection();
+        // Set the network based on the decoded identifier
+        resolutionOptions.drivers.bitcoin.setActiveNetwork(didComponents.network);
+      }
+
+      // Parse the genesis document from the resolution options if provided
+      const genesisDocument = resolutionOptions.sidecar?.genesisDocument;
+      // Since genesisDocument is optional, check if it exists
+      if(!genesisDocument) {
+        // If no genesisDocument and x HRP, throw MISSING_UPDATE_DATA error
+        if(didComponents.hrp === IdentifierHrp.x)
+          throw new ResolveError(
+            'External resolution requires genesisDocument',
+            MISSING_UPDATE_DATA, { resolutionOptions }
+          );
+      }
+
+      // Establish the current document
+      const currentDocument = await Resolve.currentDocument(didComponents, genesisDocument);
+
+      // Extract all Beacon services from the current DID Document
+      const beaconServices = currentDocument.service
+        .filter(BeaconUtils.isBeaconService)
+        .map(BeaconUtils.parseBeaconServiceEndpoint);
+
+      console.log('beaconServices', beaconServices);
+
+      // Process the Beacon Signals to get the required updates
+      const unsortedUpdates = await Resolve.beaconSignals(
+        beaconServices,
+        sidecarData,
+        resolutionOptions.drivers.bitcoin
+      );
+      console.log('unsortedUpdates', unsortedUpdates);
+
+      // If no updates found, return the current document
+      if(!unsortedUpdates.length) {
+        // Set the current document in the didResolutionResult
+        didResolutionResult.didDocument = currentDocument;
+
+        // Set the deactivated status in the didDocumentMetadata
+        didResolutionResult.didDocumentMetadata.deactivated = !!currentDocument.deactivated;
+
+        // Return the didResolutionResult early
+        return didResolutionResult;
+      }
+
+      // Process the updates to apply updates to bring the current DID Document to its more current state
+      const result = await Resolve.updates(
+        currentDocument,
+        unsortedUpdates,
+        resolutionOptions.versionTime,
+        resolutionOptions.versionId
+      );
+
+      // Set all of the required fields in the didResolutionResult
+      didResolutionResult.didDocument = result.currentDocument;
+      didResolutionResult.didDocumentMetadata.confirmations = result.confirmations;
+      didResolutionResult.didDocumentMetadata.versionId = result.versionId;
+      didResolutionResult.didDocumentMetadata.deactivated = !!result.currentDocument.deactivated;
+
       // Return didResolutionResult;
       return didResolutionResult;
     } catch (error: any) {
       console.error(error);
-      // Rethrow any unexpected errors that are not a `DidError`.
-      if (!(error instanceof DidError)) throw new Error(error);
+      // Rethrow any unexpected errors that are not a `ResolveError`.
+      if (!(error instanceof ResolveError)) throw new Error(error);
 
       // Return a DID Resolution Result with the appropriate error code.
       return {
         ...EMPTY_DID_RESOLUTION_RESULT,
         didResolutionMetadata : {
-          error : error.code,
+          error : error.type,
           ...error.message && { errorMessage: error.message }
         }
       };
@@ -156,92 +231,118 @@ export class DidBtcr2 implements DidMethod {
   }
 
   /**
-   * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#update | 4.3 Update}.
-   * See {@link Update} for implementation details.
+   * 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}.
+   * See {@link Update | Update (class)} for class implementation.
    *
-   * An update to a did:btcr2 document is an invoked capability using the ZCAP-LD data format, signed by a
-   * verificationMethod that has the authority to make the update as specified in the previous DID document. Capability
-   * invocations for updates MUST be authorized using Data Integrity following the bip340-jcs-2025
-   * cryptosuite with a proofPurpose of capabilityInvocation.
-   *
-   * The Update algorithm takes as inputs a Identifier, sourceDocument, sourceVersionId, documentPatch, a
-   * verificationMethodId and an array of beaconIds. The sourceDocument is the DID document being updated. The
-   * documentPatch is a JSON Patch object containing a set of transformations to be applied to the sourceDocument.
-   * The result of these transformations MUST produce a DID document conformant to the DID Core specification. The
-   * verificationMethodId is an identifier for a verificationMethod within the sourceDocument. The verificationMethod
-   * identified MUST be a BIP340 Multikey. The beaconIds MUST identify service endpoints with one of the three Beacon
-   * Types SingletonBeacon, CIDAggregateBeacon, and SMTAggregateBeacon.
-   *
-   * @param {UpdateParams} params Required parameters for the update operation.
-   * @param {string} params.identifier The btcr2 identifier to be updated.
-   * @param {DidDocument} params.sourceDocument The DID document being updated.
-   * @param {string} params.sourceVersionId The versionId of the source document.
-   * @param {PatchOperation} params.documentPatch The JSON patch to be applied to the source document.
-   * @param {string} params.verificationMethodId The verificationMethod ID to sign the update
-   * @param {string[]} params.beaconIds The beacon IDs to announce the update
-   * @returns {Promise<void>} Promise resolving to void
-   * @throws {MethodError} if the verificationMethod type is not `Multikey` or the publicKeyMultibase header is not `zQ3s`
+   * BTCR2 DID documents can be updated by anchoring BTCR2 Updates to Bitcoin transactions. These transactions MAY be
+   * published to the Bitcoin network. Any property in the DID document may be updated except the id. Doing so would
+   * invalidate the DID document.
+   * @param params An object containing the parameters for the update operation.
+   * @param {Btcr2DidDocument} params.sourceDocument The DID document being updated.
+   * @param {PatchOperation[]} params.patches The array of JSON Patch operations to apply to the sourceDocument.
+   * @param {string} params.sourceVersionId The version ID before applying the update.
+   * @param {string} params.verificationMethodId The verificationMethod ID to sign the update with.
+   * @param {string} params.beaconId The beacon ID associated with the update.
+   * @param {KeyBytes | HexString} [params.signingMaterial] Optional signing material (key bytes or hex string).
+   * @param {BitcoinNetworkConnection} [params.bitcoin] Optional Bitcoin network connection for announcing the update. If not provided, a default connection will be initialized.
+   * @return {Promise<SignedBTCR2Update>} Promise resolving to the signed BTCR2 update.
+   * @throws {UpdateError} if no verificationMethod, verificationMethod type is not `Multikey` or the publicKeyMultibase
+   * header is not `zQ3s`
    */
-  public static async update(params: {
-    identifier: string;
-    sourceDocument: DidDocument;
+  static async update({
+    sourceDocument,
+    patches,
+    sourceVersionId,
+    verificationMethodId,
+    beaconId,
+    signingMaterial,
+    bitcoin,
+  }: {
+    sourceDocument: Btcr2DidDocument;
+    patches: PatchOperation[];
     sourceVersionId: number;
-    patch: PatchOperation[];
     verificationMethodId: string;
-    beaconIds: string[];
-  }): Promise<SignalsMetadata> {
-    // Deconstruct the params
-    const {
-      identifier,
-      sourceDocument,
-      sourceVersionId,
-      patch,
-      verificationMethodId: methodId,
-      beaconIds,
-    } = params;
-
-    // 1. Set unsignedUpdate to the result of passing Identifier, sourceDocument,
-    //    sourceVersionId, and documentPatch into the Construct DID Update
-    //    Payload algorithm.
-    const didUpdatePayload = await Update.construct({
-      identifier,
-      sourceDocument,
-      sourceVersionId,
-      patch,
-    });
-
-    // 2. Set verificationMethod to the result of retrieving the verificationMethod
-    //    from sourceDocument using the verificationMethodId.
-    const verificationMethod = this.getSigningMethod({ didDocument: sourceDocument, methodId, });
+    beaconId: string;
+    signingMaterial?: KeyBytes | HexString;
+    bitcoin?: BitcoinNetworkConnection;
+  }): Promise<SignedBTCR2Update> {
+    // TODO: provide KMS as alternative
+    // If no signingMaterial provided, throw an UpdateError with INVALID_DID_UPDATE.
+    if (!signingMaterial) {
+      throw new UpdateError(
+        'Missing signing material for update',
+        INVALID_DID_UPDATE, {signingMaterial}
+      );
+    }
+
+    // Convert signingMaterial to bytes if it's a hex string
+    const secretKey = typeof signingMaterial === 'string'
+      ? Buffer.from(signingMaterial, 'hex')
+      : signingMaterial;
+
+    // Validate that the verificationMethodId is authorized for capabilityInvocation
+    if(!sourceDocument.capabilityInvocation?.some(vr => vr === verificationMethodId)) {
+      throw new UpdateError(
+        'Invalid verificationMethodId: not authorized for capabilityInvocation',
+        INVALID_DID_DOCUMENT, sourceDocument
+      );
+    }
+
+    // Get the verification method to be used for signing the update
+    const verificationMethod = this.getSigningMethod(sourceDocument, verificationMethodId);
 
     // Validate the verificationMethod exists in the sourceDocument
     if (!verificationMethod) {
-      throw new MethodError('Verification method not found in did document', INVALID_DID_DOCUMENT, sourceDocument);
+      throw new UpdateError(
+        'Invalid verificationMethod: not found in source document',
+        INVALID_DID_DOCUMENT, {sourceDocument, verificationMethodId}
+      );
     }
 
-    // 3. Validate the verificationMethod is a BIP340 Multikey:
-    //    3.1 verificationMethod.type == Multikey
+    // Validate the verificationMethod is of type 'Multikey'
     if (verificationMethod.type !== 'Multikey') {
-      throw new MethodError('Invalid type: must be type "Multikey"', INVALID_DID_DOCUMENT, verificationMethod);
+      throw new UpdateError(
+        'Invalid verificationMethod: verificationMethod.type must be "Multikey"',
+        INVALID_DID_DOCUMENT, verificationMethod
+      );
     }
 
-    //    3.2 verificationMethod.publicKeyMultibase[4] == zQ3s
-    const mbasePrefix = verificationMethod.publicKeyMultibase?.slice(0, 4);
-    if (mbasePrefix !== 'zQ3s') {
-      throw new MethodError(`Invalid publicKeyMultibase prefix ${mbasePrefix}`, INVALID_DID_DOCUMENT, verificationMethod);
+    // Validate the publicKeyMultibase prefix is 'zQ3s'
+    if (verificationMethod.publicKeyMultibase?.slice(0, 4) !== 'zQ3s') {
+      throw new UpdateError(
+        'Invalid verificationMethodId: publicKeyMultibase prefix must start with "zQ3s"',
+        INVALID_DID_DOCUMENT, verificationMethod
+      );
     }
 
-    // 4. Set didUpdateInvocation to the result of passing Identifier, unsignedUpdate as didUpdatePayload, and
-    //    verificationMethod to the Invoke DID Update Payload algorithm.
-    const didUpdateInvocation = await Update.invoke({ identifier, verificationMethod, didUpdatePayload, });
+    // Construct an unsigned update following the BTCR2 Update construction algorithm
+    const update = await Update.construct(sourceDocument, patches, sourceVersionId);
+
+    // Sign the unsigned update using the specified verification method
+    const signed = await Update.sign(sourceDocument.id, update, verificationMethod, secretKey);
 
-    // 5. Set signalsMetadata to the result of passing Identifier, sourceDocument, beaconIds and didUpdateInvocation
-    //    to the Announce DID Update algorithm.
-    const signalsMetadata = await Update.announce({ sourceDocument, beaconIds, didUpdateInvocation, });
+    // Filter sourceDocument services to get beaconServices matching beaconIds
+    const beaconService = sourceDocument.service
+      .filter((service: BeaconService) => service.id === beaconId)
+      .filter((service: BeaconService): service is BeaconService => !!service)
+      .shift();
 
-    // 6. Return signalsMetadata. It is up to implementations to ensure that the signalsMetadata is persisted.
-    return signalsMetadata;
-    // TODO: Should we be applying the patch, producing a target did document and returning it?
+    // If no matching beacon service found, throw an UpdateError with INVALID_DID_UPDATE.
+    if(!beaconService) {
+      throw new UpdateError(
+        'No beacon service found for provided beaconId',
+        INVALID_DID_UPDATE, {sourceDocument, beaconId}
+      );
+    }
+    // If no bitcoin network connection provided, initialize default
+    bitcoin ??= new BitcoinNetworkConnection();
+
+    // Announce the signed update to the blockchain using the specified beacon(s)
+    // await Update.announce(beaconService, signed, secretKey, bitcoin);
+
+    // Return signed update if announced successfully
+    return signed;
   }
 
   /**
@@ -249,17 +350,12 @@ export class DidBtcr2 implements DidMethod {
    * for signing messages and credentials. If given, the `methodId` parameter is used to select the
    * verification method. If not given, the Identity Key's verification method with an ID fragment
    * of '#initialKey' is used.
-   *
-   * @param {{ didDocument: DidDocument; methodId?: string; }} params Parameters for the `getSigningMethod` method.
-   * @param {DidDocument} params.didDocument DID Document to get the verification method from.
-   * @param {string} params.methodId Optional ID of the verification method to use for signing.
+   * @param {Btcr2DidDocument} didDocument The DID Document of the `did:btcr2` identifier.
+   * @param {string} [methodId] Optional verification method ID to be used for signing.
    * @returns {DidVerificationMethod} Promise resolving to the {@link DidVerificationMethod} object used for signing.
    * @throws {DidError} if the parsed did method does not match `btcr2` or signing method could not be determined.
    */
-  public static getSigningMethod({ didDocument, methodId }: {
-    didDocument: DidDocument;
-    methodId?: string;
-  }): DidVerificationMethod {
+  static getSigningMethod(didDocument: Btcr2DidDocument,  methodId?: string): DidVerificationMethod {
     // Set the default methodId to the first assertionMethod if not given
     methodId ??= '#initialKey';
 

package/src/index.ts

@@ -1,54 +1,51 @@
+export * from './core/beacon/aggregation/cohort/index.js';
+export * from './core/beacon/aggregation/cohort/status.js';
+
+export * from './core/beacon/aggregation/cohort/messages/base.js';
+export * from './core/beacon/aggregation/cohort/messages/constants.js';
+export * from './core/beacon/aggregation/cohort/messages/index.js';
+export * from './core/beacon/aggregation/cohort/messages/keygen//subscribe.js';
 export * from './core/beacon/aggregation/cohort/messages/keygen/cohort-advert.js';
 export * from './core/beacon/aggregation/cohort/messages/keygen/cohort-ready.js';
 export * from './core/beacon/aggregation/cohort/messages/keygen/opt-in-accept.js';
 export * from './core/beacon/aggregation/cohort/messages/keygen/opt-in.js';
-export * from './core/beacon/aggregation/cohort/messages/keygen//subscribe.js';
-
 export * from './core/beacon/aggregation/cohort/messages/sign/aggregated-nonce.js';
 export * from './core/beacon/aggregation/cohort/messages/sign/authorization-request.js';
 export * from './core/beacon/aggregation/cohort/messages/sign/nonce-contribution.js';
 export * from './core/beacon/aggregation/cohort/messages/sign/request-signature.js';
 export * from './core/beacon/aggregation/cohort/messages/sign/signature-authorization.js';
 
-export * from './core/beacon/aggregation/cohort/messages/base.js';
-export * from './core/beacon/aggregation/cohort/messages/constants.js';
-export * from './core/beacon/aggregation/cohort/messages/index.js';
-
-export * from './core/beacon/aggregation/cohort/index.js';
-export * from './core/beacon/aggregation/cohort/status.js';
-
 export * from './core/beacon/aggregation/communication/adapter/did-comm.js';
 export * from './core/beacon/aggregation/communication/adapter/nostr.js';
+
 export * from './core/beacon/aggregation/communication/error.js';
 export * from './core/beacon/aggregation/communication/factory.js';
 export * from './core/beacon/aggregation/communication/service.js';
 
-export * from './core/beacon/aggregation/session/index.js';
-export * from './core/beacon/aggregation/session/status.js';
-
 export * from './core/beacon/aggregation/coordinator.js';
 export * from './core/beacon/aggregation/participant.js';
+export * from './core/beacon/aggregation/session/index.js';
+export * from './core/beacon/aggregation/session/status.js';
 
-export * from './core/beacon/cid-aggregate.js';
+export * from './core/beacon/beacon.js';
+export * from './core/beacon/cas-beacon.js';
 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/smt-aggregate.js';
+export * from './core/beacon/smt-beacon.js';
 export * from './core/beacon/utils.js';
 
-export * from './core/crud/deactivate.js';
-export * from './core/crud/read.js';
-export * from './core/crud/update.js';
-
 export * from './core/identifier.js';
-
-export * from './interfaces/beacon.js';
-export * from './interfaces/crud.js';
+export * from './core/interfaces.js';
+export * from './core/resolve.js';
+export * from './core/types.js';
+export * from './core/update.js';
 
 export * from './utils/appendix.js';
 export * from './utils/did-document-builder.js';
 export * from './utils/did-document.js';
 export * from './utils/general.js';
-export * from './utils/types.js';
 
 export * from './did-btcr2.js';