@pioneer-platform/pioneer-react 0.2.47 → 0.2.49

package/dist/index_94d38802.js

@@ -0,0 +1,2856 @@
+import { f as requireBrowser$8, d as dist, h as requireSafeBuffer, i as requireBrowser$9, j as requireSha_js, g as getDefaultExportFromCjs, R as RIPEMD160 } from "./index_94b7968d.js";
+import { c as crypto_1 } from "./index_29be6ff5.js";
+import { S as Sg } from "./index_096371b1.js";
+import { F as Fg } from "./index_6cd7bc1a.js";
+import { s } from "./index_b1028d5f.js";
+import { d } from "./index_10812439.js";
+import { w } from "./index_c232ca43.js";
+import { v as vn$1 } from "./index_849386d3.js";
+import "./index_3402bab8.js";
+import "./index_2dc95f2a.js";
+import "./index_a5ca5cc4.js";
+import "./index_f8bc80e1.js";
+import "./index_0652205a.js";
+import "./index_aa71379e.js";
+import "react";
+import "@chakra-ui/react";
+import "react-dom";
+import "./index_0a6e5811.js";
+import "./index_aa773d39.js";
+const X = requireBrowser$8(), rn = dist.Buffer.alloc(1, 1), gt = dist.Buffer.alloc(1, 0);
+function sn(n, e, t, r, o) {
+  let i = dist.Buffer.alloc(32, 0), s2 = dist.Buffer.alloc(32, 1);
+  i = X("sha256", i).update(s2).update(gt).update(e).update(n).update(o || "").digest(), s2 = X("sha256", i).update(s2).digest(), i = X("sha256", i).update(s2).update(rn).update(e).update(n).update(o || "").digest(), s2 = X("sha256", i).update(s2).digest(), s2 = X("sha256", i).update(s2).digest();
+  let a = s2;
+  for (; !r(a) || !t(a); )
+    i = X("sha256", i).update(s2).update(gt).digest(), s2 = X("sha256", i).update(s2).digest(), s2 = X("sha256", i).update(s2).digest(), a = s2;
+  return a;
+}
+var on = sn;
+const un = Sg, cn = Fg.ec, ot = new cn("secp256k1"), fn = on, Se = dist.Buffer.alloc(32, 0), _e = dist.Buffer.from("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", "hex"), wt = dist.Buffer.from("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f", "hex"), G = ot.curve.n, Mt = G.shrn(1), Me = ot.curve.g, Ae = "Expected Private", ie = "Expected Point", Ne = "Expected Tweak", At = "Expected Hash", an = "Expected Signature", ln = "Expected Extra Data (32 bytes)";
+function xe(n) {
+  return dist.Buffer.isBuffer(n) && n.length === 32;
+}
+function De(n) {
+  return xe(n) ? n.compare(_e) < 0 : false;
+}
+function z(n) {
+  if (!dist.Buffer.isBuffer(n) || n.length < 33)
+    return false;
+  const e = n[0], t = n.slice(1, 33);
+  if (t.compare(Se) === 0 || t.compare(wt) >= 0)
+    return false;
+  if ((e === 2 || e === 3) && n.length === 33) {
+    try {
+      se(n);
+    } catch {
+      return false;
+    }
+    return true;
+  }
+  const r = n.slice(33);
+  return r.compare(Se) === 0 || r.compare(wt) >= 0 ? false : e === 4 && n.length === 65;
+}
+function Nt(n) {
+  return n[0] !== 4;
+}
+function hn(n) {
+  return z(n) ? Nt(n) : false;
+}
+function H(n) {
+  return xe(n) ? n.compare(Se) > 0 && // > 0
+  n.compare(_e) < 0 : false;
+}
+function pn(n) {
+  const e = n.slice(0, 32), t = n.slice(32, 64);
+  return dist.Buffer.isBuffer(n) && n.length === 64 && e.compare(_e) < 0 && t.compare(_e) < 0;
+}
+function Ee(n, e) {
+  return n === void 0 && e !== void 0 ? Nt(e) : n === void 0 ? true : n;
+}
+function k(n) {
+  return new un(n);
+}
+function ve(n) {
+  return n.toArrayLike(dist.Buffer, "be", 32);
+}
+function se(n) {
+  return ot.curve.decodePoint(n);
+}
+function le(n, e) {
+  return dist.Buffer.from(n._encode(e));
+}
+function dn(n, e, t) {
+  if (!z(n))
+    throw new TypeError(ie);
+  if (!z(e))
+    throw new TypeError(ie);
+  const r = se(n), o = se(e), i = r.add(o);
+  if (i.isInfinity())
+    return null;
+  const s2 = Ee(t, n);
+  return le(i, s2);
+}
+function gn(n, e, t) {
+  if (!z(n))
+    throw new TypeError(ie);
+  if (!De(e))
+    throw new TypeError(Ne);
+  const r = Ee(t, n), o = se(n);
+  if (e.compare(Se) === 0)
+    return le(o, r);
+  const i = k(e), s2 = Me.mul(i), a = o.add(s2);
+  return a.isInfinity() ? null : le(a, r);
+}
+function wn(n, e) {
+  if (!z(n))
+    throw new TypeError(ie);
+  const t = se(n);
+  if (t.isInfinity())
+    throw new TypeError(ie);
+  const r = Ee(e, n);
+  return le(t, r);
+}
+function mn(n, e) {
+  if (!H(n))
+    throw new TypeError(Ae);
+  const t = k(n), r = Me.mul(t);
+  if (r.isInfinity())
+    return null;
+  const o = Ee(e);
+  return le(r, o);
+}
+function In(n, e, t) {
+  if (!z(n))
+    throw new TypeError(ie);
+  if (!De(e))
+    throw new TypeError(Ne);
+  const r = Ee(t, n), o = se(n), i = k(e), s2 = o.mul(i);
+  return s2.isInfinity() ? null : le(s2, r);
+}
+function xn(n, e) {
+  if (!H(n))
+    throw new TypeError(Ae);
+  if (!De(e))
+    throw new TypeError(Ne);
+  const t = k(n), r = k(e), o = ve(t.add(r).umod(G));
+  return H(o) ? o : null;
+}
+function En(n, e) {
+  if (!H(n))
+    throw new TypeError(Ae);
+  if (!De(e))
+    throw new TypeError(Ne);
+  const t = k(n), r = k(e), o = ve(t.sub(r).umod(G));
+  return H(o) ? o : null;
+}
+function Bn(n, e) {
+  return Dt(n, e);
+}
+function Tn(n, e, t) {
+  return Dt(n, e, t);
+}
+function Dt(n, e, t) {
+  if (!xe(n))
+    throw new TypeError(At);
+  if (!H(e))
+    throw new TypeError(Ae);
+  if (t !== void 0 && !xe(t))
+    throw new TypeError(ln);
+  const r = k(e), o = k(n);
+  let i, s2;
+  fn(n, e, function(l) {
+    const f = k(l), h = Me.mul(f);
+    return !(h.isInfinity() || (i = h.x.umod(G), i.isZero() === 0) || (s2 = f.invm(G).mul(o.add(r.mul(i))).umod(G), s2.isZero() === 0));
+  }, H, t), s2.cmp(Mt) > 0 && (s2 = G.sub(s2));
+  const c = dist.Buffer.allocUnsafe(64);
+  return ve(i).copy(c, 0), ve(s2).copy(c, 32), c;
+}
+function yn(n, e, t, r) {
+  if (!xe(n))
+    throw new TypeError(At);
+  if (!z(e))
+    throw new TypeError(ie);
+  if (!pn(t))
+    throw new TypeError(an);
+  const o = se(e), i = k(t.slice(0, 32)), s2 = k(t.slice(32, 64));
+  if (r && s2.cmp(Mt) > 0 || i.gtn(0) <= 0 || s2.gtn(0) <= 0)
+    return false;
+  const a = k(n), c = s2.invm(G), l = a.mul(c).umod(G), f = i.mul(c).umod(G), h = Me.mulAdd(l, o, f);
+  return h.isInfinity() ? false : h.x.umod(G).eq(i);
+}
+var kt = {
+  isPoint: z,
+  isPointCompressed: hn,
+  isPrivate: H,
+  pointAdd: dn,
+  pointAddScalar: gn,
+  pointCompress: wn,
+  pointFromScalar: mn,
+  pointMultiply: In,
+  privateAdd: xn,
+  privateSub: En,
+  sign: Bn,
+  signWithEntropy: Tn,
+  verify: yn
+}, ye = requireSafeBuffer().Buffer;
+function Sn(n) {
+  if (n.length >= 255)
+    throw new TypeError("Alphabet too long");
+  for (var e = new Uint8Array(256), t = 0; t < e.length; t++)
+    e[t] = 255;
+  for (var r = 0; r < n.length; r++) {
+    var o = n.charAt(r), i = o.charCodeAt(0);
+    if (e[i] !== 255)
+      throw new TypeError(o + " is ambiguous");
+    e[i] = r;
+  }
+  var s2 = n.length, a = n.charAt(0), c = Math.log(s2) / Math.log(256), l = Math.log(256) / Math.log(s2);
+  function f(w2) {
+    if ((Array.isArray(w2) || w2 instanceof Uint8Array) && (w2 = ye.from(w2)), !ye.isBuffer(w2))
+      throw new TypeError("Expected Buffer");
+    if (w2.length === 0)
+      return "";
+    for (var T = 0, y = 0, B = 0, m = w2.length; B !== m && w2[B] === 0; )
+      B++, T++;
+    for (var p = (m - B) * l + 1 >>> 0, d2 = new Uint8Array(p); B !== m; ) {
+      for (var E = w2[B], _ = 0, I = p - 1; (E !== 0 || _ < y) && I !== -1; I--, _++)
+        E += 256 * d2[I] >>> 0, d2[I] = E % s2 >>> 0, E = E / s2 >>> 0;
+      if (E !== 0)
+        throw new Error("Non-zero carry");
+      y = _, B++;
+    }
+    for (var b = p - y; b !== p && d2[b] === 0; )
+      b++;
+    for (var U = a.repeat(T); b < p; ++b)
+      U += n.charAt(d2[b]);
+    return U;
+  }
+  function h(w2) {
+    if (typeof w2 != "string")
+      throw new TypeError("Expected String");
+    if (w2.length === 0)
+      return ye.alloc(0);
+    for (var T = 0, y = 0, B = 0; w2[T] === a; )
+      y++, T++;
+    for (var m = (w2.length - T) * c + 1 >>> 0, p = new Uint8Array(m); w2[T]; ) {
+      var d2 = e[w2.charCodeAt(T)];
+      if (d2 === 255)
+        return;
+      for (var E = 0, _ = m - 1; (d2 !== 0 || E < B) && _ !== -1; _--, E++)
+        d2 += s2 * p[_] >>> 0, p[_] = d2 % 256 >>> 0, d2 = d2 / 256 >>> 0;
+      if (d2 !== 0)
+        throw new Error("Non-zero carry");
+      B = E, T++;
+    }
+    for (var I = m - B; I !== m && p[I] === 0; )
+      I++;
+    var b = ye.allocUnsafe(y + (m - I));
+    b.fill(0, 0, y);
+    for (var U = y; I !== m; )
+      b[U++] = p[I++];
+    return b;
+  }
+  function x(w2) {
+    var T = h(w2);
+    if (T)
+      return T;
+    throw new Error("Non-base" + s2 + " character");
+  }
+  return {
+    encode: f,
+    decodeUnsafe: h,
+    decode: x
+  };
+}
+var _n = Sn, vn = _n, bn = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", Ct = vn(bn);
+const Pn = /* @__PURE__ */ getDefaultExportFromCjs(Ct);
+var Ve = Ct, On = requireSafeBuffer().Buffer, Rn = function(n) {
+  function e(i) {
+    var s2 = n(i);
+    return Ve.encode(On.concat([
+      i,
+      s2
+    ], i.length + 4));
+  }
+  function t(i) {
+    var s2 = i.slice(0, -4), a = i.slice(-4), c = n(s2);
+    if (!(a[0] ^ c[0] | a[1] ^ c[1] | a[2] ^ c[2] | a[3] ^ c[3]))
+      return s2;
+  }
+  function r(i) {
+    var s2 = Ve.decodeUnsafe(i);
+    if (s2)
+      return t(s2);
+  }
+  function o(i) {
+    var s2 = Ve.decode(i), a = t(s2);
+    if (!a)
+      throw new Error("Invalid checksum");
+    return a;
+  }
+  return {
+    encode: e,
+    decode: o,
+    decodeUnsafe: r
+  };
+}, mt = requireBrowser$9(), Un = Rn;
+function Mn(n) {
+  var e = mt("sha256").update(n).digest();
+  return mt("sha256").update(e).digest();
+}
+var An = Un(Mn);
+const Lt = /* @__PURE__ */ getDefaultExportFromCjs(An);
+function Ye(n) {
+  const e = dist.Buffer.alloc(1 + n.length * 4);
+  return e[0] = n.length, n.forEach((t, r) => {
+    e.writeUInt32BE(t, 1 + 4 * r);
+  }), e;
+}
+function ut(n) {
+  const e = n ? F(n) : [];
+  return Ye(e);
+}
+function ct(n) {
+  return s.fromPathArray(n).toString();
+}
+function F(n) {
+  return s.fromString(n).toPathArray();
+}
+function It(n) {
+  const e = Lt.decode(n);
+  return e.slice(e.length - 33);
+}
+function xt(n) {
+  const e = Lt.decode(n);
+  return {
+    chaincode: e.slice(13, 13 + 32),
+    pubkey: e.slice(e.length - 33),
+    version: e.readUInt32BE(0)
+  };
+}
+function Nn(n) {
+  for (let e = n.length - 1; e >= 0; e--)
+    if (n[e] >= 2147483648)
+      return n.slice(0, e + 1);
+  return [];
+}
+var je = requireSafeBuffer().Buffer, Dn = 9007199254740991;
+function ft(n) {
+  if (n < 0 || n > Dn || n % 1 !== 0)
+    throw new RangeError("value out of range");
+}
+function we(n, e, t) {
+  if (ft(n), e || (e = je.allocUnsafe(Kt(n))), !je.isBuffer(e))
+    throw new TypeError("buffer must be a Buffer instance");
+  return t || (t = 0), n < 253 ? (e.writeUInt8(n, t), we.bytes = 1) : n <= 65535 ? (e.writeUInt8(253, t), e.writeUInt16LE(n, t + 1), we.bytes = 3) : n <= 4294967295 ? (e.writeUInt8(254, t), e.writeUInt32LE(n, t + 1), we.bytes = 5) : (e.writeUInt8(255, t), e.writeUInt32LE(n >>> 0, t + 1), e.writeUInt32LE(n / 4294967296 | 0, t + 5), we.bytes = 9), e;
+}
+function me(n, e) {
+  if (!je.isBuffer(n))
+    throw new TypeError("buffer must be a Buffer instance");
+  e || (e = 0);
+  var t = n.readUInt8(e);
+  if (t < 253)
+    return me.bytes = 1, t;
+  if (t === 253)
+    return me.bytes = 3, n.readUInt16LE(e + 1);
+  if (t === 254)
+    return me.bytes = 5, n.readUInt32LE(e + 1);
+  me.bytes = 9;
+  var r = n.readUInt32LE(e + 1), o = n.readUInt32LE(e + 5), i = o * 4294967296 + r;
+  return ft(i), i;
+}
+function Kt(n) {
+  return ft(n), n < 253 ? 1 : n <= 65535 ? 3 : n <= 4294967295 ? 5 : 9;
+}
+var kn = { encode: we, decode: me, encodingLength: Kt };
+const Ze = /* @__PURE__ */ getDefaultExportFromCjs(kn);
+function Gt(n) {
+  if (n > Number.MAX_SAFE_INTEGER)
+    throw new Error("Can't convert numbers > MAX_SAFE_INT");
+  const e = dist.Buffer.alloc(8, 0);
+  for (let t = 0; t < e.length; t++) {
+    const r = n & 255;
+    e[t] = r, n = (n - r) / 256;
+  }
+  return e;
+}
+function Vt(n) {
+  let e = 0;
+  if (n.length != 8)
+    throw new Error("Expected Bufffer of lenght 8");
+  if (n[7] != 0)
+    throw new Error("Can't encode numbers > MAX_SAFE_INT");
+  if (n[6] > 31)
+    throw new Error("Can't encode numbers > MAX_SAFE_INT");
+  for (let t = n.length - 1; t >= 0; t--)
+    e = e * 256 + n[t];
+  return e;
+}
+class A {
+  constructor() {
+    this.bufs = [];
+  }
+  write(e, t) {
+    const r = dist.Buffer.alloc(e);
+    t(r), this.bufs.push(r);
+  }
+  writeUInt8(e) {
+    this.write(1, (t) => t.writeUInt8(e, 0));
+  }
+  writeInt32(e) {
+    this.write(4, (t) => t.writeInt32LE(e, 0));
+  }
+  writeUInt32(e) {
+    this.write(4, (t) => t.writeUInt32LE(e, 0));
+  }
+  writeUInt64(e) {
+    const t = Gt(e);
+    this.writeSlice(t);
+  }
+  writeVarInt(e) {
+    this.bufs.push(Ze.encode(e));
+  }
+  writeSlice(e) {
+    this.bufs.push(dist.Buffer.from(e));
+  }
+  writeVarSlice(e) {
+    this.writeVarInt(e.length), this.writeSlice(e);
+  }
+  buffer() {
+    return dist.Buffer.concat(this.bufs);
+  }
+}
+class ee {
+  constructor(e, t = 0) {
+    this.buffer = e, this.offset = t;
+  }
+  available() {
+    return this.buffer.length - this.offset;
+  }
+  readUInt8() {
+    const e = this.buffer.readUInt8(this.offset);
+    return this.offset++, e;
+  }
+  readInt32() {
+    const e = this.buffer.readInt32LE(this.offset);
+    return this.offset += 4, e;
+  }
+  readUInt32() {
+    const e = this.buffer.readUInt32LE(this.offset);
+    return this.offset += 4, e;
+  }
+  readUInt64() {
+    const e = this.readSlice(8);
+    return Vt(e);
+  }
+  readVarInt() {
+    const e = Ze.decode(this.buffer, this.offset);
+    return this.offset += Ze.decode.bytes, e;
+  }
+  readSlice(e) {
+    if (this.buffer.length < this.offset + e)
+      throw new Error("Cannot read slice out of bounds");
+    const t = this.buffer.slice(this.offset, this.offset + e);
+    return this.offset += e, t;
+  }
+  readVarSlice() {
+    return this.readSlice(this.readVarInt());
+  }
+  readVector() {
+    const e = this.readVarInt(), t = [];
+    for (let r = 0; r < e; r++)
+      t.push(this.readVarSlice());
+    return t;
+  }
+}
+const Y = 50, Cn = 1, Ft = 0, be = 4294967295, at = 1, qt = 118, lt = 169, ke = 20, Ln = 135, Wt = 136, Xt = 172;
+var Kn = requireSha_js();
+const Pe = /* @__PURE__ */ getDefaultExportFromCjs(Kn);
+function he(n) {
+  return new RIPEMD160().update(Pe("sha256").update(n).digest()).digest();
+}
+class Gn {
+  constructor(e, t) {
+    this.psbt = e, this.masterFp = t;
+  }
+}
+class Ce extends Gn {
+  spendingCondition(e) {
+    if (e.length != 1)
+      throw new Error("Expected single key, got " + e.length);
+    return this.singleKeyCondition(e[0]);
+  }
+  setInput(e, t, r, o, i) {
+    if (o.length != 1)
+      throw new Error("Expected single key, got " + o.length);
+    if (i.length != 1)
+      throw new Error("Expected single path, got " + i.length);
+    this.setSingleKeyInput(e, t, r, o[0], i[0]);
+  }
+  setOwnOutput(e, t, r, o) {
+    if (r.length != 1)
+      throw new Error("Expected single key, got " + r.length);
+    if (o.length != 1)
+      throw new Error("Expected single path, got " + o.length);
+    this.setSingleKeyOutput(e, t, r[0], o[0]);
+  }
+}
+class Vn extends Ce {
+  singleKeyCondition(e) {
+    const t = new A(), r = he(e);
+    return t.writeSlice(dist.Buffer.from([qt, lt, ke])), t.writeSlice(r), t.writeSlice(dist.Buffer.from([Wt, Xt])), { scriptPubKey: t.buffer() };
+  }
+  setSingleKeyInput(e, t, r, o, i) {
+    if (!t)
+      throw new Error("Full input base transaction required");
+    this.psbt.setInputNonWitnessUtxo(e, t), this.psbt.setInputBip32Derivation(e, o, this.masterFp, i);
+  }
+  setSingleKeyOutput(e, t, r, o) {
+    this.psbt.setOutputBip32Derivation(e, r, this.masterFp, o);
+  }
+  getDescriptorTemplate() {
+    return "pkh(@0)";
+  }
+}
+class Fn extends Ce {
+  singleKeyCondition(e) {
+    const t = e.slice(1), r = new A(), o = this.getTaprootOutputKey(t);
+    return r.writeSlice(dist.Buffer.from([81, 32])), r.writeSlice(o), { scriptPubKey: r.buffer() };
+  }
+  setSingleKeyInput(e, t, r, o, i) {
+    const s2 = o.slice(1);
+    this.psbt.setInputTapBip32Derivation(e, s2, [], this.masterFp, i), this.psbt.setInputWitnessUtxo(e, r.amount, r.cond.scriptPubKey);
+  }
+  setSingleKeyOutput(e, t, r, o) {
+    const i = r.slice(1);
+    this.psbt.setOutputTapBip32Derivation(e, i, [], this.masterFp, o);
+  }
+  getDescriptorTemplate() {
+    return "tr(@0)";
+  }
+  /*
+  The following two functions are copied from wallet-btc and adapted.
+  They should be moved to a library to avoid code reuse.
+  */
+  hashTapTweak(e) {
+    const t = crypto_1.sha256(dist.Buffer.from("TapTweak", "utf-8"));
+    return crypto_1.sha256(dist.Buffer.concat([t, t, e]));
+  }
+  /**
+   * Calculates a taproot output key from an internal key. This output key will be
+   * used as witness program in a taproot output. The internal key is tweaked
+   * according to recommendation in BIP341:
+   * https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_ref-22-0
+   *
+   * @param internalPubkey A 32 byte x-only taproot internal key
+   * @returns The output key
+   */
+  getTaprootOutputKey(e) {
+    if (e.length != 32)
+      throw new Error("Expected 32 byte pubkey. Got " + e.length);
+    const t = dist.Buffer.concat([dist.Buffer.from([2]), e]), r = this.hashTapTweak(e);
+    return dist.Buffer.from(kt.pointAddScalar(t, r)).slice(1);
+  }
+}
+class qn extends Ce {
+  singleKeyCondition(e) {
+    const t = new A(), r = this.createRedeemScript(e), o = he(r);
+    return t.writeSlice(dist.Buffer.from([lt, ke])), t.writeSlice(o), t.writeUInt8(Ln), { scriptPubKey: t.buffer(), redeemScript: r };
+  }
+  setSingleKeyInput(e, t, r, o, i) {
+    if (!t)
+      throw new Error("Full input base transaction required");
+    this.psbt.setInputNonWitnessUtxo(e, t), this.psbt.setInputBip32Derivation(e, o, this.masterFp, i);
+    const s2 = r.cond.redeemScript, a = this.createRedeemScript(o);
+    if (s2 && !a.equals(s2))
+      throw new Error(`User-supplied redeemScript ${s2.toString("hex")} doesn't
+       match expected ${a.toString("hex")} for input ${e}`);
+    this.psbt.setInputRedeemScript(e, a), this.psbt.setInputWitnessUtxo(e, r.amount, r.cond.scriptPubKey);
+  }
+  setSingleKeyOutput(e, t, r, o) {
+    this.psbt.setOutputRedeemScript(e, t.redeemScript), this.psbt.setOutputBip32Derivation(e, r, this.masterFp, o);
+  }
+  getDescriptorTemplate() {
+    return "sh(wpkh(@0))";
+  }
+  createRedeemScript(e) {
+    const t = he(e);
+    return dist.Buffer.concat([dist.Buffer.from("0014", "hex"), t]);
+  }
+}
+class Wn extends Ce {
+  singleKeyCondition(e) {
+    const t = new A(), r = he(e);
+    return t.writeSlice(dist.Buffer.from([0, ke])), t.writeSlice(r), { scriptPubKey: t.buffer() };
+  }
+  setSingleKeyInput(e, t, r, o, i) {
+    if (!t)
+      throw new Error("Full input base transaction required");
+    this.psbt.setInputNonWitnessUtxo(e, t), this.psbt.setInputBip32Derivation(e, o, this.masterFp, i), this.psbt.setInputWitnessUtxo(e, r.amount, r.cond.scriptPubKey);
+  }
+  setSingleKeyOutput(e, t, r, o) {
+    this.psbt.setOutputBip32Derivation(e, r, this.masterFp, o);
+  }
+  getDescriptorTemplate() {
+    return "wpkh(@0)";
+  }
+}
+class te {
+  constructor(e, t = crypto_1.sha256) {
+    this.leaves = e, this.h = t;
+    const r = this.calculateRoot(e);
+    this.rootNode = r.root, this.leafNodes = r.leaves;
+  }
+  getRoot() {
+    return this.rootNode.hash;
+  }
+  size() {
+    return this.leaves.length;
+  }
+  getLeaves() {
+    return this.leaves;
+  }
+  getLeafHash(e) {
+    return this.leafNodes[e].hash;
+  }
+  getProof(e) {
+    if (e >= this.leaves.length)
+      throw Error("Index out of bounds");
+    return Qe(this.leafNodes[e]);
+  }
+  calculateRoot(e) {
+    const t = e.length;
+    if (t == 0)
+      return {
+        root: new Fe(void 0, void 0, dist.Buffer.alloc(32, 0)),
+        leaves: []
+      };
+    if (t == 1) {
+      const f = new Fe(void 0, void 0, e[0]);
+      return { root: f, leaves: [f] };
+    }
+    const r = $n(t), o = this.calculateRoot(e.slice(0, r)), i = this.calculateRoot(e.slice(r)), s2 = o.root, a = i.root, c = this.hashNode(s2.hash, a.hash), l = new Fe(s2, a, c);
+    return s2.parent = l, a.parent = l, { root: l, leaves: o.leaves.concat(i.leaves) };
+  }
+  hashNode(e, t) {
+    return this.h(dist.Buffer.concat([dist.Buffer.from([1]), e, t]));
+  }
+}
+function ne(n, e = crypto_1.sha256) {
+  return Xn(dist.Buffer.from([0]), n, e);
+}
+function Xn(n, e, t) {
+  return t(dist.Buffer.concat([n, e]));
+}
+class Fe {
+  constructor(e, t, r) {
+    this.leftChild = e, this.rightChild = t, this.hash = r;
+  }
+  isLeaf() {
+    return this.leftChild == null;
+  }
+}
+function Qe(n) {
+  if (!n.parent)
+    return [];
+  if (n.parent.leftChild == n) {
+    if (!n.parent.rightChild)
+      throw new Error("Expected right child to exist");
+    return [n.parent.rightChild.hash, ...Qe(n.parent)];
+  } else {
+    if (!n.parent.leftChild)
+      throw new Error("Expected left child to exist");
+    return [n.parent.leftChild.hash, ...Qe(n.parent)];
+  }
+}
+function $n(n) {
+  if (n < 2)
+    throw Error("Expected n >= 2");
+  return zn(n) ? n / 2 : 1 << Math.floor(Math.log2(n));
+}
+function zn(n) {
+  return (n & n - 1) == 0;
+}
+class Et {
+  /**
+   * For now, we only support default descriptor templates.
+   */
+  constructor(e, t) {
+    this.descriptorTemplate = e, this.keys = [t];
+  }
+  getWalletId() {
+    return crypto_1.sha256(this.serialize());
+  }
+  serialize() {
+    const e = this.keys.map((o) => dist.Buffer.from(o, "ascii")), t = new te(e.map((o) => ne(o))), r = new A();
+    return r.writeUInt8(1), r.writeUInt8(0), r.writeVarSlice(dist.Buffer.from(this.descriptorTemplate, "ascii")), r.writeVarInt(this.keys.length), r.writeSlice(t.getRoot()), r.buffer();
+  }
+}
+function Bt(n, e, t) {
+  const r = ct(e);
+  return `[${n.toString("hex")}${r.substring(1)}]${t}/**`;
+}
+function Hn(n) {
+  var e, t;
+  const r = new A();
+  r.writeUInt32(n.getGlobalTxVersion());
+  const o = !!n.getInputWitnessUtxo(0);
+  o && r.writeSlice(dist.Buffer.from([0, 1]));
+  const i = n.getGlobalInputCount();
+  r.writeVarInt(i);
+  const s2 = new A();
+  for (let c = 0; c < i; c++)
+    r.writeSlice(n.getInputPreviousTxid(c)), r.writeUInt32(n.getInputOutputIndex(c)), r.writeVarSlice((e = n.getInputFinalScriptsig(c)) !== null && e !== void 0 ? e : dist.Buffer.from([])), r.writeUInt32(n.getInputSequence(c)), o && s2.writeSlice(n.getInputFinalScriptwitness(c));
+  const a = n.getGlobalOutputCount();
+  r.writeVarInt(a);
+  for (let c = 0; c < a; c++)
+    r.writeUInt64(n.getOutputAmount(c)), r.writeVarSlice(n.getOutputScript(c));
+  return r.writeSlice(s2.buffer()), r.writeUInt32((t = n.getGlobalFallbackLocktime()) !== null && t !== void 0 ? t : 0), r.buffer();
+}
+var N;
+(function(n) {
+  n[n.TX_VERSION = 2] = "TX_VERSION", n[n.FALLBACK_LOCKTIME = 3] = "FALLBACK_LOCKTIME", n[n.INPUT_COUNT = 4] = "INPUT_COUNT", n[n.OUTPUT_COUNT = 5] = "OUTPUT_COUNT", n[n.TX_MODIFIABLE = 6] = "TX_MODIFIABLE", n[n.VERSION = 251] = "VERSION";
+})(N || (N = {}));
+var S;
+(function(n) {
+  n[n.NON_WITNESS_UTXO = 0] = "NON_WITNESS_UTXO", n[n.WITNESS_UTXO = 1] = "WITNESS_UTXO", n[n.PARTIAL_SIG = 2] = "PARTIAL_SIG", n[n.SIGHASH_TYPE = 3] = "SIGHASH_TYPE", n[n.REDEEM_SCRIPT = 4] = "REDEEM_SCRIPT", n[n.BIP32_DERIVATION = 6] = "BIP32_DERIVATION", n[n.FINAL_SCRIPTSIG = 7] = "FINAL_SCRIPTSIG", n[n.FINAL_SCRIPTWITNESS = 8] = "FINAL_SCRIPTWITNESS", n[n.PREVIOUS_TXID = 14] = "PREVIOUS_TXID", n[n.OUTPUT_INDEX = 15] = "OUTPUT_INDEX", n[n.SEQUENCE = 16] = "SEQUENCE", n[n.TAP_KEY_SIG = 19] = "TAP_KEY_SIG", n[n.TAP_BIP32_DERIVATION = 22] = "TAP_BIP32_DERIVATION";
+})(S || (S = {}));
+var L;
+(function(n) {
+  n[n.REDEEM_SCRIPT = 0] = "REDEEM_SCRIPT", n[n.BIP_32_DERIVATION = 2] = "BIP_32_DERIVATION", n[n.AMOUNT = 3] = "AMOUNT", n[n.SCRIPT = 4] = "SCRIPT", n[n.TAP_BIP32_DERIVATION = 7] = "TAP_BIP32_DERIVATION";
+})(L || (L = {}));
+const Yn = dist.Buffer.from([112, 115, 98, 116, 255]);
+class jn extends Error {
+}
+class $t {
+  constructor() {
+    this.globalMap = /* @__PURE__ */ new Map(), this.inputMaps = [], this.outputMaps = [];
+  }
+  setGlobalTxVersion(e) {
+    this.setGlobal(N.TX_VERSION, ue(e));
+  }
+  getGlobalTxVersion() {
+    return this.getGlobal(N.TX_VERSION).readUInt32LE(0);
+  }
+  setGlobalFallbackLocktime(e) {
+    this.setGlobal(N.FALLBACK_LOCKTIME, ue(e));
+  }
+  getGlobalFallbackLocktime() {
+    var e;
+    return (e = this.getGlobalOptional(N.FALLBACK_LOCKTIME)) === null || e === void 0 ? void 0 : e.readUInt32LE(0);
+  }
+  setGlobalInputCount(e) {
+    this.setGlobal(N.INPUT_COUNT, Tt(e));
+  }
+  getGlobalInputCount() {
+    return yt(this.getGlobal(N.INPUT_COUNT));
+  }
+  setGlobalOutputCount(e) {
+    this.setGlobal(N.OUTPUT_COUNT, Tt(e));
+  }
+  getGlobalOutputCount() {
+    return yt(this.getGlobal(N.OUTPUT_COUNT));
+  }
+  setGlobalTxModifiable(e) {
+    this.setGlobal(N.TX_MODIFIABLE, e);
+  }
+  getGlobalTxModifiable() {
+    return this.getGlobalOptional(N.TX_MODIFIABLE);
+  }
+  setGlobalPsbtVersion(e) {
+    this.setGlobal(N.VERSION, ue(e));
+  }
+  getGlobalPsbtVersion() {
+    return this.getGlobal(N.VERSION).readUInt32LE(0);
+  }
+  setInputNonWitnessUtxo(e, t) {
+    this.setInput(e, S.NON_WITNESS_UTXO, P(), t);
+  }
+  getInputNonWitnessUtxo(e) {
+    return this.getInputOptional(e, S.NON_WITNESS_UTXO, P());
+  }
+  setInputWitnessUtxo(e, t, r) {
+    const o = new A();
+    o.writeSlice(t), o.writeVarSlice(r), this.setInput(e, S.WITNESS_UTXO, P(), o.buffer());
+  }
+  getInputWitnessUtxo(e) {
+    const t = this.getInputOptional(e, S.WITNESS_UTXO, P());
+    if (!t)
+      return;
+    const r = new ee(t);
+    return { amount: r.readSlice(8), scriptPubKey: r.readVarSlice() };
+  }
+  setInputPartialSig(e, t, r) {
+    this.setInput(e, S.PARTIAL_SIG, t, r);
+  }
+  getInputPartialSig(e, t) {
+    return this.getInputOptional(e, S.PARTIAL_SIG, t);
+  }
+  setInputSighashType(e, t) {
+    this.setInput(e, S.SIGHASH_TYPE, P(), ue(t));
+  }
+  getInputSighashType(e) {
+    const t = this.getInputOptional(e, S.SIGHASH_TYPE, P());
+    if (t)
+      return t.readUInt32LE(0);
+  }
+  setInputRedeemScript(e, t) {
+    this.setInput(e, S.REDEEM_SCRIPT, P(), t);
+  }
+  getInputRedeemScript(e) {
+    return this.getInputOptional(e, S.REDEEM_SCRIPT, P());
+  }
+  setInputBip32Derivation(e, t, r, o) {
+    if (t.length != 33)
+      throw new Error("Invalid pubkey length: " + t.length);
+    this.setInput(e, S.BIP32_DERIVATION, t, this.encodeBip32Derivation(r, o));
+  }
+  getInputBip32Derivation(e, t) {
+    const r = this.getInputOptional(e, S.BIP32_DERIVATION, t);
+    if (r)
+      return this.decodeBip32Derivation(r);
+  }
+  setInputFinalScriptsig(e, t) {
+    this.setInput(e, S.FINAL_SCRIPTSIG, P(), t);
+  }
+  getInputFinalScriptsig(e) {
+    return this.getInputOptional(e, S.FINAL_SCRIPTSIG, P());
+  }
+  setInputFinalScriptwitness(e, t) {
+    this.setInput(e, S.FINAL_SCRIPTWITNESS, P(), t);
+  }
+  getInputFinalScriptwitness(e) {
+    return this.getInput(e, S.FINAL_SCRIPTWITNESS, P());
+  }
+  setInputPreviousTxId(e, t) {
+    this.setInput(e, S.PREVIOUS_TXID, P(), t);
+  }
+  getInputPreviousTxid(e) {
+    return this.getInput(e, S.PREVIOUS_TXID, P());
+  }
+  setInputOutputIndex(e, t) {
+    this.setInput(e, S.OUTPUT_INDEX, P(), ue(t));
+  }
+  getInputOutputIndex(e) {
+    return this.getInput(e, S.OUTPUT_INDEX, P()).readUInt32LE(0);
+  }
+  setInputSequence(e, t) {
+    this.setInput(e, S.SEQUENCE, P(), ue(t));
+  }
+  getInputSequence(e) {
+    var t, r;
+    return (r = (t = this.getInputOptional(e, S.SEQUENCE, P())) === null || t === void 0 ? void 0 : t.readUInt32LE(0)) !== null && r !== void 0 ? r : 4294967295;
+  }
+  setInputTapKeySig(e, t) {
+    this.setInput(e, S.TAP_KEY_SIG, P(), t);
+  }
+  getInputTapKeySig(e) {
+    return this.getInputOptional(e, S.TAP_KEY_SIG, P());
+  }
+  setInputTapBip32Derivation(e, t, r, o, i) {
+    if (t.length != 32)
+      throw new Error("Invalid pubkey length: " + t.length);
+    const s2 = this.encodeTapBip32Derivation(r, o, i);
+    this.setInput(e, S.TAP_BIP32_DERIVATION, t, s2);
+  }
+  getInputTapBip32Derivation(e, t) {
+    const r = this.getInput(e, S.TAP_BIP32_DERIVATION, t);
+    return this.decodeTapBip32Derivation(r);
+  }
+  getInputKeyDatas(e, t) {
+    return this.getKeyDatas(this.inputMaps[e], t);
+  }
+  setOutputRedeemScript(e, t) {
+    this.setOutput(e, L.REDEEM_SCRIPT, P(), t);
+  }
+  getOutputRedeemScript(e) {
+    return this.getOutput(e, L.REDEEM_SCRIPT, P());
+  }
+  setOutputBip32Derivation(e, t, r, o) {
+    this.setOutput(e, L.BIP_32_DERIVATION, t, this.encodeBip32Derivation(r, o));
+  }
+  getOutputBip32Derivation(e, t) {
+    const r = this.getOutput(e, L.BIP_32_DERIVATION, t);
+    return this.decodeBip32Derivation(r);
+  }
+  setOutputAmount(e, t) {
+    this.setOutput(e, L.AMOUNT, P(), Jn(t));
+  }
+  getOutputAmount(e) {
+    const t = this.getOutput(e, L.AMOUNT, P());
+    return Vt(t);
+  }
+  setOutputScript(e, t) {
+    this.setOutput(e, L.SCRIPT, P(), t);
+  }
+  getOutputScript(e) {
+    return this.getOutput(e, L.SCRIPT, P());
+  }
+  setOutputTapBip32Derivation(e, t, r, o, i) {
+    const s2 = this.encodeTapBip32Derivation(r, o, i);
+    this.setOutput(e, L.TAP_BIP32_DERIVATION, t, s2);
+  }
+  getOutputTapBip32Derivation(e, t) {
+    const r = this.getOutput(e, L.TAP_BIP32_DERIVATION, t);
+    return this.decodeTapBip32Derivation(r);
+  }
+  deleteInputEntries(e, t) {
+    this.inputMaps[e].forEach((o, i, s2) => {
+      this.isKeyType(i, t) && s2.delete(i);
+    });
+  }
+  copy(e) {
+    this.copyMap(this.globalMap, e.globalMap), this.copyMaps(this.inputMaps, e.inputMaps), this.copyMaps(this.outputMaps, e.outputMaps);
+  }
+  copyMaps(e, t) {
+    e.forEach((r, o) => {
+      const i = /* @__PURE__ */ new Map();
+      this.copyMap(r, i), t[o] = i;
+    });
+  }
+  copyMap(e, t) {
+    e.forEach((r, o) => t.set(o, dist.Buffer.from(r)));
+  }
+  serialize() {
+    const e = new A();
+    return e.writeSlice(dist.Buffer.from([112, 115, 98, 116, 255])), qe(e, this.globalMap), this.inputMaps.forEach((t) => {
+      qe(e, t);
+    }), this.outputMaps.forEach((t) => {
+      qe(e, t);
+    }), e.buffer();
+  }
+  deserialize(e) {
+    const t = new ee(e);
+    if (!t.readSlice(5).equals(Yn))
+      throw new Error("Invalid magic bytes");
+    for (; this.readKeyPair(this.globalMap, t); )
+      ;
+    for (let r = 0; r < this.getGlobalInputCount(); r++)
+      for (this.inputMaps[r] = /* @__PURE__ */ new Map(); this.readKeyPair(this.inputMaps[r], t); )
+        ;
+    for (let r = 0; r < this.getGlobalOutputCount(); r++)
+      for (this.outputMaps[r] = /* @__PURE__ */ new Map(); this.readKeyPair(this.outputMaps[r], t); )
+        ;
+  }
+  readKeyPair(e, t) {
+    const r = t.readVarInt();
+    if (r == 0)
+      return false;
+    const o = t.readUInt8(), i = t.readSlice(r - 1), s2 = t.readVarSlice();
+    return We(e, o, i, s2), true;
+  }
+  getKeyDatas(e, t) {
+    const r = [];
+    return e.forEach((o, i) => {
+      this.isKeyType(i, [t]) && r.push(dist.Buffer.from(i.substring(2), "hex"));
+    }), r;
+  }
+  isKeyType(e, t) {
+    const r = dist.Buffer.from(e.substring(0, 2), "hex").readUInt8(0);
+    return t.some((o) => o == r);
+  }
+  setGlobal(e, t) {
+    const r = new Le(e, dist.Buffer.from([]));
+    this.globalMap.set(r.toString(), t);
+  }
+  getGlobal(e) {
+    return ge(this.globalMap, e, P(), false);
+  }
+  getGlobalOptional(e) {
+    return ge(this.globalMap, e, P(), true);
+  }
+  setInput(e, t, r, o) {
+    We(this.getMap(e, this.inputMaps), t, r, o);
+  }
+  getInput(e, t, r) {
+    return ge(this.inputMaps[e], t, r, false);
+  }
+  getInputOptional(e, t, r) {
+    return ge(this.inputMaps[e], t, r, true);
+  }
+  setOutput(e, t, r, o) {
+    We(this.getMap(e, this.outputMaps), t, r, o);
+  }
+  getOutput(e, t, r) {
+    return ge(this.outputMaps[e], t, r, false);
+  }
+  getMap(e, t) {
+    return t[e] ? t[e] : t[e] = /* @__PURE__ */ new Map();
+  }
+  encodeBip32Derivation(e, t) {
+    const r = new A();
+    return this.writeBip32Derivation(r, e, t), r.buffer();
+  }
+  decodeBip32Derivation(e) {
+    const t = new ee(e);
+    return this.readBip32Derivation(t);
+  }
+  writeBip32Derivation(e, t, r) {
+    e.writeSlice(t), r.forEach((o) => {
+      e.writeUInt32(o);
+    });
+  }
+  readBip32Derivation(e) {
+    const t = e.readSlice(4), r = [];
+    for (; e.offset < e.buffer.length; )
+      r.push(e.readUInt32());
+    return { masterFingerprint: t, path: r };
+  }
+  encodeTapBip32Derivation(e, t, r) {
+    const o = new A();
+    return o.writeVarInt(e.length), e.forEach((i) => {
+      o.writeSlice(i);
+    }), this.writeBip32Derivation(o, t, r), o.buffer();
+  }
+  decodeTapBip32Derivation(e) {
+    const t = new ee(e), r = t.readVarInt(), o = [];
+    for (let s2 = 0; s2 < r; s2++)
+      o.push(t.readSlice(32));
+    const i = this.readBip32Derivation(t);
+    return Object.assign({ hashes: o }, i);
+  }
+}
+function ge(n, e, t, r) {
+  if (!n)
+    throw Error("No such map");
+  const o = new Le(e, t), i = n.get(o.toString());
+  if (!i) {
+    if (r)
+      return;
+    throw new jn(o.toString());
+  }
+  return dist.Buffer.from(i);
+}
+class Le {
+  constructor(e, t) {
+    this.keyType = e, this.keyData = t;
+  }
+  toString() {
+    const e = new A();
+    return this.toBuffer(e), e.buffer().toString("hex");
+  }
+  serialize(e) {
+    e.writeVarInt(1 + this.keyData.length), this.toBuffer(e);
+  }
+  toBuffer(e) {
+    e.writeUInt8(this.keyType), e.writeSlice(this.keyData);
+  }
+}
+class Zn {
+  constructor(e, t) {
+    this.key = e, this.value = t;
+  }
+  serialize(e) {
+    this.key.serialize(e), e.writeVarSlice(this.value);
+  }
+}
+function Qn(n) {
+  return new Le(n.readUInt8(0), n.slice(1));
+}
+function qe(n, e) {
+  for (const t of e.keys()) {
+    const r = e.get(t);
+    new Zn(Qn(dist.Buffer.from(t, "hex")), r).serialize(n);
+  }
+  n.writeUInt8(0);
+}
+function P() {
+  return dist.Buffer.from([]);
+}
+function We(n, e, t, r) {
+  const o = new Le(e, t);
+  n.set(o.toString(), r);
+}
+function ue(n) {
+  const e = dist.Buffer.alloc(4);
+  return e.writeUInt32LE(n, 0), e;
+}
+function Jn(n) {
+  return Gt(n);
+}
+function Tt(n) {
+  const e = new A();
+  return e.writeVarInt(n), e.buffer();
+}
+function yt(n) {
+  return new ee(n).readVarInt();
+}
+function er(n) {
+  const e = n.getGlobalInputCount();
+  for (let t = 0; t < e; t++) {
+    const r = n.getInputKeyDatas(t, S.PARTIAL_SIG), o = n.getInputTapKeySig(t);
+    if (r.length == 0 && !o)
+      throw Error(`No signature for input ${t} present`);
+    if (r.length > 0) {
+      if (r.length > 1)
+        throw Error(`Expected exactly one signature, got ${r.length}`);
+      if (o)
+        throw Error("Both taproot and non-taproot signatures present.");
+      const i = !!n.getInputWitnessUtxo(t), s2 = n.getInputRedeemScript(t), a = !!s2, c = n.getInputPartialSig(t, r[0]);
+      if (!c)
+        throw new Error("Expected partial signature for input " + t);
+      if (i) {
+        const l = new A();
+        if (l.writeVarInt(2), l.writeVarInt(c.length), l.writeSlice(c), l.writeVarInt(r[0].length), l.writeSlice(r[0]), n.setInputFinalScriptwitness(t, l.buffer()), a) {
+          if (!s2 || s2.length == 0)
+            throw new Error("Expected non-empty redeemscript. Can't finalize intput " + t);
+          const f = new A();
+          f.writeUInt8(s2.length), f.writeSlice(s2), n.setInputFinalScriptsig(t, f.buffer());
+        }
+      } else {
+        const l = new A();
+        St(l, c), St(l, r[0]), n.setInputFinalScriptsig(t, l.buffer());
+      }
+    } else {
+      const i = n.getInputTapKeySig(t);
+      if (!i)
+        throw Error("No taproot signature found");
+      if (i.length != 64 && i.length != 65)
+        throw Error("Unexpected length of schnorr signature.");
+      const s2 = new A();
+      s2.writeVarInt(1), s2.writeVarSlice(i), n.setInputFinalScriptwitness(t, s2.buffer());
+    }
+    tr(n, t);
+  }
+}
+function tr(n, e) {
+  const t = [
+    S.BIP32_DERIVATION,
+    S.PARTIAL_SIG,
+    S.TAP_BIP32_DERIVATION,
+    S.TAP_KEY_SIG
+  ], r = !!n.getInputWitnessUtxo(e), o = !!n.getInputNonWitnessUtxo(e);
+  r && o && t.push(S.NON_WITNESS_UTXO), n.deleteInputEntries(e, t);
+}
+function St(n, e) {
+  if (e.length <= 75)
+    n.writeUInt8(e.length);
+  else if (e.length <= 256)
+    n.writeUInt8(76), n.writeUInt8(e.length);
+  else if (e.length <= 256 * 256) {
+    n.writeUInt8(77);
+    const t = dist.Buffer.alloc(2);
+    t.writeUInt16LE(e.length, 0), n.writeSlice(t);
+  }
+  n.writeSlice(e);
+}
+function ce(n, e) {
+  if (n[e] < 253)
+    return [n[e], 1];
+  if (n[e] === 253)
+    return [(n[e + 2] << 8) + n[e + 1], 3];
+  if (n[e] === 254)
+    return [
+      (n[e + 4] << 24) + (n[e + 3] << 16) + (n[e + 2] << 8) + n[e + 1],
+      5
+    ];
+  throw new Error("getVarint called with unexpected parameters");
+}
+function M(n) {
+  if (n < 253) {
+    const t = dist.Buffer.alloc(1);
+    return t[0] = n, t;
+  }
+  if (n <= 65535) {
+    const t = dist.Buffer.alloc(3);
+    return t[0] = 253, t[1] = n & 255, t[2] = n >> 8 & 255, t;
+  }
+  const e = dist.Buffer.alloc(5);
+  return e[0] = 254, e[1] = n & 255, e[2] = n >> 8 & 255, e[3] = n >> 16 & 255, e[4] = n >> 24 & 255, e;
+}
+function zt({ outputs: n }) {
+  let e = dist.Buffer.alloc(0);
+  return typeof n < "u" && (e = dist.Buffer.concat([e, M(n.length)]), n.forEach((t) => {
+    e = dist.Buffer.concat([
+      e,
+      t.amount,
+      M(t.script.length),
+      t.script
+    ]);
+  })), e;
+}
+function ht(n, e, t, r = []) {
+  const o = r.includes("decred"), i = r.includes("zcash"), s2 = r.includes("bech32");
+  let a = dist.Buffer.alloc(0);
+  const c = typeof n.witness < "u" && !e;
+  n.inputs.forEach((f) => {
+    a = o || s2 ? dist.Buffer.concat([
+      a,
+      f.prevout,
+      dist.Buffer.from([0]),
+      f.sequence
+    ]) : dist.Buffer.concat([
+      a,
+      f.prevout,
+      M(f.script.length),
+      f.script,
+      f.sequence
+    ]);
+  });
+  let l = zt(n);
+  return typeof n.outputs < "u" && typeof n.locktime < "u" && (l = dist.Buffer.concat([
+    l,
+    c && n.witness || dist.Buffer.alloc(0),
+    n.locktime,
+    n.nExpiryHeight || dist.Buffer.alloc(0),
+    n.extraData || dist.Buffer.alloc(0)
+  ])), i ? dist.Buffer.concat([
+    n.version,
+    n.nVersionGroupId || dist.Buffer.alloc(0),
+    dist.Buffer.from([180, 208, 214, 194]),
+    n.locktime || dist.Buffer.from([0, 0, 0, 0]),
+    n.nExpiryHeight || dist.Buffer.from([0, 0, 0, 0]),
+    c ? dist.Buffer.from("0001", "hex") : dist.Buffer.alloc(0),
+    M(n.inputs.length),
+    a,
+    l
+  ]) : dist.Buffer.concat([
+    n.version,
+    t || dist.Buffer.alloc(0),
+    n.nVersionGroupId || dist.Buffer.alloc(0),
+    c ? dist.Buffer.from("0001", "hex") : dist.Buffer.alloc(0),
+    M(n.inputs.length),
+    a,
+    l
+  ]);
+}
+var $ = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+class nr {
+  constructor(e) {
+    this.client = e;
+  }
+  /**
+   * This is a new method that allow users to get an xpub at a standard path.
+   * Standard paths are described at
+   * https://github.com/LedgerHQ/app-bitcoin-new/blob/master/doc/bitcoin.md#description
+   *
+   * This boils down to paths (N=0 for Bitcoin, N=1 for Testnet):
+   * M/44'/N'/x'/**
+   * M/48'/N'/x'/y'/**
+   * M/49'/N'/x'/**
+   * M/84'/N'/x'/**
+   * M/86'/N'/x'/**
+   *
+   * The method was added because of added security in the hardware app v2+. The
+   * new hardware app will allow export of any xpub up to and including the
+   * deepest hardened key of standard derivation paths, whereas the old app
+   * would allow export of any key.
+   *
+   * This caused an issue for callers of this class, who only had
+   * getWalletPublicKey() to call which means they have to constuct xpub
+   * themselves:
+   *
+   * Suppose a user of this class wants to create an account xpub on a standard
+   * path, M/44'/0'/Z'. The user must get the parent key fingerprint (see BIP32)
+   * by requesting the parent key M/44'/0'. The new app won't allow that, because
+   * it only allows exporting deepest level hardened path. So the options are to
+   * allow requesting M/44'/0' from the app, or to add a new function
+   * "getWalletXpub".
+   *
+   * We opted for adding a new function, which can greatly simplify client code.
+   */
+  getWalletXpub({ path: e, xpubVersion: t }) {
+    return $(this, void 0, void 0, function* () {
+      const r = F(e), o = yield this.client.getExtendedPubkey(false, r), i = xt(o);
+      if (i.version != t)
+        throw new Error(`Expected xpub version ${t} doesn't match the xpub version from the device ${i.version}`);
+      return o;
+    });
+  }
+  /**
+   * This method returns a public key, a bitcoin address, and and a chaincode
+   * for a specific derivation path.
+   *
+   * Limitation: If the path is not a leaf node of a standard path, the address
+   * will be the empty string "", see this.getWalletAddress() for details.
+   */
+  getWalletPublicKey(e, t) {
+    var r, o;
+    return $(this, void 0, void 0, function* () {
+      if (!sr(e))
+        throw Error(`non-standard path: ${e}`);
+      const i = F(e), s2 = yield this.client.getExtendedPubkey(false, i), a = (r = t == null ? void 0 : t.verify) !== null && r !== void 0 ? r : false, c = yield this.getWalletAddress(i, rr((o = t == null ? void 0 : t.format) !== null && o !== void 0 ? o : "legacy"), a), l = xt(s2);
+      return {
+        publicKey: dist.Buffer.from(kt.pointCompress(l.pubkey, false)).toString("hex"),
+        bitcoinAddress: c,
+        chainCode: l.chaincode.toString("hex")
+      };
+    });
+  }
+  /**
+   * Get an address for the specified path.
+   *
+   * If display is true, we must get the address from the device, which would require
+   * us to determine WalletPolicy. This requires two *extra* queries to the device, one
+   * for the account xpub and one for master key fingerprint.
+   *
+   * If display is false we *could* generate the address ourselves, but chose to
+   * get it from the device to save development time. However, it shouldn't take
+   * too much time to implement local address generation.
+   *
+   * Moreover, if the path is not for a leaf, ie accountPath+/X/Y, there is no
+   * way to get the address from the device. In this case we have to create it
+   * ourselves, but we don't at this time, and instead return an empty ("") address.
+   */
+  getWalletAddress(e, t, r) {
+    return $(this, void 0, void 0, function* () {
+      const o = Nn(e);
+      if (o.length + 2 != e.length)
+        return "";
+      const i = yield this.client.getExtendedPubkey(false, o), s2 = yield this.client.getMasterFingerprint(), a = new Et(t, Bt(s2, o, i)), c = e.slice(-2, e.length);
+      return this.client.getWalletAddress(a, dist.Buffer.alloc(32, 0), c[0], c[1], r);
+    });
+  }
+  /**
+   * Build and sign a transaction. See Btc.createPaymentTransaction for
+   * details on how to use this method.
+   *
+   * This method will convert the legacy arguments, CreateTransactionArg, into
+   * a psbt which is finally signed and finalized, and the extracted fully signed
+   * transaction is returned.
+   */
+  createPaymentTransaction(e) {
+    return $(this, void 0, void 0, function* () {
+      const t = e.inputs.length;
+      if (t == 0)
+        throw Error("No inputs");
+      const r = new $t(), o = yield this.client.getMasterFingerprint(), i = ir(e, r, o);
+      e.lockTime != null && r.setGlobalFallbackLocktime(e.lockTime), r.setGlobalInputCount(t), r.setGlobalPsbtVersion(2), r.setGlobalTxVersion(2);
+      let s2 = 0;
+      const a = () => {
+        e.onDeviceStreaming && e.onDeviceStreaming({
+          total: 2 * t,
+          index: s2,
+          progress: ++s2 / (2 * t)
+        });
+      };
+      let c = "", l = [];
+      for (let E = 0; E < t; E++) {
+        a();
+        const _ = F(e.associatedKeysets[E]);
+        c == "" && (l = _.slice(0, -2), c = yield this.client.getExtendedPubkey(false, l)), yield this.setInput(r, E, e.inputs[E], _, i, o, e.sigHashType);
+      }
+      const f = dist.Buffer.from(e.outputScriptHex, "hex"), h = new ee(f), x = h.readVarInt();
+      r.setGlobalOutputCount(x);
+      const w2 = yield this.outputScriptAt(l, i, e.changePath);
+      let T = !w2;
+      for (let E = 0; E < x; E++) {
+        const _ = Number(h.readUInt64()), I = h.readVarSlice();
+        if (r.setOutputAmount(E, _), r.setOutputScript(E, I), w2 && I.equals(w2 == null ? void 0 : w2.cond.scriptPubKey)) {
+          T = true;
+          const U = F(e.changePath), q = w2.pubkey;
+          i.setOwnOutput(E, w2.cond, [q], [U]);
+        }
+      }
+      if (!T)
+        throw new Error("Change script not found among outputs! " + (w2 == null ? void 0 : w2.cond.scriptPubKey.toString("hex")));
+      const y = Bt(o, l, c), B = new Et(i.getDescriptorTemplate(), y);
+      e.onDeviceSignatureRequested && e.onDeviceSignatureRequested();
+      let m = false;
+      const p = () => {
+        m || (m = true, e.onDeviceSignatureGranted && e.onDeviceSignatureGranted()), a();
+      };
+      return yield this.signPsbt(r, B, p), er(r), Hn(r).toString("hex");
+    });
+  }
+  /**
+   * Signs an arbitrary hex-formatted message with the private key at
+   * the provided derivation path according to the Bitcoin Signature format
+   * and returns v, r, s.
+   */
+  signMessage({ path: e, messageHex: t }) {
+    return $(this, void 0, void 0, function* () {
+      const r = F(e), o = dist.Buffer.from(t, "hex"), i = yield this.client.signMessage(o, r), s2 = dist.Buffer.from(i, "base64"), a = s2.readUInt8() - 27 - 4, c = s2.slice(1, 33).toString("hex"), l = s2.slice(33, 65).toString("hex");
+      return {
+        v: a,
+        r: c,
+        s: l
+      };
+    });
+  }
+  /**
+   * Calculates an output script along with public key and possible redeemScript
+   * from a path and accountType. The accountPath must be a prefix of path.
+   *
+   * @returns an object with output script (property "script"), redeemScript (if
+   * wrapped p2wpkh), and pubkey at provided path. The values of these three
+   * properties depend on the accountType used.
+   */
+  outputScriptAt(e, t, r) {
+    return $(this, void 0, void 0, function* () {
+      if (!r)
+        return;
+      const o = F(r);
+      for (let c = 0; c < e.length; c++)
+        if (e[c] != o[c])
+          throw new Error(`Path ${r} not in account ${ct(e)}`);
+      const i = yield this.client.getExtendedPubkey(false, o), s2 = It(i);
+      return { cond: t.spendingCondition([s2]), pubkey: s2 };
+    });
+  }
+  /**
+   * Adds relevant data about an input to the psbt. This includes sequence,
+   * previous txid, output index, spent UTXO, redeem script for wrapped p2wpkh,
+   * public key and its derivation path.
+   */
+  setInput(e, t, r, o, i, s2, a) {
+    return $(this, void 0, void 0, function* () {
+      const c = r[0], l = r[1], f = r[2] ? dist.Buffer.from(r[2], "hex") : void 0, h = r[3];
+      h != null && e.setInputSequence(t, h), a != null && e.setInputSighashType(t, a);
+      const x = ht(c, true), w2 = crypto_1.hash256(x), T = yield this.client.getExtendedPubkey(false, o), y = It(T);
+      if (!c.outputs)
+        throw Error("Missing outputs array in transaction to sign");
+      const B = c.outputs[l], p = { cond: {
+        scriptPubKey: B.script,
+        redeemScript: f
+      }, amount: B.amount };
+      i.setInput(t, x, p, [y], [o]), e.setInputPreviousTxId(t, w2), e.setInputOutputIndex(t, l);
+    });
+  }
+  /**
+   * This implements the "Signer" role of the BIP370 transaction signing
+   * process.
+   *
+   * It ssks the hardware device to sign the a psbt using the specified wallet
+   * policy. This method assumes BIP32 derived keys are used for all inputs, see
+   * comment in-line. The signatures returned from the hardware device is added
+   * to the appropriate input fields of the PSBT.
+   */
+  signPsbt(e, t, r) {
+    return $(this, void 0, void 0, function* () {
+      (yield this.client.signPsbt(e, t, dist.Buffer.alloc(32, 0), r)).forEach((i, s2) => {
+        const a = e.getInputKeyDatas(s2, S.BIP32_DERIVATION);
+        let c;
+        if (a.length != 1) {
+          if (c = e.getInputKeyDatas(s2, S.TAP_BIP32_DERIVATION), c.length == 0)
+            throw Error(`Missing pubkey derivation for input ${s2}`);
+          e.setInputTapKeySig(s2, i);
+        } else
+          c = a[0], e.setInputPartialSig(s2, c, i);
+      });
+    });
+  }
+}
+function rr(n) {
+  if (n == "legacy")
+    return "pkh(@0)";
+  if (n == "p2sh")
+    return "sh(wpkh(@0))";
+  if (n == "bech32")
+    return "wpkh(@0)";
+  if (n == "bech32m")
+    return "tr(@0)";
+  throw new Error("Unsupported address format " + n);
+}
+function ir(n, e, t) {
+  return n.additionals.includes("bech32m") ? new Fn(e, t) : n.additionals.includes("bech32") ? new Wn(e, t) : n.segwit ? new qn(e, t) : new Vn(e, t);
+}
+function sr(n) {
+  const t = F(n), r = (s2) => s2 >= 2147483648, o = (s2) => s2 === void 0 || s2 < 2147483648, i = (s2) => s2 === void 0 || s2 === 0 || s2 === 1;
+  return !!(t.length >= 3 && t.length <= 5 && [44 + 2147483648, 49 + 2147483648, 84 + 2147483648, 86 + 2147483648].some((s2) => s2 == t[0]) && [0 + 2147483648, 1 + 2147483648].some((s2) => s2 == t[1]) && r(t[2]) && i(t[3]) && o(t[4]) || t.length >= 4 && t.length <= 6 && 48 + 2147483648 == t[0] && [0 + 2147483648, 1 + 2147483648].some((s2) => s2 == t[1]) && r(t[2]) && r(t[3]) && i(t[4]) && o(t[5]));
+}
+var or = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+const _t = {
+  legacy: 0,
+  p2sh: 1,
+  bech32: 2,
+  cashaddr: 3
+};
+function Je(n, e) {
+  return or(this, void 0, void 0, function* () {
+    const { path: t, verify: r, format: o } = Object.assign({ verify: false, format: "legacy" }, e);
+    if (!(o in _t))
+      throw new Error("btc.getWalletPublicKey invalid format=" + o);
+    const i = ut(t), s2 = r ? 1 : 0, a = _t[o], c = yield n.send(224, 64, s2, a, i), l = c[0], f = c[1 + l], h = c.slice(1, 1 + l).toString("hex"), x = c.slice(1 + l + 1, 1 + l + 1 + f).toString("ascii"), w2 = c.slice(1 + l + 1 + f, 1 + l + 1 + f + 32).toString("hex");
+    return {
+      publicKey: h,
+      bitcoinAddress: x,
+      chainCode: w2
+    };
+  });
+}
+var et = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+function fe(n, e, t) {
+  return et(this, void 0, void 0, function* () {
+    let r, o = false;
+    if (typeof t == "number") {
+      o = true;
+      const a = dist.Buffer.alloc(4);
+      a.writeUInt32BE(t, 0), r = dist.Buffer.concat([a, e], e.length + 4);
+    } else
+      r = e;
+    const i = yield n.send(224, 66, o ? 0 : 128, 0, r);
+    return i.slice(0, i.length - 2).toString("hex");
+  });
+}
+function pt(n, e, t, r = []) {
+  return et(this, void 0, void 0, function* () {
+    const { version: o, inputs: i, outputs: s2, locktime: a, nExpiryHeight: c, extraData: l } = t;
+    if (!s2 || !a)
+      throw new Error("getTrustedInput: locktime & outputs is expected");
+    const f = r.includes("decred"), h = r.includes("stealthcoin"), x = (m, p) => et(this, void 0, void 0, function* () {
+      const d2 = p || dist.Buffer.alloc(0), E = [];
+      let _ = 0;
+      for (; _ !== m.length; ) {
+        const b = m.length - _ > Y ? Y : m.length - _;
+        _ + b !== m.length ? E.push(m.slice(_, _ + b)) : E.push(dist.Buffer.concat([m.slice(_, _ + b), d2])), _ += b;
+      }
+      m.length === 0 && E.push(d2);
+      let I;
+      for (const b of E)
+        I = yield fe(n, b);
+      return I;
+    }), w$1 = (m) => fe(n, m);
+    yield fe(n, dist.Buffer.concat([
+      t.version,
+      t.timestamp || dist.Buffer.alloc(0),
+      t.nVersionGroupId || dist.Buffer.alloc(0),
+      M(i.length)
+    ]), e);
+    for (const m of i) {
+      const p = h && dist.Buffer.compare(o, dist.Buffer.from([2, 0, 0, 0])) === 0, d2 = f ? m.tree || dist.Buffer.from([0]) : dist.Buffer.alloc(0), E = dist.Buffer.concat([
+        m.prevout,
+        d2,
+        p ? dist.Buffer.from([0]) : M(m.script.length)
+      ]);
+      yield fe(n, E), yield f ? w$1(dist.Buffer.concat([m.script, m.sequence])) : p ? w$1(m.sequence) : x(m.script, m.sequence);
+    }
+    yield fe(n, M(s2.length));
+    for (const m of s2) {
+      const p = dist.Buffer.concat([
+        m.amount,
+        f ? dist.Buffer.from([0, 0]) : dist.Buffer.alloc(0),
+        M(m.script.length),
+        m.script
+      ]);
+      yield fe(n, p);
+    }
+    const T = [];
+    c && c.length > 0 && T.push(c), l && l.length > 0 && T.push(l);
+    let y;
+    if (T.length) {
+      const m = dist.Buffer.concat(T);
+      y = f ? m : dist.Buffer.concat([M(m.length), m]);
+    }
+    const B = yield x(dist.Buffer.concat([a, y || dist.Buffer.alloc(0)]));
+    return w(B, "missing result in processScriptBlocks"), B;
+  });
+}
+var ur = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+function Xe(n, e, t, r, o = false, i = false, s2 = []) {
+  const a = s2.includes("cashaddr") ? 3 : o ? s2.includes("sapling") ? 5 : i ? 4 : 2 : 0;
+  return n.send(224, 68, t ? 0 : 128, e ? a : 128, r);
+}
+function Oe(n, e, t, r, o = false, i = false, s2 = [], a = false) {
+  return ur(this, void 0, void 0, function* () {
+    let c = dist.Buffer.concat([
+      t.version,
+      t.timestamp || dist.Buffer.alloc(0),
+      t.nVersionGroupId || dist.Buffer.alloc(0),
+      M(t.inputs.length)
+    ]);
+    yield Xe(n, e, true, c, o, i, s2);
+    let l = 0;
+    const f = s2.includes("decred");
+    for (const h of t.inputs) {
+      let x;
+      const w2 = r[l].value;
+      o ? a && r[l].trustedInput ? x = dist.Buffer.from([1, w2.length]) : x = dist.Buffer.from([2]) : r[l].trustedInput ? x = dist.Buffer.from([1, r[l].value.length]) : x = dist.Buffer.from([0]), c = dist.Buffer.concat([
+        x,
+        w2,
+        f ? dist.Buffer.from([0]) : dist.Buffer.alloc(0),
+        M(h.script.length)
+      ]), yield Xe(n, e, false, c, o, i, s2);
+      const T = [];
+      let y = 0;
+      if (h.script.length === 0)
+        T.push(h.sequence);
+      else
+        for (; y !== h.script.length; ) {
+          const B = h.script.length - y > Y ? Y : h.script.length - y;
+          y + B !== h.script.length ? T.push(h.script.slice(y, y + B)) : T.push(dist.Buffer.concat([h.script.slice(y, y + B), h.sequence])), y += B;
+        }
+      for (const B of T)
+        yield Xe(n, e, false, B, o, i, s2);
+      l++;
+    }
+  });
+}
+function dt(n, e, t, r = []) {
+  if (!t)
+    throw new Error("getTrustedInputBIP143: missing tx");
+  if (r.includes("decred"))
+    throw new Error("Decred does not implement BIP143");
+  let i = Pe("sha256").update(Pe("sha256").update(ht(t, true)).digest()).digest();
+  const s2 = dist.Buffer.alloc(4);
+  s2.writeUInt32LE(e, 0);
+  const { outputs: a, locktime: c } = t;
+  if (!a || !c)
+    throw new Error("getTrustedInputBIP143: locktime & outputs is expected");
+  if (!a[e])
+    throw new Error("getTrustedInputBIP143: wrong index");
+  return i = dist.Buffer.concat([i, s2, a[e].amount]), i.toString("hex");
+}
+function cr(n) {
+  const e = n[64] & 1 ? 3 : 2, t = dist.Buffer.alloc(1);
+  return t[0] = e, dist.Buffer.concat([t, n.slice(1, 1 + 32)]);
+}
+function tt(n, e, t, r, o, i = []) {
+  const s2 = i.includes("decred"), a = ut(e), c = dist.Buffer.alloc(4);
+  c.writeUInt32BE(t, 0);
+  let l = s2 ? dist.Buffer.concat([
+    a,
+    c,
+    o || dist.Buffer.from([0, 0, 0, 0]),
+    dist.Buffer.from([r])
+  ]) : dist.Buffer.concat([a, dist.Buffer.from([0]), c, dist.Buffer.from([r])]);
+  return o && !s2 && (l = dist.Buffer.concat([l, o])), n.send(224, 72, 0, 0, l).then((f) => f.length > 0 ? (f[0] = 48, f.slice(0, f.length - 2)) : f);
+}
+var fr = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+function vt(n, e) {
+  const t = ut(e);
+  return n.send(224, 74, 255, 0, t);
+}
+function Re(n, e, t = []) {
+  return fr(this, void 0, void 0, function* () {
+    let r = 0;
+    const o = 128;
+    if (t.includes("decred"))
+      return n.send(224, 74, o, 0, e);
+    for (; r < e.length; ) {
+      const s2 = r + Y >= e.length ? e.length - r : Y, a = r + s2 === e.length ? 128 : 0, c = e.slice(r, r + s2);
+      yield n.send(224, 74, a, 0, c), r += s2;
+    }
+  });
+}
+var Ht = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+const Yt = (n) => Ht(void 0, void 0, void 0, function* () {
+  const e = yield n.send(176, 1, 0, 0);
+  let t = 0;
+  const r = e[t++];
+  w(r === 1, "getAppAndVersion: format not supported");
+  const o = e[t++], i = e.slice(t, t += o).toString("ascii"), s2 = e[t++], a = e.slice(t, t += s2).toString("ascii"), c = e[t++], l = e.slice(t, t += c);
+  return {
+    name: i,
+    version: a,
+    flags: l
+  };
+}), ar = (n) => Ht(void 0, void 0, void 0, function* () {
+  try {
+    yield n.send(224, 196, 0, 0);
+  } catch {
+    return false;
+  }
+  return true;
+});
+function lr({ version: n, name: e }) {
+  return e === "Decred" ? false : e === "Exchange" ? true : vn$1.gte(n, "1.4.0");
+}
+var hr = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+const pr = {
+  lockTime: Ft,
+  sigHashType: at,
+  segwit: false,
+  additionals: [],
+  onDeviceStreaming: (n) => {
+  },
+  onDeviceSignatureGranted: () => {
+  },
+  onDeviceSignatureRequested: () => {
+  }
+};
+function dr(n, e) {
+  return hr(this, void 0, void 0, function* () {
+    const t = Object.assign(Object.assign({}, pr), e), { inputs: r, associatedKeysets: o, changePath: i, outputScriptHex: s2, lockTime: a, sigHashType: c, segwit: l, initialTimestamp: f, additionals: h, expiryHeight: x, onDeviceStreaming: w2, onDeviceSignatureGranted: T, onDeviceSignatureRequested: y } = t;
+    let B = t.useTrustedInputForSegwit;
+    if (B === void 0)
+      try {
+        const g = yield Yt(n);
+        B = lr(g);
+      } catch (g) {
+        if (g.statusCode === 27904)
+          B = false;
+        else
+          throw g;
+      }
+    const m = (g, v) => {
+      const { length: R } = r;
+      if (R < 3)
+        return;
+      const D = R * g + v, Q = 2 * R, Ge = D / Q;
+      w2({
+        progress: Ge,
+        total: Q,
+        index: D
+      });
+    }, p = h.includes("decred"), d$1 = h.includes("zcash"), E = h.includes("stealthcoin"), _ = Date.now(), I = h.includes("sapling"), b = l && h.includes("bech32"), U = l || !!h && (h.includes("abc") || h.includes("gold") || h.includes("bip143")) || !!x && !p, q = dist.Buffer.alloc(4);
+    q.writeUInt32LE(a, 0);
+    const C = dist.Buffer.alloc(0), j = dist.Buffer.alloc(0), V = dist.Buffer.alloc(4);
+    x && !p ? V.writeUInt32LE(d$1 ? 2147483653 : I ? 2147483652 : 2147483651, 0) : E ? V.writeUInt32LE(2, 0) : V.writeUInt32LE(1, 0);
+    const W = [], pe = [], de = [], Z = [];
+    let Te = true;
+    const O = {
+      inputs: [],
+      version: V,
+      timestamp: dist.Buffer.alloc(0)
+    }, jt = U && !B ? dt : pt, Ke = dist.Buffer.from(s2, "hex");
+    m(0, 0);
+    for (const g of r) {
+      {
+        const D = yield jt(n, g[1], g[0], h);
+        d("hw", "got trustedInput=" + D);
+        const Q = dist.Buffer.alloc(4);
+        Q.writeUInt32LE(g.length >= 4 && typeof g[3] == "number" ? g[3] : be, 0), W.push({
+          trustedInput: true,
+          value: dist.Buffer.from(D, "hex"),
+          sequence: Q
+        });
+      }
+      const { outputs: v } = g[0], R = g[1];
+      v && R <= v.length - 1 && pe.push(v[R]), x && !p ? (O.nVersionGroupId = dist.Buffer.from(
+        // nVersionGroupId is 0x26A7270A for zcash from https://z.cash/upgrade/nu5/
+        d$1 ? [10, 39, 167, 38] : I ? [133, 32, 47, 137] : [112, 130, 196, 3]
+      ), O.nExpiryHeight = x, O.extraData = dist.Buffer.from(I ? [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] : [0])) : p && (O.nExpiryHeight = x);
+    }
+    O.inputs = r.map((g, v) => {
+      const R = dist.Buffer.alloc(4);
+      return R.writeUInt32LE(g.length >= 4 && typeof g[3] == "number" ? g[3] : be, 0), {
+        script: d$1 ? pe[v].script : C,
+        prevout: j,
+        sequence: R
+      };
+    });
+    {
+      const g = [];
+      for (let v = 0; v < r.length; v++) {
+        const R = yield Je(n, {
+          path: o[v]
+        });
+        m(0, v + 1), g.push(R);
+      }
+      for (let v = 0; v < g.length; v++)
+        Z.push(cr(dist.Buffer.from(g[v].publicKey, "hex")));
+    }
+    f !== void 0 && (O.timestamp = dist.Buffer.alloc(4), O.timestamp.writeUInt32LE(Math.floor(f + (Date.now() - _) / 1e3), 0)), y(), U && (yield Oe(n, true, O, W, true, !!x, h, B), i && (yield vt(n, i)), yield Re(n, Ke)), x && !p && (yield tt(n, "", a, at, x));
+    for (let g = 0; g < r.length; g++) {
+      const v = r[g], R = r[g].length >= 3 && typeof v[2] == "string" ? dist.Buffer.from(v[2], "hex") : l ? dist.Buffer.concat([
+        dist.Buffer.from([qt, lt, ke]),
+        he(Z[g]),
+        dist.Buffer.from([Wt, Xt])
+      ]) : pe[g].script, D = Object.assign({}, O), Q = U ? [W[g]] : W;
+      U ? D.inputs = [Object.assign(Object.assign({}, D.inputs[g]), { script: R })] : D.inputs[g].script = R, yield Oe(n, !U && Te, D, Q, U, !!x && !p, h, B), U || (i && (yield vt(n, i)), yield Re(n, Ke, h)), Te && (T(), m(1, 0));
+      const Ge = yield tt(n, o[g], a, c, x, h);
+      m(1, g + 1), de.push(Ge), O.inputs[g].script = C, Te && (Te = false);
+    }
+    for (let g = 0; g < r.length; g++) {
+      if (l)
+        O.witness = dist.Buffer.alloc(0), b || (O.inputs[g].script = dist.Buffer.concat([
+          dist.Buffer.from("160014", "hex"),
+          he(Z[g])
+        ]));
+      else {
+        const R = dist.Buffer.alloc(1), D = dist.Buffer.alloc(1);
+        R[0] = de[g].length, D[0] = Z[g].length, O.inputs[g].script = dist.Buffer.concat([
+          R,
+          de[g],
+          D,
+          Z[g]
+        ]);
+      }
+      const v = U && !B ? 0 : 4;
+      O.inputs[g].prevout = W[g].value.slice(v, v + 36);
+    }
+    O.locktime = q;
+    let K = dist.Buffer.concat([
+      ht(O, false, O.timestamp, h),
+      Ke
+    ]);
+    if (l && !p) {
+      let g = dist.Buffer.alloc(0);
+      for (let v = 0; v < r.length; v++) {
+        const R = dist.Buffer.concat([
+          dist.Buffer.from("02", "hex"),
+          dist.Buffer.from([de[v].length]),
+          de[v],
+          dist.Buffer.from([Z[v].length]),
+          Z[v]
+        ]);
+        g = dist.Buffer.concat([g, R]);
+      }
+      K = dist.Buffer.concat([K, g]);
+    }
+    if (d$1 || (K = dist.Buffer.concat([K, q]), x && (K = dist.Buffer.concat([
+      K,
+      O.nExpiryHeight || dist.Buffer.alloc(0),
+      O.extraData || dist.Buffer.alloc(0)
+    ]))), p) {
+      let g = dist.Buffer.from([O.inputs.length]);
+      r.forEach((v, R) => {
+        g = dist.Buffer.concat([
+          g,
+          dist.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]),
+          dist.Buffer.from([0, 0, 0, 0]),
+          dist.Buffer.from([255, 255, 255, 255]),
+          dist.Buffer.from([O.inputs[R].script.length]),
+          O.inputs[R].script
+        ]);
+      }), K = dist.Buffer.concat([K, g]);
+    }
+    return d$1 && (K = dist.Buffer.concat([K, dist.Buffer.from([0, 0, 0])])), K.toString("hex");
+  });
+}
+var gr = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+function wr(n, { path: e, messageHex: t }) {
+  return gr(this, void 0, void 0, function* () {
+    const r = s.fromString(e).toPathArray(), o = dist.Buffer.from(t, "hex");
+    let i = 0;
+    for (; i !== o.length; ) {
+      const f = i === 0 ? Y - 1 - r.length * 4 - 4 : Y, h = i + f > o.length ? o.length - i : f, x = dist.Buffer.alloc(i === 0 ? 1 + r.length * 4 + 2 + h : h);
+      i === 0 ? (x[0] = r.length, r.forEach((w2, T) => {
+        x.writeUInt32BE(w2, 1 + 4 * T);
+      }), x.writeUInt16BE(o.length, 1 + 4 * r.length), o.copy(x, 1 + 4 * r.length + 2, i, i + h)) : o.copy(x, 0, i, i + h), yield n.send(224, 78, 0, i === 0 ? 1 : 128, x), i += h;
+    }
+    const s$1 = yield n.send(224, 78, 128, 0, dist.Buffer.from([0])), a = s$1[0] - 48;
+    let c = s$1.slice(4, 4 + s$1[3]);
+    c[0] === 0 && (c = c.slice(1)), c = c.toString("hex"), i = 4 + s$1[3] + 2;
+    let l = s$1.slice(i, i + s$1[i - 1]);
+    return l[0] === 0 && (l = l.slice(1)), l = l.toString("hex"), {
+      v: a,
+      r: c,
+      s: l
+    };
+  });
+}
+var $e = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+class ze {
+  constructor(e) {
+    this.transport = e, this.derivationsCache = {};
+  }
+  derivatePath(e) {
+    return $e(this, void 0, void 0, function* () {
+      if (this.derivationsCache[e])
+        return this.derivationsCache[e];
+      const t = yield Je(this.transport, {
+        path: e
+      });
+      return this.derivationsCache[e] = t, t;
+    });
+  }
+  getWalletXpub({ path: e, xpubVersion: t }) {
+    return $e(this, void 0, void 0, function* () {
+      const r = F(e), o = r.slice(0, -1), i = yield this.derivatePath(ct(o)), s2 = yield this.derivatePath(e), a = mr(Pt(dist.Buffer.from(i.publicKey, "hex")));
+      return Ir(t, r.length, a, r[r.length - 1], dist.Buffer.from(s2.chainCode, "hex"), Pt(dist.Buffer.from(s2.publicKey, "hex")));
+    });
+  }
+  /**
+   * @param path a BIP 32 path
+   * @param options an object with optional these fields:
+   *
+   * - verify (boolean) will ask user to confirm the address on the device
+   *
+   * - format ("legacy" | "p2sh" | "bech32" | "cashaddr") to use different bitcoin address formatter.
+   *
+   * NB The normal usage is to use:
+   *
+   * - legacy format with 44' paths
+   *
+   * - p2sh format with 49' paths
+   *
+   * - bech32 format with 173' paths
+   *
+   * - cashaddr in case of Bitcoin Cash
+   *
+   * @example
+   * btc.getWalletPublicKey("44'/0'/0'/0/0").then(o => o.bitcoinAddress)
+   * btc.getWalletPublicKey("49'/0'/0'/0/0", { format: "p2sh" }).then(o => o.bitcoinAddress)
+   */
+  getWalletPublicKey(e, t) {
+    if ((t == null ? void 0 : t.format) === "bech32m")
+      throw new Error("Unsupported address format bech32m");
+    return Je(this.transport, Object.assign(Object.assign({}, t), { path: e }));
+  }
+  /**
+   * To sign a transaction involving standard (P2PKH) inputs, call createTransaction with the following parameters
+   * @param inputs is an array of [ transaction, output_index, optional redeem script, optional sequence ] where
+   *
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the optional redeem script to use when consuming a Segregated Witness input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param changePath is an optional BIP 32 path pointing to the path to the public key used to compute the change address
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @param segwit is an optional boolean indicating wether to use segwit or not
+   * @param initialTimestamp is an optional timestamp of the function call to use for coins that necessitate timestamps only, (not the one that the tx will include)
+   * @param additionals list of additionnal options
+   *
+   * - "bech32" for spending native segwit outputs
+   * - "abc" for bch
+   * - "gold" for btg
+   * - "bipxxx" for using BIPxxx
+   * - "sapling" to indicate a zec transaction is supporting sapling (to be set over block 419200)
+   * @param expiryHeight is an optional Buffer for zec overwinter / sapling Txs
+   * @param useTrustedInputForSegwit trust inputs for segwit transactions
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.createTransaction({
+   inputs: [ [tx1, 1] ],
+   associatedKeysets: ["0'/0/0"],
+   outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(res => ...);
+   */
+  createPaymentTransaction(e) {
+    if (arguments.length > 1)
+      throw new Error("@ledgerhq/hw-app-btc: createPaymentTransaction multi argument signature is deprecated. please switch to named parameters.");
+    return dr(this.transport, e);
+  }
+  signMessage({ path: e, messageHex: t }) {
+    return $e(this, void 0, void 0, function* () {
+      return wr(this.transport, {
+        path: e,
+        messageHex: t
+      });
+    });
+  }
+}
+function mr(n) {
+  return Br(n).slice(0, 4);
+}
+function bt(n) {
+  const e = dist.Buffer.allocUnsafe(4);
+  return e.writeUInt32BE(n, 0), e;
+}
+const Pt = (n) => dist.Buffer.concat([dist.Buffer.from([2 + (n[64] & 1)]), n.slice(1, 33)]);
+function Ir(n, e, t, r, o, i) {
+  const s2 = bt(r);
+  s2[0] |= 128;
+  const a = dist.Buffer.concat([
+    bt(n),
+    dist.Buffer.from([e]),
+    t,
+    s2,
+    o,
+    i
+  ]), c = xr(a).slice(0, 4);
+  return Pn.encode(dist.Buffer.concat([a, c]));
+}
+function nt(n) {
+  return Pe("sha256").update(n).digest();
+}
+function xr(n) {
+  return nt(nt(n));
+}
+function Er(n) {
+  return new RIPEMD160().update(n).digest();
+}
+function Br(n) {
+  return Er(nt(n));
+}
+class Tr {
+  /**
+   * @param keys Sorted list of (unhashed) keys
+   * @param values values, in corresponding order as the keys, and of equal length
+   */
+  constructor(e, t) {
+    if (e.length != t.length)
+      throw new Error("keys and values should have the same length");
+    for (let r = 0; r < e.length - 1; r++)
+      if (e[r].toString("hex") >= e[r + 1].toString("hex"))
+        throw new Error("keys must be in strictly increasing order");
+    this.keys = e, this.keysTree = new te(e.map((r) => ne(r))), this.values = t, this.valuesTree = new te(t.map((r) => ne(r)));
+  }
+  commitment() {
+    return dist.Buffer.concat([
+      M(this.keys.length),
+      this.keysTree.getRoot(),
+      this.valuesTree.getRoot()
+    ]);
+  }
+}
+class Ie extends $t {
+  constructor(e) {
+    super(), this.inputMerkleMaps = [], this.outputMerkleMaps = [], e.copy(this), this.globalMerkleMap = Ie.createMerkleMap(this.globalMap);
+    for (let t = 0; t < this.getGlobalInputCount(); t++)
+      this.inputMerkleMaps.push(Ie.createMerkleMap(this.inputMaps[t]));
+    this.inputMapCommitments = [...this.inputMerkleMaps.values()].map((t) => t.commitment());
+    for (let t = 0; t < this.getGlobalOutputCount(); t++)
+      this.outputMerkleMaps.push(Ie.createMerkleMap(this.outputMaps[t]));
+    this.outputMapCommitments = [...this.outputMerkleMaps.values()].map((t) => t.commitment());
+  }
+  // These public functions are for MerkelizedPsbt.
+  getGlobalSize() {
+    return this.globalMap.size;
+  }
+  getGlobalKeysValuesRoot() {
+    return this.globalMerkleMap.commitment();
+  }
+  static createMerkleMap(e) {
+    const t = [...e.keys()].sort(), r = t.map((s2) => {
+      const a = e.get(s2);
+      if (!a)
+        throw new Error("No value for key " + s2);
+      return a;
+    }), o = t.map((s2) => dist.Buffer.from(s2, "hex"));
+    return new Tr(o, r);
+  }
+}
+var oe;
+(function(n) {
+  n[n.YIELD = 16] = "YIELD", n[n.GET_PREIMAGE = 64] = "GET_PREIMAGE", n[n.GET_MERKLE_LEAF_PROOF = 65] = "GET_MERKLE_LEAF_PROOF", n[n.GET_MERKLE_LEAF_INDEX = 66] = "GET_MERKLE_LEAF_INDEX", n[n.GET_MORE_ELEMENTS = 160] = "GET_MORE_ELEMENTS";
+})(oe || (oe = {}));
+class Be {
+}
+class yr extends Be {
+  constructor(e, t) {
+    super(), this.progressCallback = t, this.code = oe.YIELD, this.results = e;
+  }
+  execute(e) {
+    return this.results.push(dist.Buffer.from(e.subarray(1))), this.progressCallback(), dist.Buffer.from("");
+  }
+}
+class Sr extends Be {
+  constructor(e, t) {
+    super(), this.code = oe.GET_PREIMAGE, this.known_preimages = e, this.queue = t;
+  }
+  execute(e) {
+    const t = dist.Buffer.from(e.subarray(1));
+    if (t.length != 1 + 32)
+      throw new Error("Invalid request, unexpected trailing data");
+    if (t[0] != 0)
+      throw new Error("Unsupported request, the first byte should be 0");
+    const r = dist.Buffer.alloc(32);
+    for (let s2 = 0; s2 < 32; s2++)
+      r[s2] = t[1 + s2];
+    const o = r.toString("hex"), i = this.known_preimages.get(o);
+    if (i != null) {
+      const s2 = M(i.length), a = 255 - s2.length - 1, c = Math.min(a, i.length);
+      if (c < i.length)
+        for (let l = c; l < i.length; l++)
+          this.queue.push(dist.Buffer.from([i[l]]));
+      return dist.Buffer.concat([
+        s2,
+        dist.Buffer.from([c]),
+        dist.Buffer.from(i.subarray(0, c))
+      ]);
+    }
+    throw Error(`Requested unknown preimage for: ${o}`);
+  }
+}
+class _r extends Be {
+  constructor(e, t) {
+    super(), this.code = oe.GET_MERKLE_LEAF_PROOF, this.known_trees = e, this.queue = t;
+  }
+  execute(e) {
+    const t = dist.Buffer.from(e.subarray(1));
+    if (t.length < 32 + 1 + 1)
+      throw new Error("Invalid request, expected at least 34 bytes");
+    const r = new ee(t), i = r.readSlice(32).toString("hex");
+    let s2, a;
+    try {
+      s2 = r.readVarInt(), a = r.readVarInt();
+    } catch {
+      throw new Error("Invalid request, couldn't parse tree_size or leaf_index");
+    }
+    const c = this.known_trees.get(i);
+    if (!c)
+      throw Error(`Requested Merkle leaf proof for unknown tree: ${i}`);
+    if (a >= s2 || c.size() != s2)
+      throw Error("Invalid index or tree size.");
+    if (this.queue.length != 0)
+      throw Error("This command should not execute when the queue is not empty.");
+    const l = c.getProof(a), f = Math.min(Math.floor((255 - 32 - 1 - 1) / 32), l.length), h = l.length - f;
+    return h > 0 && this.queue.push(...l.slice(-h)), dist.Buffer.concat([
+      c.getLeafHash(a),
+      dist.Buffer.from([l.length]),
+      dist.Buffer.from([f]),
+      ...l.slice(0, f)
+    ]);
+  }
+}
+class vr extends Be {
+  constructor(e) {
+    super(), this.code = oe.GET_MERKLE_LEAF_INDEX, this.known_trees = e;
+  }
+  execute(e) {
+    const t = dist.Buffer.from(e.subarray(1));
+    if (t.length != 32 + 32)
+      throw new Error("Invalid request, unexpected trailing data");
+    const r = dist.Buffer.alloc(32);
+    for (let f = 0; f < 32; f++)
+      r[f] = t.readUInt8(f);
+    const o = r.toString("hex"), i = dist.Buffer.alloc(32);
+    for (let f = 0; f < 32; f++)
+      i[f] = t.readUInt8(32 + f);
+    const s2 = i.toString("hex"), a = this.known_trees.get(o);
+    if (!a)
+      throw Error(`Requested Merkle leaf index for unknown root: ${o}`);
+    let c = 0, l = 0;
+    for (let f = 0; f < a.size(); f++)
+      if (a.getLeafHash(f).toString("hex") == s2) {
+        l = 1, c = f;
+        break;
+      }
+    return dist.Buffer.concat([dist.Buffer.from([l]), M(c)]);
+  }
+}
+class br extends Be {
+  constructor(e) {
+    super(), this.code = oe.GET_MORE_ELEMENTS, this.queue = e;
+  }
+  execute(e) {
+    if (e.length != 1)
+      throw new Error("Invalid request, unexpected trailing data");
+    if (this.queue.length === 0)
+      throw new Error("No elements to get");
+    const t = this.queue[0].length;
+    if (this.queue.some((s2) => s2.length != t))
+      throw new Error("The queue contains elements with different byte length, which is not expected");
+    const r = Math.floor(253 / t), o = Math.min(r, this.queue.length), i = this.queue.splice(0, o);
+    return dist.Buffer.concat([
+      dist.Buffer.from([o]),
+      dist.Buffer.from([t]),
+      ...i
+    ]);
+  }
+}
+class He {
+  constructor(e) {
+    this.roots = /* @__PURE__ */ new Map(), this.preimages = /* @__PURE__ */ new Map(), this.yielded = [], this.queue = [], this.commands = /* @__PURE__ */ new Map();
+    const t = [
+      new yr(this.yielded, e),
+      new Sr(this.preimages, this.queue),
+      new vr(this.roots),
+      new _r(this.roots, this.queue),
+      new br(this.queue)
+    ];
+    for (const r of t) {
+      if (this.commands.has(r.code))
+        throw new Error(`Multiple commands with code ${r.code}`);
+      this.commands.set(r.code, r);
+    }
+  }
+  getYielded() {
+    return this.yielded;
+  }
+  addKnownPreimage(e) {
+    this.preimages.set(crypto_1.sha256(e).toString("hex"), e);
+  }
+  addKnownList(e) {
+    for (const r of e) {
+      const o = dist.Buffer.concat([dist.Buffer.from([0]), r]);
+      this.addKnownPreimage(o);
+    }
+    const t = new te(e.map((r) => ne(r)));
+    this.roots.set(t.getRoot().toString("hex"), t);
+  }
+  addKnownMapping(e) {
+    this.addKnownList(e.keys), this.addKnownList(e.values);
+  }
+  execute(e) {
+    if (e.length == 0)
+      throw new Error("Unexpected empty command");
+    const t = e[0], r = this.commands.get(t);
+    if (!r)
+      throw new Error(`Unexpected command code ${t}`);
+    return r.execute(e);
+  }
+}
+var ae = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+const Pr = 225, Or = 248;
+var J;
+(function(n) {
+  n[n.GET_PUBKEY = 0] = "GET_PUBKEY", n[n.REGISTER_WALLET = 2] = "REGISTER_WALLET", n[n.GET_WALLET_ADDRESS = 3] = "GET_WALLET_ADDRESS", n[n.SIGN_PSBT = 4] = "SIGN_PSBT", n[n.GET_MASTER_FINGERPRINT = 5] = "GET_MASTER_FINGERPRINT", n[n.SIGN_MESSAGE = 16] = "SIGN_MESSAGE";
+})(J || (J = {}));
+var rt;
+(function(n) {
+  n[n.CONTINUE_INTERRUPTED = 1] = "CONTINUE_INTERRUPTED";
+})(rt || (rt = {}));
+class Rr {
+  constructor(e) {
+    this.transport = e;
+  }
+  makeRequest(e, t, r) {
+    return ae(this, void 0, void 0, function* () {
+      let o = yield this.transport.send(Pr, e, 0, 0, t, [36864, 57344]);
+      for (; o.readUInt16BE(o.length - 2) === 57344; ) {
+        if (!r)
+          throw new Error("Unexpected SW_INTERRUPTED_EXECUTION");
+        const i = o.slice(0, -2), s2 = r.execute(i);
+        o = yield this.transport.send(Or, rt.CONTINUE_INTERRUPTED, 0, 0, s2, [36864, 57344]);
+      }
+      return o.slice(0, -2);
+    });
+  }
+  getExtendedPubkey(e, t) {
+    return ae(this, void 0, void 0, function* () {
+      if (t.length > 6)
+        throw new Error("Path too long. At most 6 levels allowed.");
+      return (yield this.makeRequest(J.GET_PUBKEY, dist.Buffer.concat([dist.Buffer.from(e ? [1] : [0]), Ye(t)]))).toString("ascii");
+    });
+  }
+  getWalletAddress(e, t, r, o, i) {
+    return ae(this, void 0, void 0, function* () {
+      if (r !== 0 && r !== 1)
+        throw new Error("Change can only be 0 or 1");
+      if (o < 0 || !Number.isInteger(o))
+        throw new Error("Invalid address index");
+      if (t != null && t.length != 32)
+        throw new Error("Invalid HMAC length");
+      const s2 = new He(() => {
+      });
+      s2.addKnownList(e.keys.map((l) => dist.Buffer.from(l, "ascii"))), s2.addKnownPreimage(e.serialize());
+      const a = dist.Buffer.alloc(4);
+      return a.writeUInt32BE(o, 0), (yield this.makeRequest(J.GET_WALLET_ADDRESS, dist.Buffer.concat([
+        dist.Buffer.from(i ? [1] : [0]),
+        e.getWalletId(),
+        t || dist.Buffer.alloc(32, 0),
+        dist.Buffer.from([r]),
+        a
+      ]), s2)).toString("ascii");
+    });
+  }
+  signPsbt(e, t, r, o) {
+    return ae(this, void 0, void 0, function* () {
+      const i = new Ie(e);
+      if (r != null && r.length != 32)
+        throw new Error("Invalid HMAC length");
+      const s2 = new He(o);
+      s2.addKnownList(t.keys.map((h) => dist.Buffer.from(h, "ascii"))), s2.addKnownPreimage(t.serialize()), s2.addKnownMapping(i.globalMerkleMap);
+      for (const h of i.inputMerkleMaps)
+        s2.addKnownMapping(h);
+      for (const h of i.outputMerkleMaps)
+        s2.addKnownMapping(h);
+      s2.addKnownList(i.inputMapCommitments);
+      const a = new te(i.inputMapCommitments.map((h) => ne(h))).getRoot();
+      s2.addKnownList(i.outputMapCommitments);
+      const c = new te(i.outputMapCommitments.map((h) => ne(h))).getRoot();
+      yield this.makeRequest(J.SIGN_PSBT, dist.Buffer.concat([
+        i.getGlobalKeysValuesRoot(),
+        M(i.getGlobalInputCount()),
+        a,
+        M(i.getGlobalOutputCount()),
+        c,
+        t.getWalletId(),
+        r || dist.Buffer.alloc(32, 0)
+      ]), s2);
+      const l = s2.getYielded(), f = /* @__PURE__ */ new Map();
+      for (const h of l)
+        f.set(h[0], h.slice(1));
+      return f;
+    });
+  }
+  getMasterFingerprint() {
+    return ae(this, void 0, void 0, function* () {
+      return this.makeRequest(J.GET_MASTER_FINGERPRINT, dist.Buffer.from([]));
+    });
+  }
+  signMessage(e, t) {
+    return ae(this, void 0, void 0, function* () {
+      if (t.length > 6)
+        throw new Error("Path too long. At most 6 levels allowed.");
+      const r = new He(() => {
+      }), o = Math.ceil(e.length / 64), i = [];
+      for (let c = 0; c < o; c++)
+        i.push(e.subarray(64 * c, 64 * c + 64));
+      r.addKnownList(i);
+      const s2 = new te(i.map((c) => ne(c))).getRoot();
+      return (yield this.makeRequest(J.SIGN_MESSAGE, dist.Buffer.concat([Ye(t), M(e.length), s2]), r)).toString("base64");
+    });
+  }
+}
+function Ur(n) {
+  let e = "TX";
+  return e += " version " + n.version.toString("hex"), n.locktime && (e += " locktime " + n.locktime.toString("hex")), n.witness && (e += " witness " + n.witness.toString("hex")), n.timestamp && (e += " timestamp " + n.timestamp.toString("hex")), n.nVersionGroupId && (e += " nVersionGroupId " + n.nVersionGroupId.toString("hex")), n.nExpiryHeight && (e += " nExpiryHeight " + n.nExpiryHeight.toString("hex")), n.extraData && (e += " extraData " + n.extraData.toString("hex")), n.inputs.forEach(({ prevout: t, script: r, sequence: o }, i) => {
+    e += `
+input ${i}:`, e += ` prevout ${t.toString("hex")}`, e += ` script ${r.toString("hex")}`, e += ` sequence ${o.toString("hex")}`;
+  }), (n.outputs || []).forEach(({ amount: t, script: r }, o) => {
+    e += `
+output ${o}:`, e += ` amount ${t.toString("hex")}`, e += ` script ${r.toString("hex")}`;
+  }), e;
+}
+function Mr(n, e = false, t = false, r = false, o = []) {
+  const i = [], s2 = [];
+  let a = false, c = 0, l = dist.Buffer.alloc(0), f = dist.Buffer.alloc(0), h = dist.Buffer.alloc(0), x = dist.Buffer.alloc(0), w2, T;
+  const y = o.includes("decred"), B = o.includes("zencash"), m = o.includes("zcash"), p = dist.Buffer.from(n, "hex"), d$1 = p.slice(c, c + 4), E = d$1.equals(dist.Buffer.from([3, 0, 0, 128])) || d$1.equals(dist.Buffer.from([4, 0, 0, 128])) || d$1.equals(dist.Buffer.from([5, 0, 0, 128])), _ = m && d$1.equals(dist.Buffer.from([5, 0, 0, 128]));
+  c += 4, !t && e && p[c] === 0 && p[c + 1] !== 0 && !B && (c += 2, a = true), t && (l = p.slice(c, 4 + c), c += 4), E && (h = p.slice(c, 4 + c), c += 4), _ && (T = p.slice(c + 4, c + 8), f = p.slice(c + 8, c + 12), c += 12);
+  let I = ce(p, c);
+  const b = I[0];
+  c += I[1];
+  for (let C = 0; C < b; C++) {
+    const j = p.slice(c, c + 36);
+    c += 36;
+    let V = dist.Buffer.alloc(0), W = dist.Buffer.alloc(0);
+    y ? (W = p.slice(c, c + 1), c += 1) : (I = ce(p, c), c += I[1], V = p.slice(c, c + I[0]), c += I[0]);
+    const pe = p.slice(c, c + 4);
+    c += 4, i.push({
+      prevout: j,
+      script: V,
+      sequence: pe,
+      tree: W
+    });
+  }
+  I = ce(p, c);
+  const U = I[0];
+  c += I[1];
+  for (let C = 0; C < U; C++) {
+    const j = p.slice(c, c + 8);
+    c += 8, y && (c += 2), I = ce(p, c), c += I[1];
+    const V = p.slice(c, c + I[0]);
+    c += I[0], s2.push({
+      amount: j,
+      script: V
+    });
+  }
+  if (a ? (w2 = p.slice(c, -4), T = p.slice(p.length - 4)) : _ || (T = p.slice(c, c + 4)), c += 4, (E || y) && !_ && (f = p.slice(c, c + 4), c += 4), r && (x = p.slice(c)), y) {
+    if (I = ce(p, c), c += I[1], I[0] !== b)
+      throw new Error("splitTransaction: incoherent number of witnesses");
+    for (let C = 0; C < b; C++) {
+      c += 8, c += 4, c += 4, I = ce(p, c), c += I[1];
+      const j = p.slice(c, c + I[0]);
+      c += I[0], i[C].script = j;
+    }
+  }
+  const q = {
+    version: d$1,
+    inputs: i,
+    outputs: s2,
+    locktime: T,
+    witness: w2,
+    timestamp: l,
+    nVersionGroupId: h,
+    nExpiryHeight: f,
+    extraData: x
+  };
+  return d("btc", `splitTransaction ${n}:
+${Ur(q)}`), q;
+}
+var Ar = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+const Nr = {
+  lockTime: Ft,
+  sigHashType: at,
+  segwit: false,
+  transactionVersion: Cn
+};
+function Dr(n, e) {
+  return Ar(this, void 0, void 0, function* () {
+    const { inputs: t, associatedKeysets: r, outputScriptHex: o, lockTime: i, sigHashType: s2, segwit: a, transactionVersion: c } = Object.assign(Object.assign({}, Nr), e), l = dist.Buffer.alloc(0), f = dist.Buffer.alloc(0), h = dist.Buffer.alloc(4);
+    h.writeUInt32LE(c, 0);
+    const x = [], w2 = [], T = [];
+    let y = true;
+    const B = {
+      inputs: [],
+      version: h
+    }, m = a ? dt : pt, p = dist.Buffer.from(o, "hex");
+    for (const d2 of t) {
+      {
+        const I = yield m(n, d2[1], d2[0]), b = dist.Buffer.alloc(4);
+        b.writeUInt32LE(d2.length >= 4 && typeof d2[3] == "number" ? d2[3] : be, 0), x.push({
+          trustedInput: false,
+          value: a ? dist.Buffer.from(I, "hex") : dist.Buffer.from(I, "hex").slice(4, 4 + 36),
+          sequence: b
+        });
+      }
+      const { outputs: E } = d2[0], _ = d2[1];
+      E && _ <= E.length - 1 && w2.push(E[_]);
+    }
+    for (let d2 = 0; d2 < t.length; d2++) {
+      const E = dist.Buffer.alloc(4);
+      E.writeUInt32LE(t[d2].length >= 4 && typeof t[d2][3] == "number" ? t[d2][3] : be, 0), B.inputs.push({
+        script: l,
+        prevout: f,
+        sequence: E
+      });
+    }
+    a && (yield Oe(n, true, B, x, true), yield Re(n, p));
+    for (let d2 = 0; d2 < t.length; d2++) {
+      const E = t[d2], _ = t[d2].length >= 3 && typeof E[2] == "string" ? dist.Buffer.from(E[2], "hex") : w2[d2].script, I = Object.assign({}, B), b = a ? [x[d2]] : x;
+      a ? I.inputs = [Object.assign(Object.assign({}, I.inputs[d2]), { script: _ })] : I.inputs[d2].script = _, yield Oe(n, !a && y, I, b, a), a || (yield Re(n, p));
+      const U = yield tt(n, r[d2], i, s2);
+      T.push(a ? U.toString("hex") : U.slice(0, U.length - 1).toString("hex")), B.inputs[d2].script = l, y && (y = false);
+    }
+    return T;
+  });
+}
+var kr = globalThis && globalThis.__awaiter || function(n, e, t, r) {
+  function o(i) {
+    return i instanceof t ? i : new t(function(s2) {
+      s2(i);
+    });
+  }
+  return new (t || (t = Promise))(function(i, s2) {
+    function a(f) {
+      try {
+        l(r.next(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function c(f) {
+      try {
+        l(r.throw(f));
+      } catch (h) {
+        s2(h);
+      }
+    }
+    function l(f) {
+      f.done ? i(f.value) : o(f.value).then(a, c);
+    }
+    l((r = r.apply(n, e || [])).next());
+  });
+};
+class ti {
+  constructor({ transport: e, scrambleKey: t = "BTC", currency: r = "bitcoin" }) {
+    this._transport = e, this._transport.decorateAppAPIMethods(this, [
+      "getWalletXpub",
+      "getWalletPublicKey",
+      "signP2SHTransaction",
+      "signMessage",
+      "createPaymentTransaction",
+      "getTrustedInput",
+      "getTrustedInputBIP143"
+    ], t), r === "bitcoin" || r === "bitcoin_testnet" ? this._impl = new nr(new Rr(this._transport)) : this._impl = new ze(this._transport);
+  }
+  /**
+   * Get an XPUB with a ledger device
+   * @param arg derivation parameter
+   * - path: a BIP 32 path of the account level. e.g. `84'/0'/0'`
+   * - xpubVersion: the XPUBVersion of the coin used. (use @ledgerhq/currencies if needed)
+   * @returns XPUB of the account
+   */
+  getWalletXpub(e) {
+    return this.changeImplIfNecessary().then((t) => t.getWalletXpub(e));
+  }
+  /**
+   * @param path a BIP 32 path
+   * @param options an object with optional these fields:
+   *
+   * - verify (boolean) will ask user to confirm the address on the device
+   *
+   * - format ("legacy" | "p2sh" | "bech32" | "bech32m" | "cashaddr") to use different bitcoin address formatter.
+   *
+   * NB The normal usage is to use:
+   *
+   * - legacy format with 44' paths
+   *
+   * - p2sh format with 49' paths
+   *
+   * - bech32 format with 84' paths
+   *
+   * - cashaddr in case of Bitcoin Cash
+   *
+   * @example
+   * btc.getWalletPublicKey("44'/0'/0'/0/0").then(o => o.bitcoinAddress)
+   * btc.getWalletPublicKey("49'/0'/0'/0/0", { format: "p2sh" }).then(o => o.bitcoinAddress)
+   */
+  getWalletPublicKey(e, t) {
+    let r;
+    return arguments.length > 2 || typeof t == "boolean" ? (console.warn("btc.getWalletPublicKey deprecated signature used. Please switch to getWalletPublicKey(path, { format, verify })"), r = {
+      verify: !!t,
+      // eslint-disable-next-line prefer-rest-params
+      format: arguments[2] ? "p2sh" : "legacy"
+    }) : r = t || {}, this.changeImplIfNecessary().then((o) => o.getWalletPublicKey(e, r));
+  }
+  /**
+   * You can sign a message according to the Bitcoin Signature format and retrieve v, r, s given the message and the BIP 32 path of the account to sign.
+   * @example
+   btc.signMessage("44'/60'/0'/0'/0", Buffer.from("test").toString("hex")).then(function(result) {
+     var v = result['v'] + 27 + 4;
+     var signature = Buffer.from(v.toString(16) + result['r'] + result['s'], 'hex').toString('base64');
+     console.log("Signature : " + signature);
+   }).catch(function(ex) {console.log(ex);});
+   */
+  signMessage(e, t) {
+    return this.changeImplIfNecessary().then((r) => r.signMessage({
+      path: e,
+      messageHex: t
+    }));
+  }
+  /**
+   * To sign a transaction involving standard (P2PKH) inputs, call createTransaction with the following parameters
+   * @param inputs is an array of [ transaction, output_index, optional redeem script, optional sequence ] where
+   *
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the optional redeem script to use when consuming a Segregated Witness input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param changePath is an optional BIP 32 path pointing to the path to the public key used to compute the change address
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign, including leading vararg voutCount
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @param segwit is an optional boolean indicating wether to use segwit or not. This includes wrapped segwit.
+   * @param initialTimestamp is an optional timestamp of the function call to use for coins that necessitate timestamps only, (not the one that the tx will include)
+   * @param additionals list of additionnal options
+   *
+   * - "bech32" for spending native segwit outputs
+   * - "bech32m" for spending segwit v1+ outputs
+   * - "abc" for bch
+   * - "gold" for btg
+   * - "bipxxx" for using BIPxxx
+   * - "sapling" to indicate a zec transaction is supporting sapling (to be set over block 419200)
+   * @param expiryHeight is an optional Buffer for zec overwinter / sapling Txs
+   * @param useTrustedInputForSegwit trust inputs for segwit transactions. If app version >= 1.4.0 this should be true.
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.createTransaction({
+   inputs: [ [tx1, 1] ],
+   associatedKeysets: ["0'/0/0"],
+   outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(res => ...);
+   */
+  createPaymentTransaction(e) {
+    if (arguments.length > 1)
+      throw new Error("@ledgerhq/hw-app-btc: createPaymentTransaction multi argument signature is deprecated. please switch to named parameters.");
+    return this.changeImplIfNecessary().then((t) => t.createPaymentTransaction(e));
+  }
+  /**
+   * To obtain the signature of multisignature (P2SH) inputs, call signP2SHTransaction_async with the folowing parameters
+   * @param inputs is an array of [ transaction, output_index, redeem script, optional sequence ] where
+   * * transaction is the previously computed transaction object for this UTXO
+   * * output_index is the output in the transaction used as input for this UTXO (counting from 0)
+   * * redeem script is the mandatory redeem script associated to the current P2SH input
+   * * sequence is the sequence number to use for this input (when using RBF), or non present
+   * @param associatedKeysets is an array of BIP 32 paths pointing to the path to the private key used for each UTXO
+   * @param outputScriptHex is the hexadecimal serialized outputs of the transaction to sign
+   * @param lockTime is the optional lockTime of the transaction to sign, or default (0)
+   * @param sigHashType is the hash type of the transaction to sign, or default (all)
+   * @return the signed transaction ready to be broadcast
+   * @example
+  btc.signP2SHTransaction({
+  inputs: [ [tx, 1, "52210289b4a3ad52a919abd2bdd6920d8a6879b1e788c38aa76f0440a6f32a9f1996d02103a3393b1439d1693b063482c04bd40142db97bdf139eedd1b51ffb7070a37eac321030b9a409a1e476b0d5d17b804fcdb81cf30f9b99c6f3ae1178206e08bc500639853ae"] ],
+  associatedKeysets: ["0'/0/0"],
+  outputScriptHex: "01905f0100000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88ac"
+  }).then(result => ...);
+   */
+  signP2SHTransaction(e) {
+    return Dr(this._transport, e);
+  }
+  /**
+   * For each UTXO included in your transaction, create a transaction object from the raw serialized version of the transaction used in this UTXO.
+   * @example
+  const tx1 = btc.splitTransaction("01000000014ea60aeac5252c14291d428915bd7ccd1bfc4af009f4d4dc57ae597ed0420b71010000008a47304402201f36a12c240dbf9e566bc04321050b1984cd6eaf6caee8f02bb0bfec08e3354b022012ee2aeadcbbfd1e92959f57c15c1c6debb757b798451b104665aa3010569b49014104090b15bde569386734abf2a2b99f9ca6a50656627e77de663ca7325702769986cf26cc9dd7fdea0af432c8e2becc867c932e1b9dd742f2a108997c2252e2bdebffffffff0281b72e00000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88aca0860100000000001976a9144533f5fb9b4817f713c48f0bfe96b9f50c476c9b88ac00000000");
+   */
+  splitTransaction(e, t = false, r = false, o = false, i = []) {
+    return Mr(e, t, r, o, i);
+  }
+  /**
+  @example
+  const tx1 = btc.splitTransaction("01000000014ea60aeac5252c14291d428915bd7ccd1bfc4af009f4d4dc57ae597ed0420b71010000008a47304402201f36a12c240dbf9e566bc04321050b1984cd6eaf6caee8f02bb0bfec08e3354b022012ee2aeadcbbfd1e92959f57c15c1c6debb757b798451b104665aa3010569b49014104090b15bde569386734abf2a2b99f9ca6a50656627e77de663ca7325702769986cf26cc9dd7fdea0af432c8e2becc867c932e1b9dd742f2a108997c2252e2bdebffffffff0281b72e00000000001976a91472a5d75c8d2d0565b656a5232703b167d50d5a2b88aca0860100000000001976a9144533f5fb9b4817f713c48f0bfe96b9f50c476c9b88ac00000000");
+  const outputScript = btc.serializeTransactionOutputs(tx1).toString('hex');
+  */
+  serializeTransactionOutputs(e) {
+    return zt(e);
+  }
+  getTrustedInput(e, t, r = []) {
+    return pt(this._transport, e, t, r);
+  }
+  getTrustedInputBIP143(e, t, r = []) {
+    return dt(this._transport, e, t, r);
+  }
+  changeImplIfNecessary() {
+    return kr(this, void 0, void 0, function* () {
+      if (this._impl instanceof ze)
+        return this._impl;
+      const e = yield Yt(this._transport);
+      let t = true;
+      if (e.name === "Bitcoin" || e.name === "Bitcoin Test") {
+        const [r, o] = e.version.split(".");
+        t = parseInt(r) <= 1 || parseInt(r) == 2 && parseInt(o) == 0;
+      } else
+        e.name === "Bitcoin Legacy" || e.name === "Bitcoin Test Legacy" ? t = true : e.name === "Exchange" && (t = yield ar(this._transport));
+      return t && (this._impl = new ze(this._transport)), this._impl;
+    });
+  }
+}
+export {
+  ti as default
+};