@did-btcr2/method 0.15.0 → 0.17.0

package/dist/browser.mjs

@@ -7359,7 +7359,7 @@ var require_dist2 = __commonJS({
         return false;
       }
     }
-    function isPoint3(p3) {
+    function isPoint4(p3) {
       return _isPoint(p3, false);
     }
     function isPointCompressed(p3) {
@@ -7386,7 +7386,7 @@ var require_dist2 = __commonJS({
       });
     }
     function xOnlyPointFromPoint(p3) {
-      if (!isPoint3(p3)) {
+      if (!isPoint4(p3)) {
         throw new Error(THROW_BAD_POINT);
       }
       return p3.slice(1, 33);
@@ -7406,13 +7406,13 @@ var require_dist2 = __commonJS({
       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)) {
@@ -7423,7 +7423,7 @@ var require_dist2 = __commonJS({
       );
     }
     function pointAdd2(a3, b2, compressed) {
-      if (!isPoint3(a3) || !isPoint3(b2)) {
+      if (!isPoint4(a3) || !isPoint4(b2)) {
         throw new Error(THROW_BAD_POINT);
       }
       return throwToNull(() => {
@@ -7437,7 +7437,7 @@ var require_dist2 = __commonJS({
       });
     }
     function pointAddScalar(p3, tweak, compressed) {
-      if (!isPoint3(p3)) {
+      if (!isPoint4(p3)) {
         throw new Error(THROW_BAD_POINT);
       }
       if (!isTweak(tweak)) {
@@ -7531,7 +7531,7 @@ var require_dist2 = __commonJS({
       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)) {
@@ -7554,7 +7554,7 @@ var require_dist2 = __commonJS({
       }
       return secp256k13.schnorr.verify(signature2, h2, Q);
     }
-    exports.isPoint = isPoint3;
+    exports.isPoint = isPoint4;
     exports.isPointCompressed = isPointCompressed;
     exports.isPrivate = isPrivate3;
     exports.isXOnlyPoint = isXOnlyPoint;
@@ -30635,7 +30635,7 @@ var require_eddsa = __commonJS({
     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;
     };
   }
@@ -32247,13 +32247,13 @@ var require_asn12 = __commonJS({
         ).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"](),
@@ -45001,11 +45001,11 @@ var require_Reflect = __commonJS({
           };
           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);
@@ -45013,7 +45013,7 @@ var require_Reflect = __commonJS({
             }
             var metadataMap = targetMetadata.get(P3);
             if (IsUndefined(metadataMap)) {
-              if (!Create2)
+              if (!Create)
                 return void 0;
               metadataMap = new _Map();
               targetMetadata.set(P3, metadataMap);
@@ -45140,12 +45140,12 @@ var require_Reflect = __commonJS({
           };
           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;
             }
@@ -48429,8 +48429,8 @@ var CIDAggregateBeacon = class _CIDAggregateBeacon extends Beacon {
    *
    * 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.
@@ -48685,21 +48685,21 @@ init_shim();
 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,
@@ -48835,7 +48835,7 @@ var BitcoinRpcClientConfig = class _BitcoinRpcClientConfig {
   allowDefaultWallet;
   constructor(options2 = {
     headers: {},
-    host: "localhost",
+    host: "http://localhost",
     logger: console,
     password: "",
     timeout: 3e4,
@@ -48904,8 +48904,8 @@ var JsonRpcTransport = class {
           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);
       }
     }
   }
@@ -57621,7 +57621,7 @@ function getNetwork(network) {
 // ../bitcoin/dist/esm/bitcoin.js
 var BitcoinNetworkConnection = class {
   network;
-  mainnet;
+  bitcoin;
   testnet3;
   testnet4;
   signet;
@@ -57642,7 +57642,7 @@ var BitcoinNetworkConnection = class {
       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) {
@@ -57666,7 +57666,7 @@ var BitcoinNetworkConnection = class {
   }
   /**
    * 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) {
@@ -57678,7 +57678,7 @@ var BitcoinNetworkConnection = class {
   }
   /**
    * 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) {
@@ -57712,7 +57712,7 @@ init_shim();
 
 // ../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();
@@ -57722,12 +57722,13 @@ init_shim();
 
 // ../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 */
@@ -57735,7 +57736,7 @@ var SecretKey = class _SecretKey {
   /** @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
    */
@@ -57747,10 +57748,10 @@ var SecretKey = class _SecretKey {
     }
     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) {
@@ -57807,7 +57808,7 @@ var SecretKey = class _SecretKey {
   }
   /**
    * 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) {
@@ -57815,7 +57816,7 @@ var SecretKey = class _SecretKey {
   }
   /**
    * 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);
@@ -57825,7 +57826,7 @@ var SecretKey = class _SecretKey {
     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.
@@ -57847,10 +57848,10 @@ var SecretKey = class _SecretKey {
   }
   /**
    * 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;
     }
@@ -57874,21 +57875,21 @@ var SecretKey = class _SecretKey {
     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 });
   }
@@ -57913,14 +57914,14 @@ var SecretKey = class _SecretKey {
     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.
@@ -57931,35 +57932,35 @@ var SecretKey = class _SecretKey {
     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)
    */
@@ -57967,8 +57968,11 @@ var PublicKey = class _PublicKey {
     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];
   }
   /**
@@ -57988,13 +57992,30 @@ var PublicKey = class _PublicKey {
     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.
@@ -58037,6 +58058,13 @@ var PublicKey = class _PublicKey {
       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.
@@ -58045,11 +58073,11 @@ var PublicKey = class _PublicKey {
    */
   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 });
@@ -58059,7 +58087,7 @@ var PublicKey = class _PublicKey {
    * @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");
     }
@@ -58085,15 +58113,15 @@ var PublicKey = class _PublicKey {
   }
   /**
    * 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 {
@@ -58107,26 +58135,26 @@ var PublicKey = class _PublicKey {
     };
   }
   /**
-   * 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.
@@ -58174,23 +58202,11 @@ var PublicKey = class _PublicKey {
     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 */
@@ -58199,31 +58215,35 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
   _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() {
@@ -58233,33 +58253,38 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
     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 {
@@ -58269,7 +58294,7 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
   }
   /**
    * Get the Keys in multibase format.
-   * @returns {MultibaseKeys} The SecretKey in multibase format
+   * @returns {MultibaseKeys} The Secp256k1SecretKey in multibase format
    */
   get multibase() {
     return {
@@ -58293,37 +58318,40 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
    * @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) {
@@ -58331,18 +58359,18 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
   }
   /**
    * 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;
     }
@@ -58350,16 +58378,19 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
   }
   /**
    * 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();
 
@@ -65680,7 +65711,7 @@ function twistedEdwards(curveDef) {
     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");
   }
@@ -65745,7 +65776,7 @@ function twistedEdwards(curveDef) {
     }
     // 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);
@@ -65785,7 +65816,7 @@ function twistedEdwards(curveDef) {
     // 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;
@@ -86841,10 +86872,10 @@ var __KeyTypeValues;
     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) {
@@ -86886,13 +86917,13 @@ var PublicKey2;
     }
     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;
@@ -87143,7 +87174,7 @@ function pkixToRSAPublicKey(bytes3, digest2) {
 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
     }));
@@ -87156,7 +87187,7 @@ function jwkToRSAPrivateKey(jwk) {
     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)
   }));
@@ -87168,7 +87199,7 @@ async function generateRSAKeyPair(bits) {
     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)
   }));
@@ -88659,7 +88690,7 @@ async function generateKeyPair(type, bits) {
   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:
@@ -88675,7 +88706,7 @@ function publicKeyFromProtobuf(buf2, digest2) {
   }
 }
 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:
@@ -88689,7 +88720,7 @@ function publicKeyFromMultihash(digest2) {
   }
 }
 function publicKeyToProtobuf(key) {
-  return PublicKey2.encode({
+  return PublicKey.encode({
     Type: KeyType[key.type],
     Data: key.raw
   });
@@ -142574,7 +142605,7 @@ var PemData = class _PemData extends AsnData {
     }
   }
 };
-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;
@@ -142690,7 +142721,7 @@ var AuthorityKeyIdentifierExtension = class _AuthorityKeyIdentifierExtension ext
     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);
   }
@@ -142830,7 +142861,7 @@ var KeyUsagesExtension = class extends Extension2 {
 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);
   }
@@ -143472,7 +143503,7 @@ var Pkcs10CertificateRequest = class extends PemData {
   }
   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");
   }
@@ -143594,7 +143625,7 @@ var _X509Certificate_publicKey;
 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");
   }
@@ -143734,11 +143765,11 @@ var X509Certificate = class extends PemData {
       } 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 {
@@ -143867,7 +143898,7 @@ var X509CertificateGenerator = class {
   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;
@@ -145174,7 +145205,7 @@ var Appendix = class _Appendix {
     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
@@ -145182,7 +145213,7 @@ var Appendix = class _Appendix {
    * 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
    * ```
@@ -145210,7 +145241,7 @@ var Appendix = class _Appendix {
    * 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.
    * ```
@@ -145236,7 +145267,7 @@ var Appendix = class _Appendix {
    *    "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"
@@ -145567,8 +145598,8 @@ var SchnorrMultikey = class _SchnorrMultikey {
    * @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 }) {
@@ -145587,7 +145618,7 @@ var SchnorrMultikey = class _SchnorrMultikey {
     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;
@@ -145663,7 +145694,7 @@ var SchnorrMultikey = class _SchnorrMultikey {
       id: this.id,
       type: _SchnorrMultikey.type,
       controller: this.controller,
-      publicKeyMultibase: this.publicKey.multibase.address
+      publicKeyMultibase: this.publicKey.multibase.encoded
     };
   }
   /**
@@ -145691,10 +145722,10 @@ var SchnorrMultikey = class _SchnorrMultikey {
     }
     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;
   }
@@ -145735,7 +145766,7 @@ var SchnorrMultikey = class _SchnorrMultikey {
    * @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 });
@@ -145749,7 +145780,7 @@ var SchnorrMultikey = class _SchnorrMultikey {
    * @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 });
   }
   /**
@@ -145840,9 +145871,9 @@ var KeyManager = class _KeyManager {
     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);
@@ -145959,11 +145990,11 @@ var KeyManager = class _KeyManager {
   }
   /**
    * 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}`;
   }
   /**
@@ -146106,7 +146137,7 @@ var SingletonBeacon = class _SingletonBeacon extends Beacon {
     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");
       }
@@ -146185,7 +146216,7 @@ var SingletonBeacon = class _SingletonBeacon extends Beacon {
     if (!spentTx) {
       throw new SingletonBeaconError("Failed to send raw transaction.", "SEND_FAILED", { spentTx });
     }
-    return { [spentTx]: { btc1Update: didUpdatePayload } };
+    return { [spentTx]: { didUpdate: didUpdatePayload } };
   }
 };
 
@@ -146324,7 +146355,14 @@ var BeaconFactory = class {
   }
 };
 
-// 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
@@ -146904,7 +146942,7 @@ var bech32m3 = /* @__PURE__ */ genBech32("bech32m");
 // 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;
@@ -146935,7 +146973,7 @@ var Identifier = class {
     }
     if (idType === "KEY") {
       try {
-        new PublicKey(genesisBytes);
+        new CompressedSecp256k1PublicKey(genesisBytes);
       } catch {
         throw new MethodError(
           'Expected "genesisBytes" to be a valid compressed secp256k1 public key',
@@ -146968,7 +147006,7 @@ var Identifier = class {
     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
@@ -147037,7 +147075,7 @@ var Identifier = class {
     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 });
       }
@@ -147062,7 +147100,7 @@ var Identifier = class {
 
 // 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;
@@ -147092,6 +147130,7 @@ var DidDocument2 = class _DidDocument {
   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;
@@ -147331,6 +147370,7 @@ var DidDocument2 = class _DidDocument {
     if (!_DidDocument.isValidVerificationRelationships(this)) {
       throw new DidDocumentError("Invalid IntermediateDidDocument assertionMethod", INVALID_DID_DOCUMENT, this);
     }
+    return true;
   }
   /**
    * Convert the DidDocument to an IntermediateDidDocument.
@@ -147345,19 +147385,7 @@ var DidDocument2 = class _DidDocument {
 };
 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.
@@ -147370,92 +147398,72 @@ var IntermediateDidDocument = class _IntermediateDidDocument extends DidDocument
     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 {
   /**
@@ -147472,7 +147480,7 @@ var Resolve = class {
    */
   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,
@@ -147486,7 +147494,7 @@ var Resolve = class {
         id: `${identifier}#initialKey`,
         type: "Multikey",
         controller: identifier,
-        publicKeyMultibase: publicKeyMultibase.address
+        publicKeyMultibase: publicKeyMultibase.encoded
       }],
       service
     });
@@ -147622,7 +147630,7 @@ var Resolve = class {
       targetVersionId,
       targetTime,
       didDocumentHistory: new Array(),
-      btc1UpdateHashHistory: new Array(),
+      updateHashHistory: new Array(),
       signalsMetadata,
       network
     });
@@ -147654,7 +147662,7 @@ var Resolve = class {
    * @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).
@@ -147667,7 +147675,7 @@ var Resolve = class {
     targetVersionId,
     targetTime,
     didDocumentHistory,
-    btc1UpdateHashHistory,
+    updateHashHistory,
     signalsMetadata,
     network
   }) {
@@ -147690,8 +147698,8 @@ var Resolve = class {
     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) {
@@ -147707,7 +147715,7 @@ var Resolve = class {
         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(
@@ -147893,12 +147901,12 @@ var Resolve = class {
     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}.
@@ -147913,7 +147921,7 @@ var Resolve = class {
    * @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;
@@ -148061,7 +148069,7 @@ var Update = class {
       id,
       controller,
       keys: new SchnorrKeyPair({
-        secretKey: SecretKey.decode(secretKeyMultibase)
+        secretKey: Secp256k1SecretKey.decode(secretKeyMultibase)
       })
     });
     if (!multikey) {
@@ -148130,7 +148138,7 @@ var Update = class {
 };
 
 // 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";
@@ -148154,15 +148162,9 @@ var DidBtcr2 = class {
    */
   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}.
@@ -148235,7 +148237,7 @@ var DidBtcr2 = class {
    * @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
@@ -148303,7 +148305,7 @@ var DidBtcr2 = class {
 };
 
 // src/core/crud/deactivate.ts
-var Btc1Deactivate = class extends DidBtcr2 {
+var Deactivate = class extends DidBtcr2 {
 };
 
 // src/core/key-manager/interface.ts
@@ -148320,7 +148322,7 @@ init_shim();
 
 // src/utils/did-document-builder.ts
 init_shim();
-var Btc1DidDocumentBuilder = class {
+var DidDocumentBuilder = class {
   document = {};
   constructor(initialDocument) {
     if (!initialDocument.id) {
@@ -150886,17 +150888,17 @@ var GeneralUtils = class {
 export {
   Appendix,
   BECH32M_CHARS,
-  BTC1_DID_REGEX,
   Beacon,
   BeaconFactory,
   BeaconUtils,
-  Btc1Deactivate,
-  Btc1DidDocumentBuilder,
   CIDAggregateBeacon,
-  Create,
+  DID_REGEX,
+  Deactivate,
   DidBtcr2,
   DidDocument2 as DidDocument,
+  DidDocumentBuilder,
   DidVerificationMethod,
+  Document,
   GeneralUtils,
   Identifier,
   IntermediateDidDocument,