@did-btcr2/method 0.13.1

package/dist/types/btcr2/crud/create.d.ts

@@ -0,0 +1,92 @@
+import { KeyBytes, PatchOperation } from '@did-btcr2/common';
+import { DidCreateOptions as IDidCreateOptions } from '@web5/dids';
+import { Btc1DidDocument, IntermediateDidDocument } from '../../utils/did-document.js';
+import { Btc1KeyManager } from '../key-manager/index.js';
+export type Btc1CreateParams = Btc1CreateKeyParams | Btc1CreateExternalParams;
+export interface CreateIdentifierParams {
+    genesisBytes: Uint8Array;
+    newtork?: string;
+    version?: string;
+}
+export type Btc1CreateResponse = {
+    did: string;
+    initialDocument: Btc1DidDocument;
+};
+export interface Btc1UpdateConstructParams {
+    identifier: string;
+    sourceDocument: Btc1DidDocument;
+    sourceVersionId: number;
+    patch: PatchOperation[];
+}
+export interface Btc1UpdateParams extends Btc1UpdateConstructParams {
+    verificationMethodId: string;
+    beaconIds: string[];
+}
+export interface DidCreateOptions extends IDidCreateOptions<Btc1KeyManager> {
+    /** DID BTCR2 Version Number */
+    version?: number;
+    /** Bitcoin Network */
+    network?: string;
+}
+export type Btc1CreateKeyParams = {
+    idType: 'KEY';
+    pubKeyBytes: KeyBytes;
+    options?: DidCreateOptions;
+};
+export type Btc1CreateExternalParams = {
+    idType: 'EXTERNAL';
+    intermediateDocument: IntermediateDidDocument;
+    options?: DidCreateOptions;
+};
+/**
+ * Implements section {@link https://dcdpr.github.io/did-btcr2/#create | 4.1 Create}.
+ *
+ * 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.
+ *
+ * @class Btc1Create
+ * @type {Btc1Create}
+ */
+export declare class Btc1Create {
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#deterministic-key-based-creation | 4.1.1 Deterministic Key-Based Creation}.
+     *
+     * For deterministic key-based creation, the did:btcr2 identifier encodes a secp256k1 public key. The key is then used
+     * to deterministically generate the initial DID document.
+     *
+     * @param {Btc1CreateKeyParams} params See {@link Btc1CreateKeyParams} for details.
+     * @param {number} params.version did-btcr2 identifier version.
+     * @param {string} params.network did-btcr2 bitcoin network.
+     * @param {KeyBytes} params.pubKeyBytes public key bytes for id creation.
+     * @returns {Btc1CreateResponse} A response object of type {@link Btc1CreateResponse}.
+     * @throws {DidError} if the public key is missing or invalid.
+     */
+    static deterministic({ pubKeyBytes, options }: {
+        pubKeyBytes: KeyBytes;
+        options: DidCreateOptions;
+    }): Btc1CreateResponse;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#external-initial-document-creation | 4.1.2 External Initial Document Creation}.
+     *
+     * Creates a did:btcr2 identifier from some initiating arbitrary DID document. This allows for more complex
+     * initial DID documents, including the ability to include Service Endpoints and Beacons that support aggregation.
+     * Inputs include `intermediateDocument`, optional version and network returning initialDidDocument. The
+     * intermediateDocument should be a valid DID document except all places where the DID document requires the use of
+     * the identifier (e.g. the id field). These fields should use placeholder value
+     * `did:btcr2:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`. The intermediateDocument should include at
+     * least one verificationMethod and service of the type SingletonBeacon.
+     *
+     * @param {Btc1CreateExternalParams} params See {@link Btc1CreateExternalParams} for details.
+     * @param {number} params.version Identifier version.
+     * @param {string} params.network Identifier network name.
+     * @param {string} params.documentBytes Intermediate DID Document bytes.
+     * @returns {Btc1CreateResponse} A Promise resolving to {@link Btc1CreateResponses}.
+     * @throws {DidError} if the verificationMethod or service objects are missing required properties
+     */
+    static external({ intermediateDocument, options }: {
+        intermediateDocument: IntermediateDidDocument;
+        options: DidCreateOptions;
+    }): Promise<Btc1CreateResponse>;
+}

