@did-btcr2/method 0.18.1 → 0.19.0

package/src/utils/did-document.ts

@@ -2,19 +2,21 @@ import { getNetwork } from '@did-btcr2/bitcoin';
 import {
   BTCR2_DID_DOCUMENT_CONTEXT,
   DidDocumentError,
-  ID_PLACEHOLDER_VALUE,
   IdentifierTypes,
   INVALID_DID_DOCUMENT,
   JSONObject,
-  KeyBytes,
+  JSONUtils,
+  KeyBytes
 } from '@did-btcr2/common';
 import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
 import { DidService, DidDocument as IIDidDocument, DidVerificationMethod as IIDidVerificationMethod } from '@web5/dids';
-import { BeaconService } from '../interfaces/beacon.js';
+import { BeaconService } from '../core/beacon/interfaces.js';
 import { BeaconUtils } from '../core/beacon/utils.js';
 import { Identifier } from '../core/identifier.js';
 import { Appendix } from './appendix.js';
+import { payments } from 'bitcoinjs-lib';
 
+export const ID_PLACEHOLDER_VALUE = 'did:btcr2:_';
 export const BECH32M_CHARS = '';
 export const DID_REGEX = /did:btcr2:(x1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*)/g;
 
@@ -120,18 +122,22 @@ export class DidDocument implements IDidDocument {
   capabilityInvocation?: Array<string | DidVerificationMethod>;
   capabilityDelegation?: Array<string | DidVerificationMethod>;
   service: Array<BeaconService>;
+  deactivated?: boolean;
 
   constructor(document: IDidDocument) {
     // Set the ID and ID type
-    const idType = document.id.includes('k1')
+    const idType = document.id.includes('k')
       ? IdentifierTypes.KEY
       : IdentifierTypes.EXTERNAL;
 
     // Validate ID and parts for non-intermediate
-    const isIntermediate = document.id === ID_PLACEHOLDER_VALUE;
+    const isGenesis = document.id === ID_PLACEHOLDER_VALUE;
+
     // Deconstruct the document parts for validation
     const { id, controller, verificationMethod: vm, service } = document;
-    if (!isIntermediate) {
+
+    // If not genesis, validate core properties
+    if (!isGenesis) {
       if (!DidDocument.isValidId(id)) {
         throw new DidDocumentError(`Invalid id: ${id}`, INVALID_DID_DOCUMENT, document);
       }
@@ -172,29 +178,19 @@ export class DidDocument implements IDidDocument {
     // Sanitize the DID Document
     DidDocument.sanitize(this);
     // If the DID Document is not an intermediateDocument, validate it
-    if (!isIntermediate) {
+    if (!isGenesis) {
       DidDocument.validate(this);
     } else {
-      this.validateIntermediate();
+      this.validateGenesis();
     }
   }
 
   /**
    * Convert the DidDocument to a JSON object.
-   * @returns {JSONObject} The JSON representation of the DidDocument.
+   * @returns {DidDocument} The JSON representation of the DidDocument.
    */
-  public json(): JSONObject {
-    return {
-      id                   : this.id,
-      controller           : this.controller,
-      '@context'           : this['@context'],
-      verificationMethod   : this.verificationMethod,
-      authentication       : this.authentication,
-      assertionMethod      : this.assertionMethod,
-      capabilityInvocation : this.capabilityInvocation,
-      capabilityDelegation : this.capabilityDelegation,
-      service              : this.service
-    };
+  public json(): DidDocument {
+    return Object.fromEntries(Object.entries(this)) as DidDocument;
   }
 
   /**
@@ -374,10 +370,10 @@ export class DidDocument implements IDidDocument {
    * @returns {DidDocument} Validated DID Document.
    * @throws {DidDocumentError} If the DID Document is invalid.
    */
-  public static validate(didDocument: DidDocument | IntermediateDidDocument): DidDocument {
+  public static validate(didDocument: DidDocument | GenesisDocument): DidDocument {
     // Validate the DID Document
     if (didDocument.id === ID_PLACEHOLDER_VALUE) {
-      (didDocument as IntermediateDidDocument).validateIntermediate();
+      (didDocument as GenesisDocument).validateGenesis();
     } else {
       DidDocument.isValid(didDocument);
     }
@@ -386,60 +382,67 @@ export class DidDocument implements IDidDocument {
   }
 
   /**
-   * Validate the IntermediateDidDocument.
-   * @returns {boolean} True if the IntermediateDidDocument is valid.
+   * Validate the GenesisDocument.
+   * @returns {boolean} True if the GenesisDocument is valid.
    */
-  public validateIntermediate(): boolean {
+  public validateGenesis(): boolean {
     // Validate the id
     if(this.id !== ID_PLACEHOLDER_VALUE) {
-      throw new DidDocumentError('Invalid IntermediateDidDocument ID', INVALID_DID_DOCUMENT, this);
+      throw new DidDocumentError('Invalid GenesisDocument ID', INVALID_DID_DOCUMENT, this);
     }
     // Validate the controller
     if(!this.controller?.every(c => c === ID_PLACEHOLDER_VALUE)) {
-      throw new DidDocumentError('Invalid IntermediateDidDocument controller', INVALID_DID_DOCUMENT, this);
+      throw new DidDocumentError('Invalid GenesisDocument controller', INVALID_DID_DOCUMENT, this);
     }
     // Validate the verificationMethod
     if(!this.verificationMethod.every(vm => vm.id.includes(ID_PLACEHOLDER_VALUE) && vm.controller === ID_PLACEHOLDER_VALUE)) {
-      throw new DidDocumentError('Invalid IntermediateDidDocument verificationMethod', INVALID_DID_DOCUMENT, this);
+      throw new DidDocumentError('Invalid GenesisDocument verificationMethod', INVALID_DID_DOCUMENT, this);
     }
     // Validate the service
     if(!this.service.every(svc => svc.id.includes(ID_PLACEHOLDER_VALUE))) {
-      throw new DidDocumentError('Invalid IntermediateDidDocument service', INVALID_DID_DOCUMENT, this);
+      throw new DidDocumentError('Invalid GenesisDocument service', INVALID_DID_DOCUMENT, this);
     }
     if(!DidDocument.isValidVerificationRelationships(this)) {
       // Return true if all validations pass
-      throw new DidDocumentError('Invalid IntermediateDidDocument assertionMethod', INVALID_DID_DOCUMENT, this);
+      throw new DidDocumentError('Invalid GenesisDocument assertionMethod', INVALID_DID_DOCUMENT, this);
     }
 
     return true;
   }
 
   /**
-   * Convert the DidDocument to an IntermediateDidDocument.
-   * @returns {IntermediateDidDocument} The IntermediateDidDocument representation of the DidDocument.
+   * Convert the DidDocument to an GenesisDocument.
+   * @returns {GenesisDocument} The GenesisDocument representation of the DidDocument.
    */
-  public toIntermediate(): IntermediateDidDocument {
+  public toIntermediate(): GenesisDocument {
     if(this.id.includes('k1')) {
       throw new DidDocumentError('Cannot convert a key identifier to an intermediate document', INVALID_DID_DOCUMENT, this);
     }
-    return new IntermediateDidDocument(this);
+    return new GenesisDocument(this);
+  }
+}
+
+export class Document {
+  public static isValid(didDocument: DidDocument | GenesisDocument): boolean {
+    return new DidDocument(didDocument).validateGenesis();
   }
 }
 
+
 /**
- * IntermediateDidDocument extends the DidDocument class for creating and managing intermediate DID documents.
+ * GenesisDocument extends the DidDocument class for creating and managing intermediate DID documents.
  * This class is used to create a minimal DID document with a placeholder ID.
  * It is used in the process of creating a new DID document.
- * @class IntermediateDidDocument
+ * @class GenesisDocument
  * @extends {DidDocument}
  */
-export class IntermediateDidDocument extends DidDocument {
-  constructor(document: JSONObject) {
-    super(document as IDidDocument);
+export class GenesisDocument extends DidDocument {
+  constructor(document: object | DidDocument) {
+    super(document as DidDocument);
   }
 
   /**
-   * Convert the IntermediateDidDocument to a DidDocument by replacing the placeholder value with the provided DID.
+   * Convert the GenesisDocument to a DidDocument by replacing the placeholder value with the provided DID.
    * @param did The DID to replace the placeholder value in the document.
    * @returns {DidDocument} A new DidDocument with the placeholder value replaced by the provided DID.
    */
@@ -451,46 +454,45 @@ export class IntermediateDidDocument extends DidDocument {
 
 
   /**
-   * Create an IntermediateDidDocument from a DidDocument by replacing the DID with a placeholder value.
+   * Create an GenesisDocument from a DidDocument by replacing the DID with a placeholder value.
    * @param {DidDocument} didDocument The DidDocument to convert.
-   * @returns {IntermediateDidDocument} The IntermediateDidDocument representation of the DidDocument.
+   * @returns {GenesisDocument} The GenesisDocument representation of the DidDocument.
    */
-  public static fromDidDocument(didDocument: DidDocument): IntermediateDidDocument {
-    const intermediateDocument = JSON.cloneReplace(didDocument, DID_REGEX, ID_PLACEHOLDER_VALUE) as IDidDocument;
-    return new IntermediateDidDocument(intermediateDocument);
+  public static fromDidDocument(didDocument: DidDocument): GenesisDocument {
+    const intermediateDocument = JSONUtils.cloneReplace(didDocument, DID_REGEX, ID_PLACEHOLDER_VALUE) as IDidDocument;
+    return new GenesisDocument(intermediateDocument);
   }
 
   /**
-   * Create a minimal IntermediateDidDocument with a placeholder ID.
+   * Create a minimal GenesisDocument with a placeholder ID.
    * @param {Array<DidVerificationMethod>} verificationMethod The public key in multibase format.
    * @param {VerificationRelationships} relationships The public key in multibase format.
    * @param {Array<BeaconService>} service The service to be included in the document.
-   * @returns {IntermediateDidDocument} A new IntermediateDidDocument with the placeholder ID.
+   * @returns {GenesisDocument} A new GenesisDocument with the placeholder ID.
    */
   public static create(
     verificationMethod: Array<DidVerificationMethod>,
     relationships: VerificationRelationships,
     service: Array<BeaconService>
-  ): IntermediateDidDocument {
+  ): GenesisDocument {
     const id = ID_PLACEHOLDER_VALUE;
-    return new IntermediateDidDocument({ id, ...relationships, verificationMethod, service, });
+    return new GenesisDocument({ id, ...relationships, verificationMethod, service, });
   }
 
   /**
-   * Create a minimal IntermediateDidDocument from a public key.
+   * Create a minimal GenesisDocument from a public key.
    * @param {KeyBytes} publicKey The public key in bytes format.
-   * @returns {IntermediateDidDocument} A new IntermediateDidDocument with the placeholder ID.
+   * @returns {GenesisDocument} A new GenesisDocument with the placeholder ID.
    */
-  public static fromPublicKey(publicKey: KeyBytes, network: string): IntermediateDidDocument {
+  public static fromPublicKey(publicKey: KeyBytes, network: string): GenesisDocument {
     const pk = new CompressedSecp256k1PublicKey(publicKey);
     const id = ID_PLACEHOLDER_VALUE;
-    const service = BeaconUtils.generateBeaconService({
-      id          : `${id}#key-0`,
-      publicKey   : pk.compressed,
-      network     : getNetwork(network),
-      addressType : 'p2pkh',
-      type        : 'SingletonBeacon',
-    });
+    const address = payments.p2pkh({ pubkey: pk.compressed, network: getNetwork(network) })?.address;
+    const services = [{
+      id              : `${id}#key-0`,
+      serviceEndpoint : `bitcoin:${address}`,
+      type            : 'SingletonBeacon',
+    }];
 
     const relationships = {
       authentication       : [`${id}#key-0`],
@@ -507,21 +509,15 @@ export class IntermediateDidDocument extends DidDocument {
       }
     ];
 
-    return IntermediateDidDocument.create(verificationMethod, relationships, [service]);
+    return GenesisDocument.create(verificationMethod, relationships, services);
   }
 
   /**
    * Taken an object, convert it to an IntermediateDocuemnt and then to a DidDocument.
-   * @param {JSONObject} object The JSON object to convert.
+   * @param {object | DidDocument} object The JSON object to convert.
    * @returns {DidDocument} The created DidDocument.
    */
-  public static fromJSON(object: JSONObject): IntermediateDidDocument {
-    return new IntermediateDidDocument(object as IDidDocument);
-  }
-}
-
-export class Document {
-  public static isValid(didDocument: DidDocument | IntermediateDidDocument): boolean {
-    return new DidDocument(didDocument).validateIntermediate();
+  public static fromJSON(object: object | DidDocument): GenesisDocument {
+    return new GenesisDocument(object as IDidDocument);
   }
-}
+}

package/src/utils/general.ts

@@ -36,7 +36,7 @@ export class GeneralUtils {
    */
   static bigintToBuffer(value: bigint): Buffer {
     const hex = value.toString(16).padStart(64, '0');
-    return Buffer.fromHex(hex);
+    return Buffer.from(hex, 'hex');
   }
 
   /**

package/dist/cjs/core/beacon/cid-aggregate.js

@@ -1,116 +0,0 @@
-import { MethodError } from '@did-btcr2/common';
-import { Beacon } from '../../interfaces/beacon.js';
-/**
- * Implements {@link https://dcdpr.github.io/did-btcr2/#cidaggregate-beacon | 5.2 CIDAggregate Beacon}.
- *
- * A Beacon of the type CIDAggregatoBeacon is a Beacon that publishes Bitcoin transactions containing a Content
- * Identifier (CID) announcing an Aggregated DID Update Bundle. An Aggregated DID Update Bundle is a JSON object that
- * maps did:btcr2 identifiers to CID values for the individual DID Update Payloads. The Aggregated DID Update Bundle CID
- * (bundleCID) SHOULD be resolvable against a Content Addressable Storage (CAS) system such as IPFS, while the CID for
- * the DID Update Payload (payloadCID) MAY be resolvable against a CAS or provided through a Sidecar mechanism. It is
- * RECOMMENDED that this type of Beacon is only included in a DID document if the DID controller is REQUIRED to
- * participate in authorizing Bitcoin transactions from this Beacon. In other words, this Beacon SHOULD identify an
- * n-of-n P2TR Bitcoin address where n is the number of unique DID controllers submitting updates through the Beacon.
- *
- * @class CIDAggregateBeacon
- * @type {CIDAggregateBeacon}
- * @extends {Beacon}
- */
-export class CIDAggregateBeacon extends Beacon {
-    /**
-     * Creates an instance of CIDAggregateBeacon.
-     * @param {BeaconService} service The service of the Beacon.
-     * @param {?BeaconSidecarData} [sidecar] The sidecar data of the Beacon.
-     */
-    constructor(service, sidecar) {
-        super({ ...service, type: 'CIDAggregateBeacon' }, sidecar);
-    }
-    get service() {
-        return {
-            type: this.type,
-            id: this.id,
-            serviceEndpoint: this.serviceEndpoint
-        };
-    }
-    /**
-     * TODO: Finish implementation
-     *
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-cidaggregate-beacon | 5.2.1 Establish CIDAggregate Beacon}.
-     *
-     * To establish a CIDAggregatorBeacon, a cohort of cooperating parties SHOULD generate an n-of-n P2TR Bitcoin address
-     * where each party contributes a public key. Furthermore, each party SHOULD verify that their key is part of the
-     * address and all other keys that are part of the address are keys with controllers able to produce valid signatures.
-     * To establish a Beacon there are two roles. One is the cohort participant, they want to join a Beacon cohort and
-     * submit a request to do so with a key and proof of control over that key. The other is the Beacon coordinator, they
-     * advertise and curate Beacon cohorts by combining Beacon participants into cohorts, verifying proofs of control, and
-     * producing Beacon addresses.
-     *
-     * @param {string} id The identifier of the Beacon.
-     * @param {string} type The type of the Beacon.
-     * @param {DidServiceEndpoint} serviceEndpoint The service endpoint of the Beacon.
-     * @returns {CIDAggregateBeacon} The established CIDAggregate Beacon.
-     */
-    static establish(id, type, serviceEndpoint) {
-        return new CIDAggregateBeacon({ id, type, serviceEndpoint });
-    }
-    /**
-     * TODO: Figure out if this is necessary or not.
-     * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
-     * @returns {BeaconSignal} The generated signal.
-     * @throws {MethodError} if the signal is invalid.
-     */
-    generateSignal(didUpdatePayload) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { didUpdatePayload });
-    }
-    /**
-     * TODO: Finish implementation
-     *
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-cidaggregate-beacon-signal | 5.2.3 Process CIDAggregate Beacon Signal}.
-     *
-     * A Beacon Signal from a CIDAggregate Beacon is a Bitcoin transaction that contains the hashBytes of a DID Update
-     * Bundle in its first transaction output. The corresponding DID Update Bundle MUST either be provided through Sidecar
-     * Data or by converting hashBytes into a IPFS v1 Content Identifier and attempting to retrieve it from Content
-     * Addressable Storage. The DID Update Bundle maps from did:btcr2 identifiers to hashes of DID Update payloads
-     * applicable for that identifier. Again this algorithm attempts to retrieve and validate the DID Update Payload
-     * identified for the identifier being resolved. If successful, the DID Update Payload is returned.
-     *
-     * The Process CIDAggregate Beacon Signal algorithm is called by the Process Beacon Signals algorithm as part of the
-     * Read operation.
-     *
-     * It takes as inputs a did:btcr2 identifier, Identifier, a Beacon Signal, tx, and a optional
-     * object, signalSidecarData, containing any sidecar data provided to the resolver for the Beacon Signal identified by
-     * the Bitcoin transaction identifier.
-     *
-     * It returns the DID Update payload announced by the Beacon Signal for the
-     * did:btcr2 identifier being resolved or throws an error.
-     *
-     * @param {RawTransactionV2} signal Bitcoin transaction representing a Beacon Signal.
-     * @param {SignalsMetadata} signalsMetadata Optional sidecar data for the Beacon Signal.
-     * @returns {Promise<DidUpdatePayload | undefined>} The DID Update payload announced by the Beacon Signal.
-     * @throws {DidError} if the signalTx is invalid or the signalsMetadata is invalid.
-     */
-    processSignal(signal, signalsMetadata) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { signal, signalsMetadata });
-    }
-    /**
-     * TODO: Finish implementation
-     *
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-cidaggregate-beacon-signal | 5.2.2 Broadcast CIDAggregate Beacon Signal}.
-     *
-     * The Broadcast CIDAggregate Beacon Signal algorithm involving two roles: a set of cohort participants and a Beacon
-     * coordinator. The Beacon coordinator collects individual DID Update Payload Content Identifiers (CIDs) for specific
-     * did:btcr2 idntifiers and aggregates them into a DID Update Bundle, which is then published to a Content Addressable
-     * Storage (CAS). The CID for the DID Update Bundle is included in a Partially Signed Bitcoin Transaction (PSBT) transaction
-     * output spent from the Beacon’s n-of-n address. Each of the n cohort participants in the Beacon MUST sign the
-     * transaction before it can be broadcast to the network. It is RECOMMENDED that cohort participants keep a copy of
-     * the DID Update Bundle and separately pin it to the CAS.
-     *
-     * @param {DidUpdatePayload} didUpdatePayload The verificationMethod object to be used for signing.
-     * @returns {SignalsMetadata} Successful output of a bitcoin transaction.
-     * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
-     */
-    broadcastSignal(didUpdatePayload) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, didUpdatePayload);
-    }
-}
-//# sourceMappingURL=cid-aggregate.js.map

package/dist/cjs/core/beacon/cid-aggregate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cid-aggregate.js","sourceRoot":"","sources":["../../../../src/core/beacon/cid-aggregate.ts"],"names":[],"mappings":"AACA,OAAO,EAAyC,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEvF,OAAO,EAAE,MAAM,EAA+B,MAAM,4BAA4B,CAAC;AAGjF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,kBAAmB,SAAQ,MAAM;IAC5C;;;;OAIG;IACH,YAAY,OAAsB,EAAE,OAAgD;QAClF,KAAK,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,OAAO;QACT,OAAO;YACL,IAAI,EAAc,IAAI,CAAC,IAAI;YAC3B,EAAE,EAAgB,IAAI,CAAC,EAAE;YACzB,eAAe,EAAG,IAAI,CAAC,eAAe;SACvC,CAAC;IACJ,CAAC;IAGD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,SAAS,CAAC,EAAU,EAAE,IAAY,EAAE,eAAmC;QAC5E,OAAO,IAAI,kBAAkB,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;IAC/D,CAAC;IAGD;;;;;OAKG;IACH,cAAc,CAAC,gBAAwB;QACrC,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,EAAC,gBAAgB,EAAC,CAAC,CAAC;IACjG,CAAC;IAGD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,aAAa,CAAC,MAAwB,EAAE,eAAgC;QACtE,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,EAAC,MAAM,EAAE,eAAe,EAAC,CAAC,CAAC;IACxG,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAC,gBAAkC;QAChD,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,gBAAgB,CAAC,CAAC;IAC/F,CAAC;CA4BF"}

package/dist/cjs/core/beacon/smt-aggregate.js

@@ -1,126 +0,0 @@
-import { MethodError } from '@did-btcr2/common';
-import { Beacon } from '../../interfaces/beacon.js';
-/**
- * TODO: Finish implementation
- *
- * Implements {@link https://dcdpr.github.io/did-btcr2/#smtaggregate-beacon | 5.3 SMTAggregate Beacon}.
- *
- * A SMTAggregate Beacon is a Beacon whose Beacon Signals are Bitcoin transactions containing the root of a Sparse
- * Merkle Tree (SMT). The SMT root attests to a set of DID Update Payloads, however, the updates themselves MUST be
- * provided along with a proof of inclusion against the SMT root through a Sidecar mechanism during resolution. Using
- * the SMT root a resolver can then verify the inclusion proof for the given DID Update Payload. If a DID document
- * includes a SMTAggregator Beacon in their set of Beacon services, then they MUST provide proofs for each signal that
- * the Beacon broadcasts. If they did not submit an update to their DID in a signal, then they MUST provide a proof of
- * non-inclusion for that signal.
- *
- * @class SMTAggregateBeacon
- * @type {SMTAggregateBeacon}
- * @extends {Beacon}
- */
-export class SMTAggregateBeacon extends Beacon {
-    /**
-     * Creates an instance of SMTAggregateBeacon.
-     * @param {BeaconService} service The Beacon service.
-     * @param {?BeaconSidecarData} [sidecar] Optional sidecar data.
-     */
-    constructor(service, sidecar) {
-        super({ ...service, type: 'SMTAggregateBeacon' }, sidecar);
-    }
-    /**
-     * Get the Beacon service.
-     * @readonly
-     * @type {BeaconService} The Beacon service.
-     */
-    get service() {
-        const service = {
-            type: this.type,
-            id: this.id,
-            serviceEndpoint: this.serviceEndpoint
-        };
-        return service;
-    }
-    /**
-     * TODO: Figure out if this is necessary or not.
-     * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
-     * @returns {BeaconSignal} The generated signal.
-     * @throws {MethodError} if the signal is invalid.
-     */
-    generateSignal(didUpdatePayload) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { didUpdatePayload });
-    }
-    /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-beacon | 5.3.1 Establish Beacon}.
-     *
-     * The Establish Beacon algorithm is essentially the same as for the CIDAggregate Beacon in Establish CIDAggregate
-     * Beacon. A cohort of DID controllers need to coordinate to produce a Bitcoin address that will act as the Beacon.
-     * It is RECOMMENDED this is an n-of-n P2TR address, with n being the set of DID controllers in the cohort. Once the
-     * address has been created, and all parties in the cohort acknowledge their intention to participate in that Beacon,
-     * each DID controller SHOULD add the Beacon as a service to their DID document.
-     *
-     * Additionally, the SMTAggregate Beacon cohort participants MUST register the did:btcr2 identifiers they intend use
-     * this Beacon with. This is so the Beacon coordinator can generate the necessary proofs of both inclusion and
-     * non-inclusion for each DID.
-     *
-     * Static, convenience method for establishing a Beacon object.
-     *
-     * @param {string} id The Beacon ID.
-     * @param {string} type The Beacon type.
-     * @param {DidServiceEndpoint} serviceEndpoint The service endpoint.
-     * @returns {Beacon} The Beacon.
-     */
-    static establish(id, type, serviceEndpoint) {
-        return new SMTAggregateBeacon({ id, type, serviceEndpoint });
-    }
-    /**
-     *
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-smtaggregate-beacon-signal | 5.3.2 Broadcast SMTAggregate Beacon Signal}.
-     *
-     * See {@link Beacon.broadcastSignal | Beacon Interface Method broadcastSignal} for more information.
-     *
-     * To publish a DID Update Payload, the DID controller MUST get a hash of the DID Update Payload included at the leaf
-     * of the Sparse Merkle Tree (SMT) identified by their did:btcr2 identifier and receive an inclusion proof for this
-     * data. If a member of the Beacon cohort does not wish to announce an update in a Beacon Signal, they MUST receive
-     * and verify a proof of non-inclusion for their DID. Upon verifying the non-inclusion proof against the SMT root
-     * contained in the Beacon Signal, they SHOULD accept and authorize the signal following the MuSig2 protocol. Once all
-     * members of the cohort have authorized the signal, it can be broadcast as a transaction to the Bitcoin network. DID
-     * controllers are responsible for persisting their DID updates and proofs, these will need to be provided through a
-     * Sidecar mechanism during a resolution process.
-     *
-     * @param {DidUpdatePayload} didUpdatePayload The DID Update Payload to broadcast.
-     * @returns {Promise<SignalMetadata>} The signal metadata.
-     * @throws {MethodError} if the signal is invalid.
-     */
-    broadcastSignal(didUpdatePayload) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, didUpdatePayload);
-    }
-    /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#process-smtaggregate-beacon-signal | 5.3.3 Process SMTAggregate Beacon Signal}.
-     *
-     * See {@link Beacon.processSignal | Beacon Interface Method processSignal} for more information.
-     *
-     * A Beacon Signal from a SMTAggregate Beacon is a Bitcoin transaction with the first transaction output of the format
-     * [OP_RETURN, OP_PUSH32, <32bytes>]. The 32 bytes of data contained within this transaction output represent the root
-     * of a Sparse Merkle Tree (SMT). This SMT aggregates a set of hashes of DID Update payloads. In order to process
-     * these Beacon Signals, the resolver MUST have been passed Sidecar data for this signal containing either the DID
-     * Update payload object and a SMT proof that the hash of this object is in the SMT at the leaf indexed by the
-     * did:Identifier being resolved. Or theSidecar data:: MUST contain a proof that the leaf indexed by the
-     * did:Identifier is empty, thereby proving that theSMT:: does not contain an update for their identifier.
-     *
-     * The Process SMTAggregate Beacon Signal is called by the Process Beacon Signals algorithm as part of the Read
-     * operation. It takes as inputs a did:btcr2 identifier, Identifier, a Beacon Signal, tx, and a optional object,
-     * signalSidecarData, containing any sidecar data provided to the resolver for the Beacon Signal identified by the
-     * Bitcoin transaction identifier.
-     *
-     * It returns the DID Update payload announced by the Beacon Signal for the did:btcr2 identifier being resolved or
-     * throws an error.
-     *
-     * @param {RawTransactionV2} signal The raw transaction signal.
-     * @param {SignalsMetadata} signalsMetadata The signals metadata.
-     * @returns {Promise<DidUpdatePayload | undefined>} The updated DID document.
-     * @throws {MethodError} if the signal is invalid.
-     */
-    processSignal(signal, signalsMetadata) {
-        throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { signal, signalsMetadata });
-    }
-}
-//# sourceMappingURL=smt-aggregate.js.map

package/dist/cjs/core/beacon/smt-aggregate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"smt-aggregate.js","sourceRoot":"","sources":["../../../../src/core/beacon/smt-aggregate.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAE,MAAM,EAA+B,MAAM,4BAA4B,CAAC;AAGjF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,kBAAmB,SAAQ,MAAM;IAC5C;;;;OAIG;IACH,YAAY,OAAsB,EAAE,OAAgD;QAClF,KAAK,CAAC,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,IAAI,OAAO;QACT,MAAM,OAAO,GAAG;YACd,IAAI,EAAc,IAAI,CAAC,IAAI;YAC3B,EAAE,EAAgB,IAAI,CAAC,EAAE;YACzB,eAAe,EAAG,IAAI,CAAC,eAAe;SACvC,CAAC;QACF,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAC,gBAAwB;QAC5C,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,EAAC,gBAAgB,EAAC,CAAC,CAAC;IACjG,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,CAAC,SAAS,CAAC,EAAU,EAAE,IAAY,EAAE,eAAmC;QACnF,OAAO,IAAI,kBAAkB,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACI,eAAe,CAAC,gBAAkC;QACvD,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,gBAAgB,CAAC,CAAC;IAC/F,CAAC;IAGD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,aAAa,CAAC,MAAwB,EAAE,eAAgC;QAC7E,MAAM,IAAI,WAAW,CAAC,yBAAyB,EAAE,wBAAwB,EAAE,EAAC,MAAM,EAAE,eAAe,EAAC,CAAC,CAAC;IACxG,CAAC;CACF"}

package/dist/cjs/core/crud/deactivate.js

@@ -1,14 +0,0 @@
-import { DidBtcr2 } 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 Deactivate
- * @type {Deactivate}
- * @extends {DidBtcr2}
- */
-export class Deactivate extends DidBtcr2 {
-}
-//# sourceMappingURL=deactivate.js.map

package/dist/cjs/core/crud/deactivate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deactivate.js","sourceRoot":"","sources":["../../../../src/core/crud/deactivate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,OAAO,UAAW,SAAQ,QAAQ;CAAG"}