@did-btcr2/method 0.15.0 → 0.17.0

package/dist/browser.js

@@ -7362,7 +7362,7 @@ var BTCR2 = (() => {
           return false;
         }
       }
-      function isPoint3(p3) {
+      function isPoint4(p3) {
         return _isPoint(p3, false);
       }
       function isPointCompressed(p3) {
@@ -7389,7 +7389,7 @@ var BTCR2 = (() => {
         });
       }
       function xOnlyPointFromPoint(p3) {
-        if (!isPoint3(p3)) {
+        if (!isPoint4(p3)) {
           throw new Error(THROW_BAD_POINT);
         }
         return p3.slice(1, 33);
@@ -7409,13 +7409,13 @@ var BTCR2 = (() => {
         return xOnlyPointFromPoint(pointFromScalar2(d2));
       }
       function pointCompress(p3, compressed) {
-        if (!isPoint3(p3)) {
+        if (!isPoint4(p3)) {
           throw new Error(THROW_BAD_POINT);
         }
         return fromHex2(p3).toRawBytes(assumeCompression(compressed, p3));
       }
       function pointMultiply(a3, tweak, compressed) {
-        if (!isPoint3(a3)) {
+        if (!isPoint4(a3)) {
           throw new Error(THROW_BAD_POINT);
         }
         if (!isTweak(tweak)) {
@@ -7426,7 +7426,7 @@ var BTCR2 = (() => {
         );
       }
       function pointAdd2(a3, b2, compressed) {
-        if (!isPoint3(a3) || !isPoint3(b2)) {
+        if (!isPoint4(a3) || !isPoint4(b2)) {
           throw new Error(THROW_BAD_POINT);
         }
         return throwToNull(() => {
@@ -7440,7 +7440,7 @@ var BTCR2 = (() => {
         });
       }
       function pointAddScalar(p3, tweak, compressed) {
-        if (!isPoint3(p3)) {
+        if (!isPoint4(p3)) {
           throw new Error(THROW_BAD_POINT);
         }
         if (!isTweak(tweak)) {
@@ -7534,7 +7534,7 @@ var BTCR2 = (() => {
         return Q.toRawBytes(assumeCompression(compressed));
       }
       function verify(h2, Q, signature2, strict) {
-        if (!isPoint3(Q)) {
+        if (!isPoint4(Q)) {
           throw new Error(THROW_BAD_POINT);
         }
         if (!isSignature(signature2)) {
@@ -7557,7 +7557,7 @@ var BTCR2 = (() => {
         }
         return secp256k13.schnorr.verify(signature2, h2, Q);
       }
-      exports.isPoint = isPoint3;
+      exports.isPoint = isPoint4;
       exports.isPointCompressed = isPointCompressed;
       exports.isPrivate = isPrivate3;
       exports.isXOnlyPoint = isXOnlyPoint;
@@ -30638,7 +30638,7 @@ var BTCR2 = (() => {
       EDDSA.prototype.decodeInt = function decodeInt(bytes3) {
         return utils3.intFromLE(bytes3);
       };
-      EDDSA.prototype.isPoint = function isPoint3(val) {
+      EDDSA.prototype.isPoint = function isPoint4(val) {
         return val instanceof this.pointClass;
       };
     }
@@ -32250,13 +32250,13 @@ var BTCR2 = (() => {
           ).optional()
         );
       });
-      var PublicKey4 = asn1.define("SubjectPublicKeyInfo", function() {
+      var PublicKey3 = asn1.define("SubjectPublicKeyInfo", function() {
         this.seq().obj(
           this.key("algorithm").use(AlgorithmIdentifier2),
           this.key("subjectPublicKey").bitstr()
         );
       });
-      exports.PublicKey = PublicKey4;
+      exports.PublicKey = PublicKey3;
       var PrivateKeyInfo2 = asn1.define("PrivateKeyInfo", function() {
         this.seq().obj(
           this.key("version")["int"](),
@@ -45004,11 +45004,11 @@ var BTCR2 = (() => {
             };
             metadataRegistry.registerProvider(provider);
             return provider;
-            function GetOrCreateMetadataMap(O, P3, Create2) {
+            function GetOrCreateMetadataMap(O, P3, Create) {
               var targetMetadata = metadata2.get(O);
               var createdTargetMetadata = false;
               if (IsUndefined(targetMetadata)) {
-                if (!Create2)
+                if (!Create)
                   return void 0;
                 targetMetadata = new _Map();
                 metadata2.set(O, targetMetadata);
@@ -45016,7 +45016,7 @@ var BTCR2 = (() => {
               }
               var metadataMap = targetMetadata.get(P3);
               if (IsUndefined(metadataMap)) {
-                if (!Create2)
+                if (!Create)
                   return void 0;
                 metadataMap = new _Map();
                 targetMetadata.set(P3, metadataMap);
@@ -45143,12 +45143,12 @@ var BTCR2 = (() => {
             };
             return provider;
           }
-          function GetMetadataProvider(O, P3, Create2) {
+          function GetMetadataProvider(O, P3, Create) {
             var registeredProvider = metadataRegistry.getProvider(O, P3);
             if (!IsUndefined(registeredProvider)) {
               return registeredProvider;
             }
-            if (Create2) {
+            if (Create) {
               if (metadataRegistry.setProvider(O, P3, metadataProvider)) {
                 return metadataProvider;
               }
@@ -45987,17 +45987,17 @@ var BTCR2 = (() => {
   __export(index_exports, {
     Appendix: () => Appendix,
     BECH32M_CHARS: () => BECH32M_CHARS,
-    BTC1_DID_REGEX: () => BTC1_DID_REGEX,
     Beacon: () => Beacon,
     BeaconFactory: () => BeaconFactory,
     BeaconUtils: () => BeaconUtils,
-    Btc1Deactivate: () => Btc1Deactivate,
-    Btc1DidDocumentBuilder: () => Btc1DidDocumentBuilder,
     CIDAggregateBeacon: () => CIDAggregateBeacon,
-    Create: () => Create,
+    DID_REGEX: () => DID_REGEX,
+    Deactivate: () => Deactivate,
     DidBtcr2: () => DidBtcr2,
     DidDocument: () => DidDocument2,
+    DidDocumentBuilder: () => DidDocumentBuilder,
     DidVerificationMethod: () => DidVerificationMethod,
+    Document: () => Document,
     GeneralUtils: () => GeneralUtils,
     Identifier: () => Identifier,
     IntermediateDidDocument: () => IntermediateDidDocument,
@@ -48457,8 +48457,8 @@ var BTCR2 = (() => {
      *
      * 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:btc1s 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
+     * 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.
@@ -48713,21 +48713,21 @@ var BTCR2 = (() => {
   var TXIN_WITNESS_COINBASE = "0000000000000000000000000000000000000000000000000000000000000000";
   var GENESIS_TX_ID = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
   var DEFAULT_BITCOIN_NETWORK_CONFIG = {
-    mainnet: {
+    bitcoin: {
       rpc: void 0,
-      rest: { host: "https://mempool.space/api" }
+      rest: { host: "https://mempool.holdings/api" }
     },
     testnet3: {
       rpc: void 0,
-      rest: { host: "https://mempool.space/testnet/api" }
+      rest: { host: "https://mempool.holdings/testnet/api" }
     },
     testnet4: {
       rpc: void 0,
-      rest: { host: "https://mempool.space/testnet4/api" }
+      rest: { host: "https://mempool.holdings/testnet4/api" }
     },
     signet: {
       rpc: void 0,
-      rest: { host: "https://mempool.space/signet/api" }
+      rest: { host: "https://mempool.holdings/signet/api" }
     },
     mutinynet: {
       rpc: void 0,
@@ -48863,7 +48863,7 @@ var BTCR2 = (() => {
     allowDefaultWallet;
     constructor(options2 = {
       headers: {},
-      host: "localhost",
+      host: "http://localhost",
       logger: console,
       password: "",
       timeout: 3e4,
@@ -48932,8 +48932,8 @@ var BTCR2 = (() => {
             u.password = "";
             this.url = u.toString().replace(/\/+$/, "");
           }
-        } catch {
-          console.error("Invalid URL in Bitcoin RPC config");
+        } catch (error) {
+          console.error(`Invalid URL in Bitcoin RPC config: ${this.url}`, error);
         }
       }
     }
@@ -57649,7 +57649,7 @@ var BTCR2 = (() => {
   // ../bitcoin/dist/esm/bitcoin.js
   var BitcoinNetworkConnection = class {
     network;
-    mainnet;
+    bitcoin;
     testnet3;
     testnet4;
     signet;
@@ -57670,7 +57670,7 @@ var BTCR2 = (() => {
         throw new MethodError("Parsing failed: malformed BITCOIN_NETWORK_CONFIG", "MISSING_MALFORMED_BITCOIN_NETWORK_CONFIG", { BITCOIN_NETWORK_CONFIG });
       }
       const networkConfigs = JSON.parse(BITCOIN_NETWORK_CONFIG);
-      const networks2 = ["mainnet", "testnet3", "testnet4", "signet", "mutinynet", "regtest"];
+      const networks2 = ["bitcoin", "testnet3", "testnet4", "signet", "mutinynet", "regtest"];
       for (const network of networks2) {
         const networkConfig = configs?.[network] ?? networkConfigs[network];
         if (networkConfig) {
@@ -57694,7 +57694,7 @@ var BTCR2 = (() => {
     }
     /**
      * Get the Bitcoin network configuration for a specific network.
-     * @param {keyof AvailableNetworks} network - The Bitcoin network (e.g., 'mainnet', 'testnet3', 'signet', 'regtest').
+     * @param {keyof AvailableNetworks} network - The Bitcoin network (e.g., 'bitcoin', 'testnet3', 'signet', 'regtest').
      * @returns {Bitcoin} The Bitcoin object.
      */
     getNetworkConnection(network) {
@@ -57706,7 +57706,7 @@ var BTCR2 = (() => {
     }
     /**
      * Sets the active Bitcoin network.
-     * @param {keyof AvailableNetworks} active - The Bitcoin network to set as active (e.g., 'mainnet', 'testnet3', 'signet', 'regtest').
+     * @param {keyof AvailableNetworks} active - The Bitcoin network to set as active (e.g., 'bitcoin', 'testnet3', 'signet', 'regtest').
      * @throws {MethodError} If no configuration is found for the specified network.
      */
     setActiveNetwork(active) {
@@ -57740,7 +57740,7 @@ var BTCR2 = (() => {
 
   // ../bitcoin/dist/esm/taproot.js
   init_shim();
-  var tinysecp2 = __toESM(require_dist2(), 1);
+  var tinysecp3 = __toESM(require_dist2(), 1);
 
   // ../keypair/dist/esm/index.js
   init_shim();
@@ -57750,12 +57750,13 @@ var BTCR2 = (() => {
 
   // ../keypair/dist/esm/public.js
   init_shim();
+  var tinysecp2 = __toESM(require_dist2(), 1);
 
   // ../keypair/dist/esm/secret.js
   init_shim();
   var import_crypto3 = __toESM(require_crypto_browserify(), 1);
   var tinysecp = __toESM(require_dist2(), 1);
-  var SecretKey = class _SecretKey {
+  var Secp256k1SecretKey = class _Secp256k1SecretKey {
     /** @type {KeyBytes} The entropy for the secret key as a byte array */
     _bytes;
     /** @type {bigint} The entropy for the secret key as a bigint */
@@ -57763,7 +57764,7 @@ var BTCR2 = (() => {
     /** @type {string} The secret key as a secretKeyMultibase */
     _multibase;
     /**
-     * Instantiates an instance of SecretKey.
+     * Instantiates an instance of Secp256k1SecretKey.
      * @param {Entropy} entropy bytes (Uint8Array) or secret (bigint)
      * @throws {SecretKeyError} If entropy is not provided, not a valid 32-byte secret key or not a valid bigint seed
      */
@@ -57775,10 +57776,10 @@ var BTCR2 = (() => {
       }
       if (isBytes9 && entropy.length === 32) {
         this._bytes = entropy;
-        this._seed = _SecretKey.toSecret(entropy);
+        this._seed = _Secp256k1SecretKey.toSecret(entropy);
       }
       if (isSecret && !(entropy < 1n || entropy >= CURVE.n)) {
-        this._bytes = _SecretKey.toBytes(entropy);
+        this._bytes = _Secp256k1SecretKey.toBytes(entropy);
         this._seed = entropy;
       }
       if (!this._bytes || this._bytes.length !== 32) {
@@ -57835,7 +57836,7 @@ var BTCR2 = (() => {
     }
     /**
      * Checks if this secret key is equal to another.
-     * @param {SecretKey} other The other secret key
+     * @param {Secp256k1SecretKey} other The other secret key
      * @returns {boolean} True if the private keys are equal, false otherwise
      */
     equals(other) {
@@ -57843,7 +57844,7 @@ var BTCR2 = (() => {
     }
     /**
      * Computes the public key from the secret key bytes.
-     * @returns {KeyBytes} The computed public key
+     * @returns {CompressedSecp256k1PublicKey} The computed public key
      */
     computePublicKey() {
       const publicKeyBytes = tinysecp.pointFromScalar(this.bytes, true);
@@ -57853,7 +57854,7 @@ var BTCR2 = (() => {
       if (publicKeyBytes.length !== 33) {
         throw new SecretKeyError("Invalid compute: public key not compressed format", "COMPUTE_PUBLIC_KEY_ERROR");
       }
-      return publicKeyBytes;
+      return new CompressedSecp256k1PublicKey(publicKeyBytes);
     }
     /**
      * Converts the secret key to a JSON object.
@@ -57875,10 +57876,10 @@ var BTCR2 = (() => {
     }
     /**
      * Checks if the public key is a valid secp256k1 point.
-     * @param {PublicKey} pk The public key to validate
      * @returns {boolean} True if the public key is valid, false otherwise
      */
-    isValidPair(pk) {
+    hasValidPublicKey() {
+      const pk = this.computePublicKey();
       if (!tinysecp.isPoint(pk.compressed)) {
         return false;
       }
@@ -57902,21 +57903,21 @@ var BTCR2 = (() => {
       return decoded;
     }
     /**
-     * Creates a SecretKey object from a JSON object.
+     * Creates a Secp256k1SecretKey object from a JSON object.
      * @param {SecretKeyObject} json The JSON object containing the secret key bytes
-     * @returns {SecretKey} A new SecretKey object
+     * @returns {Secp256k1SecretKey} A new Secp256k1SecretKey object
      */
     static fromJSON(json) {
-      return new _SecretKey(new Uint8Array(json.bytes));
+      return new _Secp256k1SecretKey(new Uint8Array(json.bytes));
     }
     /**
-     * Converts a SecretKey or KeyBytes to a Pair.
-     * @param {KeyBytes} bytes
+     * Converts a Secp256k1SecretKey or KeyBytes to a SchnorrKeyPair.
+     * @param {KeyBytes} bytes The secret key bytes
      * @returns {SchnorrKeyPair} The SchnorrKeyPair object containing the public and private keys
      * @throws {SecretKeyError} If the secret key is not valid
      */
     static toKeyPair(bytes3) {
-      const secretKey = new _SecretKey(bytes3);
+      const secretKey = new _Secp256k1SecretKey(bytes3);
       const publicKey2 = secretKey.computePublicKey();
       return new SchnorrKeyPair({ publicKey: publicKey2, secretKey });
     }
@@ -57941,14 +57942,14 @@ var BTCR2 = (() => {
       return new Uint8Array(bytes3);
     }
     /**
-     * Creates a new SecretKey object from a bigint secret.
-     * @param {bigint} secret The secret bigint
-     * @returns {SecretKey} A new SecretKey object
+     * Creates a new Secp256k1SecretKey object from a bigint secret.
+     * @param {bigint} entropy The secret bigint
+     * @returns {Secp256k1SecretKey} A new Secp256k1SecretKey object
      */
-    static fromSecret(secret) {
-      const hexsecret = secret.toString(16).padStart(64, "0");
+    static fromEntropy(entropy) {
+      const hexsecret = entropy.toString(16).padStart(64, "0");
       const privateKeyBytes = new Uint8Array(hexsecret.match(/.{2}/g).map((byte) => parseInt(byte, 16)));
-      return new _SecretKey(privateKeyBytes);
+      return new _Secp256k1SecretKey(privateKeyBytes);
     }
     /**
      * Generates random secret key bytes.
@@ -57959,35 +57960,35 @@ var BTCR2 = (() => {
       return (0, import_crypto3.getRandomValues)(byteArray);
     }
     /**
-     * Creates a new SecretKey from random secret key bytes.
-     * @returns {SecretKey} A new SecretKey object
+     * Creates a new Secp256k1SecretKey from random secret key bytes.
+     * @returns {Secp256k1SecretKey} A new Secp256k1SecretKey object
      */
     static generate() {
       const randomBytes7 = this.random();
-      return new _SecretKey(randomBytes7);
+      return new _Secp256k1SecretKey(randomBytes7);
     }
     /**
      * Generates a public key from the given secret key bytes.
      * @param {KeyBytes} bytes The secret key bytes
-     * @returns {KeyBytes} The computed public key bytes
+     * @returns {CompressedSecp256k1PublicKey} The computed public key bytes
      */
     static getPublicKey(bytes3) {
-      return new _SecretKey(bytes3).computePublicKey();
+      return new _Secp256k1SecretKey(bytes3).computePublicKey();
     }
   };
 
   // ../keypair/dist/esm/public.js
-  var PublicKey = class _PublicKey {
+  var CompressedSecp256k1PublicKey = class _CompressedSecp256k1PublicKey {
     /** @type {KeyBytes} The public key bytes */
     _bytes;
     /** @type {MultibaseObject} The public key as a MultibaseObject */
     _multibase = {
       prefix: BIP340_PUBLIC_KEY_MULTIBASE_PREFIX,
       key: [],
-      address: ""
+      encoded: ""
     };
     /**
-     * Creates a PublicKey instance.
+     * Creates a CompressedSecp256k1PublicKey instance.
      * @param {KeyBytes} bytes The public key byte array.
      * @throws {PublicKeyError} if the byte length is not 32 (x-only) or 33 (compressed)
      */
@@ -57995,8 +57996,11 @@ var BTCR2 = (() => {
       if (bytes3.length !== 33) {
         throw new PublicKeyError("Invalid argument: byte length must be 33 (compressed)", "CONSTRUCTOR_ERROR", { bytes: bytes3 });
       }
+      if (!tinysecp2.isPoint(bytes3)) {
+        throw new PublicKeyError("Invalid argument: bytes are not a valid secp256k1 compressed point", "CONSTRUCTOR_ERROR", { bytes: bytes3 });
+      }
       this._bytes = bytes3;
-      this._multibase.address = this.encode();
+      this._multibase.encoded = this.encode();
       this._multibase.key = [...this._multibase.prefix, ...this.compressed];
     }
     /**
@@ -58016,13 +58020,30 @@ var BTCR2 = (() => {
       return uncompressed;
     }
     /**
-     * Get the parity byte of the public key.
-     * @returns {number} The parity byte of the public key.
+     * X-only (32-byte) view of the public key per BIP-340.
+     */
+    get xOnly() {
+      return this._bytes.slice(1);
+    }
+    /**
+     * Parity of the SEC compressed public key.
+     * @returns {0x02 | 0x03} The parity byte (0x02 if even, 0x03 if odd).
+     * @throws {PublicKeyError} If the parity byte is not 0x02 or 0x03.
      */
     get parity() {
-      const parity = this.compressed[0];
+      const parity = this._bytes[0];
+      if (![2, 3].includes(parity)) {
+        throw new PublicKeyError("Invalid state: parity byte must be 2 or 3", "PARITY_ERROR", { parity });
+      }
       return parity;
     }
+    /**
+     * Whether the SEC compressed public key has even Y.
+     * @returns {boolean} True if the public key has even Y.
+     */
+    get isEven() {
+      return this._bytes[0] === 2;
+    }
     /**
      * Get the x-coordinate of the public key.
      * @returns {Uint8Array} The 32-byte x-coordinate of the public key.
@@ -58065,6 +58086,13 @@ var BTCR2 = (() => {
         y: this.y
       };
     }
+    /**
+     * Returns the BIP-340 (x-only) representation of this key.
+     * @returns {KeyBytes} The BIP-340 (x-only) representation of the public key.
+     */
+    bip340() {
+      return this.xOnly;
+    }
     /**
      * Returns the point of the public key.
      * @param {Hex} pk The public key in hex (Uint8Array or string) format.
@@ -58073,11 +58101,11 @@ var BTCR2 = (() => {
      */
     static point(pk) {
       if (typeof pk === "string" && /^[0-9a-fA-F]+$/.test(pk)) {
-        const publicKey2 = new _PublicKey(import_buffer.Buffer.fromHex(pk));
+        const publicKey2 = new _CompressedSecp256k1PublicKey(import_buffer.Buffer.fromHex(pk));
         return publicKey2.point;
       }
       if (pk instanceof Uint8Array || ArrayBuffer.isView(pk)) {
-        const publicKey2 = new _PublicKey(pk);
+        const publicKey2 = new _CompressedSecp256k1PublicKey(pk);
         return publicKey2.point;
       }
       throw new PublicKeyError("Invalid publicKey: must be a hex string or byte array", "POINT_ERROR", { publicKey: pk });
@@ -58087,7 +58115,7 @@ var BTCR2 = (() => {
      * @returns {KeyBytes} The decoded public key: prefix and public key bytes
      */
     decode() {
-      const decoded = base58btc.decode(this.multibase.address);
+      const decoded = base58btc.decode(this.multibase.encoded);
       if (decoded.length !== 35) {
         throw new PublicKeyError("Invalid argument: must be 35 byte publicKeyMultibase", "DECODE_MULTIBASE_ERROR");
       }
@@ -58113,15 +58141,15 @@ var BTCR2 = (() => {
     }
     /**
      * Compares this public key to another public key.
-     * @param {PublicKey} other The other public key to compare
+     * @param {CompressedSecp256k1PublicKey} other The other public key to compare
      * @returns {boolean} True if the public keys are equal, false otherwise.
      */
     equals(other) {
       return this.hex === other.hex;
     }
     /**
-     * JSON representation of a PublicKey object.
-     * @returns {PublicKeyObject} The PublicKey as a JSON object.
+     * JSON representation of a CompressedSecp256k1PublicKey object.
+     * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
      */
     json() {
       return {
@@ -58135,26 +58163,26 @@ var BTCR2 = (() => {
       };
     }
     /**
-     * Creates a PublicKey object from a JSON representation.
-     * @param {PublicKeyObject} json The JSON object to initialize the PublicKey.
-     * @returns {PublicKey} The initialized PublicKey object.
+     * Creates a CompressedSecp256k1PublicKey object from a JSON representation.
+     * @param {PublicKeyObject} json The JSON object to initialize the CompressedSecp256k1PublicKey.
+     * @returns {CompressedSecp256k1PublicKey} The initialized CompressedSecp256k1PublicKey object.
      */
     static fromJSON(json) {
       json.x.unshift(json.parity);
-      return new _PublicKey(json.x.toUint8Array());
+      return new _CompressedSecp256k1PublicKey(json.x.toUint8Array());
     }
     /**
-     * Computes the deterministic public key for a given private key.
-     * @param {PrivateKey | KeyBytes} sk The PrivateKey object or the private key bytes
-     * @returns {PublicKey} A new PublicKey object
+     * Computes the deterministic public key for a given secret key.
+     * @param {Secp256k1SecretKey | KeyBytes} sk The Secp256k1SecretKey object or the secret key bytes
+     * @returns {CompressedSecp256k1PublicKey} A new CompressedSecp256k1PublicKey object
      */
     static fromSecretKey(sk) {
-      const bytes3 = sk instanceof SecretKey ? sk.bytes : sk;
+      const bytes3 = sk instanceof Secp256k1SecretKey ? sk.bytes : sk;
       if (bytes3.length !== 32) {
-        throw new PublicKeyError("Invalid arg: must be 32 byte private key", "FROM_PRIVATE_KEY_ERROR");
+        throw new PublicKeyError("Invalid arg: must be 32 byte secret key", "FROM_SECRET_KEY_ERROR");
       }
-      const privateKey = sk instanceof SecretKey ? sk : new SecretKey(sk);
-      return new _PublicKey(privateKey.computePublicKey());
+      const secret = sk instanceof Secp256k1SecretKey ? sk : new Secp256k1SecretKey(sk);
+      return secret.computePublicKey();
     }
     /**
      * Computes modular exponentiation: (base^exp) % mod.
@@ -58202,23 +58230,11 @@ var BTCR2 = (() => {
       const yBytes = import_buffer.Buffer.fromHex(y.toString(16).padStart(64, "0"));
       return new Uint8Array(import_buffer.Buffer.concat([import_buffer.Buffer.from([4]), import_buffer.Buffer.from(this.x), yBytes]));
     }
-    /**
-     * Static version of liftX method.
-     * @param {KeyBytes} x The 32-byte x-coordinate to lift.
-     * @returns {Uint8Array} The 65-byte uncompressed public key (0x04, x, y).
-     */
-    static xOnly(x) {
-      if (x.length !== 32) {
-        throw new PublicKeyError("Invalid argument: x-coordinate length must be 32 bytes", "LIFT_X_ERROR");
-      }
-      const publicKey2 = new _PublicKey(x);
-      return publicKey2.x;
-    }
   };
 
   // ../keypair/dist/esm/pair.js
   var SchnorrKeyPair = class _SchnorrKeyPair {
-    /** @type {SecretKey} The secret key object */
+    /** @type {Secp256k1SecretKey} The secret key object */
     _secretKey;
     _publicKey;
     /** @type {string} The public key in multibase format */
@@ -58227,31 +58243,35 @@ var BTCR2 = (() => {
     _secretKeyMultibase;
     /**
      * Creates an instance of Keys. Must provide a at least a secret key.
-     * Can optionally provide both a private and public key, but must be a valid pair.
-     * @param {SecretKey} secretKey The secret key object
+     * Can optionally provide both a secret and public key, but must be a valid pair.
+     * @param {SchnorrKeyPairParams} params The parameters to initialize the Keys object.
+     * @param {CompressedSecp256k1PublicKey | KeyBytes} params.publicKey The public key object or bytes
+     * @param {Secp256k1SecretKey | KeyBytes} [params.secret] The secret key object or bytes
+     * @throws {KeyPairError} If neither a public key or secret key is provided.
+     * @throws {KeyPairError} If the public key is not a valid pair with the secret key.
      */
-    constructor({ secretKey, publicKey: publicKey2 } = {}) {
-      if (!publicKey2 && !secretKey) {
+    constructor(params = {}) {
+      if (!params.publicKey && !params.secretKey) {
         throw new KeyPairError("Argument missing: must at least provide a publicKey", "CONSTRUCTOR_ERROR");
       }
-      if (secretKey instanceof Uint8Array) {
-        this._secretKey = new SecretKey(secretKey);
-      } else if (secretKey instanceof SecretKey) {
-        this._secretKey = secretKey;
+      if (params.secretKey instanceof Uint8Array) {
+        this._secretKey = new Secp256k1SecretKey(params.secretKey);
+      } else if (params.secretKey instanceof Secp256k1SecretKey) {
+        this._secretKey = params.secretKey;
       }
-      if (publicKey2 instanceof PublicKey) {
-        this._publicKey = publicKey2;
-      } else if (publicKey2 instanceof Uint8Array) {
-        this._publicKey = new PublicKey(publicKey2);
+      if (params.publicKey instanceof CompressedSecp256k1PublicKey) {
+        this._publicKey = params.publicKey;
+      } else if (params.publicKey instanceof Uint8Array) {
+        this._publicKey = new CompressedSecp256k1PublicKey(params.publicKey);
       } else {
-        this._publicKey = new PublicKey(this._secretKey.computePublicKey());
+        this._publicKey = this._secretKey.computePublicKey();
       }
-      this._publicKeyMultibase = this._publicKey.multibase.address;
+      this._publicKeyMultibase = this._publicKey.multibase.encoded;
       this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : "";
     }
     /**
-     * Get the SecretKey.
-     * @returns {SecretKey} The SecretKey object
+     * Get the Secp256k1SecretKey.
+     * @returns {Secp256k1SecretKey} The Secp256k1SecretKey object
      * @throws {KeyPairError} If the secret key is not available
      */
     get secretKey() {
@@ -58261,33 +58281,38 @@ var BTCR2 = (() => {
       if (!this._secretKey.isValid()) {
         throw new KeyPairError("Secret key is not valid", "SECRET_KEY_ERROR");
       }
-      const secretKey = this._secretKey;
-      return secretKey;
+      const secret = this._secretKey;
+      return secret;
     }
     /**
-     * Set the PublicKey.
-     * @param {PublicKey} publicKey The PublicKey object
+     * Set the CompressedSecp256k1PublicKey.
+     * @param {CompressedSecp256k1PublicKey} publicKey The CompressedSecp256k1PublicKey object
      * @throws {KeyPairError} If the public key is not a valid pair with the secret key.
      */
     set publicKey(publicKey2) {
-      if (this.secretKey && !this.secretKey.isValidPair(publicKey2)) {
-        throw new KeyPairError("Public key is not a valid pair with the secret key", "PUBLIC_KEY_ERROR");
+      if (this.secretKey) {
+        if (!this.secretKey.hasValidPublicKey()) {
+          throw new KeyPairError("Secret key is not valid", "SECRET_KEY_ERROR");
+        }
+        const cPk = this.secretKey.computePublicKey();
+        if (!publicKey2.equals(cPk))
+          throw new KeyPairError("Public key is not a valid pair with the secret key", "PUBLIC_KEY_ERROR");
       }
       this._publicKey = publicKey2;
-      this._publicKeyMultibase = publicKey2.multibase.address;
+      this._publicKeyMultibase = publicKey2.multibase.encoded;
       this._secretKeyMultibase = this._secretKey ? this._secretKey.multibase : "";
     }
     /**
-     * Get the PublicKey.
-     * @returns {PublicKey} The PublicKey object
+     * Get the CompressedSecp256k1PublicKey.
+     * @returns {CompressedSecp256k1PublicKey} The CompressedSecp256k1PublicKey object
      */
     get publicKey() {
       const publicKey2 = this._publicKey;
       return publicKey2;
     }
     /**
-     * Get the Keys as a raw key pair.
-     * @returns {RawKeyPair} The Keys as a raw key pair
+     * Get the raw bytes of each key in the SchnorrKeyPair.
+     * @returns {RawSchnorrKeyPair} JSON object with the SchnorrKeyPair raw bytes.
      */
     get raw() {
       return {
@@ -58297,7 +58322,7 @@ var BTCR2 = (() => {
     }
     /**
      * Get the Keys in multibase format.
-     * @returns {MultibaseKeys} The SecretKey in multibase format
+     * @returns {MultibaseKeys} The Secp256k1SecretKey in multibase format
      */
     get multibase() {
       return {
@@ -58321,37 +58346,40 @@ var BTCR2 = (() => {
      * @returns {SchnorrKeyPair} The initialized Keys object.
      */
     static fromJSON(keys) {
-      const secretKey = SecretKey.fromJSON(keys.secretKey);
-      const publicKey2 = PublicKey.fromJSON(keys.publicKey);
-      return new _SchnorrKeyPair({ secretKey, publicKey: publicKey2 });
+      return new _SchnorrKeyPair({
+        secretKey: Secp256k1SecretKey.fromJSON(keys.secretKey),
+        publicKey: CompressedSecp256k1PublicKey.fromJSON(keys.publicKey)
+      });
     }
     /**
-     * Static method creates a new SchnorrKeyPair from a SecretKey object or secret key bytes.
-     * @param {SecretKey | KeyBytes} data The secret key bytes
+     * Static method creates a new SchnorrKeyPair from a Secp256k1SecretKey object or secret key bytes.
+     * @param {Secp256k1SecretKey | KeyBytes} data The secret key bytes
      * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
      */
     static fromPrivateKey(data) {
-      const bytes3 = data instanceof SecretKey ? data.bytes : data;
+      const bytes3 = data instanceof Secp256k1SecretKey ? data.bytes : data;
       if (bytes3.length !== 32) {
         throw new KeyPairError("Invalid arg: must be 32 byte secret key", "FROM_PRIVATE_KEY_ERROR");
       }
-      const secretKey = data instanceof Uint8Array ? new SecretKey(data) : data;
-      const publicKey2 = secretKey.computePublicKey();
-      return new _SchnorrKeyPair({ secretKey, publicKey: publicKey2 });
+      const secret = data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data;
+      return new _SchnorrKeyPair({
+        secretKey: data instanceof Uint8Array ? new Secp256k1SecretKey(data) : data,
+        publicKey: secret.computePublicKey()
+      });
     }
     /**
-     * Static method creates a new Keys (SecretKey/PublicKey) bigint secret.
-     * @param {bigint} secret The secret key secret
-     * @returns {Keys} A new Keys object
+     * Static method creates a new Keys (Secp256k1SecretKey/CompressedSecp256k1PublicKey) from bigint entropy.
+     * @param {bigint} entropy The entropy in bigint form
+     * @returns {SchnorrKeyPair} A new SchnorrKeyPair object
      */
-    static fromSecret(secret) {
-      const secretKey = SecretKey.fromSecret(secret);
+    static fromEntropy(entropy) {
+      const secretKey = Secp256k1SecretKey.fromEntropy(entropy);
       const publicKey2 = secretKey.computePublicKey();
       return new _SchnorrKeyPair({ secretKey, publicKey: publicKey2 });
     }
     /**
      * Converts key bytes to a hex string.
-     * @param {KeyBytes} keyBytes The key bytes (private or public).
+     * @param {KeyBytes} keyBytes The key bytes (secret or public).
      * @returns {Hex} The key bytes as a hex string.
      */
     static toHex(keyBytes) {
@@ -58359,18 +58387,18 @@ var BTCR2 = (() => {
     }
     /**
      * Compares two Keys objects for equality.
-     * @param {SchnorrKeyPair} keys The main keys.
-     * @param {SchnorrKeyPair} otherKeys The other keys to compare.
+     * @param {SchnorrKeyPair} kp The main keys.
+     * @param {SchnorrKeyPair} otherKp The other keys to compare.
      * @returns {boolean} True if the public key and secret key are equal, false otherwise.
      */
-    static equals(keys, otherKeys) {
-      const pk = keys.publicKey;
-      const otherPk = otherKeys.publicKey;
+    static equals(kp, otherKp) {
+      const pk = kp.publicKey;
+      const otherPk = otherKp.publicKey;
       if (pk && otherPk) {
         return pk.hex === otherPk.hex;
       }
-      const sk = keys.secretKey;
-      const otherSk = otherKeys.secretKey;
+      const sk = kp.secretKey;
+      const otherSk = otherKp.secretKey;
       if (sk && otherSk) {
         return sk.hex === otherSk.hex;
       }
@@ -58378,16 +58406,19 @@ var BTCR2 = (() => {
     }
     /**
      * Static method to generate a new random SchnorrKeyPair instance.
-     * @returns {SchnorrKeyPair} A new SecretKey object.
+     * @returns {SchnorrKeyPair} A new Secp256k1SecretKey object.
      */
     static generate() {
-      const skBytes = SecretKey.random();
-      const secretKey = new SecretKey(skBytes);
+      const sk = Secp256k1SecretKey.random();
+      const secretKey = new Secp256k1SecretKey(sk);
       const publicKey2 = secretKey.computePublicKey();
       return new _SchnorrKeyPair({ secretKey, publicKey: publicKey2 });
     }
   };
 
+  // ../keypair/dist/esm/types.js
+  init_shim();
+
   // src/utils/appendix.ts
   init_shim();
 
@@ -65708,7 +65739,7 @@ var BTCR2 = (() => {
       return n3 === _0n6 ? n3 : assertInRange(n3, CURVE_ORDER);
     }
     const pointPrecomputes2 = /* @__PURE__ */ new Map();
-    function isPoint3(other) {
+    function isPoint4(other) {
       if (!(other instanceof Point4))
         throw new Error("ExtendedPoint expected");
     }
@@ -65773,7 +65804,7 @@ var BTCR2 = (() => {
       }
       // Compare one point to another.
       equals(other) {
-        isPoint3(other);
+        isPoint4(other);
         const { ex: X1, ey: Y1, ez: Z1 } = this;
         const { ex: X2, ey: Y2, ez: Z2 } = other;
         const X1Z2 = modP(X1 * Z2);
@@ -65813,7 +65844,7 @@ var BTCR2 = (() => {
       // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
       // Cost: 9M + 1*a + 1*d + 7add.
       add(other) {
-        isPoint3(other);
+        isPoint4(other);
         const { a: a3, d: d2 } = CURVE2;
         const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
         const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
@@ -86869,10 +86900,10 @@ var BTCR2 = (() => {
       return enumeration(__KeyTypeValues);
     };
   })(KeyType || (KeyType = {}));
-  var PublicKey2;
-  (function(PublicKey4) {
+  var PublicKey;
+  (function(PublicKey3) {
     let _codec;
-    PublicKey4.codec = () => {
+    PublicKey3.codec = () => {
       if (_codec == null) {
         _codec = message((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
@@ -86914,13 +86945,13 @@ var BTCR2 = (() => {
       }
       return _codec;
     };
-    PublicKey4.encode = (obj) => {
-      return encodeMessage(obj, PublicKey4.codec());
+    PublicKey3.encode = (obj) => {
+      return encodeMessage(obj, PublicKey3.codec());
     };
-    PublicKey4.decode = (buf2, opts) => {
-      return decodeMessage(buf2, PublicKey4.codec(), opts);
+    PublicKey3.decode = (buf2, opts) => {
+      return decodeMessage(buf2, PublicKey3.codec(), opts);
     };
-  })(PublicKey2 || (PublicKey2 = {}));
+  })(PublicKey || (PublicKey = {}));
   var PrivateKey;
   (function(PrivateKey3) {
     let _codec;
@@ -87171,7 +87202,7 @@ var BTCR2 = (() => {
   function pkixMessageToRSAPublicKey(message2, bytes3, digest2) {
     const jwk = pkixMessageToJwk(message2);
     if (digest2 == null) {
-      const hash2 = sha2562(PublicKey2.encode({
+      const hash2 = sha2562(PublicKey.encode({
         Type: KeyType.RSA,
         Data: bytes3
       }));
@@ -87184,7 +87215,7 @@ var BTCR2 = (() => {
       throw new InvalidParametersError("Key size is too large");
     }
     const keys = jwkToJWKKeyPair(jwk);
-    const hash2 = sha2562(PublicKey2.encode({
+    const hash2 = sha2562(PublicKey.encode({
       Type: KeyType.RSA,
       Data: jwkToPkix(keys.publicKey)
     }));
@@ -87196,7 +87227,7 @@ var BTCR2 = (() => {
       throw new InvalidParametersError("Key size is too large");
     }
     const keys = await generateRSAKey(bits);
-    const hash2 = sha2562(PublicKey2.encode({
+    const hash2 = sha2562(PublicKey.encode({
       Type: KeyType.RSA,
       Data: jwkToPkix(keys.publicKey)
     }));
@@ -88687,7 +88718,7 @@ var BTCR2 = (() => {
     throw new UnsupportedKeyTypeError();
   }
   function publicKeyFromProtobuf(buf2, digest2) {
-    const { Type: Type2, Data } = PublicKey2.decode(buf2);
+    const { Type: Type2, Data } = PublicKey.decode(buf2);
     const data = Data ?? new Uint8Array();
     switch (Type2) {
       case KeyType.RSA:
@@ -88703,7 +88734,7 @@ var BTCR2 = (() => {
     }
   }
   function publicKeyFromMultihash(digest2) {
-    const { Type: Type2, Data } = PublicKey2.decode(digest2.digest);
+    const { Type: Type2, Data } = PublicKey.decode(digest2.digest);
     const data = Data ?? new Uint8Array();
     switch (Type2) {
       case KeyType.Ed25519:
@@ -88717,7 +88748,7 @@ var BTCR2 = (() => {
     }
   }
   function publicKeyToProtobuf(key) {
-    return PublicKey2.encode({
+    return PublicKey.encode({
       Type: KeyType[key.type],
       Data: key.raw
     });
@@ -142602,7 +142633,7 @@ ${values.join("\n")}` : `${blockName} :`;
       }
     }
   };
-  var PublicKey3 = class _PublicKey extends PemData {
+  var PublicKey2 = class _PublicKey extends PemData {
     static async create(data, crypto6 = cryptoProvider.get()) {
       if (data instanceof _PublicKey) {
         return data;
@@ -142718,7 +142749,7 @@ ${values.join("\n")}` : `${blockName} :`;
       if ("name" in param && "serialNumber" in param) {
         return new _AuthorityKeyIdentifierExtension(param, critical);
       }
-      const key = await PublicKey3.create(param, crypto6);
+      const key = await PublicKey2.create(param, crypto6);
       const id = await key.getKeyIdentifier(crypto6);
       return new _AuthorityKeyIdentifierExtension(import_pvtsutils6.Convert.ToHex(id), critical);
     }
@@ -142858,7 +142889,7 @@ ${values.join("\n")}` : `${blockName} :`;
   KeyUsagesExtension.NAME = "Key Usages";
   var SubjectKeyIdentifierExtension = class _SubjectKeyIdentifierExtension extends Extension2 {
     static async create(publicKey2, critical = false, crypto6 = cryptoProvider.get()) {
-      const key = await PublicKey3.create(publicKey2, crypto6);
+      const key = await PublicKey2.create(publicKey2, crypto6);
       const id = await key.getKeyIdentifier(crypto6);
       return new _SubjectKeyIdentifierExtension(import_pvtsutils6.Convert.ToHex(id), critical);
     }
@@ -143500,7 +143531,7 @@ ${values.join("\n")}` : `${blockName} :`;
     }
     get publicKey() {
       if (!__classPrivateFieldGet(this, _Pkcs10CertificateRequest_publicKey, "f")) {
-        __classPrivateFieldSet(this, _Pkcs10CertificateRequest_publicKey, new PublicKey3(this.asn.certificationRequestInfo.subjectPKInfo), "f");
+        __classPrivateFieldSet(this, _Pkcs10CertificateRequest_publicKey, new PublicKey2(this.asn.certificationRequestInfo.subjectPKInfo), "f");
       }
       return __classPrivateFieldGet(this, _Pkcs10CertificateRequest_publicKey, "f");
     }
@@ -143622,7 +143653,7 @@ ${values.join("\n")}` : `${blockName} :`;
   var X509Certificate = class extends PemData {
     get publicKey() {
       if (!__classPrivateFieldGet(this, _X509Certificate_publicKey, "f")) {
-        __classPrivateFieldSet(this, _X509Certificate_publicKey, new PublicKey3(this.asn.tbsCertificate.subjectPublicKeyInfo), "f");
+        __classPrivateFieldSet(this, _X509Certificate_publicKey, new PublicKey2(this.asn.tbsCertificate.subjectPublicKeyInfo), "f");
       }
       return __classPrivateFieldGet(this, _X509Certificate_publicKey, "f");
     }
@@ -143762,11 +143793,11 @@ ${values.join("\n")}` : `${blockName} :`;
         } else if ("publicKey" in paramsKey) {
           keyAlgorithm = { ...paramsKey.publicKey.algorithm, ...this.signatureAlgorithm };
           publicKey2 = await paramsKey.publicKey.export(keyAlgorithm, ["verify"], crypto6);
-        } else if (paramsKey instanceof PublicKey3) {
+        } else if (paramsKey instanceof PublicKey2) {
           keyAlgorithm = { ...paramsKey.algorithm, ...this.signatureAlgorithm };
           publicKey2 = await paramsKey.export(keyAlgorithm, ["verify"], crypto6);
         } else if (import_pvtsutils6.BufferSourceConverter.isBufferSource(paramsKey)) {
-          const key = new PublicKey3(paramsKey);
+          const key = new PublicKey2(paramsKey);
           keyAlgorithm = { ...key.algorithm, ...this.signatureAlgorithm };
           publicKey2 = await key.export(keyAlgorithm, ["verify"], crypto6);
         } else {
@@ -143895,7 +143926,7 @@ ${values.join("\n")}` : `${blockName} :`;
     static async create(params, crypto6 = cryptoProvider.get()) {
       var _a3;
       let spki;
-      if (params.publicKey instanceof PublicKey3) {
+      if (params.publicKey instanceof PublicKey2) {
         spki = params.publicKey.rawData;
       } else if ("publicKey" in params.publicKey) {
         spki = params.publicKey.publicKey.rawData;
@@ -145202,7 +145233,7 @@ a=end-of-candidates
       return verificationMethods;
     }
     /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#derive-root-capability-from-didbtc1-identifier | 9.4.1 Derive Root Capability from did:btcr2 Identifier}.
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#derive-root-capability-from-didbtcr2-identifier | 9.4.1 Derive Root Capability from did:btcr2 Identifier }.
      *
      * The Derive Root Capability algorithm deterministically generates a ZCAP-LD root capability from a given did:btcr2
      * identifier. Each root capability is unique to the identifier. This root capability is defined and understood by the
@@ -145210,7 +145241,7 @@ a=end-of-candidates
      * document. It takes in a did:btcr2 identifier and returns a rootCapability object. It returns the root capability.
      *
      * @param {string} identifier The did-btcr2 identifier to derive the root capability from
-     * @returns {Btc1RootCapability} The root capability object
+     * @returns {RootCapability} The root capability object
      * @example Root capability for updating the DID document for
      * did:btcr2:k1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u
      * ```
@@ -145238,7 +145269,7 @@ a=end-of-candidates
      * capability object.
      *
      * @param {string} capabilityId The root capability identifier to dereference.
-     * @returns {Btc1RootCapability} The root capability object.
+     * @returns {RootCapability} The root capability object.
      * @example a didUpdatePayload with an invoked ZCAP-LD capability containing a patch defining how the DID document
      * for did:btcr2:k1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u SHOULD be mutated.
      * ```
@@ -145264,7 +145295,7 @@ a=end-of-candidates
      *    "cryptosuite": "schnorr-secp256k1-jcs-2025",
      *    "verificationMethod": "did:btcr2:k1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u#initialKey",
      *    "invocationTarget": "did:btcr2:k1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u",
-     *    "capability": "urn:zcap:root:did%3Abtc1%3Ak1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u",
+     *    "capability": "urn:zcap:root:did%3Abtcr2%3Ak1q0rnnwf657vuu8trztlczvlmphjgc6q598h79cm6sp7c4fgqh0fkc0vzd9u",
      *    "capabilityAction": "Write",
      *    "proofPurpose": "assertionMethod",
      *    "proofValue": "z381yXYmxU8NudZ4HXY56DfMN6zfD8syvWcRXzT9xD9uYoQToo8QsXD7ahM3gXTzuay5WJbqTswt2BKaGWYn2hHhVFKJLXaDz"
@@ -145595,8 +145626,8 @@ a=end-of-candidates
      * @param {string} params.id The id of the multikey (required)
      * @param {string} params.controller The controller of the multikey (required)
      * @param {Keys} params.keys The Keys of the multikey (optional, required if no publicKey)
-     * @param {PublicKey} params.keys.publicKey The public key of the multikey (optional, required if no privateKey)
-     * @param {SecretKey} params.keys.privateKey The private key of the multikey (optional)
+     * @param {CompressedSecp256k1PublicKey} params.keys.publicKey The public key of the multikey (optional, required if no privateKey)
+     * @param {Secp256k1SecretKey} params.keys.privateKey The private key of the multikey (optional)
      * @throws {MultikeyError} if neither a publicKey nor a privateKey is provided
      */
     constructor({ id, controller, keys }) {
@@ -145615,7 +145646,7 @@ a=end-of-candidates
       const keys = this._keys;
       return keys;
     }
-    /** @type {PublicKey} @readonly Get the Multikey PublicKey. */
+    /** @type {CompressedSecp256k1PublicKey} @readonly Get the Multikey CompressedSecp256k1PublicKey. */
     get publicKey() {
       const publicKey2 = this._keys.publicKey;
       return publicKey2;
@@ -145691,7 +145722,7 @@ a=end-of-candidates
         id: this.id,
         type: _SchnorrMultikey.type,
         controller: this.controller,
-        publicKeyMultibase: this.publicKey.multibase.address
+        publicKeyMultibase: this.publicKey.multibase.encoded
       };
     }
     /**
@@ -145719,10 +145750,10 @@ a=end-of-candidates
       }
       const decoded = this.publicKey.decode();
       const publicKey2 = decoded.slice(2, decoded.length);
-      const keys = new SchnorrKeyPair({ publicKey: new PublicKey(publicKey2) });
+      const keys = new SchnorrKeyPair({ publicKey: new CompressedSecp256k1PublicKey(publicKey2) });
       return new _SchnorrMultikey({ id, controller, keys });
     }
-    /** @type {boolean} @readonly Get signing ability of the Multikey (i.e. is there a valid SecretKey). */
+    /** @type {boolean} @readonly Get signing ability of the Multikey (i.e. is there a valid Secp256k1SecretKey). */
     get signer() {
       return !!this.keys.secretKey;
     }
@@ -145763,7 +145794,7 @@ a=end-of-candidates
      * @returns {SchnorrMultikey} The new multikey instance
      */
     static fromPrivateKey({ id, controller, entropy }) {
-      const secretKey = new SecretKey(entropy);
+      const secretKey = new Secp256k1SecretKey(entropy);
       const publicKey2 = secretKey.computePublicKey();
       const keys = new SchnorrKeyPair({ publicKey: publicKey2, secretKey });
       return new _SchnorrMultikey({ id, controller, keys });
@@ -145777,7 +145808,7 @@ a=end-of-candidates
      * @returns {Multikey} The new multikey instance
      */
     static fromPublicKey({ id, controller, publicKeyBytes }) {
-      const keys = new SchnorrKeyPair({ publicKey: new PublicKey(publicKeyBytes) });
+      const keys = new SchnorrKeyPair({ publicKey: new CompressedSecp256k1PublicKey(publicKeyBytes) });
       return new _SchnorrMultikey({ id, controller, keys });
     }
     /**
@@ -145868,9 +145899,9 @@ a=end-of-candidates
       throw new Error("Method not implemented." + txHex + keyUri);
     }
     /**
-     * Gets the key pair from the key store and returns a PublicKey.
+     * Gets the key pair from the key store and returns a CompressedSecp256k1PublicKey.
      * @param {KeyIdentifier} keyUri The URI of the key to get the public key for.
-     * @returns {Promise<PublicKey>} The public key associated with the key URI.
+     * @returns {Promise<CompressedSecp256k1PublicKey>} The public key associated with the key URI.
      */
     async getPublicKey(keyUri) {
       const key = await this.getKey(keyUri);
@@ -145987,11 +146018,11 @@ a=end-of-candidates
     }
     /**
      * Computes a multibase-compliant URI from a key.
-     * @param key A SchnorrKeyPair, PublicKey, or multibase string
+     * @param key A SchnorrKeyPair, CompressedSecp256k1PublicKey, or multibase string
      * @returns {string} A multibase URI (e.g. 'urn:mb:zQ3s...')
      */
     static toMultibaseUri(data) {
-      const multibase = data instanceof SchnorrKeyPair ? data.publicKey.multibase : data instanceof PublicKey ? data.multibase : data;
+      const multibase = data instanceof SchnorrKeyPair ? data.publicKey.multibase : data instanceof CompressedSecp256k1PublicKey ? data.multibase : data;
       return `${MULTIBASE_URI_PREFIX}${multibase}`;
     }
     /**
@@ -146134,7 +146165,7 @@ a=end-of-candidates
       const hashBytes = JSON.canonicalization.encode(import_buffer.Buffer.fromHex(UPDATE_PAYLOAD_HASH), "base58");
       const signalsMetadataMap = new Map(Object.entries(signalsMetadata));
       if (signalsMetadata) {
-        didUpdatePayload = signalsMetadataMap.get(signal.txid)?.btc1Update;
+        didUpdatePayload = signalsMetadataMap.get(signal.txid)?.didUpdate;
         if (!didUpdatePayload) {
           throw new SingletonBeaconError("Update Payload not found in signal metadata.", "PROCESS_SIGNAL_ERROR");
         }
@@ -146213,7 +146244,7 @@ a=end-of-candidates
       if (!spentTx) {
         throw new SingletonBeaconError("Failed to send raw transaction.", "SEND_FAILED", { spentTx });
       }
-      return { [spentTx]: { btc1Update: didUpdatePayload } };
+      return { [spentTx]: { didUpdate: didUpdatePayload } };
     }
   };
 
@@ -146352,7 +146383,14 @@ a=end-of-candidates
     }
   };
 
-  // src/core/crud/create.ts
+  // src/core/crud/deactivate.ts
+  init_shim();
+
+  // src/did-btcr2.ts
+  init_shim();
+  var tinysecp4 = __toESM(require_dist2(), 1);
+
+  // src/core/crud/read.ts
   init_shim();
 
   // src/utils/beacons.ts
@@ -146932,7 +146970,7 @@ a=end-of-candidates
   // src/utils/identifier.ts
   var Identifier = class {
     /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtc1-identifier-encoding | 3.2 did:btcr2 Identifier Encoding}.
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtcr2-identifier-encoding | 3.2 did:btcr2 Identifier Encoding}.
      *
      * A did:btcr2 DID consists of a did:btcr2 prefix, followed by an id-bech32 value, which is a Bech32m encoding of:
      *  - the specification version;
@@ -146963,7 +147001,7 @@ a=end-of-candidates
       }
       if (idType === "KEY") {
         try {
-          new PublicKey(genesisBytes);
+          new CompressedSecp256k1PublicKey(genesisBytes);
         } catch {
           throw new MethodError(
             'Expected "genesisBytes" to be a valid compressed secp256k1 public key',
@@ -146996,7 +147034,7 @@ a=end-of-candidates
       return `did:btcr2:${bech32m3.encodeFromBytes(hrp, dataBytes)}`;
     }
     /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtc1-identifier-decoding | 3.3 did:btcr2 Identifier Decoding}.
+     * Implements {@link https://dcdpr.github.io/did-btcr2/#didbtcr2-identifier-decoding | 3.3 did:btcr2 Identifier Decoding}.
      * @param {string} identifier The BTCR2 DID to be parsed
      * @returns {DidComponents} The parsed identifier components. See {@link DidComponents} for details.
      * @throws {DidError} if an error occurs while parsing the identifier
@@ -147065,7 +147103,7 @@ a=end-of-candidates
       const genesisBytes = dataBytes.slice(byteIndex + 1);
       if (idType === "KEY") {
         try {
-          new PublicKey(genesisBytes);
+          new CompressedSecp256k1PublicKey(genesisBytes);
         } catch {
           throw new MethodError(`Invalid genesisBytes: ${genesisBytes}`, INVALID_DID, { identifier });
         }
@@ -147090,7 +147128,7 @@ a=end-of-candidates
 
   // src/utils/did-document.ts
   var BECH32M_CHARS = "";
-  var BTC1_DID_REGEX = /did:btcr2:(x1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*)/g;
+  var DID_REGEX = /did:btcr2:(x1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*)/g;
   var DidVerificationMethod = class {
     id;
     type;
@@ -147120,6 +147158,7 @@ a=end-of-candidates
     capabilityDelegation;
     service;
     constructor(document2) {
+      console.log("Constructing DidDocument with document:", document2);
       const idType = document2.id.includes("k1") ? IdentifierTypes.KEY : IdentifierTypes.EXTERNAL;
       const isIntermediate = document2.id === ID_PLACEHOLDER_VALUE;
       const { id, controller, verificationMethod: vm, service } = document2;
@@ -147359,6 +147398,7 @@ a=end-of-candidates
       if (!_DidDocument.isValidVerificationRelationships(this)) {
         throw new DidDocumentError("Invalid IntermediateDidDocument assertionMethod", INVALID_DID_DOCUMENT, this);
       }
+      return true;
     }
     /**
      * Convert the DidDocument to an IntermediateDidDocument.
@@ -147373,19 +147413,7 @@ a=end-of-candidates
   };
   var IntermediateDidDocument = class _IntermediateDidDocument extends DidDocument2 {
     constructor(document2) {
-      const intermediateDocument = JSON.cloneReplace(document2, BTC1_DID_REGEX, ID_PLACEHOLDER_VALUE);
-      super(intermediateDocument);
-    }
-    /**
-     * Create a minimal IntermediateDidDocument 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.
-     */
-    static create(verificationMethod, relationships, service) {
-      const id = ID_PLACEHOLDER_VALUE;
-      return new _IntermediateDidDocument({ id, ...relationships, verificationMethod, service });
+      super(document2);
     }
     /**
      * Convert the IntermediateDidDocument to a DidDocument by replacing the placeholder value with the provided DID.
@@ -147398,92 +147426,72 @@ a=end-of-candidates
       return new DidDocument2(parseThis);
     }
     /**
-     * Create a DidDocument from a JSON object.
-     * @param {JSONObject} object The JSON object to convert.
-     * @returns {DidDocument} The created DidDocument.
+     * Create an IntermediateDidDocument 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.
      */
-    static from(object2) {
-      return new _IntermediateDidDocument(object2).toDidDocument(object2.id);
+    static fromDidDocument(didDocument) {
+      const intermediateDocument = JSON.cloneReplace(didDocument, DID_REGEX, ID_PLACEHOLDER_VALUE);
+      return new _IntermediateDidDocument(intermediateDocument);
     }
-  };
-
-  // src/core/crud/create.ts
-  var Create = class {
     /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#deterministic-key-based-creation | 4.1.1 Deterministic Key-Based Creation}.
-     *
-     * For deterministic key-based creation, the did:btcr2 identifier encodes a secp256k1 public key. The key is then used
-     * to deterministically generate the initial DID document.
-     *
-     * @param {CreateKeyParams} params See {@link CreateKeyParams} for details.
-     * @param {number} params.version did-btcr2 identifier version.
-     * @param {string} params.network did-btcr2 bitcoin network.
-     * @param {KeyBytes} params.pubKeyBytes public key bytes for id creation.
-     * @returns {CreateResponse} A response object of type {@link CreateResponse}.
-     * @throws {DidError} if the public key is missing or invalid.
+     * Create a minimal IntermediateDidDocument 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.
      */
-    static deterministic({ pubKeyBytes, options: options2 }) {
-      const { version: version3 = 1, network = "bitcoin" } = options2;
-      const idType = IdentifierTypes.KEY;
-      const identifier = Identifier.encode({ version: version3, network, idType, genesisBytes: pubKeyBytes });
-      const { compressed: publicKey2, multibase: publicKeyMultibase } = new PublicKey(pubKeyBytes);
-      const service = BeaconUtils.generateBeaconServices({
-        identifier,
-        publicKey: publicKey2,
+    static create(verificationMethod, relationships, service) {
+      const id = ID_PLACEHOLDER_VALUE;
+      return new _IntermediateDidDocument({ id, ...relationships, verificationMethod, service });
+    }
+    /**
+     * Create a minimal IntermediateDidDocument from a public key.
+     * @param {KeyBytes} publicKey The public key in bytes format.
+     * @returns {IntermediateDidDocument} A new IntermediateDidDocument with the placeholder ID.
+     */
+    static fromPublicKey(publicKey2, network) {
+      const pk = new CompressedSecp256k1PublicKey(publicKey2);
+      const id = ID_PLACEHOLDER_VALUE;
+      const service = BeaconUtils.generateBeaconService({
+        id: `${id}#key-0`,
+        publicKey: pk.compressed,
         network: getNetwork(network),
+        addressType: "p2pkh",
         type: "SingletonBeacon"
       });
-      const initialDocument = new DidDocument2({
-        id: identifier,
-        controller: [identifier],
-        verificationMethod: [{
-          id: `${identifier}#initialKey`,
+      const relationships = {
+        authentication: [`${id}#key-0`],
+        assertionMethod: [`${id}#key-0`],
+        capabilityInvocation: [`${id}#key-0`],
+        capabilityDelegation: [`${id}#key-0`]
+      };
+      const verificationMethod = [
+        {
+          id: `${id}#key-0`,
           type: "Multikey",
-          controller: identifier,
-          publicKeyMultibase: publicKeyMultibase.address
-        }],
-        service
-      });
-      return { did: identifier, initialDocument };
+          controller: id,
+          publicKeyMultibase: pk.multibase.encoded
+        }
+      ];
+      return _IntermediateDidDocument.create(verificationMethod, relationships, [service]);
     }
     /**
-     * Implements {@link https://dcdpr.github.io/did-btcr2/#external-initial-document-creation | 4.1.2 External Initial Document Creation}.
-     *
-     * Creates a did:btcr2 identifier from some initiating arbitrary DID document. This allows for more complex
-     * initial DID documents, including the ability to include Service Endpoints and Beacons that support aggregation.
-     * Inputs include `intermediateDocument`, optional version and network returning initialDidDocument. The
-     * intermediateDocument should be a valid DID document except all places where the DID document requires the use of
-     * the identifier (e.g. the id field). These fields should use placeholder value
-     * `did:btcr2:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`. The intermediateDocument should include at
-     * least one verificationMethod and service of the type SingletonBeacon.
-     *
-     * @param {CreateExternalParams} params See {@link CreateExternalParams} for details.
-     * @param {number} params.version Identifier version.
-     * @param {string} params.network Identifier network name.
-     * @param {string} params.documentBytes Intermediate DID Document bytes.
-     * @returns {CreateResponse} A Promise resolving to {@link CreateResponses}.
-     * @throws {DidError} if the verificationMethod or service objects are missing required properties
+     * Taken an object, convert it to an IntermediateDocuemnt and then to a DidDocument.
+     * @param {JSONObject} object The JSON object to convert.
+     * @returns {DidDocument} The created DidDocument.
      */
-    static async external({ intermediateDocument, options: options2 }) {
-      const idType = IdentifierTypes.EXTERNAL;
-      const { version: version3 = 1, network = "bitcoin" } = options2;
-      intermediateDocument.validateIntermediate();
-      const genesisBytes = await JSON.canonicalization.canonicalhash(intermediateDocument);
-      const did = Identifier.encode({ idType, genesisBytes, version: version3, network });
-      const initialDocument = intermediateDocument.toDidDocument(did);
-      return { did, initialDocument };
+    static fromJSON(object2) {
+      return new _IntermediateDidDocument(object2);
+    }
+  };
+  var Document = class {
+    static isValid(didDocument) {
+      return new DidDocument2(didDocument).validateIntermediate();
     }
   };
-
-  // src/core/crud/deactivate.ts
-  init_shim();
-
-  // src/did-btcr2.ts
-  init_shim();
-  var tinysecp3 = __toESM(require_dist2(), 1);
 
   // src/core/crud/read.ts
-  init_shim();
   var bitcoin4 = new BitcoinNetworkConnection();
   var Resolve = class {
     /**
@@ -147500,7 +147508,7 @@ a=end-of-candidates
      */
     static deterministic({ identifier, identifierComponents }) {
       const { network, genesisBytes } = identifierComponents;
-      const { compressed: publicKey2, multibase: publicKeyMultibase } = new PublicKey(genesisBytes);
+      const { compressed: publicKey2, multibase: publicKeyMultibase } = new CompressedSecp256k1PublicKey(genesisBytes);
       const service = BeaconUtils.generateBeaconServices({
         identifier,
         publicKey: publicKey2,
@@ -147514,7 +147522,7 @@ a=end-of-candidates
           id: `${identifier}#initialKey`,
           type: "Multikey",
           controller: identifier,
-          publicKeyMultibase: publicKeyMultibase.address
+          publicKeyMultibase: publicKeyMultibase.encoded
         }],
         service
       });
@@ -147650,7 +147658,7 @@ a=end-of-candidates
         targetVersionId,
         targetTime,
         didDocumentHistory: new Array(),
-        btc1UpdateHashHistory: new Array(),
+        updateHashHistory: new Array(),
         signalsMetadata,
         network
       });
@@ -147682,7 +147690,7 @@ a=end-of-candidates
      * @param {UnixTimestamp} params.targetTime The timestamp used to target specific historical states of a DID document.
      *    Only Beacon Signals included in the Bitcoin blockchain before the targetTime are processed.
      * @param {boolean} params.didDocumentHistory An array of DID documents ordered ascensing by version (1...N).
-     * @param {boolean} params.btc1UpdateHashHistory An array of SHA256 hashes of BTCR2 Updates ordered by version that are
+     * @param {boolean} params.updateHashHistory An array of SHA256 hashes of BTCR2 Updates ordered by version that are
      *    applied to the DID document in order to construct the contemporaryDIDDocument.
      * @param {SignalsMetadata} params.signalsMetadata See {@link SignalsMetadata} for details.
      * @param {string} params.network The bitcoin network to connect to (mainnet, signet, testnet, regtest).
@@ -147695,7 +147703,7 @@ a=end-of-candidates
       targetVersionId,
       targetTime,
       didDocumentHistory,
-      btc1UpdateHashHistory,
+      updateHashHistory,
       signalsMetadata,
       network
     }) {
@@ -147718,8 +147726,8 @@ a=end-of-candidates
       for (let update of orderedUpdates) {
         const updateTargetVersionId = update.targetVersionId;
         if (updateTargetVersionId <= currentVersionId) {
-          btc1UpdateHashHistory.push(contemporaryHash);
-          await this.confirmDuplicateUpdate({ update, updateHashHistory: btc1UpdateHashHistory });
+          updateHashHistory.push(contemporaryHash);
+          await this.confirmDuplicateUpdate({ update, updateHashHistory });
         } else if (updateTargetVersionId === currentVersionId + 1) {
           const sourceHash = update.sourceHash.startsWith("z") ? update.sourceHash : `z${update.sourceHash}`;
           if (sourceHash !== contemporaryHash) {
@@ -147735,7 +147743,7 @@ a=end-of-candidates
           const unsecuredUpdate = update;
           delete unsecuredUpdate.proof;
           const updateHash = await JSON.canonicalization.process(update, "base58");
-          btc1UpdateHashHistory.push(updateHash);
+          updateHashHistory.push(updateHash);
           contemporaryHash = await JSON.canonicalization.process(contemporaryDidDocument, "base58");
         } else if (update.targetVersionId > currentVersionId + 1) {
           throw new ResolveError(
@@ -147921,12 +147929,12 @@ a=end-of-candidates
       const sidecar = { signalsMetadata };
       const service = { id, type, serviceEndpoint: `bitcoin:${address}` };
       const beacon = BeaconFactory.establish(service, sidecar);
-      const btc1Update = await beacon.processSignal(signalTx, signalsMetadata) ?? null;
-      if (!btc1Update) {
-        throw new MethodError("No btc1Update for beacon", "PROCESS_BEACON_SIGNALS_ERROR", { tx, signalsMetadata });
+      const didUpdate = await beacon.processSignal(signalTx, signalsMetadata) ?? null;
+      if (!didUpdate) {
+        throw new MethodError("No didUpdate for beacon", "PROCESS_BEACON_SIGNALS_ERROR", { tx, signalsMetadata });
       }
-      updates.push(btc1Update);
-      return btc1Update;
+      updates.push(didUpdate);
+      return didUpdate;
     }
     /**
      * Implements {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.2.4 Confirm Duplicate Update}.
@@ -147941,7 +147949,7 @@ a=end-of-candidates
      * @param {DidUpdatePayload} params.update The DID Update Payload to confirm.
      * @param {Array<string>} params.updateHashHistory The history of hashes for previously applied updates.
      * @returns {Promise<void>} A promise that resolves if the update is a duplicate, otherwise throws an error.
-     * @throws {DidBtc1Error} if the update hash does not match the historical hash.
+     * @throws {ResolveError} if the update hash does not match the historical hash.
      */
     static async confirmDuplicateUpdate({ update, updateHashHistory }) {
       const unsecuredUpdate = update;
@@ -148089,7 +148097,7 @@ a=end-of-candidates
         id,
         controller,
         keys: new SchnorrKeyPair({
-          secretKey: SecretKey.decode(secretKeyMultibase)
+          secretKey: Secp256k1SecretKey.decode(secretKeyMultibase)
         })
       });
       if (!multikey) {
@@ -148158,7 +148166,7 @@ a=end-of-candidates
   };
 
   // src/did-btcr2.ts
-  initEccLib(tinysecp3);
+  initEccLib(tinysecp4);
   var DidBtcr2 = class {
     /** @type {string} Name of the DID method, as defined in the DID BTCR2 specification */
     static methodName = "btcr2";
@@ -148182,15 +148190,9 @@ a=end-of-candidates
      */
     static async create(params) {
       const { idType, options: options2 = {} } = params;
-      if (idType === IdentifierTypes.KEY) {
-        const { pubKeyBytes } = params;
-        return Create.deterministic({ pubKeyBytes, options: options2 });
-      }
-      if (idType === IdentifierTypes.EXTERNAL) {
-        const { intermediateDocument } = params;
-        return await Create.external({ intermediateDocument, options: options2 });
-      }
-      throw new MethodError('Invalid idType: expected "KEY" or "EXTERNAL"', INVALID_DID, params);
+      const { version: version3 = 1, network = "bitcoin" } = options2;
+      const genesisBytes = params.genesisBytes;
+      return Identifier.encode({ idType, genesisBytes, version: version3, network });
     }
     /**
      * Entry point for section {@link https://dcdpr.github.io/did-btcr2/#read | 7.2 Read}.
@@ -148263,7 +148265,7 @@ a=end-of-candidates
      * @param {string} params.identifier The btcr2 identifier to be updated.
      * @param {DidDocument} params.sourceDocument The DID document being updated.
      * @param {string} params.sourceVersionId The versionId of the source document.
-     * @param {Btc1DocumentPatch} params.documentPatch The JSON patch to be applied to the source document.
+     * @param {PatchOperation} params.documentPatch The JSON patch to be applied to the source document.
      * @param {string} params.verificationMethodId The verificationMethod ID to sign the update
      * @param {string[]} params.beaconIds The beacon IDs to announce the update
      * @returns {Promise<void>} Promise resolving to void
@@ -148331,7 +148333,7 @@ a=end-of-candidates
   };
 
   // src/core/crud/deactivate.ts
-  var Btc1Deactivate = class extends DidBtcr2 {
+  var Deactivate = class extends DidBtcr2 {
   };
 
   // src/core/key-manager/interface.ts
@@ -148348,7 +148350,7 @@ a=end-of-candidates
 
   // src/utils/did-document-builder.ts
   init_shim();
-  var Btc1DidDocumentBuilder = class {
+  var DidDocumentBuilder = class {
     document = {};
     constructor(initialDocument) {
       if (!initialDocument.id) {