@did-btcr2/method 0.13.1

package/dist/types/btcr2/key-manager/index.d.ts

@@ -0,0 +1,145 @@
+import { HashBytes, Hex, SchnorrKeyPairObject, KeyBytes, SignatureBytes } from '@did-btcr2/common';
+import { SchnorrMultikey } from '@did-btcr2/cryptosuite';
+import { SchnorrKeyPair, PublicKey } from '@did-btcr2/keypair';
+import { KeyIdentifier } from '@web5/crypto';
+import { Multibase } from 'multiformats';
+import { AvailableNetworks } from '../../bitcoin/index.js';
+import { BitcoinSigner, Btc1KeyManagerOptions, CryptoSigner, KeyManager, KeyManagerParams } from './interface.js';
+export interface Btc1Signer {
+    multikey: SchnorrMultikey;
+    network: keyof AvailableNetworks;
+}
+/**
+ * Class for managing cryptographic keys for the B DID method.
+ * @class Btc1KeyManager
+ * @type {Btc1KeyManager}
+ */
+export declare class Btc1KeyManager implements KeyManager, CryptoSigner, BitcoinSigner {
+    #private;
+    /**
+     * The `activeKeyUri` property is a string that represents the URI of the currently active key.
+     * It is used to identify the key that will be used for signing and verifying operations.
+     * This property is optional and can be set to a specific key URI when initializing the
+     * `Btc1KeyManager` instance. If not set, the key manager will use the default key URI.
+     * @type {KeyIdentifier}
+     */
+    activeKeyUri?: KeyIdentifier;
+    /**
+     * The `_store` private variable in `Btc1KeyManager` is a `KeyValueStore` instance used for
+     * storing and managing cryptographic keys. It allows the `Btc1KeyManager` class to save,
+     * retrieve, and handle keys efficiently within the local Key Management System (KMS) context.
+     * This variable can be configured to use different storage backends, like in-memory storage or
+     * persistent storage, providing flexibility in key management according to the application's
+     * requirements.
+     * @private
+     * @readonly
+     * @type {KeyValueStore<KeyIdentifier, SchnorrKeyPair>} The key store for managing cryptographic keys.
+     */
+    private readonly _store;
+    /**
+     * Creates an instance of Btc1KeyManager.
+     * @param {?KeyManagerParams} params The parameters to initialize the key manager.
+     * @param {KeyValueStore<KeyIdentifier, SchnorrMultikey>} params.store An optional property to specify a custom
+     * `KeyValueStore` instance for key management. If not provided, {@link Btc1KeyManager} uses a default `MemoryStore`
+     * instance. This store is responsible for managing cryptographic keys, allowing them to be retrieved, stored, and
+     * managed during cryptographic operations.
+     * @param {KeyIdentifier} params.keyUri An optional property to specify the active key URI for the key manager.
+     */
+    constructor({ store, keyUri, keys }?: KeyManagerParams);
+    /**
+     * Gets the singleton instance of the Btc1KeyManager.
+     * @returns {Btc1KeyManager} The singleton instance of the Btc1KeyManager.
+     */
+    static get instance(): Btc1KeyManager;
+    /**
+     * Signs a transaction using the key associated with the key URI.
+     * @param {Hex} txHex The transaction hex to sign.
+     * @param {KeyIdentifier} keyUri The URI of the key to sign the transaction with.
+     * @returns {Promise<Hex>} A promise resolving to the signed transaction hex.
+     */
+    signTransaction(txHex: Hex, keyUri?: KeyIdentifier): Promise<Hex>;
+    /**
+     * Gets the key pair from the key store and returns a PublicKey.
+     * @param {KeyIdentifier} keyUri The URI of the key to get the public key for.
+     * @returns {Promise<PublicKey>} The public key associated with the key URI.
+     */
+    getPublicKey(keyUri?: KeyIdentifier): Promise<PublicKey>;
+    /**
+     * Signs the given data using the key associated with the key URI.
+     * @param {Hex} data The data to sign.
+     * @param {?KeyIdentifier} keyUri The URI of the key to sign the data with.
+     * @returns {Promise<SignatureBytes>} A promise resolving to the signature of the data.
+     */
+    sign(data: Hex, keyUri?: KeyIdentifier): Promise<SignatureBytes>;
+    /**
+     * Verifies a signature using the key associated with the key URI.
+     * @param {KeyIdentifier} keyUri The URI of the key to verify the signature with.
+     * @param {SignatureBytes} signature The signature to verify.
+     * @param {Hex} data The data to verify the signature with.
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating the verification result.
+     */
+    verify(signature: SignatureBytes, data: Hex, keyUri?: KeyIdentifier): Promise<boolean>;
+    /**
+     * Gets the key pair from the key store.
+     * @param {KeyIdentifier} keyUri The URI of the key to get.
+     * @returns {Promise<SchnorrKeyPair>} The key pair associated with the key URI.
+     * @throws {Btcr2KeyManagerError} If the key is not found in the key store.
+     */
+    private getKey;
+    /**
+     * Exports the full multikeypair from the key store.
+     * @returns {Promise<SchnorrKeyPair>} The key pair associated with the key URI.
+     * @throws {Btcr2KeyManagerError} If the key is not found in the key store.
+     */
+    exportKey(keyUri?: KeyIdentifier): Promise<SchnorrMultikey | undefined>;
+    /**
+     * Imports a keypair to the store.
+     * @param {SchnorrKeyPair} keys The keypair to import.
+     * @param {KeyIdentifier} keyUri The URI of the key to import.
+     * @param {Btc1KeyManagerOptions} options Relevant import options.
+     * @param {boolean} options.active A flag to set the key as active (optional, default: false).
+     * @returns {Promise<KeyIdentifier>} A promise that resolves to the key identifier of the imported key.
+     */
+    importKey(keys: SchnorrKeyPair, keyUri: string, options?: Btc1KeyManagerOptions): Promise<KeyIdentifier>;
+    /**
+     * Computes the hash of the given data.
+     * @param {Uint8Array} data The data to hash.
+     * @returns {HashBytes} The hash of the data.
+     */
+    digest(data: Uint8Array): HashBytes;
+    /**
+     * Computes the key URI of a given keypair.
+     * @param {string} id The fragment identifier (e.g. 'key-1').
+     * @param {string} [controller] The DID controller (e.g. 'did:btcr2:xyz').
+     * @returns {KeyIdentifier} A full DID fragment URI (e.g. 'did:btcr2:xyz#key-1')
+     */
+    static computeKeyUri(id: string, controller: string): KeyIdentifier;
+    /**
+     * Computes a multibase-compliant URI from a key.
+     * @param key A SchnorrKeyPair, PublicKey, or multibase string
+     * @returns {string} A multibase URI (e.g. 'urn:mb:zQ3s...')
+     */
+    static toMultibaseUri(data: SchnorrKeyPair | PublicKey | Multibase<'zQ3s'>): string;
+    /**
+     * Initializes a singleton Btc1KeyManager instance.
+     * @param {SchnorrKeyPair} keys The keypair used to initialize the key manager.
+     * @returns {void}
+     */
+    static initialize(keys: SchnorrKeyPair | SchnorrKeyPairObject, keyUri: string): Promise<Btc1KeyManager>;
+    /**
+     * Retrieves a keypair from the key store using the provided key URI.
+     * @public
+     * @param {KeyIdentifier} keyUri The URI of the keypair to retrieve.
+     * @returns {Promise<SchnorrKeyPair | undefined>} The retrieved keypair, or undefined if not found.
+     */
+    static getKeyPair(keyUri?: KeyIdentifier): Promise<SchnorrMultikey | undefined>;
+    getKeySigner(keyUri: KeyIdentifier, network: keyof AvailableNetworks): Promise<Signer>;
+}
+export declare class Signer {
+    multikey: SchnorrMultikey;
+    network: keyof AvailableNetworks;
+    constructor(params: Btc1Signer);
+    get publicKey(): KeyBytes;
+    sign(hash: Hex): SignatureBytes;
+    signSchnorr(hash: Hex): SignatureBytes;
+}

