@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/btc-vision-bitcoin.js

@@ -0,0 +1,4179 @@
+import { B as h, a as N } from "./polyfills.js";
+import { i as _n, d as P, a as Oe, b as bn, e as Sr, c as Pe, v as Ke, p as Ct, u as U } from "./bitcoin-utils.js";
+import { f as _r, g as Tn, s as Me } from "./noble-hashes.js";
+const K = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "bc",
+  bech32Opnet: "op",
+  bip32: {
+    public: 76067358,
+    private: 76066276
+  },
+  pubKeyHash: 0,
+  scriptHash: 5,
+  wif: 128
+}, Pi = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "bcrt",
+  bech32Opnet: "opr",
+  bip32: {
+    public: 70617039,
+    private: 70615956
+  },
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+}, Ii = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "tb",
+  bech32Opnet: "opt",
+  bip32: {
+    public: 70617039,
+    private: 70615956
+  },
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+};
+function On(e) {
+  if (e.length < 8 || e.length > 72 || e[0] !== 48 || e[1] !== e.length - 2 || e[2] !== 2)
+    return !1;
+  const t = e[3];
+  if (t === 0 || 5 + t >= e.length || e[4 + t] !== 2)
+    return !1;
+  const r = e[5 + t];
+  return !(r === 0 || 6 + t + r !== e.length || e[4] & 128 || t > 1 && e[4] === 0 && !(e[5] & 128) || e[t + 6] & 128 || r > 1 && e[t + 6] === 0 && !(e[t + 7] & 128));
+}
+function Pn(e) {
+  if (e.length < 8)
+    throw new Error("DER sequence length is too short");
+  if (e.length > 72)
+    throw new Error("DER sequence length is too long");
+  if (e[0] !== 48)
+    throw new Error("Expected DER sequence");
+  if (e[1] !== e.length - 2)
+    throw new Error("DER sequence length is invalid");
+  if (e[2] !== 2)
+    throw new Error("Expected DER integer");
+  const t = e[3];
+  if (t === 0)
+    throw new Error("R length is zero");
+  if (5 + t >= e.length)
+    throw new Error("R length is too long");
+  if (e[4 + t] !== 2)
+    throw new Error("Expected DER integer (2)");
+  const r = e[5 + t];
+  if (r === 0)
+    throw new Error("S length is zero");
+  if (6 + t + r !== e.length)
+    throw new Error("S length is invalid");
+  if (e[4] & 128)
+    throw new Error("R value is negative");
+  if (t > 1 && e[4] === 0 && !(e[5] & 128))
+    throw new Error("R value excessively padded");
+  if (e[t + 6] & 128)
+    throw new Error("S value is negative");
+  if (r > 1 && e[t + 6] === 0 && !(e[t + 7] & 128))
+    throw new Error("S value excessively padded");
+  return {
+    r: e.slice(4, 4 + t),
+    s: e.slice(6 + t)
+  };
+}
+function In(e, t) {
+  const r = e.length, n = t.length;
+  if (r === 0)
+    throw new Error("R length is zero");
+  if (n === 0)
+    throw new Error("S length is zero");
+  if (r > 33)
+    throw new Error("R length is too long");
+  if (n > 33)
+    throw new Error("S length is too long");
+  if (e[0] & 128)
+    throw new Error("R value is negative");
+  if (t[0] & 128)
+    throw new Error("S value is negative");
+  if (r > 1 && e[0] === 0 && !(e[1] & 128))
+    throw new Error("R value excessively padded");
+  if (n > 1 && t[0] === 0 && !(t[1] & 128))
+    throw new Error("S value excessively padded");
+  const s = h.allocUnsafe(6 + r + n);
+  return s[0] = 48, s[1] = s.length - 2, s[2] = 2, s[3] = e.length, e.copy(s, 4), s[4 + r] = 2, s[5 + r] = t.length, t.copy(s, 6 + r), s;
+}
+const E = {
+  OP_FALSE: 0,
+  OP_0: 0,
+  OP_PUSHDATA1: 76,
+  OP_PUSHDATA2: 77,
+  OP_PUSHDATA4: 78,
+  OP_1NEGATE: 79,
+  OP_RESERVED: 80,
+  OP_TRUE: 81,
+  OP_1: 81,
+  OP_2: 82,
+  OP_3: 83,
+  OP_4: 84,
+  OP_5: 85,
+  OP_6: 86,
+  OP_7: 87,
+  OP_8: 88,
+  OP_9: 89,
+  OP_10: 90,
+  OP_11: 91,
+  OP_12: 92,
+  OP_13: 93,
+  OP_14: 94,
+  OP_15: 95,
+  OP_16: 96,
+  OP_NOP: 97,
+  OP_VER: 98,
+  OP_IF: 99,
+  OP_NOTIF: 100,
+  OP_VERIF: 101,
+  OP_VERNOTIF: 102,
+  OP_ELSE: 103,
+  OP_ENDIF: 104,
+  OP_VERIFY: 105,
+  OP_RETURN: 106,
+  OP_TOALTSTACK: 107,
+  OP_FROMALTSTACK: 108,
+  OP_2DROP: 109,
+  OP_2DUP: 110,
+  OP_3DUP: 111,
+  OP_2OVER: 112,
+  OP_2ROT: 113,
+  OP_2SWAP: 114,
+  OP_IFDUP: 115,
+  OP_DEPTH: 116,
+  OP_DROP: 117,
+  OP_DUP: 118,
+  OP_NIP: 119,
+  OP_OVER: 120,
+  OP_PICK: 121,
+  OP_ROLL: 122,
+  OP_ROT: 123,
+  OP_SWAP: 124,
+  OP_TUCK: 125,
+  OP_CAT: 126,
+  OP_SUBSTR: 127,
+  OP_LEFT: 128,
+  OP_RIGHT: 129,
+  OP_SIZE: 130,
+  OP_INVERT: 131,
+  OP_AND: 132,
+  OP_OR: 133,
+  OP_XOR: 134,
+  OP_EQUAL: 135,
+  OP_EQUALVERIFY: 136,
+  OP_RESERVED1: 137,
+  OP_RESERVED2: 138,
+  OP_1ADD: 139,
+  OP_1SUB: 140,
+  OP_2MUL: 141,
+  OP_2DIV: 142,
+  OP_NEGATE: 143,
+  OP_ABS: 144,
+  OP_NOT: 145,
+  OP_0NOTEQUAL: 146,
+  OP_ADD: 147,
+  OP_SUB: 148,
+  OP_MUL: 149,
+  OP_DIV: 150,
+  OP_MOD: 151,
+  OP_LSHIFT: 152,
+  OP_RSHIFT: 153,
+  OP_BOOLAND: 154,
+  OP_BOOLOR: 155,
+  OP_NUMEQUAL: 156,
+  OP_NUMEQUALVERIFY: 157,
+  OP_NUMNOTEQUAL: 158,
+  OP_LESSTHAN: 159,
+  OP_GREATERTHAN: 160,
+  OP_LESSTHANOREQUAL: 161,
+  OP_GREATERTHANOREQUAL: 162,
+  OP_MIN: 163,
+  OP_MAX: 164,
+  OP_WITHIN: 165,
+  OP_RIPEMD160: 166,
+  OP_SHA1: 167,
+  OP_SHA256: 168,
+  OP_HASH160: 169,
+  OP_HASH256: 170,
+  OP_CODESEPARATOR: 171,
+  OP_CHECKSIG: 172,
+  OP_CHECKSIGVERIFY: 173,
+  OP_CHECKMULTISIG: 174,
+  OP_CHECKMULTISIGVERIFY: 175,
+  OP_NOP1: 176,
+  OP_NOP2: 177,
+  OP_CHECKLOCKTIMEVERIFY: 177,
+  OP_NOP3: 178,
+  OP_CHECKSEQUENCEVERIFY: 178,
+  OP_NOP4: 179,
+  OP_NOP5: 180,
+  OP_NOP6: 181,
+  OP_NOP7: 182,
+  OP_NOP8: 183,
+  OP_NOP9: 184,
+  OP_NOP10: 185,
+  OP_CHECKSIGADD: 186,
+  OP_PUBKEYHASH: 253,
+  OP_PUBKEY: 254,
+  OP_INVALIDOPCODE: 255
+}, br = {};
+for (const e of Object.keys(E)) {
+  const t = E[e];
+  br[t] = e;
+}
+function Tr(e) {
+  return e < E.OP_PUSHDATA1 ? 1 : e <= 255 ? 2 : e <= 65535 ? 3 : 5;
+}
+function An(e, t, r) {
+  const n = Tr(t);
+  return n === 1 ? e.writeUInt8(t, r) : n === 2 ? (e.writeUInt8(E.OP_PUSHDATA1, r), e.writeUInt8(t, r + 1)) : n === 3 ? (e.writeUInt8(E.OP_PUSHDATA2, r), e.writeUInt16LE(t, r + 1)) : (e.writeUInt8(E.OP_PUSHDATA4, r), e.writeUInt32LE(t, r + 1)), n;
+}
+function Hn(e, t) {
+  const r = e.readUInt8(t);
+  let n, s;
+  if (r < E.OP_PUSHDATA1)
+    n = r, s = 1;
+  else if (r === E.OP_PUSHDATA1) {
+    if (t + 2 > e.length)
+      return null;
+    n = e.readUInt8(t + 1), s = 2;
+  } else if (r === E.OP_PUSHDATA2) {
+    if (t + 3 > e.length)
+      return null;
+    n = e.readUInt16LE(t + 1), s = 3;
+  } else {
+    if (t + 5 > e.length)
+      return null;
+    if (r !== E.OP_PUSHDATA4)
+      throw new Error("Unexpected opcode");
+    n = e.readUInt32LE(t + 1), s = 5;
+  }
+  return {
+    opcode: r,
+    number: n,
+    size: s
+  };
+}
+function vn(e, t, r) {
+  t = t || 4, r = r === void 0 ? !0 : r;
+  const n = e.length;
+  if (n === 0)
+    return 0;
+  if (n > t)
+    throw new TypeError("Script number overflow");
+  if (r && (e[n - 1] & 127) === 0 && (n <= 1 || (e[n - 2] & 128) === 0))
+    throw new Error("Non-minimally encoded script number");
+  if (n === 5) {
+    const i = e.readUInt32LE(0), o = e.readUInt8(4);
+    return o & 128 ? -((o & -129) * 4294967296 + i) : o * 4294967296 + i;
+  }
+  let s = 0;
+  for (let i = 0; i < n; ++i)
+    s |= e[i] << 8 * i;
+  return e[n - 1] & 128 ? -(s & ~(128 << 8 * (n - 1))) : s;
+}
+function kn(e) {
+  return e > 2147483647 ? 5 : e > 8388607 ? 4 : e > 32767 ? 3 : e > 127 ? 2 : e > 0 ? 1 : 0;
+}
+function Or(e) {
+  let t = Math.abs(e);
+  const r = kn(t), n = h.allocUnsafe(r), s = e < 0;
+  for (let i = 0; i < r; ++i)
+    n.writeUInt8(t & 255, i), t >>= 8;
+  return n[r - 1] & 128 ? n.writeUInt8(s ? 128 : 0, r - 1) : s && (n[r - 1] |= 128), n;
+}
+const Nn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: vn,
+  encode: Or
+}, Symbol.toStringTag, { value: "Module" })), f = _n, Rt = N.alloc(32, 0), Bt = N.from("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f", "hex");
+function ie(e, t) {
+  return e.length !== t.length ? !1 : e.every((r, n) => r.equals(t[n]));
+}
+function L(e) {
+  if (!N.isBuffer(e) || e.length < 33)
+    return !1;
+  const t = e[0], r = e.slice(1, 33);
+  if (r.compare(Rt) === 0 || r.compare(Bt) >= 0)
+    return !1;
+  if ((t === 2 || t === 3) && e.length === 33)
+    return !0;
+  if (e.length !== 65)
+    return !1;
+  const n = e.slice(33);
+  return n.compare(Rt) === 0 || n.compare(Bt) >= 0 ? !1 : t === 4 || t === 6 || t === 7;
+}
+const Un = 21 * 1e14;
+function Le(e) {
+  return f.UInt53(e) && e <= Un;
+}
+const Ee = 254;
+function Ze(e) {
+  return !e || !("output" in e) || !N.isBuffer(e.output) ? !1 : e.version !== void 0 ? (e.version & Ee) === e.version : !0;
+}
+function Pt(e) {
+  return ve(e) ? e.length !== 2 ? !1 : e.every((t) => Pt(t)) : Ze(e);
+}
+const xn = f.BufferN(32), Cn = f.BufferN(20), lt = f.BufferN(32), Se = f.Number, ve = f.Array, Rn = f.Boolean, Pr = f.String, V = f.Buffer, Ir = f.Hex, dt = f.maybe, D = f.tuple, Ar = f.UInt8, z = f.UInt32, Bn = f.Function, Hr = f.BufferN, vr = f.Null, Fn = f.oneOf, Qe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Array: ve,
+  Boolean: Rn,
+  Buffer: V,
+  Buffer256bit: xn,
+  BufferN: Hr,
+  Function: Bn,
+  Hash160bit: Cn,
+  Hash256bit: lt,
+  Hex: Ir,
+  Null: vr,
+  Number: Se,
+  Satoshi: Le,
+  String: Pr,
+  TAPLEAF_VERSION_MASK: Ee,
+  UInt32: z,
+  UInt8: Ar,
+  isPoint: L,
+  isTapleaf: Ze,
+  isTaptree: Pt,
+  maybe: dt,
+  oneOf: Fn,
+  stacksEqual: ie,
+  tuple: D,
+  typeforce: f
+}, Symbol.toStringTag, { value: "Module" })), { typeforce: Vn } = Qe, Ft = h.alloc(1, 0);
+function Vt(e) {
+  let t = 0;
+  for (; e[t] === 0; )
+    ++t;
+  return t === e.length ? Ft : (e = e.slice(t), e[0] & 128 ? h.concat([Ft, e], 1 + e.length) : e);
+}
+function Lt(e) {
+  e[0] === 0 && (e = e.slice(1));
+  const t = h.alloc(32, 0), r = Math.max(0, 32 - e.length);
+  return e.copy(t, r), t;
+}
+function Ln(e) {
+  const t = e.readUInt8(e.length - 1);
+  if (!et(t))
+    throw new Error("Invalid hashType " + t);
+  const r = Pn(e.slice(0, -1)), n = Lt(r.r), s = Lt(r.s);
+  return { signature: h.concat([n, s], 64), hashType: t };
+}
+function Wn(e, t) {
+  if (Vn({
+    signature: Hr(64),
+    hashType: Ar
+  }, { signature: e, hashType: t }), !et(t))
+    throw new Error("Invalid hashType " + t);
+  const r = h.allocUnsafe(1);
+  r.writeUInt8(t, 0);
+  const n = Vt(e.slice(0, 32)), s = Vt(e.slice(32, 64));
+  return h.concat([In(n, s), r]);
+}
+const Gn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: Ln,
+  encode: Wn
+}, Symbol.toStringTag, { value: "Module" })), { typeforce: Ie } = Qe, kr = E.OP_RESERVED;
+function Kn(e) {
+  return Se(e) && (e === E.OP_0 || e >= E.OP_1 && e <= E.OP_16 || e === E.OP_1NEGATE);
+}
+function Nr(e) {
+  return V(e) || Kn(e);
+}
+function Je(e) {
+  return ve(e) && e.every(Nr);
+}
+function It(e) {
+  return e.length - e.filter(Nr).length;
+}
+function qe(e) {
+  if (e.length === 0)
+    return E.OP_0;
+  if (e.length === 1) {
+    if (e[0] >= 1 && e[0] <= 16)
+      return kr + e[0];
+    if (e[0] === 129)
+      return E.OP_1NEGATE;
+  }
+}
+function Ur(e) {
+  return h.isBuffer(e);
+}
+function Mn(e) {
+  return ve(e);
+}
+function $e(e) {
+  return h.isBuffer(e);
+}
+function H(e) {
+  if (Ur(e))
+    return e;
+  Ie(ve, e);
+  const t = e.reduce((s, i) => $e(i) ? i.length === 1 && qe(i) !== void 0 ? s + 1 : s + Tr(i.length) + i.length : s + 1, 0), r = h.allocUnsafe(t);
+  let n = 0;
+  if (e.forEach((s) => {
+    if ($e(s)) {
+      const i = qe(s);
+      if (i !== void 0) {
+        r.writeUInt8(i, n), n += 1;
+        return;
+      }
+      n += An(r, s.length, n), s.copy(r, n), n += s.length;
+    } else
+      r.writeUInt8(s, n), n += 1;
+  }), n !== r.length)
+    throw new Error("Could not decode chunks");
+  return r;
+}
+function b(e) {
+  if (Mn(e))
+    return e;
+  Ie(V, e);
+  const t = [];
+  let r = 0;
+  for (; r < e.length; ) {
+    const n = e[r];
+    if (n > E.OP_0 && n <= E.OP_PUSHDATA4) {
+      const s = Hn(e, r);
+      if (s === null || (r += s.size, r + s.number > e.length))
+        return null;
+      const i = e.slice(r, r + s.number);
+      r += s.number;
+      const o = qe(i);
+      o !== void 0 ? t.push(o) : t.push(i);
+    } else
+      t.push(n), r += 1;
+  }
+  return t;
+}
+function xr(e) {
+  if (Ur(e) && (e = b(e)), !e)
+    throw new Error("Could not convert invalid chunks to ASM");
+  return e.map((t) => {
+    if ($e(t)) {
+      const r = qe(t);
+      if (r === void 0)
+        return t.toString("hex");
+      t = r;
+    }
+    return br[t];
+  }).join(" ");
+}
+function qn(e) {
+  return Ie(Pr, e), H(e.split(" ").map((t) => E[t] !== void 0 ? E[t] : (Ie(Ir, t), h.from(t, "hex"))));
+}
+function Cr(e) {
+  return e = b(e), Ie(Je, e), e.map((t) => $e(t) ? t : t === E.OP_0 ? h.allocUnsafe(0) : Or(t - kr));
+}
+function Rr(e) {
+  return L(e);
+}
+function et(e) {
+  const t = e & -129;
+  return t > 0 && t < 4;
+}
+function Y(e) {
+  return !h.isBuffer(e) || !et(e[e.length - 1]) ? !1 : On(e.slice(0, -1));
+}
+const $n = Nn, fe = Gn, Xn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  compile: H,
+  countNonPushOnlyOPs: It,
+  decompile: b,
+  fromASM: qn,
+  isCanonicalPubKey: Rr,
+  isCanonicalScriptSignature: Y,
+  isDefinedHashType: et,
+  isPushOnly: Je,
+  number: $n,
+  opcodes: E,
+  signature: fe,
+  toASM: xr,
+  toStack: Cr
+}, Symbol.toStringTag, { value: "Module" })), tt = 40, rt = 2, nt = 15, Dn = 16, wt = 16, At = 2, Ht = 80, zn = "WARNING: Sending to a future segwit version address can lead to loss of funds. End users MUST be warned carefully in the GUI and asked if they wish to proceed with caution. Wallets should verify the segwit version from the output of fromBech32, then decide when it is safe to use which version of segwit.", jn = (e) => {
+  try {
+    const t = h.from(e.subarray(2));
+    if (t.length < rt || t.length > tt)
+      throw new TypeError("Invalid program length for segwit address");
+    const r = e[0] - Ht;
+    if (r < At || r > nt + 1)
+      throw new TypeError("Invalid version for segwit address");
+    if (r === 1)
+      throw new TypeError("taproot");
+    return !0;
+  } catch {
+  }
+  return !1;
+};
+function Yn(e, t) {
+  if (!h.isBuffer(e))
+    throw new TypeError("output must be a Buffer");
+  if (!t.bech32Opnet)
+    throw new Error("Network does not support opnet");
+  const r = e[0];
+  let n = 1, s;
+  if (e[1] < 76)
+    s = e[1], n = 2;
+  else if (e[1] === 76)
+    s = e[2], n = 3;
+  else
+    throw new TypeError("Unsupported push opcode in script");
+  const i = h.from(e.subarray(n, n + s));
+  if (i.length < rt || i.length > tt)
+    throw new TypeError("Invalid program length for segwit address");
+  const o = r === E.OP_0 ? 0 : r >= E.OP_1 && r <= E.OP_16 ? r - (E.OP_1 - 1) : -1;
+  if (o < nt || o > Dn)
+    throw new TypeError(`Invalid segwit version ${o}`);
+  const u = [o, ...P.bech32m.toWords(i)];
+  return P.bech32m.encode(t.bech32Opnet, u);
+}
+function Zn(e, t) {
+  const r = h.from(e.subarray(2));
+  if (r.length < rt || r.length > tt)
+    throw new TypeError("Invalid program length for segwit address");
+  const n = e[0] - Ht;
+  if (n < At || n > nt)
+    throw new TypeError("Invalid version for segwit address");
+  if (e[1] !== r.length)
+    throw new TypeError(`Invalid script for segwit address ${e[1]} !== ${r.length}`);
+  return Jn(r, n, t.bech32, t.bech32Opnet);
+}
+function Qn(e) {
+  const t = h.from(Oe.decode(e));
+  if (t.length < 21)
+    throw new TypeError(e + " is too short");
+  if (t.length > 21)
+    throw new TypeError(e + " is too long");
+  const r = t.readUInt8(0), n = h.from(t.subarray(1));
+  return { version: r, hash: n };
+}
+function vt(e) {
+  let t, r;
+  try {
+    t = P.bech32.decode(e);
+  } catch {
+  }
+  if (t) {
+    if (r = t.words[0], r !== 0)
+      throw new TypeError(e + " uses wrong encoding");
+  } else if (t = P.bech32m.decode(e), r = t.words[0], r === 0)
+    throw new TypeError(e + " uses wrong encoding");
+  const n = P.bech32.fromWords(t.words.slice(1));
+  return {
+    version: r,
+    prefix: t.prefix,
+    data: h.from(n)
+  };
+}
+function Jn(e, t, r, n) {
+  const s = P.bech32.toWords(e);
+  return s.unshift(t), t === wt && n ? P.bech32m.encode(n, s) : t === 0 ? P.bech32.encode(r, s) : P.bech32m.encode(r, s);
+}
+function es(e, t) {
+  t = t || K;
+  try {
+    return de({ output: e, network: t }).address;
+  } catch {
+  }
+  try {
+    return he({ output: e, network: t }).address;
+  } catch {
+  }
+  try {
+    return xe({ output: e, network: t }).address;
+  } catch {
+  }
+  try {
+    return le({ output: e, network: t }).address;
+  } catch {
+  }
+  try {
+    return pe({ output: e, network: t }).address;
+  } catch {
+  }
+  try {
+    return Yn(e, t);
+  } catch {
+  }
+  try {
+    return Zn(e, t);
+  } catch {
+  }
+  throw new Error(xr(e) + " has no matching Address");
+}
+function ts(e, t) {
+  t = t || K;
+  let r, n;
+  try {
+    r = Qn(e);
+  } catch {
+  }
+  if (r) {
+    if (r.version === t.pubKeyHash)
+      return de({ hash: r.hash }).output;
+    if (r.version === t.scriptHash)
+      return he({ hash: r.hash }).output;
+  } else {
+    try {
+      n = vt(e);
+    } catch {
+    }
+    if (n) {
+      if (n.prefix !== t.bech32 && t.bech32Opnet && n.prefix !== t.bech32Opnet)
+        throw new Error(e + " has an invalid prefix");
+      if (n.version === 0) {
+        if (n.data.length === 20)
+          return xe({ hash: n.data }).output;
+        if (n.data.length === 32)
+          return le({ hash: n.data }).output;
+      } else if (n.version === 1) {
+        if (n.data.length === 32)
+          return pe({ pubkey: n.data }).output;
+      } else if (n.version === wt) {
+        if (!t.bech32Opnet)
+          throw new Error(e + " has an invalid prefix");
+        return tn({
+          program: n.data,
+          network: t
+        }).output;
+      } else if (n.version >= At && n.version <= nt && n.data.length >= rt && n.data.length <= tt)
+        return n.version !== wt && console.warn(zn), H([
+          n.version + Ht,
+          n.data
+        ]);
+    }
+  }
+  return h.from(e, "hex");
+}
+function rs(e) {
+  return h.from(_r(Uint8Array.from(e)));
+}
+function ns(e) {
+  return h.from(Tn(Uint8Array.from(e)));
+}
+function M(e) {
+  return h.from(Me(Uint8Array.from(e)));
+}
+function x(e) {
+  return h.from(_r(Me(Uint8Array.from(e))));
+}
+function te(e) {
+  return h.from(Me(Me(Uint8Array.from(e))));
+}
+const ss = [
+  "BIP0340/challenge",
+  "BIP0340/aux",
+  "BIP0340/nonce",
+  "TapLeaf",
+  "TapBranch",
+  "TapSighash",
+  "TapTweak",
+  "KeyAgg list",
+  "KeyAgg coefficient"
+], Br = {
+  "BIP0340/challenge": h.from([
+    123,
+    181,
+    45,
+    122,
+    159,
+    239,
+    88,
+    50,
+    62,
+    177,
+    191,
+    122,
+    64,
+    125,
+    179,
+    130,
+    210,
+    243,
+    242,
+    216,
+    27,
+    177,
+    34,
+    79,
+    73,
+    254,
+    81,
+    143,
+    109,
+    72,
+    211,
+    124,
+    123,
+    181,
+    45,
+    122,
+    159,
+    239,
+    88,
+    50,
+    62,
+    177,
+    191,
+    122,
+    64,
+    125,
+    179,
+    130,
+    210,
+    243,
+    242,
+    216,
+    27,
+    177,
+    34,
+    79,
+    73,
+    254,
+    81,
+    143,
+    109,
+    72,
+    211,
+    124
+  ]),
+  "BIP0340/aux": h.from([
+    241,
+    239,
+    78,
+    94,
+    192,
+    99,
+    202,
+    218,
+    109,
+    148,
+    202,
+    250,
+    157,
+    152,
+    126,
+    160,
+    105,
+    38,
+    88,
+    57,
+    236,
+    193,
+    31,
+    151,
+    45,
+    119,
+    165,
+    46,
+    216,
+    193,
+    204,
+    144,
+    241,
+    239,
+    78,
+    94,
+    192,
+    99,
+    202,
+    218,
+    109,
+    148,
+    202,
+    250,
+    157,
+    152,
+    126,
+    160,
+    105,
+    38,
+    88,
+    57,
+    236,
+    193,
+    31,
+    151,
+    45,
+    119,
+    165,
+    46,
+    216,
+    193,
+    204,
+    144
+  ]),
+  "BIP0340/nonce": h.from([
+    7,
+    73,
+    119,
+    52,
+    167,
+    155,
+    203,
+    53,
+    91,
+    155,
+    140,
+    125,
+    3,
+    79,
+    18,
+    28,
+    244,
+    52,
+    215,
+    62,
+    247,
+    45,
+    218,
+    25,
+    135,
+    0,
+    97,
+    251,
+    82,
+    191,
+    235,
+    47,
+    7,
+    73,
+    119,
+    52,
+    167,
+    155,
+    203,
+    53,
+    91,
+    155,
+    140,
+    125,
+    3,
+    79,
+    18,
+    28,
+    244,
+    52,
+    215,
+    62,
+    247,
+    45,
+    218,
+    25,
+    135,
+    0,
+    97,
+    251,
+    82,
+    191,
+    235,
+    47
+  ]),
+  TapLeaf: h.from([
+    174,
+    234,
+    143,
+    220,
+    66,
+    8,
+    152,
+    49,
+    5,
+    115,
+    75,
+    88,
+    8,
+    29,
+    30,
+    38,
+    56,
+    211,
+    95,
+    28,
+    181,
+    64,
+    8,
+    212,
+    211,
+    87,
+    202,
+    3,
+    190,
+    120,
+    233,
+    238,
+    174,
+    234,
+    143,
+    220,
+    66,
+    8,
+    152,
+    49,
+    5,
+    115,
+    75,
+    88,
+    8,
+    29,
+    30,
+    38,
+    56,
+    211,
+    95,
+    28,
+    181,
+    64,
+    8,
+    212,
+    211,
+    87,
+    202,
+    3,
+    190,
+    120,
+    233,
+    238
+  ]),
+  TapBranch: h.from([
+    25,
+    65,
+    161,
+    242,
+    229,
+    110,
+    185,
+    95,
+    162,
+    169,
+    241,
+    148,
+    190,
+    92,
+    1,
+    247,
+    33,
+    111,
+    51,
+    237,
+    130,
+    176,
+    145,
+    70,
+    52,
+    144,
+    208,
+    91,
+    245,
+    22,
+    160,
+    21,
+    25,
+    65,
+    161,
+    242,
+    229,
+    110,
+    185,
+    95,
+    162,
+    169,
+    241,
+    148,
+    190,
+    92,
+    1,
+    247,
+    33,
+    111,
+    51,
+    237,
+    130,
+    176,
+    145,
+    70,
+    52,
+    144,
+    208,
+    91,
+    245,
+    22,
+    160,
+    21
+  ]),
+  TapSighash: h.from([
+    244,
+    10,
+    72,
+    223,
+    75,
+    42,
+    112,
+    200,
+    180,
+    146,
+    75,
+    242,
+    101,
+    70,
+    97,
+    237,
+    61,
+    149,
+    253,
+    102,
+    163,
+    19,
+    235,
+    135,
+    35,
+    117,
+    151,
+    198,
+    40,
+    228,
+    160,
+    49,
+    244,
+    10,
+    72,
+    223,
+    75,
+    42,
+    112,
+    200,
+    180,
+    146,
+    75,
+    242,
+    101,
+    70,
+    97,
+    237,
+    61,
+    149,
+    253,
+    102,
+    163,
+    19,
+    235,
+    135,
+    35,
+    117,
+    151,
+    198,
+    40,
+    228,
+    160,
+    49
+  ]),
+  TapTweak: h.from([
+    232,
+    15,
+    225,
+    99,
+    156,
+    156,
+    160,
+    80,
+    227,
+    175,
+    27,
+    57,
+    193,
+    67,
+    198,
+    62,
+    66,
+    156,
+    188,
+    235,
+    21,
+    217,
+    64,
+    251,
+    181,
+    197,
+    161,
+    244,
+    175,
+    87,
+    197,
+    233,
+    232,
+    15,
+    225,
+    99,
+    156,
+    156,
+    160,
+    80,
+    227,
+    175,
+    27,
+    57,
+    193,
+    67,
+    198,
+    62,
+    66,
+    156,
+    188,
+    235,
+    21,
+    217,
+    64,
+    251,
+    181,
+    197,
+    161,
+    244,
+    175,
+    87,
+    197,
+    233
+  ]),
+  "KeyAgg list": h.from([
+    72,
+    28,
+    151,
+    28,
+    60,
+    11,
+    70,
+    215,
+    240,
+    178,
+    117,
+    174,
+    89,
+    141,
+    78,
+    44,
+    126,
+    215,
+    49,
+    156,
+    89,
+    74,
+    92,
+    110,
+    199,
+    158,
+    160,
+    212,
+    153,
+    2,
+    148,
+    240,
+    72,
+    28,
+    151,
+    28,
+    60,
+    11,
+    70,
+    215,
+    240,
+    178,
+    117,
+    174,
+    89,
+    141,
+    78,
+    44,
+    126,
+    215,
+    49,
+    156,
+    89,
+    74,
+    92,
+    110,
+    199,
+    158,
+    160,
+    212,
+    153,
+    2,
+    148,
+    240
+  ]),
+  "KeyAgg coefficient": h.from([
+    191,
+    201,
+    4,
+    3,
+    77,
+    28,
+    136,
+    232,
+    200,
+    14,
+    34,
+    229,
+    61,
+    36,
+    86,
+    109,
+    100,
+    130,
+    78,
+    214,
+    66,
+    114,
+    129,
+    192,
+    145,
+    0,
+    249,
+    77,
+    205,
+    82,
+    201,
+    129,
+    191,
+    201,
+    4,
+    3,
+    77,
+    28,
+    136,
+    232,
+    200,
+    14,
+    34,
+    229,
+    61,
+    36,
+    86,
+    109,
+    100,
+    130,
+    78,
+    214,
+    66,
+    114,
+    129,
+    192,
+    145,
+    0,
+    249,
+    77,
+    205,
+    82,
+    201,
+    129
+  ])
+};
+function ke(e, t) {
+  return M(h.concat([Br[e], t]));
+}
+const is = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TAGGED_HASH_PREFIXES: Br,
+  TAGS: ss,
+  hash160: x,
+  hash256: te,
+  ripemd160: rs,
+  sha1: ns,
+  sha256: M,
+  taggedHash: ke
+}, Symbol.toStringTag, { value: "Module" })), _e = {};
+function Ai(e) {
+  e ? e !== _e.eccLib && (os(e), _e.eccLib = e) : _e.eccLib = e;
+}
+function Fr() {
+  if (!_e.eccLib)
+    throw new Error("No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance");
+  return _e.eccLib;
+}
+const Z = (e) => h.from(e, "hex");
+function os(e) {
+  F(typeof e.isXOnlyPoint == "function"), F(e.isXOnlyPoint(Z("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"))), F(e.isXOnlyPoint(Z("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e"))), F(e.isXOnlyPoint(Z("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"))), F(e.isXOnlyPoint(Z("0000000000000000000000000000000000000000000000000000000000000001"))), F(!e.isXOnlyPoint(Z("0000000000000000000000000000000000000000000000000000000000000000"))), F(!e.isXOnlyPoint(Z("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"))), F(typeof e.xOnlyPointAddTweak == "function"), us.forEach((t) => {
+    const r = e.xOnlyPointAddTweak(Z(t.pubkey), Z(t.tweak));
+    t.result === null ? F(r === null) : (F(r !== null), F(r.parity === t.parity), F(h.from(r.xOnlyPubkey).equals(Z(t.result))));
+  });
+}
+function F(e) {
+  if (!e)
+    throw new Error("ecc library invalid");
+}
+const us = [
+  {
+    pubkey: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+    tweak: "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
+    parity: -1,
+    result: null
+  },
+  {
+    pubkey: "1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b",
+    tweak: "a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac",
+    parity: 1,
+    result: "e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf"
+  },
+  {
+    pubkey: "2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991",
+    tweak: "823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47",
+    parity: 0,
+    result: "9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c"
+  }
+], { typeforce: Vr } = Qe;
+function Lr(e, t) {
+  if (typeof e != "number")
+    throw new Error("cannot write a non-number as a number");
+  if (e < 0)
+    throw new Error("specified a negative value for writing an unsigned value");
+  if (e > t)
+    throw new Error("RangeError: value out of range");
+  if (Math.floor(e) !== e)
+    throw new Error("value has a fractional component");
+}
+function fs(e, t) {
+  const r = e.readUInt32LE(t);
+  let n = e.readUInt32LE(t + 4);
+  return n *= 4294967296, Lr(n + r, 9007199254740991), n + r;
+}
+function cs(e, t, r) {
+  return Lr(t, 9007199254740991), e.writeInt32LE(t & -1, r), e.writeUInt32LE(Math.floor(t / 4294967296), r + 4), r + 8;
+}
+function kt(e) {
+  if (e.length < 1)
+    return e;
+  let t = e.length - 1, r = 0;
+  for (let n = 0; n < e.length / 2; n++)
+    r = e[n], e[n] = e[t], e[t] = r, t--;
+  return e;
+}
+function Wt(e) {
+  const t = h.allocUnsafe(e.length);
+  return e.copy(t), t;
+}
+class k {
+  constructor(t, r = 0) {
+    this.buffer = t, this.offset = r, Vr(D(V, z), [t, r]);
+  }
+  static withCapacity(t) {
+    return new k(h.alloc(t));
+  }
+  writeUInt8(t) {
+    this.offset = this.buffer.writeUInt8(t, this.offset);
+  }
+  writeInt32(t) {
+    this.offset = this.buffer.writeInt32LE(t, this.offset);
+  }
+  writeUInt32(t) {
+    this.offset = this.buffer.writeUInt32LE(t, this.offset);
+  }
+  writeUInt64(t) {
+    this.offset = cs(this.buffer, t, this.offset);
+  }
+  writeVarInt(t) {
+    const r = Sr(t, this.buffer, this.offset);
+    this.offset += r.bytes;
+  }
+  writeSlice(t) {
+    if (this.buffer.length < this.offset + t.length)
+      throw new Error("Cannot write slice out of bounds");
+    this.offset += t.copy(this.buffer, this.offset);
+  }
+  writeVarSlice(t) {
+    this.writeVarInt(t.length), this.writeSlice(t);
+  }
+  writeVector(t) {
+    this.writeVarInt(t.length), t.forEach((r) => this.writeVarSlice(r));
+  }
+  end() {
+    if (this.buffer.length === this.offset)
+      return this.buffer;
+    throw new Error(`buffer size ${this.buffer.length}, offset ${this.offset}`);
+  }
+}
+class as {
+  constructor(t, r = 0) {
+    this.buffer = t, this.offset = r, Vr(D(V, z), [t, r]);
+  }
+  readUInt8() {
+    const t = this.buffer.readUInt8(this.offset);
+    return this.offset++, t;
+  }
+  readInt32() {
+    const t = this.buffer.readInt32LE(this.offset);
+    return this.offset += 4, t;
+  }
+  readUInt32() {
+    const t = this.buffer.readUInt32LE(this.offset);
+    return this.offset += 4, t;
+  }
+  readUInt64() {
+    const t = fs(this.buffer, this.offset);
+    return this.offset += 8, t;
+  }
+  readVarInt() {
+    const t = bn(this.buffer, this.offset);
+    return this.offset += t.bytes, t.numberValue || 0;
+  }
+  readSlice(t) {
+    if (this.buffer.length < this.offset + t)
+      throw new Error("Cannot read slice out of bounds");
+    const r = h.from(this.buffer.subarray(this.offset, this.offset + t));
+    return this.offset += t, r;
+  }
+  readVarSlice() {
+    return this.readSlice(this.readVarInt());
+  }
+  readVector() {
+    const t = this.readVarInt(), r = [];
+    for (let n = 0; n < t; n++)
+      r.push(this.readVarSlice());
+    return r;
+  }
+}
+const Nt = 192, Wr = 128, hs = (e) => "left" in e && "right" in e;
+function Xe(e, t) {
+  if (e.length < 33)
+    throw new TypeError(`The control-block length is too small. Got ${e.length}, expected min 33.`);
+  const r = (e.length - 33) / 32;
+  let n = t;
+  for (let s = 0; s < r; s++) {
+    const i = e.slice(33 + 32 * s, 65 + 32 * s);
+    n.compare(i) < 0 ? n = gt(n, i) : n = gt(i, n);
+  }
+  return n;
+}
+function De(e) {
+  if (Ze(e))
+    return { hash: j(e) };
+  const t = [De(e[0]), De(e[1])];
+  t.sort((s, i) => s.hash.compare(i.hash));
+  const [r, n] = t;
+  return {
+    hash: gt(r.hash, n.hash),
+    left: r,
+    right: n
+  };
+}
+function Ae(e, t) {
+  if (hs(e)) {
+    const r = Ae(e.left, t);
+    if (r !== void 0)
+      return [...r, e.right.hash];
+    const n = Ae(e.right, t);
+    if (n !== void 0)
+      return [...n, e.left.hash];
+  } else if (e.hash.equals(t))
+    return [];
+}
+function j(e) {
+  const t = e.version || Nt;
+  return ke("TapLeaf", N.concat([N.from([t]), ps(e.output)]));
+}
+function Gr(e, t) {
+  return ke("TapTweak", N.concat(t ? [e, t] : [e]));
+}
+function ye(e, t) {
+  if (!N.isBuffer(e) || e.length !== 32 || t && t.length !== 32)
+    return null;
+  const r = Gr(e, t), n = Fr().xOnlyPointAddTweak(e, r);
+  return !n || n.xOnlyPubkey === null ? null : {
+    parity: n.parity,
+    x: N.from(n.xOnlyPubkey)
+  };
+}
+function gt(e, t) {
+  return ke("TapBranch", N.concat([e, t]));
+}
+function ps(e) {
+  const t = Pe(e.length), r = N.allocUnsafe(t);
+  return Sr(e.length, r), N.concat([r, e]);
+}
+function w(e, t, r) {
+  Object.defineProperty(e, t, {
+    configurable: !0,
+    enumerable: !0,
+    get() {
+      const n = r.call(this);
+      return this[t] = n, n;
+    },
+    set(n) {
+      Object.defineProperty(this, t, {
+        configurable: !0,
+        enumerable: !0,
+        value: n,
+        writable: !0
+      });
+    }
+  });
+}
+function C(e) {
+  let t;
+  return () => (t !== void 0 || (t = e()), t);
+}
+const Gt = E;
+function ls(e, t) {
+  if (!e.data && !e.output)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    network: f.maybe(f.Object),
+    output: f.maybe(f.Buffer),
+    data: f.maybe(f.arrayOf(f.Buffer))
+  }, e);
+  const r = e.network || K, n = { name: G.Embed, network: r, data: [] };
+  if (w(n, "output", () => {
+    if (e.data)
+      return H([Gt.OP_RETURN].concat(e.data));
+  }), w(n, "data", () => {
+    if (!e.output)
+      return;
+    const s = b(e.output);
+    if (s != null)
+      return s.slice(1);
+  }), t.validate && e.output) {
+    const s = b(e.output);
+    if (s[0] !== Gt.OP_RETURN)
+      throw new TypeError("Output is invalid");
+    if (!s.slice(1).every(f.Buffer))
+      throw new TypeError("Output is invalid");
+    if (e.data && !ie(e.data, n.data))
+      throw new TypeError("Data mismatch");
+  }
+  return Object.assign(n, e);
+}
+const ue = E, Ce = ue.OP_RESERVED;
+function Ne(e, t) {
+  if (!e.input && !e.output && !(e.pubkeys && e.m !== void 0) && !e.signatures)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {});
+  function r(c) {
+    return Y(c) || (t.allowIncomplete && c === ue.OP_0) !== void 0;
+  }
+  f({
+    network: f.maybe(f.Object),
+    m: f.maybe(f.Number),
+    n: f.maybe(f.Number),
+    output: f.maybe(f.Buffer),
+    pubkeys: f.maybe(f.arrayOf(L)),
+    signatures: f.maybe(f.arrayOf(r)),
+    input: f.maybe(f.Buffer)
+  }, e);
+  const s = {
+    network: e.network || K,
+    name: G.P2MS
+  };
+  let i = [], o = !1;
+  function u(c) {
+    o || (o = !0, i = b(c), s.m = i[0] - Ce, s.n = i[i.length - 2] - Ce, s.pubkeys = i.slice(1, -2));
+  }
+  if (w(s, "output", () => {
+    if (e.m && s.n && e.pubkeys)
+      return H([].concat(Ce + e.m, e.pubkeys, Ce + s.n, ue.OP_CHECKMULTISIG));
+  }), w(s, "m", () => {
+    if (s.output)
+      return u(s.output), s.m;
+  }), w(s, "n", () => {
+    if (s.pubkeys)
+      return s.pubkeys.length;
+  }), w(s, "pubkeys", () => {
+    if (e.output)
+      return u(e.output), s.pubkeys;
+  }), w(s, "signatures", () => {
+    if (!e.input)
+      return;
+    const c = b(e.input);
+    if (c != null)
+      return c.slice(1);
+  }), w(s, "input", () => {
+    if (e.signatures)
+      return H([ue.OP_0].concat(e.signatures));
+  }), w(s, "witness", () => {
+    if (s.input)
+      return [];
+  }), w(s, "name", () => {
+    if (!(!s.m || !s.n))
+      return `p2ms(${s.m} of ${s.n})`;
+  }), t.validate) {
+    if (e.output) {
+      if (u(e.output), !f.Number(i[0]))
+        throw new TypeError("Output is invalid");
+      if (!f.Number(i[i.length - 2]))
+        throw new TypeError("Output is invalid");
+      if (i[i.length - 1] !== ue.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((c) => L(c)))
+        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 && !ie(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] !== ue.OP_0)
+        throw new TypeError("Input is invalid");
+      if (s.signatures.length === 0 || !s.signatures.every(r))
+        throw new TypeError("Input has invalid signature(s)");
+      if (e.signatures && !ie(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 Kt = E;
+function Ut(e, t) {
+  if (!e.input && !e.output && !e.pubkey && !e.input && !e.signature)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    network: f.maybe(f.Object),
+    output: f.maybe(f.Buffer),
+    pubkey: f.maybe(L),
+    signature: f.maybe(Y),
+    input: f.maybe(f.Buffer)
+  }, e);
+  const r = C(() => b(e.input)), n = e.network || K, s = {
+    name: G.P2PK,
+    network: n,
+    pubkey: void 0
+  };
+  if (w(s, "output", () => {
+    if (e.pubkey)
+      return H([e.pubkey, Kt.OP_CHECKSIG]);
+  }), w(s, "pubkey", () => {
+    if (e.output)
+      return e.output.slice(1, -1);
+  }), w(s, "signature", () => {
+    if (e.input)
+      return r()[0];
+  }), w(s, "input", () => {
+    if (e.signature)
+      return H([e.signature]);
+  }), w(s, "witness", () => {
+    if (s.input)
+      return [];
+  }), t.validate) {
+    if (e.output) {
+      if (e.output[e.output.length - 1] !== Kt.OP_CHECKSIG)
+        throw new TypeError("Output is invalid");
+      if (!L(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 (r().length !== 1)
+        throw new TypeError("Input is invalid");
+      if (!Y(s.signature))
+        throw new TypeError("Input has invalid signature");
+    }
+  }
+  return Object.assign(s, e);
+}
+const ds = {
+  p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+  n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+  b: 7n,
+  Gx: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+  Gy: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+}, { p: se, n: Kr, Gx: ws, Gy: gs, b: Mr } = ds, We = 32, mt = 64, W = (e = "") => {
+  throw new Error(e);
+}, qr = (e) => typeof e == "bigint", $r = (e) => typeof e == "string", ms = (e) => e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array", He = (e, t) => !ms(e) || typeof t == "number" && t > 0 && e.length !== t ? W("Uint8Array expected") : e, Xr = (e) => new Uint8Array(e), ys = (e) => Uint8Array.from(e), Dr = (e, t) => e.toString(16).padStart(t, "0"), zr = (e) => Array.from(He(e)).map((t) => Dr(t, 2)).join(""), Q = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }, Mt = (e) => {
+  if (e >= Q._0 && e <= Q._9)
+    return e - Q._0;
+  if (e >= Q.A && e <= Q.F)
+    return e - (Q.A - 10);
+  if (e >= Q.a && e <= Q.f)
+    return e - (Q.a - 10);
+}, jr = (e) => {
+  const t = "hex invalid";
+  if (!$r(e))
+    return W(t);
+  const r = e.length, n = r / 2;
+  if (r % 2)
+    return W(t);
+  const s = Xr(n);
+  for (let i = 0, o = 0; i < n; i++, o += 2) {
+    const u = Mt(e.charCodeAt(o)), c = Mt(e.charCodeAt(o + 1));
+    if (u === void 0 || c === void 0)
+      return W(t);
+    s[i] = u * 16 + c;
+  }
+  return s;
+}, Yr = (e, t) => He($r(e) ? jr(e) : ys(He(e)), t), qt = (...e) => {
+  const t = Xr(e.reduce((n, s) => n + He(s).length, 0));
+  let r = 0;
+  return e.forEach((n) => {
+    t.set(n, r), r += n.length;
+  }), t;
+}, ze = BigInt, Ue = (e, t, r, n = "bad number: out of range") => qr(e) && t <= e && e < r ? e : W(n), g = (e, t = se) => {
+  const r = e % t;
+  return r >= 0n ? r : t + r;
+}, Es = (e, t) => {
+  (e === 0n || t <= 0n) && W("no inverse n=" + e + " mod=" + t);
+  let r = g(e, t), n = t, s = 0n, i = 1n;
+  for (; r !== 0n; ) {
+    const o = n / r, u = n % r, c = s - i * o;
+    n = r, r = u, s = i, i = c;
+  }
+  return n === 1n ? g(s, t) : W("no inverse");
+}, $t = (e) => e instanceof R ? e : W("Point expected"), Zr = (e) => g(g(e * e) * e + Mr), Xt = (e) => Ue(e, 0n, se), Ge = (e) => Ue(e, 1n, se), Ss = (e) => Ue(e, 1n, Kr), yt = (e) => (e & 1n) === 0n, Qr = (e) => Uint8Array.of(e), _s = (e) => Qr(yt(e) ? 2 : 3), bs = (e) => {
+  const t = Zr(Ge(e));
+  let r = 1n;
+  for (let n = t, s = (se + 1n) / 4n; s > 0n; s >>= 1n)
+    s & 1n && (r = r * n % se), n = n * n % se;
+  return g(r * r) === t ? r : W("sqrt invalid");
+};
+class R {
+  static BASE;
+  static ZERO;
+  px;
+  py;
+  pz;
+  constructor(t, r, n) {
+    this.px = Xt(t), this.py = Ge(r), this.pz = Xt(n), Object.freeze(this);
+  }
+  /** Convert Uint8Array or hex string to Point. */
+  static fromBytes(t) {
+    He(t);
+    let r;
+    const n = t[0], s = t.subarray(1), i = Dt(s, 0, We), o = t.length;
+    if (o === We + 1 && [2, 3].includes(n)) {
+      let u = bs(i);
+      const c = yt(u);
+      yt(ze(n)) !== c && (u = g(-u)), r = new R(i, u, 1n);
+    }
+    return o === mt + 1 && n === 4 && (r = new R(i, Dt(s, We, mt), 1n)), r ? r.assertValidity() : W("bad point: not on curve");
+  }
+  /** Equality check: compare points P&Q. */
+  equals(t) {
+    const { px: r, py: n, pz: s } = this, { px: i, py: o, pz: u } = $t(t), c = g(r * u), a = g(i * s), p = g(n * u), l = g(o * s);
+    return c === a && p === l;
+  }
+  is0() {
+    return this.equals(ne);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new R(this.px, g(-this.py), this.pz);
+  }
+  /** Point doubling: P+P, complete formula. */
+  double() {
+    return this.add(this);
+  }
+  /**
+   * Point addition: P+Q, complete, exception-free formula
+   * (Renes-Costello-Batina, algo 1 of [2015/1060](https://eprint.iacr.org/2015/1060)).
+   * Cost: `12M + 0S + 3*a + 3*b3 + 23add`.
+   */
+  // prettier-ignore
+  add(t) {
+    const { px: r, py: n, pz: s } = this, { px: i, py: o, pz: u } = $t(t), c = 0n, a = Mr;
+    let p = 0n, l = 0n, m = 0n;
+    const T = g(a * 3n);
+    let y = g(r * i), O = g(n * o), I = g(s * u), B = g(r + n), v = g(i + o);
+    B = g(B * v), v = g(y + O), B = g(B - v), v = g(r + s);
+    let S = g(i + u);
+    return v = g(v * S), S = g(y + I), v = g(v - S), S = g(n + s), p = g(o + u), S = g(S * p), p = g(O + I), S = g(S - p), m = g(c * v), p = g(T * I), m = g(p + m), p = g(O - m), m = g(O + m), l = g(p * m), O = g(y + y), O = g(O + y), I = g(c * I), v = g(T * v), O = g(O + I), I = g(y - I), I = g(c * I), v = g(v + I), y = g(O * v), l = g(l + y), y = g(S * v), p = g(B * p), p = g(p - y), y = g(B * O), m = g(S * m), m = g(m + y), new R(p, l, m);
+  }
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(t, r = !0) {
+    if (!r && t === 0n)
+      return ne;
+    if (Ss(t), t === 1n)
+      return this;
+    if (this.equals(ce))
+      return As(t).p;
+    let n = ne, s = ce;
+    for (let i = this; t > 0n; i = i.double(), t >>= 1n)
+      t & 1n ? n = n.add(i) : r && (s = s.add(i));
+    return n;
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { px: t, py: r, pz: n } = this;
+    if (this.equals(ne))
+      return { x: 0n, y: 0n };
+    if (n === 1n)
+      return { x: t, y: r };
+    const s = Es(n, se);
+    return g(n * s) !== 1n && W("inverse invalid"), { x: g(t * s), y: g(r * s) };
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const { x: t, y: r } = this.toAffine();
+    return Ge(t), Ge(r), g(r * r) === Zr(t) ? this : W("bad point: not on curve");
+  }
+  /** Converts point to 33/65-byte Uint8Array. */
+  toBytes(t = !0) {
+    const { x: r, y: n } = this.assertValidity().toAffine(), s = zt(r);
+    return t ? qt(_s(n), s) : qt(Qr(4), s, zt(n));
+  }
+  /** Create 3d xyz point from 2d xy. (0, 0) => (0, 1, 0), not (0, 0, 1) */
+  static fromAffine(t) {
+    const { x: r, y: n } = t;
+    return r === 0n && n === 0n ? ne : new R(r, n, 1n);
+  }
+  toHex(t) {
+    return zr(this.toBytes(t));
+  }
+  static fromPrivateKey(t) {
+    return ce.multiply(Os(t));
+  }
+  static fromHex(t) {
+    return R.fromBytes(Yr(t));
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  toRawBytes(t) {
+    return this.toBytes(t);
+  }
+}
+const ce = new R(ws, gs, 1n), ne = new R(0n, 1n, 0n);
+R.BASE = ce;
+R.ZERO = ne;
+const Jr = (e) => ze("0x" + (zr(e) || "0")), Dt = (e, t, r) => Jr(e.subarray(t, r)), Ts = 2n ** 256n, zt = (e) => jr(Dr(Ue(e, 0n, Ts), mt)), Os = (e) => {
+  const t = qr(e) ? e : Jr(Yr(e, We));
+  return Ue(t, 1n, Kr, "private key invalid 3");
+}, je = 8, Ps = 256, en = Math.ceil(Ps / je) + 1, Et = 2 ** (je - 1), Is = () => {
+  const e = [];
+  let t = ce, r = t;
+  for (let n = 0; n < en; n++) {
+    r = t, e.push(r);
+    for (let s = 1; s < Et; s++)
+      r = r.add(t), e.push(r);
+    t = r.double();
+  }
+  return e;
+};
+let jt;
+const Yt = (e, t) => {
+  const r = t.negate();
+  return e ? r : t;
+}, As = (e) => {
+  const t = jt || (jt = Is());
+  let r = ne, n = ce;
+  const s = 2 ** je, i = s, o = ze(s - 1), u = ze(je);
+  for (let c = 0; c < en; c++) {
+    let a = Number(e & o);
+    e >>= u, a > Et && (a -= i, e += 1n);
+    const p = c * Et, l = p, m = p + Math.abs(a) - 1, T = c % 2 !== 0, y = a < 0;
+    a === 0 ? n = n.add(Yt(T, t[l])) : r = r.add(Yt(y, t[m]));
+  }
+  return { p: r, f: n };
+}, we = E;
+function he(e, t) {
+  if (!e.address && !e.hash && !e.output && !e.redeem && !e.input)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    network: f.maybe(f.Object),
+    address: f.maybe(f.String),
+    hash: f.maybe(f.BufferN(20)),
+    output: f.maybe(f.BufferN(23)),
+    redeem: f.maybe({
+      network: f.maybe(f.Object),
+      output: f.maybe(f.Buffer),
+      input: f.maybe(f.Buffer),
+      witness: f.maybe(f.arrayOf(f.Buffer))
+    }),
+    input: f.maybe(f.Buffer),
+    witness: f.maybe(f.arrayOf(f.Buffer))
+  }, e);
+  let r = e.network;
+  r || (r = e.redeem && e.redeem.network || K);
+  const n = {
+    network: r,
+    name: G.P2SH
+  }, s = C(() => {
+    const u = h.from(Oe.decode(e.address)), c = u.readUInt8(0), a = u.slice(1);
+    return { version: c, hash: a };
+  }), i = C(() => b(e.input)), o = C(() => {
+    const u = i(), c = u[u.length - 1];
+    return {
+      network: r,
+      output: c === we.OP_FALSE ? h.from([]) : c,
+      input: H(u.slice(0, -1)),
+      witness: e.witness || []
+    };
+  });
+  if (w(n, "address", () => {
+    if (!n.hash)
+      return;
+    const u = h.allocUnsafe(21);
+    return u.writeUInt8(n.network.scriptHash, 0), n.hash.copy(u, 1), Oe.encode(u);
+  }), w(n, "hash", () => {
+    if (e.output)
+      return e.output.slice(2, 22);
+    if (e.address)
+      return s().hash;
+    if (n.redeem && n.redeem.output)
+      return x(n.redeem.output);
+  }), w(n, "output", () => {
+    if (n.hash)
+      return H([we.OP_HASH160, n.hash, we.OP_EQUAL]);
+  }), w(n, "redeem", () => {
+    if (e.input)
+      return o();
+  }), w(n, "input", () => {
+    if (!(!e.redeem || !e.redeem.input || !e.redeem.output))
+      return H([].concat(b(e.redeem.input), e.redeem.output));
+  }), w(n, "witness", () => {
+    if (n.redeem && n.redeem.witness)
+      return n.redeem.witness;
+    if (n.input)
+      return [];
+  }), w(n, "name", () => {
+    const u = ["p2sh"];
+    return n.redeem !== void 0 && n.redeem.name !== void 0 && u.push(n.redeem.name), u.join("-");
+  }), t.validate) {
+    let u = h.from([]);
+    if (e.address) {
+      if (s().version !== r.scriptHash)
+        throw new TypeError("Invalid version or Network mismatch");
+      if (s().hash.length !== 20)
+        throw new TypeError("Invalid address");
+      u = s().hash;
+    }
+    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 !== 23 || e.output[0] !== we.OP_HASH160 || e.output[1] !== 20 || e.output[22] !== we.OP_EQUAL)
+        throw new TypeError("Output is invalid");
+      const a = e.output.slice(2, 22);
+      if (u.length > 0 && !u.equals(a))
+        throw new TypeError("Hash mismatch");
+      u = a;
+    }
+    const c = (a) => {
+      if (a.output) {
+        const p = b(a.output);
+        if (!p || p.length < 1)
+          throw new TypeError("Redeem.output too short");
+        if (a.output.byteLength > 520)
+          throw new TypeError("Redeem.output unspendable if larger than 520 bytes");
+        if (It(p) > 201)
+          throw new TypeError("Redeem.output unspendable with more than 201 non-push ops");
+        const l = x(a.output);
+        if (u.length > 0 && !u.equals(l))
+          throw new TypeError("Hash mismatch");
+        u = l;
+      }
+      if (a.input) {
+        const p = a.input.length > 0, l = a.witness && a.witness.length > 0;
+        if (!p && !l)
+          throw new TypeError("Empty input");
+        if (p && l)
+          throw new TypeError("Input and witness provided");
+        if (p) {
+          const m = b(a.input);
+          if (!Je(m))
+            throw new TypeError("Non push-only scriptSig");
+        }
+      }
+    };
+    if (e.input) {
+      const a = i();
+      if (!a || a.length < 1)
+        throw new TypeError("Input too short");
+      if (!h.isBuffer(o().output))
+        throw new TypeError("Input is invalid");
+      c(o());
+    }
+    if (e.redeem) {
+      if (e.redeem.network && e.redeem.network !== r)
+        throw new TypeError("Network mismatch");
+      if (e.input) {
+        const a = o();
+        if (e.redeem.output && !e.redeem.output.equals(a.output))
+          throw new TypeError("Redeem.output mismatch");
+        if (e.redeem.input && !e.redeem.input.equals(a.input))
+          throw new TypeError("Redeem.input mismatch");
+      }
+      c(e.redeem);
+    }
+    if (e.witness && e.redeem && e.redeem.witness && !ie(e.redeem.witness, e.witness))
+      throw new TypeError("Witness and redeem.witness mismatch");
+  }
+  return Object.assign(n, e);
+}
+const Zt = E, Qt = 1, Hs = 80;
+function pe(e, t) {
+  if (!e.address && !e.output && !e.pubkey && !e.internalPubkey && !(e.witness && e.witness.length > 1))
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    address: f.maybe(f.String),
+    input: f.maybe(f.BufferN(0)),
+    network: f.maybe(f.Object),
+    output: f.maybe(f.BufferN(34)),
+    internalPubkey: f.maybe(f.BufferN(32)),
+    hash: f.maybe(f.BufferN(32)),
+    pubkey: f.maybe(f.BufferN(32)),
+    signature: f.maybe(f.anyOf(f.BufferN(64), f.BufferN(65))),
+    witness: f.maybe(f.arrayOf(f.Buffer)),
+    scriptTree: f.maybe(Pt),
+    redeem: f.maybe({
+      output: f.maybe(f.Buffer),
+      redeemVersion: f.maybe(f.Number),
+      witness: f.maybe(f.arrayOf(f.Buffer))
+    }),
+    redeemVersion: f.maybe(f.Number)
+  }, e);
+  const r = C(() => vt(e.address)), n = C(() => {
+    if (!(!e.witness || !e.witness.length))
+      return e.witness.length >= 2 && e.witness[e.witness.length - 1][0] === Hs ? e.witness.slice(0, -1) : e.witness.slice();
+  }), s = C(() => {
+    if (e.scriptTree)
+      return De(e.scriptTree);
+    if (e.hash)
+      return { hash: e.hash };
+  }), i = e.network || K, o = {
+    name: G.P2TR,
+    network: i
+  };
+  if (w(o, "address", () => {
+    if (!o.pubkey)
+      return;
+    const u = P.bech32m.toWords(o.pubkey);
+    return u.unshift(Qt), P.bech32m.encode(i.bech32, u);
+  }), w(o, "hash", () => {
+    const u = s();
+    if (u)
+      return u.hash;
+    const c = n();
+    if (c && c.length > 1) {
+      const a = c[c.length - 1], p = a[0] & Ee, l = c[c.length - 2], m = j({
+        output: l,
+        version: p
+      });
+      return Xe(a, m);
+    }
+  }), w(o, "output", () => {
+    if (o.pubkey)
+      return H([Zt.OP_1, o.pubkey]);
+  }), w(o, "redeemVersion", () => e.redeemVersion ? e.redeemVersion : e.redeem && e.redeem.redeemVersion !== void 0 && e.redeem.redeemVersion !== null ? e.redeem.redeemVersion : Nt), w(o, "redeem", () => {
+    const u = n();
+    if (!(!u || u.length < 2))
+      return {
+        output: u[u.length - 2],
+        witness: u.slice(0, -2),
+        redeemVersion: u[u.length - 1][0] & Ee
+      };
+  }), w(o, "pubkey", () => {
+    if (e.pubkey)
+      return e.pubkey;
+    if (e.output)
+      return e.output.slice(2);
+    if (e.address)
+      return r().data;
+    if (o.internalPubkey) {
+      const u = ye(o.internalPubkey, o.hash);
+      if (u)
+        return u.x;
+    }
+  }), w(o, "internalPubkey", () => {
+    if (e.internalPubkey)
+      return e.internalPubkey;
+    const u = n();
+    if (u && u.length > 1)
+      return u[u.length - 1].slice(1, 33);
+  }), w(o, "signature", () => {
+    if (e.signature)
+      return e.signature;
+    const u = n();
+    if (!(!u || u.length !== 1))
+      return u[0];
+  }), w(o, "witness", () => {
+    if (e.witness)
+      return e.witness;
+    const u = s();
+    if (u && e.redeem && e.redeem.output && e.internalPubkey) {
+      const c = j({
+        output: e.redeem.output,
+        version: o.redeemVersion
+      }), a = Ae(u, c);
+      if (!a)
+        return;
+      const p = ye(e.internalPubkey, u.hash);
+      if (!p)
+        return;
+      const l = N.concat([N.from([o.redeemVersion | p.parity]), e.internalPubkey].concat(a));
+      return [e.redeem.output, l];
+    }
+    if (e.signature)
+      return [e.signature];
+  }), t.validate) {
+    let u = N.from([]);
+    if (e.address) {
+      if (i && i.bech32 !== r().prefix)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (r().version !== Qt)
+        throw new TypeError("Invalid address version");
+      if (r().data.length !== 32)
+        throw new TypeError("Invalid address data");
+      u = r().data;
+    }
+    if (e.pubkey) {
+      if (u.length > 0 && !u.equals(e.pubkey))
+        throw new TypeError("Pubkey mismatch");
+      u = e.pubkey;
+    }
+    if (e.output) {
+      if (e.output.length !== 34 || e.output[0] !== Zt.OP_1 || e.output[1] !== 32)
+        throw new TypeError("Output is invalid");
+      if (u.length > 0 && !u.equals(e.output.slice(2)))
+        throw new TypeError("Pubkey mismatch");
+      u = e.output.slice(2);
+    }
+    if (e.internalPubkey) {
+      const p = ye(e.internalPubkey, o.hash);
+      if (u.length > 0 && !u.equals(p.x))
+        throw new TypeError("Pubkey mismatch");
+      u = p.x;
+    }
+    const c = s();
+    if (e.hash && c && !e.hash.equals(c.hash))
+      throw new TypeError("Hash mismatch");
+    if (e.redeem && e.redeem.output && c) {
+      const p = j({
+        output: e.redeem.output,
+        version: o.redeemVersion
+      });
+      if (!Ae(c, p))
+        throw new TypeError("Redeem script not in tree");
+    }
+    const a = n();
+    if (e.redeem && o.redeem) {
+      if (e.redeem.redeemVersion && e.redeem.redeemVersion !== o.redeem.redeemVersion)
+        throw new TypeError("Redeem.redeemVersion and witness mismatch");
+      if (e.redeem.output) {
+        if (b(e.redeem.output).length === 0)
+          throw new TypeError("Redeem.output is invalid");
+        if (o.redeem.output && !e.redeem.output.equals(o.redeem.output))
+          throw new TypeError("Redeem.output and witness mismatch");
+      }
+      if (e.redeem.witness && o.redeem.witness && !ie(e.redeem.witness, o.redeem.witness))
+        throw new TypeError("Redeem.witness and witness mismatch");
+    }
+    if (a && a.length)
+      if (a.length === 1) {
+        if (e.signature && !e.signature.equals(a[0]))
+          throw new TypeError("Signature mismatch");
+      } else {
+        const p = a[a.length - 1];
+        if (p.length < 33)
+          throw new TypeError(`The control-block length is too small. Got ${p.length}, expected min 33.`);
+        if ((p.length - 33) % 32 !== 0)
+          throw new TypeError(`The control-block length of ${p.length} is incorrect!`);
+        const l = (p.length - 33) / 32;
+        if (l > 128)
+          throw new TypeError(`The script path is too long. Got ${l}, expected max 128.`);
+        const m = p.slice(1, 33);
+        if (e.internalPubkey && !e.internalPubkey.equals(m))
+          throw new TypeError("Internal pubkey mismatch");
+        if (!Fr().isXOnlyPoint(m))
+          throw new TypeError("Invalid internalPubkey for p2tr witness");
+        const T = p[0] & Ee, y = a[a.length - 2], O = j({
+          output: y,
+          version: T
+        }), I = Xe(p, O), B = ye(m, I);
+        if (!B)
+          throw new TypeError("Invalid outputKey for p2tr witness");
+        if (u.length && !u.equals(B.x))
+          throw new TypeError("Pubkey mismatch for p2tr witness");
+        if (B.parity !== (p[0] & 1))
+          throw new Error("Incorrect parity");
+      }
+  }
+  return Object.assign(o, e);
+}
+const Jt = E, vs = h.alloc(0);
+function xe(e, t) {
+  if (!e.address && !e.hash && !e.output && !e.pubkey && !e.witness)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    address: f.maybe(f.String),
+    hash: f.maybe(f.BufferN(20)),
+    input: f.maybe(f.BufferN(0)),
+    network: f.maybe(f.Object),
+    output: f.maybe(f.BufferN(22)),
+    pubkey: f.maybe(L),
+    signature: f.maybe(Y),
+    witness: f.maybe(f.arrayOf(f.Buffer))
+  }, e);
+  const r = C(() => {
+    const i = P.bech32.decode(e.address), o = i.words.shift(), u = P.bech32.fromWords(i.words);
+    return {
+      version: o,
+      prefix: i.prefix,
+      data: h.from(u)
+    };
+  }), n = e.network || K, s = {
+    name: G.P2WPKH,
+    network: n
+  };
+  if (w(s, "address", () => {
+    if (!s.hash)
+      return;
+    const i = P.bech32.toWords(s.hash);
+    return i.unshift(0), P.bech32.encode(n.bech32, i);
+  }), w(s, "hash", () => {
+    if (e.output)
+      return e.output.slice(2, 22);
+    if (e.address)
+      return r().data;
+    if (e.pubkey || s.pubkey)
+      return x(e.pubkey || s.pubkey);
+  }), w(s, "output", () => {
+    if (s.hash)
+      return H([Jt.OP_0, s.hash]);
+  }), w(s, "pubkey", () => {
+    if (e.pubkey)
+      return e.pubkey;
+    if (e.witness)
+      return e.witness[1];
+  }), w(s, "signature", () => {
+    if (e.witness)
+      return e.witness[0];
+  }), w(s, "input", () => {
+    if (s.witness)
+      return vs;
+  }), w(s, "witness", () => {
+    if (e.pubkey && e.signature)
+      return [e.signature, e.pubkey];
+  }), t.validate) {
+    let i = h.from([]);
+    if (e.address) {
+      if (n && n.bech32 !== r().prefix)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (r().version !== 0)
+        throw new TypeError("Invalid address version");
+      if (r().data.length !== 20)
+        throw new TypeError("Invalid address data");
+      i = r().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] !== Jt.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 o = x(e.pubkey);
+      if (i.length > 0 && !i.equals(o))
+        throw new TypeError("Hash mismatch");
+      if (i = o, !L(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 (!Y(e.witness[0]))
+        throw new TypeError("Witness has invalid signature");
+      if (!L(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 o = x(e.witness[1]);
+      if (i.length > 0 && !i.equals(o))
+        throw new TypeError("Hash mismatch");
+    }
+  }
+  return Object.assign(s, e);
+}
+const er = E, ft = h.alloc(0);
+function Re(e) {
+  return !!(h.isBuffer(e) && e.length === 65 && e[0] === 4 && L(e));
+}
+function le(e, t) {
+  if (!e.address && !e.hash && !e.output && !e.redeem && !e.witness)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    network: f.maybe(f.Object),
+    address: f.maybe(f.String),
+    hash: f.maybe(f.BufferN(32)),
+    output: f.maybe(f.BufferN(34)),
+    redeem: f.maybe({
+      input: f.maybe(f.Buffer),
+      network: f.maybe(f.Object),
+      output: f.maybe(f.Buffer),
+      witness: f.maybe(f.arrayOf(f.Buffer))
+    }),
+    input: f.maybe(f.BufferN(0)),
+    witness: f.maybe(f.arrayOf(f.Buffer))
+  }, e);
+  const r = C(() => {
+    const o = P.bech32.decode(e.address), u = o.words.shift(), c = P.bech32.fromWords(o.words);
+    return {
+      version: u,
+      prefix: o.prefix,
+      data: h.from(c)
+    };
+  }), n = C(() => b(e.redeem.input));
+  let s = e.network;
+  s || (s = e.redeem && e.redeem.network || K);
+  const i = {
+    network: s,
+    name: G.P2WSH
+  };
+  if (w(i, "address", () => {
+    if (!i.hash)
+      return;
+    const o = P.bech32.toWords(i.hash);
+    return o.unshift(0), P.bech32.encode(s.bech32, o);
+  }), w(i, "hash", () => {
+    if (e.output)
+      return e.output.slice(2);
+    if (e.address)
+      return r().data;
+    if (i.redeem && i.redeem.output)
+      return M(i.redeem.output);
+  }), w(i, "output", () => {
+    if (i.hash)
+      return H([er.OP_0, i.hash]);
+  }), w(i, "redeem", () => {
+    if (e.witness)
+      return {
+        output: e.witness[e.witness.length - 1],
+        input: ft,
+        witness: e.witness.slice(0, -1)
+      };
+  }), w(i, "input", () => {
+    if (i.witness)
+      return ft;
+  }), w(i, "witness", () => {
+    if (e.redeem && e.redeem.input && e.redeem.input.length > 0 && e.redeem.output && e.redeem.output.length > 0) {
+      const o = Cr(n());
+      return i.redeem = Object.assign({ witness: o }, e.redeem), i.redeem.input = ft, [].concat(o, e.redeem.output);
+    }
+    if (e.redeem && e.redeem.output && e.redeem.witness)
+      return [].concat(e.redeem.witness, e.redeem.output);
+  }), w(i, "name", () => {
+    const o = ["p2wsh"];
+    return i.redeem !== void 0 && i.redeem.name !== void 0 && o.push(i.redeem.name), o.join("-");
+  }), t.validate) {
+    let o = h.from([]);
+    if (e.address) {
+      if (r().prefix !== s.bech32)
+        throw new TypeError("Invalid prefix or Network mismatch");
+      if (r().version !== 0)
+        throw new TypeError("Invalid address version");
+      if (r().data.length !== 32)
+        throw new TypeError("Invalid address data");
+      o = r().data;
+    }
+    if (e.hash) {
+      if (o.length > 0 && !o.equals(e.hash))
+        throw new TypeError("Hash mismatch");
+      o = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 34 || e.output[0] !== er.OP_0 || e.output[1] !== 32)
+        throw new TypeError("Output is invalid");
+      const u = e.output.slice(2);
+      if (o.length > 0 && !o.equals(u))
+        throw new TypeError("Hash mismatch");
+      o = u;
+    }
+    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 u = b(e.redeem.output);
+        if (!u || u.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 (It(u) > 201)
+          throw new TypeError("Redeem.output unspendable with more than 201 non-push ops");
+        const c = M(e.redeem.output);
+        if (o.length > 0 && !o.equals(c))
+          throw new TypeError("Hash mismatch");
+        o = c;
+      }
+      if (e.redeem.input && !Je(n()))
+        throw new TypeError("Non push-only scriptSig");
+      if (e.witness && e.redeem.witness && !ie(e.witness, e.redeem.witness))
+        throw new TypeError("Witness and redeem.witness mismatch");
+      if (e.redeem.input && n().some(Re) || e.redeem.output && (b(e.redeem.output) || []).some(Re))
+        throw new TypeError("redeem.input or redeem.output contains uncompressed pubkey");
+    }
+    if (e.witness && e.witness.length > 0) {
+      const u = e.witness[e.witness.length - 1];
+      if (e.redeem && e.redeem.output && !e.redeem.output.equals(u))
+        throw new TypeError("Witness and redeem.output mismatch");
+      if (e.witness.some(Re) || (b(u) || []).some(Re))
+        throw new TypeError("Witness contains uncompressed pubkey");
+    }
+  }
+  return Object.assign(i, e);
+}
+const { typeforce: $ } = Qe;
+function X(e) {
+  const t = e.length;
+  return Pe(t) + t;
+}
+function ks(e) {
+  const t = e.length;
+  return Pe(t) + e.reduce((r, n) => r + X(n), 0);
+}
+const re = h.allocUnsafe(0), tr = [], ct = h.from("0000000000000000000000000000000000000000000000000000000000000000", "hex"), rr = h.from("0000000000000000000000000000000000000000000000000000000000000001", "hex"), Ns = h.from("ffffffffffffffff", "hex"), Us = {
+  script: re,
+  valueBuffer: Ns
+};
+function xs(e) {
+  return e.value !== void 0;
+}
+class d {
+  constructor() {
+    this.version = 1, this.locktime = 0, this.ins = [], this.outs = [];
+  }
+  static fromBuffer(t, r) {
+    const n = new as(t), s = new d();
+    s.version = n.readInt32();
+    const i = n.readUInt8(), o = n.readUInt8();
+    let u = !1;
+    i === d.ADVANCED_TRANSACTION_MARKER && o === d.ADVANCED_TRANSACTION_FLAG ? u = !0 : n.offset -= 2;
+    const c = n.readVarInt();
+    for (let p = 0; p < c; ++p) {
+      const l = n.readSlice(32), m = n.readUInt32(), T = n.readVarSlice(), y = n.readUInt32();
+      s.ins.push({
+        hash: l,
+        index: m,
+        script: T,
+        sequence: y,
+        witness: tr
+      });
+    }
+    const a = n.readVarInt();
+    for (let p = 0; p < a; ++p)
+      s.outs.push({
+        value: n.readUInt64(),
+        script: n.readVarSlice()
+      });
+    if (u) {
+      for (let p = 0; p < c; ++p)
+        s.ins[p].witness = n.readVector();
+      if (!s.hasWitnesses())
+        throw new Error("Transaction has superfluous witness data");
+    }
+    if (s.locktime = n.readUInt32(), r)
+      return s;
+    if (n.offset !== t.length)
+      throw new Error("Transaction has unexpected data");
+    return s;
+  }
+  static fromHex(t) {
+    return d.fromBuffer(h.from(t, "hex"), !1);
+  }
+  static isCoinbaseHash(t) {
+    $(lt, t);
+    for (let r = 0; r < 32; ++r)
+      if (t[r] !== 0)
+        return !1;
+    return !0;
+  }
+  isCoinbase() {
+    return this.ins.length === 1 && d.isCoinbaseHash(this.ins[0].hash);
+  }
+  addInput(t, r, n, s) {
+    return $(D(lt, z, dt(z), dt(V)), arguments), vr(n) && (n = d.DEFAULT_SEQUENCE), this.ins.push({
+      hash: t,
+      index: r,
+      script: s || re,
+      sequence: n,
+      witness: tr
+    }) - 1;
+  }
+  addOutput(t, r) {
+    return $(D(V, Le), arguments), this.outs.push({
+      script: t,
+      value: r
+    }) - 1;
+  }
+  hasWitnesses() {
+    return this.ins.some((t) => t.witness.length !== 0);
+  }
+  weight() {
+    const t = this.byteLength(!1), r = this.byteLength(!0);
+    return t * 3 + r;
+  }
+  virtualSize() {
+    return Math.ceil(this.weight() / 4);
+  }
+  byteLength(t = !0) {
+    const r = t && this.hasWitnesses();
+    return (r ? 10 : 8) + Pe(this.ins.length) + Pe(this.outs.length) + this.ins.reduce((n, s) => n + 40 + X(s.script), 0) + this.outs.reduce((n, s) => n + 8 + X(s.script), 0) + (r ? this.ins.reduce((n, s) => n + ks(s.witness), 0) : 0);
+  }
+  clone() {
+    const t = new d();
+    return t.version = this.version, t.locktime = this.locktime, t.ins = this.ins.map((r) => ({
+      hash: r.hash,
+      index: r.index,
+      script: r.script,
+      sequence: r.sequence,
+      witness: r.witness
+    })), t.outs = this.outs.map((r) => ({
+      script: r.script,
+      value: r.value
+    })), t;
+  }
+  hashForSignature(t, r, n) {
+    if ($(D(z, V, Se), arguments), t >= this.ins.length)
+      return rr;
+    const s = H(b(r).filter((u) => u !== E.OP_CODESEPARATOR)), i = this.clone();
+    if ((n & 31) === d.SIGHASH_NONE)
+      i.outs = [], i.ins.forEach((u, c) => {
+        c !== t && (u.sequence = 0);
+      });
+    else if ((n & 31) === d.SIGHASH_SINGLE) {
+      if (t >= this.outs.length)
+        return rr;
+      i.outs.length = t + 1;
+      for (let u = 0; u < t; u++)
+        i.outs[u] = Us;
+      i.ins.forEach((u, c) => {
+        c !== t && (u.sequence = 0);
+      });
+    }
+    n & d.SIGHASH_ANYONECANPAY ? (i.ins = [i.ins[t]], i.ins[0].script = s) : (i.ins.forEach((u) => {
+      u.script = re;
+    }), i.ins[t].script = s);
+    const o = h.allocUnsafe(i.byteLength(!1) + 4);
+    return o.writeInt32LE(n, o.length - 4), i.__toBuffer(o, 0, !1), te(o);
+  }
+  hashForWitnessV1(t, r, n, s, i, o) {
+    if ($(D(z, $.arrayOf(V), $.arrayOf(Le), z), arguments), n.length !== this.ins.length || r.length !== this.ins.length)
+      throw new Error("Must supply prevout script and value for all inputs");
+    const u = s === d.SIGHASH_DEFAULT ? d.SIGHASH_ALL : s & d.SIGHASH_OUTPUT_MASK, a = (s & d.SIGHASH_INPUT_MASK) === d.SIGHASH_ANYONECANPAY, p = u === d.SIGHASH_NONE, l = u === d.SIGHASH_SINGLE;
+    let m = re, T = re, y = re, O = re, I = re;
+    if (!a) {
+      let _ = k.withCapacity(36 * this.ins.length);
+      this.ins.forEach((A) => {
+        _.writeSlice(A.hash), _.writeUInt32(A.index);
+      }), m = M(_.end()), _ = k.withCapacity(8 * this.ins.length), n.forEach((A) => _.writeUInt64(A)), T = M(_.end()), _ = k.withCapacity(r.map(X).reduce((A, J) => A + J)), r.forEach((A) => _.writeVarSlice(A)), y = M(_.end()), _ = k.withCapacity(4 * this.ins.length), this.ins.forEach((A) => _.writeUInt32(A.sequence)), O = M(_.end());
+    }
+    if (p || l) {
+      if (l && t < this.outs.length) {
+        const _ = this.outs[t], A = k.withCapacity(8 + X(_.script));
+        A.writeUInt64(_.value), A.writeVarSlice(_.script), I = M(A.end());
+      }
+    } else {
+      if (!this.outs.length)
+        throw new Error("Add outputs to the transaction before signing.");
+      const _ = this.outs.map((J) => 8 + X(J.script)).reduce((J, Sn) => J + Sn), A = k.withCapacity(_);
+      this.outs.forEach((J) => {
+        A.writeUInt64(J.value), A.writeVarSlice(J.script);
+      }), I = M(A.end());
+    }
+    const B = (i ? 2 : 0) + (o ? 1 : 0), v = 174 - (a ? 49 : 0) - (p ? 32 : 0) + (o ? 32 : 0) + (i ? 37 : 0), S = k.withCapacity(v);
+    if (S.writeUInt8(s), S.writeInt32(this.version), S.writeUInt32(this.locktime), S.writeSlice(m), S.writeSlice(T), S.writeSlice(y), S.writeSlice(O), p || l || S.writeSlice(I), S.writeUInt8(B), a) {
+      const _ = this.ins[t];
+      S.writeSlice(_.hash), S.writeUInt32(_.index), S.writeUInt64(n[t]), S.writeVarSlice(r[t]), S.writeUInt32(_.sequence);
+    } else
+      S.writeUInt32(t);
+    if (o) {
+      const _ = k.withCapacity(X(o));
+      _.writeVarSlice(o), S.writeSlice(M(_.end()));
+    }
+    return l && S.writeSlice(I), i && (S.writeSlice(i), S.writeUInt8(0), S.writeUInt32(4294967295)), ke("TapSighash", h.concat([h.from([0]), S.end()]));
+  }
+  hashForWitnessV0(t, r, n, s) {
+    $(D(z, V, Le, z), arguments);
+    let i = h.from([]), o, u = ct, c = ct, a = ct;
+    if (s & d.SIGHASH_ANYONECANPAY || (i = h.allocUnsafe(36 * this.ins.length), o = new k(i, 0), this.ins.forEach((l) => {
+      o.writeSlice(l.hash), o.writeUInt32(l.index);
+    }), c = te(i)), !(s & d.SIGHASH_ANYONECANPAY) && (s & 31) !== d.SIGHASH_SINGLE && (s & 31) !== d.SIGHASH_NONE && (i = h.allocUnsafe(4 * this.ins.length), o = new k(i, 0), this.ins.forEach((l) => {
+      o.writeUInt32(l.sequence);
+    }), a = te(i)), (s & 31) !== d.SIGHASH_SINGLE && (s & 31) !== d.SIGHASH_NONE) {
+      const l = this.outs.reduce((m, T) => m + 8 + X(T.script), 0);
+      i = h.allocUnsafe(l), o = new k(i, 0), this.outs.forEach((m) => {
+        o.writeUInt64(m.value), o.writeVarSlice(m.script);
+      }), u = te(i);
+    } else if ((s & 31) === d.SIGHASH_SINGLE && t < this.outs.length) {
+      const l = this.outs[t];
+      i = h.allocUnsafe(8 + X(l.script)), o = new k(i, 0), o.writeUInt64(l.value), o.writeVarSlice(l.script), u = te(i);
+    }
+    i = h.allocUnsafe(156 + X(r)), o = new k(i, 0);
+    const p = this.ins[t];
+    return o.writeInt32(this.version), o.writeSlice(c), o.writeSlice(a), o.writeSlice(p.hash), o.writeUInt32(p.index), o.writeVarSlice(r), o.writeUInt64(n), o.writeUInt32(p.sequence), o.writeSlice(u), o.writeUInt32(this.locktime), o.writeUInt32(s), te(i);
+  }
+  getHash(t) {
+    return t && this.isCoinbase() ? h.alloc(32, 0) : te(this.__toBuffer(void 0, void 0, t));
+  }
+  getId() {
+    return kt(this.getHash(!1)).toString("hex");
+  }
+  toBuffer(t, r) {
+    return this.__toBuffer(t, r, !0);
+  }
+  toHex() {
+    return this.toBuffer(void 0, void 0).toString("hex");
+  }
+  setInputScript(t, r) {
+    $(D(Se, V), arguments), this.ins[t].script = r;
+  }
+  setWitness(t, r) {
+    $(D(Se, [V]), arguments), this.ins[t].witness = r;
+  }
+  __toBuffer(t, r, n = !1) {
+    t || (t = h.allocUnsafe(this.byteLength(n)));
+    const s = new k(t, r || 0);
+    s.writeInt32(this.version);
+    const i = n && this.hasWitnesses();
+    return i && (s.writeUInt8(d.ADVANCED_TRANSACTION_MARKER), s.writeUInt8(d.ADVANCED_TRANSACTION_FLAG)), s.writeVarInt(this.ins.length), this.ins.forEach((o) => {
+      s.writeSlice(o.hash), s.writeUInt32(o.index), s.writeVarSlice(o.script), s.writeUInt32(o.sequence);
+    }), s.writeVarInt(this.outs.length), this.outs.forEach((o) => {
+      xs(o) ? s.writeUInt64(o.value) : s.writeSlice(o.valueBuffer), s.writeVarSlice(o.script);
+    }), i && this.ins.forEach((o) => {
+      s.writeVector(o.witness);
+    }), s.writeUInt32(this.locktime), r !== void 0 ? t.slice(r, s.offset) : t;
+  }
+}
+d.DEFAULT_SEQUENCE = 4294967295;
+d.SIGHASH_DEFAULT = 0;
+d.SIGHASH_ALL = 1;
+d.SIGHASH_NONE = 2;
+d.SIGHASH_SINGLE = 3;
+d.SIGHASH_ANYONECANPAY = 128;
+d.SIGHASH_OUTPUT_MASK = 3;
+d.SIGHASH_INPUT_MASK = 128;
+d.ADVANCED_TRANSACTION_MARKER = 0;
+d.ADVANCED_TRANSACTION_FLAG = 1;
+d.TRUC_VERSION = 3;
+d.TRUC_MAX_VSIZE = 1e4;
+d.TRUC_CHILD_MAX_VSIZE = 1e3;
+const be = (e) => {
+  const t = e.length === 32 ? e : e.slice(1, 33);
+  return h.isBuffer(t) ? t : h.from(t);
+};
+function nr(e, t, r) {
+  const n = Ds(t, e, r);
+  try {
+    const i = $s(t, n).concat(n.script).concat(n.controlBlock);
+    return { finalScriptWitness: Te(i) };
+  } catch (s) {
+    throw new Error(`Can not finalize taproot input #${e}: ${s}`);
+  }
+}
+function Be(e, t) {
+  const r = t ? h.from([t]) : h.from([]);
+  return h.concat([e, r]);
+}
+function q(e) {
+  return e && !!(e.tapInternalKey || e.tapMerkleRoot || e.tapLeafScript && e.tapLeafScript.length || e.tapBip32Derivation && e.tapBip32Derivation.length || e.witnessUtxo && nn(e.witnessUtxo.script));
+}
+function at(e, t) {
+  return e && !!(e.tapInternalKey || e.tapTree || e.tapBip32Derivation && e.tapBip32Derivation.length || t);
+}
+function sr(e, t, r) {
+  Ks(e, t, r), qs(e, t, r);
+}
+function ir(e, t, r) {
+  Ms(e, t, r), Cs(e, t);
+}
+function Cs(e, t) {
+  if (!t.tapTree && !t.tapInternalKey)
+    return;
+  const r = t.tapInternalKey || e.tapInternalKey, n = t.tapTree || e.tapTree;
+  if (r) {
+    const { script: s } = e, i = Rs(r, n);
+    if (s && !s.equals(i))
+      throw new Error("Error adding output. Script or address missmatch.");
+  }
+}
+function Rs(e, t) {
+  const r = t && Bs(t.leaves), { output: n } = pe({
+    internalPubkey: e,
+    scriptTree: r
+  });
+  return n;
+}
+function Bs(e = []) {
+  return e.length === 1 && e[0].depth === 0 ? {
+    output: e[0].script,
+    version: e[0].leafVersion
+  } : Gs(e);
+}
+function Fs(e, t) {
+  return Ls(e).some((n) => on(n, Vs, t));
+}
+function Vs(e) {
+  return {
+    signature: e.slice(0, 64),
+    hashType: e.slice(64)[0] || d.SIGHASH_DEFAULT
+  };
+}
+function Ls(e) {
+  const t = [];
+  if (e.tapKeySig && t.push(e.tapKeySig), e.tapScriptSig && t.push(...e.tapScriptSig.map((r) => r.signature)), !t.length) {
+    const r = Ws(e.finalScriptWitness);
+    r && t.push(r);
+  }
+  return t;
+}
+function Ws(e) {
+  if (!e)
+    return;
+  const t = e.slice(2);
+  if (t.length === 64 || t.length === 65)
+    return t;
+}
+function Gs(e) {
+  let t;
+  for (const r of e)
+    if (t = St(r, t), !t)
+      throw new Error("No room left to insert tapleaf in tree");
+  return t;
+}
+function St(e, t, r = 0) {
+  if (r > Wr)
+    throw new Error("Max taptree depth exceeded.");
+  if (e.depth === r)
+    return t ? void 0 : {
+      output: e.script,
+      version: e.leafVersion
+    };
+  if (Ze(t))
+    return;
+  const n = St(e, t && t[0], r + 1);
+  if (n)
+    return [n, t && t[1]];
+  const s = St(e, t && t[1], r + 1);
+  if (s)
+    return [t && t[0], s];
+}
+function Ks(e, t, r) {
+  const n = q(e) && ae(t), s = ae(e) && q(t), i = e === t && q(t) && ae(t);
+  if (n || s || i)
+    throw new Error(`Invalid arguments for Psbt.${r}. Cannot use both taproot and non-taproot fields.`);
+}
+function Ms(e, t, r) {
+  const n = at(e) && ae(t), s = ae(e) && at(t), i = e === t && at(t) && ae(t);
+  if (n || s || i)
+    throw new Error(`Invalid arguments for Psbt.${r}. Cannot use both taproot and non-taproot fields.`);
+}
+function qs(e, t, r) {
+  if (t.tapMerkleRoot) {
+    const n = (t.tapLeafScript || []).every((i) => ht(i, t.tapMerkleRoot)), s = (e.tapLeafScript || []).every((i) => ht(i, t.tapMerkleRoot));
+    if (!n || !s)
+      throw new Error(`Invalid arguments for Psbt.${r}. Tapleaf not part of taptree.`);
+  } else if (e.tapMerkleRoot && !(t.tapLeafScript || []).every((s) => ht(s, e.tapMerkleRoot)))
+    throw new Error(`Invalid arguments for Psbt.${r}. Tapleaf not part of taptree.`);
+}
+function ht(e, t) {
+  if (!t)
+    return !0;
+  const r = j({
+    output: e.script,
+    version: e.leafVersion
+  });
+  return Xe(e.controlBlock, r).equals(t);
+}
+function $s(e, t) {
+  const r = j({
+    output: t.script,
+    version: t.leafVersion
+  });
+  return (e.tapScriptSig || []).filter((n) => n.leafHash.equals(r)).map((n) => Xs(t.script, n)).sort((n, s) => s.positionInScript - n.positionInScript).map((n) => n.signature);
+}
+function Xs(e, t) {
+  return Object.assign({
+    positionInScript: sn(t.pubkey, e)
+  }, t);
+}
+function Ds(e, t, r) {
+  if (!e.tapScriptSig || !e.tapScriptSig.length)
+    throw new Error(`Can not finalize taproot input #${t}. No tapleaf script signature provided.`);
+  const n = (e.tapLeafScript || []).sort((s, i) => s.controlBlock.length - i.controlBlock.length).find((s) => zs(s, e.tapScriptSig, r));
+  if (!n)
+    throw new Error(`Can not finalize taproot input #${t}. Signature for tapleaf script not found.`);
+  return n;
+}
+function zs(e, t, r) {
+  const n = j({
+    output: e.script,
+    version: e.leafVersion
+  });
+  return (!r || r.equals(n)) && t.find((i) => i.leafHash.equals(n)) !== void 0;
+}
+function ae(e) {
+  return e && !!(e.redeemScript || e.witnessScript || e.bip32Derivation && e.bip32Derivation.length);
+}
+const or = E, ur = 16, fr = 2, cr = 40;
+function tn(e, t) {
+  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");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    address: f.maybe(f.String),
+    output: f.maybe(f.Buffer),
+    program: f.maybe(f.Buffer),
+    network: f.maybe(f.Object),
+    deploymentVersion: f.maybe(f.Number),
+    hash160: f.maybe(f.BufferN(20))
+  }, e);
+  const r = () => {
+    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 h.concat([h.of(e.deploymentVersion), e.hash160]);
+    }
+  }, n = C(() => vt(e.address)), s = e.network || K, i = {
+    name: G.P2OP,
+    network: s,
+    deploymentVersion: 0
+  };
+  if (w(i, "program", () => {
+    if (e.program)
+      return e.program;
+    const o = r();
+    if (o)
+      return o;
+    if (e.output) {
+      if (e.output[0] !== or.OP_16)
+        throw new TypeError("Invalid P2OP script");
+      let u = 1, c;
+      if (e.output[1] < 76)
+        c = e.output[1], u = 2;
+      else if (e.output[1] === 76)
+        c = e.output[2], u = 3;
+      else
+        throw new TypeError("Unsupported push opcode in P2OP script");
+      return e.output.slice(u, u + c);
+    }
+    if (e.address)
+      return n().data;
+  }), w(i, "deploymentVersion", () => {
+    if (i.program)
+      return i.program[0];
+  }), w(i, "hash160", () => {
+    if (i.program)
+      return i.program.slice(1);
+  }), w(i, "output", () => {
+    if (i.program)
+      return H([or.OP_16, i.program]);
+  }), w(i, "address", () => {
+    if (!i.program)
+      return;
+    if (!s.bech32Opnet)
+      throw new TypeError("Network does not support opnet");
+    const o = P.bech32m.toWords(i.program);
+    return o.unshift(ur), P.bech32m.encode(s.bech32Opnet, o);
+  }), t.validate) {
+    let o = N.alloc(0);
+    if (e.address) {
+      const u = n();
+      if (s.bech32Opnet !== u.prefix)
+        throw new TypeError("Invalid prefix or network mismatch");
+      if (u.version !== ur)
+        throw new TypeError("Invalid witness version for p2op");
+      if (u.data.length < fr || u.data.length > cr)
+        throw new TypeError("Invalid witness program length");
+      o = u.data;
+    }
+    if (e.program) {
+      if (o.length && !o.equals(e.program))
+        throw new TypeError("Program mismatch");
+      o = e.program;
+    }
+    if (!o.length && e.deploymentVersion !== void 0 && e.hash160 && (o = r()), e.output) {
+      const u = i.program;
+      if (o.length && !o.equals(u))
+        throw new TypeError("Program mismatch (output vs other source)");
+      o = u;
+    }
+    if (o.length < fr || o.length > cr)
+      throw new TypeError(`Witness program must be 2–40 bytes. Was ${o.length} bytes`);
+    if (e.deploymentVersion !== void 0 && e.deploymentVersion !== o[0])
+      throw new TypeError("deploymentVersion mismatch");
+    if (e.hash160 && !e.hash160.equals(o.slice(1)))
+      throw new TypeError("hash160 mismatch");
+  }
+  return Object.assign(i, e);
+}
+function oe(e) {
+  return (t) => {
+    try {
+      return e({ output: t }), !0;
+    } catch {
+      return !1;
+    }
+  };
+}
+const js = oe(Ne), Ys = oe(Ut), Zs = oe(de), st = oe(xe), ar = oe(le), rn = oe(he), nn = oe(pe), Hi = (e) => e.length === 4 && e[0] === 81 && e[1] === 2 && e[2] === 78 && e[3] === 115;
+function Te(e) {
+  let t = h.allocUnsafe(0);
+  function r(o) {
+    t = h.concat([t, h.from(o)]);
+  }
+  function n(o) {
+    const u = t.length, c = Ke.encodingLength(o);
+    t = h.concat([t, h.allocUnsafe(c)]), Ke.encode(o, t, u);
+  }
+  function s(o) {
+    n(o.length), r(o);
+  }
+  function i(o) {
+    n(o.length), o.forEach(s);
+  }
+  return i(e), t;
+}
+function _t(e) {
+  if (e.length === 32)
+    return;
+  if (![33, 65].includes(e.length)) {
+    console.warn(`Unsupported key length=${e.length}. Must be 33 (compressed) or 65 (uncompressed).`);
+    return;
+  }
+  let t;
+  try {
+    t = R.fromHex(e);
+  } catch {
+    throw new Error("Invalid secp256k1 public key bytes. Cannot parse.");
+  }
+  const r = hr(t.x), n = hr(t.y), i = t.y % 2n === 0n ? 6 : 7, o = h.alloc(65);
+  o[0] = i, r.copy(o, 1), n.copy(o, 33);
+  const u = h.concat([h.from([4]), r, n]);
+  return {
+    hybrid: o,
+    uncompressed: u
+  };
+}
+function hr(e) {
+  let t = e.toString(16);
+  return t = t.padStart(64, "0"), t.length > 64 && (t = t.slice(-64)), h.from(t, "hex");
+}
+function Fe(e, t) {
+  if (e.equals(t))
+    return !0;
+  if (e.length === 65 && t.length === 65) {
+    const r = h.from(e), n = h.from(t);
+    return (r[0] === 6 || r[0] === 7) && (r[0] = 4), (n[0] === 6 || n[0] === 7) && (n[0] = 4), r.equals(n);
+  }
+  return !1;
+}
+function sn(e, t) {
+  const r = b(t);
+  if (r === null)
+    throw new Error("Unknown script error");
+  const n = x(e), s = be(e), i = _t(e), o = i?.hybrid ? x(i.hybrid) : void 0, u = i?.uncompressed ? x(i.uncompressed) : void 0;
+  return r.findIndex((c) => {
+    if (typeof c == "number")
+      return !1;
+    if (Fe(c, e) || Fe(c, s) || c.equals(n) || i && (Fe(c, i.uncompressed) || Fe(c, i.hybrid) || o && c.equals(o) || u && c.equals(u)))
+      return !0;
+  });
+}
+function it(e, t) {
+  return sn(e, t) !== -1;
+}
+function Qs(e, t) {
+  return Js(e).some((n) => on(n, fe.decode, t));
+}
+function on(e, t, r) {
+  const { hashType: n } = t(e), s = [];
+  switch (n & d.SIGHASH_ANYONECANPAY && s.push("addInput"), n & 31) {
+    case d.SIGHASH_ALL:
+      break;
+    case d.SIGHASH_SINGLE:
+    case d.SIGHASH_NONE:
+      s.push("addOutput"), s.push("setInputSequence");
+      break;
+  }
+  return s.indexOf(r) === -1;
+}
+function Js(e) {
+  let t = [];
+  if ((e.partialSig || []).length === 0) {
+    if (!e.finalScriptSig && !e.finalScriptWitness)
+      return [];
+    t = ei(e);
+  } else
+    t = e.partialSig;
+  return t.map((r) => r.signature);
+}
+function ei(e) {
+  const t = e.finalScriptSig ? b(e.finalScriptSig) || [] : [], r = e.finalScriptWitness ? b(e.finalScriptWitness) || [] : [];
+  return t.concat(r).filter((n) => h.isBuffer(n) && Y(n)).map((n) => ({ signature: n }));
+}
+const ee = E;
+function de(e, t) {
+  if (!e.address && !e.hash && !e.output && !e.pubkey && !e.input)
+    throw new TypeError("Not enough data");
+  t = Object.assign({ validate: !0 }, t || {}), f({
+    network: f.maybe(f.Object),
+    address: f.maybe(f.String),
+    hash: f.maybe(f.BufferN(20)),
+    output: f.maybe(f.BufferN(25)),
+    pubkey: f.maybe(L),
+    signature: f.maybe(Y),
+    input: f.maybe(f.Buffer)
+  }, e);
+  const r = C(() => {
+    const o = h.from(Oe.decode(e.address)), u = o.readUInt8(0), c = o.slice(1);
+    return { version: u, hash: c };
+  }), n = C(() => b(e.input)), s = e.network || K, i = {
+    name: G.P2PKH,
+    network: s,
+    hash: void 0
+  };
+  if (w(i, "address", () => {
+    if (!i.hash)
+      return;
+    const o = h.allocUnsafe(21);
+    return o.writeUInt8(s.pubKeyHash, 0), i.hash.copy(o, 1), Oe.encode(o);
+  }), w(i, "hash", () => {
+    if (e.output)
+      return e.output.slice(3, 23);
+    if (e.address)
+      return r().hash;
+    if (e.pubkey || i.pubkey)
+      return x(e.pubkey || i.pubkey);
+  }), w(i, "output", () => {
+    if (i.hash)
+      return H([
+        ee.OP_DUP,
+        ee.OP_HASH160,
+        i.hash,
+        ee.OP_EQUALVERIFY,
+        ee.OP_CHECKSIG
+      ]);
+  }), w(i, "pubkey", () => {
+    if (e.input)
+      return n()[1];
+  }), w(i, "signature", () => {
+    if (e.input)
+      return n()[0];
+  }), w(i, "input", () => {
+    if (!e.pubkey || !e.signature)
+      return;
+    let o = e.pubkey;
+    if (e.useHybrid || e.useUncompressed) {
+      const u = _t(e.pubkey);
+      u && (e.useUncompressed ? o = u.uncompressed : o = u.hybrid);
+    }
+    return H([e.signature, o]);
+  }), w(i, "witness", () => {
+    if (i.input)
+      return [];
+  }), t.validate) {
+    let o = h.from([]);
+    if (e.address) {
+      if (r().version !== s.pubKeyHash)
+        throw new TypeError("Invalid version or Network mismatch");
+      if (r().hash.length !== 20)
+        throw new TypeError("Invalid address");
+      o = r().hash;
+    }
+    if (e.hash) {
+      if (o.length > 0 && !o.equals(e.hash))
+        throw new TypeError("Hash mismatch");
+      o = e.hash;
+    }
+    if (e.output) {
+      if (e.output.length !== 25 || e.output[0] !== ee.OP_DUP || e.output[1] !== ee.OP_HASH160 || e.output[2] !== 20 || e.output[23] !== ee.OP_EQUALVERIFY || e.output[24] !== ee.OP_CHECKSIG)
+        throw new TypeError("Output is invalid");
+      const u = e.output.slice(3, 23);
+      if (o.length > 0 && !o.equals(u))
+        throw new TypeError("Hash mismatch");
+      o = u;
+    }
+    if (e.pubkey) {
+      const u = x(e.pubkey);
+      let c = o.length > 0 && !o.equals(u);
+      if (c && (e.pubkey.length === 33 && (e.pubkey[0] === 2 || e.pubkey[0] === 3) || e.pubkey.length === 65 && e.pubkey[0] === 4)) {
+        const a = _t(e.pubkey);
+        if (a) {
+          const p = x(a.uncompressed);
+          if (o.equals(p))
+            c = !1, e.useUncompressed = !0;
+          else {
+            const l = x(a.hybrid);
+            c = !o.equals(l), c || (e.useHybrid = !0);
+          }
+        }
+      }
+      if (c)
+        throw new TypeError("Hash mismatch");
+      o = u;
+    }
+    if (e.input) {
+      const u = n();
+      if (u.length !== 2)
+        throw new TypeError("Input is invalid");
+      if (!Y(u[0]))
+        throw new TypeError("Input has invalid signature");
+      if (!L(u[1]))
+        throw new TypeError("Input has invalid pubkey");
+      if (e.signature && !e.signature.equals(u[0]))
+        throw new TypeError("Signature mismatch");
+      if (e.pubkey && !e.pubkey.equals(u[1]))
+        throw new TypeError("Pubkey mismatch");
+      const c = x(u[1]);
+      if (o.length > 0 && !o.equals(c))
+        throw new TypeError("Hash mismatch (input)");
+    }
+  }
+  return Object.assign(i, e);
+}
+var G;
+(function(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";
+})(G || (G = {}));
+const ti = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LEAF_VERSION_TAPSCRIPT: Nt,
+  MAX_TAPTREE_DEPTH: Wr,
+  get PaymentType() {
+    return G;
+  },
+  findScriptPath: Ae,
+  p2data: ls,
+  p2ms: Ne,
+  p2op: tn,
+  p2pk: Ut,
+  p2pkh: de,
+  p2sh: he,
+  p2tr: pe,
+  p2wpkh: xe,
+  p2wsh: le,
+  prop: w,
+  rootHashFromPath: Xe,
+  tapTweakHash: Gr,
+  tapleafHash: j,
+  toHashTree: De,
+  tweakKey: ye,
+  value: C
+}, Symbol.toStringTag, { value: "Module" })), ri = {
+  network: K,
+  maximumFeeRate: 5e3
+};
+class bt {
+  constructor(t = {}, r = new Ct.Psbt(new un())) {
+    this.data = r, this.opts = Object.assign({}, ri, t), this.__CACHE = {
+      __NON_WITNESS_UTXO_TX_CACHE: [],
+      __NON_WITNESS_UTXO_BUF_CACHE: [],
+      __TX_IN_CACHE: {},
+      __TX: this.data.globalMap.unsignedTx.tx,
+      __UNSAFE_SIGN_NONSEGWIT: !1
+    }, t.version === 3 ? this.setVersionTRUC() : this.data.inputs.length === 0 && this.setVersion(2);
+    const n = (s, i, o, u) => {
+      Object.defineProperty(s, i, {
+        enumerable: o,
+        writable: u
+      });
+    };
+    n(this, "__CACHE", !1, !0), n(this, "opts", !1, !0);
+  }
+  get inputCount() {
+    return this.data.inputs.length;
+  }
+  get version() {
+    return this.__CACHE.__TX.version;
+  }
+  set version(t) {
+    this.setVersion(t);
+  }
+  get locktime() {
+    return this.__CACHE.__TX.locktime;
+  }
+  set locktime(t) {
+    this.setLocktime(t);
+  }
+  get txInputs() {
+    return this.__CACHE.__TX.ins.map((t) => ({
+      hash: Wt(t.hash),
+      index: t.index,
+      sequence: t.sequence
+    }));
+  }
+  get txOutputs() {
+    return this.__CACHE.__TX.outs.map((t) => {
+      let r;
+      try {
+        r = es(t.script, this.opts.network);
+      } catch {
+      }
+      return {
+        script: Wt(t.script),
+        value: t.value,
+        address: r
+      };
+    });
+  }
+  static fromBase64(t, r = {}) {
+    const n = h.from(t, "base64");
+    return this.fromBuffer(n, r);
+  }
+  static fromHex(t, r = {}) {
+    const n = h.from(t, "hex");
+    return this.fromBuffer(n, r);
+  }
+  static fromBuffer(t, r = {}) {
+    const n = Ct.Psbt.fromBuffer(t, ni), s = new bt(r, n);
+    return fi(s.__CACHE.__TX, s.__CACHE), s;
+  }
+  combine(...t) {
+    return this.data.combine(...t.map((r) => r.data)), this;
+  }
+  clone() {
+    return bt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
+  }
+  setMaximumFeeRate(t) {
+    Ve(t), this.opts.maximumFeeRate = t;
+  }
+  setVersion(t) {
+    Ve(t), ge(this.data.inputs, "setVersion");
+    const r = this.__CACHE;
+    return r.__TX.version = t, r.__EXTRACTED_TX = void 0, this;
+  }
+  setVersionTRUC() {
+    return this.setVersion(d.TRUC_VERSION);
+  }
+  setLocktime(t) {
+    Ve(t), ge(this.data.inputs, "setLocktime");
+    const r = this.__CACHE;
+    return r.__TX.locktime = t, r.__EXTRACTED_TX = void 0, this;
+  }
+  setInputSequence(t, r) {
+    Ve(r), ge(this.data.inputs, "setInputSequence");
+    const n = this.__CACHE;
+    if (n.__TX.ins.length <= t)
+      throw new Error("Input index too high");
+    return n.__TX.ins[t].sequence = r, n.__EXTRACTED_TX = void 0, this;
+  }
+  addInputs(t, r = !0) {
+    return t.forEach((n) => this.addInput(n, r)), this;
+  }
+  addInput(t, r = !0) {
+    if (!t || t.hash === void 0 || t.index === void 0)
+      throw new Error("Invalid arguments for Psbt.addInput. Requires single object with at least [hash] and [index]");
+    sr(t, t, "addInput"), r && ge(this.data.inputs, "addInput"), t.witnessScript && Ye(t.witnessScript);
+    const n = this.__CACHE;
+    this.data.addInput(t);
+    const s = n.__TX.ins[n.__TX.ins.length - 1];
+    an(n, s);
+    const i = this.data.inputs.length - 1, o = this.data.inputs[i];
+    return o.nonWitnessUtxo && Ot(this.__CACHE, o, i), n.__FEE = void 0, n.__FEE_RATE = void 0, n.__EXTRACTED_TX = void 0, this;
+  }
+  addOutputs(t) {
+    return t.forEach((r) => this.addOutput(r)), this;
+  }
+  addOutput(t) {
+    if (arguments.length > 1 || !t || t.value === void 0 || t.address === void 0 && t.script === void 0)
+      throw new Error("Invalid arguments for Psbt.addOutput. Requires single object with at least [script or address] and [value]");
+    ge(this.data.inputs, "addOutput");
+    const { address: r } = t;
+    if (typeof r == "string") {
+      const { network: s } = this.opts, i = ts(r, s);
+      t = Object.assign({}, t, { script: i });
+    }
+    ir(t, t, "addOutput");
+    const n = this.__CACHE;
+    return this.data.addOutput(t), n.__FEE = void 0, n.__FEE_RATE = void 0, n.__EXTRACTED_TX = void 0, this;
+  }
+  extractTransaction(t, r) {
+    if (r && (this.data.inputs = this.data.inputs.filter((i) => !i.partialSig)), !this.data.inputs.every(fn))
+      throw new Error("Not finalized");
+    const n = this.__CACHE;
+    if (t || ii(this, n, this.opts), n.__EXTRACTED_TX)
+      return n.__EXTRACTED_TX;
+    const s = n.__TX.clone();
+    return gn(this.data.inputs, s, n, !0, r), s;
+  }
+  getFeeRate(t = !1) {
+    return gr("__FEE_RATE", "fee rate", this.data.inputs, this.__CACHE, t);
+  }
+  getFee(t = !1) {
+    return gr("__FEE", "fee", this.data.inputs, this.__CACHE, t);
+  }
+  finalizeAllInputs() {
+    return U.checkForInput(this.data.inputs, 0), me(this.data.inputs.length).forEach((t) => this.finalizeInput(t)), this;
+  }
+  finalizeInput(t, r, n) {
+    const s = U.checkForInput(this.data.inputs, t);
+    return q(s) ? this._finalizeTaprootInput(t, s, void 0, r) : this._finalizeInput(t, s, r, n ?? !0);
+  }
+  finalizeTaprootInput(t, r, n = nr) {
+    const s = U.checkForInput(this.data.inputs, t);
+    if (q(s))
+      return this._finalizeTaprootInput(t, s, r, n);
+    throw new Error(`Cannot finalize input #${t}. Not Taproot.`);
+  }
+  getInputType(t) {
+    const r = U.checkForInput(this.data.inputs, t), n = mn(t, r, this.__CACHE), s = ut(n, t, "input", r.redeemScript || yi(r.finalScriptSig), r.witnessScript || Ei(r.finalScriptWitness)), i = s.type === "raw" ? "" : s.type + "-", o = En(s.meaningfulScript);
+    return i + o;
+  }
+  inputHasPubkey(t, r) {
+    const n = U.checkForInput(this.data.inputs, t);
+    return gi(r, n, t, this.__CACHE);
+  }
+  inputHasHDKey(t, r) {
+    const n = U.checkForInput(this.data.inputs, t), s = lr(r);
+    return !!n.bip32Derivation && n.bip32Derivation.some(s);
+  }
+  outputHasPubkey(t, r) {
+    const n = U.checkForOutput(this.data.outputs, t);
+    return mi(r, n, t, this.__CACHE);
+  }
+  outputHasHDKey(t, r) {
+    const n = U.checkForOutput(this.data.outputs, t), s = lr(r);
+    return !!n.bip32Derivation && n.bip32Derivation.some(s);
+  }
+  validateSignaturesOfAllInputs(t) {
+    return U.checkForInput(this.data.inputs, 0), me(this.data.inputs.length).map((n) => this.validateSignaturesOfInput(n, t)).reduce((n, s) => s === !0 && n, !0);
+  }
+  validateSignaturesOfInput(t, r, n) {
+    const s = this.data.inputs[t];
+    return q(s) ? this.validateSignaturesOfTaprootInput(t, r, n) : this._validateSignaturesOfInput(t, r, n);
+  }
+  signAllInputsHD(t, r = [d.SIGHASH_ALL]) {
+    if (!t || !t.publicKey || !t.fingerprint)
+      throw new Error("Need HDSigner to sign input");
+    const n = [];
+    for (const s of me(this.data.inputs.length))
+      try {
+        this.signInputHD(s, t, r), n.push(!0);
+      } catch {
+        n.push(!1);
+      }
+    if (n.every((s) => s === !1))
+      throw new Error("No inputs were signed");
+    return this;
+  }
+  signAllInputsHDAsync(t, r = [d.SIGHASH_ALL]) {
+    return new Promise((n, s) => {
+      if (!t || !t.publicKey || !t.fingerprint)
+        return s(new Error("Need HDSigner to sign input"));
+      const i = [], o = [];
+      for (const u of me(this.data.inputs.length))
+        o.push(this.signInputHDAsync(u, t, r).then(() => {
+          i.push(!0);
+        }, () => {
+          i.push(!1);
+        }));
+      return Promise.all(o).then(() => {
+        if (i.every((u) => u === !1))
+          return s(new Error("No inputs were signed"));
+        n();
+      });
+    });
+  }
+  signInputHD(t, r, n = [d.SIGHASH_ALL]) {
+    if (!r || !r.publicKey || !r.fingerprint)
+      throw new Error("Need HDSigner to sign input");
+    return Er(t, this.data.inputs, r).forEach((i) => this.signInput(t, i, n)), this;
+  }
+  signInputHDAsync(t, r, n = [d.SIGHASH_ALL]) {
+    return new Promise((s, i) => {
+      if (!r || !r.publicKey || !r.fingerprint)
+        return i(new Error("Need HDSigner to sign input"));
+      const u = Er(t, this.data.inputs, r).map((c) => this.signInputAsync(t, c, n));
+      return Promise.all(u).then(() => {
+        s();
+      }).catch(i);
+    });
+  }
+  signAllInputs(t, r) {
+    if (!t || !t.publicKey)
+      throw new Error("Need Signer to sign input");
+    const n = [];
+    for (const s of me(this.data.inputs.length))
+      try {
+        this.signInput(s, t, r), n.push(!0);
+      } catch {
+        n.push(!1);
+      }
+    if (n.every((s) => s === !1))
+      throw new Error("No inputs were signed");
+    return this;
+  }
+  signAllInputsAsync(t, r) {
+    return new Promise((n, s) => {
+      if (!t || !t.publicKey)
+        return s(new Error("Need Signer to sign input"));
+      const i = [], o = [];
+      for (const [u] of this.data.inputs.entries())
+        o.push(this.signInputAsync(u, t, r).then(() => {
+          i.push(!0);
+        }, () => {
+          i.push(!1);
+        }));
+      return Promise.all(o).then(() => {
+        if (i.every((u) => u === !1))
+          return s(new Error("No inputs were signed"));
+        n();
+      });
+    });
+  }
+  signInput(t, r, n) {
+    if (!r || !r.publicKey)
+      throw new Error("Need Signer to sign input");
+    const s = U.checkForInput(this.data.inputs, t);
+    return q(s) ? this._signTaprootInput(t, s, r, void 0, n) : this._signInput(t, r, n);
+  }
+  signTaprootInput(t, r, n, s) {
+    if (!r || !r.publicKey)
+      throw new Error("Need Signer to sign input");
+    const i = U.checkForInput(this.data.inputs, t);
+    if (q(i))
+      return this._signTaprootInput(t, i, r, n, s);
+    throw new Error(`Input #${t} is not of type Taproot.`);
+  }
+  signInputAsync(t, r, n) {
+    return Promise.resolve().then(() => {
+      if (!r || !r.publicKey)
+        throw new Error("Need Signer to sign input");
+      const s = U.checkForInput(this.data.inputs, t);
+      return q(s) ? this._signTaprootInputAsync(t, s, r, void 0, n) : this._signInputAsync(t, r, n);
+    });
+  }
+  signTaprootInputAsync(t, r, n, s) {
+    return Promise.resolve().then(() => {
+      if (!r || !r.publicKey)
+        throw new Error("Need Signer to sign input");
+      const i = U.checkForInput(this.data.inputs, t);
+      if (q(i))
+        return this._signTaprootInputAsync(t, i, r, n, s);
+      throw new Error(`Input #${t} is not of type Taproot.`);
+    });
+  }
+  toBuffer() {
+    return pt(this.__CACHE), this.data.toBuffer();
+  }
+  toHex() {
+    return pt(this.__CACHE), this.data.toHex();
+  }
+  toBase64() {
+    return pt(this.__CACHE), this.data.toBase64();
+  }
+  updateGlobal(t) {
+    return this.data.updateGlobal(t), this;
+  }
+  updateInput(t, r) {
+    return r.witnessScript && Ye(r.witnessScript), sr(this.data.inputs[t], r, "updateInput"), this.data.updateInput(t, r), r.nonWitnessUtxo && Ot(this.__CACHE, this.data.inputs[t], t), this;
+  }
+  updateOutput(t, r) {
+    const n = this.data.outputs[t];
+    return ir(n, r, "updateOutput"), this.data.updateOutput(t, r), this;
+  }
+  addUnknownKeyValToGlobal(t) {
+    return this.data.addUnknownKeyValToGlobal(t), this;
+  }
+  addUnknownKeyValToInput(t, r) {
+    return this.data.addUnknownKeyValToInput(t, r), this;
+  }
+  addUnknownKeyValToOutput(t, r) {
+    return this.data.addUnknownKeyValToOutput(t, r), this;
+  }
+  clearFinalizedInput(t) {
+    return this.data.clearFinalizedInput(t), this;
+  }
+  checkTaprootHashesForSig(t, r, n, s, i) {
+    if (typeof n.signSchnorr != "function")
+      throw new Error(`Need Schnorr Signer to sign taproot input #${t}.`);
+    const o = Tt(t, r, this.data.inputs, n.publicKey, this.__CACHE, s, i);
+    if (!o || !o.length)
+      throw new Error(`Can not sign for input #${t} with the key ${n.publicKey.toString("hex")}`);
+    return o;
+  }
+  _finalizeInput(t, r, n = ci, s = !0) {
+    const { script: i, isP2SH: o, isP2WSH: u, isSegwit: c } = li(t, r, this.__CACHE);
+    if (!i)
+      throw new Error(`No script found for input #${t}`);
+    oi(r);
+    const { finalScriptSig: a, finalScriptWitness: p } = n(t, r, i, c, o, u, s);
+    if (a && this.data.updateInput(t, { finalScriptSig: a }), p && this.data.updateInput(t, { finalScriptWitness: p }), !a && !p)
+      throw new Error(`Unknown error finalizing input #${t}`);
+    return this.data.clearFinalizedInput(t), this;
+  }
+  _finalizeTaprootInput(t, r, n, s = nr) {
+    if (!r.witnessUtxo)
+      throw new Error(`Cannot finalize input #${t}. Missing witness utxo.`);
+    if (r.tapKeySig) {
+      const i = pe({
+        output: r.witnessUtxo.script,
+        signature: r.tapKeySig
+      }), o = Te(i.witness);
+      this.data.updateInput(t, { finalScriptWitness: o });
+    } else {
+      const { finalScriptWitness: i } = s(t, r, n);
+      this.data.updateInput(t, { finalScriptWitness: i });
+    }
+    return this.data.clearFinalizedInput(t), this;
+  }
+  _validateSignaturesOfInput(t, r, n) {
+    const s = this.data.inputs[t], i = (s || {}).partialSig;
+    if (!s || !i || i.length < 1)
+      throw new Error("No signatures to validate");
+    if (typeof r != "function")
+      throw new Error("Need validator function to validate signatures");
+    const o = n ? i.filter((l) => l.pubkey.equals(n)) : i;
+    if (o.length < 1)
+      throw new Error("No signatures for this pubkey");
+    const u = [];
+    let c, a, p;
+    for (const l of o) {
+      const m = fe.decode(l.signature), { hash: T, script: y } = p !== m.hashType ? pn(t, Object.assign({}, s, {
+        sighashType: m.hashType
+      }), this.__CACHE, !0) : { hash: c, script: a };
+      p = m.hashType, c = T, a = y, cn(l.pubkey, y, "verify"), u.push(r(l.pubkey, T, m.signature));
+    }
+    return u.every((l) => l === !0);
+  }
+  validateSignaturesOfTaprootInput(t, r, n) {
+    const s = this.data.inputs[t], i = (s || {}).tapKeySig, o = (s || {}).tapScriptSig;
+    if (!s && !i && !(o && !o.length))
+      throw new Error("No signatures to validate");
+    if (typeof r != "function")
+      throw new Error("Need validator function to validate signatures");
+    n = n && be(n);
+    const u = n ? Tt(t, s, this.data.inputs, n, this.__CACHE) : hi(t, s, this.data.inputs, this.__CACHE);
+    if (!u.length)
+      throw new Error("No signatures for this pubkey");
+    const c = u.find((p) => !p.leafHash);
+    let a = 0;
+    if (i && c) {
+      if (!r(c.pubkey, c.hash, yr(i)))
+        return !1;
+      a++;
+    }
+    if (o)
+      for (const p of o) {
+        const l = u.find((m) => p.pubkey.equals(m.pubkey));
+        if (l) {
+          if (!r(p.pubkey, l.hash, yr(p.signature)))
+            return !1;
+          a++;
+        }
+      }
+    return a > 0;
+  }
+  _signInput(t, r, n = [d.SIGHASH_ALL]) {
+    const { hash: s, sighashType: i } = mr(this.data.inputs, t, r.publicKey, this.__CACHE, n), o = [
+      {
+        pubkey: r.publicKey,
+        signature: fe.encode(r.sign(s), i)
+      }
+    ];
+    return this.data.updateInput(t, { partialSig: o }), this;
+  }
+  _signTaprootInput(t, r, n, s, i = [d.SIGHASH_DEFAULT]) {
+    const o = this.checkTaprootHashesForSig(t, r, n, s, i), u = o.filter((a) => !a.leafHash).map((a) => Be(n.signSchnorr(a.hash), r.sighashType))[0], c = o.filter((a) => !!a.leafHash).map((a) => ({
+      pubkey: be(n.publicKey),
+      signature: Be(n.signSchnorr(a.hash), r.sighashType),
+      leafHash: a.leafHash
+    }));
+    return u && this.data.updateInput(t, { tapKeySig: u }), c.length && this.data.updateInput(t, { tapScriptSig: c }), this;
+  }
+  _signInputAsync(t, r, n = [d.SIGHASH_ALL]) {
+    const { hash: s, sighashType: i } = mr(this.data.inputs, t, r.publicKey, this.__CACHE, n);
+    return Promise.resolve(r.sign(s)).then((o) => {
+      const u = [
+        {
+          pubkey: r.publicKey,
+          signature: fe.encode(o, i)
+        }
+      ];
+      this.data.updateInput(t, { partialSig: u });
+    });
+  }
+  async _signTaprootInputAsync(t, r, n, s, i = [d.SIGHASH_DEFAULT]) {
+    const o = this.checkTaprootHashesForSig(t, r, n, s, i), u = [], c = o.filter((l) => !l.leafHash)[0];
+    if (c) {
+      const l = Promise.resolve(n.signSchnorr(c.hash)).then((m) => ({
+        tapKeySig: Be(m, r.sighashType)
+      }));
+      u.push(l);
+    }
+    const a = o.filter((l) => !!l.leafHash);
+    if (a.length) {
+      const l = a.map(async (m) => {
+        const T = await n.signSchnorr(m.hash);
+        return { tapScriptSig: [
+          {
+            pubkey: be(n.publicKey),
+            signature: Be(T, r.sighashType),
+            leafHash: m.leafHash
+          }
+        ] };
+      });
+      u.push(...l);
+    }
+    const p = await Promise.all(u);
+    for (const l of p)
+      this.data.updateInput(t, l);
+  }
+}
+const ni = (e) => new un(e);
+class un {
+  constructor(t = h.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
+    this.tx = d.fromBuffer(t), ui(this.tx), Object.defineProperty(this, "tx", {
+      enumerable: !1,
+      writable: !0
+    });
+  }
+  getInputOutputCounts() {
+    return {
+      inputCount: this.tx.ins.length,
+      outputCount: this.tx.outs.length
+    };
+  }
+  addInput(t) {
+    if (t.hash === void 0 || t.index === void 0 || !h.isBuffer(t.hash) && typeof t.hash != "string" || typeof t.index != "number")
+      throw new Error("Error adding input.");
+    const r = typeof t.hash == "string" ? kt(h.from(t.hash, "hex")) : t.hash;
+    this.tx.addInput(r, t.index, t.sequence);
+  }
+  addOutput(t) {
+    if (t.script === void 0 || t.value === void 0 || !h.isBuffer(t.script) || typeof t.value != "number")
+      throw new Error("Error adding output.");
+    this.tx.addOutput(t.script, t.value);
+  }
+  toBuffer() {
+    return this.tx.toBuffer();
+  }
+}
+function si(e, t, r) {
+  switch (r) {
+    case "pubkey":
+    case "pubkeyhash":
+    case "witnesspubkeyhash":
+      return pr(1, e.partialSig);
+    case "multisig":
+      const n = Ne({
+        output: t
+      });
+      return pr(n.m, e.partialSig, n.pubkeys);
+    case "nonstandard":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function pt(e) {
+  if (e.__UNSAFE_SIGN_NONSEGWIT !== !1)
+    throw new Error("Not BIP174 compliant, can not export");
+}
+function pr(e, t, r) {
+  if (!t)
+    return !1;
+  let n;
+  if (r ? n = r.map((s) => {
+    const i = Si(s);
+    return t.find((o) => o.pubkey.equals(i));
+  }).filter((s) => !!s) : n = t, n.length > e)
+    throw new Error("Too many signatures");
+  return n.length === e;
+}
+function fn(e) {
+  return !!e.finalScriptSig || !!e.finalScriptWitness;
+}
+function lr(e) {
+  return (t) => !(!t.masterFingerprint.equals(e.fingerprint) || !e.derivePath(t.path).publicKey.equals(t.pubkey));
+}
+function Ve(e) {
+  if (typeof e != "number" || e !== Math.floor(e) || e > 4294967295 || e < 0)
+    throw new Error("Invalid 32 bit integer");
+}
+function ii(e, t, r) {
+  const n = t.__FEE_RATE || e.getFeeRate(), s = t.__EXTRACTED_TX.virtualSize(), i = n * s;
+  if (n >= r.maximumFeeRate)
+    throw new Error(`Warning: You are paying around ${(i / 1e8).toFixed(8)} in fees, which is ${n} satoshi per byte for a transaction with a VSize of ${s} bytes (segwit counted as 0.25 byte per byte). Use setMaximumFeeRate method to raise your threshold, or pass true to the first arg of extractTransaction.`);
+}
+function ge(e, t) {
+  e.forEach((r) => {
+    if (q(r) ? Fs(r, t) : Qs(r, t))
+      throw new Error("Can not modify transaction, signatures exist.");
+  });
+}
+function oi(e) {
+  if (!e.sighashType || !e.partialSig)
+    return;
+  const { partialSig: t, sighashType: r } = e;
+  t.forEach((n) => {
+    const { hashType: s } = fe.decode(n.signature);
+    if (r !== s)
+      throw new Error("Signature sighash does not match input sighash type");
+  });
+}
+function cn(e, t, r) {
+  if (!it(e, t))
+    throw new Error(`Can not ${r} for this input with the key ${e.toString("hex")}`);
+}
+function ui(e) {
+  if (!e.ins.every((r) => r.script && r.script.length === 0 && r.witness && r.witness.length === 0))
+    throw new Error("Format Error: Transaction ScriptSigs are not empty");
+}
+function fi(e, t) {
+  e.ins.forEach((r) => {
+    an(t, r);
+  });
+}
+function an(e, t) {
+  const r = kt(h.from(t.hash)).toString("hex") + ":" + t.index;
+  if (e.__TX_IN_CACHE[r])
+    throw new Error("Duplicate input detected.");
+  e.__TX_IN_CACHE[r] = 1;
+}
+function hn(e, t) {
+  return (r, n, s, i) => {
+    const o = e({
+      redeem: { output: s }
+    }).output;
+    if (!n.equals(o))
+      throw new Error(`${t} for ${i} #${r} doesn't match the scriptPubKey in the prevout`);
+  };
+}
+const dr = hn(he, "Redeem script"), wr = hn(le, "Witness script");
+function gr(e, t, r, n, s = !1) {
+  if (!r.every(fn))
+    throw new Error(`PSBT must be finalized to calculate ${t}`);
+  if (e === "__FEE_RATE" && n.__FEE_RATE)
+    return n.__FEE_RATE;
+  if (e === "__FEE" && n.__FEE)
+    return n.__FEE;
+  let i, o = !0;
+  if (n.__EXTRACTED_TX ? (i = n.__EXTRACTED_TX, o = !1) : i = n.__TX.clone(), gn(r, i, n, o, s), e === "__FEE_RATE")
+    return n.__FEE_RATE;
+  if (e === "__FEE")
+    return n.__FEE;
+}
+function ci(e, t, r, n, s, i, o = !0, u) {
+  const c = En(r);
+  if (!si(t, r, c) && o)
+    throw new Error(`Can not finalize input #${e}`);
+  return ai(r, c, t.partialSig, n, s, i, u);
+}
+function ai(e, t, r, n, s, i, o) {
+  let u, c;
+  const a = pi(e, t, r), p = i ? le({ redeem: a }) : null, l = s ? he({ redeem: p || a }) : null;
+  return n ? (p ? c = Te(p.witness) : a ? c = Te(a.witness) : c = Te(o ?? [h.from([0])]), l && (u = l?.input)) : l ? u = l?.input : a ? u = a.input : u = Array.isArray(o) && o[0] ? o[0] : h.from([1]), {
+    finalScriptSig: u,
+    finalScriptWitness: c
+  };
+}
+function mr(e, t, r, n, s) {
+  const i = U.checkForInput(e, t), { hash: o, sighashType: u, script: c } = pn(t, i, n, !1, s);
+  return cn(r, c, "sign"), {
+    hash: o,
+    sighashType: u
+  };
+}
+function pn(e, t, r, n, s) {
+  const i = r.__TX, o = t.sighashType || d.SIGHASH_ALL;
+  dn(o, s);
+  let u, c;
+  if (t.nonWitnessUtxo) {
+    const l = ot(r, t, e), m = i.ins[e].hash, T = l.getHash();
+    if (!m.equals(T))
+      throw new Error(`Non-witness UTXO hash for input #${e} doesn't match the hash specified in the prevout`);
+    const y = i.ins[e].index;
+    c = l.outs[y];
+  } else if (t.witnessUtxo)
+    c = t.witnessUtxo;
+  else
+    throw new Error("Need a Utxo input item for signing");
+  const { meaningfulScript: a, type: p } = ut(c.script, e, "input", t.redeemScript, t.witnessScript);
+  if (["p2sh-p2wsh", "p2wsh"].indexOf(p) >= 0)
+    u = i.hashForWitnessV0(e, a, c.value, o);
+  else if (st(a)) {
+    const l = de({
+      hash: a.slice(2)
+    }).output;
+    u = i.hashForWitnessV0(e, l, c.value, o);
+  } else {
+    if (t.nonWitnessUtxo === void 0 && r.__UNSAFE_SIGN_NONSEGWIT === !1)
+      throw new Error(`Input #${e} has witnessUtxo but non-segwit script: ${a.toString("hex")}`);
+    !n && r.__UNSAFE_SIGN_NONSEGWIT !== !1 && console.warn(`Warning: Signing non-segwit inputs without the full parent transaction means there is a chance that a miner could feed you incorrect information to trick you into paying large fees. This behavior is the same as Psbt's predecessor (TransactionBuilder - now removed) when signing non-segwit scripts. You are not able to export this Psbt with toBuffer|toBase64|toHex since it is not BIP174 compliant.
+*********************
+PROCEED WITH CAUTION!
+*********************`), u = i.hashForSignature(e, a, o);
+  }
+  return {
+    script: a,
+    sighashType: o,
+    hash: u
+  };
+}
+function hi(e, t, r, n) {
+  const s = [];
+  if (t.tapInternalKey) {
+    const o = ln(e, t, n);
+    o && s.push(o);
+  }
+  if (t.tapScriptSig) {
+    const o = t.tapScriptSig.map((u) => u.pubkey);
+    s.push(...o);
+  }
+  return s.map((o) => Tt(e, t, r, o, n)).flat();
+}
+function ln(e, t, r) {
+  const { script: n } = xt(e, t, r);
+  return nn(n) ? h.from(n.subarray(2, 34)) : null;
+}
+function yr(e) {
+  return e.length === 64 ? e : h.from(e.subarray(0, 64));
+}
+function Tt(e, t, r, n, s, i, o) {
+  const u = s.__TX, c = t.sighashType || d.SIGHASH_DEFAULT;
+  dn(c, o);
+  const a = r.map((y, O) => xt(O, y, s)), p = a.map((y) => y.script), l = a.map((y) => y.value), m = [];
+  if (t.tapInternalKey && !i) {
+    const y = ln(e, t, s) || h.from([]);
+    if (be(n).equals(y)) {
+      const O = u.hashForWitnessV1(e, p, l, c);
+      m.push({ pubkey: n, hash: O });
+    }
+  }
+  const T = (t.tapLeafScript || []).filter((y) => it(n, y.script)).map((y) => {
+    const O = j({
+      output: y.script,
+      version: y.leafVersion
+    });
+    return Object.assign({ hash: O }, y);
+  }).filter((y) => !i || i.equals(y.hash)).map((y) => {
+    const O = u.hashForWitnessV1(e, p, l, c, y.hash);
+    return {
+      pubkey: n,
+      hash: O,
+      leafHash: y.hash
+    };
+  });
+  return m.concat(T);
+}
+function dn(e, t) {
+  if (t && t.indexOf(e) < 0) {
+    const r = wi(e);
+    throw new Error(`Sighash type is not allowed. Retry the sign method passing the sighashTypes array of whitelisted types. Sighash type: ${r}`);
+  }
+}
+function pi(e, t, r) {
+  let n;
+  switch (t) {
+    case "multisig": {
+      const s = di(e, r);
+      n = Ne({
+        output: e,
+        signatures: s
+      });
+      break;
+    }
+    case "pubkey":
+      n = Ut({
+        output: e,
+        signature: r[0].signature
+      });
+      break;
+    case "pubkeyhash":
+      n = de({
+        output: e,
+        pubkey: r[0].pubkey,
+        signature: r[0].signature
+      });
+      break;
+    case "witnesspubkeyhash":
+      n = xe({
+        output: e,
+        pubkey: r[0].pubkey,
+        signature: r[0].signature
+      });
+      break;
+  }
+  return n;
+}
+function li(e, t, r) {
+  const n = r.__TX, s = {
+    script: null,
+    isSegwit: !1,
+    isP2SH: !1,
+    isP2WSH: !1
+  };
+  if (s.isP2SH = !!t.redeemScript, s.isP2WSH = !!t.witnessScript, t.witnessScript)
+    s.script = t.witnessScript;
+  else if (t.redeemScript)
+    s.script = t.redeemScript;
+  else if (t.nonWitnessUtxo) {
+    const i = ot(r, t, e), o = n.ins[e].index;
+    s.script = i.outs[o].script;
+  } else t.witnessUtxo && (s.script = t.witnessUtxo.script);
+  if (t.witnessScript || st(s.script))
+    s.isSegwit = !0;
+  else
+    try {
+      const i = s.script;
+      if (!i)
+        throw new TypeError("Invalid script for segwit address");
+      s.isSegwit = jn(i);
+    } catch {
+    }
+  return s;
+}
+function Er(e, t, r) {
+  const n = U.checkForInput(t, e);
+  if (!n.bip32Derivation || n.bip32Derivation.length === 0)
+    throw new Error("Need bip32Derivation to sign with HD");
+  const s = n.bip32Derivation.map((i) => {
+    if (i.masterFingerprint.equals(r.fingerprint))
+      return i;
+  }).filter((i) => !!i);
+  if (s.length === 0)
+    throw new Error("Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint");
+  return s.map((i) => {
+    const o = r.derivePath(i.path);
+    if (!i.pubkey.equals(o.publicKey))
+      throw new Error("pubkey did not match bip32Derivation");
+    return o;
+  });
+}
+function di(e, t) {
+  return Ne({ output: e }).pubkeys.map((n) => (t.filter((s) => s.pubkey.equals(n))[0] || {}).signature).filter((n) => !!n);
+}
+function wn(e) {
+  let t = 0;
+  function r(o) {
+    return t += o, e.slice(t - o, t);
+  }
+  function n() {
+    const o = Ke.decode(e, t);
+    return t += Ke.decode.bytes, o;
+  }
+  function s() {
+    return r(n());
+  }
+  function i() {
+    const o = n(), u = [];
+    for (let c = 0; c < o; c++)
+      u.push(s());
+    return u;
+  }
+  return i();
+}
+function wi(e) {
+  let t = e & d.SIGHASH_ANYONECANPAY ? "SIGHASH_ANYONECANPAY | " : "";
+  switch (e & 31) {
+    case d.SIGHASH_ALL:
+      t += "SIGHASH_ALL";
+      break;
+    case d.SIGHASH_SINGLE:
+      t += "SIGHASH_SINGLE";
+      break;
+    case d.SIGHASH_NONE:
+      t += "SIGHASH_NONE";
+      break;
+  }
+  return t;
+}
+function Ot(e, t, r) {
+  e.__NON_WITNESS_UTXO_BUF_CACHE[r] = t.nonWitnessUtxo, e.__NON_WITNESS_UTXO_TX_CACHE[r] = d.fromBuffer(t.nonWitnessUtxo);
+  const n = e, s = r;
+  delete t.nonWitnessUtxo, Object.defineProperty(t, "nonWitnessUtxo", {
+    enumerable: !0,
+    get() {
+      const i = n.__NON_WITNESS_UTXO_BUF_CACHE[s], o = n.__NON_WITNESS_UTXO_TX_CACHE[s];
+      if (i !== void 0)
+        return i;
+      {
+        const u = o.toBuffer();
+        return n.__NON_WITNESS_UTXO_BUF_CACHE[s] = u, u;
+      }
+    },
+    set(i) {
+      n.__NON_WITNESS_UTXO_BUF_CACHE[s] = i;
+    }
+  });
+}
+function gn(e, t, r, n, s) {
+  let i = 0;
+  e.forEach((a, p) => {
+    if (n && a.finalScriptSig && (t.ins[p].script = a.finalScriptSig), n && a.finalScriptWitness && (t.ins[p].witness = wn(a.finalScriptWitness)), a.witnessUtxo)
+      i += a.witnessUtxo.value;
+    else if (a.nonWitnessUtxo) {
+      const l = ot(r, a, p), m = t.ins[p].index, T = l.outs[m];
+      i += T.value;
+    }
+  });
+  const o = t.outs.reduce((a, p) => a + p.value, 0), u = i - o;
+  if (!s && u < 0)
+    throw new Error(`Outputs are spending more than Inputs ${i} < ${o}`);
+  const c = t.virtualSize();
+  r.__FEE = u, r.__EXTRACTED_TX = t, r.__FEE_RATE = Math.floor(u / c);
+}
+function ot(e, t, r) {
+  const n = e.__NON_WITNESS_UTXO_TX_CACHE;
+  return n[r] || Ot(e, t, r), n[r];
+}
+function mn(e, t, r) {
+  const { script: n } = xt(e, t, r);
+  return n;
+}
+function xt(e, t, r) {
+  if (t.witnessUtxo !== void 0)
+    return {
+      script: t.witnessUtxo.script,
+      value: t.witnessUtxo.value
+    };
+  if (t.nonWitnessUtxo !== void 0) {
+    const s = ot(r, t, e).outs[r.__TX.ins[e].index];
+    return { script: s.script, value: s.value };
+  } else
+    throw new Error("Can't find pubkey in input without Utxo data");
+}
+function gi(e, t, r, n) {
+  const s = mn(r, t, n), { meaningfulScript: i } = ut(s, r, "input", t.redeemScript, t.witnessScript);
+  return it(e, i);
+}
+function mi(e, t, r, n) {
+  const s = n.__TX.outs[r].script, { meaningfulScript: i } = ut(s, r, "output", t.redeemScript, t.witnessScript);
+  return it(e, i);
+}
+function yi(e) {
+  if (!e)
+    return;
+  const t = b(e);
+  if (!t)
+    return;
+  const r = t[t.length - 1];
+  if (!(!h.isBuffer(r) || yn(r) || _i(r) || !b(r)))
+    return r;
+}
+function Ei(e) {
+  if (!e)
+    return;
+  const t = wn(e), r = t[t.length - 1];
+  if (!(yn(r) || !b(r)))
+    return r;
+}
+function Si(e) {
+  if (e.length === 65) {
+    const t = e[64] & 1, r = e.slice(0, 33);
+    return r[0] = 2 | t, r;
+  }
+  return e.slice();
+}
+function yn(e) {
+  return e.length === 33 && Rr(e);
+}
+function _i(e) {
+  return Y(e);
+}
+function ut(e, t, r, n, s) {
+  const i = rn(e), o = i && n && ar(n), u = ar(e);
+  if (i && n === void 0)
+    throw new Error("scriptPubkey is P2SH but redeemScript missing");
+  if ((u || o) && s === void 0)
+    throw new Error("scriptPubkey or redeemScript is P2WSH but witnessScript missing");
+  let c;
+  return o ? (c = s, dr(t, e, n, r), wr(t, n, s, r), Ye(c)) : u ? (c = s, wr(t, e, s, r), Ye(c)) : i ? (c = n, dr(t, e, n, r)) : c = e, {
+    meaningfulScript: c,
+    type: o ? "p2sh-p2wsh" : i ? "p2sh" : u ? "p2wsh" : "raw"
+  };
+}
+function Ye(e) {
+  if (st(e) || rn(e))
+    throw new Error("P2WPKH or P2SH can not be contained within P2WSH");
+}
+function En(e) {
+  return st(e) ? "witnesspubkeyhash" : Zs(e) ? "pubkeyhash" : js(e) ? "multisig" : Ys(e) ? "pubkey" : "nonstandard";
+}
+function me(e) {
+  return [...Array(e).keys()];
+}
+const vi = {
+  payments: ti,
+  script: Xn,
+  crypto: is
+};
+export {
+  Pi as A,
+  nn as B,
+  sn as C,
+  ci as D,
+  Zs as E,
+  st as F,
+  jn as G,
+  ar as H,
+  rn as I,
+  Hi as J,
+  Ys as K,
+  js as L,
+  bt as M,
+  ns as N,
+  G as P,
+  d as T,
+  le as a,
+  K as b,
+  xe as c,
+  pe as d,
+  vi as e,
+  H as f,
+  es as g,
+  ts as h,
+  Ai as i,
+  he as j,
+  de as k,
+  Ut as l,
+  b as m,
+  vt as n,
+  E as o,
+  Ne as p,
+  Qn as q,
+  $n as r,
+  _t as s,
+  be as t,
+  te as u,
+  x as v,
+  rs as w,
+  Gr as x,
+  M as y,
+  Ii as z
+};