@did-btcr2/method 0.23.0 → 0.25.0

package/src/core/resolve.ts

@@ -1,474 +0,0 @@
-import {
-  BitcoinConnection,
-  getNetwork
-} from '@did-btcr2/bitcoin';
-import {
-  Canonicalization,
-  DateUtils,
-  IdentifierHrp,
-  INVALID_DID,
-  INVALID_DID_DOCUMENT,
-  INVALID_DID_UPDATE,
-  JSONPatch,
-  JSONUtils,
-  LATE_PUBLISHING_ERROR,
-  MISSING_UPDATE_DATA,
-  ResolveError
-} from '@did-btcr2/common';
-import {
-  BIP340Cryptosuite,
-  BIP340DataIntegrityProof,
-  SchnorrMultikey,
-  SignedBTCR2Update,
-  UnsignedBTCR2Update
-} from '@did-btcr2/cryptosuite';
-import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
-import { bytesToHex } from '@noble/hashes/utils';
-import { DidBtcr2 } from '../did-btcr2.js';
-import { Appendix } from '../utils/appendix.js';
-import { DidDocument, ID_PLACEHOLDER_VALUE } from '../utils/did-document.js';
-import { BeaconFactory } from './beacon/factory.js';
-import { BeaconService, BlockMetadata } from './beacon/interfaces.js';
-import { BeaconSignalDiscovery } from './beacon/signal-discovery.js';
-import { BeaconUtils } from './beacon/utils.js';
-import { DidComponents, Identifier } from './identifier.js';
-import { SMTProof } from './interfaces.js';
-import { CASAnnouncement, Sidecar, SidecarData } from './types.js';
-
-/**
- * The response object for DID Resolution.
- */
-export interface DidResolutionResponse {
-  didDocument: DidDocument;
-  metadata: {
-    confirmations?: number;
-    versionId: string;
-    updated?: string;
-    deactivated?: boolean;
-  }
-}
-
-/**
- * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html | 7.2 Resolve}.
- * Resolving a did:btcr2 identifier iteratively builds a DID document by applying BTCR2 Updates
- * to an Initial DID Document that have been committed to the Bitcoin blockchain by Authorized
- * Beacon Signals. The Initial DID Document is either deterministically created from the DID or
- * provided by Sidecar Data.
- * @class Resolve
- * @type {Resolve}
- */
-export class Resolve {
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-secp256k1-public-key | 7.2.d.1 if genesis bytes is a secp256k1 Public Key}.
-   * @param {DidComponents} didComponents The decoded components of the did.
-   * @returns {DidDocument} The resolved DID Document object.
-   */
-  static deterministic(didComponents: DidComponents): DidDocument {
-    // Deconstruct the bytes from the given components
-    const { genesisBytes } = didComponents;
-
-    // Encode the did from the didComponents
-    const did = Identifier.encode(genesisBytes, didComponents);
-
-    // Construct a new CompressedSecp256k1PublicKey and deconstruct the publicKey and publicKeyMultibase
-    const { multibase: publicKeyMultibase } = new CompressedSecp256k1PublicKey(genesisBytes);
-
-    // Generate the service field for the DID Document
-    const service = BeaconUtils.generateBeaconServices({
-      id         : did,
-      publicKey  : genesisBytes,
-      network    : getNetwork(didComponents.network),
-      beaconType : 'SingletonBeacon'
-    });
-
-    return new DidDocument({
-      id                 : did,
-      verificationMethod : [{
-        id                 : `${did}#initialKey`,
-        type               : 'Multikey',
-        controller         : did,
-        publicKeyMultibase : publicKeyMultibase.encoded
-      }],
-      service
-    });
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-sha-256-hash | 7.2.d.2 if genesis_bytes is a SHA-256 Hash}.
-   * @param {DidComponents} didComponents BTCR2 DID components used to resolve the DID Document
-   * @param {GenesisDocument} genesisDocument The genesis document for resolving the DID Document.
-   * @returns {Promise<DidDocument>} The resolved DID Document object
-   * @throws {ResolveError} InvalidDidDocument if not conformant to DID Core v1.1
-   */
-  static async external(
-    didComponents: DidComponents,
-    genesisDocument: object,
-  ): Promise<DidDocument> {
-    // Canonicalize and sha256 hash the currentDocument
-    const hashBytes = Canonicalization.process(genesisDocument, { encoding: 'hex' });
-
-    const { genesisBytes } = didComponents;
-
-    // If the genesisBytes do not match the hashBytes, throw an error
-    if (bytesToHex(genesisBytes) !== hashBytes) {
-      throw new ResolveError(
-        `Initial document mismatch: genesisBytes ${bytesToHex(genesisBytes)} !== hashBytes ${hashBytes}`,
-        INVALID_DID_DOCUMENT, { genesisBytes, hashBytes }
-      );
-    }
-
-    // Encode the did from the didComponents
-    const did = Identifier.encode(genesisBytes, didComponents);
-
-    // Replace the placeholder did with the did throughout the currentDocument.
-    const currentDocument = JSON.parse(
-      JSON.stringify(genesisDocument).replaceAll(ID_PLACEHOLDER_VALUE, did)
-    );
-
-    // Return a W3C conformant DID Document
-    return new DidDocument(currentDocument);
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
-   * @param {Sidecar} sidecar The sidecar data to process.
-   * @returns {ProcessedSidecar} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
-   */
-  static sidecarData(sidecar: Sidecar = {} as Sidecar): SidecarData {
-    // BTCR2 Signed Updates map
-    const updateMap = new Map<string, SignedBTCR2Update>();
-    if(sidecar.updates?.length)
-      for(const update of sidecar.updates) {
-        updateMap.set(Canonicalization.process(update, { encoding: 'hex' }), update);
-      }
-
-    // CAS Announcements map
-    const casMap = new Map<string, CASAnnouncement>();
-    if(sidecar.casUpdates?.length)
-      for(const update of sidecar.casUpdates) {
-        casMap.set(Canonicalization.process(update, { encoding: 'hex' }), update);
-      }
-
-    // SMT Proofs map
-    const smtMap = new Map<string, SMTProof>();
-    if(sidecar.smtProofs?.length)
-      for(const proof of sidecar.smtProofs) {
-        smtMap.set(proof.id, proof);
-      }
-
-    return { updateMap, casMap, smtMap };
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#establish-current-document | 7.2.d Establish current_document}.
-   * Resolution begins by creating an Initial Did Document called current_document (Current DID Document).
-   * The current_document is iteratively patched with BTCR2 Signed Updates announced by Authorized Beacon Signals.
-   * @param {DidComponents} didComponents The decoded components of the did.
-   * @param {GenesisDocument} genesisDocument The genesis document for resolving the DID Document.
-   * @returns {Promise<DidDocument>} The resolved DID Document object.
-   * @throws {ResolveError} if the DID hrp is invalid, no sidecarData passed and hrp = "x".
-   */
-
-  static async currentDocument(
-    didComponents: DidComponents,
-    genesisDocument?: object,
-  ): Promise<DidDocument> {
-    // Deconstruct the hrp from the components
-    const { hrp, genesisBytes } = didComponents;
-
-    // If hrp `x`, perform external resolution
-    if (hrp === IdentifierHrp.x) {
-      if(!genesisDocument)
-        throw new ResolveError(
-          'External resolution requires genesisDocument',
-          MISSING_UPDATE_DATA, { didComponents }
-        );
-      return await this.external(didComponents, genesisDocument);
-    }
-
-    // Check for hrp `k`
-    if(hrp === IdentifierHrp.k){
-      // Validate genesis bytes as a compressed secp256k1 public key
-      if(!CompressedSecp256k1PublicKey.isValid(genesisBytes)) {
-        throw new ResolveError(
-          'Deterministic resolution requires valid secp256k1 public key',
-          INVALID_DID, { genesisBytes }
-        );
-      }
-      // Perform deterministic resolution
-      return this.deterministic(didComponents);
-    }
-
-    // Else, throw an error for unsupported hrp
-    throw new ResolveError(`Unsupported DID hrp ${hrp}`, INVALID_DID, { hrp });
-  }
-
-  /**
-   * Finds uses the beacon services in the currentDocument to scan for onchain Beacon Signals (transactions) containing
-   * Signal Bytes (last output in OP_RETURN transaction).
-   * @param {Array<BeaconService>} beaconServices The array of BeaconService objects to search for signals.
-   * @param {SidecarData} sidecarData The sidecar data containing maps of updates, CAS announcements, and SMT proofs.
-   * @param {BitcoinConnection} bitcoin The bitcoin network connection used to fetch beacon signals
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The array of BTCR2 Signed Updates announced by the Beacon Signals.
-   */
-  static async beaconSignals(
-    beaconServices: Array<BeaconService>,
-    sidecarData: SidecarData,
-    bitcoin: BitcoinConnection
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
-    // Discover Beacon Signals via indexer server (esplora/electrs) or full node
-    const beaconServicesSignals = bitcoin.rest
-      ? await BeaconSignalDiscovery.indexer(beaconServices, bitcoin)
-      : await BeaconSignalDiscovery.fullnode(beaconServices, bitcoin);
-
-    // Process each beacon's signals in parallel
-    const promises = await Promise.all(
-      Array.from(beaconServicesSignals.entries()).map(
-        async ([service, signals]) => {
-          // Skip beacons with no signals
-          if (!signals.length) return [];
-          // Establish a typed beacon and process its signals
-          return BeaconFactory.establish(service).processSignals(signals, sidecarData);
-        }
-      )
-    );
-
-    return promises.flat();
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-updates | 7.2.f Process updates Array}.
-   * @param {DidDocument} currentDocument The current DID Document to apply the updates to.
-   * @param {Array<[SignedBTCR2Update, BlockMetadata]>} unsortedUpdates The unsorted array of BTCR2 Signed Updates and their associated Block Metadata.
-   * @param {string} [versionTime] The optional version time to limit updates to.
-   * @param {string} [versionId] The optional version id to limit updates to.
-   * @returns {Promise<DidResolutionResponse>} The updated DID Document, number of confirmations, and version id.
-   */
-  static async updates(
-    currentDocument: DidDocument,
-    unsortedUpdates: Array<[SignedBTCR2Update, BlockMetadata]>,
-    versionTime?: string,
-    versionId?: string
-  ): Promise<DidResolutionResponse> {
-    // Start the version number being processed at 1
-    let currentVersionId = 1;
-
-    // Initialize an empty array to hold the update hashes
-    const updateHashHistory: string[] = [];
-
-    // 1. Sort updates by targetVersionId (ascending), using blockheight as tie-breaker
-    const updates = unsortedUpdates.sort(([upd0, blk0], [upd1, blk1]) =>
-      upd0.targetVersionId - upd1.targetVersionId || blk0.height - blk1.height
-    );
-
-    // Create a default response object
-    const response: DidResolutionResponse = {
-      didDocument : currentDocument,
-      metadata    : {
-        versionId     : `${currentVersionId}`,
-        confirmations : 0,
-        updated       : '',
-        deactivated   : currentDocument.deactivated || false
-      }
-    };
-
-    // Iterate over each (update block) pair
-    for(const [update, block] of updates) {
-      // Get the hash of the current document
-      const currentDocumentHash = Canonicalization.process(response.didDocument, { encoding: 'base58btc' });
-
-      // Safely convert block.time to timestamp
-      const blocktime = DateUtils.blocktimeToTimestamp(block.time);
-
-      // Set the updated field to the blocktime of the current update
-      response.metadata.updated = DateUtils.toISOStringNonFractional(blocktime);
-
-      // Set confirmations to the block confirmations
-      response.metadata.confirmations = block.confirmations;
-
-      // if resolutionOptions.versionTime is defined and the blocktime is more recent, return currentDocument
-      if(versionTime) {
-        // Safely convert versionTime to timestamp
-        if(blocktime > DateUtils.dateStringToTimestamp(versionTime)) {
-          return response;
-        }
-      }
-
-      // Check update.targetVersionId against currentVersionId
-      // If update.targetVersionId <= currentVersionId, confirm duplicate update
-      if(update.targetVersionId <= currentVersionId) {
-        updateHashHistory.push(currentDocumentHash);
-        this.confirmDuplicate(update, updateHashHistory);
-      }
-
-      // If update.targetVersionId == currentVersionId + 1, apply the update
-      else if (update.targetVersionId === currentVersionId + 1) {
-        // Check if update.sourceHash !== currentDocumentHash
-        if (update.sourceHash !== currentDocumentHash) {
-          // Raise an INVALID_DID_UPDATE error if they do not match
-          throw new ResolveError(
-            `Hash mismatch: update.sourceHash !== currentDocumentHash`,
-            INVALID_DID_UPDATE, { sourceHash: update.sourceHash, currentDocumentHash }
-          );
-        }
-        // Apply the update to the currentDocument and set it in the response
-        response.didDocument = await this.applyUpdate(response.didDocument, update);
-
-        // Create unsigned_update by removing the proof property from update.
-        const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']) as UnsignedBTCR2Update;
-        // Push the canonicalized unsigned update hash to the updateHashHistory
-        updateHashHistory.push(Canonicalization.process(unsignedUpdate, { encoding: 'base58btc' }));
-      }
-
-      // If update.targetVersionId > currentVersionId + 1, throw LATE_PUBLISHING error
-      else if(update.targetVersionId > currentVersionId + 1) {
-        throw new ResolveError(
-          `Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`,
-          'LATE_PUBLISHING_ERROR', {
-            targetVersionId  : update.targetVersionId,
-            currentVersionId : currentVersionId + 1
-          }
-        );
-      }
-
-      // Increment currentVersionId
-      currentVersionId++;
-
-      // Set response.versionId to be the new  currentVersionId
-      response.metadata.versionId = `${currentVersionId}`;
-
-      // If resolutionOptions.versionId is defined and <= currentVersionId, return currentDocument
-      if(currentVersionId >= Number(versionId)) {
-        return response;
-      }
-
-      // Check if the current document is deactivated before further processing
-      if(currentDocument.deactivated) {
-        // Set the response deactivated flag to true
-        response.metadata.deactivated = currentDocument.deactivated;
-        // If deactivated, stop processing further updates and return the response
-        return response;
-      }
-    }
-
-    // Return response data
-    return response;
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.f.1 Confirm Duplicate Update}.
-   * This step confirms that an update with a lower-than-expected targetVersionId is a true duplicate.
-   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to confirm as a duplicate.
-   * @returns {void} Does not return a value, but throws an error if the update is not a valid duplicate.
-   */
-  static confirmDuplicate(update: SignedBTCR2Update, updateHashHistory: string[]): void {
-    // Create unsigned_update by removing the proof property from update.
-    const { proof: _, ...unsignedUpdate } = update;
-
-    // Hash unsignedUpdate with JSON Document Hashing algorithm
-    const unsignedUpdateHash = Canonicalization.process(unsignedUpdate);
-
-    // Let historicalUpdateHash equal updateHashHistory[updateHashIndex].
-    const historicalUpdateHash = updateHashHistory[update.targetVersionId - 2];
-
-    // Check if the updateHash matches the historical hash
-    if (updateHashHistory[update.targetVersionId - 2] !== unsignedUpdateHash) {
-      throw new ResolveError(
-        `Invalid duplicate: ${unsignedUpdateHash} does not match ${historicalUpdateHash}`,
-        LATE_PUBLISHING_ERROR, { unsignedUpdateHash, updateHashHistory }
-      );
-    }
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#apply-update | 7.2.f.3 Apply Update}.
-   * @param {DidDocument} currentDocument The current DID Document to apply the update to.
-   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to apply.
-   * @returns {Promise<DidDocument>} The updated DID Document after applying the update.
-   * @throws {ResolveError} If the update is invalid or cannot be applied.
-   */
-  static async applyUpdate(
-    currentDocument: DidDocument,
-    update: SignedBTCR2Update
-  ): Promise<DidDocument> {
-    // Get the capability id from the to update proof.
-    const capabilityId = update.proof?.capability;
-    // Since this field is optional, check that it exists
-    if (!capabilityId) {
-      // If it does not exist, throw INVALID_DID_UPDATE error
-      throw new ResolveError('No root capability found in update', INVALID_DID_UPDATE, update);
-    }
-
-    // Get the root capability object by dereferencing the capabilityId
-    const rootCapability = Appendix.dereferenceZcapId(capabilityId);
-
-    // Deconstruct the invocationTarget and controller from the root capability
-    const { invocationTarget, controller: rootController } = rootCapability;
-    // Check that both invocationTarget and rootController equal currentDocument.id
-    if (![invocationTarget, rootController].every((id) => id === currentDocument.id)) {
-      // If they do not all match, throw INVALID_DID_UPDATE error
-      throw new ResolveError(
-        'Invalid root capability',
-        INVALID_DID_UPDATE, { rootCapability, currentDocument }
-      );
-    }
-
-    // Get the verificationMethod field from the update proof as verificationMethodId.
-    const verificationMethodId = update.proof?.verificationMethod;
-    // Since this field is optional, check that it exists
-    if(!verificationMethodId) {
-      // If it does not exist, throw INVALID_DID_UPDATE error
-      throw new ResolveError('No verificationMethod found in update', INVALID_DID_UPDATE, update);
-    }
-
-    // Get the verificationMethod from the DID Document using the verificationMethodId.
-    const vm = DidBtcr2.getSigningMethod(currentDocument, verificationMethodId);
-
-    // Construct a new SchnorrMultikey.
-    const multikey = SchnorrMultikey.fromVerificationMethod(vm);
-
-    // Construct a new BIP340Cryptosuite with the SchnorrMultikey.
-    const cryptosuite = new BIP340Cryptosuite(multikey);
-
-    // Canonicalize the update
-    const canonicalUpdate = Canonicalization.canonicalize(update);
-
-    // Construct a DataIntegrityProof with the cryptosuite
-    const diProof = new BIP340DataIntegrityProof(cryptosuite);
-
-    // Call the verifyProof method
-    const verificationResult = diProof.verifyProof(canonicalUpdate, 'capabilityInvocation');
-
-    // If the result is not verified, throw INVALID_DID_UPDATE error
-    if (!verificationResult.verified) {
-      throw new ResolveError(
-        'Invalid update: proof not verified',
-        INVALID_DID_UPDATE, verificationResult
-      );
-    }
-
-    // Apply the update.patch to the currentDocument to get the updatedDocument.
-    const updatedDocument = JSONPatch.apply(currentDocument, update.patch) as DidDocument;
-
-    // Verify that updatedDocument is conformant to DID Core v1.1.
-    DidDocument.validate(updatedDocument);
-
-    // Canonicalize and hash the updatedDocument to get the currentDocumentHash.
-    const currentDocumentHash = Canonicalization.process(updatedDocument, { encoding: 'base58btc' });
-
-    // Prepare the update targetHash for comparison with currentDocumentHash.
-    const updateTargetHash = update.targetHash;
-
-    // Make sure the update.targetHash equals currentDocumentHash.
-    if (update.targetHash !== currentDocumentHash) {
-      // If they do not match, throw INVALID_DID_UPDATE error.
-      throw new ResolveError(
-        `Invalid update: update.targetHash !== currentDocumentHash`,
-        INVALID_DID_UPDATE, { updateTargetHash, currentDocumentHash }
-      );
-    }
-
-    //  Return final updatedDocument.
-    return updatedDocument;
-  }
-}

package/src/utils/general.ts

@@ -1,204 +0,0 @@
-import { KeyBytes, BIP340_PUBLIC_KEY_MULTIBASE_PREFIX, HdWallet } from '@did-btcr2/common';
-import { sha256 } from '@noble/hashes/sha2';
-import { CURVE, getPublicKey, utils } from '@noble/secp256k1';
-import { HDKey } from '@scure/bip32';
-import { generateMnemonic, mnemonicToSeed } from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { base58btc } from 'multiformats/bases/base58';
-
-/**
- * Static class of general utility functions for the did-btcr2 spec implementation
- * @class GeneralUtils
- * @type {GeneralUtils}
- */
-export class GeneralUtils {
-  /**
-   * Helper function to encode a secp256k1 key in SchnorrSecp256k1 Multikey Format
-   * @param {KeyBytes} xOnlyKeyBytes
-   * @returns {PublicKeyMultibase}
-   */
-  public static encode(xOnlyKeyBytes: KeyBytes): string {
-    if (xOnlyKeyBytes.length !== 32) {
-      throw new Error('x-only public key must be 32 bytes');
-    }
-    const prefix = Array.from(BIP340_PUBLIC_KEY_MULTIBASE_PREFIX);
-    const x = Array.from(xOnlyKeyBytes);
-    // Set the prefix and the public key bytes
-    const multikeyBytes = new Uint8Array([...prefix, ...x]);
-    // Encode the public key as a multibase base58btc string
-    return base58btc.encode(multikeyBytes);
-  }
-
-  /**
-   * Converts a bigint to a buffer
-   * @param {bigint} value The bigint to convert
-   * @returns {Buffer} The buffer representation of the bigint
-   */
-  static bigintToBuffer(value: bigint): Buffer {
-    const hex = value.toString(16).padStart(64, '0');
-    return Buffer.from(hex, 'hex');
-  }
-
-  /**
-   * Generates a new mnemonic phrase and HD wallet
-   * @returns {HdWallet} Promise resolving to a new hdwallet object w/ mnemonic and hdkey
-   * @throws {Error} if the public key bytes cannot be derived
-   */
-  static async generateHdWallet(): Promise<HdWallet> {
-    // Generate random mnemonic phrase.
-    const mnemonic = generateMnemonic(wordlist, 128);
-    // Generate seed from random mnemonic phrase.
-    const seed = await mnemonicToSeed(mnemonic);
-    // Generate HDKey from seed.
-    const hdkey = HDKey.fromMasterSeed(seed);
-    // Ensure HDKey returns valid
-    if (!hdkey) {
-      throw new Error('Failed to derive hd wallet');
-    }
-    return { mnemonic, hdkey };
-  }
-
-  static generateCompressedSecp256k1KeyPair(){
-    const privateKey = utils.randomPrivateKey();
-    if(!utils.isValidPrivateKey(privateKey)) {
-      throw new Error('Invalid private key');
-    }
-    return { privateKey, publicKey: getPublicKey(privateKey, true) };
-  };
-
-  /**
-   * Recovers an HDKey from a mnemonic phrase
-   * @param {string} mnemonic The mnemonic phrase to recover the HDKey from
-   * @param {Uint8Array} seed Optional seed to recover the HDKey from
-   * @returns {HDKey} Promise resolving to the recovered HDKey
-   * @throws Error if the HDKey cannot be recovered
-   */
-  static async recoverHdWallet(mnemonic: string, seed?: Uint8Array): Promise<HDKey> {
-    seed ??= await mnemonicToSeed(mnemonic);
-    // Generate HDKey from seed.
-    const hdkey = HDKey.fromMasterSeed(seed);
-    // Ensure HDKey returns valid
-    if (!hdkey) {
-      throw new Error('Failed to recover hdkey');
-    }
-    // Return the HDKey
-    return hdkey;
-  }
-
-  /**
-   * Recovers a secp256k1 privateKey from its original entropy
-   * @param {Uint8Array} xorEntropy The original entropy to recover the privateKey from
-   * @param {Uint8Array} salt The salt used to tweak the privateKey
-   * @returns {Uint8Array} The recovered privateKey
-   * @throws {Error} if the privateKey cannot be recovered
-   */
-  static recoverTweakedRawPrivateKey(xorEntropy: Uint8Array, salt: Uint8Array): Uint8Array {
-    // If entropy is not 32 bytes, hash it to get a deterministic 32-byte private key
-    if (xorEntropy.length !== 32) {
-      xorEntropy = sha256(xorEntropy);
-    }
-    const entropy = this.XNOR(xorEntropy, salt);
-    // Convert entropy to hex
-    const hexEntropy = Buffer.from(entropy).toString('hex');
-    // Convert hexEntropy to BigInt
-    const privateKey = BigInt(`0x${hexEntropy}`);
-    // Ensure private key is in valid secp256k1 range1
-    if (privateKey < BigInt(1) || privateKey >= CURVE.n) {
-      throw new Error('Invalid private key derived from entropy');
-    }
-    // The valid 32-byte private key
-    return entropy;
-  }
-
-  /**
-   * Recovers a secp256k1 privateKey from its original entropy
-   * @param {Uint8Array} entropy The entropy to recover the privateKey from
-   * @returns {Uint8Array} The recovered privateKey
-   * @throws {Error} if the privateKey cannot be recovered
-   */
-  static recoverRawPrivateKey(entropy: Uint8Array): Uint8Array {
-    // If entropy is not 32 bytes, hash it to get a deterministic 32-byte private key
-    if (entropy.length !== 32) {
-      entropy = sha256(entropy);
-    }
-    // Convert entropy to hex
-    const hexEntropy = Buffer.from(entropy).toString('hex');
-    // Convert hexEntropy to BigInt
-    const privateKey = BigInt(`0x${hexEntropy}`);
-    // Ensure private key is in valid secp256k1 range1
-    if (privateKey < BigInt(1) || privateKey >= CURVE.n) {
-      throw new Error('Invalid private key derived from entropy');
-    }
-    // The valid 32-byte private key
-    return entropy;
-  }
-
-  /**
-   * Tweak the entropy with a salt using XOR
-   * @param {Uint8Array} entropy The entropy to tweak
-   * @param {Uint8Array} salt The salt to tweak the entropy with
-   * @returns {Uint8Array} The tweaked entropy
-   */
-  static XOR(entropy: Uint8Array, salt: Uint8Array): Uint8Array {
-    const tweaked = new Uint8Array(entropy.length);
-    for (let i = 0; i < entropy.length; i++) {
-      tweaked[i] = entropy[i] ^ salt[i % salt.length]; // XOR with repeating salt
-    }
-    return tweaked;
-  }
-
-  /**
-   * Untweak the entropy with a salt using XNOR
-   *
-   * @param {Uint8Array} tweakedEntropy The tweaked entropy to untweak
-   * @param {Uint8Array} salt The salt to untweak the entropy with
-   * @returns {Uint8Array} The original entropy
-   */
-  static XNOR(tweakedEntropy: Uint8Array, salt: Uint8Array): Uint8Array {
-    const originalEntropy = new Uint8Array(tweakedEntropy.length);
-    for (let i = 0; i < tweakedEntropy.length; i++) {
-      originalEntropy[i] = tweakedEntropy[i] ^ salt[i % salt.length]; // XOR with salt again
-    }
-    return originalEntropy;
-  }
-
-  /**
-   * Recovers an HDKey from a mnemonic phrase
-   * @param {string} mnemonic The mnemonic phrase to recover the HDKey from
-   * @param {string} path The path to derive the child key from
-   * @returns {Uint8Array} Promise resolving to the recovered private key bytes
-   * @throws {Error} if the HDKey cannot be recovered
-   */
-  static async recoverHdChildFromMnemonic(mnemonic: string, path: string): Promise<Uint8Array> {
-    // Generate HDKey from seed.
-    const hdkey = await this.recoverHdWallet(mnemonic);
-    // Ensure HDKey returns valid
-    if (!hdkey) {
-      throw new Error('Failed to recover hdkey');
-    }
-    // Return the privateKey of the derived childKey
-    const childPrivKeyBytes = hdkey.derive(path).privateKey;
-    if (!childPrivKeyBytes) {
-      throw new Error('Failed to recover child private key');
-    }
-    return childPrivKeyBytes;
-  }
-
-  /**
-   * Derives a child key from an HDKey
-   * @param {HDKey} hdkey The HDKey to derive the child key from
-   * @param {string} path The path to derive the child key from
-   * @returns {HDKey} A Promise resolving to the child key
-   * @throws {Error} Error if the child key cannot be derived
-   */
-  static deriveChildKey(hdkey: HDKey, path: string): HDKey {
-    // Derive child key from HDKey.
-    const childKey = hdkey.derive(path);
-    // Ensure child key returns valid
-    if (!childKey) {
-      throw new Error(`Failed to derive child key`);
-    }
-    // Return the child key
-    return childKey;
-  }
-}