@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/btc-vision-bip32.js

@@ -0,0 +1,805 @@
+import { g as pe } from "./bip39.js";
+import { d as ye, b as X, e as ge, a as ve } from "./noble-hashes.js";
+import { d as W, e as _e } from "./vendors.js";
+import { r as oe } from "./scure-base.js";
+import { r as Z } from "./valibot.js";
+import { r as Ee, a as we } from "./btc-vision-post-quantum.js";
+var G = {}, D = {}, R = {}, $;
+function se() {
+  if ($) return R;
+  $ = 1, Object.defineProperty(R, "__esModule", { value: !0 }), R.hash160 = e, R.hash256 = w, R.hmacSHA512 = s;
+  const i = /* @__PURE__ */ ge(), I = /* @__PURE__ */ ye(), g = /* @__PURE__ */ X(), _ = /* @__PURE__ */ ve();
+  function e(r) {
+    return (0, I.ripemd160)((0, g.sha256)(r));
+  }
+  function w(r) {
+    return (0, g.sha256)(r);
+  }
+  function s(r, f) {
+    return (0, i.hmac)(_.sha512, r, f);
+  }
+  return R;
+}
+var j = {}, ee;
+function Pe() {
+  if (ee) return j;
+  ee = 1;
+  var i = j && j.__createBinding || (Object.create ? (function(r, f, E, u) {
+    u === void 0 && (u = E);
+    var p = Object.getOwnPropertyDescriptor(f, E);
+    (!p || ("get" in p ? !f.__esModule : p.writable || p.configurable)) && (p = { enumerable: !0, get: function() {
+      return f[E];
+    } }), Object.defineProperty(r, u, p);
+  }) : (function(r, f, E, u) {
+    u === void 0 && (u = E), r[u] = f[E];
+  })), I = j && j.__setModuleDefault || (Object.create ? (function(r, f) {
+    Object.defineProperty(r, "default", { enumerable: !0, value: f });
+  }) : function(r, f) {
+    r.default = f;
+  }), g = j && j.__importStar || /* @__PURE__ */ (function() {
+    var r = function(f) {
+      return r = Object.getOwnPropertyNames || function(E) {
+        var u = [];
+        for (var p in E) Object.prototype.hasOwnProperty.call(E, p) && (u[u.length] = p);
+        return u;
+      }, r(f);
+    };
+    return function(f) {
+      if (f && f.__esModule) return f;
+      var E = {};
+      if (f != null) for (var u = r(f), p = 0; p < u.length; p++) u[p] !== "default" && i(E, f, u[p]);
+      return I(E, f), E;
+    };
+  })();
+  Object.defineProperty(j, "__esModule", { value: !0 }), j.testEcc = w;
+  const _ = g(W), e = (r) => _.fromHex(r);
+  function w(r) {
+    if (s(r.isPoint(e("0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"))), s(!r.isPoint(e("030000000000000000000000000000000000000000000000000000000000000005"))), s(r.isPrivate(e("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"))), s(r.isPrivate(e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140"))), s(!r.isPrivate(e("0000000000000000000000000000000000000000000000000000000000000000"))), s(!r.isPrivate(e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"))), s(!r.isPrivate(e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364142"))), s(_.compare(r.pointFromScalar(e("b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af")), e("02b07ba9dca9523b7ef4bd97703d43d20399eb698e194704791a25ce77a400df99")) === 0), r.xOnlyPointAddTweak) {
+      s(r.xOnlyPointAddTweak(e("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140")) === null);
+      let f = r.xOnlyPointAddTweak(e("1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b"), e("a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac"));
+      s(_.compare(f.xOnlyPubkey, e("e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf")) === 0 && f.parity === 1), f = r.xOnlyPointAddTweak(e("2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991"), e("823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47"));
+    }
+    s(_.compare(r.pointAddScalar(e("0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), e("0000000000000000000000000000000000000000000000000000000000000003")), e("02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")) === 0), s(_.compare(r.privateAdd(e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e"), e("0000000000000000000000000000000000000000000000000000000000000002")), e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140")) === 0), r.privateNegate && (s(_.compare(r.privateNegate(e("0000000000000000000000000000000000000000000000000000000000000001")), e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140")) === 0), s(_.compare(r.privateNegate(e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e")), e("0000000000000000000000000000000000000000000000000000000000000003")) === 0), s(_.compare(r.privateNegate(e("b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af")), e("4eede1bf775995d70a494f0a7bb6bc11e0b8cccd41cce8009ab1132c8b0a3792")) === 0)), s(_.compare(r.sign(e("5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed"), e("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140")), e("54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5")) === 0), s(r.verify(e("5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed"), e("0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), e("54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5"))), r.signSchnorr && s(_.compare(r.signSchnorr(e("7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c"), e("c90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b14e5c9"), e("c87aa53824b4d7ae2eb035a2b5bbbccc080e76cdc6d1692c4b0b62d798e6d906")), e("5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7")) === 0), r.verifySchnorr && s(r.verifySchnorr(e("7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c"), e("dd308afec5777e13121fa72b9cc1b7cc0139715309b086c960e18fd969774eb8"), e("5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7")));
+  }
+  function s(r) {
+    if (!r)
+      throw new Error("ecc library invalid");
+  }
+  return j;
+}
+var A = {}, te;
+function de() {
+  return te || (te = 1, (function(i) {
+    var I = A && A.__createBinding || (Object.create ? (function(r, f, E, u) {
+      u === void 0 && (u = E);
+      var p = Object.getOwnPropertyDescriptor(f, E);
+      (!p || ("get" in p ? !f.__esModule : p.writable || p.configurable)) && (p = { enumerable: !0, get: function() {
+        return f[E];
+      } }), Object.defineProperty(r, u, p);
+    }) : (function(r, f, E, u) {
+      u === void 0 && (u = E), r[u] = f[E];
+    })), g = A && A.__setModuleDefault || (Object.create ? (function(r, f) {
+      Object.defineProperty(r, "default", { enumerable: !0, value: f });
+    }) : function(r, f) {
+      r.default = f;
+    }), _ = A && A.__importStar || /* @__PURE__ */ (function() {
+      var r = function(f) {
+        return r = Object.getOwnPropertyNames || function(E) {
+          var u = [];
+          for (var p in E) Object.prototype.hasOwnProperty.call(E, p) && (u[u.length] = p);
+          return u;
+        }, r(f);
+      };
+      return function(f) {
+        if (f && f.__esModule) return f;
+        var E = {};
+        if (f != null) for (var u = r(f), p = 0; p < u.length; p++) u[p] !== "default" && I(E, f, u[p]);
+        return g(E, f), E;
+      };
+    })();
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.Bip32PathSchema = i.NetworkSchema = i.Buffer33Bytes = i.Buffer256Bit = i.Uint31Schema = i.Uint32Schema = void 0;
+    const e = _(/* @__PURE__ */ Z());
+    i.Uint32Schema = e.pipe(e.number(), e.integer(), e.minValue(0), e.maxValue(4294967295)), i.Uint31Schema = e.pipe(e.number(), e.integer(), e.minValue(0), e.maxValue(2147483647));
+    const w = e.pipe(e.number(), e.integer(), e.minValue(0), e.maxValue(255));
+    i.Buffer256Bit = e.pipe(e.instance(Uint8Array), e.length(32)), i.Buffer33Bytes = e.pipe(e.instance(Uint8Array), e.length(33));
+    const s = e.object({
+      public: i.Uint32Schema,
+      private: i.Uint32Schema
+    });
+    i.NetworkSchema = e.object({
+      wif: w,
+      bip32: s,
+      messagePrefix: e.string(),
+      bech32: e.string(),
+      bech32Opnet: e.optional(e.string()),
+      pubKeyHash: w,
+      scriptHash: w
+    }), i.Bip32PathSchema = e.pipe(e.string(), e.regex(/^(m\/)?(\d+'?\/)*\d+'?$/));
+  })(A)), A;
+}
+var U = {}, re;
+function z() {
+  return re || (re = 1, Object.defineProperty(U, "__esModule", { value: !0 }), U.REGTEST = U.TESTNET = U.BITCOIN = void 0, U.BITCOIN = {
+    messagePrefix: `Bitcoin Signed Message:
+`,
+    bech32: "bc",
+    bip32: {
+      public: 76067358,
+      private: 76066276
+    },
+    pubKeyHash: 0,
+    scriptHash: 5,
+    wif: 128
+  }, U.TESTNET = {
+    messagePrefix: `Bitcoin Signed Message:
+`,
+    bech32: "tb",
+    bip32: {
+      public: 70617039,
+      private: 70615956
+    },
+    pubKeyHash: 111,
+    scriptHash: 196,
+    wif: 239
+  }, U.REGTEST = {
+    messagePrefix: `Bitcoin Signed Message:
+`,
+    bech32: "bcrt",
+    bip32: {
+      public: 70617039,
+      private: 70615956
+    },
+    pubKeyHash: 111,
+    scriptHash: 196,
+    wif: 239
+  }), U;
+}
+var ie;
+function me() {
+  if (ie) return D;
+  ie = 1;
+  var i = D && D.__createBinding || (Object.create ? (function(l, P, m, L) {
+    L === void 0 && (L = m);
+    var T = Object.getOwnPropertyDescriptor(P, m);
+    (!T || ("get" in T ? !P.__esModule : T.writable || T.configurable)) && (T = { enumerable: !0, get: function() {
+      return P[m];
+    } }), Object.defineProperty(l, L, T);
+  }) : (function(l, P, m, L) {
+    L === void 0 && (L = m), l[L] = P[m];
+  })), I = D && D.__setModuleDefault || (Object.create ? (function(l, P) {
+    Object.defineProperty(l, "default", { enumerable: !0, value: P });
+  }) : function(l, P) {
+    l.default = P;
+  }), g = D && D.__importStar || /* @__PURE__ */ (function() {
+    var l = function(P) {
+      return l = Object.getOwnPropertyNames || function(m) {
+        var L = [];
+        for (var T in m) Object.prototype.hasOwnProperty.call(m, T) && (L[L.length] = T);
+        return L;
+      }, l(P);
+    };
+    return function(P) {
+      if (P && P.__esModule) return P;
+      var m = {};
+      if (P != null) for (var L = l(P), T = 0; T < L.length; T++) L[T] !== "default" && i(m, P, L[T]);
+      return I(m, P), m;
+    };
+  })();
+  Object.defineProperty(D, "__esModule", { value: !0 }), D.BIP32Factory = F;
+  const _ = g(se()), e = Pe(), w = oe, s = /* @__PURE__ */ X(), r = g(/* @__PURE__ */ Z()), f = de(), E = g(_e()), u = g(W), p = z(), V = (0, w.base58check)(s.sha256), q = {
+    encode: (l) => V.encode(l),
+    decode: (l) => V.decode(l)
+  };
+  function F(l) {
+    (0, e.testEcc)(l);
+    const P = 2147483648;
+    function m(c) {
+      return c.length === 32 ? c : c.slice(1, 33);
+    }
+    class L {
+      __D;
+      __Q;
+      lowR = !1;
+      constructor(t, n) {
+        this.__D = t, this.__Q = n;
+      }
+      get publicKey() {
+        return this.__Q === void 0 && (this.__Q = l.pointFromScalar(this.__D, !0)), this.__Q;
+      }
+      get privateKey() {
+        return this.__D;
+      }
+      sign(t, n) {
+        if (!this.privateKey)
+          throw new Error("Missing private key");
+        if (n === void 0 && (n = this.lowR), n) {
+          let o = l.sign(t, this.privateKey);
+          const h = new Uint8Array(32);
+          let v = 0;
+          for (; o[0] > 127; )
+            v++, u.writeUInt32(h, 0, v, "LE"), o = l.sign(t, this.privateKey, h);
+          return o;
+        } else
+          return l.sign(t, this.privateKey);
+      }
+      signSchnorr(t) {
+        if (!this.privateKey)
+          throw new Error("Missing private key");
+        if (!l.signSchnorr)
+          throw new Error("signSchnorr not supported by ecc library");
+        return l.signSchnorr(t, this.privateKey);
+      }
+      verify(t, n) {
+        return l.verify(t, this.publicKey, n);
+      }
+      verifySchnorr(t, n) {
+        if (!l.verifySchnorr)
+          throw new Error("verifySchnorr not supported by ecc library");
+        return l.verifySchnorr(t, this.publicKey.subarray(1, 33), n);
+      }
+    }
+    class T extends L {
+      chainCode;
+      network;
+      __DEPTH;
+      __INDEX;
+      __PARENT_FINGERPRINT;
+      constructor(t, n, o, h, v = 0, O = 0, S = 0) {
+        super(t, n), this.chainCode = o, this.network = h, this.__DEPTH = v, this.__INDEX = O, this.__PARENT_FINGERPRINT = S, r.parse(f.NetworkSchema, h);
+      }
+      get depth() {
+        return this.__DEPTH;
+      }
+      get index() {
+        return this.__INDEX;
+      }
+      get parentFingerprint() {
+        return this.__PARENT_FINGERPRINT;
+      }
+      get identifier() {
+        return _.hash160(this.publicKey);
+      }
+      get fingerprint() {
+        return this.identifier.slice(0, 4);
+      }
+      get compressed() {
+        return !0;
+      }
+      // Private === not neutered
+      // Public === neutered
+      isNeutered() {
+        return this.__D === void 0;
+      }
+      neutered() {
+        return b(this.publicKey, this.chainCode, this.network, this.depth, this.index, this.parentFingerprint);
+      }
+      toBase58() {
+        const t = this.network, n = this.isNeutered() ? t.bip32.public : t.bip32.private, o = new Uint8Array(78);
+        return u.writeUInt32(o, 0, n, "BE"), u.writeUInt8(o, 4, this.depth), u.writeUInt32(o, 5, this.parentFingerprint, "BE"), u.writeUInt32(o, 9, this.index, "BE"), o.set(this.chainCode, 13), this.isNeutered() ? o.set(this.publicKey, 45) : (u.writeUInt8(o, 45, 0), o.set(this.privateKey, 46)), q.encode(o);
+      }
+      toWIF() {
+        if (!this.privateKey)
+          throw new TypeError("Missing private key");
+        return E.encode({
+          version: this.network.wif,
+          privateKey: this.privateKey,
+          compressed: !0
+        });
+      }
+      // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
+      derive(t) {
+        r.parse(f.Uint32Schema, t);
+        const n = t >= P, o = new Uint8Array(37);
+        if (n) {
+          if (this.isNeutered())
+            throw new TypeError("Missing private key for hardened child key");
+          o[0] = 0, o.set(this.privateKey, 1), u.writeUInt32(o, 33, t, "BE");
+        } else
+          o.set(this.publicKey, 0), u.writeUInt32(o, 33, t, "BE");
+        const h = _.hmacSHA512(this.chainCode, o), v = h.slice(0, 32), O = h.slice(32);
+        if (!l.isPrivate(v))
+          return this.derive(t + 1);
+        let S;
+        if (this.isNeutered()) {
+          const B = l.pointAddScalar(this.publicKey, v, !0);
+          if (B === null)
+            return this.derive(t + 1);
+          S = b(B, O, this.network, this.depth + 1, t, u.readUInt32(this.fingerprint, 0, "BE"));
+        } else {
+          const B = l.privateAdd(this.privateKey, v);
+          if (B == null)
+            return this.derive(t + 1);
+          S = y(B, O, this.network, this.depth + 1, t, u.readUInt32(this.fingerprint, 0, "BE"));
+        }
+        return S;
+      }
+      deriveHardened(t) {
+        if (typeof r.parse(f.Uint31Schema, t) == "number")
+          return this.derive(t + P);
+        throw new TypeError("Expected UInt31, got " + t);
+      }
+      derivePath(t) {
+        r.parse(f.Bip32PathSchema, t);
+        let n = t.split("/");
+        if (n[0] === "m") {
+          if (this.parentFingerprint)
+            throw new TypeError("Expected master, got child");
+          n = n.slice(1);
+        }
+        return n.reduce((o, h) => {
+          let v;
+          return h.slice(-1) === "'" ? (v = parseInt(h.slice(0, -1), 10), o.deriveHardened(v)) : (v = parseInt(h, 10), o.derive(v));
+        }, this);
+      }
+      tweak(t) {
+        return this.privateKey ? this.tweakFromPrivateKey(t) : this.tweakFromPublicKey(t);
+      }
+      tweakFromPublicKey(t) {
+        const n = m(this.publicKey);
+        if (!l.xOnlyPointAddTweak)
+          throw new Error("xOnlyPointAddTweak not supported by ecc library");
+        const o = l.xOnlyPointAddTweak(n, t);
+        if (!o || o.xOnlyPubkey === null)
+          throw new Error("Cannot tweak public key!");
+        const h = Uint8Array.from([
+          o.parity === 0 ? 2 : 3
+        ]), v = u.concat([
+          h,
+          o.xOnlyPubkey
+        ]);
+        return new L(void 0, v);
+      }
+      tweakFromPrivateKey(t) {
+        const n = this.publicKey[0] === 3 || this.publicKey[0] === 4 && (this.publicKey[64] & 1) === 1, o = (() => {
+          if (n) {
+            if (l.privateNegate)
+              return l.privateNegate(this.privateKey);
+            throw new Error("privateNegate not supported by ecc library");
+          } else return this.privateKey;
+        })(), h = l.privateAdd(o, t);
+        if (!h)
+          throw new Error("Invalid tweaked private key!");
+        return new L(h, void 0);
+      }
+    }
+    function Q(c, t) {
+      const n = q.decode(c);
+      if (n.length !== 78)
+        throw new TypeError("Invalid buffer length");
+      t = t || p.BITCOIN;
+      const o = u.readUInt32(n, 0, "BE");
+      if (o !== t.bip32.private && o !== t.bip32.public)
+        throw new TypeError("Invalid network version");
+      const h = n[4], v = u.readUInt32(n, 5, "BE");
+      if (h === 0 && v !== 0)
+        throw new TypeError("Invalid parent fingerprint");
+      const O = u.readUInt32(n, 9, "BE");
+      if (h === 0 && O !== 0)
+        throw new TypeError("Invalid index");
+      const S = n.slice(13, 45);
+      let B;
+      if (o === t.bip32.private) {
+        if (n[45] !== 0)
+          throw new TypeError("Invalid private key");
+        const C = n.slice(46, 78);
+        B = y(C, S, t, h, O, v);
+      } else {
+        const C = n.slice(45, 78);
+        B = b(C, S, t, h, O, v);
+      }
+      return B;
+    }
+    function H(c, t, n) {
+      return y(c, t, n);
+    }
+    function y(c, t, n, o, h, v) {
+      if (r.parse(f.Buffer256Bit, c), r.parse(f.Buffer256Bit, t), n = n || p.BITCOIN, !l.isPrivate(c))
+        throw new TypeError("Private key not in range [1, n)");
+      return new T(c, void 0, t, n, o, h, v);
+    }
+    function a(c, t, n) {
+      return b(c, t, n);
+    }
+    function b(c, t, n, o, h, v) {
+      if (r.parse(f.Buffer33Bytes, c), r.parse(f.Buffer256Bit, t), n = n || p.BITCOIN, !l.isPoint(c))
+        throw new TypeError("Point is not on the curve");
+      return new T(void 0, c, t, n, o, h, v);
+    }
+    function d(c, t) {
+      if (r.parse(r.instance(Uint8Array), c), c.length < 16)
+        throw new TypeError("Seed should be at least 128 bits");
+      if (c.length > 64)
+        throw new TypeError("Seed should be at most 512 bits");
+      t = t || p.BITCOIN;
+      const n = _.hmacSHA512(u.fromUtf8("Bitcoin seed"), c), o = n.slice(0, 32), h = n.slice(32);
+      return H(o, h, t);
+    }
+    return {
+      fromSeed: d,
+      fromBase58: Q,
+      fromPublicKey: a,
+      fromPrivateKey: H
+    };
+  }
+  return D;
+}
+var Y = {}, K = {}, N = {}, ne;
+function be() {
+  if (ne) return N;
+  ne = 1, Object.defineProperty(N, "__esModule", { value: !0 }), N.DEFAULT_SECURITY_LEVEL = N.MLDSASecurityLevel = void 0, N.getMLDSAConfig = e, N.findNetworkByVersion = w;
+  const i = Ee, I = z();
+  var g;
+  (function(s) {
+    s[s.LEVEL2 = 44] = "LEVEL2", s[s.LEVEL3 = 65] = "LEVEL3", s[s.LEVEL5 = 87] = "LEVEL5";
+  })(g || (N.MLDSASecurityLevel = g = {}));
+  const _ = {
+    [g.LEVEL2]: {
+      level: g.LEVEL2,
+      privateKeySize: 2560,
+      publicKeySize: 1312,
+      signatureSize: 2420,
+      algorithm: i.ml_dsa44
+    },
+    [g.LEVEL3]: {
+      level: g.LEVEL3,
+      privateKeySize: 4032,
+      publicKeySize: 1952,
+      signatureSize: 3309,
+      algorithm: i.ml_dsa65
+    },
+    [g.LEVEL5]: {
+      level: g.LEVEL5,
+      privateKeySize: 4896,
+      publicKeySize: 2592,
+      signatureSize: 4627,
+      algorithm: i.ml_dsa87
+    }
+  };
+  N.DEFAULT_SECURITY_LEVEL = g.LEVEL2;
+  function e(s, r) {
+    const f = _[s];
+    if (!f)
+      throw new TypeError(`Invalid ML-DSA security level: ${s}. Must be MLDSASecurityLevel.LEVEL2 (44), LEVEL3 (65), or LEVEL5 (87)`);
+    return {
+      ...f,
+      network: r
+    };
+  }
+  function w(s) {
+    const r = [I.BITCOIN, I.TESTNET, I.REGTEST];
+    for (const f of r) {
+      if (s === f.bip32.private)
+        return { network: f, isPrivate: !0 };
+      if (s === f.bip32.public)
+        return { network: f, isPrivate: !1 };
+    }
+    return null;
+  }
+  return N;
+}
+var fe;
+function Se() {
+  if (fe) return K;
+  fe = 1;
+  var i = K && K.__createBinding || (Object.create ? (function(y, a, b, d) {
+    d === void 0 && (d = b);
+    var c = Object.getOwnPropertyDescriptor(a, b);
+    (!c || ("get" in c ? !a.__esModule : c.writable || c.configurable)) && (c = { enumerable: !0, get: function() {
+      return a[b];
+    } }), Object.defineProperty(y, d, c);
+  }) : (function(y, a, b, d) {
+    d === void 0 && (d = b), y[d] = a[b];
+  })), I = K && K.__setModuleDefault || (Object.create ? (function(y, a) {
+    Object.defineProperty(y, "default", { enumerable: !0, value: a });
+  }) : function(y, a) {
+    y.default = a;
+  }), g = K && K.__importStar || /* @__PURE__ */ (function() {
+    var y = function(a) {
+      return y = Object.getOwnPropertyNames || function(b) {
+        var d = [];
+        for (var c in b) Object.prototype.hasOwnProperty.call(b, c) && (d[d.length] = c);
+        return d;
+      }, y(a);
+    };
+    return function(a) {
+      if (a && a.__esModule) return a;
+      var b = {};
+      if (a != null) for (var d = y(a), c = 0; c < d.length; c++) d[c] !== "default" && i(b, a, d[c]);
+      return I(b, a), b;
+    };
+  })();
+  Object.defineProperty(K, "__esModule", { value: !0 }), K.QuantumBIP32Factory = void 0;
+  const _ = we, e = g(se()), w = g(W), s = g(/* @__PURE__ */ Z()), r = de(), f = oe, E = /* @__PURE__ */ X(), u = be(), p = z(), V = (0, f.base58check)(E.sha256), q = {
+    encode: (y) => V.encode(y),
+    decode: (y) => V.decode(y)
+  }, F = 32, l = 2147483648;
+  class P {
+    _privateKey;
+    _publicKey;
+    config;
+    constructor(a, b, d) {
+      this._privateKey = a, this._publicKey = b, this.config = d;
+    }
+    get publicKey() {
+      if (!this._publicKey)
+        throw new Error("Public key not available");
+      return this._publicKey;
+    }
+    get privateKey() {
+      return this._privateKey;
+    }
+    sign(a) {
+      if (!this._privateKey)
+        throw new Error("Missing private key");
+      return this.config.algorithm.sign(a, this._privateKey, {
+        extraEntropy: (0, _.randomBytes)(32)
+      });
+    }
+    verify(a, b) {
+      return this.config.algorithm.verify(b, a, this._publicKey);
+    }
+  }
+  class m extends P {
+    chainCode;
+    _depth;
+    _index;
+    _parentFingerprint;
+    constructor(a, b, d, c, t = 0, n = 0, o = 0) {
+      super(a, b, c), this.chainCode = d, this._depth = t, this._index = n, this._parentFingerprint = o;
+    }
+    get depth() {
+      return this._depth;
+    }
+    get index() {
+      return this._index;
+    }
+    get parentFingerprint() {
+      return this._parentFingerprint;
+    }
+    get identifier() {
+      return e.hash160(this.publicKey);
+    }
+    get fingerprint() {
+      return this.identifier.slice(0, 4);
+    }
+    get securityLevel() {
+      return this.config.level;
+    }
+    get network() {
+      return this.config.network;
+    }
+    isNeutered() {
+      return this._privateKey === void 0;
+    }
+    neutered() {
+      return new m(void 0, this.publicKey, this.chainCode, this.config, this.depth, this.index, this.parentFingerprint);
+    }
+    toBase58() {
+      const a = this.isNeutered() ? this.config.network.bip32.public : this.config.network.bip32.private, b = !this.isNeutered(), c = 45 + (b ? this.config.privateKeySize : this.config.publicKeySize), t = new Uint8Array(c);
+      let n = 0;
+      return w.writeUInt32(t, n, a, "BE"), n += 4, w.writeUInt8(t, n, this.depth), n += 1, w.writeUInt32(t, n, this.parentFingerprint, "BE"), n += 4, w.writeUInt32(t, n, this.index, "BE"), n += 4, t.set(this.chainCode, n), n += 32, b ? t.set(this._privateKey, n) : t.set(this._publicKey, n), q.encode(t);
+    }
+    /**
+     * Derive a child key using BIP32 HMAC chain for seed derivation,
+     * then ML-DSA for key generation
+     */
+    derive(a) {
+      if (s.parse(r.Uint32Schema, a), this.isNeutered())
+        throw new TypeError("Cannot derive child keys without private key");
+      const b = a >= l;
+      let d;
+      if (b) {
+        const v = e.hash256(this._privateKey);
+        d = new Uint8Array(37), d[0] = 0, d.set(v, 1), w.writeUInt32(d, 33, a, "BE");
+      } else {
+        const v = e.hash256(this._privateKey);
+        d = new Uint8Array(36), d.set(v, 0), w.writeUInt32(d, 32, a, "BE");
+      }
+      const c = e.hmacSHA512(this.chainCode, d), t = c.slice(0, 32), n = c.slice(32), { secretKey: o, publicKey: h } = this.config.algorithm.keygen(t);
+      return new m(o, h, n, this.config, this.depth + 1, a, w.readUInt32(this.fingerprint, 0, "BE"));
+    }
+    deriveHardened(a) {
+      try {
+        s.parse(r.Uint31Schema, a);
+      } catch {
+        throw new TypeError("Expected UInt31, got " + a);
+      }
+      return this.derive(a + l);
+    }
+    derivePath(a) {
+      s.parse(r.Bip32PathSchema, a);
+      let b = a.split("/");
+      if (b[0] === "m") {
+        if (this.parentFingerprint)
+          throw new TypeError("Expected master, got child");
+        b = b.slice(1);
+      }
+      return b.reduce((d, c) => {
+        let t;
+        return c.slice(-1) === "'" ? (t = parseInt(c.slice(0, -1), 10), d.deriveHardened(t)) : (t = parseInt(c, 10), d.derive(t));
+      }, this);
+    }
+  }
+  function L(y, a, b) {
+    if (s.parse(s.instance(Uint8Array), y), y.length < 16)
+      throw new TypeError("Seed should be at least 128 bits");
+    if (y.length > 64)
+      throw new TypeError("Seed should be at most 512 bits");
+    const d = (0, u.getMLDSAConfig)(b || u.MLDSASecurityLevel.LEVEL2, a || p.BITCOIN), c = e.hmacSHA512(w.fromUtf8("Bitcoin seed"), y), t = c.slice(0, 32), n = c.slice(32), { secretKey: o, publicKey: h } = d.algorithm.keygen(t);
+    return new m(
+      o,
+      h,
+      n,
+      // Chain code
+      d,
+      0,
+      // depth
+      0,
+      // index
+      0
+    );
+  }
+  function T(y) {
+    const a = q.decode(y), b = w.readUInt32(a, 0, "BE"), d = (0, u.findNetworkByVersion)(b);
+    if (!d)
+      throw new TypeError("Unknown network version");
+    const { network: c, isPrivate: t } = d, o = a.length - 45;
+    let h;
+    if (t)
+      if (o === 2560)
+        h = u.MLDSASecurityLevel.LEVEL2;
+      else if (o === 4032)
+        h = u.MLDSASecurityLevel.LEVEL3;
+      else if (o === 4896)
+        h = u.MLDSASecurityLevel.LEVEL5;
+      else
+        throw new TypeError(`Invalid private key size: ${o}`);
+    else if (o === 1312)
+      h = u.MLDSASecurityLevel.LEVEL2;
+    else if (o === 1952)
+      h = u.MLDSASecurityLevel.LEVEL3;
+    else if (o === 2592)
+      h = u.MLDSASecurityLevel.LEVEL5;
+    else
+      throw new TypeError(`Invalid public key size: ${o}`);
+    const v = (0, u.getMLDSAConfig)(h, c), O = t ? 45 + v.privateKeySize : 45 + v.publicKeySize;
+    if (a.length !== O)
+      throw new TypeError(`Invalid buffer length: expected ${O}, got ${a.length}`);
+    let S = 4;
+    const B = a[S];
+    S += 1;
+    const C = w.readUInt32(a, S, "BE");
+    if (B === 0 && C !== 0)
+      throw new TypeError("Invalid parent fingerprint");
+    S += 4;
+    const x = w.readUInt32(a, S, "BE");
+    if (B === 0 && x !== 0)
+      throw new TypeError("Invalid index");
+    S += 4;
+    const J = a.slice(S, S + 32);
+    if (S += 32, t) {
+      const k = a.slice(S, S + v.privateKeySize), le = v.algorithm.getPublicKey(k);
+      return new m(k, le, J, v, B, x, C);
+    } else {
+      const k = a.slice(S, S + v.publicKeySize);
+      return new m(void 0, k, J, v, B, x, C);
+    }
+  }
+  function Q(y, a, b, d) {
+    const c = (0, u.getMLDSAConfig)(d || u.MLDSASecurityLevel.LEVEL2, b || p.BITCOIN);
+    if (y.length !== c.publicKeySize)
+      throw new TypeError(`Invalid public key length for ML-DSA-${d}: expected ${c.publicKeySize}, got ${y.length}`);
+    if (a.length !== F)
+      throw new TypeError(`Invalid chain code length: expected ${F}, got ${a.length}`);
+    return new m(void 0, y, a, c, 0, 0, 0);
+  }
+  function H(y, a, b, d) {
+    const c = (0, u.getMLDSAConfig)(d || u.MLDSASecurityLevel.LEVEL2, b || p.BITCOIN);
+    if (y.length !== c.privateKeySize)
+      throw new TypeError(`Invalid private key length for ML-DSA-${d}: expected ${c.privateKeySize}, got ${y.length}`);
+    if (a.length !== F)
+      throw new TypeError(`Invalid chain code length: expected ${F}, got ${a.length}`);
+    const t = c.algorithm.getPublicKey(y);
+    return new m(y, t, a, c, 0, 0, 0);
+  }
+  return K.QuantumBIP32Factory = {
+    fromSeed: L,
+    fromBase58: T,
+    fromPublicKey: Q,
+    fromPrivateKey: H
+  }, K;
+}
+var M = {}, ae;
+function he() {
+  if (ae) return M;
+  ae = 1, Object.defineProperty(M, "__esModule", { value: !0 }), M.QuantumDerivationPath = M.DerivationPath = void 0, M.getQuantumPath = g, M.getBitcoinPath = _;
+  var i;
+  (function(e) {
+    e.BIP44 = "m/44'/0'/0'/0/0", e.BIP49 = "m/49'/0'/0'/0/0", e.BIP84 = "m/84'/0'/0'/0/0", e.BIP86 = "m/86'/0'/0'/0/0", e.BIP360 = "m/360'/0'/0'/0/0";
+  })(i || (M.DerivationPath = i = {}));
+  var I;
+  (function(e) {
+    e.STANDARD = "m/360'/0'/0'/0/0", e.CHANGE = "m/360'/0'/0'/1/0", e.ACCOUNT_0_ADDRESS_0 = "m/360'/0'/0'/0/0", e.ACCOUNT_0_ADDRESS_1 = "m/360'/0'/0'/0/1", e.ACCOUNT_1_ADDRESS_0 = "m/360'/1'/0'/0/0";
+  })(I || (M.QuantumDerivationPath = I = {}));
+  function g(e = 0, w = 0, s = !1) {
+    return `m/360'/${e}'/${s ? 1 : 0}'/${w}`;
+  }
+  function _(e, w = 0, s = 0, r = !1) {
+    return `m/${e}'/0'/${w}'/${r ? 1 : 0}/${s}`;
+  }
+  return M;
+}
+var ce;
+function Ie() {
+  return ce || (ce = 1, (function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.getBitcoinPath = i.getQuantumPath = i.QuantumDerivationPath = i.DerivationPath = i.getMLDSAConfig = i.DEFAULT_SECURITY_LEVEL = i.MLDSASecurityLevel = i.QuantumBIP32Factory = void 0;
+    var I = Se();
+    Object.defineProperty(i, "QuantumBIP32Factory", { enumerable: !0, get: function() {
+      return I.QuantumBIP32Factory;
+    } });
+    var g = be();
+    Object.defineProperty(i, "MLDSASecurityLevel", { enumerable: !0, get: function() {
+      return g.MLDSASecurityLevel;
+    } }), Object.defineProperty(i, "DEFAULT_SECURITY_LEVEL", { enumerable: !0, get: function() {
+      return g.DEFAULT_SECURITY_LEVEL;
+    } }), Object.defineProperty(i, "getMLDSAConfig", { enumerable: !0, get: function() {
+      return g.getMLDSAConfig;
+    } });
+    var _ = he();
+    Object.defineProperty(i, "DerivationPath", { enumerable: !0, get: function() {
+      return _.DerivationPath;
+    } }), Object.defineProperty(i, "QuantumDerivationPath", { enumerable: !0, get: function() {
+      return _.QuantumDerivationPath;
+    } }), Object.defineProperty(i, "getQuantumPath", { enumerable: !0, get: function() {
+      return _.getQuantumPath;
+    } }), Object.defineProperty(i, "getBitcoinPath", { enumerable: !0, get: function() {
+      return _.getBitcoinPath;
+    } });
+  })(Y)), Y;
+}
+var ue;
+function Le() {
+  return ue || (ue = 1, (function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.getBitcoinPath = i.getQuantumPath = i.QuantumDerivationPath = i.DerivationPath = i.getMLDSAConfig = i.DEFAULT_SECURITY_LEVEL = i.MLDSASecurityLevel = i.QuantumBIP32Factory = i.REGTEST = i.TESTNET = i.BITCOIN = i.BIP32Factory = i.default = void 0;
+    var I = me();
+    Object.defineProperty(i, "default", { enumerable: !0, get: function() {
+      return I.BIP32Factory;
+    } }), Object.defineProperty(i, "BIP32Factory", { enumerable: !0, get: function() {
+      return I.BIP32Factory;
+    } });
+    var g = z();
+    Object.defineProperty(i, "BITCOIN", { enumerable: !0, get: function() {
+      return g.BITCOIN;
+    } }), Object.defineProperty(i, "TESTNET", { enumerable: !0, get: function() {
+      return g.TESTNET;
+    } }), Object.defineProperty(i, "REGTEST", { enumerable: !0, get: function() {
+      return g.REGTEST;
+    } });
+    var _ = Ie();
+    Object.defineProperty(i, "QuantumBIP32Factory", { enumerable: !0, get: function() {
+      return _.QuantumBIP32Factory;
+    } }), Object.defineProperty(i, "MLDSASecurityLevel", { enumerable: !0, get: function() {
+      return _.MLDSASecurityLevel;
+    } }), Object.defineProperty(i, "DEFAULT_SECURITY_LEVEL", { enumerable: !0, get: function() {
+      return _.DEFAULT_SECURITY_LEVEL;
+    } }), Object.defineProperty(i, "getMLDSAConfig", { enumerable: !0, get: function() {
+      return _.getMLDSAConfig;
+    } });
+    var e = he();
+    Object.defineProperty(i, "DerivationPath", { enumerable: !0, get: function() {
+      return e.DerivationPath;
+    } }), Object.defineProperty(i, "QuantumDerivationPath", { enumerable: !0, get: function() {
+      return e.QuantumDerivationPath;
+    } }), Object.defineProperty(i, "getQuantumPath", { enumerable: !0, get: function() {
+      return e.getQuantumPath;
+    } }), Object.defineProperty(i, "getBitcoinPath", { enumerable: !0, get: function() {
+      return e.getBitcoinPath;
+    } });
+  })(G)), G;
+}
+var Te = Le();
+const Ue = /* @__PURE__ */ pe(Te);
+export {
+  Ue as b,
+  Te as c
+};