@btc-vision/bitcoin 6.5.3 → 6.5.5

package/browser/chunks/{payments-CgasufRS.js → payments-yjA0Evsv.js}

@@ -1,72 +1,14 @@
-import { t as F, e as g, B as m, h as E, a as G } from "./crypto-0PweVewC.js";
-import { g as K, b as P, i as x, d as b, f as se, a as X } from "./psbt-BIwOrKer.js";
-import { b as ae, g as me, h as we, t as r, s as N, j as T, i as ce, T as W } from "./utils-CO5kmxe9.js";
-import { d as w, o as v, c as y, i as S, e as ue, f as ie, g as ye } from "./script-CROJPzz_.js";
-const M = 192, le = 128, be = (e) => "left" in e && "right" in e;
-function L(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 i = o;
-  for (let s = 0; s < p; s++) {
-    const u = e.subarray(33 + 32 * s, 65 + 32 * s);
-    i.compare(u) < 0 ? i = C(i, u) : i = C(u, i);
-  }
-  return i;
-}
-function A(e) {
-  if (ae(e)) return { hash: H(e) };
-  const o = [A(e[0]), A(e[1])];
-  o.sort((s, u) => s.hash.compare(u.hash));
-  const [p, i] = o;
-  return {
-    hash: C(p.hash, i.hash),
-    left: p,
-    right: i
-  };
-}
-function q(e, o) {
-  if (be(e)) {
-    const p = q(e.left, o);
-    if (p !== void 0) return [...p, e.right.hash];
-    const i = q(e.right, o);
-    if (i !== void 0) return [...i, e.left.hash];
-  } else if (e.hash.equals(o))
-    return [];
-}
-function H(e) {
-  const o = e.version || M;
-  return F(
-    "TapLeaf",
-    g.concat([g.from([o]), ge(e.output)])
-  );
-}
-function oe(e, o) {
-  return F("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), i = K().xOnlyPointAddTweak(e, p);
-  return !i || i.xOnlyPubkey === null ? null : {
-    parity: i.parity,
-    x: g.from(i.xOnlyPubkey)
-  };
-}
-function C(e, o) {
-  return F("TapBranch", g.concat([e, o]));
-}
-function ge(e) {
-  const o = me(e.length), p = g.allocUnsafe(o);
-  return we(e.length, p), g.concat([p, e]);
-}
-function h(e, o, p) {
+import { b as v, d as g, f as ie, i as L, a as D } from "./psbt-URK2hBFc.js";
+import { o as _, c as l, i as H, d as m, b as oe, e as fe, f as me } from "./script-DyPItFEl.js";
+import { t as r, d as P, s as j, b as we, e as le, f as ye, i as be, T as $ } from "./utils-DNZi-T5W.js";
+import { a as k, B as c, h as T, t as X, s as Y } from "./crypto-BhCpKpek.js";
+var E = /* @__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))(E || {});
+function p(e, o, f) {
   Object.defineProperty(e, o, {
     configurable: !0,
     enumerable: !0,
     get() {
-      const i = p.call(this);
+      const i = f.call(this);
       return this[o] = i, i;
     },
     set(i) {
@@ -79,187 +21,216 @@ function h(e, o, p) {
     }
   });
 }
-function l(e) {
+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");
+const Q = _, z = 16, Z = 2, J = 40;
+function ge(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 || {}), r(
     {
-      network: r.maybe(r.Object),
+      address: r.maybe(r.String),
       output: r.maybe(r.Buffer),
-      data: r.maybe(r.arrayOf(r.Buffer))
-    },
-    e
-  );
-  const p = e.network || P, i = { name: k.Embed, network: p, data: [] };
-  if (h(i, "output", () => {
-    if (e.data)
-      return y([D.OP_RETURN].concat(e.data));
-  }), h(i, "data", () => {
-    if (!e.output) return;
-    const s = w(e.output);
-    if (s != null)
-      return s.slice(1);
-  }), o.validate && e.output) {
-    const s = w(e.output);
-    if (s[0] !== D.OP_RETURN) throw new TypeError("Output is invalid");
-    if (!s.slice(1).every(r.Buffer)) throw new TypeError("Output is invalid");
-    if (e.data && !N(e.data, i.data)) throw new TypeError("Data mismatch");
-  }
-  return Object.assign(i, 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;
-  }
-  r(
-    {
+      program: r.maybe(r.Buffer),
       network: r.maybe(r.Object),
-      m: r.maybe(r.Number),
-      n: r.maybe(r.Number),
-      output: r.maybe(r.Buffer),
-      pubkeys: r.maybe(r.arrayOf(T)),
-      signatures: r.maybe(r.arrayOf(p)),
-      input: r.maybe(r.Buffer)
+      deploymentVersion: r.maybe(r.Number),
+      hash160: r.maybe(r.BufferN(20))
     },
     e
   );
-  const s = {
-    network: e.network || P,
-    name: k.P2MS
+  const f = () => {
+    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]);
+    }
+  }, i = y(() => ie(e.address)), s = e.network || v, u = {
+    name: E.P2OP,
+    network: s,
+    deploymentVersion: 0
   };
-  let u = [], n = !1;
-  function t(f) {
-    n || (n = !0, u = w(f), s.m = u[0] - V, s.n = u[u.length - 2] - V, s.pubkeys = u.slice(1, -2));
-  }
-  if (h(s, "output", () => {
-    if (e.m && s.n && e.pubkeys)
-      return y(
-        [].concat(
-          V + e.m,
-          e.pubkeys,
-          V + s.n,
-          I.OP_CHECKMULTISIG
-        )
-      );
-  }), h(s, "m", () => {
-    if (s.output)
-      return t(s.output), s.m;
-  }), h(s, "n", () => {
-    if (s.pubkeys)
-      return s.pubkeys.length;
-  }), h(s, "pubkeys", () => {
-    if (e.output)
-      return t(e.output), s.pubkeys;
-  }), h(s, "signatures", () => {
-    if (!e.input) return;
-    const f = w(e.input);
-    if (f != null)
-      return f.slice(1);
-  }), h(s, "input", () => {
-    if (e.signatures)
-      return y([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 (p(u, "program", () => {
+    if (e.program) return e.program;
+    const n = f();
+    if (n) return n;
     if (e.output) {
-      if (t(e.output), !r.Number(u[0])) throw new TypeError("Output is invalid");
-      if (!r.Number(u[u.length - 2])) throw new TypeError("Output is invalid");
-      if (u[u.length - 1] !== I.OP_CHECKMULTISIG)
-        throw new TypeError("Output is invalid");
-      if (s.m <= 0 || s.n > 16 || s.m > s.n || s.n !== u.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.output[0] !== Q.OP_16) throw new TypeError("Invalid P2OP script");
+      let t = 1, h;
+      if (e.output[1] < 76)
+        h = e.output[1], t = 2;
+      else if (e.output[1] === 76)
+        h = e.output[2], t = 3;
+      else
+        throw new TypeError("Unsupported push opcode in P2OP script");
+      return e.output.subarray(t, t + h);
     }
-    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.address)
+      return i().data;
+  }), p(u, "deploymentVersion", () => {
+    if (u.program)
+      return u.program[0];
+  }), p(u, "hash160", () => {
+    if (u.program)
+      return u.program.subarray(1);
+  }), p(u, "output", () => {
+    if (u.program)
+      return l([Q.OP_16, u.program]);
+  }), p(u, "address", () => {
+    if (!u.program) return;
+    if (!s.bech32Opnet)
+      throw new TypeError("Network does not support opnet");
+    const n = g.bech32m.toWords(u.program);
+    return n.unshift(z), g.bech32m.encode(s.bech32Opnet, n);
+  }), o.validate) {
+    let n = k.alloc(0);
+    if (e.address) {
+      const t = i();
+      if (s.bech32Opnet !== t.prefix)
+        throw new TypeError("Invalid prefix or network mismatch");
+      if (t.version !== z)
+        throw new TypeError("Invalid witness version for p2op");
+      if (t.data.length < Z || t.data.length > J)
+        throw new TypeError("Invalid witness program length");
+      n = t.data;
     }
-    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.program) {
+      if (n.length && !n.equals(e.program)) throw new TypeError("Program mismatch");
+      n = e.program;
     }
-    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");
+    if (!n.length && e.deploymentVersion !== void 0 && e.hash160 && (n = f()), e.output) {
+      const t = u.program;
+      if (n.length && !n.equals(t))
+        throw new TypeError("Program mismatch (output vs other source)");
+      n = t;
     }
+    if (n.length < Z || n.length > J)
+      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.subarray(1)))
+      throw new TypeError("hash160 mismatch");
   }
-  return Object.assign(s, e);
+  return Object.assign(u, e);
 }
-const Q = v;
-function Te(e, o) {
-  if (!e.input && !e.output && !e.pubkey && !e.input && !e.signature)
+const S = _;
+function ke(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 || {}), r(
     {
       network: r.maybe(r.Object),
-      output: r.maybe(r.Buffer),
-      pubkey: r.maybe(T),
-      signature: r.maybe(S),
+      address: r.maybe(r.String),
+      hash: r.maybe(r.BufferN(20)),
+      output: r.maybe(r.BufferN(25)),
+      pubkey: r.maybe(P),
+      signature: r.maybe(H),
       input: r.maybe(r.Buffer)
     },
     e
   );
-  const p = l(() => w(e.input)), i = e.network || P, s = {
-    name: k.P2PK,
-    network: i,
-    pubkey: void 0
+  const f = y(() => {
+    const n = c.from(L.decode(e.address)), t = n.readUInt8(0), h = n.subarray(1);
+    return { version: t, hash: h };
+  }), i = y(() => m(e.input)), s = e.network || v, u = {
+    name: E.P2PKH,
+    network: s,
+    hash: void 0
   };
-  if (h(s, "output", () => {
-    if (e.pubkey)
-      return y([e.pubkey, Q.OP_CHECKSIG]);
-  }), h(s, "pubkey", () => {
-    if (e.output)
-      return e.output.subarray(1, -1);
-  }), h(s, "signature", () => {
+  if (p(u, "address", () => {
+    if (!u.hash) return;
+    const n = c.allocUnsafe(21);
+    return n.writeUInt8(s.pubKeyHash, 0), u.hash.copy(n, 1), L.encode(n);
+  }), p(u, "hash", () => {
+    if (e.output) return e.output.subarray(3, 23);
+    if (e.address) return f().hash;
+    if (e.pubkey || u.pubkey) return T(e.pubkey || u.pubkey);
+  }), p(u, "output", () => {
+    if (u.hash)
+      return l([
+        S.OP_DUP,
+        S.OP_HASH160,
+        u.hash,
+        S.OP_EQUALVERIFY,
+        S.OP_CHECKSIG
+      ]);
+  }), p(u, "pubkey", () => {
     if (e.input)
-      return p()[0];
-  }), h(s, "input", () => {
-    if (e.signature)
-      return y([e.signature]);
-  }), h(s, "witness", () => {
-    if (s.input)
+      return i()[1];
+  }), p(u, "signature", () => {
+    if (e.input)
+      return i()[0];
+  }), p(u, "input", () => {
+    if (!e.pubkey || !e.signature) return;
+    let n = e.pubkey;
+    if (e.useHybrid || e.useUncompressed) {
+      const t = D(e.pubkey);
+      t && (e.useUncompressed ? n = t.uncompressed : n = t.hybrid);
+    }
+    return l([e.signature, n]);
+  }), p(u, "witness", () => {
+    if (u.input)
       return [];
   }), o.validate) {
+    let n = c.from([]);
+    if (e.address) {
+      if (f().version !== s.pubKeyHash)
+        throw new TypeError("Invalid version or Network mismatch");
+      if (f().hash.length !== 20)
+        throw new TypeError("Invalid address");
+      n = f().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[e.output.length - 1] !== Q.OP_CHECKSIG)
+      if (e.output.length !== 25 || e.output[0] !== S.OP_DUP || e.output[1] !== S.OP_HASH160 || e.output[2] !== 20 || e.output[23] !== S.OP_EQUALVERIFY || e.output[24] !== S.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");
+      const t = e.output.subarray(3, 23);
+      if (n.length > 0 && !n.equals(t)) throw new TypeError("Hash mismatch");
+      n = t;
+    }
+    if (e.pubkey) {
+      const t = T(e.pubkey);
+      let h = n.length > 0 && !n.equals(t);
+      if (h && (e.pubkey.length === 33 && (e.pubkey[0] === 2 || e.pubkey[0] === 3) || e.pubkey.length === 65 && e.pubkey[0] === 4)) {
+        const d = D(e.pubkey);
+        if (d) {
+          const a = T(d.uncompressed);
+          if (n.equals(a))
+            h = !1, e.useUncompressed = !0;
+          else {
+            const w = T(d.hybrid);
+            h = !n.equals(w), h || (e.useHybrid = !0);
+          }
+        }
+      }
+      if (h)
+        throw new TypeError("Hash mismatch");
+      n = t;
     }
-    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))
+      const t = i();
+      if (t.length !== 2) throw new TypeError("Input is invalid");
+      if (!H(t[0]))
         throw new TypeError("Input has invalid signature");
+      if (!P(t[1])) throw new TypeError("Input has invalid pubkey");
+      if (e.signature && !e.signature.equals(t[0]))
+        throw new TypeError("Signature mismatch");
+      if (e.pubkey && !e.pubkey.equals(t[1]))
+        throw new TypeError("Pubkey mismatch");
+      const h = T(t[1]);
+      if (n.length > 0 && !n.equals(h)) throw new TypeError("Hash mismatch (input)");
     }
   }
-  return Object.assign(s, e);
+  return Object.assign(u, e);
 }
-const B = v;
-function Pe(e, o) {
+const q = _;
+function Ee(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 || {}), r(
@@ -279,52 +250,52 @@ function Pe(e, o) {
     },
     e
   );
-  let p = e.network;
-  p || (p = e.redeem && e.redeem.network || P);
+  let f = e.network;
+  f || (f = e.redeem && e.redeem.network || v);
   const i = {
-    network: p,
-    name: k.P2SH
-  }, s = l(() => {
-    const t = m.from(x.decode(e.address)), f = t.readUInt8(0), d = t.subarray(1);
-    return { version: f, hash: d };
-  }), u = l(() => w(e.input)), n = l(() => {
-    const t = u(), f = t[t.length - 1];
+    network: f,
+    name: E.P2SH
+  }, s = y(() => {
+    const t = c.from(L.decode(e.address)), h = t.readUInt8(0), d = t.subarray(1);
+    return { version: h, hash: d };
+  }), u = y(() => m(e.input)), n = y(() => {
+    const t = u(), h = t[t.length - 1];
     return {
-      network: p,
-      output: f === B.OP_FALSE ? m.from([]) : f,
-      input: y(t.slice(0, -1)),
+      network: f,
+      output: h === q.OP_FALSE ? c.from([]) : h,
+      input: l(t.slice(0, -1)),
       witness: e.witness || []
     };
   });
-  if (h(i, "address", () => {
+  if (p(i, "address", () => {
     if (!i.hash) return;
-    const t = m.allocUnsafe(21);
-    return t.writeUInt8(i.network.scriptHash, 0), i.hash.copy(t, 1), x.encode(t);
-  }), h(i, "hash", () => {
+    const t = c.allocUnsafe(21);
+    return t.writeUInt8(i.network.scriptHash, 0), i.hash.copy(t, 1), L.encode(t);
+  }), p(i, "hash", () => {
     if (e.output) return e.output.subarray(2, 22);
     if (e.address) return s().hash;
-    if (i.redeem && i.redeem.output) return E(i.redeem.output);
-  }), h(i, "output", () => {
+    if (i.redeem && i.redeem.output) return T(i.redeem.output);
+  }), p(i, "output", () => {
     if (i.hash)
-      return y([B.OP_HASH160, i.hash, B.OP_EQUAL]);
-  }), h(i, "redeem", () => {
+      return l([q.OP_HASH160, i.hash, q.OP_EQUAL]);
+  }), p(i, "redeem", () => {
     if (e.input)
       return n();
-  }), h(i, "input", () => {
+  }), p(i, "input", () => {
     if (!(!e.redeem || !e.redeem.input || !e.redeem.output))
-      return y(
-        [].concat(w(e.redeem.input), e.redeem.output)
+      return l(
+        [].concat(m(e.redeem.input), e.redeem.output)
       );
-  }), h(i, "witness", () => {
+  }), p(i, "witness", () => {
     if (i.redeem && i.redeem.witness) return i.redeem.witness;
     if (i.input) return [];
-  }), h(i, "name", () => {
+  }), p(i, "name", () => {
     const t = ["p2sh"];
     return i.redeem !== void 0 && i.redeem.name !== void 0 && t.push(i.redeem.name), t.join("-");
   }), o.validate) {
-    let t = m.from([]);
+    let t = c.from([]);
     if (e.address) {
-      if (s().version !== p.scriptHash)
+      if (s().version !== f.scriptHash)
         throw new TypeError("Invalid version or Network mismatch");
       if (s().hash.length !== 20) throw new TypeError("Invalid address");
       t = s().hash;
@@ -334,34 +305,34 @@ function Pe(e, o) {
       t = 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)
+      if (e.output.length !== 23 || e.output[0] !== q.OP_HASH160 || e.output[1] !== 20 || e.output[22] !== q.OP_EQUAL)
         throw new TypeError("Output is invalid");
       const d = e.output.subarray(2, 22);
       if (t.length > 0 && !t.equals(d)) throw new TypeError("Hash mismatch");
       t = d;
     }
-    const f = (d) => {
+    const h = (d) => {
       if (d.output) {
-        const a = w(d.output);
+        const a = m(d.output);
         if (!a || a.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 (ue(a) > 201)
+        if (oe(a) > 201)
           throw new TypeError(
             "Redeem.output unspendable with more than 201 non-push ops"
           );
-        const c = E(d.output);
-        if (t.length > 0 && !t.equals(c)) throw new TypeError("Hash mismatch");
-        t = c;
+        const w = T(d.output);
+        if (t.length > 0 && !t.equals(w)) throw new TypeError("Hash mismatch");
+        t = w;
       }
       if (d.input) {
-        const a = d.input.length > 0, c = d.witness && d.witness.length > 0;
-        if (!a && !c) throw new TypeError("Empty input");
-        if (a && c) throw new TypeError("Input and witness provided");
+        const a = d.input.length > 0, w = d.witness && d.witness.length > 0;
+        if (!a && !w) throw new TypeError("Empty input");
+        if (a && w) throw new TypeError("Input and witness provided");
         if (a) {
-          const _ = w(d.input);
-          if (!ie(_))
+          const I = m(d.input);
+          if (!fe(I))
             throw new TypeError("Non push-only scriptSig");
         }
       }
@@ -369,11 +340,11 @@ function Pe(e, o) {
     if (e.input) {
       const d = u();
       if (!d || d.length < 1) throw new TypeError("Input too short");
-      if (!m.isBuffer(n().output)) throw new TypeError("Input is invalid");
-      f(n());
+      if (!c.isBuffer(n().output)) throw new TypeError("Input is invalid");
+      h(n());
     }
     if (e.redeem) {
-      if (e.redeem.network && e.redeem.network !== p)
+      if (e.redeem.network && e.redeem.network !== f)
         throw new TypeError("Network mismatch");
       if (e.input) {
         const d = n();
@@ -382,15 +353,118 @@ function Pe(e, o) {
         if (e.redeem.input && !e.redeem.input.equals(d.input))
           throw new TypeError("Redeem.input mismatch");
       }
-      f(e.redeem);
+      h(e.redeem);
     }
-    if (e.witness && e.redeem && e.redeem.witness && !N(e.redeem.witness, e.witness))
+    if (e.witness && e.redeem && e.redeem.witness && !j(e.redeem.witness, e.witness))
       throw new TypeError("Witness and redeem.witness mismatch");
   }
   return Object.assign(i, e);
 }
-const Y = v, z = 1, ve = 80;
-function Oe(e, o) {
+const R = {};
+function We(e) {
+  e ? e !== R.eccLib && (Te(e), R.eccLib = e) : R.eccLib = e;
+}
+function pe() {
+  if (!R.eccLib)
+    throw new Error(
+      "No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance"
+    );
+  return R.eccLib;
+}
+const O = (e) => c.from(e, "hex");
+function Te(e) {
+  b(typeof e.isXOnlyPoint == "function"), b(e.isXOnlyPoint(O("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"))), b(e.isXOnlyPoint(O("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e"))), b(e.isXOnlyPoint(O("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"))), b(e.isXOnlyPoint(O("0000000000000000000000000000000000000000000000000000000000000001"))), b(
+    !e.isXOnlyPoint(O("0000000000000000000000000000000000000000000000000000000000000000"))
+  ), b(
+    !e.isXOnlyPoint(O("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"))
+  ), b(typeof e.xOnlyPointAddTweak == "function"), Pe.forEach((o) => {
+    const f = e.xOnlyPointAddTweak(O(o.pubkey), O(o.tweak));
+    o.result === null ? b(f === null) : (b(f !== null), b(f.parity === o.parity), b(c.from(f.xOnlyPubkey).equals(O(o.result))));
+  });
+}
+function b(e) {
+  if (!e) throw new Error("ecc library invalid");
+}
+const Pe = [
+  {
+    pubkey: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+    tweak: "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
+    parity: -1,
+    result: null
+  },
+  {
+    pubkey: "1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b",
+    tweak: "a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac",
+    parity: 1,
+    result: "e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf"
+  },
+  {
+    pubkey: "2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991",
+    tweak: "823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47",
+    parity: 0,
+    result: "9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c"
+  }
+], G = 192, Oe = 128, ve = (e) => "left" in e && "right" in e;
+function F(e, o) {
+  if (e.length < 33)
+    throw new TypeError(
+      `The control-block length is too small. Got ${e.length}, expected min 33.`
+    );
+  const f = (e.length - 33) / 32;
+  let i = o;
+  for (let s = 0; s < f; s++) {
+    const u = e.subarray(33 + 32 * s, 65 + 32 * s);
+    i.compare(u) < 0 ? i = M(i, u) : i = M(u, i);
+  }
+  return i;
+}
+function W(e) {
+  if (we(e)) return { hash: B(e) };
+  const o = [W(e[0]), W(e[1])];
+  o.sort((s, u) => s.hash.compare(u.hash));
+  const [f, i] = o;
+  return {
+    hash: M(f.hash, i.hash),
+    left: f,
+    right: i
+  };
+}
+function x(e, o) {
+  if (ve(e)) {
+    const f = x(e.left, o);
+    if (f !== void 0) return [...f, e.right.hash];
+    const i = x(e.right, o);
+    if (i !== void 0) return [...i, e.left.hash];
+  } else if (e.hash.equals(o))
+    return [];
+}
+function B(e) {
+  const o = e.version || G;
+  return X(
+    "TapLeaf",
+    k.concat([k.from([o]), Se(e.output)])
+  );
+}
+function _e(e, o) {
+  return X("TapTweak", k.concat(o ? [e, o] : [e]));
+}
+function V(e, o) {
+  if (!k.isBuffer(e) || e.length !== 32 || o && o.length !== 32) return null;
+  const f = _e(e, o), i = pe().xOnlyPointAddTweak(e, f);
+  return !i || i.xOnlyPubkey === null ? null : {
+    parity: i.parity,
+    x: k.from(i.xOnlyPubkey)
+  };
+}
+function M(e, o) {
+  return X("TapBranch", k.concat([e, o]));
+}
+function Se(e) {
+  const o = le(e.length), f = k.allocUnsafe(o);
+  return ye(e.length, f), k.concat([f, e]);
+}
+const ee = _, re = 1, Ie = 80;
+function He(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 || {}), r(
@@ -406,7 +480,7 @@ function Oe(e, o) {
       // tweaked with `hash` from `internalPubkey`
       signature: r.maybe(r.anyOf(r.BufferN(64), r.BufferN(65))),
       witness: r.maybe(r.arrayOf(r.Buffer)),
-      scriptTree: r.maybe(ce),
+      scriptTree: r.maybe(be),
       redeem: r.maybe({
         output: r.maybe(r.Buffer),
         // tapleaf script
@@ -418,87 +492,87 @@ function Oe(e, o) {
     },
     e
   );
-  const p = l(() => se(e.address)), i = l(() => {
+  const f = y(() => ie(e.address)), i = 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 = l(() => {
-    if (e.scriptTree) return A(e.scriptTree);
+      return e.witness.length >= 2 && e.witness[e.witness.length - 1][0] === Ie ? e.witness.slice(0, -1) : e.witness.slice();
+  }), s = y(() => {
+    if (e.scriptTree) return W(e.scriptTree);
     if (e.hash) return { hash: e.hash };
-  }), u = e.network || P, n = {
-    name: k.P2TR,
+  }), u = e.network || v, n = {
+    name: E.P2TR,
     network: u
   };
-  if (h(n, "address", () => {
+  if (p(n, "address", () => {
     if (!n.pubkey) return;
-    const t = b.bech32m.toWords(n.pubkey);
-    return t.unshift(z), b.bech32m.encode(u.bech32, t);
-  }), h(n, "hash", () => {
+    const t = g.bech32m.toWords(n.pubkey);
+    return t.unshift(re), g.bech32m.encode(u.bech32, t);
+  }), p(n, "hash", () => {
     const t = s();
     if (t) return t.hash;
-    const f = i();
-    if (f && f.length > 1) {
-      const d = f[f.length - 1], a = d[0] & W, c = f[f.length - 2], _ = H({
-        output: c,
+    const h = i();
+    if (h && h.length > 1) {
+      const d = h[h.length - 1], a = d[0] & $, w = h[h.length - 2], I = B({
+        output: w,
         version: a
       });
-      return L(d, _);
+      return F(d, I);
     }
-  }), h(n, "output", () => {
+  }), p(n, "output", () => {
     if (n.pubkey)
-      return y([Y.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 : M), h(n, "redeem", () => {
+      return l([ee.OP_1, n.pubkey]);
+  }), p(n, "redeemVersion", () => e.redeemVersion ? e.redeemVersion : e.redeem && e.redeem.redeemVersion !== void 0 && e.redeem.redeemVersion !== null ? e.redeem.redeemVersion : G), p(n, "redeem", () => {
     const t = i();
     if (!(!t || t.length < 2))
       return {
         output: t[t.length - 2],
         witness: t.slice(0, -2),
-        redeemVersion: t[t.length - 1][0] & W
+        redeemVersion: t[t.length - 1][0] & $
       };
-  }), h(n, "pubkey", () => {
+  }), p(n, "pubkey", () => {
     if (e.pubkey) return e.pubkey;
     if (e.output) return e.output.subarray(2);
-    if (e.address) return p().data;
+    if (e.address) return f().data;
     if (n.internalPubkey) {
-      const t = j(n.internalPubkey, n.hash);
+      const t = V(n.internalPubkey, n.hash);
       if (t) return t.x;
     }
-  }), h(n, "internalPubkey", () => {
+  }), p(n, "internalPubkey", () => {
     if (e.internalPubkey) return e.internalPubkey;
     const t = i();
     if (t && t.length > 1) return t[t.length - 1].subarray(1, 33);
-  }), h(n, "signature", () => {
+  }), p(n, "signature", () => {
     if (e.signature) return e.signature;
     const t = i();
     if (!(!t || t.length !== 1))
       return t[0];
-  }), h(n, "witness", () => {
+  }), p(n, "witness", () => {
     if (e.witness) return e.witness;
     const t = s();
     if (t && e.redeem && e.redeem.output && e.internalPubkey) {
-      const f = H({
+      const h = B({
         output: e.redeem.output,
         version: n.redeemVersion
-      }), d = q(t, f);
+      }), d = x(t, h);
       if (!d) return;
-      const a = j(e.internalPubkey, t.hash);
+      const a = V(e.internalPubkey, t.hash);
       if (!a) return;
-      const c = g.concat(
-        [g.from([n.redeemVersion | a.parity]), e.internalPubkey].concat(
+      const w = k.concat(
+        [k.from([n.redeemVersion | a.parity]), e.internalPubkey].concat(
           d
         )
       );
-      return [e.redeem.output, c];
+      return [e.redeem.output, w];
     }
     if (e.signature) return [e.signature];
   }), o.validate) {
-    let t = g.from([]);
+    let t = k.from([]);
     if (e.address) {
-      if (u && u.bech32 !== p().prefix)
+      if (u && u.bech32 !== f().prefix)
         throw new TypeError("Invalid prefix or Network mismatch");
-      if (p().version !== z)
+      if (f().version !== re)
         throw new TypeError("Invalid address version");
-      if (p().data.length !== 32) throw new TypeError("Invalid address data");
-      t = p().data;
+      if (f().data.length !== 32) throw new TypeError("Invalid address data");
+      t = f().data;
     }
     if (e.pubkey) {
       if (t.length > 0 && !t.equals(e.pubkey))
@@ -506,29 +580,27 @@ function Oe(e, o) {
       t = e.pubkey;
     }
     if (e.output) {
-      if (e.output.length !== 34 || e.output[0] !== Y.OP_1 || e.output[1] !== 32)
+      if (e.output.length !== 34 || e.output[0] !== ee.OP_1 || e.output[1] !== 32)
         throw new TypeError("Output is invalid");
       if (t.length > 0 && !t.equals(e.output.subarray(2)))
         throw new TypeError("Pubkey mismatch");
       t = e.output.subarray(2);
     }
     if (e.internalPubkey) {
-      const a = j(e.internalPubkey, n.hash);
+      const a = V(e.internalPubkey, n.hash);
       if (t.length > 0 && !t.equals(a.x))
         throw new TypeError("Pubkey mismatch");
       t = a.x;
     }
-    if (t && t.length && !K().isXOnlyPoint(t))
-      throw new TypeError("Invalid pubkey for p2tr");
-    const f = s();
-    if (e.hash && f && !e.hash.equals(f.hash))
+    const h = s();
+    if (e.hash && h && !e.hash.equals(h.hash))
       throw new TypeError("Hash mismatch");
-    if (e.redeem && e.redeem.output && f) {
-      const a = H({
+    if (e.redeem && e.redeem.output && h) {
+      const a = B({
         output: e.redeem.output,
         version: n.redeemVersion
       });
-      if (!q(f, a))
+      if (!x(h, a))
         throw new TypeError("Redeem script not in tree");
     }
     const d = i();
@@ -536,12 +608,12 @@ function Oe(e, o) {
       if (e.redeem.redeemVersion && e.redeem.redeemVersion !== n.redeem.redeemVersion)
         throw new TypeError("Redeem.redeemVersion and witness mismatch");
       if (e.redeem.output) {
-        if (w(e.redeem.output).length === 0)
+        if (m(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))
+      if (e.redeem.witness && n.redeem.witness && !j(e.redeem.witness, n.redeem.witness))
         throw new TypeError("Redeem.witness and witness mismatch");
     }
     if (d && d.length)
@@ -558,29 +630,29 @@ function Oe(e, o) {
           throw new TypeError(
             `The control-block length of ${a.length} is incorrect!`
           );
-        const c = (a.length - 33) / 32;
-        if (c > 128)
-          throw new TypeError(`The script path is too long. Got ${c}, expected max 128.`);
-        const _ = a.subarray(1, 33);
-        if (e.internalPubkey && !e.internalPubkey.equals(_))
+        const w = (a.length - 33) / 32;
+        if (w > 128)
+          throw new TypeError(`The script path is too long. Got ${w}, expected max 128.`);
+        const I = a.subarray(1, 33);
+        if (e.internalPubkey && !e.internalPubkey.equals(I))
           throw new TypeError("Internal pubkey mismatch");
-        if (!K().isXOnlyPoint(_))
+        if (!pe().isXOnlyPoint(I))
           throw new TypeError("Invalid internalPubkey for p2tr witness");
-        const he = a[0] & W, pe = d[d.length - 2], fe = H({
-          output: pe,
+        const he = a[0] & $, de = d[d.length - 2], ae = B({
+          output: de,
           version: he
-        }), de = L(a, fe), U = j(_, de);
-        if (!U)
+        }), ce = F(a, ae), C = V(I, ce);
+        if (!C)
           throw new TypeError("Invalid outputKey for p2tr witness");
-        if (t.length && !t.equals(U.x))
+        if (t.length && !t.equals(C.x))
           throw new TypeError("Pubkey mismatch for p2tr witness");
-        if (U.parity !== (a[0] & 1)) throw new Error("Incorrect parity");
+        if (C.parity !== (a[0] & 1)) throw new Error("Incorrect parity");
       }
   }
   return Object.assign(n, e);
 }
-const Z = v, _e = m.alloc(0);
-function Se(e, o) {
+const te = _, Ne = c.alloc(0);
+function Be(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 || {}), r(
@@ -590,93 +662,93 @@ function Se(e, o) {
       input: r.maybe(r.BufferN(0)),
       network: r.maybe(r.Object),
       output: r.maybe(r.BufferN(22)),
-      pubkey: r.maybe(T),
-      signature: r.maybe(S),
+      pubkey: r.maybe(P),
+      signature: r.maybe(H),
       witness: r.maybe(r.arrayOf(r.Buffer))
     },
     e
   );
-  const p = l(() => {
-    const u = b.bech32.decode(e.address), n = u.words.shift(), t = b.bech32.fromWords(u.words);
+  const f = y(() => {
+    const u = g.bech32.decode(e.address), n = u.words.shift(), t = g.bech32.fromWords(u.words);
     return {
       version: n,
       prefix: u.prefix,
-      data: m.from(t)
+      data: c.from(t)
     };
-  }), i = e.network || P, s = {
-    name: k.P2WPKH,
+  }), i = e.network || v, s = {
+    name: E.P2WPKH,
     network: i
   };
-  if (h(s, "address", () => {
+  if (p(s, "address", () => {
     if (!s.hash) return;
-    const u = b.bech32.toWords(s.hash);
-    return u.unshift(0), b.bech32.encode(i.bech32, u);
-  }), h(s, "hash", () => {
+    const u = g.bech32.toWords(s.hash);
+    return u.unshift(0), g.bech32.encode(i.bech32, u);
+  }), p(s, "hash", () => {
     if (e.output) return e.output.subarray(2, 22);
-    if (e.address) return p().data;
-    if (e.pubkey || s.pubkey) return E(e.pubkey || s.pubkey);
-  }), h(s, "output", () => {
+    if (e.address) return f().data;
+    if (e.pubkey || s.pubkey) return T(e.pubkey || s.pubkey);
+  }), p(s, "output", () => {
     if (s.hash)
-      return y([Z.OP_0, s.hash]);
-  }), h(s, "pubkey", () => {
+      return l([te.OP_0, s.hash]);
+  }), p(s, "pubkey", () => {
     if (e.pubkey) return e.pubkey;
     if (e.witness)
       return e.witness[1];
-  }), h(s, "signature", () => {
+  }), p(s, "signature", () => {
     if (e.witness)
       return e.witness[0];
-  }), h(s, "input", () => {
+  }), p(s, "input", () => {
     if (s.witness)
-      return _e;
-  }), h(s, "witness", () => {
+      return Ne;
+  }), p(s, "witness", () => {
     if (e.pubkey && e.signature)
       return [e.signature, e.pubkey];
   }), o.validate) {
-    let u = m.from([]);
+    let u = c.from([]);
     if (e.address) {
-      if (i && i.bech32 !== p().prefix)
+      if (i && i.bech32 !== f().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");
-      u = p().data;
+      if (f().version !== 0) throw new TypeError("Invalid address version");
+      if (f().data.length !== 20) throw new TypeError("Invalid address data");
+      u = f().data;
     }
     if (e.hash) {
       if (u.length > 0 && !u.equals(e.hash)) throw new TypeError("Hash mismatch");
       u = e.hash;
     }
     if (e.output) {
-      if (e.output.length !== 22 || e.output[0] !== Z.OP_0 || e.output[1] !== 20)
+      if (e.output.length !== 22 || e.output[0] !== te.OP_0 || e.output[1] !== 20)
         throw new TypeError("Output is invalid");
       if (u.length > 0 && !u.equals(e.output.subarray(2)))
         throw new TypeError("Hash mismatch");
       u = e.output.subarray(2);
     }
     if (e.pubkey) {
-      const n = E(e.pubkey);
+      const n = T(e.pubkey);
       if (u.length > 0 && !u.equals(n)) throw new TypeError("Hash mismatch");
-      if (u = n, !T(e.pubkey) || e.pubkey.length !== 33)
+      if (u = n, !P(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]))
+      if (!H(e.witness[0]))
         throw new TypeError("Witness has invalid signature");
-      if (!T(e.witness[1]) || e.witness[1].length !== 33)
+      if (!P(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]);
+      const n = T(e.witness[1]);
       if (u.length > 0 && !u.equals(n)) throw new TypeError("Hash mismatch");
     }
   }
   return Object.assign(s, e);
 }
-const J = v, $ = m.alloc(0);
-function R(e) {
-  return !!(m.isBuffer(e) && e.length === 65 && e[0] === 4 && T(e));
+const ne = _, K = c.alloc(0);
+function A(e) {
+  return !!(c.isBuffer(e) && e.length === 65 && e[0] === 4 && P(e));
 }
-function Ie(e, o) {
+function je(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 || {}), r(
@@ -696,66 +768,66 @@ function Ie(e, o) {
     },
     e
   );
-  const p = l(() => {
-    const n = b.bech32.decode(e.address), t = n.words.shift(), f = b.bech32.fromWords(n.words);
+  const f = y(() => {
+    const n = g.bech32.decode(e.address), t = n.words.shift(), h = g.bech32.fromWords(n.words);
     return {
       version: t,
       prefix: n.prefix,
-      data: m.from(f)
+      data: c.from(h)
     };
-  }), i = l(() => w(e.redeem.input));
+  }), i = y(() => m(e.redeem.input));
   let s = e.network;
-  s || (s = e.redeem && e.redeem.network || P);
+  s || (s = e.redeem && e.redeem.network || v);
   const u = {
     network: s,
-    name: k.P2WSH
+    name: E.P2WSH
   };
-  if (h(u, "address", () => {
+  if (p(u, "address", () => {
     if (!u.hash) return;
-    const n = b.bech32.toWords(u.hash);
-    return n.unshift(0), b.bech32.encode(s.bech32, n);
-  }), h(u, "hash", () => {
+    const n = g.bech32.toWords(u.hash);
+    return n.unshift(0), g.bech32.encode(s.bech32, n);
+  }), p(u, "hash", () => {
     if (e.output) return e.output.subarray(2);
-    if (e.address) return p().data;
-    if (u.redeem && u.redeem.output) return G(u.redeem.output);
-  }), h(u, "output", () => {
+    if (e.address) return f().data;
+    if (u.redeem && u.redeem.output) return Y(u.redeem.output);
+  }), p(u, "output", () => {
     if (u.hash)
-      return y([J.OP_0, u.hash]);
-  }), h(u, "redeem", () => {
+      return l([ne.OP_0, u.hash]);
+  }), p(u, "redeem", () => {
     if (e.witness)
       return {
         output: e.witness[e.witness.length - 1],
-        input: $,
+        input: K,
         witness: e.witness.slice(0, -1)
       };
-  }), h(u, "input", () => {
+  }), p(u, "input", () => {
     if (u.witness)
-      return $;
-  }), h(u, "witness", () => {
+      return K;
+  }), p(u, "witness", () => {
     if (e.redeem && e.redeem.input && e.redeem.input.length > 0 && e.redeem.output && e.redeem.output.length > 0) {
-      const n = ye(i());
-      return u.redeem = Object.assign({ witness: n }, e.redeem), u.redeem.input = $, [].concat(n, e.redeem.output);
+      const n = me(i());
+      return u.redeem = Object.assign({ witness: n }, e.redeem), u.redeem.input = K, [].concat(n, e.redeem.output);
     }
     if (e.redeem && e.redeem.output && e.redeem.witness)
       return [].concat(e.redeem.witness, e.redeem.output);
-  }), h(u, "name", () => {
+  }), p(u, "name", () => {
     const n = ["p2wsh"];
     return u.redeem !== void 0 && u.redeem.name !== void 0 && n.push(u.redeem.name), n.join("-");
   }), o.validate) {
-    let n = m.from([]);
+    let n = c.from([]);
     if (e.address) {
-      if (p().prefix !== s.bech32)
+      if (f().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 (f().version !== 0) throw new TypeError("Invalid address version");
+      if (f().data.length !== 32) throw new TypeError("Invalid address data");
+      n = f().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] !== J.OP_0 || e.output[1] !== 32)
+      if (e.output.length !== 34 || e.output[0] !== ne.OP_0 || e.output[1] !== 32)
         throw new TypeError("Output is invalid");
       const t = e.output.subarray(2);
       if (n.length > 0 && !n.equals(t)) throw new TypeError("Hash mismatch");
@@ -767,281 +839,251 @@ function Ie(e, o) {
       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 t = w(e.redeem.output);
+        const t = m(e.redeem.output);
         if (!t || t.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 (ue(t) > 201)
+        if (oe(t) > 201)
           throw new TypeError(
             "Redeem.output unspendable with more than 201 non-push ops"
           );
-        const f = G(e.redeem.output);
-        if (n.length > 0 && !n.equals(f)) throw new TypeError("Hash mismatch");
-        n = f;
+        const h = Y(e.redeem.output);
+        if (n.length > 0 && !n.equals(h)) throw new TypeError("Hash mismatch");
+        n = h;
       }
-      if (e.redeem.input && !ie(i()))
+      if (e.redeem.input && !fe(i()))
         throw new TypeError("Non push-only scriptSig");
-      if (e.witness && e.redeem.witness && !N(e.witness, e.redeem.witness))
+      if (e.witness && e.redeem.witness && !j(e.witness, e.redeem.witness))
         throw new TypeError("Witness and redeem.witness mismatch");
-      if (e.redeem.input && i().some(R) || e.redeem.output && (w(e.redeem.output) || []).some(R))
+      if (e.redeem.input && i().some(A) || e.redeem.output && (m(e.redeem.output) || []).some(A))
         throw new TypeError("redeem.input or redeem.output contains uncompressed pubkey");
     }
     if (e.witness && e.witness.length > 0) {
       const t = e.witness[e.witness.length - 1];
       if (e.redeem && e.redeem.output && !e.redeem.output.equals(t))
         throw new TypeError("Witness and redeem.output mismatch");
-      if (e.witness.some(R) || (w(t) || []).some(R))
+      if (e.witness.some(A) || (m(t) || []).some(A))
         throw new TypeError("Witness contains uncompressed pubkey");
     }
   }
   return Object.assign(u, e);
 }
-const ee = v, re = 16, te = 2, ne = 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");
+const se = _;
+function qe(e, o) {
+  if (!e.data && !e.output) throw new TypeError("Not enough data");
   o = Object.assign({ validate: !0 }, o || {}), r(
     {
-      address: r.maybe(r.String),
+      network: r.maybe(r.Object),
       output: r.maybe(r.Buffer),
-      program: r.maybe(r.Buffer),
+      data: r.maybe(r.arrayOf(r.Buffer))
+    },
+    e
+  );
+  const f = e.network || v, i = { name: E.Embed, network: f, data: [] };
+  if (p(i, "output", () => {
+    if (e.data)
+      return l([se.OP_RETURN].concat(e.data));
+  }), p(i, "data", () => {
+    if (!e.output) return;
+    const s = m(e.output);
+    if (s != null)
+      return s.slice(1);
+  }), o.validate && e.output) {
+    const s = m(e.output);
+    if (s[0] !== se.OP_RETURN) throw new TypeError("Output is invalid");
+    if (!s.slice(1).every(r.Buffer)) throw new TypeError("Output is invalid");
+    if (e.data && !j(e.data, i.data)) throw new TypeError("Data mismatch");
+  }
+  return Object.assign(i, e);
+}
+const N = _, U = N.OP_RESERVED;
+function Ve(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 f(h) {
+    return H(h) || (o.allowIncomplete && h === N.OP_0) !== void 0;
+  }
+  r(
+    {
       network: r.maybe(r.Object),
-      deploymentVersion: r.maybe(r.Number),
-      hash160: r.maybe(r.BufferN(20))
+      m: r.maybe(r.Number),
+      n: r.maybe(r.Number),
+      output: r.maybe(r.Buffer),
+      pubkeys: r.maybe(r.arrayOf(P)),
+      signatures: r.maybe(r.arrayOf(f)),
+      input: r.maybe(r.Buffer)
     },
     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 m.concat([m.of(e.deploymentVersion), e.hash160]);
-    }
-  }, i = l(() => se(e.address)), s = e.network || P, u = {
-    name: k.P2OP,
-    network: s,
-    deploymentVersion: 0
+  const s = {
+    network: e.network || v,
+    name: E.P2MS
   };
-  if (h(u, "program", () => {
-    if (e.program) return e.program;
-    const n = p();
-    if (n) return n;
+  let u = [], n = !1;
+  function t(h) {
+    n || (n = !0, u = m(h), s.m = u[0] - U, s.n = u[u.length - 2] - U, s.pubkeys = u.slice(1, -2));
+  }
+  if (p(s, "output", () => {
+    if (e.m && s.n && e.pubkeys)
+      return l(
+        [].concat(
+          U + e.m,
+          e.pubkeys,
+          U + s.n,
+          N.OP_CHECKMULTISIG
+        )
+      );
+  }), p(s, "m", () => {
+    if (s.output)
+      return t(s.output), s.m;
+  }), p(s, "n", () => {
+    if (s.pubkeys)
+      return s.pubkeys.length;
+  }), p(s, "pubkeys", () => {
+    if (e.output)
+      return t(e.output), s.pubkeys;
+  }), p(s, "signatures", () => {
+    if (!e.input) return;
+    const h = m(e.input);
+    if (h != null)
+      return h.slice(1);
+  }), p(s, "input", () => {
+    if (e.signatures)
+      return l([N.OP_0].concat(e.signatures));
+  }), p(s, "witness", () => {
+    if (s.input)
+      return [];
+  }), p(s, "name", () => {
+    if (!(!s.m || !s.n))
+      return `p2ms(${s.m} of ${s.n})`;
+  }), o.validate) {
     if (e.output) {
-      if (e.output[0] !== ee.OP_16) throw new TypeError("Invalid P2OP script");
-      let t = 1, f;
-      if (e.output[1] < 76)
-        f = e.output[1], t = 2;
-      else if (e.output[1] === 76)
-        f = e.output[2], t = 3;
-      else
-        throw new TypeError("Unsupported push opcode in P2OP script");
-      return e.output.subarray(t, t + f);
+      if (t(e.output), !r.Number(u[0])) throw new TypeError("Output is invalid");
+      if (!r.Number(u[u.length - 2])) throw new TypeError("Output is invalid");
+      if (u[u.length - 1] !== N.OP_CHECKMULTISIG)
+        throw new TypeError("Output is invalid");
+      if (s.m <= 0 || s.n > 16 || s.m > s.n || s.n !== u.length - 3)
+        throw new TypeError("Output is invalid");
+      if (!s.pubkeys.every((h) => P(h))) 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 && !j(e.pubkeys, s.pubkeys))
+        throw new TypeError("Pubkeys mismatch");
     }
-    if (e.address)
-      return i().data;
-  }), h(u, "deploymentVersion", () => {
-    if (u.program)
-      return u.program[0];
-  }), h(u, "hash160", () => {
-    if (u.program)
-      return u.program.subarray(1);
-  }), h(u, "output", () => {
-    if (u.program)
-      return y([ee.OP_16, u.program]);
-  }), h(u, "address", () => {
-    if (!u.program) return;
-    if (!s.bech32Opnet)
-      throw new TypeError("Network does not support opnet");
-    const n = b.bech32m.toWords(u.program);
-    return n.unshift(re), b.bech32m.encode(s.bech32Opnet, n);
-  }), o.validate) {
-    let n = g.alloc(0);
-    if (e.address) {
-      const t = i();
-      if (s.bech32Opnet !== t.prefix)
-        throw new TypeError("Invalid prefix or network mismatch");
-      if (t.version !== re)
-        throw new TypeError("Invalid witness version for p2op");
-      if (t.data.length < te || t.data.length > ne)
-        throw new TypeError("Invalid witness program length");
-      n = t.data;
+    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.program) {
-      if (n.length && !n.equals(e.program)) throw new TypeError("Program mismatch");
-      n = e.program;
+    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 (!n.length && e.deploymentVersion !== void 0 && e.hash160 && (n = p()), e.output) {
-      const t = u.program;
-      if (n.length && !n.equals(t))
-        throw new TypeError("Program mismatch (output vs other source)");
-      n = t;
+    if (e.input) {
+      if (e.input[0] !== N.OP_0) throw new TypeError("Input is invalid");
+      if (s.signatures.length === 0 || !s.signatures.every(f))
+        throw new TypeError("Input has invalid signature(s)");
+      if (e.signatures && !j(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");
     }
-    if (n.length < te || n.length > ne)
-      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.subarray(1)))
-      throw new TypeError("hash160 mismatch");
   }
-  return Object.assign(u, e);
+  return Object.assign(s, e);
 }
-const O = v;
-function Ne(e, o) {
-  if (!e.address && !e.hash && !e.output && !e.pubkey && !e.input)
+const ue = _;
+function Re(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 || {}), r(
     {
       network: r.maybe(r.Object),
-      address: r.maybe(r.String),
-      hash: r.maybe(r.BufferN(20)),
-      output: r.maybe(r.BufferN(25)),
-      pubkey: r.maybe(T),
-      signature: r.maybe(S),
+      output: r.maybe(r.Buffer),
+      pubkey: r.maybe(P),
+      signature: r.maybe(H),
       input: r.maybe(r.Buffer)
     },
     e
   );
-  const p = l(() => {
-    const n = m.from(x.decode(e.address)), t = n.readUInt8(0), f = n.subarray(1);
-    return { version: t, hash: f };
-  }), i = l(() => w(e.input)), s = e.network || P, u = {
-    name: k.P2PKH,
-    network: s,
-    hash: void 0
+  const f = y(() => m(e.input)), i = e.network || v, s = {
+    name: E.P2PK,
+    network: i,
+    pubkey: void 0
   };
-  if (h(u, "address", () => {
-    if (!u.hash) return;
-    const n = m.allocUnsafe(21);
-    return n.writeUInt8(s.pubKeyHash, 0), u.hash.copy(n, 1), x.encode(n);
-  }), h(u, "hash", () => {
-    if (e.output) return e.output.subarray(3, 23);
-    if (e.address) return p().hash;
-    if (e.pubkey || u.pubkey) return E(e.pubkey || u.pubkey);
-  }), h(u, "output", () => {
-    if (u.hash)
-      return y([
-        O.OP_DUP,
-        O.OP_HASH160,
-        u.hash,
-        O.OP_EQUALVERIFY,
-        O.OP_CHECKSIG
-      ]);
-  }), h(u, "pubkey", () => {
-    if (e.input)
-      return i()[1];
-  }), h(u, "signature", () => {
+  if (p(s, "output", () => {
+    if (e.pubkey)
+      return l([e.pubkey, ue.OP_CHECKSIG]);
+  }), p(s, "pubkey", () => {
+    if (e.output)
+      return e.output.subarray(1, -1);
+  }), p(s, "signature", () => {
     if (e.input)
-      return i()[0];
-  }), h(u, "input", () => {
-    if (!e.pubkey || !e.signature) return;
-    let n = e.pubkey;
-    if (e.useHybrid || e.useUncompressed) {
-      const t = X(e.pubkey);
-      t && (e.useUncompressed ? n = t.uncompressed : n = t.hybrid);
-    }
-    return y([e.signature, n]);
-  }), h(u, "witness", () => {
-    if (u.input)
+      return f()[0];
+  }), p(s, "input", () => {
+    if (e.signature)
+      return l([e.signature]);
+  }), p(s, "witness", () => {
+    if (s.input)
       return [];
   }), o.validate) {
-    let n = m.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)
+      if (e.output[e.output.length - 1] !== ue.OP_CHECKSIG)
         throw new TypeError("Output is invalid");
-      const t = e.output.subarray(3, 23);
-      if (n.length > 0 && !n.equals(t)) throw new TypeError("Hash mismatch");
-      n = t;
-    }
-    if (e.pubkey) {
-      const t = E(e.pubkey);
-      let f = n.length > 0 && !n.equals(t);
-      if (f && (e.pubkey.length === 33 && (e.pubkey[0] === 2 || e.pubkey[0] === 3) || e.pubkey.length === 65 && e.pubkey[0] === 4)) {
-        const d = X(e.pubkey);
-        if (d) {
-          const a = E(d.uncompressed);
-          if (n.equals(a))
-            f = !1, e.useUncompressed = !0;
-          else {
-            const c = E(d.hybrid);
-            f = !n.equals(c), f || (e.useHybrid = !0);
-          }
-        }
-      }
-      if (f)
-        throw new TypeError("Hash mismatch");
-      n = t;
+      if (!P(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) {
-      const t = i();
-      if (t.length !== 2) throw new TypeError("Input is invalid");
-      if (!S(t[0]))
+      if (f().length !== 1) throw new TypeError("Input is invalid");
+      if (!H(s.signature))
         throw new TypeError("Input has invalid signature");
-      if (!T(t[1])) throw new TypeError("Input has invalid pubkey");
-      if (e.signature && !e.signature.equals(t[0]))
-        throw new TypeError("Signature mismatch");
-      if (e.pubkey && !e.pubkey.equals(t[1]))
-        throw new TypeError("Pubkey mismatch");
-      const f = E(t[1]);
-      if (n.length > 0 && !n.equals(f)) throw new TypeError("Hash mismatch (input)");
     }
   }
-  return Object.assign(u, e);
+  return Object.assign(s, 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({
+const Ce = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  LEAF_VERSION_TAPSCRIPT: M,
-  MAX_TAPTREE_DEPTH: le,
-  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: L,
-  tapTweakHash: oe,
-  tapleafHash: H,
-  toHashTree: A,
-  tweakKey: j,
-  value: l
+  LEAF_VERSION_TAPSCRIPT: G,
+  MAX_TAPTREE_DEPTH: Oe,
+  PaymentType: E,
+  findScriptPath: x,
+  p2data: qe,
+  p2ms: Ve,
+  p2op: ge,
+  p2pk: Re,
+  p2pkh: ke,
+  p2sh: Ee,
+  p2tr: He,
+  p2wpkh: Be,
+  p2wsh: je,
+  prop: p,
+  rootHashFromPath: F,
+  tapleafHash: B,
+  toHashTree: W,
+  tweakKey: V,
+  value: y
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  M as L,
-  le 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,
-  L as r,
-  j as t
+  G as L,
+  Oe as M,
+  E as P,
+  Ee as a,
+  Be as b,
+  je as c,
+  He as d,
+  ge as e,
+  Re as f,
+  Ve as g,
+  B as h,
+  Ce as i,
+  We as j,
+  W as k,
+  x as l,
+  _e as m,
+  ke as p,
+  F as r,
+  V as t
 };