@did-btcr2/common 3.0.0 → 4.0.1

package/src/canonicalization.ts

@@ -1,9 +1,14 @@
 import { sha256 } from '@noble/hashes/sha2';
-import { bytesToHex } from '@noble/hashes/utils';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
 import { canonicalize as jcsa } from 'json-canonicalize';
 import { base58btc } from 'multiformats/bases/base58';
 import { CanonicalizationError } from './errors.js';
-import { CanonicalizationAlgorithm, CanonicalizationEncoding, HashBytes } from './types.js';
+import { CanonicalizationAlgorithm, CanonicalizationEncoding, HashBytes, HexString } from './types.js';
+
+export interface CanonicalizationOptions {
+  algorithm?: CanonicalizationAlgorithm;
+  encoding?: CanonicalizationEncoding;
+}
 
 /**
  * Canonicalization class provides methods for canonicalizing JSON objects
@@ -13,24 +18,6 @@ import { CanonicalizationAlgorithm, CanonicalizationEncoding, HashBytes } from '
  * @type {Canonicalization}
  */
 export class Canonicalization {
-  private readonly _defaultAlgorithm: CanonicalizationAlgorithm;
-
-  /**
-   * Initializes the Canonicalization class with the specified algorithm.
-   * @param {CanonicalizationAlgorithm} algorithm The canonicalization algorithm to use ('jcs').
-   */
-  constructor(algorithm: CanonicalizationAlgorithm = 'jcs') {
-    this._defaultAlgorithm = Canonicalization.normalizeAlgorithm(algorithm);
-  }
-
-  /**
-   * Gets the canonicalization algorithm.
-   * @returns {CanonicalizationAlgorithm} The current canonicalization algorithm.
-   */
-  get algorithm(): CanonicalizationAlgorithm {
-    return this._defaultAlgorithm;
-  }
-
   /**
    * Normalizes the canonicalization algorithm.
    * @param {CanonicalizationAlgorithm} algorithm
@@ -72,22 +59,20 @@ export class Canonicalization {
    * @param {Object} [options] Options for processing.
    * @param {CanonicalizationEncoding} [options.encoding='hex'] The encoding format ('hex' or 'base58').
    * @param {CanonicalizationAlgorithm} [options.algorithm] The canonicalization algorithm to use.
-   * @returns {Promise<string>} The final SHA-256 hash bytes as a hex string.
+   * @returns {string} The final SHA-256 hash bytes as a hex string.
    */
-  async process(object: Record<any, any>, options: {
-    encoding?: CanonicalizationEncoding;
-    algorithm?: CanonicalizationAlgorithm;
-    multibase?: boolean;
-  } = {}): Promise<string> {
-    const algorithm = Canonicalization.normalizeAlgorithm(options.algorithm ?? this._defaultAlgorithm);
-    const encoding = Canonicalization.normalizeEncoding(options.encoding ?? 'hex');
+  static process(object: Record<any, any>, options?: CanonicalizationOptions): string {
+    // Normalize the algorithm
+    const algorithm = Canonicalization.normalizeAlgorithm(options?.algorithm ?? 'jcs');
+    // Normalize the encoding
+    const encoding = Canonicalization.normalizeEncoding(options?.encoding ?? 'hex');
 
     // Step 1: Canonicalize
-    const canonicalized = await this.canonicalize(object, algorithm);
+    const canonicalized = this.canonicalize(object, algorithm);
     // Step 2: Hash
-    const hashed = this.hash(canonicalized);
+    const hashed = this.toHash(canonicalized);
     // Step 3: Encode
-    const encoded = this.encode(hashed, encoding, options.multibase ?? false);
+    const encoded = this.encode(hashed, encoding);
     // Return the encoded string
     return encoded;
   }
@@ -96,9 +81,9 @@ export class Canonicalization {
    * Step 1: Uses this.algorithm to determine the method (JCS).
    * @param {Record<any, any>} object The object to canonicalize.
    * @param {CanonicalizationAlgorithm} [algorithm] The algorithm to use.
-   * @returns {Promise<string>} The canonicalized object.
+   * @returns {string} The canonicalized object.
    */
-  async canonicalize(object: Record<any, any>, algorithm: CanonicalizationAlgorithm = this._defaultAlgorithm): Promise<string> {
+  static canonicalize(object: Record<any, any>, algorithm: CanonicalizationAlgorithm = 'jcs'): string {
     switch (Canonicalization.normalizeAlgorithm(algorithm)) {
       case 'jcs':
         return this.jcs(object);
@@ -112,7 +97,7 @@ export class Canonicalization {
    * @param {Record<any, any>} object The object to canonicalize.
    * @returns {string} The canonicalized object.
    */
-  jcs(object: Record<any, any>): string {
+  static jcs(object: Record<any, any>): string {
     return jcsa(object);
   }
 
@@ -121,7 +106,7 @@ export class Canonicalization {
    * @param {string} canonicalized The canonicalized object.
    * @returns {HashBytes} The SHA-256 HashBytes (Uint8Array).
    */
-  public hash(canonicalized: string): HashBytes {
+  static toHash(canonicalized: string): HashBytes {
     return sha256(canonicalized);
   }
 
@@ -132,33 +117,83 @@ export class Canonicalization {
    * @throws {CanonicalizationError} If the encoding format is not supported.
    * @returns {string} The encoded string.
    */
-  public encode(canonicalizedhash: HashBytes, encoding: CanonicalizationEncoding = 'hex', multibase: boolean = false): string {
+  static encode(canonicalizedhash: HashBytes, encoding: CanonicalizationEncoding = 'hex'): string {
+    // Normalize encoding
     const normalized = Canonicalization.normalizeEncoding(encoding);
-    if (normalized === 'hex') return this.hex(canonicalizedhash);
+
+    // If encoding is hex, encode to hex
+    if (normalized === 'hex') {
+      return this.toHex(canonicalizedhash);
+    }
+
+    // If encoding is base58, encode to base58
     if (normalized === 'base58') {
-      const encoded = this.base58(canonicalizedhash);
-      return multibase ? `z${encoded}` : encoded;
+      return this.toBase58(canonicalizedhash);
     }
+
+    // Throw error if encoding is unsupported
     throw new CanonicalizationError(`Unsupported encoding: ${encoding}`, 'ENCODING_ERROR');
   }
 
+  /**
+   * Decodes SHA-256 hashed, canonicalized object as a hex or base58 string.
+   * @param {string} canonicalizedhash The canonicalized object to encode.
+   * @param {CanonicalizationEncoding} encoding The encoding format ('hex' or 'base58').
+   * @throws {CanonicalizationError} If the encoding format is not supported.
+   * @returns {string} The encoded string.
+   */
+  static decode(canonicalizedhash: string, encoding: CanonicalizationEncoding = 'hex'): HashBytes {
+    // Normalize encoding
+    const normalized = Canonicalization.normalizeEncoding(encoding);
+
+    // If encoding is hex, decode from hex
+    if (normalized === 'hex') {
+      return this.fromHex(canonicalizedhash);
+    }
+
+    // If encoding is base58, decode from base58
+    if (normalized === 'base58') {
+      return this.fromBase58(canonicalizedhash);
+    }
+
+    // Throw error if encoding is unsupported
+    throw new CanonicalizationError(`Unsupported encoding: ${encoding}`, 'DECODING_ERROR');
+  }
+
   /**
    * Step 3.1: Encodes HashBytes (Uint8Array) to a hex string.
    * @param {HashBytes} hashBytes The hash as a Uint8Array.
    * @returns {string} The hash as a hex string.
    */
-  public hex(hashBytes: HashBytes): string {
+  static toHex(hashBytes: HashBytes): string {
     return bytesToHex(hashBytes);
   }
 
+  /**
+   * Decodes a hex string to HashBytes (Uint8Array).
+   * @param {HexString} hexString The hash as a hex string.
+   * @returns {HashBytes} The hash bytes.
+   */
+  static fromHex(hexString: HexString): HashBytes {
+    return hexToBytes(hexString);
+  }
+
   /**
    * Step 3.2: Encodes HashBytes (Uint8Array) to a base58btc string.
    * @param {HashBytes} hashBytes The hash as a Uint8Array.
    * @returns {string} The hash as a hex string.
    */
-  public base58(hashBytes: HashBytes): string {
-    const encoded = base58btc.encode(hashBytes);
-    return encoded.startsWith('z') ? encoded.slice(1) : encoded;
+  static toBase58(hashBytes: HashBytes): string {
+    return base58btc.encode(hashBytes);
+  }
+
+  /**
+   * Decodes a base58 string to HashBytes (Uint8Array).
+   * @param {string} b58str The hash as a base58 string.
+   * @returns {HashBytes} The hash bytes.
+   */
+  static fromBase58(b58str: string): HashBytes {
+    return base58btc.decode(b58str);
   }
 
   /**
@@ -167,12 +202,16 @@ export class Canonicalization {
    * @param {Record<any, any>} object The object to process.
    * @returns {Promise<HashBytes>} The final SHA-256 hash bytes.
    */
-  public async canonicalhash(
+  static andHash(
     object: Record<any, any>,
-    algorithm: CanonicalizationAlgorithm = this._defaultAlgorithm
-  ): Promise<HashBytes> {
-    const canonicalized = await this.canonicalize(object, algorithm);
-    return this.hash(canonicalized);
+    algorithm: CanonicalizationAlgorithm = 'jcs'
+  ): HashBytes {
+    // Step 1: Canonicalize
+    const canonicalized = this.canonicalize(object, algorithm);
+    // Step 2: Hash
+    const hashed = this.toHash(canonicalized);
+    // Return canonicalized hash bytes
+    return hashed;
   }
 
   /**
@@ -181,8 +220,13 @@ export class Canonicalization {
    * @param {string} canonicalized The canonicalized object to hash.
    * @returns {string} The SHA-256 hash as a hex string.
    */
-  public hashhex(canonicalized: string): string {
-    return this.encode(this.hash(canonicalized), 'hex');
+  static andHashToHex(canonicalized: string): string {
+    // Step 2: Hash
+    const hashed = this.toHash(canonicalized);
+    // Step 3: Encode (Hex)
+    const hexed = this.toHex(hashed);
+    // Return the hashed encoded string
+    return hexed;
   }
 
   /**
@@ -191,7 +235,7 @@ export class Canonicalization {
    * @param {string} canonicalized The canonicalized object to hash.
    * @returns {string} The SHA-256 hash as a base58 string.
    */
-  public hashbase58(canonicalized: string): string {
-    return this.encode(this.hash(canonicalized), 'base58', false);
+  static andHashToBase58(canonicalized: string): string {
+    return this.encode(this.toHash(canonicalized), 'base58');
   }
 }

package/src/constants.ts

@@ -2,7 +2,6 @@ import { sha256 } from '@noble/hashes/sha2';
 import { bytesToHex } from '@noble/hashes/utils';
 import { Bytes, HashHex } from './types.js';
 
-export const ID_PLACEHOLDER_VALUE = 'did:btcr2:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
 export const OP_RETURN = 0x6a;
 export const OP_PUSH32 = 0x20;
 export const VALID_HRP = ['k', 'x'];

package/src/errors.ts

@@ -75,8 +75,11 @@ export enum MethodErrorCode {
   /** The sidecar data in the DID Update Payload was invalid. */
   INVALID_SIDECAR_DATA = 'INVALID_SIDECAR_DATA',
 
-  /** The proof is missing or has a malformed challenge field. */
-  INVALID_CHALLENGE_ERROR = 'INVALID_CHALLENGE_ERROR',
+  /** The update data required for resolution is missing. */
+  MISSING_UPDATE_DATA = 'MISSING_UPDATE_DATA',
+
+  /** The update is missing or has a malformed field(s). */
+  INVALID_UPDATE = 'INVALID_UPDATE',
 
   /** The proof is missing or has a malformed domain field. */
   INVALID_DOMAIN_ERROR = 'INVALID_DOMAIN_ERROR'
@@ -106,7 +109,8 @@ export const {
   VERIFICATION_METHOD_ERROR,
   LATE_PUBLISHING_ERROR,
   INVALID_SIDECAR_DATA,
-  INVALID_CHALLENGE_ERROR,
+  MISSING_UPDATE_DATA,
+  INVALID_UPDATE,
   INVALID_DOMAIN_ERROR
 } = MethodErrorCode;
 
@@ -166,6 +170,18 @@ export class MethodError extends DidMethodError {
   }
 }
 
+export class IdentifierError extends DidMethodError {
+  constructor(message: string, type: string = 'IdentifierError', data?: Record<string, any>) {
+    super(message, { type, name: type, data });
+  }
+}
+
+export class UpdateError extends DidMethodError {
+  constructor(message: string, type: string = 'UpdateError', data?: Record<string, any>) {
+    super(message, { type, name: type, data });
+  }
+}
+
 export class ResolveError extends DidMethodError {
   constructor(message: string, type: string = 'ResolveError', data?: Record<string, any>) {
     super(message, { type, name: 'ResolveError', data });
@@ -190,6 +206,12 @@ export class CryptosuiteError extends DidMethodError {
   }
 }
 
+export class DataIntegrityProofError extends DidMethodError {
+  constructor(message: string, type: string = 'DataIntegrityProofError', data?: Record<string, any>) {
+    super(message, { type, name: type, data });
+  }
+}
+
 export class KeyPairError extends DidMethodError {
   constructor(message: string, type: string = 'KeyPairError', data?: Record<string, any>) {
     super(message, { type, name: type, data });

package/src/interfaces.ts

@@ -9,303 +9,3 @@ export interface PatchOperation {
   value?: unknown; // Required for add, replace, test
   from?: string; // Required for move, copy
 }
-
-/**
- * The unsigned payload object containing instructions for how to update a
- * did:btcr2 DID Document. Once signed, it becomes a
- * {@link DidUpdateInvocation | DID Update Invocation}
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#construct-did-update-payload | 4.3.1 Construct DID Update Payload}.
- *
- * Found in DID BTCR2 Specification {@link https://dcdpr.github.io/did-btcr2/#dereference-root-capability-identifier | Section 9.4.2}
- * @example
- * ```
- * {
- *  "@context": [
- *    "https://w3id.org/zcap/v1",
- *    "https://w3id.org/security/data-integrity/v2",
- *    "https://w3id.org/json-ld-patch/v1"
- *  ],
- *  "patch": [
- *    {
- *      "op": "add",
- *      "path": "/service/4",
- *      "value": {
- *        "id": "#linked-domain",
- *        "type": "LinkedDomains",
- *        "serviceEndpoint": "https://contact-me.com"
- *      }
- *    }
- *   ],
- *   "proof":{
- *   "type": "DataIntegrityProof,
- *   "cryptosuite": "schnorr-secp256k1-jcs-2025,
- *   "verificationMethod": "did:btcr2:k1qqpuwwde82nennsavvf0lqfnlvx7frrgzs57lchr02q8mz49qzaaxmqphnvcx#initialKey,
- *   "invocationTarget": "did:btcr2:k1qqpuwwde82nennsavvf0lqfnlvx7frrgzs57lchr02q8mz49qzaaxmqphnvcx,
- *   "capability": "urn:zcap:root:did%3Abtcr2%3Ak1qqpuwwde82nennsavvf0lqfnlvx7frrgzs57lchr02q8mz49qzaaxmqphnvcx,
- *   "capabilityAction": "Write,
- *   "proofPurpose": "assertionMethod,
- *   "proofValue": "z381yXYmxU8NudZ4HXY56DfMN6zfD8syvWcRXzT9xD9uYoQToo8QsXD7ahM3gXTzuay5WJbqTswt2BKaGWYn2hHhVFKJLXaD
- *  }
- * }
- * ```
- */
-export interface DidUpdatePayload {
-    /**
-     * JSON-LD context URIs for interpreting this payload, including contexts
-     * for ZCAP (capabilities), Data Integrity proofs, and JSON-LD patch ops.
-     */
-    '@context': string[];
-
-    /**
-     * A JSON Patch (or JSON-LD Patch) object defining the mutations to apply to
-     * the DID Document. Applying this patch to the current DID Document yields
-     * the new DID Document (which must remain valid per DID Core spec).
-     */
-    patch: JsonPatch;
-
-    /**
-     * The multihash of the current (source) DID Document, encoded as a multibase
-     * base58-btc string. This is a SHA-256 hash of the canonicalized source DID
-     * Document, used to ensure the patch is applied to the correct document state.
-     */
-    sourceHash: string;
-
-    /**
-     * The multihash of the updated (target) DID Document, encoded as multibase
-     * base58-btc. This is the SHA-256 hash of the canonicalized
-     * DID Document after applying the patch, used to verify the update result.
-     */
-    targetHash: string;
-
-    /**
-     * The version number of the DID Document after this update.
-     * It is equal to the previous document version + 1.
-     */
-    targetVersionId: number;
-
-    /**
-     * A proof object (Data Integrity proof) that authorizes this update.
-     * It is a JSON-LD proof indicating a capability invocation on the DID's
-     * root capability, typically signed with the DID's verification key (using
-     * Schnorr secp256k1 in did:btcr2).
-     */
-    proof?: Proof;
-}
-
-/**
- * An extension of {@link DidUpdatePayload | DID Update Payload} containing a
- * Data Integrity proof that authorizes the update. Once signed, the spec calls
- * this an 'invoked DID Update Payload' or 'didUpdateInvocation'.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#invoke-did-update-payload | 4.3.2 Invoke DID Update Payload}
- * and
- * {@link https://dcdpr.github.io/did-btcr2/#root-didbtcr2-update-capabilities | 9.4 Root did:btcr2 Update Capabilities}.
- */
-export interface DidUpdateInvocation extends DidUpdatePayload {
-  proof: Proof;
-}
-
-/**
- * Proof is the Data Integrity proof (ZCAP-LD style) added to a did:btcr2 DID
- * Update Payload.
- *
- * Verifiable Credential Data Integrity
- * {@link https://w3c.github.io/vc-data-integrity/#proofs | 2.1 Proofs}.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#invoke-did-update-payload | 4.3.2 Invoke DID Update Payload}.
- */
-export interface Proof extends ProofOptions {
-  /**
-   * The cryptographic signature value. The exact property name may be defined
-   * by the cryptosuite (for instance, `proofValue` for a raw signature) and
-   * contains the actual signature bytes in an encoded form.
-   */
-  proofValue: string;
-}
-
-/**
- * Proof Options used when adding a Data Integrity proof (ZCAP-LD style)
- * to a did:btcr2 DID Update Payload.
- *
- * Verifiable Credential Data Integrity
- * {@link https://w3c.github.io/vc-data-integrity/#proofs | 2.1 Proofs}.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#invoke-did-update-payload | 4.3.2 Invoke DID Update Payload}.
- */
-export interface ProofOptions {
-  /**
-   * The proof type—per the spec’s example, "DataIntegrityProof".
-   */
-  type: string;
-
-  /**
-   * The cryptographic suite used, e.g. "schnorr-secp256k1-jcs-2025".
-   */
-  cryptosuite: string;
-
-  /**
-   * DID URL of the key invoking the capability, i.e. the DID
-   * Document's verificationMethod.id used to sign this update.
-   */
-  verificationMethod: string;
-
-  /**
-   * The purpose of the proof, which the spec sets to "capabilityInvocation".
-   */
-  proofPurpose: string;
-
-  /**
-   * The root capability being invoked. In did:btcr2, this is typically
-   * `urn:zcap:root:<urlencoded-did>` (see Section 9.4.1).
-   */
-  capability?: string;
-
-  /**
-   * The action performed under the capability—set to "Write" in the spec
-   * for DID document updates.
-   */
-  capabilityAction?: string;
-
-  /**
-   * (Optional) Some cryptosuites or proofs may include a timestamp, domain,
-   * or challenge. Although not explicitly required in the doc's steps, they
-   * often appear in Data Integrity proofs and may be included as needed.
-   */
-  created?: string;
-  domain?: string;
-  challenge?: string;
-}
-
-/**
- * A JSON object that maps did:btcr2 identifiers to the CID of the corresponding
- * DID Update Payload.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#cidaggregate-beacon | 5.2 CIDAggregate Beacons}.
- */
-export interface DidUpdateBundle {
-  /**
-   * The keys are did:btcr2 identifiers as strings. The values are
-   * IPFS CIDs (or other CAS IDs) referencing the actual DID Update Payload.
-   */
-  [didbtcr2Identifier: string]: string;
-}
-
-/**
- * A container for out-of-band data the resolver may need. This includes the
- * initial DID document if it isn't stored in IPFS, plus references for each
- * on-chain Beacon signal.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#sidecar-initial-document-validation | 4.2.1.2.1 Sidecar Initial Document Validation},
- * {@link https://dcdpr.github.io/did-btcr2/#resolve-target-document | 4.2.2 Resolve Target Document},
- * {@link https://dcdpr.github.io/did-btcr2/#traverse-blockchain-history | 4.2.2.2 Traverse Blockchain History},
- * {@link https://dcdpr.github.io/did-btcr2/#find-next-signals | 4.2.2.3 Find Next Signals}.
- */
-export interface SidecarData {
-  /**
-   * The initial DID Document for an externally created did:btcr2,
-   * if not fetched from IPFS or another CAS.
-   */
-  initialDocument?: Record<string, any>; // or a typed DIDDocument from W3C DID Core
-
-  /**
-   * A map from Bitcoin transaction IDs to the sidecar info about that signal.
-   * Each signal might provide a single DID Update Payload, or (for aggregator beacons)
-   * a bundle or proofs.
-   */
-  signalsMetadata: {
-    [txid: string]: SignalSidecarData;
-  };
-}
-
-/**
- * Sidecar data for a specific Beacon Signal. Different Beacon types store different fields.
- * - SingletonBeacon might just store one `updatePayload`.
- * - CIDAggregateBeacon might store `updateBundle` + an `updatePayload`.
- * - SMTAggregateBeacon might store `updatePayload` + a `smtProof`.
- */
-export interface SignalSidecarData {
-  updatePayload?: DidUpdateInvocation;   // or DidUpdatePayload if not yet invoked
-  updateBundle?: DidUpdateBundle;        // for CIDAggregateBeacon
-  /**
-   * For SMTAggregateBeacon, a Merkle proof that the `updatePayload`
-   * is included (or not included) in the aggregator's Sparse Merkle Tree.
-   */
-  smtProof?: SmtProof;
-}
-
-/**
- * A placeholder for the actual Sparse Merkle Tree inclusion/non-inclusion proof.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#smtaggregate-beacon | 5.3 SMTAggregate Beacon}.
- */
-export interface SmtProof {
-  // Implementation-specific structure for SMT proofs, e.g.:
-  siblingHashes: string[];
-  leafIndex?: string;
-}
-
-/**
- * The known Beacon types from the spec.
- */
-export type BeaconType =
-  | 'SingletonBeacon'
-  | 'CIDAggregateBeacon'
-  | 'SMTAggregateBeacon';
-
-/**
- * Represents a transaction discovered on the Bitcoin blockchain that
- * spends from a Beacon address, thus announcing DID updates.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#find-next-signals | 4.2.2.3 Find Next Signals}
- * and
- * {@link https://dcdpr.github.io/did-btcr2/#process-beacon-signals | 4.2.2.4 Process Beacon Signals}.
- */
-export interface BeaconSignal {
-  /**
-   * The DID Document's `service` ID of the Beacon that produced this signal, e.g. "#cidAggregateBeacon".
-   */
-  beaconId: string;
-
-  /**
-   * The type of Beacon, e.g. "SingletonBeacon".
-   */
-  beaconType: BeaconType;
-
-  /**
-   * The Bitcoin transaction that is the actual on-chain Beacon Signal.
-   * Typically you'd store a minimal subset or a reference/ID for real usage.
-   */
-  tx: any;
-}
-
-/**
- * A ZCAP-LD root capability object that authorizes updates for a particular did:btcr2.
- *
- * DID BTCR2
- * {@link https://dcdpr.github.io/did-btcr2/#derive-root-capability-from-didbtcr2-identifier | 9.4.1 Derive Root Capability from did:btcr2 Identifier}.
- *
- * @example Found in DID BTCR2 Specification Section 9.4.1
- * ```
- * {
- *   "@context": "https://w3id.org/zcap/v1",
- *   "id": "urn:zcap:root:did%3Abtcr2%3Ak1qq...",
- *   "controller": "did:btcr2:k1qq...",
- *   "invocationTarget": "did:btcr2:k1qq..."
- * }
- * ```
- */
-export interface DidBtcr2RootCapability {
-  '@context': string | string[]; // e.g. "https://w3id.org/zcap/v1"
-  id: string;                    // e.g. "urn:zcap:root:<urlencoded-did>"
-  controller: string;           // the DID
-  invocationTarget: string;     // same as DID
-}

package/src/types.ts

@@ -3,6 +3,7 @@ import { HDKey } from '@scure/bip32';
 /* Crypto Types */
 export type Bytes = Uint8Array;
 export type Hex = Bytes | string;
+export type HexString = string;
 export type SignatureHex = Hex;
 export type HashHex = Hex;
 
@@ -25,13 +26,13 @@ export type Point = {
 }
 export type PublicKeyObject = {
   point: Point;
-  hex: Hex;
+  hex: HexString;
   multibase: MultibaseObject;
 };
 export type SecretKeyObject = {
   bytes: Array<number>;
   seed?: string;
-  hex?: Hex;
+  hex?: HexString;
 };
 export type SchnorrKeyPair = {
   secretKey: KeyBytes;
@@ -69,7 +70,6 @@ export enum BitcoinNetworkNames {
 export type DecentralizedIdentifier = string;
 export type Did = DecentralizedIdentifier;
 export type BeaconUri = string;
-export type DidPlaceholder = 'did:btcr2:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
 export type CanonicalizedProofConfig = string;
 export type CryptosuiteName = 'bip340-jcs-2025' | 'bip340-rdfc-2025';
 export type JsonPrimitive = string | number | boolean | null;