package/dist/types/btcr2/key-manager/index.d.ts.map

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

package/dist/types/btcr2/key-manager/interface.d.ts

@@ -0,0 +1,113 @@
+import { HashBytes, Hex, SignatureBytes } from '@did-btcr2/common';
+import { Multikey, SchnorrMultikey } from '@did-btcr2/cryptosuite';
+import { SchnorrKeyPair, PublicKey } from '@did-btcr2/keypair';
+import { KeyValueStore } from '@web5/common';
+export type Btc1KeyManagerOptions = {
+    importKey?: boolean;
+    active?: boolean;
+};
+/** Alias type for Btc1KeyManager keyUri */
+export type KeyIdentifier = string;
+/** Params for initializing a Btc1KeyManager class instance. */
+export type KeyManagerParams = {
+    /**
+     * An optional property to specify a custom `KeyValueStore` instance for key management. If not
+     * provided, {@link Btc1KeyManager | `Btc1KeyManager`} uses a default `MemoryStore` instance.
+     * This store is responsible for managing cryptographic keys, allowing them to be retrieved,
+     * stored, and managed during cryptographic operations.
+     * @type {KeyValueStore<KeyIdentifier, KeyPair>}
+     */
+    store?: KeyValueStore<KeyIdentifier, SchnorrMultikey>;
+    /**
+     * An optional property to specify a key URI for the key manager. If not provided, the key manager
+     * will generate a key URI based on the public key of the key pair.
+     * @type {KeyIdentifier}
+     */
+    keyUri?: KeyIdentifier;
+    /**
+     * An optional property to specify the DID contoller id.
+     * @type {string}
+     */
+    id?: string;
+    /**
+     * An optional property to specify the DID controller.\
+     * @type {string}
+     */
+    controller?: string;
+    /**
+     * An optional property to pass in an initial key pair
+     * @type {SchnorrKeyPair}
+     */
+    keys?: SchnorrKeyPair;
+};
+export type GenerateKeyParams = {
+    id: string;
+    controller: string;
+    options: Btc1KeyManagerOptions;
+};
+/**
+ * The interface for the Btc1KeyManager class.
+ * @interface KeyManager
+ * @type {KeyManager}
+ */
+export interface KeyManager {
+    /**
+     * The URI of the active key.
+     * @type {KeyIdentifier}
+     */
+    activeKeyUri?: KeyIdentifier;
+    /**
+     * Exports the full key pair from the key store.
+     * @param {KeyIdentifier} keyUri The URI of the key to export.
+     * @returns {Promise<Multikey | undefined>} The key pair associated with the key URI.
+     * @throws {Btc1KeyManagerError} If the key is not found in the key store.
+     */
+    exportKey(keyUri?: KeyIdentifier): Promise<Multikey | undefined>;
+    /**
+     * Gets the public key of a key pair.
+     * @param {KeyIdentifier} keyUri The URI of the key to get the public key for.
+     * @returns {Promise<PublicKey>} The public key of the key pair.
+     */
+    getPublicKey(keyUri: KeyIdentifier): Promise<PublicKey>;
+    /**
+     * Imports a key pair into the key store.
+     * @param {SchnorrKeyPair} keyPair The key pair to import.
+     * @param {string} keyUri The full DID controller + fragment identifier (e.g. 'did:btcr2:xyz#key-1').
+     * @param {Btc1KeyManagerOptions} options The options for importing the key pair.
+     * @param {boolean} options.active Whether to set the imported key as active.
+     * @returns {Promise<KeyIdentifier>} A promise that resolves to the key identifier of the imported key.
+     */
+    importKey(keyPair: SchnorrKeyPair, keyUri: string, options: Btc1KeyManagerOptions): Promise<KeyIdentifier>;
+}
+export interface CryptoSigner {
+    /**
+     * Signs a message with a key pair.
+     * @param {Hex} data The data to sign.
+     * @param {?KeyIdentifier} keyUri The URI of the key to sign the data with.
+     * @returns {Promise<SignatureBytes>} The signature of the input data.
+     */
+    sign(data: Hex, keyUri?: KeyIdentifier): Promise<SignatureBytes>;
+    /**
+     * Verifies if a signature was produced by a key pair.
+     * @param {SignatureBytes} signature The signature to verify.
+     * @param {Hex} data The data that was signed.
+     * @param {?KeyIdentifier} keyUri The URI of the key to use for verification.
+     * @returns {Promise<boolean>} A promise that resolves if the signature is valid, and rejects otherwise.
+     */
+    verify(signature: SignatureBytes, data: Hex, keyUri?: KeyIdentifier): Promise<boolean>;
+    /**
+     * Returns the sha256 hash of the input data.
+     * @param {Uint8Array} data The data to hash.
+     * @returns {HashBytes} The sha256 hash of the input data.
+     */
+    digest(data: Uint8Array): HashBytes;
+}
+export interface BitcoinSigner {
+    /**
+     * Signs a Bitcoin transaction with a key pair.
+     * @param txHex The hex-encoded transaction to sign.
+     * @param keyUri The URI of the key to sign the transaction with.
+     * @returns {Promise<Hex>} A promise that resolves to the hex-encoded signed transaction.
+     */
+    signTransaction(txHex: Hex, keyUri?: KeyIdentifier): Promise<Hex>;
+}

