@btc-vision/transaction 1.7.22 → 1.7.23

package/browser/btc-vision-post-quantum.js

@@ -0,0 +1,542 @@
+import { a as Je } from "./bip39.js";
+import { F as qe, c as st, d as ct } from "./noble-curves.js";
+import { h as j, i as it, j as Pe, k as lt, l as ft, m as R } from "./noble-hashes.js";
+const Le = it;
+function Se(e, o) {
+  if (e.length !== o.length)
+    return !1;
+  let n = 0;
+  for (let l = 0; l < e.length; l++)
+    n |= e[l] ^ o[l];
+  return n === 0;
+}
+function dt(e) {
+  return Uint8Array.from(e);
+}
+function je(e) {
+  if (typeof e != "object" || e === null || lt(e))
+    throw new Error("expected opts to be an object");
+}
+function Me(e) {
+  je(e), e.context !== void 0 && j(e.context, void 0, "opts.context");
+}
+function me(e) {
+  Me(e), e.extraEntropy !== !1 && e.extraEntropy !== void 0 && j(e.extraEntropy, void 0, "opts.extraEntropy");
+}
+function ue(e, ...o) {
+  const n = (d) => typeof d == "number" ? d : d.bytesLen, l = o.reduce((d, g) => d + n(g), 0);
+  return {
+    bytesLen: l,
+    encode: (d) => {
+      const g = new Uint8Array(l);
+      for (let h = 0, u = 0; h < o.length; h++) {
+        const M = o[h], G = n(M), O = typeof M == "number" ? d[h] : M.encode(d[h]);
+        j(O, G, e), g.set(O, u), typeof M != "number" && O.fill(0), u += G;
+      }
+      return g;
+    },
+    decode: (d) => {
+      j(d, l, e);
+      const g = [];
+      for (const h of o) {
+        const u = n(h), M = d.subarray(0, u);
+        g.push(typeof h == "number" ? M : h.decode(M)), d = d.subarray(u);
+      }
+      return g;
+    }
+  };
+}
+function J(e, o) {
+  const n = o * e.bytesLen;
+  return {
+    bytesLen: n,
+    encode: (l) => {
+      if (l.length !== o)
+        throw new Error(`vecCoder.encode: wrong length=${l.length}. Expected: ${o}`);
+      const d = new Uint8Array(n);
+      for (let g = 0, h = 0; g < l.length; g++) {
+        const u = e.encode(l[g]);
+        d.set(u, h), u.fill(0), h += u.length;
+      }
+      return d;
+    },
+    decode: (l) => {
+      j(l, n);
+      const d = [];
+      for (let g = 0; g < l.length; g += e.bytesLen)
+        d.push(e.decode(l.subarray(g, g + e.bytesLen)));
+      return d;
+    }
+  };
+}
+function D(...e) {
+  for (const o of e)
+    if (Array.isArray(o))
+      for (const n of o)
+        n.fill(0);
+    else
+      o.fill(0);
+}
+function _e(e) {
+  return (1 << e) - 1;
+}
+const Oe = Uint8Array.of();
+function Be(e, o = Oe) {
+  if (j(e), j(o), o.length > 255)
+    throw new Error("context should be less than 255 bytes");
+  return Pe(new Uint8Array([0, o.length]), o, e);
+}
+const at = /* @__PURE__ */ Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2]);
+function et(e, o = 0) {
+  if (!e.oid || !Se(e.oid.subarray(0, 10), at))
+    throw new Error("hash.oid is invalid: expected NIST hash");
+  const n = e.outputLen * 8 / 2;
+  if (o > n)
+    throw new Error("Pre-hash security strength too low: " + n + ", required: " + o);
+}
+function ke(e, o, n = Oe) {
+  if (j(o), j(n), n.length > 255)
+    throw new Error("context should be less than 255 bytes");
+  const l = e(o);
+  return Pe(new Uint8Array([1, n.length]), n, e.oid, l);
+}
+const ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EMPTY: Oe,
+  abytes: j,
+  checkHash: et,
+  cleanBytes: D,
+  concatBytes: Pe,
+  copyBytes: dt,
+  equalBytes: Se,
+  getMask: _e,
+  getMessage: Be,
+  getMessagePrehash: ke,
+  randomBytes: Le,
+  splitCoder: ue,
+  validateOpts: je,
+  validateSigOpts: me,
+  validateVerOpts: Me,
+  vecCoder: J
+}, Symbol.toStringTag, { value: "Module" })), Lt = /* @__PURE__ */ Je(ut);
+const yt = (e) => {
+  const { newPoly: o, N: n, Q: l, F: d, ROOT_OF_UNITY: g, brvBits: h } = e, u = (y, p = l) => {
+    const B = y % p | 0;
+    return (B >= 0 ? B | 0 : p + B | 0) | 0;
+  }, M = (y, p = l) => {
+    const B = u(y, p) | 0;
+    return (B > p >> 1 ? B - p | 0 : B) | 0;
+  };
+  function G() {
+    const y = o(n);
+    for (let p = 0; p < n; p++) {
+      const B = st(p, h), oe = BigInt(g) ** BigInt(B) % BigInt(l);
+      y[p] = Number(oe) | 0;
+    }
+    return y;
+  }
+  const O = G(), Q = {
+    add: (y, p) => u((y | 0) + (p | 0)) | 0,
+    sub: (y, p) => u((y | 0) - (p | 0)) | 0,
+    mul: (y, p) => u((y | 0) * (p | 0)) | 0,
+    inv: (y) => {
+      throw new Error("not implemented");
+    }
+  }, se = {
+    N: n,
+    roots: O,
+    invertButterflies: !0,
+    skipStages: 0,
+    brp: !1
+  }, ce = qe(Q, { dit: !1, ...se }), ne = qe(Q, { dit: !0, ...se });
+  return { mod: u, smod: M, nttZetas: O, NTT: {
+    encode: (y) => ce(y),
+    decode: (y) => {
+      ne(y);
+      for (let p = 0; p < y.length; p++)
+        y[p] = u(d * y[p]);
+      return y;
+    }
+  }, bitsCoder: (y, p) => {
+    const B = _e(y), oe = y * (n / 8);
+    return {
+      bytesLen: oe,
+      encode: (V) => {
+        const W = new Uint8Array(oe);
+        for (let Y = 0, H = 0, k = 0, ie = 0; Y < V.length; Y++)
+          for (H |= (p.encode(V[Y]) & B) << k, k += y; k >= 8; k -= 8, H >>= 8)
+            W[ie++] = H & _e(k);
+        return W;
+      },
+      decode: (V) => {
+        const W = o(n);
+        for (let Y = 0, H = 0, k = 0, ie = 0; Y < V.length; Y++)
+          for (H |= V[Y] << k, k += 8; k >= y; k -= y, H >>= y)
+            W[ie++] = p.decode(H & B);
+        return W;
+      }
+    };
+  } };
+}, tt = (e) => (o, n) => {
+  n || (n = e.blockLen);
+  const l = new Uint8Array(o.length + 2);
+  l.set(o);
+  const d = o.length, g = new Uint8Array(n);
+  let h = e.create({}), u = 0, M = 0;
+  return {
+    stats: () => ({ calls: u, xofs: M }),
+    get: (G, O) => (l[d + 0] = G, l[d + 1] = O, h.destroy(), h = e.create({}).update(l), u++, () => (M++, h.xofInto(g))),
+    clean: () => {
+      h.destroy(), D(g, l);
+    }
+  };
+}, Ue = /* @__PURE__ */ tt(ft), Re = /* @__PURE__ */ tt(R);
+function Ze(e) {
+  je(e), e.externalMu !== void 0 && ct(e.externalMu, "opts.externalMu");
+}
+const b = 256, Z = 8380417, ht = 1753, gt = 8347681, te = 13, Ce = Math.floor((Z - 1) / 88) | 0, ve = Math.floor((Z - 1) / 32) | 0, Ee = {
+  2: { K: 4, L: 4, D: te, GAMMA1: 2 ** 17, GAMMA2: Ce, TAU: 39, ETA: 2, OMEGA: 80 },
+  3: { K: 6, L: 5, D: te, GAMMA1: 2 ** 19, GAMMA2: ve, TAU: 49, ETA: 4, OMEGA: 55 },
+  5: { K: 8, L: 7, D: te, GAMMA1: 2 ** 19, GAMMA2: ve, TAU: 60, ETA: 2, OMEGA: 75 }
+}, S = (e) => new Int32Array(e), { mod: ee, smod: we, NTT: x, bitsCoder: pt } = yt({
+  N: b,
+  Q: Z,
+  F: gt,
+  ROOT_OF_UNITY: ht,
+  newPoly: S,
+  brvBits: 8
+}), Qe = (e) => e, de = (e, o = Qe, n = Qe) => pt(e, {
+  encode: (l) => o(n(l)),
+  decode: (l) => n(o(l))
+}), z = (e, o) => {
+  for (let n = 0; n < e.length; n++)
+    e[n] = ee(e[n] + o[n]);
+  return e;
+}, Ve = (e, o) => {
+  for (let n = 0; n < e.length; n++)
+    e[n] = ee(e[n] - o[n]);
+  return e;
+}, At = (e) => {
+  for (let o = 0; o < b; o++)
+    e[o] <<= te;
+  return e;
+}, ae = (e, o) => {
+  for (let n = 0; n < b; n++)
+    if (Math.abs(we(e[n])) >= o)
+      return !0;
+  return !1;
+}, q = (e, o) => {
+  const n = S(b);
+  for (let l = 0; l < e.length; l++)
+    n[l] = ee(e[l] * o[l]);
+  return n;
+};
+function Te(e) {
+  const o = S(b);
+  for (let n = 0; n < b; ) {
+    const l = e();
+    if (l.length % 3)
+      throw new Error("RejNTTPoly: unaligned block");
+    for (let d = 0; n < b && d <= l.length - 3; d += 3) {
+      const g = (l[d + 0] | l[d + 1] << 8 | l[d + 2] << 16) & 8388607;
+      g < Z && (o[n++] = g);
+    }
+  }
+  return o;
+}
+function Ke(e) {
+  const { K: o, L: n, GAMMA1: l, GAMMA2: d, TAU: g, ETA: h, OMEGA: u } = e, { CRH_BYTES: M, TR_BYTES: G, C_TILDE_BYTES: O, XOF128: Q, XOF256: se, securityLevel: ce } = e;
+  if (![2, 4].includes(h))
+    throw new Error("Wrong ETA");
+  if (![1 << 17, 1 << 19].includes(l))
+    throw new Error("Wrong GAMMA1");
+  if (![Ce, ve].includes(d))
+    throw new Error("Wrong GAMMA2");
+  const ne = g * h, ye = (t) => {
+    const c = ee(t), r = we(c, 2 * d) | 0;
+    return c - r === Z - 1 ? { r1: 0, r0: r - 1 | 0 } : { r1: Math.floor((c - r) / (2 * d)) | 0, r0: r };
+  }, Ge = (t) => ye(t).r1, y = (t) => ye(t).r0, p = (t, c) => t <= d || t > Z - d || t === Z - d && c === 0 ? 0 : 1, B = (t, c) => {
+    const r = Math.floor((Z - 1) / (2 * d)), { r1: s, r0: f } = ye(c);
+    return t === 1 ? f > 0 ? ee(s + 1, r) | 0 : ee(s - 1, r) | 0 : s | 0;
+  }, oe = (t) => {
+    const c = ee(t), r = we(c, 2 ** te) | 0;
+    return { r1: Math.floor((c - r) / 2 ** te) | 0, r0: r };
+  }, V = {
+    bytesLen: u + o,
+    encode: (t) => {
+      if (t === !1)
+        throw new Error("hint.encode: hint is false");
+      const c = new Uint8Array(u + o);
+      for (let r = 0, s = 0; r < o; r++) {
+        for (let f = 0; f < b; f++)
+          t[r][f] !== 0 && (c[s++] = f);
+        c[u + r] = s;
+      }
+      return c;
+    },
+    decode: (t) => {
+      const c = [];
+      let r = 0;
+      for (let s = 0; s < o; s++) {
+        const f = S(b);
+        if (t[u + s] < r || t[u + s] > u)
+          return !1;
+        for (let a = r; a < t[u + s]; a++) {
+          if (a > r && t[a] <= t[a - 1])
+            return !1;
+          f[t[a]] = 1;
+        }
+        r = t[u + s], c.push(f);
+      }
+      for (let s = r; s < u; s++)
+        if (t[s] !== 0)
+          return !1;
+      return c;
+    }
+  }, W = de(h === 2 ? 3 : 4, (t) => h - t, (t) => {
+    if (!(-h <= t && t <= h))
+      throw new Error(`malformed key s1/s3 ${t} outside of ETA range [${-h}, ${h}]`);
+    return t;
+  }), Y = de(13, (t) => (1 << te - 1) - t), H = de(10), k = de(l === 1 << 17 ? 18 : 20, (t) => we(l - t)), ie = de(d === Ce ? 6 : 4), Ie = J(ie, o), he = ue("publicKey", 32, J(H, o)), ge = ue("secretKey", 32, 32, G, J(W, n), J(W, o), J(Y, o)), pe = ue("signature", O, J(k, n), V), Ne = h === 2 ? (t) => t < 15 ? 2 - t % 5 : !1 : (t) => t < 9 ? 4 - t : !1;
+  function Ye(t) {
+    const c = S(b);
+    for (let r = 0; r < b; ) {
+      const s = t();
+      for (let f = 0; r < b && f < s.length; f += 1) {
+        const a = Ne(s[f] & 15), L = Ne(s[f] >> 4 & 15);
+        a !== !1 && (c[r++] = a), r < b && L !== !1 && (c[r++] = L);
+      }
+    }
+    return c;
+  }
+  const He = (t) => {
+    const c = S(b), r = R.create({}).update(t), s = new Uint8Array(R.blockLen);
+    r.xofInto(s);
+    const f = s.slice(0, 8);
+    for (let a = b - g, L = 8, C = 0, T = 0; a < b; a++) {
+      let m = a + 1;
+      for (; m > a; )
+        m = s[L++], !(L < R.blockLen) && (r.xofInto(s), L = 0);
+      c[a] = c[m], c[m] = 1 - ((f[C] >> T++ & 1) << 1), T >= 8 && (C++, T = 0);
+    }
+    return c;
+  }, Fe = (t) => {
+    const c = S(b), r = S(b);
+    for (let s = 0; s < t.length; s++) {
+      const { r0: f, r1: a } = oe(t[s]);
+      c[s] = f, r[s] = a;
+    }
+    return { r0: c, r1: r };
+  }, nt = (t, c) => {
+    for (let r = 0; r < b; r++)
+      t[r] = B(c[r], t[r]);
+    return t;
+  }, ot = (t, c) => {
+    const r = S(b);
+    let s = 0;
+    for (let f = 0; f < b; f++) {
+      const a = p(t[f], c[f]);
+      r[f] = a, s += a;
+    }
+    return { v: r, cnt: s };
+  }, $e = 32, De = ue("seed", 32, 64, 32), K = {
+    info: { type: "internal-ml-dsa" },
+    lengths: {
+      secretKey: ge.bytesLen,
+      publicKey: he.bytesLen,
+      seed: 32,
+      signature: pe.bytesLen,
+      signRand: $e
+    },
+    keygen: (t) => {
+      const c = new Uint8Array(34), r = t === void 0;
+      r && (t = Le(32)), j(t, 32, "seed"), c.set(t), r && D(t), c[32] = o, c[33] = n;
+      const [s, f, a] = De.decode(R(c, { dkLen: De.bytesLen })), L = se(f), C = [];
+      for (let i = 0; i < n; i++)
+        C.push(Ye(L.get(i & 255, i >> 8 & 255)));
+      const T = [];
+      for (let i = n; i < n + o; i++)
+        T.push(Ye(L.get(i & 255, i >> 8 & 255)));
+      const m = C.map((i) => x.encode(i.slice())), w = [], _ = [], F = Q(s), E = S(b);
+      for (let i = 0; i < o; i++) {
+        D(E);
+        for (let P = 0; P < n; P++) {
+          const N = Te(F.get(P, i));
+          z(E, q(N, m[P]));
+        }
+        x.decode(E);
+        const { r0: U, r1: v } = Fe(z(E, T[i]));
+        w.push(U), _.push(v);
+      }
+      const I = he.encode([s, _]), $ = R(I, { dkLen: G }), re = ge.encode([s, a, $, C, T, w]);
+      return F.clean(), L.clean(), D(s, f, a, C, T, m, E, w, _, $, c), { publicKey: I, secretKey: re };
+    },
+    getPublicKey: (t) => {
+      const [c, r, s, f, a, L] = ge.decode(t), C = Q(c), T = f.map((_) => x.encode(_.slice())), m = [], w = S(b);
+      for (let _ = 0; _ < o; _++) {
+        w.fill(0);
+        for (let E = 0; E < n; E++) {
+          const I = Te(C.get(E, _));
+          z(w, q(I, T[E]));
+        }
+        x.decode(w), z(w, a[_]);
+        const { r1: F } = Fe(w);
+        m.push(F);
+      }
+      return C.clean(), D(w, T, L, f, a), he.encode([c, m]);
+    },
+    // NOTE: random is optional.
+    sign: (t, c, r = {}) => {
+      me(r), Ze(r);
+      let { extraEntropy: s, externalMu: f = !1 } = r;
+      const [a, L, C, T, m, w] = ge.decode(c), _ = [], F = Q(a);
+      for (let i = 0; i < o; i++) {
+        const U = [];
+        for (let v = 0; v < n; v++)
+          U.push(Te(F.get(v, i)));
+        _.push(U);
+      }
+      F.clean();
+      for (let i = 0; i < n; i++)
+        x.encode(T[i]);
+      for (let i = 0; i < o; i++)
+        x.encode(m[i]), x.encode(w[i]);
+      const E = f ? t : R.create({ dkLen: M }).update(C).update(t).digest(), I = s === !1 ? new Uint8Array(32) : s === void 0 ? Le($e) : s;
+      j(I, 32, "extraEntropy");
+      const $ = R.create({ dkLen: M }).update(L).update(I).update(E).digest();
+      j($, M);
+      const re = se($, k.bytesLen);
+      e: for (let i = 0; ; ) {
+        const U = [];
+        for (let A = 0; A < n; A++, i++)
+          U.push(k.decode(re.get(i & 255, i >> 8)()));
+        const v = U.map((A) => x.encode(A.slice())), P = [];
+        for (let A = 0; A < o; A++) {
+          const fe = S(b);
+          for (let X = 0; X < n; X++)
+            z(fe, q(_[A][X], v[X]));
+          x.decode(fe), P.push(fe);
+        }
+        const N = P.map((A) => A.map(Ge)), le = R.create({ dkLen: O }).update(E).update(Ie.encode(N)).digest(), Ae = x.encode(He(le)), be = T.map((A) => q(A, Ae));
+        for (let A = 0; A < n; A++)
+          if (z(x.decode(be[A]), U[A]), ae(be[A], l - ne))
+            continue e;
+        let We = 0;
+        const xe = [];
+        for (let A = 0; A < o; A++) {
+          const fe = x.decode(q(m[A], Ae)), X = Ve(P[A], fe).map(y);
+          if (ae(X, d - ne))
+            continue e;
+          const Xe = x.decode(q(w[A], Ae));
+          if (ae(Xe, d))
+            continue e;
+          z(X, Xe);
+          const ze = ot(X, N[A]);
+          xe.push(ze.v), We += ze.cnt;
+        }
+        if (We > u)
+          continue;
+        re.clean();
+        const rt = pe.encode([le, be, xe]);
+        return D(le, be, xe, Ae, N, P, v, U, $, E, T, m, w, ..._), rt;
+      }
+      throw new Error("Unreachable code path reached, report this error");
+    },
+    verify: (t, c, r, s = {}) => {
+      Ze(s);
+      const { externalMu: f = !1 } = s, [a, L] = he.decode(r), C = R(r, { dkLen: G });
+      if (t.length !== pe.bytesLen)
+        return !1;
+      const [T, m, w] = pe.decode(t);
+      if (w === !1)
+        return !1;
+      for (let i = 0; i < n; i++)
+        if (ae(m[i], l - ne))
+          return !1;
+      const _ = f ? c : R.create({ dkLen: M }).update(C).update(c).digest(), F = x.encode(He(T)), E = m.map((i) => i.slice());
+      for (let i = 0; i < n; i++)
+        x.encode(E[i]);
+      const I = [], $ = Q(a);
+      for (let i = 0; i < o; i++) {
+        const U = q(x.encode(At(L[i])), F), v = S(b);
+        for (let N = 0; N < n; N++) {
+          const le = Te($.get(N, i));
+          z(v, q(le, E[N]));
+        }
+        const P = x.decode(Ve(v, U));
+        I.push(nt(P, w[i]));
+      }
+      $.clean();
+      const re = R.create({ dkLen: O }).update(_).update(Ie.encode(I)).digest();
+      for (const i of w)
+        if (!(i.reduce((v, P) => v + P, 0) <= u))
+          return !1;
+      for (const i of m)
+        if (ae(i, l - ne))
+          return !1;
+      return Se(T, re);
+    }
+  };
+  return {
+    info: { type: "ml-dsa" },
+    internal: K,
+    securityLevel: ce,
+    keygen: K.keygen,
+    lengths: K.lengths,
+    getPublicKey: K.getPublicKey,
+    sign: (t, c, r = {}) => {
+      me(r);
+      const s = Be(t, r.context), f = K.sign(s, c, r);
+      return D(s), f;
+    },
+    verify: (t, c, r, s = {}) => (Me(s), K.verify(t, Be(c, s.context), r)),
+    prehash: (t) => (et(t, ce), {
+      info: { type: "hashml-dsa" },
+      securityLevel: ce,
+      lengths: K.lengths,
+      keygen: K.keygen,
+      getPublicKey: K.getPublicKey,
+      sign: (c, r, s = {}) => {
+        me(s);
+        const f = ke(t, c, s.context), a = K.sign(f, r, s);
+        return D(f), a;
+      },
+      verify: (c, r, s, f = {}) => (Me(f), K.verify(c, ke(t, r, f.context), s))
+    })
+  };
+}
+const bt = /* @__PURE__ */ Ke({
+  ...Ee[2],
+  CRH_BYTES: 64,
+  TR_BYTES: 64,
+  C_TILDE_BYTES: 32,
+  XOF128: Ue,
+  XOF256: Re,
+  securityLevel: 128
+}), Tt = /* @__PURE__ */ Ke({
+  ...Ee[3],
+  CRH_BYTES: 64,
+  TR_BYTES: 64,
+  C_TILDE_BYTES: 48,
+  XOF128: Ue,
+  XOF256: Re,
+  securityLevel: 192
+}), mt = /* @__PURE__ */ Ke({
+  ...Ee[5],
+  CRH_BYTES: 64,
+  TR_BYTES: 64,
+  C_TILDE_BYTES: 64,
+  XOF128: Ue,
+  XOF256: Re,
+  securityLevel: 256
+}), wt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PARAMS: Ee,
+  ml_dsa44: bt,
+  ml_dsa65: Tt,
+  ml_dsa87: mt
+}, Symbol.toStringTag, { value: "Module" })), _t = /* @__PURE__ */ Je(wt);
+export {
+  Lt as a,
+  _t as r
+};

