@did-btcr2/method 0.18.1 → 0.20.0

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"}