package/dist/types/btcr2/crud/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/crud/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,QAAQ,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnF,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGnE,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAC9E,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,UAAU,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AACF,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,eAAe,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,cAAc,EAAE,CAAC;CAC3B;AACD,MAAM,WAAW,gBAAiB,SAAQ,yBAAyB;IAC/D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB;AACD,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB,CAAC,cAAc,CAAC;IACzE,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AACD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,KAAK,CAAC;IACd,WAAW,EAAE,QAAQ,CAAC;IACtB,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,UAAU,CAAC;IACnB,oBAAoB,EAAE,uBAAuB,CAAC;IAC9C,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB;;;;;;;;;;;;OAYG;WACW,aAAa,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE;QACpD,WAAW,EAAE,QAAQ,CAAC;QACtB,OAAO,EAAE,gBAAgB,CAAC;KAC3B,GAAG,kBAAkB;IAsCtB;;;;;;;;;;;;;;;;;OAiBG;WACiB,QAAQ,CAAC,EAAE,oBAAoB,EAAE,OAAO,EAAE,EAAE;QAC9D,oBAAoB,EAAE,uBAAuB,CAAC;QAC9C,OAAO,EAAE,gBAAgB,CAAC;KAC3B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA0BhC"}

package/dist/types/btcr2/crud/deactivate.d.ts

@@ -0,0 +1,13 @@
+import { DidBtc1 } from '../../did-btcr2.js';
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#deactivate | 4.4 Deactivate}
+ * To deactivate a did:btcr2, the DID controller MUST add the property deactivated with the value true on the DID
+ * document. To do this, the DID controller constructs a valid DID Update Payload with a JSON patch that adds this
+ * property and announces the payload through a Beacon in their current DID document following the algorithm in Update.
+ * Once a did:btcr2 has been deactivated this state is considered permanent and resolution MUST terminate.
+ * @class Btc1Deactivate
+ * @type {Btc1Deactivate}
+ * @extends {DidBtc1}
+ */
+export declare class Btc1Deactivate extends DidBtc1 {
+}

package/dist/types/btcr2/crud/deactivate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deactivate.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/crud/deactivate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,OAAO;CAAG"}

package/dist/types/btcr2/crud/read.d.ts

