bitcoin-wallet-connector 0.1.0

package/lib/transaction-CiLOYSE_.mjs

@@ -0,0 +1,1063 @@
+import { v as W, s as v, k as b, l as E, R as Dt, m as _, n as q, o as N, I as Gt, h as I, p as L, q as J, r as gt, t as wt, P as X, C as P, u as jt, V as K, w as Y, x as Qt, y as M, z as Jt, N as Kt, E as k, A as Tt, D as Xt, F as Vt, G as Zt, H as te, J as ee, K as B, Q as bt, S as It, T as $, W as Yt, Y as ne, Z as U, _ as Z, $ as at, a0 as z, a1 as F, a2 as ut, a3 as ie, a4 as V, a5 as qt, a6 as se, a7 as At, a8 as oe, a9 as re, aa as ae, ab as ue, ac as pe } from "./index-D7YwhNAG.mjs";
+const ft = W(b(null), (n) => J(n, X.ecdsa)), nt = W(b(32), (n) => J(n, X.schnorr)), Ut = W(b(null), (n) => {
+  if (n.length !== 64 && n.length !== 65)
+    throw new Error("Schnorr signature should be 64 or 65 bytes long");
+  return n;
+}), ot = v({
+  fingerprint: jt,
+  path: N(null, E)
+}), zt = v({
+  hashes: N(P, b(32)),
+  der: ot
+}), ce = b(78), le = v({ pubKey: nt, leafHash: b(32) }), fe = v({
+  version: Y,
+  // With parity :(
+  internalKey: b(32),
+  merklePath: N(null, b(32))
+}), G = W(fe, (n) => {
+  if (n.merklePath.length > 128)
+    throw new Error("TaprootControlBlock: merklePath should be of length 0..128 (inclusive)");
+  return n;
+}), he = N(null, v({
+  depth: Y,
+  version: Y,
+  script: K
+})), x = b(null), Lt = b(20), H = b(32), St = {
+  unsignedTx: [0, !1, M, [0], [0], !1],
+  xpub: [1, ce, ot, [], [0, 2], !1],
+  txVersion: [2, !1, E, [2], [2], !1],
+  fallbackLocktime: [3, !1, E, [], [2], !1],
+  inputCount: [4, !1, P, [2], [2], !1],
+  outputCount: [5, !1, P, [2], [2], !1],
+  txModifiable: [6, !1, Y, [], [2], !1],
+  // TODO: bitfield
+  version: [251, !1, E, [], [0, 2], !1],
+  proprietary: [252, x, x, [], [0, 2], !1]
+}, rt = {
+  nonWitnessUtxo: [0, !1, q, [], [0, 2], !1],
+  witnessUtxo: [1, !1, _, [], [0, 2], !1],
+  partialSig: [2, ft, x, [], [0, 2], !1],
+  sighashType: [3, !1, E, [], [0, 2], !1],
+  redeemScript: [4, !1, x, [], [0, 2], !1],
+  witnessScript: [5, !1, x, [], [0, 2], !1],
+  bip32Derivation: [6, ft, ot, [], [0, 2], !1],
+  finalScriptSig: [7, !1, x, [], [0, 2], !1],
+  finalScriptWitness: [8, !1, Dt, [], [0, 2], !1],
+  porCommitment: [9, !1, x, [], [0, 2], !1],
+  ripemd160: [10, Lt, x, [], [0, 2], !1],
+  sha256: [11, H, x, [], [0, 2], !1],
+  hash160: [12, Lt, x, [], [0, 2], !1],
+  hash256: [13, H, x, [], [0, 2], !1],
+  txid: [14, !1, H, [2], [2], !0],
+  index: [15, !1, E, [2], [2], !0],
+  sequence: [16, !1, E, [], [2], !0],
+  requiredTimeLocktime: [17, !1, E, [], [2], !1],
+  requiredHeightLocktime: [18, !1, E, [], [2], !1],
+  tapKeySig: [19, !1, Ut, [], [0, 2], !1],
+  tapScriptSig: [20, le, Ut, [], [0, 2], !1],
+  tapLeafScript: [21, G, x, [], [0, 2], !1],
+  tapBip32Derivation: [22, H, zt, [], [0, 2], !1],
+  tapInternalKey: [23, !1, nt, [], [0, 2], !1],
+  tapMerkleRoot: [24, !1, H, [], [0, 2], !1],
+  proprietary: [252, x, x, [], [0, 2], !1]
+}, de = [
+  "txid",
+  "sequence",
+  "index",
+  "witnessUtxo",
+  "nonWitnessUtxo",
+  "finalScriptSig",
+  "finalScriptWitness",
+  "unknown"
+], ge = [
+  "partialSig",
+  "finalScriptSig",
+  "finalScriptWitness",
+  "tapKeySig",
+  "tapScriptSig"
+], it = {
+  redeemScript: [0, !1, x, [], [0, 2], !1],
+  witnessScript: [1, !1, x, [], [0, 2], !1],
+  bip32Derivation: [2, ft, ot, [], [0, 2], !1],
+  amount: [3, !1, Gt, [2], [2], !0],
+  script: [4, !1, x, [2], [2], !0],
+  tapInternalKey: [5, !1, nt, [], [0, 2], !1],
+  tapTree: [6, !1, he, [], [0, 2], !1],
+  tapBip32Derivation: [7, nt, zt, [], [0, 2], !1],
+  proprietary: [252, x, x, [], [0, 2], !1]
+}, we = [], vt = N(Kt, v({
+  //  <key> := <keylen> <keytype> <keydata> WHERE keylen = len(keytype)+len(keydata)
+  key: Jt(P, v({ type: P, key: b(null) })),
+  //  <value> := <valuelen> <valuedata>
+  value: b(P)
+}));
+function ht(n) {
+  const [t, e, i, o, s, r] = n;
+  return { type: t, kc: e, vc: i, reqInc: o, allowInc: s, silentIgnore: r };
+}
+v({ type: P, key: b(null) });
+function yt(n) {
+  const t = {};
+  for (const e in n) {
+    const [i, o, s] = n[e];
+    t[i] = [e, o, s];
+  }
+  return Qt({
+    encodeStream: (e, i) => {
+      let o = [];
+      for (const s in n) {
+        const r = i[s];
+        if (r === void 0)
+          continue;
+        const [a, u, f] = n[s];
+        if (!u)
+          o.push({ key: { type: a, key: k }, value: f.encode(r) });
+        else {
+          const p = r.map(([c, l]) => [
+            u.encode(c),
+            f.encode(l)
+          ]);
+          p.sort((c, l) => Tt(c[0], l[0]));
+          for (const [c, l] of p)
+            o.push({ key: { key: c, type: a }, value: l });
+        }
+      }
+      if (i.unknown) {
+        i.unknown.sort((s, r) => Tt(s[0].key, r[0].key));
+        for (const [s, r] of i.unknown)
+          o.push({ key: s, value: r });
+      }
+      vt.encodeStream(e, o);
+    },
+    decodeStream: (e) => {
+      const i = vt.decodeStream(e), o = {}, s = {};
+      for (const r of i) {
+        let a = "unknown", u = r.key.key, f = r.value;
+        if (t[r.key.type]) {
+          const [p, c, l] = t[r.key.type];
+          if (a = p, !c && u.length)
+            throw new Error(`PSBT: Non-empty key for ${a} (key=${I.encode(u)} value=${I.encode(f)}`);
+          if (u = c ? c.decode(u) : void 0, f = l.decode(f), !c) {
+            if (o[a])
+              throw new Error(`PSBT: Same keys: ${a} (key=${u} value=${f})`);
+            o[a] = f, s[a] = !0;
+            continue;
+          }
+        } else
+          u = { type: r.key.type, key: r.key.key };
+        if (s[a])
+          throw new Error(`PSBT: Key type with empty key and no key=${a} val=${f}`);
+        o[a] || (o[a] = []), o[a].push([u, f]);
+      }
+      return o;
+    }
+  });
+}
+const mt = W(yt(rt), (n) => {
+  if (n.finalScriptWitness && !n.finalScriptWitness.length)
+    throw new Error("validateInput: empty finalScriptWitness");
+  if (n.partialSig && !n.partialSig.length)
+    throw new Error("Empty partialSig");
+  if (n.partialSig)
+    for (const [t] of n.partialSig)
+      J(t, X.ecdsa);
+  if (n.bip32Derivation)
+    for (const [t] of n.bip32Derivation)
+      J(t, X.ecdsa);
+  if (n.requiredTimeLocktime !== void 0 && n.requiredTimeLocktime < 5e8)
+    throw new Error(`validateInput: wrong timeLocktime=${n.requiredTimeLocktime}`);
+  if (n.requiredHeightLocktime !== void 0 && (n.requiredHeightLocktime <= 0 || n.requiredHeightLocktime >= 5e8))
+    throw new Error(`validateInput: wrong heighLocktime=${n.requiredHeightLocktime}`);
+  if (n.tapLeafScript)
+    for (const [t, e] of n.tapLeafScript) {
+      if ((t.version & 254) !== e[e.length - 1])
+        throw new Error("validateInput: tapLeafScript version mimatch");
+      if (e[e.length - 1] & 1)
+        throw new Error("validateInput: tapLeafScript version has parity bit!");
+    }
+  return n;
+}), kt = W(yt(it), (n) => {
+  if (n.bip32Derivation)
+    for (const [t] of n.bip32Derivation)
+      J(t, X.ecdsa);
+  return n;
+}), Ft = W(yt(St), (n) => {
+  if ((n.version || 0) === 0) {
+    if (!n.unsignedTx)
+      throw new Error("PSBTv0: missing unsignedTx");
+    for (const e of n.unsignedTx.inputs)
+      if (e.finalScriptSig && e.finalScriptSig.length)
+        throw new Error("PSBTv0: input scriptSig found in unsignedTx");
+  }
+  return n;
+}), Se = v({
+  magic: gt(wt(new Uint8Array([255])), "psbt"),
+  global: Ft,
+  inputs: N("global/unsignedTx/inputs/length", mt),
+  outputs: N(null, kt)
+}), ye = v({
+  magic: gt(wt(new Uint8Array([255])), "psbt"),
+  global: Ft,
+  inputs: N("global/inputCount", mt),
+  outputs: N("global/outputCount", kt)
+});
+v({
+  magic: gt(wt(new Uint8Array([255])), "psbt"),
+  items: N(null, Xt(N(Kt, Zt([te(P), b(ee)])), Vt.dict()))
+});
+function pt(n, t, e) {
+  for (const i in e) {
+    if (i === "unknown" || !t[i])
+      continue;
+    const { allowInc: o } = ht(t[i]);
+    if (!o.includes(n))
+      throw new Error(`PSBTv${n}: field ${i} is not allowed`);
+  }
+  for (const i in t) {
+    const { reqInc: o } = ht(t[i]);
+    if (o.includes(n) && e[i] === void 0)
+      throw new Error(`PSBTv${n}: missing required field ${i}`);
+  }
+}
+function Nt(n, t, e) {
+  const i = {};
+  for (const o in e) {
+    const s = o;
+    if (s !== "unknown") {
+      if (!t[s])
+        continue;
+      const { allowInc: r, silentIgnore: a } = ht(t[s]);
+      if (!r.includes(n)) {
+        if (a)
+          continue;
+        throw new Error(`Failed to serialize in PSBTv${n}: ${s} but versions allows inclusion=${r}`);
+      }
+    }
+    i[s] = e[s];
+  }
+  return i;
+}
+function Ht(n) {
+  const t = n && n.global && n.global.version || 0;
+  pt(t, St, n.global);
+  for (const r of n.inputs)
+    pt(t, rt, r);
+  for (const r of n.outputs)
+    pt(t, it, r);
+  const e = t ? n.global.inputCount : n.global.unsignedTx.inputs.length;
+  if (n.inputs.length < e)
+    throw new Error("Not enough inputs");
+  const i = n.inputs.slice(e);
+  if (i.length > 1 || i.length && Object.keys(i[0]).length)
+    throw new Error(`Unexpected inputs left in tx=${i}`);
+  const o = t ? n.global.outputCount : n.global.unsignedTx.outputs.length;
+  if (n.outputs.length < o)
+    throw new Error("Not outputs inputs");
+  const s = n.outputs.slice(o);
+  if (s.length > 1 || s.length && Object.keys(s[0]).length)
+    throw new Error(`Unexpected outputs left in tx=${s}`);
+  return n;
+}
+function dt(n, t, e, i, o) {
+  const s = { ...e, ...t };
+  for (const r in n) {
+    const a = r, [u, f, p] = n[a], c = i && !i.includes(r);
+    if (t[r] === void 0 && r in t) {
+      if (c)
+        throw new Error(`Cannot remove signed field=${r}`);
+      delete s[r];
+    } else if (f) {
+      const l = e && e[r] ? e[r] : [];
+      let g = t[a];
+      if (g) {
+        if (!Array.isArray(g))
+          throw new Error(`keyMap(${r}): KV pairs should be [k, v][]`);
+        g = g.map((d) => {
+          if (d.length !== 2)
+            throw new Error(`keyMap(${r}): KV pairs should be [k, v][]`);
+          return [
+            typeof d[0] == "string" ? f.decode(I.decode(d[0])) : d[0],
+            typeof d[1] == "string" ? p.decode(I.decode(d[1])) : d[1]
+          ];
+        });
+        const y = {}, w = (d, m, S) => {
+          if (y[d] === void 0) {
+            y[d] = [m, S];
+            return;
+          }
+          const T = I.encode(p.encode(y[d][1])), A = I.encode(p.encode(S));
+          if (T !== A)
+            throw new Error(`keyMap(${a}): same key=${d} oldVal=${T} newVal=${A}`);
+        };
+        for (const [d, m] of l) {
+          const S = I.encode(f.encode(d));
+          w(S, d, m);
+        }
+        for (const [d, m] of g) {
+          const S = I.encode(f.encode(d));
+          if (m === void 0) {
+            if (c)
+              throw new Error(`Cannot remove signed field=${a}/${d}`);
+            delete y[S];
+          } else
+            w(S, d, m);
+        }
+        s[a] = Object.values(y);
+      }
+    } else if (typeof s[r] == "string")
+      s[r] = p.decode(I.decode(s[r]));
+    else if (c && r in t && e && e[r] !== void 0 && !L(p.encode(t[r]), p.encode(e[r])))
+      throw new Error(`Cannot change signed field=${r}`);
+  }
+  for (const r in s)
+    if (!n[r]) {
+      if (o && r === "unknown")
+        continue;
+      delete s[r];
+    }
+  return s;
+}
+const Ot = W(Se, Ht), Pt = W(ye, Ht), tt = new Uint8Array(32), me = {
+  amount: 0xffffffffffffffffn,
+  script: k
+}, ke = (n) => Math.ceil(n / 4), Ee = 8, xe = 2, C = 0, Rt = 4294967295;
+Vt.decimal(Ee);
+const j = (n, t) => n === void 0 ? t : n;
+function st(n) {
+  if (Array.isArray(n))
+    return n.map((t) => st(t));
+  if (V(n))
+    return Uint8Array.from(n);
+  if (["number", "bigint", "boolean", "string", "undefined"].includes(typeof n))
+    return n;
+  if (n === null)
+    return n;
+  if (typeof n == "object")
+    return Object.fromEntries(Object.entries(n).map(([t, e]) => [t, st(e)]));
+  throw new Error(`cloneDeep: unknown type=${n} (${typeof n})`);
+}
+const h = {
+  DEFAULT: 0,
+  ALL: 1,
+  NONE: 2,
+  SINGLE: 3,
+  ANYONECANPAY: 128
+}, Te = {
+  DEFAULT: h.DEFAULT,
+  ALL: h.ALL,
+  NONE: h.NONE,
+  SINGLE: h.SINGLE,
+  DEFAULT_ANYONECANPAY: h.DEFAULT | h.ANYONECANPAY,
+  ALL_ANYONECANPAY: h.ALL | h.ANYONECANPAY,
+  NONE_ANYONECANPAY: h.NONE | h.ANYONECANPAY,
+  SINGLE_ANYONECANPAY: h.SINGLE | h.ANYONECANPAY
+}, be = ue(Te);
+function Ie(n, t, e, i = k) {
+  return L(e, t) && (n = pe(n, i), t = qt(n)), { privKey: n, pubKey: t };
+}
+function D(n) {
+  if (n.script === void 0 || n.amount === void 0)
+    throw new Error("Transaction/output: script and amount required");
+  return { script: n.script, amount: n.amount };
+}
+function R(n) {
+  if (n.txid === void 0 || n.index === void 0)
+    throw new Error("Transaction/input: txid and index required");
+  return {
+    txid: n.txid,
+    index: n.index,
+    sequence: j(n.sequence, Rt),
+    finalScriptSig: j(n.finalScriptSig, k)
+  };
+}
+function ct(n) {
+  for (const t in n) {
+    const e = t;
+    de.includes(e) || delete n[e];
+  }
+}
+const lt = v({ txid: b(32, !0), index: E });
+function Ae(n) {
+  if (typeof n != "number" || typeof be[n] != "string")
+    throw new Error(`Invalid SigHash=${n}`);
+  return n;
+}
+function $t(n) {
+  const t = n & 31;
+  return {
+    isAny: !!(n & h.ANYONECANPAY),
+    isNone: t === h.NONE,
+    isSingle: t === h.SINGLE
+  };
+}
+function Ue(n) {
+  if (n !== void 0 && {}.toString.call(n) !== "[object Object]")
+    throw new Error(`Wrong object type for transaction options: ${n}`);
+  const t = {
+    ...n,
+    // Defaults
+    version: j(n.version, xe),
+    lockTime: j(n.lockTime, 0),
+    PSBTVersion: j(n.PSBTVersion, 0)
+  };
+  if (typeof t.allowUnknowInput < "u" && (n.allowUnknownInputs = t.allowUnknowInput), typeof t.allowUnknowOutput < "u" && (n.allowUnknownOutputs = t.allowUnknowOutput), typeof t.lockTime != "number")
+    throw new Error("Transaction lock time should be number");
+  if (E.encode(t.lockTime), t.PSBTVersion !== 0 && t.PSBTVersion !== 2)
+    throw new Error(`Unknown PSBT version ${t.PSBTVersion}`);
+  for (const e of [
+    "allowUnknownVersion",
+    "allowUnknownOutputs",
+    "allowUnknownInputs",
+    "disableScriptCheck",
+    "bip174jsCompat",
+    "allowLegacyWitnessUtxo",
+    "lowR"
+  ]) {
+    const i = t[e];
+    if (i !== void 0 && typeof i != "boolean")
+      throw new Error(`Transation options wrong type: ${e}=${i} (${typeof i})`);
+  }
+  if (t.allowUnknownVersion ? typeof t.version == "number" : ![-1, 0, 1, 2, 3].includes(t.version))
+    throw new Error(`Unknown version: ${t.version}`);
+  if (t.customScripts !== void 0) {
+    const e = t.customScripts;
+    if (!Array.isArray(e))
+      throw new Error(`wrong custom scripts type (expected array): customScripts=${e} (${typeof e})`);
+    for (const i of e) {
+      if (typeof i.encode != "function" || typeof i.decode != "function")
+        throw new Error(`wrong script=${i} (${typeof i})`);
+      if (i.finalizeTaproot !== void 0 && typeof i.finalizeTaproot != "function")
+        throw new Error(`wrong script=${i} (${typeof i})`);
+    }
+  }
+  return Object.freeze(t);
+}
+function Wt(n) {
+  if (n.nonWitnessUtxo && n.index !== void 0) {
+    const t = n.nonWitnessUtxo.outputs.length - 1;
+    if (n.index > t)
+      throw new Error(`validateInput: index(${n.index}) not in nonWitnessUtxo`);
+    const e = n.nonWitnessUtxo.outputs[n.index];
+    if (n.witnessUtxo && (!L(n.witnessUtxo.script, e.script) || n.witnessUtxo.amount !== e.amount))
+      throw new Error("validateInput: witnessUtxo different from nonWitnessUtxo");
+    if (n.txid) {
+      if (n.nonWitnessUtxo.outputs.length - 1 < n.index)
+        throw new Error("nonWitnessUtxo: incorect output index");
+      const o = Q.fromRaw(q.encode(n.nonWitnessUtxo), {
+        allowUnknownOutputs: !0,
+        disableScriptCheck: !0,
+        allowUnknownInputs: !0
+      }), s = I.encode(n.txid);
+      if (o.isFinal && o.id !== s)
+        throw new Error(`nonWitnessUtxo: wrong txid, exp=${s} got=${o.id}`);
+    }
+  }
+  return n;
+}
+function et(n) {
+  if (n.nonWitnessUtxo) {
+    if (n.index === void 0)
+      throw new Error("Unknown input index");
+    return n.nonWitnessUtxo.outputs[n.index];
+  } else {
+    if (n.witnessUtxo)
+      return n.witnessUtxo;
+    throw new Error("Cannot find previous output info");
+  }
+}
+function Bt(n, t, e, i = !1, o = !1) {
+  let { nonWitnessUtxo: s, txid: r } = n;
+  typeof s == "string" && (s = I.decode(s)), V(s) && (s = q.decode(s)), !("nonWitnessUtxo" in n) && s === void 0 && (s = t?.nonWitnessUtxo), typeof r == "string" && (r = I.decode(r)), r === void 0 && (r = t?.txid);
+  let a = { ...t, ...n, nonWitnessUtxo: s, txid: r };
+  !("nonWitnessUtxo" in n) && a.nonWitnessUtxo === void 0 && delete a.nonWitnessUtxo, a.sequence === void 0 && (a.sequence = Rt), a.tapMerkleRoot === null && delete a.tapMerkleRoot, a = dt(rt, a, t, e, o), mt.encode(a);
+  let u;
+  return a.nonWitnessUtxo && a.index !== void 0 ? u = a.nonWitnessUtxo.outputs[a.index] : a.witnessUtxo && (u = a.witnessUtxo), u && !i && Yt(u && u.script, a.redeemScript, a.witnessScript), a;
+}
+function Ct(n, t = !1) {
+  let e = "legacy", i = h.ALL;
+  const o = et(n), s = $.decode(o.script);
+  let r = s.type, a = s;
+  const u = [s];
+  if (s.type === "tr")
+    return i = h.DEFAULT, {
+      txType: "taproot",
+      type: "tr",
+      last: s,
+      lastScript: o.script,
+      defaultSighash: i,
+      sighash: n.sighashType || i
+    };
+  {
+    if ((s.type === "wpkh" || s.type === "wsh") && (e = "segwit"), s.type === "sh") {
+      if (!n.redeemScript)
+        throw new Error("inputType: sh without redeemScript");
+      let l = $.decode(n.redeemScript);
+      (l.type === "wpkh" || l.type === "wsh") && (e = "segwit"), u.push(l), a = l, r += `-${l.type}`;
+    }
+    if (a.type === "wsh") {
+      if (!n.witnessScript)
+        throw new Error("inputType: wsh without witnessScript");
+      let l = $.decode(n.witnessScript);
+      l.type === "wsh" && (e = "segwit"), u.push(l), a = l, r += `-${l.type}`;
+    }
+    const f = u[u.length - 1];
+    if (f.type === "sh" || f.type === "wsh")
+      throw new Error("inputType: sh/wsh cannot be terminal type");
+    const p = $.encode(f), c = {
+      type: r,
+      txType: e,
+      last: f,
+      lastScript: p,
+      defaultSighash: i,
+      sighash: n.sighashType || i
+    };
+    if (e === "legacy" && !t && !n.nonWitnessUtxo)
+      throw new Error("Transaction/sign: legacy input without nonWitnessUtxo, can result in attack that forces paying higher fees. Pass allowLegacyWitnessUtxo=true, if you sure");
+    return c;
+  }
+}
+class Q {
+  global = {};
+  inputs = [];
+  // use getInput()
+  outputs = [];
+  // use getOutput()
+  opts;
+  constructor(t = {}) {
+    const e = this.opts = Ue(t);
+    e.lockTime !== C && (this.global.fallbackLocktime = e.lockTime), this.global.txVersion = e.version;
+  }
+  // Import
+  static fromRaw(t, e = {}) {
+    const i = q.decode(t), o = new Q({ ...e, version: i.version, lockTime: i.lockTime });
+    for (const s of i.outputs)
+      o.addOutput(s);
+    if (o.outputs = i.outputs, o.inputs = i.inputs, i.witnesses)
+      for (let s = 0; s < i.witnesses.length; s++)
+        o.inputs[s].finalScriptWitness = i.witnesses[s];
+    return o;
+  }
+  // PSBT
+  static fromPSBT(t, e = {}) {
+    let i;
+    try {
+      i = Ot.decode(t);
+    } catch (c) {
+      try {
+        i = Pt.decode(t);
+      } catch {
+        throw c;
+      }
+    }
+    const o = i.global.version || 0;
+    if (o !== 0 && o !== 2)
+      throw new Error(`Wrong PSBT version=${o}`);
+    const s = i.global.unsignedTx, r = o === 0 ? s?.version : i.global.txVersion, a = o === 0 ? s?.lockTime : i.global.fallbackLocktime, u = new Q({ ...e, version: r, lockTime: a, PSBTVersion: o }), f = o === 0 ? s?.inputs.length : i.global.inputCount;
+    u.inputs = i.inputs.slice(0, f).map((c, l) => Wt({
+      finalScriptSig: k,
+      ...i.global.unsignedTx?.inputs[l],
+      ...c
+    }));
+    const p = o === 0 ? s?.outputs.length : i.global.outputCount;
+    return u.outputs = i.outputs.slice(0, p).map((c, l) => ({
+      ...c,
+      ...i.global.unsignedTx?.outputs[l]
+    })), u.global = { ...i.global, txVersion: r }, a !== C && (u.global.fallbackLocktime = a), u;
+  }
+  toPSBT(t = this.opts.PSBTVersion) {
+    if (t !== 0 && t !== 2)
+      throw new Error(`Wrong PSBT version=${t}`);
+    const e = this.inputs.map((s) => Wt(Nt(t, rt, s)));
+    for (const s of e)
+      s.partialSig && !s.partialSig.length && delete s.partialSig, s.finalScriptSig && !s.finalScriptSig.length && delete s.finalScriptSig, s.finalScriptWitness && !s.finalScriptWitness.length && delete s.finalScriptWitness;
+    const i = this.outputs.map((s) => Nt(t, it, s)), o = { ...this.global };
+    return t === 0 ? (o.unsignedTx = M.decode(M.encode({
+      version: this.version,
+      lockTime: this.lockTime,
+      inputs: this.inputs.map(R).map((s) => ({
+        ...s,
+        finalScriptSig: k
+      })),
+      outputs: this.outputs.map(D)
+    })), delete o.fallbackLocktime, delete o.txVersion) : (o.version = t, o.txVersion = this.version, o.inputCount = this.inputs.length, o.outputCount = this.outputs.length, o.fallbackLocktime && o.fallbackLocktime === C && delete o.fallbackLocktime), this.opts.bip174jsCompat && (e.length || e.push({}), i.length || i.push({})), (t === 0 ? Ot : Pt).encode({
+      global: o,
+      inputs: e,
+      outputs: i
+    });
+  }
+  // BIP370 lockTime (https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#determining-lock-time)
+  get lockTime() {
+    let t = C, e = 0, i = C, o = 0;
+    for (const s of this.inputs)
+      s.requiredHeightLocktime && (t = Math.max(t, s.requiredHeightLocktime), e++), s.requiredTimeLocktime && (i = Math.max(i, s.requiredTimeLocktime), o++);
+    return e && e >= o ? t : i !== C ? i : this.global.fallbackLocktime || C;
+  }
+  get version() {
+    if (this.global.txVersion === void 0)
+      throw new Error("No global.txVersion");
+    return this.global.txVersion;
+  }
+  inputStatus(t) {
+    this.checkInputIdx(t);
+    const e = this.inputs[t];
+    return e.finalScriptSig && e.finalScriptSig.length || e.finalScriptWitness && e.finalScriptWitness.length ? "finalized" : e.tapKeySig || e.tapScriptSig && e.tapScriptSig.length || e.partialSig && e.partialSig.length ? "signed" : "unsigned";
+  }
+  // Cannot replace unpackSighash, tests rely on very generic implemenetation with signing inputs outside of range
+  // We will lose some vectors -> smaller test coverage of preimages (very important!)
+  inputSighash(t) {
+    this.checkInputIdx(t);
+    const e = this.inputs[t].sighashType, i = e === void 0 ? h.DEFAULT : e, o = i === h.DEFAULT ? h.ALL : i & 3;
+    return { sigInputs: i & h.ANYONECANPAY, sigOutputs: o };
+  }
+  // Very nice for debug purposes, but slow. If there is too much inputs/outputs to add, will be quadratic.
+  // Some cache will be nice, but there chance to have bugs with cache invalidation
+  signStatus() {
+    let t = !0, e = !0, i = [], o = [];
+    for (let s = 0; s < this.inputs.length; s++) {
+      if (this.inputStatus(s) === "unsigned")
+        continue;
+      const { sigInputs: a, sigOutputs: u } = this.inputSighash(s);
+      if (a === h.ANYONECANPAY ? i.push(s) : t = !1, u === h.ALL)
+        e = !1;
+      else if (u === h.SINGLE)
+        o.push(s);
+      else if (u !== h.NONE) throw new Error(`Wrong signature hash output type: ${u}`);
+    }
+    return { addInput: t, addOutput: e, inputs: i, outputs: o };
+  }
+  get isFinal() {
+    for (let t = 0; t < this.inputs.length; t++)
+      if (this.inputStatus(t) !== "finalized")
+        return !1;
+    return !0;
+  }
+  // Info utils
+  get hasWitnesses() {
+    let t = !1;
+    for (const e of this.inputs)
+      e.finalScriptWitness && e.finalScriptWitness.length && (t = !0);
+    return t;
+  }
+  // https://en.bitcoin.it/wiki/Weight_units
+  get weight() {
+    if (!this.isFinal)
+      throw new Error("Transaction is not finalized");
+    let t = 32;
+    const e = this.outputs.map(D);
+    t += 4 * P.encode(this.outputs.length).length;
+    for (const i of e)
+      t += 32 + 4 * K.encode(i.script).length;
+    this.hasWitnesses && (t += 2), t += 4 * P.encode(this.inputs.length).length;
+    for (const i of this.inputs)
+      t += 160 + 4 * K.encode(i.finalScriptSig || k).length, this.hasWitnesses && i.finalScriptWitness && (t += Dt.encode(i.finalScriptWitness).length);
+    return t;
+  }
+  get vsize() {
+    return ke(this.weight);
+  }
+  toBytes(t = !1, e = !1) {
+    return q.encode({
+      version: this.version,
+      lockTime: this.lockTime,
+      inputs: this.inputs.map(R).map((i) => ({
+        ...i,
+        finalScriptSig: t && i.finalScriptSig || k
+      })),
+      outputs: this.outputs.map(D),
+      witnesses: this.inputs.map((i) => i.finalScriptWitness || []),
+      segwitFlag: e && this.hasWitnesses
+    });
+  }
+  get unsignedTx() {
+    return this.toBytes(!1, !1);
+  }
+  get hex() {
+    return I.encode(this.toBytes(!0, this.hasWitnesses));
+  }
+  get hash() {
+    return I.encode(B(this.toBytes(!0)));
+  }
+  get id() {
+    return I.encode(B(this.toBytes(!0)).reverse());
+  }
+  // Input stuff
+  checkInputIdx(t) {
+    if (!Number.isSafeInteger(t) || 0 > t || t >= this.inputs.length)
+      throw new Error(`Wrong input index=${t}`);
+  }
+  getInput(t) {
+    return this.checkInputIdx(t), st(this.inputs[t]);
+  }
+  get inputsLength() {
+    return this.inputs.length;
+  }
+  // Modification
+  addInput(t, e = !1) {
+    if (!e && !this.signStatus().addInput)
+      throw new Error("Tx has signed inputs, cannot add new one");
+    return this.inputs.push(Bt(t, void 0, void 0, this.opts.disableScriptCheck)), this.inputs.length - 1;
+  }
+  updateInput(t, e, i = !1) {
+    this.checkInputIdx(t);
+    let o;
+    if (!i) {
+      const s = this.signStatus();
+      (!s.addInput || s.inputs.includes(t)) && (o = ge);
+    }
+    this.inputs[t] = Bt(e, this.inputs[t], o, this.opts.disableScriptCheck, this.opts.allowUnknown);
+  }
+  // Output stuff
+  checkOutputIdx(t) {
+    if (!Number.isSafeInteger(t) || 0 > t || t >= this.outputs.length)
+      throw new Error(`Wrong output index=${t}`);
+  }
+  getOutput(t) {
+    return this.checkOutputIdx(t), st(this.outputs[t]);
+  }
+  getOutputAddress(t, e = bt) {
+    const i = this.getOutput(t);
+    if (i.script)
+      return It(e).encode($.decode(i.script));
+  }
+  get outputsLength() {
+    return this.outputs.length;
+  }
+  normalizeOutput(t, e, i) {
+    let { amount: o, script: s } = t;
+    if (o === void 0 && (o = e?.amount), typeof o != "bigint")
+      throw new Error(`Wrong amount type, should be of type bigint in sats, but got ${o} of type ${typeof o}`);
+    typeof s == "string" && (s = I.decode(s)), s === void 0 && (s = e?.script);
+    let r = { ...e, ...t, amount: o, script: s };
+    if (r.amount === void 0 && delete r.amount, r = dt(it, r, e, i, this.opts.allowUnknown), kt.encode(r), r.script && !this.opts.allowUnknownOutputs && $.decode(r.script).type === "unknown")
+      throw new Error("Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure");
+    return this.opts.disableScriptCheck || Yt(r.script, r.redeemScript, r.witnessScript), r;
+  }
+  addOutput(t, e = !1) {
+    if (!e && !this.signStatus().addOutput)
+      throw new Error("Tx has signed outputs, cannot add new one");
+    return this.outputs.push(this.normalizeOutput(t)), this.outputs.length - 1;
+  }
+  updateOutput(t, e, i = !1) {
+    this.checkOutputIdx(t);
+    let o;
+    if (!i) {
+      const s = this.signStatus();
+      (!s.addOutput || s.outputs.includes(t)) && (o = we);
+    }
+    this.outputs[t] = this.normalizeOutput(e, this.outputs[t], o);
+  }
+  addOutputAddress(t, e, i = bt) {
+    return this.addOutput({ script: $.encode(It(i).decode(t)), amount: e });
+  }
+  // Utils
+  get fee() {
+    let t = 0n;
+    for (const i of this.inputs) {
+      const o = et(i);
+      if (!o)
+        throw new Error("Empty input amount");
+      t += o.amount;
+    }
+    const e = this.outputs.map(D);
+    for (const i of e)
+      t -= i.amount;
+    return t;
+  }
+  // Signing
+  // Based on https://github.com/bitcoin/bitcoin/blob/5871b5b5ab57a0caf9b7514eb162c491c83281d5/test/functional/test_framework/script.py#L624
+  // There is optimization opportunity to re-use hashes for multiple inputs for witness v0/v1,
+  // but we are trying to be less complicated for audit purpose for now.
+  preimageLegacy(t, e, i) {
+    const { isAny: o, isNone: s, isSingle: r } = $t(i);
+    if (t < 0 || !Number.isSafeInteger(t))
+      throw new Error(`Invalid input idx=${t}`);
+    if (r && t >= this.outputs.length || t >= this.inputs.length)
+      return ne.encode(1n);
+    e = U.encode(U.decode(e).filter((p) => p !== "CODESEPARATOR"));
+    let a = this.inputs.map(R).map((p, c) => ({
+      ...p,
+      finalScriptSig: c === t ? e : k
+    }));
+    o ? a = [a[t]] : (s || r) && (a = a.map((p, c) => ({
+      ...p,
+      sequence: c === t ? p.sequence : 0
+    })));
+    let u = this.outputs.map(D);
+    s ? u = [] : r && (u = u.slice(0, t).fill(me).concat([u[t]]));
+    const f = q.encode({
+      lockTime: this.lockTime,
+      version: this.version,
+      segwitFlag: !1,
+      inputs: a,
+      outputs: u
+    });
+    return B(f, Z.encode(i));
+  }
+  preimageWitnessV0(t, e, i, o) {
+    const { isAny: s, isNone: r, isSingle: a } = $t(i);
+    let u = tt, f = tt, p = tt;
+    const c = this.inputs.map(R), l = this.outputs.map(D);
+    s || (u = B(...c.map(lt.encode))), !s && !a && !r && (f = B(...c.map((y) => E.encode(y.sequence)))), !a && !r ? p = B(...l.map(_.encode)) : a && t < l.length && (p = B(_.encode(l[t])));
+    const g = c[t];
+    return B(Z.encode(this.version), u, f, b(32, !0).encode(g.txid), E.encode(g.index), K.encode(e), at.encode(o), E.encode(g.sequence), p, E.encode(this.lockTime), E.encode(i));
+  }
+  preimageWitnessV1(t, e, i, o, s = -1, r, a = 192, u) {
+    if (!Array.isArray(o) || this.inputs.length !== o.length)
+      throw new Error(`Invalid amounts array=${o}`);
+    if (!Array.isArray(e) || this.inputs.length !== e.length)
+      throw new Error(`Invalid prevOutScript array=${e}`);
+    const f = [
+      Y.encode(0),
+      Y.encode(i),
+      // U8 sigHash
+      Z.encode(this.version),
+      E.encode(this.lockTime)
+    ], p = i === h.DEFAULT ? h.ALL : i & 3, c = i & h.ANYONECANPAY, l = this.inputs.map(R), g = this.outputs.map(D);
+    c !== h.ANYONECANPAY && f.push(...[
+      l.map(lt.encode),
+      o.map(at.encode),
+      e.map(K.encode),
+      l.map((w) => E.encode(w.sequence))
+    ].map((w) => z(F(...w)))), p === h.ALL && f.push(z(F(...g.map(_.encode))));
+    const y = (u ? 1 : 0) | (r ? 2 : 0);
+    if (f.push(new Uint8Array([y])), c === h.ANYONECANPAY) {
+      const w = l[t];
+      f.push(lt.encode(w), at.encode(o[t]), K.encode(e[t]), E.encode(w.sequence));
+    } else
+      f.push(E.encode(t));
+    return y & 1 && f.push(z(K.encode(u || k))), p === h.SINGLE && f.push(t < g.length ? z(_.encode(g[t])) : tt), r && f.push(ut(r, a), Y.encode(0), Z.encode(s)), ie("TapSighash", ...f);
+  }
+  // Signer can be privateKey OR instance of bip32 HD stuff
+  signIdx(t, e, i, o) {
+    this.checkInputIdx(e);
+    const s = this.inputs[e], r = Ct(s, this.opts.allowLegacyWitnessUtxo);
+    if (!V(t)) {
+      if (!s.bip32Derivation || !s.bip32Derivation.length)
+        throw new Error("bip32Derivation: empty");
+      const p = s.bip32Derivation.filter((l) => l[1].fingerprint == t.fingerprint).map(([l, { path: g }]) => {
+        let y = t;
+        for (const w of g)
+          y = y.deriveChild(w);
+        if (!L(y.publicKey, l))
+          throw new Error("bip32Derivation: wrong pubKey");
+        if (!y.privateKey)
+          throw new Error("bip32Derivation: no privateKey");
+        return y;
+      });
+      if (!p.length)
+        throw new Error(`bip32Derivation: no items with fingerprint=${t.fingerprint}`);
+      let c = !1;
+      for (const l of p)
+        this.signIdx(l.privateKey, e) && (c = !0);
+      return c;
+    }
+    i ? i.forEach(Ae) : i = [r.defaultSighash];
+    const a = r.sighash;
+    if (!i.includes(a))
+      throw new Error(`Input with not allowed sigHash=${a}. Allowed: ${i.join(", ")}`);
+    const { sigOutputs: u } = this.inputSighash(e);
+    if (u === h.SINGLE && e >= this.outputs.length)
+      throw new Error(`Input with sighash SINGLE, but there is no output with corresponding index=${e}`);
+    const f = et(s);
+    if (r.txType === "taproot") {
+      const p = this.inputs.map(et), c = p.map((d) => d.script), l = p.map((d) => d.amount);
+      let g = !1, y = qt(t), w = s.tapMerkleRoot || k;
+      if (s.tapInternalKey) {
+        const { pubKey: d, privKey: m } = Ie(t, y, s.tapInternalKey, w), [S] = se(s.tapInternalKey, w);
+        if (L(S, d)) {
+          const T = this.preimageWitnessV1(e, c, a, l), A = F(At(T, m, o), a !== h.DEFAULT ? new Uint8Array([a]) : k);
+          this.updateInput(e, { tapKeySig: A }, !0), g = !0;
+        }
+      }
+      if (s.tapLeafScript) {
+        s.tapScriptSig = s.tapScriptSig || [];
+        for (const [d, m] of s.tapLeafScript) {
+          const S = m.subarray(0, -1), T = U.decode(S), A = m[m.length - 1], O = ut(S, A);
+          if (T.findIndex((xt) => V(xt) && L(xt, y)) === -1)
+            continue;
+          const _t = this.preimageWitnessV1(e, c, a, l, void 0, S, A), Mt = F(At(_t, t, o), a !== h.DEFAULT ? new Uint8Array([a]) : k);
+          this.updateInput(e, { tapScriptSig: [[{ pubKey: y, leafHash: O }, Mt]] }, !0), g = !0;
+        }
+      }
+      if (!g)
+        throw new Error("No taproot scripts signed");
+      return !0;
+    } else {
+      const p = oe(t);
+      let c = !1;
+      const l = re(p);
+      for (const w of U.decode(r.lastScript))
+        V(w) && (L(w, p) || L(w, l)) && (c = !0);
+      if (!c)
+        throw new Error(`Input script doesn't have pubKey: ${r.lastScript}`);
+      let g;
+      if (r.txType === "legacy")
+        g = this.preimageLegacy(e, r.lastScript, a);
+      else if (r.txType === "segwit") {
+        let w = r.lastScript;
+        r.last.type === "wpkh" && (w = $.encode({ type: "pkh", hash: r.last.hash })), g = this.preimageWitnessV0(e, w, a, f.amount);
+      } else
+        throw new Error(`Transaction/sign: unknown tx type: ${r.txType}`);
+      const y = ae(g, t, this.opts.lowR);
+      this.updateInput(e, {
+        partialSig: [[p, F(y, new Uint8Array([a]))]]
+      }, !0);
+    }
+    return !0;
+  }
+  // This is bad API. Will work if user creates and signs tx, but if
+  // there is some complex workflow with exchanging PSBT and signing them,
+  // then it is better to validate which output user signs. How could a better API look like?
+  // Example: user adds input, sends to another party, then signs received input (mixer etc),
+  // another user can add different input for same key and user will sign it.
+  // Even worse: another user can add bip32 derivation, and spend money from different address.
+  // Better api: signIdx
+  sign(t, e, i) {
+    let o = 0;
+    for (let s = 0; s < this.inputs.length; s++)
+      try {
+        this.signIdx(t, s, e, i) && o++;
+      } catch {
+      }
+    if (!o)
+      throw new Error("No inputs signed");
+    return o;
+  }
+  finalizeIdx(t) {
+    if (this.checkInputIdx(t), this.fee < 0n)
+      throw new Error("Outputs spends more than inputs amount");
+    const e = this.inputs[t], i = Ct(e, this.opts.allowLegacyWitnessUtxo);
+    if (i.txType === "taproot") {
+      if (e.tapKeySig)
+        e.finalScriptWitness = [e.tapKeySig];
+      else if (e.tapLeafScript && e.tapScriptSig) {
+        const u = e.tapLeafScript.sort((f, p) => G.encode(f[0]).length - G.encode(p[0]).length);
+        for (const [f, p] of u) {
+          const c = p.slice(0, -1), l = p[p.length - 1], g = $.decode(c), y = ut(c, l), w = e.tapScriptSig.filter((m) => L(m[0].leafHash, y));
+          let d = [];
+          if (g.type === "tr_ms") {
+            const m = g.m, S = g.pubkeys;
+            let T = 0;
+            for (const A of S) {
+              const O = w.findIndex((Et) => L(Et[0].pubKey, A));
+              if (T === m || O === -1) {
+                d.push(k);
+                continue;
+              }
+              d.push(w[O][1]), T++;
+            }
+            if (T !== m)
+              continue;
+          } else if (g.type === "tr_ns") {
+            for (const m of g.pubkeys) {
+              const S = w.findIndex((T) => L(T[0].pubKey, m));
+              S !== -1 && d.push(w[S][1]);
+            }
+            if (d.length !== g.pubkeys.length)
+              continue;
+          } else if (g.type === "unknown" && this.opts.allowUnknownInputs) {
+            const m = U.decode(c);
+            if (d = w.map(([{ pubKey: S }, T]) => {
+              const A = m.findIndex((O) => V(O) && L(O, S));
+              if (A === -1)
+                throw new Error("finalize/taproot: cannot find position of pubkey in script");
+              return { signature: T, pos: A };
+            }).sort((S, T) => S.pos - T.pos).map((S) => S.signature), !d.length)
+              continue;
+          } else {
+            const m = this.opts.customScripts;
+            if (m)
+              for (const S of m) {
+                if (!S.finalizeTaproot)
+                  continue;
+                const T = U.decode(c), A = S.encode(T);
+                if (A === void 0)
+                  continue;
+                const O = S.finalizeTaproot(c, A, w);
+                if (O) {
+                  e.finalScriptWitness = O.concat(G.encode(f)), e.finalScriptSig = k, ct(e);
+                  return;
+                }
+              }
+            throw new Error("Finalize: Unknown tapLeafScript");
+          }
+          e.finalScriptWitness = d.reverse().concat([c, G.encode(f)]);
+          break;
+        }
+        if (!e.finalScriptWitness)
+          throw new Error("finalize/taproot: empty witness");
+      } else
+        throw new Error("finalize/taproot: unknown input");
+      e.finalScriptSig = k, ct(e);
+      return;
+    }
+    if (!e.partialSig || !e.partialSig.length)
+      throw new Error("Not enough partial sign");
+    let o = k, s = [];
+    if (i.last.type === "ms") {
+      const u = i.last.m, f = i.last.pubkeys;
+      let p = [];
+      for (const c of f) {
+        const l = e.partialSig.find((g) => L(c, g[0]));
+        l && p.push(l[1]);
+      }
+      if (p = p.slice(0, u), p.length !== u)
+        throw new Error(`Multisig: wrong signatures count, m=${u} n=${f.length} signatures=${p.length}`);
+      o = U.encode([0, ...p]);
+    } else if (i.last.type === "pk")
+      o = U.encode([e.partialSig[0][1]]);
+    else if (i.last.type === "pkh")
+      o = U.encode([e.partialSig[0][1], e.partialSig[0][0]]);
+    else if (i.last.type === "wpkh")
+      o = k, s = [e.partialSig[0][1], e.partialSig[0][0]];
+    else if (i.last.type === "unknown" && !this.opts.allowUnknownInputs)
+      throw new Error("Unknown inputs not allowed");
+    let r, a;
+    if (i.type.includes("wsh-") && (o.length && i.lastScript.length && (s = U.decode(o).map((u) => {
+      if (u === 0)
+        return k;
+      if (V(u))
+        return u;
+      throw new Error(`Wrong witness op=${u}`);
+    })), s = s.concat(i.lastScript)), i.txType === "segwit" && (a = s), i.type.startsWith("sh-wsh-") ? r = U.encode([U.encode([0, z(i.lastScript)])]) : i.type.startsWith("sh-") ? r = U.encode([...U.decode(o), i.lastScript]) : i.type.startsWith("wsh-") || i.txType !== "segwit" && (r = o), !r && !a)
+      throw new Error("Unknown error finalizing input");
+    r && (e.finalScriptSig = r), a && (e.finalScriptWitness = a), ct(e);
+  }
+  finalize() {
+    for (let t = 0; t < this.inputs.length; t++)
+      this.finalizeIdx(t);
+  }
+  extract() {
+    if (!this.isFinal)
+      throw new Error("Transaction has unfinalized inputs");
+    if (!this.outputs.length)
+      throw new Error("Transaction has no outputs");
+    if (this.fee < 0n)
+      throw new Error("Outputs spends more than inputs amount");
+    return this.toBytes(!0, !0);
+  }
+  combine(t) {
+    for (const o of ["PSBTVersion", "version", "lockTime"])
+      if (this.opts[o] !== t.opts[o])
+        throw new Error(`Transaction/combine: different ${o} this=${this.opts[o]} other=${t.opts[o]}`);
+    for (const o of ["inputs", "outputs"])
+      if (this[o].length !== t[o].length)
+        throw new Error(`Transaction/combine: different ${o} length this=${this[o].length} other=${t[o].length}`);
+    const e = this.global.unsignedTx ? M.encode(this.global.unsignedTx) : k, i = t.global.unsignedTx ? M.encode(t.global.unsignedTx) : k;
+    if (!L(e, i))
+      throw new Error("Transaction/combine: different unsigned tx");
+    this.global = dt(St, this.global, t.global, void 0, this.opts.allowUnknown);
+    for (let o = 0; o < this.inputs.length; o++)
+      this.updateInput(o, t.inputs[o], !0);
+    for (let o = 0; o < this.outputs.length; o++)
+      this.updateOutput(o, t.outputs[o], !0);
+    return this;
+  }
+  clone() {
+    return Q.fromPSBT(this.toPSBT(this.opts.PSBTVersion), this.opts);
+  }
+}
+export {
+  Q as T
+};
+//# sourceMappingURL=transaction-CiLOYSE_.mjs.map