package/dist/types/btcr2/key-manager/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/key-manager/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAC;AAEF,2CAA2C;AAC3C,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,+DAA+D;AAC/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;IAEtD;;;;OAIG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IAEvB;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,qBAAqB,CAAA;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC;IAE7B;;;;;OAKG;IACH,SAAS,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;IAEjE;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAExD;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC9G;AAED,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEjE;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEvF;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACnE"}

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

@@ -0,0 +1,117 @@
+import { PatchOperation } from '@did-btcr2/common';
+import type { DidResolutionResult } from '@web5/dids';
+import { DidMethod } from '@web5/dids';
+import { Btc1CreateParams, Btc1CreateResponse } from './btcr2/crud/create.js';
+import { DidResolutionOptions } from './interfaces/crud.js';
+import { Btc1DidDocument, Btc1VerificationMethod } from './utils/did-document.js';
+/**
+ * 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.
+ *
+ * @class DidBtc1
+ * @type {DidBtc1}
+ *
+ */
+export declare class DidBtc1 implements DidMethod {
+    /** @type {string} Name of the DID method, as defined in the DID BTCR2 specification */
+    static methodName: string;
+    /**
+     * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#create | 4.1 Create}.
+     * See {@link Btc1Create} 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 {Btc1CreateParams} params See {@link Btc1CreateParams} 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 {DidBtc1Error} if any of the checks fail
+     */
+    static create(params: Btc1CreateParams): Promise<Btc1CreateResponse>;
+    /**
+     * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#read | 7.2 Read}.
+     * See {@link Btc1Read} for implementation details.
+     *
+     * 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.
+     *
+     * @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 {Btc1DidDocument} 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
+     * @example
+     * ```ts
+     * const resolution = await DidBtc1.resolve('did:btcr2:k1q0dygyp3gz969tp46dychzy4q78c2k3js68kvyr0shanzg67jnuez2cfplh')
+     * ```
+     */
+    static resolve(identifier: string, resolutionsOptions?: DidResolutionOptions): Promise<DidResolutionResult>;
+    /**
+     * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#update | 4.3 Update}.
+     * See {@link Btc1Update} for implementation details.
+     *
+     * 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 btc1Identifier, 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 {Btc1UpdateParams} params Required parameters for the update operation.
+     * @param {string} params.identifier The btcr2 identifier to be updated.
+     * @param {Btc1DidDocument} params.sourceDocument The DID document being updated.
+     * @param {string} params.sourceVersionId The versionId of the source document.
+     * @param {Btc1DocumentPatch} 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 {Btcr2Error} if the verificationMethod type is not `Multikey` or the publicKeyMultibase header is not `zQ3s`
+     */
+    static update(params: {
+        identifier: string;
+        sourceDocument: Btc1DidDocument;
+        sourceVersionId: number;
+        patch: PatchOperation[];
+        verificationMethodId: string;
+        beaconIds: string[];
+    }): Promise<any>;
+    /**
+     * Given the W3C DID Document of a `did:btcr2` identifier, return the signing verification method that will be used
+     * 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: Btc1DidDocument; 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.
+     * @returns {Btc1VerificationMethod} Promise resolving to the {@link Btc1VerificationMethod} object used for signing.
+     * @throws {DidError} if the parsed did method does not match `btcr2` or signing method could not be determined.
+     */
+    static getSigningMethod({ didDocument, methodId }: {
+        didDocument: Btc1DidDocument;
+        methodId?: string;
+    }): Btc1VerificationMethod;
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"did-btcr2.d.ts","sourceRoot":"","sources":["../../src/did-btcr2.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAIL,SAAS,EAEV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAc,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG1F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAMlF;;;;;;;;;;GAUG;AACH,qBAAa,OAAQ,YAAW,SAAS;IACvC,uFAAuF;IACvF,OAAc,UAAU,EAAE,MAAM,CAAW;IAE3C;;;;;;;;;;;;;;;;;OAiBG;WACiB,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA0BjF;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,kBAAkB,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAwC5H;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;WACiB,MAAM,CAAC,MAAM,EAAE;QACjC,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,eAAe,CAAC;QAChC,eAAe,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE,cAAc,EAAE,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,GAAG,OAAO,CAAC,GAAG,CAAC;IAuDhB;;;;;;;;;;;OAWG;WACW,gBAAgB,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE;QACxD,WAAW,EAAE,eAAe,CAAC;QAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,sBAAsB;CA0B3B"}

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+export * from './bitcoin/constants.js';
+export * from './bitcoin/interface.js';
+export * from './bitcoin/network.js';
+export * from './bitcoin/rpc-client.js';
+export * from './btcr2/beacon/cid-aggregate.js';
+export * from './btcr2/beacon/factory.js';
+export * from './btcr2/beacon/singleton.js';
+export * from './btcr2/beacon/smt-aggregate.js';
+export * from './btcr2/crud/create.js';
+export * from './btcr2/crud/deactivate.js';
+export * from './btcr2/crud/read.js';
+export * from './btcr2/crud/update.js';
+export * from './btcr2/key-manager/index.js';
+export * from './btcr2/key-manager/interface.js';
+export * from './interfaces/beacon.js';
+export * from './interfaces/crud.js';
+export * from './interfaces/ibeacon.js';
+export * from './types/bitcoin.js';
+export * from './types/crud.js';
+export * from './utils/appendix.js';
+export * from './utils/beacons.js';
+export * from './utils/did-document-builder.js';
+export * from './utils/did-document.js';
+export * from './utils/general.js';
+export * from './utils/identifier.js';
+export * from './did-btcr2.js';

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AAExC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAEhD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AAExC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAEhC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,gBAAgB,CAAC"}

package/dist/types/interfaces/beacon.d.ts

@@ -0,0 +1,57 @@
+import { DidUpdatePayload } from '@did-btcr2/common';
+import { DidServiceEndpoint } from '@web5/dids';
+import { RawTransactionRest } from '../bitcoin/rest-client.js';
+import { RawTransactionV2 } from '../types/bitcoin.js';
+import { SidecarData, SignalsMetadata } from '../types/crud.js';
+import { BeaconService, BeaconSignal, IBeacon } from './ibeacon.js';
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#update-beacons | 5. Beacons}.
+ * Beacons are the mechanism by which a DID controller announces an update to their DID document by broadcasting an
+ * attestation to this update onto the public Bitcoin network. Beacons are identified by a Bitcoin address and emit
+ * Beacon Signals by broadcasting a valid Bitcoin transaction that spends from this Beacon address. These transactions
+ * include attestations to a set of didUpdatePayloads, either in the form of Content Identifiers (CIDs) or Sparse Merkle
+ * Tree (SMT) roots. Beacons are included as a service in DID documents, with the Service Endpoint identifying a Bitcoin
+ * address to watch for Beacon Signals. All Beacon Signals broadcast from this Beacon MUST be processed as part of
+ * resolution (see Read). The type of the Beacon service in the DID document defines how Beacon Signals SHOULD be
+ * processed.
+ * did:btcr2 supports different Beacon Types, with each type defining a set of algorithms for:
+ *  1. How a Beacon can be established and added as a service to a DID document.
+ *  2. How attestations to DID updates are broadcast within Beacon Signals.
+ *  3. How a resolver processes a Beacon Signal, identifying, verifying, and applying the authorized mutations to a
+ *     DID document for a specific DID.
+ * This is an extendable mechanism, such that in the future new Beacon Types could be added. It would be up to the
+ * resolver to determine if the Beacon Type is a mechanism they support and are willing to trust. If they are unable to
+ * support a Beacon Type and a DID they are resolving uses that type then the DID MUST be treated as invalid.
+ * The current, active Beacons of a DID document are specified in the document’s service property. By updating the DID
+ * document, a DID controller can change the set of Beacons they can use to broadcast updates to their DID document over
+ * time. Resolution of a DID MUST process signals from all Beacons identified in the latest DID document and apply them
+ * in order determined by the version specified by the didUpdatePayload.
+ * All resolvers of did:btcr2 DIDs MUST support the core Beacon Types defined in this specification.
+ *
+ * @abstract
+ * @class Beacon
+ * @type {Beacon}
+ */
+export declare abstract class Beacon implements IBeacon {
+    id: string;
+    type: string;
+    serviceEndpoint: DidServiceEndpoint;
+    sidecar?: SidecarData;
+    constructor({ id, type, serviceEndpoint }: BeaconService, sidecar?: SidecarData);
+    /**
+     * Returns the Beacon Service object.
+     */
+    abstract get service(): BeaconService;
+    /**
+     * Generates a Beacon Signal (implemented by subclasses).
+     */
+    abstract generateSignal(didUpdatePayload: string): BeaconSignal;
+    /**
+     * Processes a Beacon Signal (implemented by subclasses).
+     */
+    abstract processSignal(signal: RawTransactionRest | RawTransactionV2, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload | undefined>;
+    /**
+     * Broadcasts a Beacon Signal (implemented by subclasses).
+     */
+    abstract broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata>;
+}

package/dist/types/interfaces/beacon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beacon.d.ts","sourceRoot":"","sources":["../../../src/interfaces/beacon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,8BAAsB,MAAO,YAAW,OAAO;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,kBAAkB,CAAC;IACpC,OAAO,CAAC,EAAE,WAAW,CAAC;gBAEjB,EAAE,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,WAAW;IAO/E;;OAEG;IACH,QAAQ,KAAK,OAAO,IAAI,aAAa,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,cAAc,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY;IAE/D;;OAEG;IACH,QAAQ,CAAC,aAAa,CAAC,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAE9I;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;CACvF"}

package/dist/types/interfaces/crud.d.ts

@@ -0,0 +1,35 @@
+import { BitcoinNetworkNames, UnixTimestamp } from '@did-btcr2/common';
+import { DidResolutionOptions as IDidResolutionOptions } from '@web5/dids';
+import BitcoinRpc from '../bitcoin/rpc-client.js';
+import { SidecarData } from '../types/crud.js';
+import { Btc1DidDocument } from '../utils/did-document.js';
+/**
+ * Options for resolving a DID Document
+ * @param {?number} versionId The versionId for resolving the DID Document
+ * @param {?UnixTimestamp} versionTime The versionTime for resolving the DID Document
+ * @param {?BitcoinRpc} rpc BitcoinRpc client connection
+ * @param {?SidecarData} sidecarData The sidecar data for resolving the DID Document
+ */
+export interface DidResolutionOptions extends IDidResolutionOptions {
+    versionId?: number;
+    versionTime?: UnixTimestamp;
+    sidecarData?: SidecarData;
+    network?: BitcoinNetworkNames;
+    rpc?: BitcoinRpc;
+}
+export interface Btc1RootCapability {
+    '@context': string;
+    id: string;
+    controller: string;
+    invocationTarget: string;
+}
+export interface ReadBlockchainParams {
+    contemporaryDidDocument: Btc1DidDocument;
+    contemporaryBlockHeight: number | 1;
+    currentVersionId: number | 1;
+    targetVersionId?: number;
+    targetBlockHeight: number;
+    updateHashHistory: string[];
+    sidecarData?: SidecarData;
+    options?: DidResolutionOptions;
+}

package/dist/types/interfaces/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../src/interfaces/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,oBAAoB,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AACD,MAAM,WAAW,kBAAkB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AACD,MAAM,WAAW,oBAAoB;IACnC,uBAAuB,EAAE,eAAe,CAAC;IACzC,uBAAuB,EAAE,MAAM,GAAG,CAAC,CAAC;IACpC,gBAAgB,EAAE,MAAM,GAAG,CAAC,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC"}

package/dist/types/interfaces/ibeacon.d.ts

@@ -0,0 +1,66 @@
+import { DidUpdatePayload, UnixTimestamp } from '@did-btcr2/common';
+import { DidServiceEndpoint, DidService as IDidService } from '@web5/dids';
+import { RawTransactionV2 } from '../types/bitcoin.js';
+import { SignalsMetadata } from '../types/crud.js';
+import { RawTransactionRest } from '../bitcoin/rest-client.js';
+/**
+ * Beacon interface
+ * @interface IBeacon
+ * @type {IBeacon}
+ */
+export interface IBeacon {
+    /**
+     * A unique identifier for the Beacon
+     * @type {string}
+     */
+    id: string;
+    /**
+     * The type of the Beacon
+     * @type {string}
+     */
+    type: string;
+    /**
+     * The service endpoint of the Beacon
+     * @type {string}
+     */
+    serviceEndpoint: DidServiceEndpoint;
+    /**
+     * Returns the Beacon Service object
+     * @type {BeaconService}
+     */
+    service: BeaconService;
+    /**
+     * Generates a Beacon Signal Transaction
+     * @param {string} didUpdatePayload The DID update payload
+     * @returns {BeaconSignal} The Beacon Signal
+     */
+    generateSignal(didUpdatePayload: string): BeaconSignal;
+    /**
+     * Processes a Beacon Signal.
+     * @param {RawTransactionV2} signal The raw transaction
+     * @param {SidecarData} signalsMetadata The signals metadata from the sidecar data
+     * @returns {Promise<DidUpdatePayload | undefined>} The DID update payload
+     */
+    processSignal(signal: RawTransactionV2, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload | undefined>;
+    /**
+     * Broadcasts a signal.
+     * @param {DidUpdatePayload} didUpdatePayload The DID update payload.
+     * @returns {Promise<SignalMetadata>} The signal metadata.
+     */
+    broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata>;
+}
+export interface BeaconService extends IDidService {
+    serviceEndpoint: DidServiceEndpoint;
+    casType?: string;
+}
+export interface BeaconServiceAddress extends BeaconService {
+    address: string;
+}
+export interface BeaconSignal {
+    beaconId: string;
+    beaconType: string;
+    beaconAddress: string;
+    tx: RawTransactionRest | RawTransactionV2;
+    blockheight: number;
+    blocktime: UnixTimestamp;
+}

package/dist/types/interfaces/ibeacon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibeacon.d.ts","sourceRoot":"","sources":["../../../src/interfaces/ibeacon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACpB;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,eAAe,EAAE,kBAAkB,CAAC;IAEpC;;;OAGG;IACH,OAAO,EAAE,aAAa,CAAC;IAEvB;;;;OAIG;IACH,cAAc,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY,CAAC;IAEvD;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;IAGjH;;;;OAIG;IACH,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CACjF;AAED,MAAM,WAAW,aAAc,SAAQ,WAAW;IAC9C,eAAe,EAAE,kBAAkB,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACvD,OAAO,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,kBAAkB,GAAG,gBAAgB,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,aAAa,CAAC;CAC1B"}