package/browser/chain/ChainData.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 export declare function getChainIdHex(network: Network): string;
 export declare function getChainId(network: Network): Uint8Array;
 export declare const BITCOIN_PROTOCOL_ID: Uint8Array<ArrayBuffer>;

package/browser/crypto/crypto.d.ts

@@ -1 +1 @@
-export { createHash, createHmac, pbkdf2Sync, randomBytes } from 'crypto';
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from './crypto-browser.js';

package/browser/generators/AddressGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 export declare class AddressGenerator {
     static generatePKSH(sha256Hash: Buffer, network: Network): string;
     static generateTaprootAddress(pubKey: Buffer, network: {

package/browser/generators/Generator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
 import { Feature, Features } from './Features.js';
 export declare abstract class Generator {

package/browser/generators/MLDSAData.d.ts

@@ -1,4 +1,4 @@
-import { MLDSASecurityLevel } from '@btc-vision/bip32';
+import { MLDSASecurityLevel } from '../../node_modules/@btc-vision/bip32/src/cjs/index.cjs';
 export declare enum MLDSAPublicKeyMetadata {
     MLDSA44 = 1312,
     MLDSA65 = 1952,

package/browser/generators/builders/CalldataGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';

package/browser/generators/builders/CustomGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network, Stack } from '@btc-vision/bitcoin';
+import { Network, Stack } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Generator } from '../Generator.js';
 export declare class CustomGenerator extends Generator {
     constructor(senderPubKey: Buffer, network?: Network);

package/browser/generators/builders/DeploymentGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Generator } from '../Generator.js';
 import { Feature, Features } from '../Features.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';

package/browser/generators/builders/HashCommitmentGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { IHashCommittedP2WSH } from '../../transaction/interfaces/IConsolidatedTransactionParameters.js';
 import { IP2WSHAddress } from '../../transaction/mineable/IP2WSHAddress.js';
 import { Logger } from '@btc-vision/logger';

package/browser/generators/builders/LegacyCalldataGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Generator } from '../Generator.js';
 import { Feature, Features } from '../Features.js';
 export declare class LegacyCalldataGenerator extends Generator {

package/browser/generators/builders/P2WDAGenerator.d.ts

@@ -1,4 +1,4 @@
-import { Network } from '@btc-vision/bitcoin';
+import { Network } from '../../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';