@@ -0,0 +1,341 @@
+import { BitcoinNetworkNames, DidUpdatePayload, UnixTimestamp } from '@did-btcr2/common';
+import BitcoinRest from '../../bitcoin/rest-client.js';
+import BitcoinRpc from '../../bitcoin/rpc-client.js';
+import { DidResolutionOptions } from '../../interfaces/crud.js';
+import { BeaconService, BeaconServiceAddress, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { BlockV3 } from '../../types/bitcoin.js';
+import { SignalsMetadata } from '../../types/crud.js';
+import { DidComponents } from '../../utils/appendix.js';
+import { Btc1DidDocument } from '../../utils/did-document.js';
+export type FindNextSignalsRestParams = {
+    connection: BitcoinRest;
+    beaconSignals: Array<BeaconSignal>;
+    block: BlockV3;
+    beacons: Array<BeaconServiceAddress>;
+};
+export type BeaconSignals = Array<BeaconSignal>;
+export type BitcoinClient = BitcoinRpc | BitcoinRest;
+export type NetworkVersion = {
+    version?: string;
+    network?: string;
+};
+export type ResolveInitialDocument = {
+    identifier: string;
+    components: DidComponents;
+    resolutionsOptions: DidResolutionOptions;
+};
+export interface Btc1ReadDeterministic {
+    components: DidComponents;
+    identifier: string;
+}
+export interface Btc1ReadExternal {
+    components: DidComponents;
+    identifier: string;
+    resolutionsOptions: DidResolutionOptions;
+}
+export interface Btc1ReadSidecar {
+    identifierComponents: DidComponents;
+    initialDocument: Btc1DidDocument;
+}
+export interface DidReadCas {
+    identifier: string;
+    identifierComponents: DidComponents;
+}
+export interface ApplyDidUpdateParams {
+    contemporaryDidDocument: Btc1DidDocument;
+    update: DidUpdatePayload;
+}
+export interface TargetDocumentParams {
+    initialDocument: Btc1DidDocument;
+    resolutionsOptions: DidResolutionOptions;
+}
+export interface TargetBlockheightParams {
+    network: BitcoinNetworkNames;
+    targetTime?: UnixTimestamp;
+}
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#read | 4.2 Read}.
+ * The read operation is executed by a resolver after a resolution request identifying a specific did:btcr2 identifier is
+ * received from a client at Resolution Time. The request MAY contain a resolutionOptions object containing additional
+ * information to be used in resolution. 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.
+ * To do so it executes the following algorithm:
+ *  1. Let identifierComponents be the result of running the algorithm
+ *     in Parse did:btcr2 identifier, passing in the identifier.
+ *  2. Set initialDocument to the result of running Resolve Initial Document
+ *     passing identifier, identifierComponents and resolutionOptions.
+ *  3. Set targetDocument to the result of running the algorithm in Resolve
+ *     Target Document passing in initialDocument and resolutionOptions.
+ *  4. Return targetDocument.
+ *
+ * @class Btc1Read
+ * @type {Btc1Read}
+ */
+export declare class Btc1Read {
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#deterministically-generate-initial-did-document | 4.2.2.1 Deterministically Generate Initial DID Document}.
+     *
+     * The Deterministically Generate Initial DID Document algorithm deterministically generates an initial DID
+     * Document from a secp256k1 public key. It takes in a did:btcr2 identifier and a identifierComponents object and
+     * returns an initialDocument.
+     *
+     * @param {Btc1ReadDeterministic} params See {@link Btc1ReadDeterministic} for details.
+     * @param {string} params.identifier The did-btcr2 version.
+     * @param {DidComponents} params.identifierComponents The decoded components of the identifier.
+     * @returns {Btc1DidDocument} The resolved DID Document object.
+     */
+    static deterministic({ identifier, identifierComponents }: {
+        identifier: string;
+        identifierComponents: DidComponents;
+    }): Btc1DidDocument;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#external-resolution | 4.2.2.2 External Resolution}.
+     *
+     * The External Resolution algorithm externally retrieves an intermediateDocumentRepresentation, either by retrieving
+     * it from {@link https://dcdpr.github.io/did-btcr2/#def-content-addressable-storage | Content Addressable Storage (CAS)}
+     * or from the {@link https://dcdpr.github.io/did-btcr2/#def-sidecar-data | Sidecar Data} provided as part of the
+     * resolution request. It takes in a did:btcr2 identifier, a identifierComponents object and a resolutionOptions object.
+     * It returns an initialDocument, which is a conformant DID document validated against the identifier.
+     *
+     * @param {Btc1ReadExternal} params Required params for calling the external method.
+     * @param {string} params.identifier The DID to be resolved.
+     * @param {DidComponents} params.identifierComponents The decoded components of the identifier.
+     * @param {DidResolutionOptions} params.resolutionsOptions The options for resolving the DID Document.
+     * @param {Btc1DidDocument} params.resolutionsOptions.sidecarData The sidecar data for resolving the DID Document.
+     * @param {Btc1DidDocument} params.resolutionsOptions.sidecarData.initialDocument The offline user-provided DID Document
+     * @returns {Btc1DidDocument} The resolved DID Document object
+     */
+    static external({ identifier, identifierComponents, resolutionsOptions }: {
+        identifier: string;
+        identifierComponents: DidComponents;
+        resolutionsOptions: DidResolutionOptions;
+    }): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#sidecar-initial-document-validation | 4.2.2.2.1 Sidecar Initial Document Validation}.
+     *
+     * The Sidecar Initial Document Validation algorithm validates an initialDocument against its identifier, by first
+     * constructing the intermediateDocumentRepresentation and verifying the hash of this document matches the bytes
+     * encoded within the identifier. It takes in a did:btcr2 identifier, identifierComponents and a
+     * initialDocument. It returns the initialDocument if validated, otherwise it throws an error.
+     *
+     * @param {Btc1ReadSidecar} params Required params for calling the sidecar method
+     * @param {string} params.identifier The DID to be resolved
+     * @param {DidComponents} params.identifierComponents The components of the DID identifier
+     * @param {Btc1DidDocument} params.initialDocument The initial DID Document provided by the user
+     * @returns {Btc1DidDocument} The resolved DID Document object
+     * @throws {DidError} InvalidDidDocument if genesisBytes !== initialDocument hashBytes
+     */
+    static sidecar({ identifierComponents, initialDocument }: Btc1ReadSidecar): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#cas-retrieval | 4.2.2.2.2 CAS Retrieval}.
+     *
+     * The CAS Retrieval algorithm attempts to retrieve an initialDocument from a Content Addressable Storage (CAS) system
+     * by converting the bytes in the identifier into a Content Identifier (CID). It takes in an identifier and
+     * an identifierComponents object. It returns an initialDocument.
+     *
+     * @param {DidReadCas} params Required params for calling the cas method
+     * @param {string} params.identifier BTCR2 DID used to resolve the DID Document
+     * @param {DidComponents} params.identifierComponents BTCR2 DID components used to resolve the DID Document
+     * @returns {Btc1DidDocument} The resolved DID Document object
+     * @throws {Btcr2Error} if the DID Document content is invalid
+     */
+    static cas({ identifier, identifierComponents }: DidReadCas): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#resolve-initial-document | 4.2.2 Resolve Initial Document}.
+     *
+     * This algorithm resolves an initial DID document and validates it against the identifier for a specific did:btcr2.
+     * The algorithm takes in a did:btcr2 identifier, identifier components object, resolutionsOptions object and returns
+     * a valid initialDocument for that identifier.
+     *
+     * @public
+     * @param {ResolveInitialDocument} params See {@link ResolveInitialDocument} for parameter details.
+     * @param {string} params.identifier The DID to be resolved.
+     * @param {DidComponents} params.identifierComponents The decoded components of the identifier.
+     * @param {DidResolutionOptions} params.resolutionsOptions Options for resolving the DID Document. See {@link DidResolutionOptions}.
+     * @returns {Promise<Btc1DidDocument>} The resolved DID Document object.
+     * @throws {DidError} if the DID hrp is invalid, no sidecarData passed and hrp = "x".
+     */
+    static initialDocument({ identifier, identifierComponents, resolutionsOptions }: {
+        identifier: string;
+        identifierComponents: DidComponents;
+        resolutionsOptions: DidResolutionOptions;
+    }): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#resolve-target-document | 4.2.3 Resolve Target Document}.
+     *
+     * The Resolve Target Document algorithm resolves a DID document from an initial document by walking the Bitcoin
+     * blockchain to identify Beacon Signals that announce DID Update Payloads applicable to the did:btcr2 identifier being
+     * resolved. It takes as inputs initialDocument, resolutionOptions and network. It returns a valid DID document.
+     *
+     * @public
+     * @param {TargetDocumentParams} params See {@link TargetDocumentParams} for details.
+     * @param {Btc1DidDocument} params.initialDocument The initial DID Document to resolve
+     * @param {ResolutionOptions} params.options See {@link DidResolutionOptions} for details.
+     * @returns {Btc1DidDocument} The resolved DID Document object with a validated single, canonical history
+     */
+    static targetDocument({ initialDocument, resolutionsOptions }: {
+        initialDocument: Btc1DidDocument;
+        resolutionsOptions: DidResolutionOptions;
+    }): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#traverse-blockchain-history | 4.2.3.2 Traverse Blockchain History}.
+     *
+     * The Traverse Blockchain History algorithm traverses Bitcoin blocks, starting from the block with the
+     * contemporaryBlockheight, to find beaconSignals emitted by Beacons within the contemporaryDidDocument. Each
+     * beaconSignal is processed to retrieve a didUpdatePayload to the DID document. Each update is applied to the
+     * document and duplicates are ignored. If the algorithm reaches the block with the blockheight specified by a
+     * targetBlockheight, the contemporaryDidDocument at that blockheight is returned assuming a single canonical history
+     * of the DID document has been constructed up to that point. It takes in contemporaryDidDocument,
+     * contemporaryBlockHeight, currentVersionId, targetVersionId, targetBlockheight, updateHashHistory, signalsMetadata
+     * and network. It returns the contemporaryDidDocument once either the targetBlockheight or targetVersionId have been
+     * reached.
+     *
+     * @protected
+     * @param {ReadBlockchainParams} params The parameters for the traverseBlockchainHistory operation.
+     * @param {Btc1DidDocument} params.contemporaryDidDocument The DID document for the did:btcr2 identifier being resolved.
+     *    It should be "current" (contemporary) at the blockheight of the contemporaryBlockheight.
+     *    It should be a DID Core conformant DID document.
+     * @param {number} params.contemporaryBlockHeight The Bitcoin blockheight signaling the "contemporary time" of the
+     *    contemporary DID Document that is being resolved and updated using the Traverse Blockchain History algorithm.
+     * @param {number} params.currentVersionId The version of the contemporary DID document starting from 1 and
+     *    incrementing by 1 with each BTCR2 Update applied to the DID document.
+     * @param {number} params.targetVersionId The version of the DID document where resolution will complete.
+     * @param {UnixTimestamp} params.targetTime The timestamp used to target specific historical states of a DID document.
+     *    Only Beacon Signals included in the Bitcoin blockchain before the targetTime are processed.
+     * @param {boolean} params.didDocumentHistory An array of DID documents ordered ascensing by version (1...N).
+     * @param {boolean} params.btc1UpdateHashHistory An array of SHA256 hashes of BTCR2 Updates ordered by version that are
+     *    applied to the DID document in order to construct the contemporaryDIDDocument.
+     * @param {SignalsMetadata} params.signalsMetadata See {@link SignalsMetadata} for details.
+     * @param {BitcoinNetworkNames} params.network The bitcoin network to connect to (mainnet, signet, testnet, regtest).
+     * @returns {Promise<Btc1DidDocument>} The resolved DID Document object with a validated single, canonical history.
+     */
+    protected static traverseBlockchainHistory({ contemporaryDidDocument, contemporaryBlockHeight, currentVersionId, targetVersionId, targetTime, didDocumentHistory, btc1UpdateHashHistory, signalsMetadata, network }: {
+        contemporaryDidDocument: Btc1DidDocument;
+        contemporaryBlockHeight: number;
+        currentVersionId: number;
+        targetVersionId?: number;
+        targetTime: number;
+        didDocumentHistory: Btc1DidDocument[];
+        btc1UpdateHashHistory: string[];
+        signalsMetadata: SignalsMetadata;
+        network: BitcoinNetworkNames;
+    }): Promise<Btc1DidDocument>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#find-next-signals | 4.2.3.3 Find Next Signals}.
+     *
+     * The Find Next Signals algorithm finds the next Bitcoin block containing Beacon Signals from one or more of the
+     * beacons and retuns all Beacon Signals within that block.
+     *
+     * It takes the following inputs:
+     *  - `contemporaryBlockhieght`: The height of the block this function is looking for Beacon Signals in.
+     *                               An integer greater or equal to 0.
+     *  - `targetBlockheight`: The height of the Bitcoin block that the resolution algorithm searches for Beacon Signals
+     *                         up to. An integer greater or equal to 0.
+     *  - `beacons`: An array of Beacon services in the contemporary DID document. Each Beacon contains properties:
+     *      - `id`: The id of the Beacon service in the DID document. A string.
+     *      - `type`: The type of the Beacon service in the DID document. A string whose values MUST be
+     *                          either SingletonBeacon, CIDAggregateBeacon or SMTAggregateBeacon.
+     *      - `serviceEndpoint`: A BIP21 URI representing a Bitcoin address.
+     *      - `address`: The Bitcoin address decoded from the `serviceEndpoint value.
+     *  - `network`: A string identifying the Bitcoin network of the did:btcr2 identifier. This algorithm MUST query the
+     *               Bitcoin blockchain identified by the network.
+     *
+     * It returns a nextSignals struct, containing the following properties:
+     *  - blockheight: The Bitcoin blockheight for the block containing the Beacon Signals.
+     *  - signals: An array of signals. Each signal is a struct containing the following:
+     *      - beaconId: The id for the Beacon that the signal was announced by.
+     *      - beaconType: The type of the Beacon that announced the signal.
+     *      - tx: The Bitcoin transaction that is the Beacon Signal.
+     *
+     * @public
+     * @param {FindNextSignals} params The parameters for the findNextSignals operation.
+     * @param {number} params.blockheight The blockheight to start looking for beacon signals.
+     * @param {Array<BeaconService>} params.target The target blockheight at which to stop finding signals.
+     * @param {Array<BeaconService>} params.beacons The beacons to look for in the block.
+     * @returns {Promise<Array<BeaconSignal>>} An array of BeaconSignal objects with blockHeight and signals.
+     */
+    static findNextSignals({ contemporaryBlockHeight, targetTime, beacons }: {
+        contemporaryBlockHeight: number;
+        beacons: Array<BeaconServiceAddress>;
+        network: BitcoinNetworkNames;
+        targetTime: UnixTimestamp;
+    }): Promise<Array<BeaconSignal>>;
+    /**
+     * Helper method for the {@link findNextSignals | Find Next Signals} algorithm.
+     *
+     * @param params See {@link FindNextSignalsRestParams} for details.
+     * @param {BitcoinClient} params.connection The bitcoin connection to use.
+     * @param {Array<BeaconSignal>} params.beaconSignals The beacon signals to process.
+     * @param {BlockV3} params.block The block to process.
+     * @param {Array<BeaconService>} params.beacons The beacons to process.
+     * @returns {Promise<Array<BeaconSignal>>} The beacon signals found in the block.
+     */
+    static findSignalsRest({ beacons }: {
+        beacons: Array<BeaconService>;
+    }): Promise<Array<BeaconSignal>>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-beacon-signals | 4.2.3.4 Process Beacon Signals}.
+     *
+     * The Process Beacon Signals algorithm processes each Beacon Signal by attempting to retrieve and validate an
+     * announce DID Update Payload for that signal according to the type of the Beacon.
+     *
+     * It takes as inputs
+     *  - `beaconSignals`: An array of Beacon Signals retrieved from the Find Next Signals algorithm. Each signal contains:
+     *    - `beaconId`: The id for the Beacon that the signal was announced by.
+     *    - `beaconType`: The type of the Beacon that announced the signal.
+     *    - `tx`: The Bitcoin transaction that is the Beacon Signal.
+     *  - `signalsMetadata`: Maps Beacon Signal Bitcoin transaction ids to a SignalMetadata object containing:
+     *    - `updatePayload`: A DID Update Payload which should match the update announced by the Beacon Signal.
+     *                       In the case of a SMT proof of non-inclusion, no DID Update Payload may be provided.
+     *    - `proofs`: Sparse Merkle Tree proof used to verify that the `updatePayload` exists as the leaf indexed by the
+     *                did:btcr2 identifier being resolved.
+     *
+     * It returns an array of {@link https://dcdpr.github.io/did-btcr2/#def-did-update-payload | DID Update Payloads}.
+     *
+     * @public
+     * @param {BeaconSignal} signal The beacon signals to process.
+     * @param {SignalsMetadata} signalsMetadata The sidecar data for the DID Document.
+     * @returns {DidUpdatePayload[]} The updated DID Document object.
+     */
+    static processBeaconSignal(signal: BeaconSignal, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.2.4 Confirm Duplicate Update}.
+     *
+     * The Confirm Duplicate Update algorithm takes in a {@link DidUpdatePayload | DID Update Payload} and verifies that
+     * the update is a duplicate against the hash history of previously applied updates. The algorithm takes in an update
+     * and an array of hashes, updateHashHistory. It throws an error if the update is not a duplicate, otherwise it
+     * returns.
+     *
+     * @public
+     * @param {{ update: DidUpdatePayload; updateHashHistory: string[]; }} params Parameters for confirmDuplicateUpdate.
+     * @param {DidUpdatePayload} params.update The DID Update Payload to confirm.
+     * @param {Array<string>} params.updateHashHistory The history of hashes for previously applied updates.
+     * @returns {Promise<void>} A promise that resolves if the update is a duplicate, otherwise throws an error.
+     * @throws {DidBtc1Error} if the update hash does not match the historical hash.
+     */
+    static confirmDuplicateUpdate({ update, updateHashHistory }: {
+        update: DidUpdatePayload;
+        updateHashHistory: string[];
+    }): Promise<void>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#apply-did-update | 4.2.3.6 Apply DID Update}.
+     *
+     * This algorithm attempts to apply a DID Update to a DID document, it first verifies the proof on the update is a
+     * valid capabilityInvocation of the root authority over the DID being resolved. Then it applies the JSON patch
+     * transformation to the DID document, checks the transformed DID document matches the targetHash specified by the
+     * update and validates it is a conformant DID document before returning it. This algorithm takes inputs
+     * contemporaryDidDocument and an update.
+     *
+     * @public
+     * @param {ApplyDidUpdateParams} params Parameters for applyDidUpdate.
+     * @param {Btc1DidDocument} params.contemporaryDidDocument The current DID Document to update.
+     * @param {DidUpdatePayload} params.update The DID Update Payload to apply.
+     * @param {Bytes} params.genesisBytes The genesis bytes for the DID Document.
+     * @returns {Promise<Btc1DidDocument>}
+     */
+    static applyDidUpdate({ contemporaryDidDocument, update }: {
+        contemporaryDidDocument: Btc1DidDocument;
+        update: DidUpdatePayload;
+    }): Promise<Btc1DidDocument>;
+}

package/dist/types/btcr2/crud/read.d.ts.map

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

package/dist/types/btcr2/crud/update.d.ts

@@ -0,0 +1,83 @@
+import { DidUpdateInvocation, DidUpdatePayload, PatchOperation } from '@did-btcr2/common';
+import { SignalsMetadata } from '../../types/crud.js';
+import { Btc1DidDocument, Btc1VerificationMethod } from '../../utils/did-document.js';
+export type InvokePayloadParams = {
+    identifier: string;
+    didUpdatePayload: DidUpdatePayload;
+    verificationMethod: Btc1VerificationMethod;
+};
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#update | 4.3 Update}.
+ *
+ * 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.
+ *
+ * @class Btc1Update
+ * @type {Btc1Update}
+ */
+export declare class Btc1Update {
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#construct-did-update-payload | 4.3.1 Construct DID Update Payload}.
+     *
+     * The Construct DID Update Payload algorithm applies the documentPatch to the sourceDocument and verifies the
+     * resulting targetDocument is a conformant DID document. It takes in a btc1Identifier, sourceDocument,
+     * sourceVersionId, and documentPatch objects. It returns an unsigned DID Update Payload.
+     *
+     * @param {ConstructPayloadParams} params See  {@link ConstructPayloadParams} for more details.
+     * @param {string} params.identifier The did-btcr2 identifier to use for verification.
+     * @param {Btc1DidDocument} params.sourceDocument The source document to be updated.
+     * @param {string} params.sourceVersionId The versionId of the source document.
+     * @param {DidDocumentPatch} params.patch The JSON patch to be applied to the source document.
+     * @returns {Promise<DidUpdatePayload>} The constructed DidUpdatePayload object.
+     * @throws {Btcr2Error} InvalidDid if sourceDocument.id does not match identifier.
+     */
+    static construct({ identifier, sourceDocument, sourceVersionId, patch, }: {
+        identifier: string;
+        sourceDocument: Btc1DidDocument;
+        sourceVersionId: number;
+        patch: PatchOperation[];
+    }): Promise<DidUpdatePayload>;
+    /**
+     * {@link https://dcdpr.github.io/did-btcr2/#invoke-did-update-payload | 4.3.2 Invoke DID Update Payload}.
+     *
+     * The Invoke DID Update Payload algorithm takes in a btc1Identifier, an unsigned didUpdatePayload, and a
+     * verificationMethod. It retrieves the privateKeyBytes for the verificationMethod and adds a capability invocation in
+     * the form of a Data Integrity proof following the Authorization Capabilities (ZCAP-LD) and VC Data Integrity
+     * specifications. It returns the invoked DID Update Payload.
+     *
+     * @param {InvokePayloadParams} params Required params for calling the invokePayload method
+     * @param {string} params.identifier The did-btcr2 identifier to derive the root capability from
+     * @param {DidUpdatePayload} params.didUpdatePayload The updatePayload object to be signed
+     * @param {DidVerificationMethod} params.verificationMethod The verificationMethod object to be used for signing
+     * @returns {DidUpdateInvocation} Did update payload secured with a proof => DidUpdateInvocation
+     * @throws {Btcr2Error} if the privateKeyBytes are invalid
+     */
+    static invoke({ identifier, didUpdatePayload, verificationMethod }: {
+        identifier: string;
+        didUpdatePayload: DidUpdatePayload;
+        verificationMethod: Btc1VerificationMethod;
+    }): Promise<DidUpdateInvocation>;
+    /**
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#announce-did-update | 4.3.3 Announce DID Update}.
+     *
+     * The Announce DID Update algorithm retrieves beaconServices from the sourceDocument and calls the Broadcast DID
+     * Update algorithm corresponding to the type of the Beacon. It takes in a btc1Identifier, sourceDocument, an array of
+     * beaconIds, and a didUpdateInvocation. It returns an array of signalsMetadata, containing the necessary
+     * data to validate the Beacon Signal against the didUpdateInvocation.
+     *
+     * @param {AnnounceUpdatePayloadParams} params Required params for calling the announcePayload method
+     * @param {Btc1DidDocument} params.sourceDocument The did-btcr2 did document to derive the root capability from
+     * @param {string[]} params.beaconIds The didUpdatePayload object to be signed
+     * @param {DidUpdateInvocation} params.didUpdatePayload The verificationMethod object to be used for signing
+     * @returns {SignalsMetadata} The signalsMetadata object containing data to validate the Beacon Signal
+     * @throws {Btcr2Error} if the beaconService type is invalid
+     */
+    static announce({ sourceDocument, beaconIds, didUpdateInvocation }: {
+        sourceDocument: Btc1DidDocument;
+        beaconIds: string[];
+        didUpdateInvocation: DidUpdateInvocation;
+    }): Promise<SignalsMetadata>;
+}

package/dist/types/btcr2/crud/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../src/btcr2/crud/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,mBAAmB,EACnB,gBAAgB,EAMhB,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAItF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,kBAAkB,EAAE,sBAAsB,CAAC;CAC5C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;OAcG;WACiB,SAAS,CAAC,EAC5B,UAAU,EACV,cAAc,EACd,eAAe,EACf,KAAK,GACN,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,eAAe,CAAC;QAChC,eAAe,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE,cAAc,EAAE,CAAC;KACzB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8C7B;;;;;;;;;;;;;;OAcG;WACiB,MAAM,CAAC,EACzB,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EACnB,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,kBAAkB,EAAE,sBAAsB,CAAC;KAC5C,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAqEhC;;;;;;;;;;;;;;OAcG;WACiB,QAAQ,CAAC,EAC3B,cAAc,EACd,SAAS,EACT,mBAAmB,EACpB,EAAE;QACD,cAAc,EAAE,eAAe,CAAC;QAChC,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,mBAAmB,EAAE,mBAAmB,CAAC;KAC1C,GAAG,OAAO,CAAC,eAAe,CAAC;CAgD7B"}