@btc-vision/bitcoin 6.4.10 → 6.5.1

package/browser/chunks/payments-BE4vwHhV.js

@@ -0,0 +1,1045 @@
+import { t as C, f as g, B as c, h as E, b as M } from "./crypto-C6FlKKmp.js";
+import { g as ne, b as P, i as x, d as b, f as se, a as G } from "./psbt-Dlosf9CT.js";
+import { b as me, g as ce, h as ae, t, s as N, j as T, i as we, T as W } from "./utils-BKmkTzNZ.js";
+import { d as a, o as v, c as l, i as S, e as ie, f as ue, g as le } from "./script-COWGdiOo.js";
+const F = 192, ye = 128, be = (e) => "left" in e && "right" in e;
+function K(e, o) {
+  if (e.length < 33)
+    throw new TypeError(
+      `The control-block length is too small. Got ${e.length}, expected min 33.`
+    );
+  const p = (e.length - 33) / 32;
+  let u = o;
+  for (let s = 0; s < p; s++) {
+    const i = e.slice(33 + 32 * s, 65 + 32 * s);
+    u.compare(i) < 0 ? u = L(u, i) : u = L(i, u);
+  }
+  return u;
+}
+function A(e) {
+  if (me(e)) return { hash: H(e) };
+  const o = [A(e[0]), A(e[1])];
+  o.sort((s, i) => s.hash.compare(i.hash));
+  const [p, u] = o;
+  return {
+    hash: L(p.hash, u.hash),
+    left: p,
+    right: u
+  };
+}
+function q(e, o) {
+  if (be(e)) {
+    const p = q(e.left, o);
+    if (p !== void 0) return [...p, e.right.hash];
+    const u = q(e.right, o);
+    if (u !== void 0) return [...u, e.left.hash];
+  } else if (e.hash.equals(o))
+    return [];
+}
+function H(e) {
+  const o = e.version || F;
+  return C(
+    "TapLeaf",
+    g.concat([g.from([o]), ge(e.output)])
+  );
+}
+function oe(e, o) {
+  return C("TapTweak", g.concat(o ? [e, o] : [e]));
+}
+function j(e, o) {
+  if (!g.isBuffer(e) || e.length !== 32 || o && o.length !== 32) return null;
+  const p = oe(e, o), u = ne().xOnlyPointAddTweak(e, p);
+  return !u || u.xOnlyPubkey === null ? null : {
+    parity: u.parity,
+    x: g.from(u.xOnlyPubkey)
+  };
+}
+function L(e, o) {
+  return C("TapBranch", g.concat([e, o]));
+}
+function ge(e) {
+  const o = ce(e.length), p = g.allocUnsafe(o);
+  return ae(e.length, p), g.concat([p, e]);
+}
+function h(e, o, p) {
+  Object.defineProperty(e, o, {
+    configurable: !0,
+    enumerable: !0,
+    get() {
+      const u = p.call(this);
+      return this[o] = u, u;
+    },
+    set(u) {
+      Object.defineProperty(this, o, {
+        configurable: !0,
+        enumerable: !0,
+        value: u,
+        writable: !0
+      });
+    }
+  });
+}
+function y(e) {
+  let o;
+  return () => (o !== void 0 || (o = e()), o);
+}
+const D = v;
+function ke(e, o) {
+  if (!e.data && !e.output) throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      network: t.maybe(t.Object),
+      output: t.maybe(t.Buffer),
+      data: t.maybe(t.arrayOf(t.Buffer))
+    },
+    e
+  );
+  const p = e.network || P, u = { name: k.Embed, network: p, data: [] };
+  if (h(u, "output", () => {
+    if (e.data)
+      return l([D.OP_RETURN].concat(e.data));
+  }), h(u, "data", () => {
+    if (!e.output) return;
+    const s = a(e.output);
+    if (s != null)
+      return s.slice(1);
+  }), o.validate && e.output) {
+    const s = a(e.output);
+    if (s[0] !== D.OP_RETURN) throw new TypeError("Output is invalid");
+    if (!s.slice(1).every(t.Buffer)) throw new TypeError("Output is invalid");
+    if (e.data && !N(e.data, u.data))
+      throw new TypeError("Data mismatch");
+  }
+  return Object.assign(u, e);
+}
+const I = v, V = I.OP_RESERVED;
+function Ee(e, o) {
+  if (!e.input && !e.output && !(e.pubkeys && e.m !== void 0) && !e.signatures)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {});
+  function p(f) {
+    return S(f) || (o.allowIncomplete && f === I.OP_0) !== void 0;
+  }
+  t(
+    {
+      network: t.maybe(t.Object),
+      m: t.maybe(t.Number),
+      n: t.maybe(t.Number),
+      output: t.maybe(t.Buffer),
+      pubkeys: t.maybe(t.arrayOf(T)),
+      signatures: t.maybe(t.arrayOf(p)),
+      input: t.maybe(t.Buffer)
+    },
+    e
+  );
+  const s = {
+    network: e.network || P,
+    name: k.P2MS
+  };
+  let i = [], n = !1;
+  function r(f) {
+    n || (n = !0, i = a(f), s.m = i[0] - V, s.n = i[i.length - 2] - V, s.pubkeys = i.slice(1, -2));
+  }
+  if (h(s, "output", () => {
+    if (e.m && s.n && e.pubkeys)
+      return l(
+        [].concat(
+          V + e.m,
+          e.pubkeys,
+          V + s.n,
+          I.OP_CHECKMULTISIG
+        )
+      );
+  }), h(s, "m", () => {
+    if (s.output)
+      return r(s.output), s.m;
+  }), h(s, "n", () => {
+    if (s.pubkeys)
+      return s.pubkeys.length;
+  }), h(s, "pubkeys", () => {
+    if (e.output)
+      return r(e.output), s.pubkeys;
+  }), h(s, "signatures", () => {
+    if (!e.input) return;
+    const f = a(e.input);
+    if (f != null)
+      return f.slice(1);
+  }), h(s, "input", () => {
+    if (e.signatures)
+      return l([I.OP_0].concat(e.signatures));
+  }), h(s, "witness", () => {
+    if (s.input)
+      return [];
+  }), h(s, "name", () => {
+    if (!(!s.m || !s.n))
+      return `p2ms(${s.m} of ${s.n})`;
+  }), o.validate) {
+    if (e.output) {
+      if (r(e.output), !t.Number(i[0])) throw new TypeError("Output is invalid");
+      if (!t.Number(i[i.length - 2])) throw new TypeError("Output is invalid");
+      if (i[i.length - 1] !== I.OP_CHECKMULTISIG)
+        throw new TypeError("Output is invalid");
+      if (s.m <= 0 || s.n > 16 || s.m > s.n || s.n !== i.length - 3)
+        throw new TypeError("Output is invalid");
+      if (!s.pubkeys.every((f) => T(f))) throw new TypeError("Output is invalid");
+      if (e.m !== void 0 && e.m !== s.m) throw new TypeError("m mismatch");
+      if (e.n !== void 0 && e.n !== s.n) throw new TypeError("n mismatch");
+      if (e.pubkeys && !N(e.pubkeys, s.pubkeys))
+        throw new TypeError("Pubkeys mismatch");
+    }
+    if (e.pubkeys) {
+      if (e.n !== void 0 && e.n !== e.pubkeys.length)
+        throw new TypeError("Pubkey count mismatch");
+      if (s.n = e.pubkeys.length, s.n < s.m) throw new TypeError("Pubkey count cannot be less than m");
+    }
+    if (e.signatures) {
+      if (e.signatures.length < s.m) throw new TypeError("Not enough signatures provided");
+      if (e.signatures.length > s.m) throw new TypeError("Too many signatures provided");
+    }
+    if (e.input) {
+      if (e.input[0] !== I.OP_0) throw new TypeError("Input is invalid");
+      if (s.signatures.length === 0 || !s.signatures.every(p))
+        throw new TypeError("Input has invalid signature(s)");
+      if (e.signatures && !N(e.signatures, s.signatures))
+        throw new TypeError("Signature mismatch");
+      if (e.m !== void 0 && e.m !== e.signatures.length)
+        throw new TypeError("Signature count mismatch");
+    }
+  }
+  return Object.assign(s, e);
+}
+const X = v;
+function Te(e, o) {
+  if (!e.input && !e.output && !e.pubkey && !e.input && !e.signature)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      network: t.maybe(t.Object),
+      output: t.maybe(t.Buffer),
+      pubkey: t.maybe(T),
+      signature: t.maybe(S),
+      input: t.maybe(t.Buffer)
+    },
+    e
+  );
+  const p = y(() => a(e.input)), u = e.network || P, s = {
+    name: k.P2PK,
+    network: u,
+    pubkey: void 0
+  };
+  if (h(s, "output", () => {
+    if (e.pubkey)
+      return l([e.pubkey, X.OP_CHECKSIG]);
+  }), h(s, "pubkey", () => {
+    if (e.output)
+      return e.output.slice(1, -1);
+  }), h(s, "signature", () => {
+    if (e.input)
+      return p()[0];
+  }), h(s, "input", () => {
+    if (e.signature)
+      return l([e.signature]);
+  }), h(s, "witness", () => {
+    if (s.input)
+      return [];
+  }), o.validate) {
+    if (e.output) {
+      if (e.output[e.output.length - 1] !== X.OP_CHECKSIG)
+        throw new TypeError("Output is invalid");
+      if (!T(s.pubkey)) throw new TypeError("Output pubkey is invalid");
+      if (e.pubkey && !e.pubkey.equals(s.pubkey)) throw new TypeError("Pubkey mismatch");
+    }
+    if (e.signature && e.input && !e.input.equals(s.input))
+      throw new TypeError("Signature mismatch");
+    if (e.input) {
+      if (p().length !== 1) throw new TypeError("Input is invalid");
+      if (!S(s.signature))
+        throw new TypeError("Input has invalid signature");
+    }
+  }
+  return Object.assign(s, e);
+}
+const B = v;
+function Pe(e, o) {
+  if (!e.address && !e.hash && !e.output && !e.redeem && !e.input)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      network: t.maybe(t.Object),
+      address: t.maybe(t.String),
+      hash: t.maybe(t.BufferN(20)),
+      output: t.maybe(t.BufferN(23)),
+      redeem: t.maybe({
+        network: t.maybe(t.Object),
+        output: t.maybe(t.Buffer),
+        input: t.maybe(t.Buffer),
+        witness: t.maybe(t.arrayOf(t.Buffer))
+      }),
+      input: t.maybe(t.Buffer),
+      witness: t.maybe(t.arrayOf(t.Buffer))
+    },
+    e
+  );
+  let p = e.network;
+  p || (p = e.redeem && e.redeem.network || P);
+  const u = {
+    network: p,
+    name: k.P2SH
+  }, s = y(() => {
+    const r = c.from(x.decode(e.address)), f = r.readUInt8(0), d = r.slice(1);
+    return { version: f, hash: d };
+  }), i = y(() => a(e.input)), n = y(() => {
+    const r = i(), f = r[r.length - 1];
+    return {
+      network: p,
+      output: f === B.OP_FALSE ? c.from([]) : f,
+      input: l(r.slice(0, -1)),
+      witness: e.witness || []
+    };
+  });
+  if (h(u, "address", () => {
+    if (!u.hash) return;
+    const r = c.allocUnsafe(21);
+    return r.writeUInt8(u.network.scriptHash, 0), u.hash.copy(r, 1), x.encode(r);
+  }), h(u, "hash", () => {
+    if (e.output) return e.output.slice(2, 22);
+    if (e.address) return s().hash;
+    if (u.redeem && u.redeem.output) return E(u.redeem.output);
+  }), h(u, "output", () => {
+    if (u.hash)
+      return l([B.OP_HASH160, u.hash, B.OP_EQUAL]);
+  }), h(u, "redeem", () => {
+    if (e.input)
+      return n();
+  }), h(u, "input", () => {
+    if (!(!e.redeem || !e.redeem.input || !e.redeem.output))
+      return l(
+        [].concat(a(e.redeem.input), e.redeem.output)
+      );
+  }), h(u, "witness", () => {
+    if (u.redeem && u.redeem.witness) return u.redeem.witness;
+    if (u.input) return [];
+  }), h(u, "name", () => {
+    const r = ["p2sh"];
+    return u.redeem !== void 0 && u.redeem.name !== void 0 && r.push(u.redeem.name), r.join("-");
+  }), o.validate) {
+    let r = c.from([]);
+    if (e.address) {
+      if (s().version !== p.scriptHash)
+        throw new TypeError("Invalid version or Network mismatch");
+      if (s().hash.length !== 20) throw new TypeError("Invalid address");
+      r = s().hash;
+    }
+    if (e.hash) {
+      if (r.length > 0 && !r.equals(e.hash)) throw new TypeError("Hash mismatch");
+      r = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 23 || e.output[0] !== B.OP_HASH160 || e.output[1] !== 20 || e.output[22] !== B.OP_EQUAL)
+        throw new TypeError("Output is invalid");
+      const d = e.output.slice(2, 22);
+      if (r.length > 0 && !r.equals(d)) throw new TypeError("Hash mismatch");
+      r = d;
+    }
+    const f = (d) => {
+      if (d.output) {
+        const m = a(d.output);
+        if (!m || m.length < 1)
+          throw new TypeError("Redeem.output too short");
+        if (d.output.byteLength > 520)
+          throw new TypeError("Redeem.output unspendable if larger than 520 bytes");
+        if (ie(m) > 201)
+          throw new TypeError(
+            "Redeem.output unspendable with more than 201 non-push ops"
+          );
+        const w = E(d.output);
+        if (r.length > 0 && !r.equals(w)) throw new TypeError("Hash mismatch");
+        r = w;
+      }
+      if (d.input) {
+        const m = d.input.length > 0, w = d.witness && d.witness.length > 0;
+        if (!m && !w) throw new TypeError("Empty input");
+        if (m && w) throw new TypeError("Input and witness provided");
+        if (m) {
+          const _ = a(d.input);
+          if (!ue(_))
+            throw new TypeError("Non push-only scriptSig");
+        }
+      }
+    };
+    if (e.input) {
+      const d = i();
+      if (!d || d.length < 1) throw new TypeError("Input too short");
+      if (!c.isBuffer(n().output)) throw new TypeError("Input is invalid");
+      f(n());
+    }
+    if (e.redeem) {
+      if (e.redeem.network && e.redeem.network !== p)
+        throw new TypeError("Network mismatch");
+      if (e.input) {
+        const d = n();
+        if (e.redeem.output && !e.redeem.output.equals(d.output))
+          throw new TypeError("Redeem.output mismatch");
+        if (e.redeem.input && !e.redeem.input.equals(d.input))
+          throw new TypeError("Redeem.input mismatch");
+      }
+      f(e.redeem);
+    }
+    if (e.witness && e.redeem && e.redeem.witness && !N(e.redeem.witness, e.witness))
+      throw new TypeError("Witness and redeem.witness mismatch");
+  }
+  return Object.assign(u, e);
+}
+const Q = v, Y = 1, ve = 80;
+function Oe(e, o) {
+  if (!e.address && !e.output && !e.pubkey && !e.internalPubkey && !(e.witness && e.witness.length > 1))
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      address: t.maybe(t.String),
+      input: t.maybe(t.BufferN(0)),
+      network: t.maybe(t.Object),
+      output: t.maybe(t.BufferN(34)),
+      internalPubkey: t.maybe(t.BufferN(32)),
+      hash: t.maybe(t.BufferN(32)),
+      // merkle root hash, the tweak
+      pubkey: t.maybe(t.BufferN(32)),
+      // tweaked with `hash` from `internalPubkey`
+      signature: t.maybe(t.anyOf(t.BufferN(64), t.BufferN(65))),
+      witness: t.maybe(t.arrayOf(t.Buffer)),
+      scriptTree: t.maybe(we),
+      redeem: t.maybe({
+        output: t.maybe(t.Buffer),
+        // tapleaf script
+        redeemVersion: t.maybe(t.Number),
+        // tapleaf version
+        witness: t.maybe(t.arrayOf(t.Buffer))
+      }),
+      redeemVersion: t.maybe(t.Number)
+    },
+    e
+  );
+  const p = y(() => se(e.address)), u = y(() => {
+    if (!(!e.witness || !e.witness.length))
+      return e.witness.length >= 2 && e.witness[e.witness.length - 1][0] === ve ? e.witness.slice(0, -1) : e.witness.slice();
+  }), s = y(() => {
+    if (e.scriptTree) return A(e.scriptTree);
+    if (e.hash) return { hash: e.hash };
+  }), i = e.network || P, n = {
+    name: k.P2TR,
+    network: i
+  };
+  if (h(n, "address", () => {
+    if (!n.pubkey) return;
+    const r = b.bech32m.toWords(n.pubkey);
+    return r.unshift(Y), b.bech32m.encode(i.bech32, r);
+  }), h(n, "hash", () => {
+    const r = s();
+    if (r) return r.hash;
+    const f = u();
+    if (f && f.length > 1) {
+      const d = f[f.length - 1], m = d[0] & W, w = f[f.length - 2], _ = H({
+        output: w,
+        version: m
+      });
+      return K(d, _);
+    }
+  }), h(n, "output", () => {
+    if (n.pubkey)
+      return l([Q.OP_1, n.pubkey]);
+  }), h(n, "redeemVersion", () => e.redeemVersion ? e.redeemVersion : e.redeem && e.redeem.redeemVersion !== void 0 && e.redeem.redeemVersion !== null ? e.redeem.redeemVersion : F), h(n, "redeem", () => {
+    const r = u();
+    if (!(!r || r.length < 2))
+      return {
+        output: r[r.length - 2],
+        witness: r.slice(0, -2),
+        redeemVersion: r[r.length - 1][0] & W
+      };
+  }), h(n, "pubkey", () => {
+    if (e.pubkey) return e.pubkey;
+    if (e.output) return e.output.slice(2);
+    if (e.address) return p().data;
+    if (n.internalPubkey) {
+      const r = j(n.internalPubkey, n.hash);
+      if (r) return r.x;
+    }
+  }), h(n, "internalPubkey", () => {
+    if (e.internalPubkey) return e.internalPubkey;
+    const r = u();
+    if (r && r.length > 1) return r[r.length - 1].slice(1, 33);
+  }), h(n, "signature", () => {
+    if (e.signature) return e.signature;
+    const r = u();
+    if (!(!r || r.length !== 1))
+      return r[0];
+  }), h(n, "witness", () => {
+    if (e.witness) return e.witness;
+    const r = s();
+    if (r && e.redeem && e.redeem.output && e.internalPubkey) {
+      const f = H({
+        output: e.redeem.output,
+        version: n.redeemVersion
+      }), d = q(r, f);
+      if (!d) return;
+      const m = j(e.internalPubkey, r.hash);
+      if (!m) return;
+      const w = g.concat(
+        [g.from([n.redeemVersion | m.parity]), e.internalPubkey].concat(
+          d
+        )
+      );
+      return [e.redeem.output, w];
+    }
+    if (e.signature) return [e.signature];
+  }), o.validate) {
+    let r = g.from([]);
+    if (e.address) {
+      if (i && i.bech32 !== p().prefix)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (p().version !== Y)
+        throw new TypeError("Invalid address version");
+      if (p().data.length !== 32) throw new TypeError("Invalid address data");
+      r = p().data;
+    }
+    if (e.pubkey) {
+      if (r.length > 0 && !r.equals(e.pubkey))
+        throw new TypeError("Pubkey mismatch");
+      r = e.pubkey;
+    }
+    if (e.output) {
+      if (e.output.length !== 34 || e.output[0] !== Q.OP_1 || e.output[1] !== 32)
+        throw new TypeError("Output is invalid");
+      if (r.length > 0 && !r.equals(e.output.slice(2)))
+        throw new TypeError("Pubkey mismatch");
+      r = e.output.slice(2);
+    }
+    if (e.internalPubkey) {
+      const m = j(e.internalPubkey, n.hash);
+      if (r.length > 0 && !r.equals(m.x))
+        throw new TypeError("Pubkey mismatch");
+      r = m.x;
+    }
+    const f = s();
+    if (e.hash && f && !e.hash.equals(f.hash))
+      throw new TypeError("Hash mismatch");
+    if (e.redeem && e.redeem.output && f) {
+      const m = H({
+        output: e.redeem.output,
+        version: n.redeemVersion
+      });
+      if (!q(f, m))
+        throw new TypeError("Redeem script not in tree");
+    }
+    const d = u();
+    if (e.redeem && n.redeem) {
+      if (e.redeem.redeemVersion && e.redeem.redeemVersion !== n.redeem.redeemVersion)
+        throw new TypeError("Redeem.redeemVersion and witness mismatch");
+      if (e.redeem.output) {
+        if (a(e.redeem.output).length === 0)
+          throw new TypeError("Redeem.output is invalid");
+        if (n.redeem.output && !e.redeem.output.equals(n.redeem.output))
+          throw new TypeError("Redeem.output and witness mismatch");
+      }
+      if (e.redeem.witness && n.redeem.witness && !N(e.redeem.witness, n.redeem.witness))
+        throw new TypeError("Redeem.witness and witness mismatch");
+    }
+    if (d && d.length)
+      if (d.length === 1) {
+        if (e.signature && !e.signature.equals(d[0]))
+          throw new TypeError("Signature mismatch");
+      } else {
+        const m = d[d.length - 1];
+        if (m.length < 33)
+          throw new TypeError(
+            `The control-block length is too small. Got ${m.length}, expected min 33.`
+          );
+        if ((m.length - 33) % 32 !== 0)
+          throw new TypeError(
+            `The control-block length of ${m.length} is incorrect!`
+          );
+        const w = (m.length - 33) / 32;
+        if (w > 128)
+          throw new TypeError(`The script path is too long. Got ${w}, expected max 128.`);
+        const _ = m.slice(1, 33);
+        if (e.internalPubkey && !e.internalPubkey.equals(_))
+          throw new TypeError("Internal pubkey mismatch");
+        if (!ne().isXOnlyPoint(_))
+          throw new TypeError("Invalid internalPubkey for p2tr witness");
+        const he = m[0] & W, pe = d[d.length - 2], fe = H({
+          output: pe,
+          version: he
+        }), de = K(m, fe), U = j(_, de);
+        if (!U)
+          throw new TypeError("Invalid outputKey for p2tr witness");
+        if (r.length && !r.equals(U.x))
+          throw new TypeError("Pubkey mismatch for p2tr witness");
+        if (U.parity !== (m[0] & 1)) throw new Error("Incorrect parity");
+      }
+  }
+  return Object.assign(n, e);
+}
+const z = v, _e = c.alloc(0);
+function Se(e, o) {
+  if (!e.address && !e.hash && !e.output && !e.pubkey && !e.witness)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      address: t.maybe(t.String),
+      hash: t.maybe(t.BufferN(20)),
+      input: t.maybe(t.BufferN(0)),
+      network: t.maybe(t.Object),
+      output: t.maybe(t.BufferN(22)),
+      pubkey: t.maybe(T),
+      signature: t.maybe(S),
+      witness: t.maybe(t.arrayOf(t.Buffer))
+    },
+    e
+  );
+  const p = y(() => {
+    const i = b.bech32.decode(e.address), n = i.words.shift(), r = b.bech32.fromWords(i.words);
+    return {
+      version: n,
+      prefix: i.prefix,
+      data: c.from(r)
+    };
+  }), u = e.network || P, s = {
+    name: k.P2WPKH,
+    network: u
+  };
+  if (h(s, "address", () => {
+    if (!s.hash) return;
+    const i = b.bech32.toWords(s.hash);
+    return i.unshift(0), b.bech32.encode(u.bech32, i);
+  }), h(s, "hash", () => {
+    if (e.output) return e.output.slice(2, 22);
+    if (e.address) return p().data;
+    if (e.pubkey || s.pubkey) return E(e.pubkey || s.pubkey);
+  }), h(s, "output", () => {
+    if (s.hash)
+      return l([z.OP_0, s.hash]);
+  }), h(s, "pubkey", () => {
+    if (e.pubkey) return e.pubkey;
+    if (e.witness)
+      return e.witness[1];
+  }), h(s, "signature", () => {
+    if (e.witness)
+      return e.witness[0];
+  }), h(s, "input", () => {
+    if (s.witness)
+      return _e;
+  }), h(s, "witness", () => {
+    if (e.pubkey && e.signature)
+      return [e.signature, e.pubkey];
+  }), o.validate) {
+    let i = c.from([]);
+    if (e.address) {
+      if (u && u.bech32 !== p().prefix)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (p().version !== 0) throw new TypeError("Invalid address version");
+      if (p().data.length !== 20) throw new TypeError("Invalid address data");
+      i = p().data;
+    }
+    if (e.hash) {
+      if (i.length > 0 && !i.equals(e.hash)) throw new TypeError("Hash mismatch");
+      i = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 22 || e.output[0] !== z.OP_0 || e.output[1] !== 20)
+        throw new TypeError("Output is invalid");
+      if (i.length > 0 && !i.equals(e.output.slice(2)))
+        throw new TypeError("Hash mismatch");
+      i = e.output.slice(2);
+    }
+    if (e.pubkey) {
+      const n = E(e.pubkey);
+      if (i.length > 0 && !i.equals(n)) throw new TypeError("Hash mismatch");
+      if (i = n, !T(e.pubkey) || e.pubkey.length !== 33)
+        throw new TypeError("Invalid pubkey for p2wpkh");
+    }
+    if (e.witness) {
+      if (e.witness.length !== 2) throw new TypeError("Witness is invalid");
+      if (!S(e.witness[0]))
+        throw new TypeError("Witness has invalid signature");
+      if (!T(e.witness[1]) || e.witness[1].length !== 33)
+        throw new TypeError("Witness has invalid pubkey");
+      if (e.signature && !e.signature.equals(e.witness[0]))
+        throw new TypeError("Signature mismatch");
+      if (e.pubkey && !e.pubkey.equals(e.witness[1])) throw new TypeError("Pubkey mismatch");
+      const n = E(e.witness[1]);
+      if (i.length > 0 && !i.equals(n)) throw new TypeError("Hash mismatch");
+    }
+  }
+  return Object.assign(s, e);
+}
+const Z = v, $ = c.alloc(0);
+function R(e) {
+  return !!(c.isBuffer(e) && e.length === 65 && e[0] === 4 && T(e));
+}
+function Ie(e, o) {
+  if (!e.address && !e.hash && !e.output && !e.redeem && !e.witness)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      network: t.maybe(t.Object),
+      address: t.maybe(t.String),
+      hash: t.maybe(t.BufferN(32)),
+      output: t.maybe(t.BufferN(34)),
+      redeem: t.maybe({
+        input: t.maybe(t.Buffer),
+        network: t.maybe(t.Object),
+        output: t.maybe(t.Buffer),
+        witness: t.maybe(t.arrayOf(t.Buffer))
+      }),
+      input: t.maybe(t.BufferN(0)),
+      witness: t.maybe(t.arrayOf(t.Buffer))
+    },
+    e
+  );
+  const p = y(() => {
+    const n = b.bech32.decode(e.address), r = n.words.shift(), f = b.bech32.fromWords(n.words);
+    return {
+      version: r,
+      prefix: n.prefix,
+      data: c.from(f)
+    };
+  }), u = y(() => a(e.redeem.input));
+  let s = e.network;
+  s || (s = e.redeem && e.redeem.network || P);
+  const i = {
+    network: s,
+    name: k.P2WSH
+  };
+  if (h(i, "address", () => {
+    if (!i.hash) return;
+    const n = b.bech32.toWords(i.hash);
+    return n.unshift(0), b.bech32.encode(s.bech32, n);
+  }), h(i, "hash", () => {
+    if (e.output) return e.output.slice(2);
+    if (e.address) return p().data;
+    if (i.redeem && i.redeem.output) return M(i.redeem.output);
+  }), h(i, "output", () => {
+    if (i.hash)
+      return l([Z.OP_0, i.hash]);
+  }), h(i, "redeem", () => {
+    if (e.witness)
+      return {
+        output: e.witness[e.witness.length - 1],
+        input: $,
+        witness: e.witness.slice(0, -1)
+      };
+  }), h(i, "input", () => {
+    if (i.witness)
+      return $;
+  }), h(i, "witness", () => {
+    if (e.redeem && e.redeem.input && e.redeem.input.length > 0 && e.redeem.output && e.redeem.output.length > 0) {
+      const n = le(u());
+      return i.redeem = Object.assign({ witness: n }, e.redeem), i.redeem.input = $, [].concat(n, e.redeem.output);
+    }
+    if (e.redeem && e.redeem.output && e.redeem.witness)
+      return [].concat(e.redeem.witness, e.redeem.output);
+  }), h(i, "name", () => {
+    const n = ["p2wsh"];
+    return i.redeem !== void 0 && i.redeem.name !== void 0 && n.push(i.redeem.name), n.join("-");
+  }), o.validate) {
+    let n = c.from([]);
+    if (e.address) {
+      if (p().prefix !== s.bech32)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (p().version !== 0) throw new TypeError("Invalid address version");
+      if (p().data.length !== 32) throw new TypeError("Invalid address data");
+      n = p().data;
+    }
+    if (e.hash) {
+      if (n.length > 0 && !n.equals(e.hash)) throw new TypeError("Hash mismatch");
+      n = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 34 || e.output[0] !== Z.OP_0 || e.output[1] !== 32)
+        throw new TypeError("Output is invalid");
+      const r = e.output.slice(2);
+      if (n.length > 0 && !n.equals(r)) throw new TypeError("Hash mismatch");
+      n = r;
+    }
+    if (e.redeem) {
+      if (e.redeem.network && e.redeem.network !== s)
+        throw new TypeError("Network mismatch");
+      if (e.redeem.input && e.redeem.input.length > 0 && e.redeem.witness && e.redeem.witness.length > 0)
+        throw new TypeError("Ambiguous witness source");
+      if (e.redeem.output) {
+        const r = a(e.redeem.output);
+        if (!r || r.length < 1)
+          throw new TypeError("Redeem.output is invalid");
+        if (e.redeem.output.byteLength > 3600)
+          throw new TypeError("Redeem.output unspendable if larger than 3600 bytes");
+        if (ie(r) > 201)
+          throw new TypeError(
+            "Redeem.output unspendable with more than 201 non-push ops"
+          );
+        const f = M(e.redeem.output);
+        if (n.length > 0 && !n.equals(f)) throw new TypeError("Hash mismatch");
+        n = f;
+      }
+      if (e.redeem.input && !ue(u()))
+        throw new TypeError("Non push-only scriptSig");
+      if (e.witness && e.redeem.witness && !N(e.witness, e.redeem.witness))
+        throw new TypeError("Witness and redeem.witness mismatch");
+      if (e.redeem.input && u().some(R) || e.redeem.output && (a(e.redeem.output) || []).some(R))
+        throw new TypeError("redeem.input or redeem.output contains uncompressed pubkey");
+    }
+    if (e.witness && e.witness.length > 0) {
+      const r = e.witness[e.witness.length - 1];
+      if (e.redeem && e.redeem.output && !e.redeem.output.equals(r))
+        throw new TypeError("Witness and redeem.output mismatch");
+      if (e.witness.some(R) || (a(r) || []).some(R))
+        throw new TypeError("Witness contains uncompressed pubkey");
+    }
+  }
+  return Object.assign(i, e);
+}
+const J = v, ee = 16, te = 2, re = 40;
+function He(e, o) {
+  if (!e.address && !e.output && !e.program && (typeof e.deploymentVersion > "u" || !e.hash160))
+    throw new TypeError("At least one of address, output or program must be provided");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      address: t.maybe(t.String),
+      output: t.maybe(t.Buffer),
+      program: t.maybe(t.Buffer),
+      network: t.maybe(t.Object),
+      deploymentVersion: t.maybe(t.Number),
+      hash160: t.maybe(t.BufferN(20))
+    },
+    e
+  );
+  const p = () => {
+    if (typeof e.deploymentVersion < "u" && typeof e.hash160 < "u") {
+      if (e.hash160.length !== 20) throw new TypeError("hash160 must be exactly 20 bytes");
+      if (e.deploymentVersion < 0 || e.deploymentVersion > 255)
+        throw new TypeError("deploymentVersion must fit in one byte");
+      return c.concat([c.of(e.deploymentVersion), e.hash160]);
+    }
+  }, u = y(() => se(e.address)), s = e.network || P, i = {
+    name: k.P2OP,
+    network: s,
+    deploymentVersion: 0
+  };
+  if (h(i, "program", () => {
+    if (e.program) return e.program;
+    const n = p();
+    if (n) return n;
+    if (e.output) {
+      if (e.output[0] !== J.OP_16) throw new TypeError("Invalid P2OP script");
+      let r = 1, f;
+      if (e.output[1] < 76)
+        f = e.output[1], r = 2;
+      else if (e.output[1] === 76)
+        f = e.output[2], r = 3;
+      else
+        throw new TypeError("Unsupported push opcode in P2OP script");
+      return e.output.slice(r, r + f);
+    }
+    if (e.address)
+      return u().data;
+  }), h(i, "deploymentVersion", () => {
+    if (i.program)
+      return i.program[0];
+  }), h(i, "hash160", () => {
+    if (i.program)
+      return i.program.slice(1);
+  }), h(i, "output", () => {
+    if (i.program)
+      return l([J.OP_16, i.program]);
+  }), h(i, "address", () => {
+    if (!i.program) return;
+    if (!s.bech32Opnet)
+      throw new TypeError("Network does not support opnet");
+    const n = b.bech32m.toWords(i.program);
+    return n.unshift(ee), b.bech32m.encode(s.bech32Opnet, n);
+  }), o.validate) {
+    let n = g.alloc(0);
+    if (e.address) {
+      const r = u();
+      if (s.bech32Opnet !== r.prefix)
+        throw new TypeError("Invalid prefix or network mismatch");
+      if (r.version !== ee)
+        throw new TypeError("Invalid witness version for p2op");
+      if (r.data.length < te || r.data.length > re)
+        throw new TypeError("Invalid witness program length");
+      n = r.data;
+    }
+    if (e.program) {
+      if (n.length && !n.equals(e.program)) throw new TypeError("Program mismatch");
+      n = e.program;
+    }
+    if (!n.length && e.deploymentVersion !== void 0 && e.hash160 && (n = p()), e.output) {
+      const r = i.program;
+      if (n.length && !n.equals(r))
+        throw new TypeError("Program mismatch (output vs other source)");
+      n = r;
+    }
+    if (n.length < te || n.length > re)
+      throw new TypeError(`Witness program must be 2–40 bytes. Was ${n.length} bytes`);
+    if (e.deploymentVersion !== void 0 && e.deploymentVersion !== n[0])
+      throw new TypeError("deploymentVersion mismatch");
+    if (e.hash160 && !e.hash160.equals(n.slice(1))) throw new TypeError("hash160 mismatch");
+  }
+  return Object.assign(i, e);
+}
+const O = v;
+function Ne(e, o) {
+  if (!e.address && !e.hash && !e.output && !e.pubkey && !e.input)
+    throw new TypeError("Not enough data");
+  o = Object.assign({ validate: !0 }, o || {}), t(
+    {
+      network: t.maybe(t.Object),
+      address: t.maybe(t.String),
+      hash: t.maybe(t.BufferN(20)),
+      output: t.maybe(t.BufferN(25)),
+      pubkey: t.maybe(T),
+      signature: t.maybe(S),
+      input: t.maybe(t.Buffer)
+    },
+    e
+  );
+  const p = y(() => {
+    const n = c.from(x.decode(e.address)), r = n.readUInt8(0), f = n.slice(1);
+    return { version: r, hash: f };
+  }), u = y(() => a(e.input)), s = e.network || P, i = {
+    name: k.P2PKH,
+    network: s,
+    hash: void 0
+  };
+  if (h(i, "address", () => {
+    if (!i.hash) return;
+    const n = c.allocUnsafe(21);
+    return n.writeUInt8(s.pubKeyHash, 0), i.hash.copy(n, 1), x.encode(n);
+  }), h(i, "hash", () => {
+    if (e.output) return e.output.slice(3, 23);
+    if (e.address) return p().hash;
+    if (e.pubkey || i.pubkey) return E(e.pubkey || i.pubkey);
+  }), h(i, "output", () => {
+    if (i.hash)
+      return l([
+        O.OP_DUP,
+        O.OP_HASH160,
+        i.hash,
+        O.OP_EQUALVERIFY,
+        O.OP_CHECKSIG
+      ]);
+  }), h(i, "pubkey", () => {
+    if (e.input)
+      return u()[1];
+  }), h(i, "signature", () => {
+    if (e.input)
+      return u()[0];
+  }), h(i, "input", () => {
+    if (!e.pubkey || !e.signature) return;
+    let n = e.pubkey;
+    if (e.useHybrid || e.useUncompressed) {
+      const r = G(e.pubkey);
+      r && (e.useUncompressed ? n = r.uncompressed : n = r.hybrid);
+    }
+    return l([e.signature, n]);
+  }), h(i, "witness", () => {
+    if (i.input)
+      return [];
+  }), o.validate) {
+    let n = c.from([]);
+    if (e.address) {
+      if (p().version !== s.pubKeyHash)
+        throw new TypeError("Invalid version or Network mismatch");
+      if (p().hash.length !== 20)
+        throw new TypeError("Invalid address");
+      n = p().hash;
+    }
+    if (e.hash) {
+      if (n.length > 0 && !n.equals(e.hash))
+        throw new TypeError("Hash mismatch");
+      n = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 25 || e.output[0] !== O.OP_DUP || e.output[1] !== O.OP_HASH160 || e.output[2] !== 20 || e.output[23] !== O.OP_EQUALVERIFY || e.output[24] !== O.OP_CHECKSIG)
+        throw new TypeError("Output is invalid");
+      const r = e.output.slice(3, 23);
+      if (n.length > 0 && !n.equals(r)) throw new TypeError("Hash mismatch");
+      n = r;
+    }
+    if (e.pubkey) {
+      const r = E(e.pubkey);
+      let f = n.length > 0 && !n.equals(r);
+      if (f && (e.pubkey.length === 33 && (e.pubkey[0] === 2 || e.pubkey[0] === 3) || e.pubkey.length === 65 && e.pubkey[0] === 4)) {
+        const d = G(e.pubkey);
+        if (d) {
+          const m = E(d.uncompressed);
+          if (n.equals(m))
+            f = !1, e.useUncompressed = !0;
+          else {
+            const w = E(d.hybrid);
+            f = !n.equals(w), f || (e.useHybrid = !0);
+          }
+        }
+      }
+      if (f)
+        throw new TypeError("Hash mismatch");
+      n = r;
+    }
+    if (e.input) {
+      const r = u();
+      if (r.length !== 2) throw new TypeError("Input is invalid");
+      if (!S(r[0]))
+        throw new TypeError("Input has invalid signature");
+      if (!T(r[1])) throw new TypeError("Input has invalid pubkey");
+      if (e.signature && !e.signature.equals(r[0]))
+        throw new TypeError("Signature mismatch");
+      if (e.pubkey && !e.pubkey.equals(r[1]))
+        throw new TypeError("Pubkey mismatch");
+      const f = E(r[1]);
+      if (n.length > 0 && !n.equals(f)) throw new TypeError("Hash mismatch (input)");
+    }
+  }
+  return Object.assign(i, e);
+}
+var k = /* @__PURE__ */ ((e) => (e.P2PK = "p2pk", e.P2PKH = "p2pkh", e.P2SH = "p2sh", e.P2MS = "p2ms", e.P2WPKH = "p2wpkh", e.P2WSH = "p2wsh", e.P2TR = "p2tr", e.P2OP = "p2op", e.Embed = "embed", e.ScriptRedeem = "scriptRedeem", e))(k || {});
+const Re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LEAF_VERSION_TAPSCRIPT: F,
+  MAX_TAPTREE_DEPTH: ye,
+  PaymentType: k,
+  findScriptPath: q,
+  p2data: ke,
+  p2ms: Ee,
+  p2op: He,
+  p2pk: Te,
+  p2pkh: Ne,
+  p2sh: Pe,
+  p2tr: Oe,
+  p2wpkh: Se,
+  p2wsh: Ie,
+  prop: h,
+  rootHashFromPath: K,
+  tapTweakHash: oe,
+  tapleafHash: H,
+  toHashTree: A,
+  tweakKey: j,
+  value: y
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  F as L,
+  ye as M,
+  k as P,
+  Pe as a,
+  Se as b,
+  Ie as c,
+  Oe as d,
+  He as e,
+  H as f,
+  Te as g,
+  Ee as h,
+  Re as i,
+  A as j,
+  q as k,
+  oe as l,
+  Ne as p,
+  K as r,
+  j as t
+};