@did-btcr2/method 0.18.1 → 0.20.0

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

@@ -1,334 +0,0 @@
-import { BitcoinCoreRpcClient, BitcoinRestClient, BlockV3 } from '@did-btcr2/bitcoin';
-import { BitcoinNetworkNames, DidUpdatePayload, UnixTimestamp } from '@did-btcr2/common';
-import { BeaconService, BeaconServiceAddress, BeaconSignal } from '../../interfaces/beacon.js';
-import { DidResolutionOptions } from '../../interfaces/crud.js';
-import { DidDocument } from '../../utils/did-document.js';
-import { SignalsMetadata } from '../../utils/types.js';
-import { DidComponents } from '../identifier.js';
-export type FindNextSignalsRestParams = {
-    connection: BitcoinRestClient;
-    beaconSignals: Array<BeaconSignal>;
-    block: BlockV3;
-    beacons: Array<BeaconServiceAddress>;
-};
-export type BeaconSignals = Array<BeaconSignal>;
-export type BitcoinClient = BitcoinCoreRpcClient | BitcoinRestClient;
-export type NetworkVersion = {
-    version?: string;
-    network?: string;
-};
-export type ResolveInitialDocument = {
-    identifier: string;
-    components: DidComponents;
-    resolutionsOptions: DidResolutionOptions;
-};
-export interface ResolveDeterministic {
-    components: DidComponents;
-    identifier: string;
-}
-export interface ResolveExternal {
-    components: DidComponents;
-    identifier: string;
-    resolutionsOptions: DidResolutionOptions;
-}
-export interface ResolveSidecar {
-    identifierComponents: DidComponents;
-    initialDocument: DidDocument;
-}
-export interface ResolveCas {
-    identifier: string;
-    identifierComponents: DidComponents;
-}
-export interface ApplyDidUpdateParams {
-    contemporaryDidDocument: DidDocument;
-    update: DidUpdatePayload;
-}
-export interface TargetDocumentParams {
-    initialDocument: DidDocument;
-    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 Resolve
- * @type {Resolve}
- */
-export declare class Resolve {
-    /**
-     * 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 {ResolveDeterministic} params See {@link ResolveDeterministic} for details.
-     * @param {string} params.identifier The did-btcr2 version.
-     * @param {DidComponents} params.identifierComponents The decoded components of the identifier.
-     * @returns {DidDocument} The resolved DID Document object.
-     */
-    static deterministic({ identifier, identifierComponents }: {
-        identifier: string;
-        identifierComponents: DidComponents;
-    }): DidDocument;
-    /**
-     * 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 {ResolveExternal} 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 {DidDocument} params.resolutionsOptions.sidecarData The sidecar data for resolving the DID Document.
-     * @param {DidDocument} params.resolutionsOptions.sidecarData.initialDocument The offline user-provided DID Document
-     * @returns {DidDocument} The resolved DID Document object
-     */
-    static external({ identifier, identifierComponents, resolutionsOptions }: {
-        identifier: string;
-        identifierComponents: DidComponents;
-        resolutionsOptions: DidResolutionOptions;
-    }): Promise<DidDocument>;
-    /**
-     * 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 {ResolveSidecar} 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 {DidDocument} params.initialDocument The initial DID Document provided by the user
-     * @returns {DidDocument} The resolved DID Document object
-     * @throws {DidError} InvalidDidDocument if genesisBytes !== initialDocument hashBytes
-     */
-    static sidecar({ identifierComponents, initialDocument }: ResolveSidecar): Promise<DidDocument>;
-    /**
-     * 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 {ResolveCas} 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 {DidDocument} The resolved DID Document object
-     * @throws {MethodError} if the DID Document content is invalid
-     */
-    static cas({ identifier, identifierComponents }: ResolveCas): Promise<DidDocument>;
-    /**
-     * 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<DidDocument>} 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<DidDocument>;
-    /**
-     * 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 {DidDocument} params.initialDocument The initial DID Document to resolve
-     * @param {ResolutionOptions} params.options See {@link DidResolutionOptions} for details.
-     * @returns {DidDocument} The resolved DID Document object with a validated single, canonical history
-     */
-    static targetDocument({ initialDocument, resolutionsOptions }: {
-        initialDocument: DidDocument;
-        resolutionsOptions: DidResolutionOptions;
-    }): Promise<DidDocument>;
-    /**
-     * 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 {DidDocument} 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.updateHashHistory 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 {string} params.network The bitcoin network to connect to (mainnet, signet, testnet, regtest).
-     * @returns {Promise<DidDocument>} The resolved DID Document object with a validated single, canonical history.
-     */
-    protected static traverseBlockchainHistory({ contemporaryDidDocument, contemporaryBlockHeight, currentVersionId, targetVersionId, targetTime, didDocumentHistory, updateHashHistory, signalsMetadata, network }: {
-        contemporaryDidDocument: DidDocument;
-        contemporaryBlockHeight: number;
-        currentVersionId: number;
-        targetVersionId?: number;
-        targetTime: number;
-        didDocumentHistory: DidDocument[];
-        updateHashHistory: string[];
-        signalsMetadata: SignalsMetadata;
-        network: string;
-    }): Promise<DidDocument>;
-    /**
-     * 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.contemporaryBlockHeight The blockheight to start looking for beacon signals.
-     * @param {Array<BeaconService>} params.beacons The beacons to look for in the block.
-     * @param {Array<BeaconService>} params.network The bitcoin network to connect to (mainnet, signet, testnet, regtest).
-     * @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.
-     * @returns {Promise<Array<BeaconSignal>>} An array of BeaconSignal objects with blockHeight and signals.
-     */
-    static findNextSignals({ contemporaryBlockHeight, targetTime, network, beacons }: {
-        contemporaryBlockHeight: number;
-        beacons: Array<BeaconServiceAddress>;
-        network: string;
-        targetTime: UnixTimestamp;
-    }): Promise<Array<BeaconSignal>>;
-    /**
-     * Helper method for the {@link findNextSignals | Find Next Signals} algorithm.
-     * @param {Array<BeaconService>} beacons The beacons to process.
-     * @returns {Promise<Array<BeaconSignal>>} The beacon signals found in the block.
-     */
-    static findSignalsRest(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 {ResolveError} 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 {DidDocument} 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<DidDocument>}
-     */
-    static applyDidUpdate({ contemporaryDidDocument, update }: {
-        contemporaryDidDocument: DidDocument;
-        update: DidUpdatePayload;
-    }): Promise<DidDocument>;
-}

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

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

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

@@ -1,93 +0,0 @@
-import { DidUpdateInvocation, DidUpdatePayload, PatchOperation } from '@did-btcr2/common';
-import { DidDocument, DidVerificationMethod } from '../../utils/did-document.js';
-import { SignalsMetadata } from '../../utils/types.js';
-export interface ConstructUpdateParams {
-    identifier: string;
-    sourceDocument: DidDocument;
-    sourceVersionId: number;
-    patch: PatchOperation[];
-}
-export interface UpdateParams extends ConstructUpdateParams {
-    verificationMethodId: string;
-    beaconIds: string[];
-}
-export type InvokePayloadParams = {
-    identifier: string;
-    didUpdatePayload: DidUpdatePayload;
-    verificationMethod: DidVerificationMethod;
-};
-/**
- * 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 Update
- * @type {Update}
- */
-export declare class Update {
-    /**
-     * 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 Identifier, 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 {DidDocument} 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 {MethodError} InvalidDid if sourceDocument.id does not match identifier.
-     */
-    static construct({ identifier, sourceDocument, sourceVersionId, patch, }: {
-        identifier: string;
-        sourceDocument: DidDocument;
-        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 Identifier, 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 {MethodError} if the privateKeyBytes are invalid
-     */
-    static invoke({ identifier, didUpdatePayload, verificationMethod }: {
-        identifier: string;
-        didUpdatePayload: DidUpdatePayload;
-        verificationMethod: DidVerificationMethod;
-    }): 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 Identifier, 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 {DidDocument} 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 {MethodError} if the beaconService type is invalid
-     */
-    static announce({ sourceDocument, beaconIds, didUpdateInvocation }: {
-        sourceDocument: DidDocument;
-        beaconIds: string[];
-        didUpdateInvocation: DidUpdateInvocation;
-    }): Promise<SignalsMetadata>;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../src/core/crud/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,mBAAmB,EACnB,gBAAgB,EAOhB,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAIvD,MAAM,WAAW,qBAAqB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,WAAW,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,cAAc,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,YAAa,SAAQ,qBAAqB;IACvD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,kBAAkB,EAAE,qBAAqB,CAAC;CAC3C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,MAAM;IACjB;;;;;;;;;;;;;;OAcG;WACiB,SAAS,CAAC,EAC5B,UAAU,EACV,cAAc,EACd,eAAe,EACf,KAAK,GACN,EAAE;QACD,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,WAAW,CAAC;QAC5B,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,qBAAqB,CAAC;KAC3C,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAuEhC;;;;;;;;;;;;;;OAcG;WACiB,QAAQ,CAAC,EAC3B,cAAc,EACd,SAAS,EACT,mBAAmB,EACpB,EAAE;QACD,cAAc,EAAE,WAAW,CAAC;QAC5B,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,mBAAmB,EAAE,mBAAmB,CAAC;KAC1C,GAAG,OAAO,CAAC,eAAe,CAAC;CAgD7B"}

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

@@ -1,116 +0,0 @@
-import { RawTransactionRest, RawTransactionV2 } from '@did-btcr2/bitcoin';
-import { DidUpdatePayload, UnixTimestamp } from '@did-btcr2/common';
-import { DidServiceEndpoint, DidService as IDidService } from '@web5/dids';
-import { SidecarData, SignalsMetadata } from '../utils/types.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;
-}
-/**
- * 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

@@ -1 +0,0 @@
-{"version":3,"file":"beacon.d.ts","sourceRoot":"","sources":["../../../src/interfaces/beacon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEjE;;;;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;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;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

@@ -1,32 +0,0 @@
-import { UnixTimestamp } from '@did-btcr2/common';
-import { DidResolutionOptions as IDidResolutionOptions } from '@web5/dids';
-import { DidDocument } from '../utils/did-document.js';
-import { SidecarData } from '../utils/types.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 {?SidecarData} sidecarData The sidecar data for resolving the DID Document
- */
-export interface DidResolutionOptions extends IDidResolutionOptions {
-    versionId?: number;
-    versionTime?: UnixTimestamp;
-    sidecarData?: SidecarData;
-    network?: string;
-}
-export interface RootCapability {
-    '@context': string;
-    id: string;
-    controller: string;
-    invocationTarget: string;
-}
-export interface ReadBlockchainParams {
-    contemporaryDidDocument: DidDocument;
-    contemporaryBlockHeight: number | 1;
-    currentVersionId: number | 1;
-    targetVersionId?: number;
-    targetBlockHeight: number;
-    updateHashHistory: string[];
-    sidecarData?: SidecarData;
-    options?: DidResolutionOptions;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../src/interfaces/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,oBAAoB,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;GAKG;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,MAAM,CAAC;CAClB;AACD,MAAM,WAAW,cAAc;IAC3B,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,WAAW,CAAC;IACrC,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/utils/types.d.ts

@@ -1,38 +0,0 @@
-import { DidUpdatePayload, ProofBytes } from '@did-btcr2/common';
-import { BeaconService } from '../interfaces/beacon.js';
-import { DidDocument } from './did-document.js';
-import { BlockV3 } from '@did-btcr2/bitcoin';
-export type FindNextSignals = {
-    block: BlockV3;
-    beacons: BeaconService[];
-};
-export type Metadata = {
-    didUpdate: DidUpdatePayload;
-    proofs?: string;
-};
-export type SignalSidecarData = Metadata;
-export interface Sidecar {
-    did: string;
-}
-export type SignalsMetadata = {
-    [signalId: string]: Metadata;
-};
-export interface SingletonSidecar extends Sidecar {
-    signalsMetadata: SignalsMetadata;
-}
-export interface CIDAggregateSidecar extends Sidecar {
-    initialDocument: DidDocument;
-    signalsMetadata: SignalsMetadata;
-    cidUpdates: Array<string>;
-}
-export interface SMTAggregateSidecar extends Sidecar {
-    initialDocument: DidDocument;
-    signalsMetadata: SignalsMetadata;
-    smtProof: ProofBytes;
-}
-export type BeaconSidecarData<T> = T extends 'SingletonBeacon' ? SingletonSidecar : T extends 'CIDAggregateBeacon' ? CIDAggregateSidecar : T extends 'SMTAggregateBeacon' ? SMTAggregateSidecar : T;
-export type SidecarData = BeaconSidecarData<SingletonSidecar | CIDAggregateSidecar | SMTAggregateSidecar>;
-export type GetSigningMethodParams = {
-    didDocument: DidDocument;
-    methodId?: string;
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,aAAa,EAAE,CAAA;CACzB,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG;IACrB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AACzC,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;CACb;AACD,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;CAAE,CAAC;AAChE,MAAM,WAAW,gBAAiB,SAAQ,OAAO;IAC/C,eAAe,EAAE,eAAe,CAAC;CAClC;AACD,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,eAAe,EAAE,WAAW,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC3B;AACD,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IAClD,eAAe,EAAE,WAAW,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,UAAU,CAAC;CACtB;AACD,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAC7B,CAAC,SAAS,iBAAiB,GAAG,gBAAgB,GAC9C,CAAC,SAAS,oBAAoB,GAAG,mBAAmB,GACpD,CAAC,SAAS,oBAAoB,GAAG,mBAAmB,GACpD,CAAC,CAAC;AACJ,MAAM,MAAM,WAAW,GAAG,iBAAiB,CAAC,gBAAgB,GAAG,mBAAmB,GAAG,mBAAmB,CAAC,CAAC;AAC1G,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/src/canonicalize.d.ts

@@ -1,6 +0,0 @@
-// canonicalize.d.ts
-declare module 'canonicalize' {
-    const canonicalize: any;
-    export default canonicalize;
-  }
-