@btc-vision/bitcoin 6.5.1 → 6.5.3

package/browser/chunks/psbt-BIwOrKer.js

@@ -0,0 +1,4096 @@
+import { B as l, h as ot, c as xr } from "./crypto-0PweVewC.js";
+import { o as Ce, t as Or, c as Cr, d as he, i as Hn, s as Se, a as Pr, b as Nr } from "./script-CROJPzz_.js";
+import { t as Hr, a as Ur, H as Br, U as Rr, i as Fr, b as Un, c as Ot, r as Bn } from "./utils-CO5kmxe9.js";
+import { p as _e, a as me, b as $e, c as ve, d as Ie, e as Rn, t as Kr, f as Ye, M as Fn, L as Lr, r as Mr, g as Kn, h as Ze, i as Wr } from "./payments-CgasufRS.js";
+import { T as I, a as Gr } from "./transaction-DchBu35N.js";
+const Je = {
+  /**
+   * The message prefix used for signing Bitcoin messages.
+   */
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  /**
+   * The Bech32 prefix used for Bitcoin addresses.
+   */
+  bech32: "bc",
+  bech32Opnet: "op",
+  /**
+   * The BIP32 key prefixes for Bitcoin.
+   */
+  bip32: {
+    /**
+     * The public key prefix for BIP32 extended public keys.
+     */
+    public: 76067358,
+    /**
+     * The private key prefix for BIP32 extended private keys.
+     */
+    private: 76066276
+  },
+  /**
+   * The prefix for Bitcoin public key hashes.
+   */
+  pubKeyHash: 0,
+  /**
+   * The prefix for Bitcoin script hashes.
+   */
+  scriptHash: 5,
+  /**
+   * The prefix for Bitcoin Wallet Import Format (WIF) private keys.
+   */
+  wif: 128
+}, Xr = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "bcrt",
+  bech32Opnet: "opr",
+  bip32: {
+    public: 70617039,
+    private: 70615956
+  },
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+}, qr = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "tb",
+  bech32Opnet: "opt",
+  bip32: {
+    public: 70617039,
+    private: 70615956
+  },
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+}, Dr = {
+  messagePrefix: `Dogecoin Signed Message:
+`,
+  bech32: "",
+  // Dogecoin does not currently use Bech32
+  bech32Opnet: "",
+  bip32: {
+    public: 49990397,
+    private: 49988504
+  },
+  pubKeyHash: 30,
+  scriptHash: 22,
+  wif: 158
+}, Vr = {
+  messagePrefix: `Dogecoin Signed Message:
+`,
+  bech32: "",
+  // Dogecoin testnet does not currently use Bech32
+  bech32Opnet: "",
+  bip32: {
+    public: 70429096,
+    private: 70427203
+  },
+  pubKeyHash: 113,
+  scriptHash: 196,
+  wif: 241
+}, jr = {
+  messagePrefix: `Litecoin Signed Message:
+`,
+  bech32: "ltc",
+  bech32Opnet: "opl",
+  bip32: {
+    public: 27108450,
+    private: 27106558
+  },
+  pubKeyHash: 48,
+  scriptHash: 50,
+  wif: 176
+}, zr = {
+  messagePrefix: `Litecoin Signed Message:
+`,
+  bech32: "tltc",
+  bech32Opnet: "oplt",
+  bip32: {
+    public: 70709117,
+    private: 70711009
+  },
+  pubKeyHash: 111,
+  scriptHash: 58,
+  wif: 239
+}, $r = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  // Cashaddr prefix differs from bech32 for general usage, but we can set it similarly.
+  // Actual cashaddr prefix is "bitcoincash", but this field is for bech32 which BCH doesn't fully use for segwit (it doesn't have segwit).
+  bech32: "bitcoincash",
+  bech32Opnet: "opbch",
+  bip32: {
+    public: 76067358,
+    private: 76066276
+  },
+  pubKeyHash: 0,
+  scriptHash: 5,
+  wif: 128
+}, Yr = {
+  messagePrefix: `Bitcoin Signed Message:
+`,
+  bech32: "bchtest",
+  bech32Opnet: "opbcht",
+  bip32: {
+    public: 70617039,
+    private: 70615956
+  },
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+}, Zr = {
+  // Historically Dash used DarkCoin message prefix, and most implementations use this:
+  // As of Dash Core 0.17, this has not changed in code.
+  messagePrefix: `DarkCoin Signed Message:
+`,
+  bech32: "",
+  // Dash does not use Bech32
+  bech32Opnet: "",
+  bip32: {
+    public: 50221772,
+    private: 50221816
+  },
+  pubKeyHash: 76,
+  scriptHash: 16,
+  wif: 204
+}, Jr = {
+  messagePrefix: `DarkCoin Signed Message:
+`,
+  bech32: "",
+  // Dash testnet does not use Bech32
+  bech32Opnet: "",
+  bip32: {
+    public: 981492128,
+    private: 981489719
+  },
+  pubKeyHash: 140,
+  scriptHash: 19,
+  wif: 239
+}, Qr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bitcoin: Je,
+  bitcoinCash: $r,
+  bitcoinCashTestnet: Yr,
+  dash: Zr,
+  dashTestnet: Jr,
+  dogecoin: Dr,
+  dogecoinTestnet: Vr,
+  litecoin: jr,
+  litecoinTestnet: zr,
+  regtest: Xr,
+  testnet: qr
+}, Symbol.toStringTag, { value: "Module" }));
+var se = {}, Ct;
+function es() {
+  if (Ct) return se;
+  Ct = 1, Object.defineProperty(se, "__esModule", { value: !0 }), se.bech32m = se.bech32 = void 0;
+  const t = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", e = {};
+  for (let u = 0; u < t.length; u++) {
+    const f = t.charAt(u);
+    e[f] = u;
+  }
+  function n(u) {
+    const f = u >> 25;
+    return (u & 33554431) << 5 ^ -(f >> 0 & 1) & 996825010 ^ -(f >> 1 & 1) & 642813549 ^ -(f >> 2 & 1) & 513874426 ^ -(f >> 3 & 1) & 1027748829 ^ -(f >> 4 & 1) & 705979059;
+  }
+  function r(u) {
+    let f = 1;
+    for (let p = 0; p < u.length; ++p) {
+      const g = u.charCodeAt(p);
+      if (g < 33 || g > 126)
+        return "Invalid prefix (" + u + ")";
+      f = n(f) ^ g >> 5;
+    }
+    f = n(f);
+    for (let p = 0; p < u.length; ++p) {
+      const g = u.charCodeAt(p);
+      f = n(f) ^ g & 31;
+    }
+    return f;
+  }
+  function c(u, f, p, g) {
+    let y = 0, h = 0;
+    const d = (1 << p) - 1, w = [];
+    for (let E = 0; E < u.length; ++E)
+      for (y = y << f | u[E], h += f; h >= p; )
+        h -= p, w.push(y >> h & d);
+    if (g)
+      h > 0 && w.push(y << p - h & d);
+    else {
+      if (h >= f)
+        return "Excess padding";
+      if (y << p - h & d)
+        return "Non-zero padding";
+    }
+    return w;
+  }
+  function s(u) {
+    return c(u, 8, 5, !0);
+  }
+  function o(u) {
+    const f = c(u, 5, 8, !1);
+    if (Array.isArray(f))
+      return f;
+  }
+  function i(u) {
+    const f = c(u, 5, 8, !1);
+    if (Array.isArray(f))
+      return f;
+    throw new Error(f);
+  }
+  function a(u) {
+    let f;
+    u === "bech32" ? f = 1 : f = 734539939;
+    function p(d, w, E) {
+      if (E = E || 90, d.length + 7 + w.length > E)
+        throw new TypeError("Exceeds length limit");
+      d = d.toLowerCase();
+      let S = r(d);
+      if (typeof S == "string")
+        throw new Error(S);
+      let b = d + "1";
+      for (let _ = 0; _ < w.length; ++_) {
+        const v = w[_];
+        if (v >> 5 !== 0)
+          throw new Error("Non 5-bit word");
+        S = n(S) ^ v, b += t.charAt(v);
+      }
+      for (let _ = 0; _ < 6; ++_)
+        S = n(S);
+      S ^= f;
+      for (let _ = 0; _ < 6; ++_) {
+        const v = S >> (5 - _) * 5 & 31;
+        b += t.charAt(v);
+      }
+      return b;
+    }
+    function g(d, w) {
+      if (w = w || 90, d.length < 8)
+        return d + " too short";
+      if (d.length > w)
+        return "Exceeds length limit";
+      const E = d.toLowerCase(), S = d.toUpperCase();
+      if (d !== E && d !== S)
+        return "Mixed-case string " + d;
+      d = E;
+      const b = d.lastIndexOf("1");
+      if (b === -1)
+        return "No separator character for " + d;
+      if (b === 0)
+        return "Missing prefix for " + d;
+      const _ = d.slice(0, b), v = d.slice(b + 1);
+      if (v.length < 6)
+        return "Data too short";
+      let C = r(_);
+      if (typeof C == "string")
+        return C;
+      const m = [];
+      for (let k = 0; k < v.length; ++k) {
+        const U = v.charAt(k), R = e[U];
+        if (R === void 0)
+          return "Unknown character " + U;
+        C = n(C) ^ R, !(k + 6 >= v.length) && m.push(R);
+      }
+      return C !== f ? "Invalid checksum for " + d : { prefix: _, words: m };
+    }
+    function y(d, w) {
+      const E = g(d, w);
+      if (typeof E == "object")
+        return E;
+    }
+    function h(d, w) {
+      const E = g(d, w);
+      if (typeof E == "object")
+        return E;
+      throw new Error(E);
+    }
+    return {
+      decodeUnsafe: y,
+      decode: h,
+      encode: p,
+      toWords: s,
+      fromWordsUnsafe: o,
+      fromWords: i
+    };
+  }
+  return se.bech32 = a("bech32"), se.bech32m = a("bech32m"), se;
+}
+var M = es();
+function ts(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function vt(t, ...e) {
+  if (!ts(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function Pt(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function ns(t, e) {
+  vt(t);
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function dt(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function it(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function B(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function rs(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function Ln(t) {
+  return typeof t == "string" && (t = rs(t)), vt(t), t;
+}
+class ss {
+}
+function os(t) {
+  const e = (r) => t().update(Ln(r)).digest(), n = t();
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = () => t(), e;
+}
+function is(t, e, n, r) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, n, r);
+  const c = BigInt(32), s = BigInt(4294967295), o = Number(n >> c & s), i = Number(n & s), a = r ? 4 : 0, u = r ? 0 : 4;
+  t.setUint32(e + a, o, r), t.setUint32(e + u, i, r);
+}
+function cs(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function as(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+class us extends ss {
+  constructor(e, n, r, c) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = c, this.buffer = new Uint8Array(e), this.view = it(this.buffer);
+  }
+  update(e) {
+    Pt(this), e = Ln(e), vt(e);
+    const { view: n, buffer: r, blockLen: c } = this, s = e.length;
+    for (let o = 0; o < s; ) {
+      const i = Math.min(c - this.pos, s - o);
+      if (i === c) {
+        const a = it(e);
+        for (; c <= s - o; o += c)
+          this.process(a, o);
+        continue;
+      }
+      r.set(e.subarray(o, o + i), this.pos), this.pos += i, o += i, this.pos === c && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    Pt(this), ns(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: c, isLE: s } = this;
+    let { pos: o } = this;
+    n[o++] = 128, dt(this.buffer.subarray(o)), this.padOffset > c - o && (this.process(r, 0), o = 0);
+    for (let p = o; p < c; p++)
+      n[p] = 0;
+    is(r, c - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const i = it(e), a = this.outputLen;
+    if (a % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = a / 4, f = this.get();
+    if (u > f.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let p = 0; p < u; p++)
+      i.setUint32(4 * p, f[p], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: c, finished: s, destroyed: o, pos: i } = this;
+    return e.destroyed = o, e.finished = s, e.length = c, e.pos = i, c % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const W = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), fs = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), G = /* @__PURE__ */ new Uint32Array(64);
+class ps extends us {
+  constructor(e = 32) {
+    super(64, e, 8, !1), this.A = W[0] | 0, this.B = W[1] | 0, this.C = W[2] | 0, this.D = W[3] | 0, this.E = W[4] | 0, this.F = W[5] | 0, this.G = W[6] | 0, this.H = W[7] | 0;
+  }
+  get() {
+    const { A: e, B: n, C: r, D: c, E: s, F: o, G: i, H: a } = this;
+    return [e, n, r, c, s, o, i, a];
+  }
+  // prettier-ignore
+  set(e, n, r, c, s, o, i, a) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = c | 0, this.E = s | 0, this.F = o | 0, this.G = i | 0, this.H = a | 0;
+  }
+  process(e, n) {
+    for (let p = 0; p < 16; p++, n += 4)
+      G[p] = e.getUint32(n, !1);
+    for (let p = 16; p < 64; p++) {
+      const g = G[p - 15], y = G[p - 2], h = B(g, 7) ^ B(g, 18) ^ g >>> 3, d = B(y, 17) ^ B(y, 19) ^ y >>> 10;
+      G[p] = d + G[p - 7] + h + G[p - 16] | 0;
+    }
+    let { A: r, B: c, C: s, D: o, E: i, F: a, G: u, H: f } = this;
+    for (let p = 0; p < 64; p++) {
+      const g = B(i, 6) ^ B(i, 11) ^ B(i, 25), y = f + g + cs(i, a, u) + fs[p] + G[p] | 0, d = (B(r, 2) ^ B(r, 13) ^ B(r, 22)) + as(r, c, s) | 0;
+      f = u, u = a, a = i, i = o + y | 0, o = s, s = c, c = r, r = y + d | 0;
+    }
+    r = r + this.A | 0, c = c + this.B | 0, s = s + this.C | 0, o = o + this.D | 0, i = i + this.E | 0, a = a + this.F | 0, u = u + this.G | 0, f = f + this.H | 0, this.set(r, c, s, o, i, a, u, f);
+  }
+  roundClean() {
+    dt(G);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), dt(this.buffer);
+  }
+}
+const hs = /* @__PURE__ */ os(() => new ps()), Nt = hs;
+function ls(t) {
+  if (t.length >= 255)
+    throw new TypeError("Alphabet too long");
+  const e = new Uint8Array(256);
+  for (let u = 0; u < e.length; u++)
+    e[u] = 255;
+  for (let u = 0; u < t.length; u++) {
+    const f = t.charAt(u), p = f.charCodeAt(0);
+    if (e[p] !== 255)
+      throw new TypeError(f + " is ambiguous");
+    e[p] = u;
+  }
+  const n = t.length, r = t.charAt(0), c = Math.log(n) / Math.log(256), s = Math.log(256) / Math.log(n);
+  function o(u) {
+    if (u instanceof Uint8Array || (ArrayBuffer.isView(u) ? u = new Uint8Array(u.buffer, u.byteOffset, u.byteLength) : Array.isArray(u) && (u = Uint8Array.from(u))), !(u instanceof Uint8Array))
+      throw new TypeError("Expected Uint8Array");
+    if (u.length === 0)
+      return "";
+    let f = 0, p = 0, g = 0;
+    const y = u.length;
+    for (; g !== y && u[g] === 0; )
+      g++, f++;
+    const h = (y - g) * s + 1 >>> 0, d = new Uint8Array(h);
+    for (; g !== y; ) {
+      let S = u[g], b = 0;
+      for (let _ = h - 1; (S !== 0 || b < p) && _ !== -1; _--, b++)
+        S += 256 * d[_] >>> 0, d[_] = S % n >>> 0, S = S / n >>> 0;
+      if (S !== 0)
+        throw new Error("Non-zero carry");
+      p = b, g++;
+    }
+    let w = h - p;
+    for (; w !== h && d[w] === 0; )
+      w++;
+    let E = r.repeat(f);
+    for (; w < h; ++w)
+      E += t.charAt(d[w]);
+    return E;
+  }
+  function i(u) {
+    if (typeof u != "string")
+      throw new TypeError("Expected String");
+    if (u.length === 0)
+      return new Uint8Array();
+    let f = 0, p = 0, g = 0;
+    for (; u[f] === r; )
+      p++, f++;
+    const y = (u.length - f) * c + 1 >>> 0, h = new Uint8Array(y);
+    for (; f < u.length; ) {
+      const S = u.charCodeAt(f);
+      if (S > 255)
+        return;
+      let b = e[S];
+      if (b === 255)
+        return;
+      let _ = 0;
+      for (let v = y - 1; (b !== 0 || _ < g) && v !== -1; v--, _++)
+        b += n * h[v] >>> 0, h[v] = b % 256 >>> 0, b = b / 256 >>> 0;
+      if (b !== 0)
+        throw new Error("Non-zero carry");
+      g = _, f++;
+    }
+    let d = y - g;
+    for (; d !== y && h[d] === 0; )
+      d++;
+    const w = new Uint8Array(p + (y - d));
+    let E = p;
+    for (; d !== y; )
+      w[E++] = h[d++];
+    return w;
+  }
+  function a(u) {
+    const f = i(u);
+    if (f)
+      return f;
+    throw new Error("Non-base" + n + " character");
+  }
+  return {
+    encode: o,
+    decodeUnsafe: i,
+    decode: a
+  };
+}
+var ds = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const ct = ls(ds);
+function gs(t) {
+  function e(s) {
+    var o = Uint8Array.from(s), i = t(o), a = o.length + 4, u = new Uint8Array(a);
+    return u.set(o, 0), u.set(i.subarray(0, 4), o.length), ct.encode(u);
+  }
+  function n(s) {
+    var o = s.slice(0, -4), i = s.slice(-4), a = t(o);
+    if (!(i[0] ^ a[0] | i[1] ^ a[1] | i[2] ^ a[2] | i[3] ^ a[3]))
+      return o;
+  }
+  function r(s) {
+    var o = ct.decodeUnsafe(s);
+    if (o != null)
+      return n(o);
+  }
+  function c(s) {
+    var o = ct.decode(s), i = n(o);
+    if (i == null)
+      throw new Error("Invalid checksum");
+    return i;
+  }
+  return {
+    encode: e,
+    decode: c,
+    decodeUnsafe: r
+  };
+}
+function ys(t) {
+  return Nt(Nt(t));
+}
+const Mn = gs(ys), ke = 40, Ae = 2, xe = 15, Wn = 16, De = 16, Qe = 2, et = 80, Ss = "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.", Gn = (t) => {
+  try {
+    const e = l.from(t.subarray(2));
+    if (e.length < Ae || e.length > ke)
+      throw new TypeError("Invalid program length for segwit address");
+    const n = t[0] - et;
+    if (n < Qe || n > xe + 1)
+      throw new TypeError("Invalid version for segwit address");
+    if (n === 1) throw new TypeError("taproot");
+    return !0;
+  } catch {
+  }
+  return !1;
+};
+function Xn(t, e) {
+  if (!l.isBuffer(t)) throw new TypeError("output must be a Buffer");
+  if (!e.bech32Opnet) throw new Error("Network does not support opnet");
+  const n = t[0];
+  let r = 1, c;
+  if (t[1] < 76)
+    c = t[1], r = 2;
+  else if (t[1] === 76)
+    c = t[2], r = 3;
+  else
+    throw new TypeError("Unsupported push opcode in script");
+  const s = l.from(t.subarray(r, r + c));
+  if (s.length < Ae || s.length > ke)
+    throw new TypeError("Invalid program length for segwit address");
+  const o = n === Ce.OP_0 ? 0 : n >= Ce.OP_1 && n <= Ce.OP_16 ? n - (Ce.OP_1 - 1) : -1;
+  if (o < xe || o > Wn)
+    throw new TypeError(`Invalid segwit version ${o}`);
+  const i = [o, ...M.bech32m.toWords(s)];
+  return M.bech32m.encode(e.bech32Opnet, i);
+}
+function qn(t, e) {
+  const n = l.from(t.subarray(2));
+  if (n.length < Ae || n.length > ke)
+    throw new TypeError("Invalid program length for segwit address");
+  const r = t[0] - et;
+  if (r < Qe || r > xe)
+    throw new TypeError("Invalid version for segwit address");
+  if (t[1] !== n.length)
+    throw new TypeError(`Invalid script for segwit address ${t[1]} !== ${n.length}`);
+  return jn(n, r, e.bech32, e.bech32Opnet);
+}
+function Dn(t) {
+  const e = l.from(Mn.decode(t));
+  if (e.length < 21) throw new TypeError(t + " is too short");
+  if (e.length > 21) throw new TypeError(t + " is too long");
+  const n = e.readUInt8(0), r = l.from(e.subarray(1));
+  return { version: n, hash: r };
+}
+function Vn(t) {
+  let e, n;
+  try {
+    e = M.bech32.decode(t);
+  } catch {
+  }
+  if (e) {
+    if (n = e.words[0], n !== 0) throw new TypeError(t + " uses wrong encoding");
+  } else if (e = M.bech32m.decode(t), n = e.words[0], n === 0) throw new TypeError(t + " uses wrong encoding");
+  const r = M.bech32.fromWords(e.words.slice(1));
+  return {
+    version: n,
+    prefix: e.prefix,
+    data: l.from(r)
+  };
+}
+function bs(t, e) {
+  Hr(Ur(Br, Rr), [t, e]);
+  const n = l.allocUnsafe(21);
+  return n.writeUInt8(e, 0), t.copy(n, 1), Mn.encode(n);
+}
+function jn(t, e, n, r) {
+  const c = M.bech32.toWords(t);
+  return c.unshift(e), e === De && r ? M.bech32m.encode(r, c) : e === 0 ? M.bech32.encode(n, c) : M.bech32m.encode(n, c);
+}
+function zn(t, e) {
+  e = e || Je;
+  try {
+    return _e({ output: t, network: e }).address;
+  } catch {
+  }
+  try {
+    return me({ output: t, network: e }).address;
+  } catch {
+  }
+  try {
+    return $e({ output: t, network: e }).address;
+  } catch {
+  }
+  try {
+    return ve({ output: t, network: e }).address;
+  } catch {
+  }
+  try {
+    return Ie({ output: t, network: e }).address;
+  } catch {
+  }
+  try {
+    return Xn(t, e);
+  } catch {
+  }
+  try {
+    return qn(t, e);
+  } catch {
+  }
+  throw new Error(Or(t) + " has no matching Address");
+}
+function $n(t, e) {
+  e = e || Je;
+  let n, r;
+  try {
+    n = Dn(t);
+  } catch {
+  }
+  if (n) {
+    if (n.version === e.pubKeyHash)
+      return _e({ hash: n.hash }).output;
+    if (n.version === e.scriptHash)
+      return me({ hash: n.hash }).output;
+  } else {
+    try {
+      r = Vn(t);
+    } catch {
+    }
+    if (r) {
+      if (r.prefix !== e.bech32 && e.bech32Opnet && r.prefix !== e.bech32Opnet)
+        throw new Error(t + " has an invalid prefix");
+      if (r.version === 0) {
+        if (r.data.length === 20)
+          return $e({ hash: r.data }).output;
+        if (r.data.length === 32)
+          return ve({ hash: r.data }).output;
+      } else if (r.version === 1) {
+        if (r.data.length === 32)
+          return Ie({ pubkey: r.data }).output;
+      } else if (r.version === De) {
+        if (!e.bech32Opnet) throw new Error(t + " has an invalid prefix");
+        return Rn({
+          program: r.data,
+          network: e
+        }).output;
+      } else if (r.version >= Qe && r.version <= xe && r.data.length >= Ae && r.data.length <= ke)
+        return r.version !== De && console.warn(Ss), Cr([
+          r.version + et,
+          r.data
+        ]);
+    }
+  }
+  throw new TypeError(t + " has no matching Script");
+}
+const ws = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FUTURE_MAX_VERSION: Wn,
+  FUTURE_OPNET_VERSION: De,
+  FUTURE_SEGWIT_MAX_SIZE: ke,
+  FUTURE_SEGWIT_MAX_VERSION: xe,
+  FUTURE_SEGWIT_MIN_SIZE: Ae,
+  FUTURE_SEGWIT_MIN_VERSION: Qe,
+  FUTURE_SEGWIT_VERSION_DIFF: et,
+  _toFutureSegwitAddress: qn,
+  fromBase58Check: Dn,
+  fromBech32: Vn,
+  fromOutputScript: zn,
+  isUnknownSegwitVersion: Gn,
+  toBase58Check: bs,
+  toBech32: jn,
+  toFutureOPNetAddress: Xn,
+  toOutputScript: $n
+}, Symbol.toStringTag, { value: "Module" })), be = {};
+function Qo(t) {
+  t ? t !== be.eccLib && (Es(t), be.eccLib = t) : be.eccLib = t;
+}
+function ei() {
+  if (!be.eccLib)
+    throw new Error(
+      "No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance"
+    );
+  return be.eccLib;
+}
+const F = (t) => l.from(t, "hex");
+function Es(t) {
+  P(typeof t.isXOnlyPoint == "function"), P(t.isXOnlyPoint(F("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"))), P(t.isXOnlyPoint(F("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e"))), P(t.isXOnlyPoint(F("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"))), P(t.isXOnlyPoint(F("0000000000000000000000000000000000000000000000000000000000000001"))), P(
+    !t.isXOnlyPoint(F("0000000000000000000000000000000000000000000000000000000000000000"))
+  ), P(
+    !t.isXOnlyPoint(F("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"))
+  ), P(typeof t.xOnlyPointAddTweak == "function"), Ts.forEach((e) => {
+    const n = t.xOnlyPointAddTweak(F(e.pubkey), F(e.tweak));
+    e.result === null ? P(n === null) : (P(n !== null), P(n.parity === e.parity), P(l.from(n.xOnlyPubkey).equals(F(e.result))));
+  });
+}
+function P(t) {
+  if (!t) throw new Error("ecc library invalid");
+}
+const Ts = [
+  {
+    pubkey: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+    tweak: "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140",
+    parity: -1,
+    result: null
+  },
+  {
+    pubkey: "1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b",
+    tweak: "a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac",
+    parity: 1,
+    result: "e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf"
+  },
+  {
+    pubkey: "2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991",
+    tweak: "823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47",
+    parity: 0,
+    result: "9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c"
+  }
+];
+const _s = {
+  p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+  n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+  b: 7n,
+  Gx: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+  Gy: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+}, { p: ie, n: Yn, Gx: ms, Gy: vs, b: Zn } = _s, Xe = 32, gt = 64, N = (t = "") => {
+  throw new Error(t);
+}, Jn = (t) => typeof t == "bigint", Qn = (t) => typeof t == "string", Is = (t) => t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array", Te = (t, e) => !Is(t) || typeof e == "number" && e > 0 && t.length !== e ? N("Uint8Array expected") : t, er = (t) => new Uint8Array(t), ks = (t) => Uint8Array.from(t), tr = (t, e) => t.toString(16).padStart(e, "0"), nr = (t) => Array.from(Te(t)).map((e) => tr(e, 2)).join(""), K = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }, Ht = (t) => {
+  if (t >= K._0 && t <= K._9)
+    return t - K._0;
+  if (t >= K.A && t <= K.F)
+    return t - (K.A - 10);
+  if (t >= K.a && t <= K.f)
+    return t - (K.a - 10);
+}, rr = (t) => {
+  const e = "hex invalid";
+  if (!Qn(t))
+    return N(e);
+  const n = t.length, r = n / 2;
+  if (n % 2)
+    return N(e);
+  const c = er(r);
+  for (let s = 0, o = 0; s < r; s++, o += 2) {
+    const i = Ht(t.charCodeAt(o)), a = Ht(t.charCodeAt(o + 1));
+    if (i === void 0 || a === void 0)
+      return N(e);
+    c[s] = i * 16 + a;
+  }
+  return c;
+}, sr = (t, e) => Te(Qn(t) ? rr(t) : ks(Te(t)), e), Ut = (...t) => {
+  const e = er(t.reduce((r, c) => r + Te(c).length, 0));
+  let n = 0;
+  return t.forEach((r) => {
+    e.set(r, n), n += r.length;
+  }), e;
+}, Ve = BigInt, Oe = (t, e, n, r = "bad number: out of range") => Jn(t) && e <= t && t < n ? t : N(r), T = (t, e = ie) => {
+  const n = t % e;
+  return n >= 0n ? n : e + n;
+}, As = (t, e) => {
+  (t === 0n || e <= 0n) && N("no inverse n=" + t + " mod=" + e);
+  let n = T(t, e), r = e, c = 0n, s = 1n;
+  for (; n !== 0n; ) {
+    const o = r / n, i = r % n, a = c - s * o;
+    r = n, n = i, c = s, s = a;
+  }
+  return r === 1n ? T(c, e) : N("no inverse");
+}, Bt = (t) => t instanceof O ? t : N("Point expected"), or = (t) => T(T(t * t) * t + Zn), Rt = (t) => Oe(t, 0n, ie), qe = (t) => Oe(t, 1n, ie), xs = (t) => Oe(t, 1n, Yn), yt = (t) => (t & 1n) === 0n, ir = (t) => Uint8Array.of(t), Os = (t) => ir(yt(t) ? 2 : 3), Cs = (t) => {
+  const e = or(qe(t));
+  let n = 1n;
+  for (let r = e, c = (ie + 1n) / 4n; c > 0n; c >>= 1n)
+    c & 1n && (n = n * r % ie), r = r * r % ie;
+  return T(n * n) === e ? n : N("sqrt invalid");
+};
+class O {
+  static BASE;
+  static ZERO;
+  px;
+  py;
+  pz;
+  constructor(e, n, r) {
+    this.px = Rt(e), this.py = qe(n), this.pz = Rt(r), Object.freeze(this);
+  }
+  /** Convert Uint8Array or hex string to Point. */
+  static fromBytes(e) {
+    Te(e);
+    let n;
+    const r = e[0], c = e.subarray(1), s = Ft(c, 0, Xe), o = e.length;
+    if (o === Xe + 1 && [2, 3].includes(r)) {
+      let i = Cs(s);
+      const a = yt(i);
+      yt(Ve(r)) !== a && (i = T(-i)), n = new O(s, i, 1n);
+    }
+    return o === gt + 1 && r === 4 && (n = new O(s, Ft(c, Xe, gt), 1n)), n ? n.assertValidity() : N("bad point: not on curve");
+  }
+  /** Equality check: compare points P&Q. */
+  equals(e) {
+    const { px: n, py: r, pz: c } = this, { px: s, py: o, pz: i } = Bt(e), a = T(n * i), u = T(s * c), f = T(r * i), p = T(o * c);
+    return a === u && f === p;
+  }
+  is0() {
+    return this.equals(oe);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new O(this.px, T(-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(e) {
+    const { px: n, py: r, pz: c } = this, { px: s, py: o, pz: i } = Bt(e), a = 0n, u = Zn;
+    let f = 0n, p = 0n, g = 0n;
+    const y = T(u * 3n);
+    let h = T(n * s), d = T(r * o), w = T(c * i), E = T(n + r), S = T(s + o);
+    E = T(E * S), S = T(h + d), E = T(E - S), S = T(n + c);
+    let b = T(s + i);
+    return S = T(S * b), b = T(h + w), S = T(S - b), b = T(r + c), f = T(o + i), b = T(b * f), f = T(d + w), b = T(b - f), g = T(a * S), f = T(y * w), g = T(f + g), f = T(d - g), g = T(d + g), p = T(f * g), d = T(h + h), d = T(d + h), w = T(a * w), S = T(y * S), d = T(d + w), w = T(h - w), w = T(a * w), S = T(S + w), h = T(d * S), p = T(p + h), h = T(b * S), f = T(E * f), f = T(f - h), h = T(E * d), g = T(b * g), g = T(g + h), new O(f, p, g);
+  }
+  /**
+   * 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(e, n = !0) {
+    if (!n && e === 0n)
+      return oe;
+    if (xs(e), e === 1n)
+      return this;
+    if (this.equals(fe))
+      return Bs(e).p;
+    let r = oe, c = fe;
+    for (let s = this; e > 0n; s = s.double(), e >>= 1n)
+      e & 1n ? r = r.add(s) : n && (c = c.add(s));
+    return r;
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { px: e, py: n, pz: r } = this;
+    if (this.equals(oe))
+      return { x: 0n, y: 0n };
+    if (r === 1n)
+      return { x: e, y: n };
+    const c = As(r, ie);
+    return T(r * c) !== 1n && N("inverse invalid"), { x: T(e * c), y: T(n * c) };
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const { x: e, y: n } = this.toAffine();
+    return qe(e), qe(n), T(n * n) === or(e) ? this : N("bad point: not on curve");
+  }
+  /** Converts point to 33/65-byte Uint8Array. */
+  toBytes(e = !0) {
+    const { x: n, y: r } = this.assertValidity().toAffine(), c = Kt(n);
+    return e ? Ut(Os(r), c) : Ut(ir(4), c, Kt(r));
+  }
+  /** Create 3d xyz point from 2d xy. (0, 0) => (0, 1, 0), not (0, 0, 1) */
+  static fromAffine(e) {
+    const { x: n, y: r } = e;
+    return n === 0n && r === 0n ? oe : new O(n, r, 1n);
+  }
+  toHex(e) {
+    return nr(this.toBytes(e));
+  }
+  static fromPrivateKey(e) {
+    return fe.multiply(Ns(e));
+  }
+  static fromHex(e) {
+    return O.fromBytes(sr(e));
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  toRawBytes(e) {
+    return this.toBytes(e);
+  }
+}
+const fe = new O(ms, vs, 1n), oe = new O(0n, 1n, 0n);
+O.BASE = fe;
+O.ZERO = oe;
+const cr = (t) => Ve("0x" + (nr(t) || "0")), Ft = (t, e, n) => cr(t.subarray(e, n)), Ps = 2n ** 256n, Kt = (t) => rr(tr(Oe(t, 0n, Ps), gt)), Ns = (t) => {
+  const e = Jn(t) ? t : cr(sr(t, Xe));
+  return Oe(e, 1n, Yn, "private key invalid 3");
+}, je = 8, Hs = 256, ar = Math.ceil(Hs / je) + 1, St = 2 ** (je - 1), Us = () => {
+  const t = [];
+  let e = fe, n = e;
+  for (let r = 0; r < ar; r++) {
+    n = e, t.push(n);
+    for (let c = 1; c < St; c++)
+      n = n.add(e), t.push(n);
+    e = n.double();
+  }
+  return t;
+};
+let Lt;
+const Mt = (t, e) => {
+  const n = e.negate();
+  return t ? n : e;
+}, Bs = (t) => {
+  const e = Lt || (Lt = Us());
+  let n = oe, r = fe;
+  const c = 2 ** je, s = c, o = Ve(c - 1), i = Ve(je);
+  for (let a = 0; a < ar; a++) {
+    let u = Number(t & o);
+    t >>= i, u > St && (u -= s, t += 1n);
+    const f = a * St, p = f, g = f + Math.abs(u) - 1, y = a % 2 !== 0, h = u < 0;
+    u === 0 ? r = r.add(Mt(y, e[p])) : n = n.add(Mt(h, e[g]));
+  }
+  return { p: n, f: r };
+};
+var ce = {}, Wt;
+function le() {
+  if (Wt) return ce;
+  Wt = 1, Object.defineProperty(ce, "__esModule", { value: !0 });
+  const t = 9007199254740991;
+  function e(s) {
+    if (s < 0 || s > t || s % 1 !== 0)
+      throw new RangeError("value out of range");
+  }
+  function n(s, o, i) {
+    if (e(s), o || (o = l.allocUnsafe(c(s))), !l.isBuffer(o))
+      throw new TypeError("buffer must be a Buffer instance");
+    return i || (i = 0), s < 253 ? (o.writeUInt8(s, i), Object.assign(n, { bytes: 1 })) : s <= 65535 ? (o.writeUInt8(253, i), o.writeUInt16LE(s, i + 1), Object.assign(n, { bytes: 3 })) : s <= 4294967295 ? (o.writeUInt8(254, i), o.writeUInt32LE(s, i + 1), Object.assign(n, { bytes: 5 })) : (o.writeUInt8(255, i), o.writeUInt32LE(s >>> 0, i + 1), o.writeUInt32LE(s / 4294967296 | 0, i + 5), Object.assign(n, { bytes: 9 })), o;
+  }
+  ce.encode = n;
+  function r(s, o) {
+    if (!l.isBuffer(s))
+      throw new TypeError("buffer must be a Buffer instance");
+    o || (o = 0);
+    const i = s.readUInt8(o);
+    if (i < 253)
+      return Object.assign(r, { bytes: 1 }), i;
+    if (i === 253)
+      return Object.assign(r, { bytes: 3 }), s.readUInt16LE(o + 1);
+    if (i === 254)
+      return Object.assign(r, { bytes: 5 }), s.readUInt32LE(o + 1);
+    {
+      Object.assign(r, { bytes: 9 });
+      const a = s.readUInt32LE(o + 1), f = s.readUInt32LE(o + 5) * 4294967296 + a;
+      return e(f), f;
+    }
+  }
+  ce.decode = r;
+  function c(s) {
+    return e(s), s < 253 ? 1 : s <= 65535 ? 3 : s <= 4294967295 ? 5 : 9;
+  }
+  return ce.encodingLength = c, ce;
+}
+var bt = le();
+const we = (t) => {
+  const e = t.length === 32 ? t : t.subarray(1, 33);
+  return l.isBuffer(e) ? e : l.from(e);
+};
+function Gt(t, e, n) {
+  const r = $s(e, t, n);
+  try {
+    const s = js(e, r).concat(r.script).concat(r.controlBlock);
+    return { finalScriptWitness: Ee(s) };
+  } catch (c) {
+    throw new Error(`Can not finalize taproot input #${t}: ${c}`);
+  }
+}
+function Pe(t, e) {
+  const n = e ? l.from([e]) : l.from([]);
+  return l.concat([t, n]);
+}
+function H(t) {
+  return t && !!(t.tapInternalKey || t.tapMerkleRoot || t.tapLeafScript && t.tapLeafScript.length || t.tapBip32Derivation && t.tapBip32Derivation.length || t.witnessUtxo && It(t.witnessUtxo.script));
+}
+function at(t, e) {
+  return t && !!(t.tapInternalKey || t.tapTree || t.tapBip32Derivation && t.tapBip32Derivation.length || e && It(e));
+}
+function Xt(t, e, n) {
+  qs(t, e, n), Vs(t, e, n);
+}
+function qt(t, e, n) {
+  Ds(t, e, n), Rs(t, e);
+}
+function Rs(t, e) {
+  if (!e.tapTree && !e.tapInternalKey) return;
+  const n = e.tapInternalKey || t.tapInternalKey, r = e.tapTree || t.tapTree;
+  if (n) {
+    const c = t.script, s = Fs(n, r);
+    if (c && !c.equals(s))
+      throw new Error("Error adding output. Script or address missmatch.");
+  }
+}
+function Fs(t, e) {
+  const n = e && Ks(e.leaves), { output: r } = Ie({
+    internalPubkey: t,
+    scriptTree: n
+  });
+  if (!r) throw new Error("Failed to generate taproot script pubkey");
+  return r;
+}
+function ti(t, e) {
+  const n = e.tapInternalKey, r = n && Kr(n, e.tapMerkleRoot);
+  if (!r)
+    throw new Error(
+      `Cannot tweak tap internal key for input #${t}. Public key: ${n && n.toString("hex")}`
+    );
+  return r.x;
+}
+function ni(t) {
+  if (!Fr(t))
+    throw new Error("Cannot convert taptree to tapleaf list. Expecting a tapree structure.");
+  return wt(t);
+}
+function Ks(t = []) {
+  return t.length === 1 && t[0].depth === 0 ? {
+    output: t[0].script,
+    version: t[0].leafVersion
+  } : Xs(t);
+}
+function Ls(t, e) {
+  return Ws(t).some((r) => pr(r, Ms, e));
+}
+function Ms(t) {
+  return {
+    signature: t.subarray(0, 64),
+    hashType: t.subarray(64)[0] || I.SIGHASH_DEFAULT
+  };
+}
+function Ws(t) {
+  const e = [];
+  if (t.tapKeySig && e.push(t.tapKeySig), t.tapScriptSig && e.push(...t.tapScriptSig.map((n) => n.signature)), !e.length) {
+    const n = Gs(t.finalScriptWitness);
+    n && e.push(n);
+  }
+  return e;
+}
+function Gs(t) {
+  if (!t) return;
+  const e = t.subarray(2);
+  if (e.length === 64 || e.length === 65) return e;
+}
+function wt(t, e = [], n = 0) {
+  if (n > Fn) throw new Error("Max taptree depth exceeded.");
+  return t ? Un(t) ? (e.push({
+    depth: n,
+    leafVersion: t.version || Lr,
+    script: t.output
+  }), e) : (t[0] && wt(t[0], e, n + 1), t[1] && wt(t[1], e, n + 1), e) : [];
+}
+function Xs(t) {
+  let e;
+  for (const n of t)
+    if (e = Et(n, e), !e) throw new Error("No room left to insert tapleaf in tree");
+  return e;
+}
+function Et(t, e, n = 0) {
+  if (n > Fn) throw new Error("Max taptree depth exceeded.");
+  if (t.depth === n)
+    return e ? void 0 : {
+      output: t.script,
+      version: t.leafVersion
+    };
+  if (Un(e)) return;
+  const r = Et(t, e && e[0], n + 1);
+  if (r) return [r, e && e[1]];
+  const c = Et(t, e && e[1], n + 1);
+  if (c) return [e && e[0], c];
+}
+function qs(t, e, n) {
+  const r = H(t) && pe(e), c = pe(t) && H(e), s = t === e && H(e) && pe(e);
+  if (r || c || s)
+    throw new Error(
+      `Invalid arguments for Psbt.${n}. Cannot use both taproot and non-taproot fields.`
+    );
+}
+function Ds(t, e, n) {
+  const r = at(t) && pe(e), c = pe(t) && at(e), s = t === e && at(e) && pe(e);
+  if (r || c || s)
+    throw new Error(
+      `Invalid arguments for Psbt.${n}. Cannot use both taproot and non-taproot fields.`
+    );
+}
+function Vs(t, e, n) {
+  if (e.tapMerkleRoot) {
+    const r = (e.tapLeafScript || []).every(
+      (s) => ut(s, e.tapMerkleRoot)
+    ), c = (t.tapLeafScript || []).every(
+      (s) => ut(s, e.tapMerkleRoot)
+    );
+    if (!r || !c)
+      throw new Error(`Invalid arguments for Psbt.${n}. Tapleaf not part of taptree.`);
+  } else if (t.tapMerkleRoot && !(e.tapLeafScript || []).every(
+    (c) => ut(c, t.tapMerkleRoot)
+  ))
+    throw new Error(`Invalid arguments for Psbt.${n}. Tapleaf not part of taptree.`);
+}
+function ut(t, e) {
+  if (!e) return !0;
+  const n = Ye({
+    output: t.script,
+    version: t.leafVersion
+  });
+  return Mr(t.controlBlock, n).equals(e);
+}
+function js(t, e) {
+  const n = Ye({
+    output: e.script,
+    version: e.leafVersion
+  });
+  return (t.tapScriptSig || []).filter((r) => r.leafHash.equals(n)).map((r) => zs(e.script, r)).sort((r, c) => c.positionInScript - r.positionInScript).map((r) => r.signature);
+}
+function zs(t, e) {
+  return Object.assign(
+    {
+      positionInScript: fr(e.pubkey, t)
+    },
+    e
+  );
+}
+function $s(t, e, n) {
+  const { tapScriptSig: r } = t;
+  if (!r || !r.length)
+    throw new Error(
+      `Can not finalize taproot input #${e}. No tapleaf script signature provided.`
+    );
+  const c = (t.tapLeafScript || []).sort((s, o) => s.controlBlock.length - o.controlBlock.length).find((s) => Ys(s, r, n));
+  if (!c)
+    throw new Error(
+      `Can not finalize taproot input #${e}. Signature for tapleaf script not found.`
+    );
+  return c;
+}
+function Ys(t, e, n) {
+  const r = Ye({
+    output: t.script,
+    version: t.leafVersion
+  });
+  return (!n || n.equals(r)) && e.find((s) => s.leafHash.equals(r)) !== void 0;
+}
+function pe(t) {
+  return t && !!(t.redeemScript || t.witnessScript || t.bip32Derivation && t.bip32Derivation.length);
+}
+function ne(t) {
+  return (e) => {
+    try {
+      return t({ output: e }), !0;
+    } catch {
+      return !1;
+    }
+  };
+}
+const Zs = ne(Ze), Js = ne(Kn), Qs = ne(_e), tt = ne($e), Dt = ne(ve), ur = ne(me), It = ne(Ie), ri = ne(Rn), si = (t) => t.length === 4 && t[0] === 81 && // OP_1
+t[1] === 2 && // push 2 bytes
+t[2] === 78 && t[3] === 115;
+function Ee(t) {
+  let e = l.allocUnsafe(0);
+  function n(o) {
+    e = l.concat([e, l.from(o)]);
+  }
+  function r(o) {
+    const i = e.length, a = bt.encodingLength(o);
+    e = l.concat([e, l.allocUnsafe(a)]), bt.encode(o, e, i);
+  }
+  function c(o) {
+    r(o.length), n(o);
+  }
+  function s(o) {
+    r(o.length), o.forEach(c);
+  }
+  return s(t), e;
+}
+function eo(t) {
+  if (t.length === 32)
+    return;
+  if (![33, 65].includes(t.length)) {
+    console.warn(
+      `Unsupported key length=${t.length}. Must be 33 (compressed) or 65 (uncompressed).`
+    );
+    return;
+  }
+  let e;
+  try {
+    e = O.fromHex(t);
+  } catch {
+    throw new Error("Invalid secp256k1 public key bytes. Cannot parse.");
+  }
+  const n = Vt(e.x), r = Vt(e.y), s = e.y % 2n === 0n ? 6 : 7, o = l.alloc(65);
+  o[0] = s, n.copy(o, 1), r.copy(o, 33);
+  const i = l.concat([l.from([4]), n, r]);
+  return {
+    hybrid: o,
+    uncompressed: i
+  };
+}
+function Vt(t) {
+  let e = t.toString(16);
+  return e = e.padStart(64, "0"), e.length > 64 && (e = e.slice(-64)), l.from(e, "hex");
+}
+function Ne(t, e) {
+  if (t.equals(e)) return !0;
+  if (t.length === 65 && e.length === 65) {
+    const n = l.from(t), r = l.from(e);
+    return (n[0] === 6 || n[0] === 7) && (n[0] = 4), (r[0] === 6 || r[0] === 7) && (r[0] = 4), n.equals(r);
+  }
+  return !1;
+}
+function fr(t, e) {
+  const n = he(e);
+  if (n === null) throw new Error("Unknown script error");
+  const r = ot(t), c = we(t), s = eo(t), o = s?.hybrid ? ot(s.hybrid) : void 0, i = s?.uncompressed ? ot(s.uncompressed) : void 0;
+  return n.findIndex((a) => {
+    if (typeof a == "number") return !1;
+    if (Ne(a, t) || Ne(a, c) || a.equals(r) || s && (Ne(a, s.uncompressed) || Ne(a, s.hybrid) || o && a.equals(o) || i && a.equals(i)))
+      return !0;
+  });
+}
+function nt(t, e) {
+  return fr(t, e) !== -1;
+}
+function to(t, e) {
+  return no(t).some((r) => pr(r, Se.decode, e));
+}
+function pr(t, e, n) {
+  const { hashType: r } = e(t), c = [];
+  switch (r & I.SIGHASH_ANYONECANPAY && c.push("addInput"), r & 31) {
+    case I.SIGHASH_ALL:
+      break;
+    case I.SIGHASH_SINGLE:
+    case I.SIGHASH_NONE:
+      c.push("addOutput"), c.push("setInputSequence");
+      break;
+  }
+  return c.indexOf(n) === -1;
+}
+function no(t) {
+  const { partialSig: e } = t;
+  let n;
+  if (!e || e.length === 0) {
+    if (!t.finalScriptSig && !t.finalScriptWitness) return [];
+    n = ro(t);
+  } else
+    n = e;
+  return n.map((r) => r.signature);
+}
+function ro(t) {
+  const e = t.finalScriptSig ? he(t.finalScriptSig) || [] : [], n = t.finalScriptWitness ? he(t.finalScriptWitness) || [] : [];
+  return e.concat(n).filter((r) => l.isBuffer(r) && Hn(r)).map((r) => ({ signature: r }));
+}
+var He = {}, Ue = {}, ft = {}, ae = {}, ue = {}, pt = {}, jt;
+function A() {
+  return jt || (jt = 1, (function(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), (function(e) {
+      e[e.UNSIGNED_TX = 0] = "UNSIGNED_TX", e[e.GLOBAL_XPUB = 1] = "GLOBAL_XPUB";
+    })(t.GlobalTypes || (t.GlobalTypes = {})), t.GLOBAL_TYPE_NAMES = ["unsignedTx", "globalXpub"], (function(e) {
+      e[e.NON_WITNESS_UTXO = 0] = "NON_WITNESS_UTXO", e[e.WITNESS_UTXO = 1] = "WITNESS_UTXO", e[e.PARTIAL_SIG = 2] = "PARTIAL_SIG", e[e.SIGHASH_TYPE = 3] = "SIGHASH_TYPE", e[e.REDEEM_SCRIPT = 4] = "REDEEM_SCRIPT", e[e.WITNESS_SCRIPT = 5] = "WITNESS_SCRIPT", e[e.BIP32_DERIVATION = 6] = "BIP32_DERIVATION", e[e.FINAL_SCRIPTSIG = 7] = "FINAL_SCRIPTSIG", e[e.FINAL_SCRIPTWITNESS = 8] = "FINAL_SCRIPTWITNESS", e[e.POR_COMMITMENT = 9] = "POR_COMMITMENT", e[e.TAP_KEY_SIG = 19] = "TAP_KEY_SIG", e[e.TAP_SCRIPT_SIG = 20] = "TAP_SCRIPT_SIG", e[e.TAP_LEAF_SCRIPT = 21] = "TAP_LEAF_SCRIPT", e[e.TAP_BIP32_DERIVATION = 22] = "TAP_BIP32_DERIVATION", e[e.TAP_INTERNAL_KEY = 23] = "TAP_INTERNAL_KEY", e[e.TAP_MERKLE_ROOT = 24] = "TAP_MERKLE_ROOT";
+    })(t.InputTypes || (t.InputTypes = {})), t.INPUT_TYPE_NAMES = [
+      "nonWitnessUtxo",
+      "witnessUtxo",
+      "partialSig",
+      "sighashType",
+      "redeemScript",
+      "witnessScript",
+      "bip32Derivation",
+      "finalScriptSig",
+      "finalScriptWitness",
+      "porCommitment",
+      "tapKeySig",
+      "tapScriptSig",
+      "tapLeafScript",
+      "tapBip32Derivation",
+      "tapInternalKey",
+      "tapMerkleRoot"
+    ], (function(e) {
+      e[e.REDEEM_SCRIPT = 0] = "REDEEM_SCRIPT", e[e.WITNESS_SCRIPT = 1] = "WITNESS_SCRIPT", e[e.BIP32_DERIVATION = 2] = "BIP32_DERIVATION", e[e.TAP_INTERNAL_KEY = 5] = "TAP_INTERNAL_KEY", e[e.TAP_TREE = 6] = "TAP_TREE", e[e.TAP_BIP32_DERIVATION = 7] = "TAP_BIP32_DERIVATION";
+    })(t.OutputTypes || (t.OutputTypes = {})), t.OUTPUT_TYPE_NAMES = [
+      "redeemScript",
+      "witnessScript",
+      "bip32Derivation",
+      "tapInternalKey",
+      "tapTree",
+      "tapBip32Derivation"
+    ];
+  })(pt)), pt;
+}
+var X = {}, zt;
+function so() {
+  if (zt) return X;
+  zt = 1, Object.defineProperty(X, "__esModule", { value: !0 });
+  const t = A(), e = (o) => [...Array(o).keys()];
+  function n(o) {
+    if (o.key[0] !== t.GlobalTypes.GLOBAL_XPUB)
+      throw new Error(
+        "Decode Error: could not decode globalXpub with key 0x" + o.key.toString("hex")
+      );
+    if (o.key.length !== 79 || ![2, 3].includes(o.key[46]))
+      throw new Error(
+        "Decode Error: globalXpub has invalid extended pubkey in key 0x" + o.key.toString("hex")
+      );
+    if (o.value.length / 4 % 1 !== 0)
+      throw new Error(
+        "Decode Error: Global GLOBAL_XPUB value length should be multiple of 4"
+      );
+    const i = o.key.slice(1), a = {
+      masterFingerprint: o.value.slice(0, 4),
+      extendedPubkey: i,
+      path: "m"
+    };
+    for (const u of e(o.value.length / 4 - 1)) {
+      const f = o.value.readUInt32LE(u * 4 + 4), p = !!(f & 2147483648), g = f & 2147483647;
+      a.path += "/" + g.toString(10) + (p ? "'" : "");
+    }
+    return a;
+  }
+  X.decode = n;
+  function r(o) {
+    const i = l.from([t.GlobalTypes.GLOBAL_XPUB]), a = l.concat([i, o.extendedPubkey]), u = o.path.split("/"), f = l.allocUnsafe(u.length * 4);
+    o.masterFingerprint.copy(f, 0);
+    let p = 4;
+    return u.slice(1).forEach((g) => {
+      const y = g.slice(-1) === "'";
+      let h = 2147483647 & parseInt(y ? g.slice(0, -1) : g, 10);
+      y && (h += 2147483648), f.writeUInt32LE(h, p), p += 4;
+    }), {
+      key: a,
+      value: f
+    };
+  }
+  X.encode = r, X.expected = "{ masterFingerprint: Buffer; extendedPubkey: Buffer; path: string; }";
+  function c(o) {
+    const i = o.extendedPubkey, a = o.masterFingerprint, u = o.path;
+    return l.isBuffer(i) && i.length === 78 && [2, 3].indexOf(i[45]) > -1 && l.isBuffer(a) && a.length === 4 && typeof u == "string" && !!u.match(/^m(\/\d+'?)*$/);
+  }
+  X.check = c;
+  function s(o, i, a) {
+    const u = i.extendedPubkey.toString("hex");
+    return a.has(u) ? !1 : (a.add(u), o.filter((f) => f.extendedPubkey.equals(i.extendedPubkey)).length === 0);
+  }
+  return X.canAddToArray = s, X;
+}
+var Be = {}, $t;
+function oo() {
+  if ($t) return Be;
+  $t = 1, Object.defineProperty(Be, "__esModule", { value: !0 });
+  const t = A();
+  function e(n) {
+    return {
+      key: l.from([t.GlobalTypes.UNSIGNED_TX]),
+      value: n.toBuffer()
+    };
+  }
+  return Be.encode = e, Be;
+}
+var q = {}, Yt;
+function io() {
+  if (Yt) return q;
+  Yt = 1, Object.defineProperty(q, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.FINAL_SCRIPTSIG)
+      throw new Error(
+        "Decode Error: could not decode finalScriptSig with key 0x" + s.key.toString("hex")
+      );
+    return s.value;
+  }
+  q.decode = e;
+  function n(s) {
+    return {
+      key: l.from([t.InputTypes.FINAL_SCRIPTSIG]),
+      value: s
+    };
+  }
+  q.encode = n, q.expected = "Buffer";
+  function r(s) {
+    return l.isBuffer(s);
+  }
+  q.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.finalScriptSig === void 0;
+  }
+  return q.canAdd = c, q;
+}
+var D = {}, Zt;
+function co() {
+  if (Zt) return D;
+  Zt = 1, Object.defineProperty(D, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.FINAL_SCRIPTWITNESS)
+      throw new Error(
+        "Decode Error: could not decode finalScriptWitness with key 0x" + s.key.toString("hex")
+      );
+    return s.value;
+  }
+  D.decode = e;
+  function n(s) {
+    return {
+      key: l.from([t.InputTypes.FINAL_SCRIPTWITNESS]),
+      value: s
+    };
+  }
+  D.encode = n, D.expected = "Buffer";
+  function r(s) {
+    return l.isBuffer(s);
+  }
+  D.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.finalScriptWitness === void 0;
+  }
+  return D.canAdd = c, D;
+}
+var V = {}, Jt;
+function ao() {
+  if (Jt) return V;
+  Jt = 1, Object.defineProperty(V, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.NON_WITNESS_UTXO)
+      throw new Error(
+        "Decode Error: could not decode nonWitnessUtxo with key 0x" + s.key.toString("hex")
+      );
+    return s.value;
+  }
+  V.decode = e;
+  function n(s) {
+    return {
+      key: l.from([t.InputTypes.NON_WITNESS_UTXO]),
+      value: s
+    };
+  }
+  V.encode = n, V.expected = "Buffer";
+  function r(s) {
+    return l.isBuffer(s);
+  }
+  V.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.nonWitnessUtxo === void 0;
+  }
+  return V.canAdd = c, V;
+}
+var j = {}, Qt;
+function uo() {
+  if (Qt) return j;
+  Qt = 1, Object.defineProperty(j, "__esModule", { value: !0 });
+  const t = A();
+  function e(o) {
+    if (o.key[0] !== t.InputTypes.PARTIAL_SIG)
+      throw new Error(
+        "Decode Error: could not decode partialSig with key 0x" + o.key.toString("hex")
+      );
+    if (!(o.key.length === 34 || o.key.length === 66) || ![2, 3, 4].includes(o.key[1]))
+      throw new Error(
+        "Decode Error: partialSig has invalid pubkey in key 0x" + o.key.toString("hex")
+      );
+    return {
+      pubkey: o.key.slice(1),
+      signature: o.value
+    };
+  }
+  j.decode = e;
+  function n(o) {
+    const i = l.from([t.InputTypes.PARTIAL_SIG]);
+    return {
+      key: l.concat([i, o.pubkey]),
+      value: o.signature
+    };
+  }
+  j.encode = n, j.expected = "{ pubkey: Buffer; signature: Buffer; }";
+  function r(o) {
+    return l.isBuffer(o.pubkey) && l.isBuffer(o.signature) && [33, 65].includes(o.pubkey.length) && [2, 3, 4].includes(o.pubkey[0]) && c(o.signature);
+  }
+  j.check = r;
+  function c(o) {
+    if (!l.isBuffer(o) || o.length < 9 || o[0] !== 48 || o.length !== o[1] + 3 || o[2] !== 2) return !1;
+    const i = o[3];
+    if (i > 33 || i < 1 || o[3 + i + 1] !== 2) return !1;
+    const a = o[3 + i + 2];
+    return !(a > 33 || a < 1 || o.length !== 3 + i + 2 + a + 2);
+  }
+  function s(o, i, a) {
+    const u = i.pubkey.toString("hex");
+    return a.has(u) ? !1 : (a.add(u), o.filter((f) => f.pubkey.equals(i.pubkey)).length === 0);
+  }
+  return j.canAddToArray = s, j;
+}
+var z = {}, en;
+function fo() {
+  if (en) return z;
+  en = 1, Object.defineProperty(z, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.POR_COMMITMENT)
+      throw new Error(
+        "Decode Error: could not decode porCommitment with key 0x" + s.key.toString("hex")
+      );
+    return s.value.toString("utf8");
+  }
+  z.decode = e;
+  function n(s) {
+    return {
+      key: l.from([t.InputTypes.POR_COMMITMENT]),
+      value: l.from(s, "utf8")
+    };
+  }
+  z.encode = n, z.expected = "string";
+  function r(s) {
+    return typeof s == "string";
+  }
+  z.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.porCommitment === void 0;
+  }
+  return z.canAdd = c, z;
+}
+var $ = {}, tn;
+function po() {
+  if (tn) return $;
+  tn = 1, Object.defineProperty($, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.SIGHASH_TYPE)
+      throw new Error(
+        "Decode Error: could not decode sighashType with key 0x" + s.key.toString("hex")
+      );
+    return s.value.readUInt32LE(0);
+  }
+  $.decode = e;
+  function n(s) {
+    const o = l.from([t.InputTypes.SIGHASH_TYPE]), i = l.allocUnsafe(4);
+    return i.writeUInt32LE(s, 0), {
+      key: o,
+      value: i
+    };
+  }
+  $.encode = n, $.expected = "number";
+  function r(s) {
+    return typeof s == "number";
+  }
+  $.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.sighashType === void 0;
+  }
+  return $.canAdd = c, $;
+}
+var Y = {}, nn;
+function ho() {
+  if (nn) return Y;
+  nn = 1, Object.defineProperty(Y, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.TAP_KEY_SIG || s.key.length !== 1)
+      throw new Error(
+        "Decode Error: could not decode tapKeySig with key 0x" + s.key.toString("hex")
+      );
+    if (!r(s.value))
+      throw new Error(
+        "Decode Error: tapKeySig not a valid 64-65-byte BIP340 signature"
+      );
+    return s.value;
+  }
+  Y.decode = e;
+  function n(s) {
+    return { key: l.from([t.InputTypes.TAP_KEY_SIG]), value: s };
+  }
+  Y.encode = n, Y.expected = "Buffer";
+  function r(s) {
+    return l.isBuffer(s) && (s.length === 64 || s.length === 65);
+  }
+  Y.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.tapKeySig === void 0;
+  }
+  return Y.canAdd = c, Y;
+}
+var Z = {}, rn;
+function lo() {
+  if (rn) return Z;
+  rn = 1, Object.defineProperty(Z, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.TAP_LEAF_SCRIPT)
+      throw new Error(
+        "Decode Error: could not decode tapLeafScript with key 0x" + s.key.toString("hex")
+      );
+    if ((s.key.length - 2) % 32 !== 0)
+      throw new Error(
+        "Decode Error: tapLeafScript has invalid control block in key 0x" + s.key.toString("hex")
+      );
+    const o = s.value[s.value.length - 1];
+    if ((s.key[1] & 254) !== o)
+      throw new Error(
+        "Decode Error: tapLeafScript bad leaf version in key 0x" + s.key.toString("hex")
+      );
+    const i = s.value.slice(0, -1);
+    return { controlBlock: s.key.slice(1), script: i, leafVersion: o };
+  }
+  Z.decode = e;
+  function n(s) {
+    const o = l.from([t.InputTypes.TAP_LEAF_SCRIPT]), i = l.from([s.leafVersion]);
+    return {
+      key: l.concat([o, s.controlBlock]),
+      value: l.concat([s.script, i])
+    };
+  }
+  Z.encode = n, Z.expected = "{ controlBlock: Buffer; leafVersion: number, script: Buffer; }";
+  function r(s) {
+    return l.isBuffer(s.controlBlock) && (s.controlBlock.length - 1) % 32 === 0 && (s.controlBlock[0] & 254) === s.leafVersion && l.isBuffer(s.script);
+  }
+  Z.check = r;
+  function c(s, o, i) {
+    const a = o.controlBlock.toString("hex");
+    return i.has(a) ? !1 : (i.add(a), s.filter((u) => u.controlBlock.equals(o.controlBlock)).length === 0);
+  }
+  return Z.canAddToArray = c, Z;
+}
+var J = {}, sn;
+function go() {
+  if (sn) return J;
+  sn = 1, Object.defineProperty(J, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.TAP_MERKLE_ROOT || s.key.length !== 1)
+      throw new Error(
+        "Decode Error: could not decode tapMerkleRoot with key 0x" + s.key.toString("hex")
+      );
+    if (!r(s.value))
+      throw new Error("Decode Error: tapMerkleRoot not a 32-byte hash");
+    return s.value;
+  }
+  J.decode = e;
+  function n(s) {
+    return { key: l.from([t.InputTypes.TAP_MERKLE_ROOT]), value: s };
+  }
+  J.encode = n, J.expected = "Buffer";
+  function r(s) {
+    return l.isBuffer(s) && s.length === 32;
+  }
+  J.check = r;
+  function c(s, o) {
+    return !!s && !!o && s.tapMerkleRoot === void 0;
+  }
+  return J.canAdd = c, J;
+}
+var Q = {}, on;
+function yo() {
+  if (on) return Q;
+  on = 1, Object.defineProperty(Q, "__esModule", { value: !0 });
+  const t = A();
+  function e(s) {
+    if (s.key[0] !== t.InputTypes.TAP_SCRIPT_SIG)
+      throw new Error(
+        "Decode Error: could not decode tapScriptSig with key 0x" + s.key.toString("hex")
+      );
+    if (s.key.length !== 65)
+      throw new Error(
+        "Decode Error: tapScriptSig has invalid key 0x" + s.key.toString("hex")
+      );
+    if (s.value.length !== 64 && s.value.length !== 65)
+      throw new Error(
+        "Decode Error: tapScriptSig has invalid signature in key 0x" + s.key.toString("hex")
+      );
+    const o = s.key.slice(1, 33), i = s.key.slice(33);
+    return {
+      pubkey: o,
+      leafHash: i,
+      signature: s.value
+    };
+  }
+  Q.decode = e;
+  function n(s) {
+    const o = l.from([t.InputTypes.TAP_SCRIPT_SIG]);
+    return {
+      key: l.concat([o, s.pubkey, s.leafHash]),
+      value: s.signature
+    };
+  }
+  Q.encode = n, Q.expected = "{ pubkey: Buffer; leafHash: Buffer; signature: Buffer; }";
+  function r(s) {
+    return l.isBuffer(s.pubkey) && l.isBuffer(s.leafHash) && l.isBuffer(s.signature) && s.pubkey.length === 32 && s.leafHash.length === 32 && (s.signature.length === 64 || s.signature.length === 65);
+  }
+  Q.check = r;
+  function c(s, o, i) {
+    const a = o.pubkey.toString("hex") + o.leafHash.toString("hex");
+    return i.has(a) ? !1 : (i.add(a), s.filter(
+      (u) => u.pubkey.equals(o.pubkey) && u.leafHash.equals(o.leafHash)
+    ).length === 0);
+  }
+  return Q.canAddToArray = c, Q;
+}
+var ee = {}, L = {}, cn;
+function kt() {
+  if (cn) return L;
+  cn = 1, Object.defineProperty(L, "__esModule", { value: !0 });
+  const t = le();
+  L.range = (i) => [...Array(i).keys()];
+  function e(i) {
+    if (i.length < 1) return i;
+    let a = i.length - 1, u = 0;
+    for (let f = 0; f < i.length / 2; f++)
+      u = i[f], i[f] = i[a], i[a] = u, a--;
+    return i;
+  }
+  L.reverseBuffer = e;
+  function n(i) {
+    const a = i.map(r);
+    return a.push(l.from([0])), l.concat(a);
+  }
+  L.keyValsToBuffer = n;
+  function r(i) {
+    const a = i.key.length, u = i.value.length, f = t.encodingLength(a), p = t.encodingLength(u), g = l.allocUnsafe(
+      f + a + p + u
+    );
+    return t.encode(a, g, 0), i.key.copy(g, f), t.encode(u, g, f + a), i.value.copy(g, f + a + p), g;
+  }
+  L.keyValToBuffer = r;
+  function c(i, a) {
+    if (typeof i != "number")
+      throw new Error("cannot write a non-number as a number");
+    if (i < 0)
+      throw new Error("specified a negative value for writing an unsigned value");
+    if (i > a) throw new Error("RangeError: value out of range");
+    if (Math.floor(i) !== i)
+      throw new Error("value has a fractional component");
+  }
+  function s(i, a) {
+    const u = i.readUInt32LE(a);
+    let f = i.readUInt32LE(a + 4);
+    return f *= 4294967296, c(f + u, 9007199254740991), f + u;
+  }
+  L.readUInt64LE = s;
+  function o(i, a, u) {
+    return c(a, 9007199254740991), i.writeInt32LE(a & -1, u), i.writeUInt32LE(Math.floor(a / 4294967296), u + 4), u + 8;
+  }
+  return L.writeUInt64LE = o, L;
+}
+var an;
+function So() {
+  if (an) return ee;
+  an = 1, Object.defineProperty(ee, "__esModule", { value: !0 });
+  const t = A(), e = kt(), n = le();
+  function r(i) {
+    if (i.key[0] !== t.InputTypes.WITNESS_UTXO)
+      throw new Error(
+        "Decode Error: could not decode witnessUtxo with key 0x" + i.key.toString("hex")
+      );
+    const a = e.readUInt64LE(i.value, 0);
+    let u = 8;
+    const f = n.decode(i.value, u);
+    u += n.encodingLength(f);
+    const p = i.value.slice(u);
+    if (p.length !== f)
+      throw new Error("Decode Error: WITNESS_UTXO script is not proper length");
+    return {
+      script: p,
+      value: a
+    };
+  }
+  ee.decode = r;
+  function c(i) {
+    const { script: a, value: u } = i, f = n.encodingLength(a.length), p = l.allocUnsafe(8 + f + a.length);
+    return e.writeUInt64LE(p, u, 0), n.encode(a.length, p, 8), a.copy(p, 8 + f), {
+      key: l.from([t.InputTypes.WITNESS_UTXO]),
+      value: p
+    };
+  }
+  ee.encode = c, ee.expected = "{ script: Buffer; value: number; }";
+  function s(i) {
+    return l.isBuffer(i.script) && typeof i.value == "number";
+  }
+  ee.check = s;
+  function o(i, a) {
+    return !!i && !!a && i.witnessUtxo === void 0;
+  }
+  return ee.canAdd = o, ee;
+}
+var te = {}, un;
+function bo() {
+  if (un) return te;
+  un = 1, Object.defineProperty(te, "__esModule", { value: !0 });
+  const t = A(), e = le();
+  function n(o) {
+    if (o.key[0] !== t.OutputTypes.TAP_TREE || o.key.length !== 1)
+      throw new Error(
+        "Decode Error: could not decode tapTree with key 0x" + o.key.toString("hex")
+      );
+    let i = 0;
+    const a = [];
+    for (; i < o.value.length; ) {
+      const u = o.value[i++], f = o.value[i++], p = e.decode(o.value, i);
+      i += e.encodingLength(p), a.push({
+        depth: u,
+        leafVersion: f,
+        script: o.value.slice(i, i + p)
+      }), i += p;
+    }
+    return { leaves: a };
+  }
+  te.decode = n;
+  function r(o) {
+    const i = l.from([t.OutputTypes.TAP_TREE]), a = [].concat(
+      ...o.leaves.map((u) => [
+        l.of(u.depth, u.leafVersion),
+        e.encode(u.script.length),
+        u.script
+      ])
+    );
+    return {
+      key: i,
+      value: l.concat(a)
+    };
+  }
+  te.encode = r, te.expected = "{ leaves: [{ depth: number; leafVersion: number, script: Buffer; }] }";
+  function c(o) {
+    return Array.isArray(o.leaves) && o.leaves.every(
+      (i) => i.depth >= 0 && i.depth <= 128 && (i.leafVersion & 254) === i.leafVersion && l.isBuffer(i.script)
+    );
+  }
+  te.check = c;
+  function s(o, i) {
+    return !!o && !!i && o.tapTree === void 0;
+  }
+  return te.canAdd = s, te;
+}
+var Re = {}, fn;
+function hr() {
+  if (fn) return Re;
+  fn = 1, Object.defineProperty(Re, "__esModule", { value: !0 });
+  const t = (r) => [...Array(r).keys()], e = (r) => r.length === 33 && [2, 3].includes(r[0]) || r.length === 65 && r[0] === 4;
+  function n(r, c = e) {
+    function s(f) {
+      if (f.key[0] !== r)
+        throw new Error(
+          "Decode Error: could not decode bip32Derivation with key 0x" + f.key.toString("hex")
+        );
+      const p = f.key.slice(1);
+      if (!c(p))
+        throw new Error(
+          "Decode Error: bip32Derivation has invalid pubkey in key 0x" + f.key.toString("hex")
+        );
+      if (f.value.length / 4 % 1 !== 0)
+        throw new Error(
+          "Decode Error: Input BIP32_DERIVATION value length should be multiple of 4"
+        );
+      const g = {
+        masterFingerprint: f.value.slice(0, 4),
+        pubkey: p,
+        path: "m"
+      };
+      for (const y of t(f.value.length / 4 - 1)) {
+        const h = f.value.readUInt32LE(y * 4 + 4), d = !!(h & 2147483648), w = h & 2147483647;
+        g.path += "/" + w.toString(10) + (d ? "'" : "");
+      }
+      return g;
+    }
+    function o(f) {
+      const p = l.from([r]), g = l.concat([p, f.pubkey]), y = f.path.split("/"), h = l.allocUnsafe(y.length * 4);
+      f.masterFingerprint.copy(h, 0);
+      let d = 4;
+      return y.slice(1).forEach((w) => {
+        const E = w.slice(-1) === "'";
+        let S = 2147483647 & parseInt(E ? w.slice(0, -1) : w, 10);
+        E && (S += 2147483648), h.writeUInt32LE(S, d), d += 4;
+      }), {
+        key: g,
+        value: h
+      };
+    }
+    const i = "{ masterFingerprint: Buffer; pubkey: Buffer; path: string; }";
+    function a(f) {
+      return l.isBuffer(f.pubkey) && l.isBuffer(f.masterFingerprint) && typeof f.path == "string" && c(f.pubkey) && f.masterFingerprint.length === 4;
+    }
+    function u(f, p, g) {
+      const y = p.pubkey.toString("hex");
+      return g.has(y) ? !1 : (g.add(y), f.filter((h) => h.pubkey.equals(p.pubkey)).length === 0);
+    }
+    return {
+      decode: s,
+      encode: o,
+      check: a,
+      expected: i,
+      canAddToArray: u
+    };
+  }
+  return Re.makeConverter = n, Re;
+}
+var Fe = {}, pn;
+function wo() {
+  if (pn) return Fe;
+  pn = 1, Object.defineProperty(Fe, "__esModule", { value: !0 });
+  function t(e) {
+    return n;
+    function n(r) {
+      let c;
+      if (e.includes(r.key[0]) && (c = r.key.slice(1), !(c.length === 33 || c.length === 65) || ![2, 3, 4].includes(c[0])))
+        throw new Error(
+          "Format Error: invalid pubkey in key 0x" + r.key.toString("hex")
+        );
+      return c;
+    }
+  }
+  return Fe.makeChecker = t, Fe;
+}
+var Ke = {}, hn;
+function Eo() {
+  if (hn) return Ke;
+  hn = 1, Object.defineProperty(Ke, "__esModule", { value: !0 });
+  function t(e) {
+    function n(i) {
+      if (i.key[0] !== e)
+        throw new Error(
+          "Decode Error: could not decode redeemScript with key 0x" + i.key.toString("hex")
+        );
+      return i.value;
+    }
+    function r(i) {
+      return {
+        key: l.from([e]),
+        value: i
+      };
+    }
+    const c = "Buffer";
+    function s(i) {
+      return l.isBuffer(i);
+    }
+    function o(i, a) {
+      return !!i && !!a && i.redeemScript === void 0;
+    }
+    return {
+      decode: n,
+      encode: r,
+      check: s,
+      expected: c,
+      canAdd: o
+    };
+  }
+  return Ke.makeConverter = t, Ke;
+}
+var Le = {}, ln;
+function To() {
+  if (ln) return Le;
+  ln = 1, Object.defineProperty(Le, "__esModule", { value: !0 });
+  const t = le(), e = hr(), n = (c) => c.length === 32;
+  function r(c) {
+    const s = e.makeConverter(c, n);
+    function o(f) {
+      const p = t.decode(f.value), g = t.encodingLength(p), y = s.decode({
+        key: f.key,
+        value: f.value.slice(g + p * 32)
+      }), h = new Array(p);
+      for (let d = 0, w = g; d < p; d++, w += 32)
+        h[d] = f.value.slice(w, w + 32);
+      return Object.assign({}, y, { leafHashes: h });
+    }
+    function i(f) {
+      const p = s.encode(f), g = t.encodingLength(f.leafHashes.length), y = l.allocUnsafe(g);
+      t.encode(f.leafHashes.length, y);
+      const h = l.concat([y, ...f.leafHashes, p.value]);
+      return Object.assign({}, p, { value: h });
+    }
+    const a = "{ masterFingerprint: Buffer; pubkey: Buffer; path: string; leafHashes: Buffer[]; }";
+    function u(f) {
+      return Array.isArray(f.leafHashes) && f.leafHashes.every(
+        (p) => l.isBuffer(p) && p.length === 32
+      ) && s.check(f);
+    }
+    return {
+      decode: o,
+      encode: i,
+      check: u,
+      expected: a,
+      canAddToArray: s.canAddToArray
+    };
+  }
+  return Le.makeConverter = r, Le;
+}
+var Me = {}, dn;
+function _o() {
+  if (dn) return Me;
+  dn = 1, Object.defineProperty(Me, "__esModule", { value: !0 });
+  function t(e) {
+    function n(i) {
+      if (i.key[0] !== e || i.key.length !== 1)
+        throw new Error(
+          "Decode Error: could not decode tapInternalKey with key 0x" + i.key.toString("hex")
+        );
+      if (i.value.length !== 32)
+        throw new Error(
+          "Decode Error: tapInternalKey not a 32-byte x-only pubkey"
+        );
+      return i.value;
+    }
+    function r(i) {
+      return { key: l.from([e]), value: i };
+    }
+    const c = "Buffer";
+    function s(i) {
+      return l.isBuffer(i) && i.length === 32;
+    }
+    function o(i, a) {
+      return !!i && !!a && i.tapInternalKey === void 0;
+    }
+    return {
+      decode: n,
+      encode: r,
+      check: s,
+      expected: c,
+      canAdd: o
+    };
+  }
+  return Me.makeConverter = t, Me;
+}
+var We = {}, gn;
+function mo() {
+  if (gn) return We;
+  gn = 1, Object.defineProperty(We, "__esModule", { value: !0 });
+  function t(e) {
+    function n(i) {
+      if (i.key[0] !== e)
+        throw new Error(
+          "Decode Error: could not decode witnessScript with key 0x" + i.key.toString("hex")
+        );
+      return i.value;
+    }
+    function r(i) {
+      return {
+        key: l.from([e]),
+        value: i
+      };
+    }
+    const c = "Buffer";
+    function s(i) {
+      return l.isBuffer(i);
+    }
+    function o(i, a) {
+      return !!i && !!a && i.witnessScript === void 0;
+    }
+    return {
+      decode: n,
+      encode: r,
+      check: s,
+      expected: c,
+      canAdd: o
+    };
+  }
+  return We.makeConverter = t, We;
+}
+var yn;
+function At() {
+  if (yn) return ue;
+  yn = 1, Object.defineProperty(ue, "__esModule", { value: !0 });
+  const t = A(), e = so(), n = oo(), r = io(), c = co(), s = ao(), o = uo(), i = fo(), a = po(), u = ho(), f = lo(), p = go(), g = yo(), y = So(), h = bo(), d = hr(), w = wo(), E = Eo(), S = To(), b = _o(), _ = mo(), v = {
+    unsignedTx: n,
+    globalXpub: e,
+    // pass an Array of key bytes that require pubkey beside the key
+    checkPubkey: w.makeChecker([])
+  };
+  ue.globals = v;
+  const C = {
+    nonWitnessUtxo: s,
+    partialSig: o,
+    sighashType: a,
+    finalScriptSig: r,
+    finalScriptWitness: c,
+    porCommitment: i,
+    witnessUtxo: y,
+    bip32Derivation: d.makeConverter(
+      t.InputTypes.BIP32_DERIVATION
+    ),
+    redeemScript: E.makeConverter(
+      t.InputTypes.REDEEM_SCRIPT
+    ),
+    witnessScript: _.makeConverter(
+      t.InputTypes.WITNESS_SCRIPT
+    ),
+    checkPubkey: w.makeChecker([
+      t.InputTypes.PARTIAL_SIG,
+      t.InputTypes.BIP32_DERIVATION
+    ]),
+    tapKeySig: u,
+    tapScriptSig: g,
+    tapLeafScript: f,
+    tapBip32Derivation: S.makeConverter(
+      t.InputTypes.TAP_BIP32_DERIVATION
+    ),
+    tapInternalKey: b.makeConverter(
+      t.InputTypes.TAP_INTERNAL_KEY
+    ),
+    tapMerkleRoot: p
+  };
+  ue.inputs = C;
+  const m = {
+    bip32Derivation: d.makeConverter(
+      t.OutputTypes.BIP32_DERIVATION
+    ),
+    redeemScript: E.makeConverter(
+      t.OutputTypes.REDEEM_SCRIPT
+    ),
+    witnessScript: _.makeConverter(
+      t.OutputTypes.WITNESS_SCRIPT
+    ),
+    checkPubkey: w.makeChecker([
+      t.OutputTypes.BIP32_DERIVATION
+    ]),
+    tapBip32Derivation: S.makeConverter(
+      t.OutputTypes.TAP_BIP32_DERIVATION
+    ),
+    tapTree: h,
+    tapInternalKey: b.makeConverter(
+      t.OutputTypes.TAP_INTERNAL_KEY
+    )
+  };
+  return ue.outputs = m, ue;
+}
+var Sn;
+function vo() {
+  if (Sn) return ae;
+  Sn = 1, Object.defineProperty(ae, "__esModule", { value: !0 });
+  const t = At(), e = kt(), n = le(), r = A();
+  function c(i, a) {
+    let u = 0;
+    function f() {
+      const m = n.decode(i, u);
+      u += n.encodingLength(m);
+      const k = i.slice(u, u + m);
+      return u += m, k;
+    }
+    function p() {
+      const m = i.readUInt32BE(u);
+      return u += 4, m;
+    }
+    function g() {
+      const m = i.readUInt8(u);
+      return u += 1, m;
+    }
+    function y() {
+      const m = f(), k = f();
+      return {
+        key: m,
+        value: k
+      };
+    }
+    function h() {
+      if (u >= i.length)
+        throw new Error("Format Error: Unexpected End of PSBT");
+      const m = i.readUInt8(u) === 0;
+      return m && u++, m;
+    }
+    if (p() !== 1886610036)
+      throw new Error("Format Error: Invalid Magic Number");
+    if (g() !== 255)
+      throw new Error(
+        "Format Error: Magic Number must be followed by 0xff separator"
+      );
+    const d = [], w = {};
+    for (; !h(); ) {
+      const m = y(), k = m.key.toString("hex");
+      if (w[k])
+        throw new Error(
+          "Format Error: Keys must be unique for global keymap: key " + k
+        );
+      w[k] = 1, d.push(m);
+    }
+    const E = d.filter(
+      (m) => m.key[0] === r.GlobalTypes.UNSIGNED_TX
+    );
+    if (E.length !== 1)
+      throw new Error("Format Error: Only one UNSIGNED_TX allowed");
+    const S = a(E[0].value), { inputCount: b, outputCount: _ } = S.getInputOutputCounts(), v = [], C = [];
+    for (const m of e.range(b)) {
+      const k = {}, U = [];
+      for (; !h(); ) {
+        const R = y(), re = R.key.toString("hex");
+        if (k[re])
+          throw new Error(
+            "Format Error: Keys must be unique for each input: input index " + m + " key " + re
+          );
+        k[re] = 1, U.push(R);
+      }
+      v.push(U);
+    }
+    for (const m of e.range(_)) {
+      const k = {}, U = [];
+      for (; !h(); ) {
+        const R = y(), re = R.key.toString("hex");
+        if (k[re])
+          throw new Error(
+            "Format Error: Keys must be unique for each output: output index " + m + " key " + re
+          );
+        k[re] = 1, U.push(R);
+      }
+      C.push(U);
+    }
+    return o(S, {
+      globalMapKeyVals: d,
+      inputKeyVals: v,
+      outputKeyVals: C
+    });
+  }
+  ae.psbtFromBuffer = c;
+  function s(i, a, u) {
+    if (!a.equals(l.from([u])))
+      throw new Error(
+        `Format Error: Invalid ${i} key: ${a.toString("hex")}`
+      );
+  }
+  ae.checkKeyBuffer = s;
+  function o(i, { globalMapKeyVals: a, inputKeyVals: u, outputKeyVals: f }) {
+    const p = {
+      unsignedTx: i
+    };
+    let g = 0;
+    for (const E of a)
+      switch (E.key[0]) {
+        case r.GlobalTypes.UNSIGNED_TX:
+          if (s(
+            "global",
+            E.key,
+            r.GlobalTypes.UNSIGNED_TX
+          ), g > 0)
+            throw new Error("Format Error: GlobalMap has multiple UNSIGNED_TX");
+          g++;
+          break;
+        case r.GlobalTypes.GLOBAL_XPUB:
+          p.globalXpub === void 0 && (p.globalXpub = []), p.globalXpub.push(t.globals.globalXpub.decode(E));
+          break;
+        default:
+          p.unknownKeyVals || (p.unknownKeyVals = []), p.unknownKeyVals.push(E);
+      }
+    const y = u.length, h = f.length, d = [], w = [];
+    for (const E of e.range(y)) {
+      const S = {};
+      for (const b of u[E])
+        switch (t.inputs.checkPubkey(b), b.key[0]) {
+          case r.InputTypes.NON_WITNESS_UTXO:
+            if (s(
+              "input",
+              b.key,
+              r.InputTypes.NON_WITNESS_UTXO
+            ), S.nonWitnessUtxo !== void 0)
+              throw new Error(
+                "Format Error: Input has multiple NON_WITNESS_UTXO"
+              );
+            S.nonWitnessUtxo = t.inputs.nonWitnessUtxo.decode(b);
+            break;
+          case r.InputTypes.WITNESS_UTXO:
+            if (s(
+              "input",
+              b.key,
+              r.InputTypes.WITNESS_UTXO
+            ), S.witnessUtxo !== void 0)
+              throw new Error("Format Error: Input has multiple WITNESS_UTXO");
+            S.witnessUtxo = t.inputs.witnessUtxo.decode(b);
+            break;
+          case r.InputTypes.PARTIAL_SIG:
+            S.partialSig === void 0 && (S.partialSig = []), S.partialSig.push(t.inputs.partialSig.decode(b));
+            break;
+          case r.InputTypes.SIGHASH_TYPE:
+            if (s(
+              "input",
+              b.key,
+              r.InputTypes.SIGHASH_TYPE
+            ), S.sighashType !== void 0)
+              throw new Error("Format Error: Input has multiple SIGHASH_TYPE");
+            S.sighashType = t.inputs.sighashType.decode(b);
+            break;
+          case r.InputTypes.REDEEM_SCRIPT:
+            if (s(
+              "input",
+              b.key,
+              r.InputTypes.REDEEM_SCRIPT
+            ), S.redeemScript !== void 0)
+              throw new Error("Format Error: Input has multiple REDEEM_SCRIPT");
+            S.redeemScript = t.inputs.redeemScript.decode(b);
+            break;
+          case r.InputTypes.WITNESS_SCRIPT:
+            if (s(
+              "input",
+              b.key,
+              r.InputTypes.WITNESS_SCRIPT
+            ), S.witnessScript !== void 0)
+              throw new Error("Format Error: Input has multiple WITNESS_SCRIPT");
+            S.witnessScript = t.inputs.witnessScript.decode(b);
+            break;
+          case r.InputTypes.BIP32_DERIVATION:
+            S.bip32Derivation === void 0 && (S.bip32Derivation = []), S.bip32Derivation.push(
+              t.inputs.bip32Derivation.decode(b)
+            );
+            break;
+          case r.InputTypes.FINAL_SCRIPTSIG:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.FINAL_SCRIPTSIG
+            ), S.finalScriptSig = t.inputs.finalScriptSig.decode(b);
+            break;
+          case r.InputTypes.FINAL_SCRIPTWITNESS:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.FINAL_SCRIPTWITNESS
+            ), S.finalScriptWitness = t.inputs.finalScriptWitness.decode(
+              b
+            );
+            break;
+          case r.InputTypes.POR_COMMITMENT:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.POR_COMMITMENT
+            ), S.porCommitment = t.inputs.porCommitment.decode(b);
+            break;
+          case r.InputTypes.TAP_KEY_SIG:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.TAP_KEY_SIG
+            ), S.tapKeySig = t.inputs.tapKeySig.decode(b);
+            break;
+          case r.InputTypes.TAP_SCRIPT_SIG:
+            S.tapScriptSig === void 0 && (S.tapScriptSig = []), S.tapScriptSig.push(t.inputs.tapScriptSig.decode(b));
+            break;
+          case r.InputTypes.TAP_LEAF_SCRIPT:
+            S.tapLeafScript === void 0 && (S.tapLeafScript = []), S.tapLeafScript.push(t.inputs.tapLeafScript.decode(b));
+            break;
+          case r.InputTypes.TAP_BIP32_DERIVATION:
+            S.tapBip32Derivation === void 0 && (S.tapBip32Derivation = []), S.tapBip32Derivation.push(
+              t.inputs.tapBip32Derivation.decode(b)
+            );
+            break;
+          case r.InputTypes.TAP_INTERNAL_KEY:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.TAP_INTERNAL_KEY
+            ), S.tapInternalKey = t.inputs.tapInternalKey.decode(b);
+            break;
+          case r.InputTypes.TAP_MERKLE_ROOT:
+            s(
+              "input",
+              b.key,
+              r.InputTypes.TAP_MERKLE_ROOT
+            ), S.tapMerkleRoot = t.inputs.tapMerkleRoot.decode(b);
+            break;
+          default:
+            S.unknownKeyVals || (S.unknownKeyVals = []), S.unknownKeyVals.push(b);
+        }
+      d.push(S);
+    }
+    for (const E of e.range(h)) {
+      const S = {};
+      for (const b of f[E])
+        switch (t.outputs.checkPubkey(b), b.key[0]) {
+          case r.OutputTypes.REDEEM_SCRIPT:
+            if (s(
+              "output",
+              b.key,
+              r.OutputTypes.REDEEM_SCRIPT
+            ), S.redeemScript !== void 0)
+              throw new Error("Format Error: Output has multiple REDEEM_SCRIPT");
+            S.redeemScript = t.outputs.redeemScript.decode(b);
+            break;
+          case r.OutputTypes.WITNESS_SCRIPT:
+            if (s(
+              "output",
+              b.key,
+              r.OutputTypes.WITNESS_SCRIPT
+            ), S.witnessScript !== void 0)
+              throw new Error("Format Error: Output has multiple WITNESS_SCRIPT");
+            S.witnessScript = t.outputs.witnessScript.decode(b);
+            break;
+          case r.OutputTypes.BIP32_DERIVATION:
+            S.bip32Derivation === void 0 && (S.bip32Derivation = []), S.bip32Derivation.push(
+              t.outputs.bip32Derivation.decode(b)
+            );
+            break;
+          case r.OutputTypes.TAP_INTERNAL_KEY:
+            s(
+              "output",
+              b.key,
+              r.OutputTypes.TAP_INTERNAL_KEY
+            ), S.tapInternalKey = t.outputs.tapInternalKey.decode(b);
+            break;
+          case r.OutputTypes.TAP_TREE:
+            s(
+              "output",
+              b.key,
+              r.OutputTypes.TAP_TREE
+            ), S.tapTree = t.outputs.tapTree.decode(b);
+            break;
+          case r.OutputTypes.TAP_BIP32_DERIVATION:
+            S.tapBip32Derivation === void 0 && (S.tapBip32Derivation = []), S.tapBip32Derivation.push(
+              t.outputs.tapBip32Derivation.decode(b)
+            );
+            break;
+          default:
+            S.unknownKeyVals || (S.unknownKeyVals = []), S.unknownKeyVals.push(b);
+        }
+      w.push(S);
+    }
+    return { globalMap: p, inputs: d, outputs: w };
+  }
+  return ae.psbtFromKeyVals = o, ae;
+}
+var de = {}, bn;
+function Io() {
+  if (bn) return de;
+  bn = 1, Object.defineProperty(de, "__esModule", { value: !0 });
+  const t = At(), e = kt();
+  function n({ globalMap: o, inputs: i, outputs: a }) {
+    const { globalKeyVals: u, inputKeyVals: f, outputKeyVals: p } = s({
+      globalMap: o,
+      inputs: i,
+      outputs: a
+    }), g = e.keyValsToBuffer(u), y = (E) => E.length === 0 ? [l.from([0])] : E.map(e.keyValsToBuffer), h = y(f), d = y(p), w = l.allocUnsafe(5);
+    return w.writeUIntBE(482972169471, 0, 5), l.concat(
+      [w, g].concat(h, d)
+    );
+  }
+  de.psbtToBuffer = n;
+  const r = (o, i) => o.key.compare(i.key);
+  function c(o, i) {
+    const a = /* @__PURE__ */ new Set(), u = Object.entries(o).reduce((p, [g, y]) => {
+      if (g === "unknownKeyVals") return p;
+      const h = i[g];
+      if (h === void 0) return p;
+      const d = (Array.isArray(y) ? y : [y]).map(
+        h.encode
+      );
+      return d.map((E) => E.key.toString("hex")).forEach((E) => {
+        if (a.has(E))
+          throw new Error("Serialize Error: Duplicate key: " + E);
+        a.add(E);
+      }), p.concat(d);
+    }, []), f = o.unknownKeyVals ? o.unknownKeyVals.filter((p) => !a.has(p.key.toString("hex"))) : [];
+    return u.concat(f).sort(r);
+  }
+  function s({ globalMap: o, inputs: i, outputs: a }) {
+    return {
+      globalKeyVals: c(o, t.globals),
+      inputKeyVals: i.map((u) => c(u, t.inputs)),
+      outputKeyVals: a.map((u) => c(u, t.outputs))
+    };
+  }
+  return de.psbtToKeyVals = s, de;
+}
+var wn;
+function lr() {
+  return wn || (wn = 1, (function(t) {
+    function e(n) {
+      for (var r in n) t.hasOwnProperty(r) || (t[r] = n[r]);
+    }
+    Object.defineProperty(t, "__esModule", { value: !0 }), e(vo()), e(Io());
+  })(ft)), ft;
+}
+var En;
+function ko() {
+  if (En) return Ue;
+  En = 1, Object.defineProperty(Ue, "__esModule", { value: !0 });
+  const t = lr();
+  function e(s) {
+    const o = s[0], i = t.psbtToKeyVals(o), a = s.slice(1);
+    if (a.length === 0) throw new Error("Combine: Nothing to combine");
+    const u = r(o);
+    if (u === void 0)
+      throw new Error("Combine: Self missing transaction");
+    const f = c(i.globalKeyVals), p = i.inputKeyVals.map(c), g = i.outputKeyVals.map(c);
+    for (const y of a) {
+      const h = r(y);
+      if (h === void 0 || !h.toBuffer().equals(u.toBuffer()))
+        throw new Error(
+          "Combine: One of the Psbts does not have the same transaction."
+        );
+      const d = t.psbtToKeyVals(y);
+      c(d.globalKeyVals).forEach(
+        n(
+          f,
+          i.globalKeyVals,
+          d.globalKeyVals
+        )
+      ), d.inputKeyVals.map(c).forEach(
+        (b, _) => b.forEach(
+          n(
+            p[_],
+            i.inputKeyVals[_],
+            d.inputKeyVals[_]
+          )
+        )
+      ), d.outputKeyVals.map(c).forEach(
+        (b, _) => b.forEach(
+          n(
+            g[_],
+            i.outputKeyVals[_],
+            d.outputKeyVals[_]
+          )
+        )
+      );
+    }
+    return t.psbtFromKeyVals(u, {
+      globalMapKeyVals: i.globalKeyVals,
+      inputKeyVals: i.inputKeyVals,
+      outputKeyVals: i.outputKeyVals
+    });
+  }
+  Ue.combine = e;
+  function n(s, o, i) {
+    return (a) => {
+      if (s.has(a)) return;
+      const u = i.filter((f) => f.key.toString("hex") === a)[0];
+      o.push(u), s.add(a);
+    };
+  }
+  function r(s) {
+    return s.globalMap.unsignedTx;
+  }
+  function c(s) {
+    const o = /* @__PURE__ */ new Set();
+    return s.forEach((i) => {
+      const a = i.key.toString("hex");
+      if (o.has(a))
+        throw new Error("Combine: KeyValue Map keys should be unique");
+      o.add(a);
+    }), o;
+  }
+  return Ue;
+}
+var ht = {}, Tn;
+function dr() {
+  return Tn || (Tn = 1, (function(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 });
+    const e = At();
+    function n(y, h) {
+      const d = y[h];
+      if (d === void 0) throw new Error(`No input #${h}`);
+      return d;
+    }
+    t.checkForInput = n;
+    function r(y, h) {
+      const d = y[h];
+      if (d === void 0) throw new Error(`No output #${h}`);
+      return d;
+    }
+    t.checkForOutput = r;
+    function c(y, h, d) {
+      if (y.key[0] < d)
+        throw new Error(
+          "Use the method for your specific key instead of addUnknownKeyVal*"
+        );
+      if (h && h.filter((w) => w.key.equals(y.key)).length !== 0)
+        throw new Error(`Duplicate Key: ${y.key.toString("hex")}`);
+    }
+    t.checkHasKey = c;
+    function s(y) {
+      let h = 0;
+      return Object.keys(y).forEach((d) => {
+        Number(isNaN(Number(d))) && h++;
+      }), h;
+    }
+    t.getEnumLength = s;
+    function o(y, h) {
+      let d = !1;
+      if (h.nonWitnessUtxo || h.witnessUtxo) {
+        const w = !!h.redeemScript, E = !!h.witnessScript, S = !w || !!h.finalScriptSig, b = !E || !!h.finalScriptWitness, _ = !!h.finalScriptSig || !!h.finalScriptWitness;
+        d = S && b && _;
+      }
+      if (d === !1)
+        throw new Error(
+          `Input #${y} has too much or too little data to clean`
+        );
+    }
+    t.inputCheckUncleanFinalized = o;
+    function i(y, h, d, w) {
+      throw new Error(
+        `Data for ${y} key ${h} is incorrect: Expected ${d} and got ${JSON.stringify(w)}`
+      );
+    }
+    function a(y) {
+      return (h, d) => {
+        for (const w of Object.keys(h)) {
+          const E = h[w], { canAdd: S, canAddToArray: b, check: _, expected: v } = (
+            // @ts-ignore
+            e[y + "s"][w] || {}
+          ), C = !!b;
+          if (_)
+            if (C) {
+              if (!Array.isArray(E) || // @ts-ignore
+              d[w] && !Array.isArray(d[w]))
+                throw new Error(`Key type ${w} must be an array`);
+              E.every(_) || i(y, w, v, E);
+              const m = d[w] || [], k = /* @__PURE__ */ new Set();
+              if (!E.every((U) => b(m, U, k)))
+                throw new Error("Can not add duplicate data to array");
+              d[w] = m.concat(E);
+            } else {
+              if (_(E) || i(y, w, v, E), !S(d, E))
+                throw new Error(`Can not add duplicate data to ${y}`);
+              d[w] = E;
+            }
+        }
+      };
+    }
+    t.updateGlobal = a("global"), t.updateInput = a("input"), t.updateOutput = a("output");
+    function u(y, h) {
+      const d = y.length - 1, w = n(y, d);
+      t.updateInput(h, w);
+    }
+    t.addInputAttributes = u;
+    function f(y, h) {
+      const d = y.length - 1, w = r(y, d);
+      t.updateOutput(h, w);
+    }
+    t.addOutputAttributes = f;
+    function p(y, h) {
+      if (!l.isBuffer(h) || h.length < 4)
+        throw new Error("Set Version: Invalid Transaction");
+      return h.writeUInt32LE(y, 0), h;
+    }
+    t.defaultVersionSetter = p;
+    function g(y, h) {
+      if (!l.isBuffer(h) || h.length < 4)
+        throw new Error("Set Locktime: Invalid Transaction");
+      return h.writeUInt32LE(y, h.length - 4), h;
+    }
+    t.defaultLocktimeSetter = g;
+  })(ht)), ht;
+}
+var _n;
+function Ao() {
+  if (_n) return He;
+  _n = 1, Object.defineProperty(He, "__esModule", { value: !0 });
+  const t = ko(), e = lr(), n = A(), r = dr();
+  class c {
+    constructor(o) {
+      this.inputs = [], this.outputs = [], this.globalMap = {
+        unsignedTx: o
+      };
+    }
+    static fromBase64(o, i) {
+      const a = l.from(o, "base64");
+      return this.fromBuffer(a, i);
+    }
+    static fromHex(o, i) {
+      const a = l.from(o, "hex");
+      return this.fromBuffer(a, i);
+    }
+    static fromBuffer(o, i) {
+      const a = e.psbtFromBuffer(o, i), u = new this(a.globalMap.unsignedTx);
+      return Object.assign(u, a), u;
+    }
+    toBase64() {
+      return this.toBuffer().toString("base64");
+    }
+    toHex() {
+      return this.toBuffer().toString("hex");
+    }
+    toBuffer() {
+      return e.psbtToBuffer(this);
+    }
+    updateGlobal(o) {
+      return r.updateGlobal(o, this.globalMap), this;
+    }
+    updateInput(o, i) {
+      const a = r.checkForInput(this.inputs, o);
+      return r.updateInput(i, a), this;
+    }
+    updateOutput(o, i) {
+      const a = r.checkForOutput(this.outputs, o);
+      return r.updateOutput(i, a), this;
+    }
+    addUnknownKeyValToGlobal(o) {
+      return r.checkHasKey(
+        o,
+        this.globalMap.unknownKeyVals,
+        r.getEnumLength(n.GlobalTypes)
+      ), this.globalMap.unknownKeyVals || (this.globalMap.unknownKeyVals = []), this.globalMap.unknownKeyVals.push(o), this;
+    }
+    addUnknownKeyValToInput(o, i) {
+      const a = r.checkForInput(this.inputs, o);
+      return r.checkHasKey(
+        i,
+        a.unknownKeyVals,
+        r.getEnumLength(n.InputTypes)
+      ), a.unknownKeyVals || (a.unknownKeyVals = []), a.unknownKeyVals.push(i), this;
+    }
+    addUnknownKeyValToOutput(o, i) {
+      const a = r.checkForOutput(this.outputs, o);
+      return r.checkHasKey(
+        i,
+        a.unknownKeyVals,
+        r.getEnumLength(n.OutputTypes)
+      ), a.unknownKeyVals || (a.unknownKeyVals = []), a.unknownKeyVals.push(i), this;
+    }
+    addInput(o) {
+      this.globalMap.unsignedTx.addInput(o), this.inputs.push({
+        unknownKeyVals: []
+      });
+      const i = o.unknownKeyVals || [], a = this.inputs.length - 1;
+      if (!Array.isArray(i))
+        throw new Error("unknownKeyVals must be an Array");
+      return i.forEach(
+        (u) => this.addUnknownKeyValToInput(a, u)
+      ), r.addInputAttributes(this.inputs, o), this;
+    }
+    addOutput(o) {
+      this.globalMap.unsignedTx.addOutput(o), this.outputs.push({
+        unknownKeyVals: []
+      });
+      const i = o.unknownKeyVals || [], a = this.outputs.length - 1;
+      if (!Array.isArray(i))
+        throw new Error("unknownKeyVals must be an Array");
+      return i.forEach(
+        (u) => this.addUnknownKeyValToOutput(a, u)
+      ), r.addOutputAttributes(this.outputs, o), this;
+    }
+    clearFinalizedInput(o) {
+      const i = r.checkForInput(this.inputs, o);
+      r.inputCheckUncleanFinalized(o, i);
+      for (const a of Object.keys(i))
+        [
+          "witnessUtxo",
+          "nonWitnessUtxo",
+          "finalScriptSig",
+          "finalScriptWitness",
+          "unknownKeyVals"
+        ].includes(a) || delete i[a];
+      return this;
+    }
+    combine(...o) {
+      const i = t.combine([this].concat(o));
+      return Object.assign(this, i), this;
+    }
+    getTransaction() {
+      return this.globalMap.unsignedTx.toBuffer();
+    }
+  }
+  return He.Psbt = c, He;
+}
+var mn = Ao(), x = dr();
+const vn = bt.decode, xo = {
+  /**
+   * A bitcoinjs Network object. This is only used if you pass an `address`
+   * parameter to addOutput. Otherwise it is not needed and can be left default.
+   */
+  network: Je,
+  /**
+   * When extractTransaction is called, the fee rate is checked.
+   * THIS IS NOT TO BE RELIED ON.
+   * It is only here as a last ditch effort to prevent sending a 500 BTC fee etc.
+   */
+  maximumFeeRate: 5e3
+  // satoshi per byte
+};
+class Tt {
+  constructor(e = {}, n = new mn.Psbt(new gr())) {
+    this.data = n, this.opts = Object.assign({}, xo, e), this.__CACHE = {
+      __NON_WITNESS_UTXO_TX_CACHE: [],
+      __NON_WITNESS_UTXO_BUF_CACHE: [],
+      __TX_IN_CACHE: {},
+      // unsignedTx.tx property is dynamically added by PsbtBase
+      __TX: this.data.globalMap.unsignedTx.tx,
+      __UNSAFE_SIGN_NONSEGWIT: !1
+    }, e.version === 3 ? this.setVersionTRUC() : this.data.inputs.length === 0 && this.setVersion(2);
+    const r = (c, s, o, i) => {
+      Object.defineProperty(c, s, {
+        enumerable: o,
+        writable: i
+      });
+    };
+    r(this, "__CACHE", !1, !0), r(this, "opts", !1, !0);
+  }
+  get inputCount() {
+    return this.data.inputs.length;
+  }
+  get version() {
+    return this.__CACHE.__TX.version;
+  }
+  set version(e) {
+    this.setVersion(e);
+  }
+  get locktime() {
+    return this.__CACHE.__TX.locktime;
+  }
+  set locktime(e) {
+    this.setLocktime(e);
+  }
+  get txInputs() {
+    return this.__CACHE.__TX.ins.map((e) => ({
+      hash: Ot(e.hash),
+      index: e.index,
+      sequence: e.sequence
+    }));
+  }
+  get txOutputs() {
+    return this.__CACHE.__TX.outs.map((e) => {
+      let n;
+      try {
+        n = zn(e.script, this.opts.network);
+      } catch {
+      }
+      return {
+        script: Ot(e.script),
+        value: e.value,
+        address: n
+      };
+    });
+  }
+  static fromBase64(e, n = {}) {
+    const r = l.from(e, "base64");
+    return this.fromBuffer(r, n);
+  }
+  static fromHex(e, n = {}) {
+    const r = l.from(e, "hex");
+    return this.fromBuffer(r, n);
+  }
+  static fromBuffer(e, n = {}) {
+    const r = mn.Psbt.fromBuffer(e, Oo), c = new Tt(n, r);
+    return Uo(c.__CACHE.__TX, c.__CACHE), c;
+  }
+  combine(...e) {
+    return this.data.combine(...e.map((n) => n.data)), this;
+  }
+  clone() {
+    const e = JSON.parse(JSON.stringify(this.opts));
+    return Tt.fromBuffer(this.data.toBuffer(), e);
+  }
+  setMaximumFeeRate(e) {
+    Ge(e), this.opts.maximumFeeRate = e;
+  }
+  setVersion(e) {
+    Ge(e), ge(this.data.inputs, "setVersion");
+    const n = this.__CACHE;
+    return n.__TX.version = e, n.__EXTRACTED_TX = void 0, this;
+  }
+  setVersionTRUC() {
+    return this.setVersion(I.TRUC_VERSION);
+  }
+  setLocktime(e) {
+    Ge(e), ge(this.data.inputs, "setLocktime");
+    const n = this.__CACHE;
+    return n.__TX.locktime = e, n.__EXTRACTED_TX = void 0, this;
+  }
+  setInputSequence(e, n) {
+    Ge(n), ge(this.data.inputs, "setInputSequence");
+    const r = this.__CACHE;
+    if (r.__TX.ins.length <= e)
+      throw new Error("Input index too high");
+    return r.__TX.ins[e].sequence = n, r.__EXTRACTED_TX = void 0, this;
+  }
+  addInputs(e, n = !0) {
+    return e.forEach((r) => this.addInput(r, n)), this;
+  }
+  addInput(e, n = !0) {
+    if (!e || e.hash === void 0 || e.index === void 0)
+      throw new Error(
+        "Invalid arguments for Psbt.addInput. Requires single object with at least [hash] and [index]"
+      );
+    Xt(e, e, "addInput"), n && ge(this.data.inputs, "addInput"), e.witnessScript && ze(e.witnessScript);
+    const r = this.__CACHE;
+    this.data.addInput(e);
+    const c = r.__TX.ins[r.__TX.ins.length - 1];
+    br(r, c);
+    const s = this.data.inputs.length - 1, o = this.data.inputs[s];
+    return o.nonWitnessUtxo && mt(this.__CACHE, o, s), r.__FEE = void 0, r.__FEE_RATE = void 0, r.__EXTRACTED_TX = void 0, this;
+  }
+  addOutputs(e) {
+    return e.forEach((n) => this.addOutput(n)), this;
+  }
+  addOutput(e) {
+    const n = "address" in e, r = "script" in e;
+    if (arguments.length > 1 || !e || e.value === void 0 || !n && !r)
+      throw new Error(
+        "Invalid arguments for Psbt.addOutput. Requires single object with at least [script or address] and [value]"
+      );
+    if (ge(this.data.inputs, "addOutput"), n) {
+      const { address: s } = e, { network: o } = this.opts, i = $n(s, o);
+      e = Object.assign({}, e, { script: i });
+    }
+    qt(e, e, "addOutput");
+    const c = this.__CACHE;
+    return this.data.addOutput(e), c.__FEE = void 0, c.__FEE_RATE = void 0, c.__EXTRACTED_TX = void 0, this;
+  }
+  extractTransaction(e, n) {
+    if (n && (this.data.inputs = this.data.inputs.filter((s) => !s.partialSig)), !this.data.inputs.every(yr)) throw new Error("Not finalized");
+    const r = this.__CACHE;
+    if (e || Po(this, r, this.opts), r.__EXTRACTED_TX) return r.__EXTRACTED_TX;
+    const c = r.__TX.clone();
+    return vr(this.data.inputs, c, r, !0, n), c;
+  }
+  getFeeRate(e = !1) {
+    return On(
+      "__FEE_RATE",
+      "fee rate",
+      this.data.inputs,
+      this.__CACHE,
+      e
+    );
+  }
+  getFee(e = !1) {
+    return On("__FEE", "fee", this.data.inputs, this.__CACHE, e);
+  }
+  finalizeAllInputs() {
+    return x.checkForInput(this.data.inputs, 0), ye(this.data.inputs.length).forEach((e) => this.finalizeInput(e)), this;
+  }
+  finalizeInput(e, n, r) {
+    const c = x.checkForInput(this.data.inputs, e);
+    return H(c) ? this._finalizeTaprootInput(
+      e,
+      c,
+      void 0,
+      n
+    ) : this._finalizeInput(
+      e,
+      c,
+      n,
+      r ?? !0
+    );
+  }
+  finalizeTaprootInput(e, n, r = Gt) {
+    const c = x.checkForInput(this.data.inputs, e);
+    if (H(c))
+      return this._finalizeTaprootInput(
+        e,
+        c,
+        n,
+        r
+      );
+    throw new Error(`Cannot finalize input #${e}. Not Taproot.`);
+  }
+  getInputType(e) {
+    const n = x.checkForInput(this.data.inputs, e), r = Ir(e, n, this.__CACHE), c = st(
+      r,
+      e,
+      "input",
+      n.redeemScript || qo(n.finalScriptSig),
+      n.witnessScript || Do(n.finalScriptWitness)
+    ), s = c.type === "raw" ? "" : c.type + "-", o = Ar(c.meaningfulScript);
+    return s + o;
+  }
+  inputHasPubkey(e, n) {
+    const r = x.checkForInput(this.data.inputs, e);
+    return Go(n, r, e, this.__CACHE);
+  }
+  inputHasHDKey(e, n) {
+    const r = x.checkForInput(this.data.inputs, e), c = kn(n);
+    return !!r.bip32Derivation && r.bip32Derivation.some(c);
+  }
+  outputHasPubkey(e, n) {
+    const r = x.checkForOutput(this.data.outputs, e);
+    return Xo(n, r, e, this.__CACHE);
+  }
+  outputHasHDKey(e, n) {
+    const r = x.checkForOutput(this.data.outputs, e), c = kn(n);
+    return !!r.bip32Derivation && r.bip32Derivation.some(c);
+  }
+  validateSignaturesOfAllInputs(e) {
+    return x.checkForInput(this.data.inputs, 0), ye(this.data.inputs.length).map(
+      (r) => this.validateSignaturesOfInput(r, e)
+    ).reduce((r, c) => c && r, !0);
+  }
+  validateSignaturesOfInput(e, n, r) {
+    const c = this.data.inputs[e];
+    return H(c) ? this.validateSignaturesOfTaprootInput(e, n, r) : this._validateSignaturesOfInput(e, n, r);
+  }
+  signAllInputsHD(e, n = [I.SIGHASH_ALL]) {
+    if (!e || !e.publicKey || !e.fingerprint)
+      throw new Error("Need HDSigner to sign input");
+    const r = [];
+    for (const c of ye(this.data.inputs.length))
+      try {
+        this.signInputHD(c, e, n), r.push(!0);
+      } catch {
+        r.push(!1);
+      }
+    if (r.every((c) => !c))
+      throw new Error("No inputs were signed");
+    return this;
+  }
+  signAllInputsHDAsync(e, n = [I.SIGHASH_ALL]) {
+    return new Promise((r, c) => {
+      if (!e || !e.publicKey || !e.fingerprint)
+        return c(new Error("Need HDSigner to sign input"));
+      const s = [], o = [];
+      for (const i of ye(this.data.inputs.length))
+        o.push(
+          this.signInputHDAsync(i, e, n).then(
+            () => {
+              s.push(!0);
+            },
+            () => {
+              s.push(!1);
+            }
+          )
+        );
+      return Promise.all(o).then(() => {
+        if (s.every((i) => !i))
+          return c(new Error("No inputs were signed"));
+        r();
+      });
+    });
+  }
+  signInputHD(e, n, r = [I.SIGHASH_ALL]) {
+    if (!n || !n.publicKey || !n.fingerprint)
+      throw new Error("Need HDSigner to sign input");
+    return Nn(e, this.data.inputs, n).forEach((s) => this.signInput(e, s, r)), this;
+  }
+  signInputHDAsync(e, n, r = [I.SIGHASH_ALL]) {
+    return new Promise((c, s) => {
+      if (!n || !n.publicKey || !n.fingerprint)
+        return s(new Error("Need HDSigner to sign input"));
+      const i = Nn(e, this.data.inputs, n).map(
+        (a) => this.signInputAsync(e, a, r)
+      );
+      return Promise.all(i).then(() => {
+        c();
+      }).catch(s);
+    });
+  }
+  signAllInputs(e, n) {
+    if (!e || !e.publicKey) throw new Error("Need Signer to sign input");
+    const r = [];
+    for (const c of ye(this.data.inputs.length))
+      try {
+        this.signInput(c, e, n), r.push(!0);
+      } catch {
+        r.push(!1);
+      }
+    if (r.every((c) => !c))
+      throw new Error("No inputs were signed");
+    return this;
+  }
+  signAllInputsAsync(e, n) {
+    return new Promise((r, c) => {
+      if (!e || !e.publicKey)
+        return c(new Error("Need Signer to sign input"));
+      const s = [], o = [];
+      for (const [i] of this.data.inputs.entries())
+        o.push(
+          this.signInputAsync(i, e, n).then(
+            () => {
+              s.push(!0);
+            },
+            () => {
+              s.push(!1);
+            }
+          )
+        );
+      return Promise.all(o).then(() => {
+        if (s.every((i) => !i))
+          return c(new Error("No inputs were signed"));
+        r();
+      });
+    });
+  }
+  signInput(e, n, r) {
+    if (!n || !n.publicKey)
+      throw new Error("Need Signer to sign input");
+    const c = x.checkForInput(this.data.inputs, e);
+    return H(c) ? this._signTaprootInput(e, c, n, void 0, r) : this._signInput(e, n, r);
+  }
+  signTaprootInput(e, n, r, c) {
+    if (!n || !n.publicKey)
+      throw new Error("Need Signer to sign input");
+    const s = x.checkForInput(this.data.inputs, e);
+    if (H(s))
+      return this._signTaprootInput(
+        e,
+        s,
+        n,
+        r,
+        c
+      );
+    throw new Error(`Input #${e} is not of type Taproot.`);
+  }
+  signInputAsync(e, n, r) {
+    return Promise.resolve().then(() => {
+      if (!n || !n.publicKey) throw new Error("Need Signer to sign input");
+      const c = x.checkForInput(this.data.inputs, e);
+      return H(c) ? this._signTaprootInputAsync(
+        e,
+        c,
+        n,
+        void 0,
+        r
+      ) : this._signInputAsync(e, n, r);
+    });
+  }
+  signTaprootInputAsync(e, n, r, c) {
+    return Promise.resolve().then(() => {
+      if (!n || !n.publicKey) throw new Error("Need Signer to sign input");
+      const s = x.checkForInput(this.data.inputs, e);
+      if (H(s))
+        return this._signTaprootInputAsync(
+          e,
+          s,
+          n,
+          r,
+          c
+        );
+      throw new Error(`Input #${e} is not of type Taproot.`);
+    });
+  }
+  toBuffer() {
+    return lt(this.__CACHE), this.data.toBuffer();
+  }
+  toHex() {
+    return lt(this.__CACHE), this.data.toHex();
+  }
+  toBase64() {
+    return lt(this.__CACHE), this.data.toBase64();
+  }
+  updateGlobal(e) {
+    return this.data.updateGlobal(e), this;
+  }
+  updateInput(e, n) {
+    return n.witnessScript && ze(n.witnessScript), Xt(this.data.inputs[e], n, "updateInput"), this.data.updateInput(e, n), n.nonWitnessUtxo && mt(this.__CACHE, this.data.inputs[e], e), this;
+  }
+  updateOutput(e, n) {
+    const r = this.data.outputs[e];
+    return qt(r, n, "updateOutput"), this.data.updateOutput(e, n), this;
+  }
+  addUnknownKeyValToGlobal(e) {
+    return this.data.addUnknownKeyValToGlobal(e), this;
+  }
+  addUnknownKeyValToInput(e, n) {
+    return this.data.addUnknownKeyValToInput(e, n), this;
+  }
+  addUnknownKeyValToOutput(e, n) {
+    return this.data.addUnknownKeyValToOutput(e, n), this;
+  }
+  clearFinalizedInput(e) {
+    return this.data.clearFinalizedInput(e), this;
+  }
+  checkTaprootHashesForSig(e, n, r, c, s) {
+    if (typeof r.signSchnorr != "function")
+      throw new Error(`Need Schnorr Signer to sign taproot input #${e}.`);
+    const o = l.isBuffer(r.publicKey) ? r.publicKey : l.from(r.publicKey), i = _t(
+      e,
+      n,
+      this.data.inputs,
+      o,
+      this.__CACHE,
+      c,
+      s
+    );
+    if (!i || !i.length)
+      throw new Error(
+        `Can not sign for input #${e} with the key ${o.toString("hex")}`
+      );
+    return i;
+  }
+  _finalizeInput(e, n, r = Bo, c = !0) {
+    const { script: s, isP2SH: o, isP2WSH: i, isSegwit: a } = Lo(
+      e,
+      n,
+      this.__CACHE
+    );
+    if (!s) throw new Error(`No script found for input #${e}`);
+    No(n);
+    const { finalScriptSig: u, finalScriptWitness: f } = r(
+      e,
+      n,
+      s,
+      a,
+      o,
+      i,
+      c
+    );
+    if (u && this.data.updateInput(e, { finalScriptSig: u }), f && this.data.updateInput(e, { finalScriptWitness: f }), !u && !f)
+      throw new Error(`Unknown error finalizing input #${e}`);
+    return this.data.clearFinalizedInput(e), this;
+  }
+  _finalizeTaprootInput(e, n, r, c = Gt) {
+    if (!n.witnessUtxo)
+      throw new Error(`Cannot finalize input #${e}. Missing witness utxo.`);
+    if (n.tapKeySig) {
+      const s = Ie({
+        output: n.witnessUtxo.script,
+        signature: n.tapKeySig
+      });
+      if (!s.witness) throw new Error("Cannot finalize taproot key spend");
+      const o = Ee(s.witness);
+      this.data.updateInput(e, { finalScriptWitness: o });
+    } else {
+      const { finalScriptWitness: s } = c(
+        e,
+        n,
+        r
+      );
+      this.data.updateInput(e, { finalScriptWitness: s });
+    }
+    return this.data.clearFinalizedInput(e), this;
+  }
+  _validateSignaturesOfInput(e, n, r) {
+    const c = this.data.inputs[e], s = (c || {}).partialSig;
+    if (!c || !s || s.length < 1)
+      throw new Error("No signatures to validate");
+    if (typeof n != "function")
+      throw new Error("Need validator function to validate signatures");
+    const o = r ? s.filter((p) => p.pubkey.equals(r)) : s;
+    if (o.length < 1) throw new Error("No signatures for this pubkey");
+    const i = [];
+    let a, u, f;
+    for (const p of o) {
+      const g = Se.decode(p.signature), { hash: y, script: h } = f !== g.hashType || !a || !u ? Er(
+        e,
+        Object.assign({}, c, {
+          sighashType: g.hashType
+        }),
+        this.__CACHE,
+        !0
+      ) : { hash: a, script: u };
+      f = g.hashType, a = y, u = h, Sr(p.pubkey, h, "verify"), i.push(n(p.pubkey, y, g.signature));
+    }
+    return i.every((p) => p);
+  }
+  validateSignaturesOfTaprootInput(e, n, r) {
+    const c = this.data.inputs[e], s = (c || {}).tapKeySig, o = (c || {}).tapScriptSig;
+    if (!c && !s && !(o && !o.length))
+      throw new Error("No signatures to validate");
+    if (typeof n != "function")
+      throw new Error("Need validator function to validate signatures");
+    r = r && we(r);
+    const i = r ? _t(e, c, this.data.inputs, r, this.__CACHE) : Fo(e, c, this.data.inputs, this.__CACHE);
+    if (!i.length) throw new Error("No signatures for this pubkey");
+    const a = i.find((f) => !f.leafHash);
+    let u = 0;
+    if (s && a) {
+      if (!n(
+        a.pubkey,
+        a.hash,
+        Pn(s)
+      )) return !1;
+      u++;
+    }
+    if (o)
+      for (const f of o) {
+        const p = i.find((g) => f.pubkey.equals(g.pubkey));
+        if (p) {
+          if (!n(
+            f.pubkey,
+            p.hash,
+            Pn(f.signature)
+          )) return !1;
+          u++;
+        }
+      }
+    return u > 0;
+  }
+  _signInput(e, n, r = [I.SIGHASH_ALL]) {
+    const c = l.isBuffer(n.publicKey) ? n.publicKey : l.from(n.publicKey), { hash: s, sighashType: o } = Cn(
+      this.data.inputs,
+      e,
+      c,
+      this.__CACHE,
+      r
+    ), i = n.sign(s), a = [
+      {
+        pubkey: c,
+        signature: Se.encode(
+          l.isBuffer(i) ? i : l.from(i),
+          o
+        )
+      }
+    ];
+    return this.data.updateInput(e, { partialSig: a }), this;
+  }
+  _signTaprootInput(e, n, r, c, s = [I.SIGHASH_DEFAULT]) {
+    const o = l.isBuffer(r.publicKey) ? r.publicKey : l.from(r.publicKey), i = this.checkTaprootHashesForSig(
+      e,
+      n,
+      r,
+      c,
+      s
+    ), a = r.signSchnorr.bind(r), u = (g) => l.isBuffer(g) ? g : l.from(g), f = i.filter((g) => !g.leafHash).map(
+      (g) => Pe(u(a(g.hash)), n.sighashType)
+    )[0], p = i.filter((g) => !!g.leafHash).map(
+      (g) => ({
+        pubkey: we(o),
+        signature: Pe(
+          u(a(g.hash)),
+          n.sighashType
+        ),
+        leafHash: g.leafHash
+      })
+    );
+    return f && this.data.updateInput(e, { tapKeySig: f }), p.length && this.data.updateInput(e, { tapScriptSig: p }), this;
+  }
+  _signInputAsync(e, n, r = [I.SIGHASH_ALL]) {
+    const c = l.isBuffer(n.publicKey) ? n.publicKey : l.from(n.publicKey), { hash: s, sighashType: o } = Cn(
+      this.data.inputs,
+      e,
+      c,
+      this.__CACHE,
+      r
+    );
+    return Promise.resolve(n.sign(s)).then((i) => {
+      const a = l.isBuffer(i) ? i : l.from(i), u = [
+        {
+          pubkey: c,
+          signature: Se.encode(a, o)
+        }
+      ];
+      this.data.updateInput(e, { partialSig: u });
+    });
+  }
+  async _signTaprootInputAsync(e, n, r, c, s = [I.SIGHASH_DEFAULT]) {
+    const o = l.isBuffer(r.publicKey) ? r.publicKey : l.from(r.publicKey), i = this.checkTaprootHashesForSig(
+      e,
+      n,
+      r,
+      c,
+      s
+    ), a = r.signSchnorr.bind(r), u = (h) => l.isBuffer(h) ? h : l.from(h), f = [], p = i.filter((h) => !h.leafHash)[0];
+    if (p) {
+      const h = Promise.resolve(a(p.hash)).then((d) => ({
+        tapKeySig: Pe(u(d), n.sighashType)
+      }));
+      f.push(h);
+    }
+    const g = i.filter((h) => !!h.leafHash);
+    if (g.length) {
+      const h = g.map(async (d) => {
+        const w = await a(d.hash);
+        return { tapScriptSig: [
+          {
+            pubkey: we(o),
+            signature: Pe(
+              u(w),
+              n.sighashType
+            ),
+            leafHash: d.leafHash
+          }
+        ] };
+      });
+      f.push(...h);
+    }
+    const y = await Promise.all(f);
+    for (const h of y)
+      this.data.updateInput(e, h);
+  }
+}
+const Oo = (t) => new gr(t);
+class gr {
+  constructor(e = l.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
+    this.tx = I.fromBuffer(e), Ho(this.tx), Object.defineProperty(this, "tx", {
+      enumerable: !1,
+      writable: !0
+    });
+  }
+  getInputOutputCounts() {
+    return {
+      inputCount: this.tx.ins.length,
+      outputCount: this.tx.outs.length
+    };
+  }
+  addInput(e) {
+    if (e.hash === void 0 || e.index === void 0 || !l.isBuffer(e.hash) && typeof e.hash != "string" || typeof e.index != "number")
+      throw new Error("Error adding input.");
+    const n = typeof e.hash == "string" ? Bn(l.from(e.hash, "hex")) : e.hash;
+    this.tx.addInput(n, e.index, e.sequence);
+  }
+  addOutput(e) {
+    if (e.script === void 0 || e.value === void 0 || !l.isBuffer(e.script) || typeof e.value != "number")
+      throw new Error("Error adding output.");
+    this.tx.addOutput(e.script, e.value);
+  }
+  toBuffer() {
+    return this.tx.toBuffer();
+  }
+}
+function Co(t, e, n) {
+  switch (n) {
+    case "pubkey":
+    case "pubkeyhash":
+    case "witnesspubkeyhash":
+      return In(1, t.partialSig);
+    case "multisig": {
+      const r = Ze({
+        output: e
+      });
+      return In(r.m, t.partialSig, r.pubkeys);
+    }
+    case "nonstandard":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function lt(t) {
+  if (t.__UNSAFE_SIGN_NONSEGWIT)
+    throw new Error("Not BIP174 compliant, can not export");
+}
+function In(t, e, n) {
+  if (!e) return !1;
+  let r;
+  if (n ? r = n.map((c) => {
+    const s = Vo(c);
+    return e.find((o) => o.pubkey.equals(s));
+  }).filter((c) => !!c) : r = e, r.length > t) throw new Error("Too many signatures");
+  return r.length === t;
+}
+function yr(t) {
+  return !!t.finalScriptSig || !!t.finalScriptWitness;
+}
+function kn(t) {
+  return (e) => {
+    const n = l.isBuffer(t.fingerprint) ? t.fingerprint : l.from(t.fingerprint);
+    if (!e.masterFingerprint.equals(n)) return !1;
+    const r = t.derivePath(e.path).publicKey;
+    return !!(l.isBuffer(r) ? r : l.from(r)).equals(e.pubkey);
+  };
+}
+function Ge(t) {
+  if (typeof t != "number" || t !== Math.floor(t) || t > 4294967295 || t < 0)
+    throw new Error("Invalid 32 bit integer");
+}
+function Po(t, e, n) {
+  const r = e.__FEE_RATE || t.getFeeRate(), c = e.__EXTRACTED_TX.virtualSize(), s = r * c;
+  if (r >= n.maximumFeeRate)
+    throw new Error(
+      `Warning: You are paying around ${(s / 1e8).toFixed(8)} in fees, which is ${r} satoshi per byte for a transaction with a VSize of ${c} 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(t, e) {
+  t.forEach((n) => {
+    if (H(n) ? Ls(n, e) : to(n, e)) throw new Error("Can not modify transaction, signatures exist.");
+  });
+}
+function No(t) {
+  if (!t.sighashType || !t.partialSig) return;
+  const { partialSig: e, sighashType: n } = t;
+  e.forEach((r) => {
+    const { hashType: c } = Se.decode(r.signature);
+    if (n !== c)
+      throw new Error("Signature sighash does not match input sighash type");
+  });
+}
+function Sr(t, e, n) {
+  if (!nt(t, e))
+    throw new Error(`Can not ${n} for this input with the key ${t.toString("hex")}`);
+}
+function Ho(t) {
+  if (!t.ins.every(
+    (n) => n.script && n.script.length === 0 && n.witness && n.witness.length === 0
+  ))
+    throw new Error("Format Error: Transaction ScriptSigs are not empty");
+}
+function Uo(t, e) {
+  t.ins.forEach((n) => {
+    br(e, n);
+  });
+}
+function br(t, e) {
+  const n = `${Bn(l.from(e.hash)).toString("hex")}:${e.index}`;
+  if (t.__TX_IN_CACHE[n]) throw new Error("Duplicate input detected.");
+  t.__TX_IN_CACHE[n] = 1;
+}
+function wr(t, e) {
+  return (n, r, c, s) => {
+    const o = t({
+      redeem: { output: c }
+    }).output;
+    if (!r.equals(o))
+      throw new Error(
+        `${e} for ${s} #${n} doesn't match the scriptPubKey in the prevout`
+      );
+  };
+}
+const An = wr(me, "Redeem script"), xn = wr(ve, "Witness script");
+function On(t, e, n, r, c = !1) {
+  if (!n.every(yr)) throw new Error(`PSBT must be finalized to calculate ${e}`);
+  if (t === "__FEE_RATE" && r.__FEE_RATE) return r.__FEE_RATE;
+  if (t === "__FEE" && r.__FEE) return r.__FEE;
+  let s, o = !0;
+  r.__EXTRACTED_TX ? (s = r.__EXTRACTED_TX, o = !1) : s = r.__TX.clone(), vr(n, s, r, o, c);
+  const i = t === "__FEE_RATE" ? r.__FEE_RATE : r.__FEE;
+  if (i === void 0) throw new Error(`Failed to calculate ${e}`);
+  return i;
+}
+function Bo(t, e, n, r, c, s, o = !0, i) {
+  const a = Ar(n);
+  if (!Co(e, n, a) && o)
+    throw new Error(`Can not finalize input #${t}`);
+  return Ro(
+    n,
+    a,
+    e.partialSig,
+    r,
+    c,
+    s,
+    i
+  );
+}
+function Ro(t, e, n, r, c, s, o) {
+  let i, a;
+  const u = Ko(t, e, n), f = s ? ve({ redeem: u }) : null, p = c ? me({ redeem: f || u }) : null;
+  return r ? (f ? a = Ee(f.witness) : u ? a = Ee(u.witness) : a = Ee(o ?? [l.from([0])]), p && (i = p?.input)) : p ? i = p?.input : u ? i = u.input : i = Array.isArray(o) && o[0] ? o[0] : l.from([1]), {
+    finalScriptSig: i,
+    finalScriptWitness: a
+  };
+}
+function Cn(t, e, n, r, c) {
+  const s = x.checkForInput(t, e), { hash: o, sighashType: i, script: a } = Er(
+    e,
+    s,
+    r,
+    !1,
+    c
+  );
+  return Sr(n, a, "sign"), {
+    hash: o,
+    sighashType: i
+  };
+}
+function Er(t, e, n, r, c) {
+  const s = n.__TX, o = e.sighashType || I.SIGHASH_ALL;
+  _r(o, c);
+  let i, a;
+  if (e.nonWitnessUtxo) {
+    const p = rt(n, e, t), g = s.ins[t].hash, y = p.getHash();
+    if (!g.equals(y))
+      throw new Error(
+        `Non-witness UTXO hash for input #${t} doesn't match the hash specified in the prevout`
+      );
+    const h = s.ins[t].index;
+    a = p.outs[h];
+  } else if (e.witnessUtxo)
+    a = e.witnessUtxo;
+  else
+    throw new Error("Need a Utxo input item for signing");
+  const { meaningfulScript: u, type: f } = st(
+    a.script,
+    t,
+    "input",
+    e.redeemScript,
+    e.witnessScript
+  );
+  if (["p2sh-p2wsh", "p2wsh"].indexOf(f) >= 0)
+    i = s.hashForWitnessV0(
+      t,
+      u,
+      a.value,
+      o
+    );
+  else if (tt(u)) {
+    const p = _e({
+      hash: u.subarray(2)
+    }).output;
+    i = s.hashForWitnessV0(t, p, a.value, o);
+  } else {
+    if (e.nonWitnessUtxo === void 0 && !n.__UNSAFE_SIGN_NONSEGWIT)
+      throw new Error(
+        `Input #${t} has witnessUtxo but non-segwit script: ` + u.toString("hex")
+      );
+    !r && n.__UNSAFE_SIGN_NONSEGWIT && 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!
+*********************`
+    ), i = s.hashForSignature(t, u, o);
+  }
+  return {
+    script: u,
+    sighashType: o,
+    hash: i
+  };
+}
+function Fo(t, e, n, r) {
+  const c = [];
+  if (e.tapInternalKey) {
+    const o = Tr(t, e, r);
+    o && c.push(o);
+  }
+  if (e.tapScriptSig) {
+    const o = e.tapScriptSig.map((i) => i.pubkey);
+    c.push(...o);
+  }
+  return c.map(
+    (o) => _t(t, e, n, o, r)
+  ).flat();
+}
+function Tr(t, e, n) {
+  const { script: r } = xt(t, e, n);
+  return It(r) ? l.from(r.subarray(2, 34)) : null;
+}
+function Pn(t) {
+  return t.length === 64 ? t : l.from(t.subarray(0, 64));
+}
+function _t(t, e, n, r, c, s, o) {
+  const i = c.__TX, a = e.sighashType || I.SIGHASH_DEFAULT;
+  _r(a, o);
+  const u = n.map(
+    (h, d) => xt(d, h, c)
+  ), f = u.map((h) => h.script), p = u.map((h) => h.value), g = [];
+  if (e.tapInternalKey && !s) {
+    const h = Tr(t, e, c) || l.from([]);
+    if (we(r).equals(h)) {
+      const d = i.hashForWitnessV1(
+        t,
+        f,
+        p,
+        a
+      );
+      g.push({ pubkey: r, hash: d });
+    }
+  }
+  const y = (e.tapLeafScript || []).filter((h) => nt(r, h.script)).map((h) => {
+    const d = Ye({
+      output: h.script,
+      version: h.leafVersion
+    });
+    return Object.assign({ hash: d }, h);
+  }).filter((h) => !s || s.equals(h.hash)).map((h) => {
+    const d = i.hashForWitnessV1(
+      t,
+      f,
+      p,
+      a,
+      h.hash
+    );
+    return {
+      pubkey: r,
+      hash: d,
+      leafHash: h.hash
+    };
+  });
+  return g.concat(y);
+}
+function _r(t, e) {
+  if (e && e.indexOf(t) < 0) {
+    const n = Wo(t);
+    throw new Error(
+      `Sighash type is not allowed. Retry the sign method passing the sighashTypes array of whitelisted types. Sighash type: ${n}`
+    );
+  }
+}
+function Ko(t, e, n) {
+  let r;
+  switch (e) {
+    case "multisig": {
+      const c = Mo(t, n);
+      r = Ze({
+        output: t,
+        signatures: c
+      });
+      break;
+    }
+    case "pubkey":
+      r = Kn({
+        output: t,
+        signature: n[0].signature
+      });
+      break;
+    case "pubkeyhash":
+      r = _e({
+        output: t,
+        pubkey: n[0].pubkey,
+        signature: n[0].signature
+      });
+      break;
+    case "witnesspubkeyhash":
+      r = $e({
+        output: t,
+        pubkey: n[0].pubkey,
+        signature: n[0].signature
+      });
+      break;
+  }
+  return r;
+}
+function Lo(t, e, n) {
+  const r = n.__TX, c = {
+    script: null,
+    isSegwit: !1,
+    isP2SH: !1,
+    isP2WSH: !1
+  };
+  if (c.isP2SH = !!e.redeemScript, c.isP2WSH = !!e.witnessScript, e.witnessScript)
+    c.script = e.witnessScript;
+  else if (e.redeemScript)
+    c.script = e.redeemScript;
+  else if (e.nonWitnessUtxo) {
+    const s = rt(n, e, t), o = r.ins[t].index;
+    c.script = s.outs[o].script;
+  } else e.witnessUtxo && (c.script = e.witnessUtxo.script);
+  if (e.witnessScript || tt(c.script))
+    c.isSegwit = !0;
+  else
+    try {
+      const s = c.script;
+      if (!s) throw new TypeError("Invalid script for segwit address");
+      c.isSegwit = Gn(s);
+    } catch {
+    }
+  return c;
+}
+function Nn(t, e, n) {
+  const r = x.checkForInput(e, t);
+  if (!r.bip32Derivation || r.bip32Derivation.length === 0)
+    throw new Error("Need bip32Derivation to sign with HD");
+  const c = r.bip32Derivation.map((s) => {
+    if (s.masterFingerprint.equals(n.fingerprint))
+      return s;
+  }).filter((s) => !!s);
+  if (c.length === 0)
+    throw new Error(
+      "Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint"
+    );
+  return c.map((s) => {
+    const o = n.derivePath(s.path);
+    if (!s.pubkey.equals(o.publicKey))
+      throw new Error("pubkey did not match bip32Derivation");
+    return o;
+  });
+}
+function Mo(t, e) {
+  return Ze({ output: t }).pubkeys.map((r) => (e.filter((c) => c.pubkey.equals(r))[0] || {}).signature).filter((r) => !!r);
+}
+function mr(t) {
+  let e = 0;
+  function n(o) {
+    return e += o, t.subarray(e - o, e);
+  }
+  function r() {
+    const o = vn(t, e);
+    return e += vn.bytes, o;
+  }
+  function c() {
+    return n(r());
+  }
+  function s() {
+    const o = r(), i = [];
+    for (let a = 0; a < o; a++) i.push(c());
+    return i;
+  }
+  return s();
+}
+function Wo(t) {
+  let e = t & I.SIGHASH_ANYONECANPAY ? "SIGHASH_ANYONECANPAY | " : "";
+  switch (t & 31) {
+    case I.SIGHASH_ALL:
+      e += "SIGHASH_ALL";
+      break;
+    case I.SIGHASH_SINGLE:
+      e += "SIGHASH_SINGLE";
+      break;
+    case I.SIGHASH_NONE:
+      e += "SIGHASH_NONE";
+      break;
+  }
+  return e;
+}
+function mt(t, e, n) {
+  t.__NON_WITNESS_UTXO_BUF_CACHE[n] = e.nonWitnessUtxo, t.__NON_WITNESS_UTXO_TX_CACHE[n] = I.fromBuffer(e.nonWitnessUtxo);
+  const r = t, c = n;
+  delete e.nonWitnessUtxo, Object.defineProperty(e, "nonWitnessUtxo", {
+    enumerable: !0,
+    get() {
+      const s = r.__NON_WITNESS_UTXO_BUF_CACHE[c], o = r.__NON_WITNESS_UTXO_TX_CACHE[c];
+      if (s !== void 0)
+        return s;
+      {
+        const i = o.toBuffer();
+        return r.__NON_WITNESS_UTXO_BUF_CACHE[c] = i, i;
+      }
+    },
+    set(s) {
+      r.__NON_WITNESS_UTXO_BUF_CACHE[c] = s;
+    }
+  });
+}
+function vr(t, e, n, r, c) {
+  let s = 0;
+  t.forEach((u, f) => {
+    if (r && u.finalScriptSig && (e.ins[f].script = u.finalScriptSig), r && u.finalScriptWitness && (e.ins[f].witness = mr(u.finalScriptWitness)), u.witnessUtxo)
+      s += u.witnessUtxo.value;
+    else if (u.nonWitnessUtxo) {
+      const p = rt(n, u, f), g = e.ins[f].index, y = p.outs[g];
+      s += y.value;
+    }
+  });
+  const o = e.outs.reduce((u, f) => u + f.value, 0), i = s - o;
+  if (!c && i < 0)
+    throw new Error(
+      `Outputs are spending more than Inputs ${s} < ${o}`
+    );
+  const a = e.virtualSize();
+  n.__FEE = i, n.__EXTRACTED_TX = e, n.__FEE_RATE = Math.floor(i / a);
+}
+function rt(t, e, n) {
+  const r = t.__NON_WITNESS_UTXO_TX_CACHE;
+  return r[n] || mt(t, e, n), r[n];
+}
+function Ir(t, e, n) {
+  const { script: r } = xt(t, e, n);
+  return r;
+}
+function xt(t, e, n) {
+  if (e.witnessUtxo !== void 0)
+    return {
+      script: e.witnessUtxo.script,
+      value: e.witnessUtxo.value
+    };
+  if (e.nonWitnessUtxo !== void 0) {
+    const c = rt(n, e, t).outs[n.__TX.ins[t].index];
+    return { script: c.script, value: c.value };
+  } else
+    throw new Error("Can't find pubkey in input without Utxo data");
+}
+function Go(t, e, n, r) {
+  const c = Ir(n, e, r), { meaningfulScript: s } = st(
+    c,
+    n,
+    "input",
+    e.redeemScript,
+    e.witnessScript
+  );
+  return nt(t, s);
+}
+function Xo(t, e, n, r) {
+  const c = r.__TX.outs[n].script, { meaningfulScript: s } = st(
+    c,
+    n,
+    "output",
+    e.redeemScript,
+    e.witnessScript
+  );
+  return nt(t, s);
+}
+function qo(t) {
+  if (!t) return;
+  const e = he(t);
+  if (!e) return;
+  const n = e[e.length - 1];
+  if (!(!l.isBuffer(n) || kr(n) || jo(n) || !he(n)))
+    return n;
+}
+function Do(t) {
+  if (!t) return;
+  const e = mr(t), n = e[e.length - 1];
+  if (!(kr(n) || !he(n)))
+    return n;
+}
+function Vo(t) {
+  if (t.length === 65) {
+    const e = t[64] & 1, n = l.from(t.subarray(0, 33));
+    return n[0] = 2 | e, n;
+  }
+  return l.from(t);
+}
+function kr(t) {
+  return t.length === 33 && Pr(t);
+}
+function jo(t) {
+  return Hn(t);
+}
+function st(t, e, n, r, c) {
+  const s = ur(t), o = s && r && Dt(r), i = Dt(t);
+  if (s && r === void 0)
+    throw new Error("scriptPubkey is P2SH but redeemScript missing");
+  if ((i || o) && c === void 0)
+    throw new Error("scriptPubkey or redeemScript is P2WSH but witnessScript missing");
+  let a;
+  return o ? (a = c, An(e, t, r, n), xn(e, r, c, n), ze(a)) : i ? (a = c, xn(e, t, c, n), ze(a)) : s ? (a = r, An(e, t, r, n)) : a = t, {
+    meaningfulScript: a,
+    type: o ? "p2sh-p2wsh" : s ? "p2sh" : i ? "p2wsh" : "raw"
+  };
+}
+function ze(t) {
+  if (tt(t) || ur(t))
+    throw new Error("P2WPKH or P2SH can not be contained within P2WSH");
+}
+function Ar(t) {
+  return tt(t) ? "witnesspubkeyhash" : Qs(t) ? "pubkeyhash" : Zs(t) ? "multisig" : Js(t) ? "pubkey" : "nonstandard";
+}
+function ye(t) {
+  return [...Array(t).keys()];
+}
+const oi = {
+  networks: Qr,
+  address: ws,
+  payments: Wr,
+  script: Nr,
+  crypto: xr,
+  Transaction: Gr
+};
+export {
+  nt as $,
+  Wn as A,
+  De as B,
+  Qe as C,
+  et as D,
+  Gn as E,
+  ke as F,
+  Xn as G,
+  Dn as H,
+  bs as I,
+  jn as J,
+  zn as K,
+  $n as L,
+  Zs as M,
+  Js as N,
+  Qs as O,
+  Tt as P,
+  tt as Q,
+  Dt as R,
+  ur as S,
+  It as T,
+  ri as U,
+  si as V,
+  Ee as W,
+  Vt as X,
+  Ne as Y,
+  fr as Z,
+  qn as _,
+  eo as a,
+  to as a0,
+  pr as a1,
+  ro as a2,
+  Je as b,
+  oi as c,
+  M as d,
+  ws as e,
+  Vn as f,
+  ei as g,
+  Qo as h,
+  Mn as i,
+  Bo as j,
+  Gt as k,
+  H as l,
+  at as m,
+  Qr as n,
+  Xt as o,
+  Ro as p,
+  qt as q,
+  ti as r,
+  Pe as s,
+  we as t,
+  ni as u,
+  Ks as v,
+  Ls as w,
+  Gs as x,
+  Ae as y,
+  xe as z
+};