@bestinslot/wallet-kit 0.14.3 → 0.15.0-rc.1

package/dist/register-browser-providers-DxplsCV5.js

@@ -0,0 +1,810 @@
+import { M as f, L as K, h as S, N, O as gn, P as fn, Q as pn, R as hn, f as bn, J as b, K as C, U as G, e as h, I as H, Z as L, _ as v, X as B } from "./helpers-BvhfqxFB.js";
+import { d as xn, r as yn } from "./balances-CcnzsQly.js";
+const W = "[Best in Slot] wants to know your public key.";
+function _(n) {
+  return f.from(n).toString("hex");
+}
+function mn(n, e) {
+  const t = G();
+  return e.toLowerCase().startsWith(t.bech32) ? b.payments.p2wpkh({ pubkey: n, network: t }).address : b.payments.p2pkh({ pubkey: n, network: t }).address;
+}
+function Pn(n, e, t) {
+  const s = [], i = f.from(e);
+  if (i.length === 65) {
+    const r = i[0] - 27, d = r & 3, a = r >= 4, p = xn.magicHash(n, G().messagePrefix), m = yn(p, i.subarray(1), d, a);
+    m && s.push(f.from(m));
+  } else {
+    let r = 0;
+    const d = i[r++] ?? 0;
+    for (let a = 0; a < d && r < i.length; a++) {
+      const p = i[r++] ?? 0;
+      s.push(i.subarray(r, r + p)), r += p;
+    }
+  }
+  const o = s.find(
+    (r) => r.length === 33 && mn(r, t) === t
+  );
+  return o ? o.toString("hex") : null;
+}
+function Tn(n) {
+  const { unsignedPsbtHex: e, paymentAddr: t, ordAddr: s, ordAddrIdxes: i, noSignIdxes: o } = n, r = b.Psbt.fromHex(e), d = [];
+  for (let a = 0; a < r.inputCount; a++)
+    o?.includes(a) || i.includes(a) || d.push(a);
+  return t === s ? [{ address: t, signingIndexes: [...d, ...i] }] : [
+    { address: t, signingIndexes: d },
+    { address: s, signingIndexes: i }
+  ].filter((a) => a.signingIndexes.length > 0);
+}
+function U(n, e) {
+  const t = b.Psbt.fromBuffer(f.from(n));
+  C(t, e);
+  const s = t.extractTransaction();
+  return { txId: s.getId(), signedTxHex: s.toHex() };
+}
+function z(n, e) {
+  const t = () => {
+    const c = e();
+    if (!c) throw new Error(`${n} is not installed.`);
+    return c;
+  }, s = async (c, l) => {
+    try {
+      const u = await t().signMessage(
+        c,
+        new TextEncoder().encode(l)
+      );
+      return _(u);
+    } catch (u) {
+      throw console.error("Failed to sign message", u), new Error("Failed to sign message.");
+    }
+  }, i = async () => {
+    const c = t(), l = await c.connect(), u = l.find((g) => g.purpose === "payment");
+    if (!u) throw new Error(`${n} returned no payment address.`);
+    const w = l.find((g) => g.purpose === "ordinals"), x = async (g) => {
+      if (g.publicKey) return g.publicKey;
+      const y = await c.signMessage(
+        g.address,
+        new TextEncoder().encode(W)
+      ), M = Pn(W, y, g.address);
+      if (!M) throw new Error(`Could not read the public key of ${g.address}.`);
+      return M;
+    };
+    return !w || w.address === u.address ? [{ address: u.address, pubkey: await x(u), purpose: "all" }] : [
+      { address: u.address, pubkey: await x(u), purpose: "payment" },
+      { address: w.address, pubkey: await x(w), purpose: "ordinals" }
+    ];
+  }, o = async (c, l, u) => {
+    const w = u || (l === "ordinals" ? bn() : S())?.address;
+    if (!w) throw new Error("No wallet address to sign with.");
+    return s(w, c);
+  }, r = async (c) => {
+    const l = S()?.address;
+    if (!l) throw new Error("No payment wallet found.");
+    return { signature: await s(l, c), address: l };
+  }, d = async (c, l, u) => {
+    const [w] = await t().signPsbts([
+      {
+        psbt: f.from(c, "base64"),
+        inputs: u.map((y) => ({
+          address: y.address,
+          signingIndexes: y.signingIndexes
+        }))
+      }
+    ]);
+    if (!w) throw new Error(`${n} returned no signed PSBT.`);
+    if (!l) return _(w);
+    const { txId: x, signedTxHex: g } = U(w);
+    if (await K([g]) == null) throw new Error("Failed to broadcast.");
+    return x;
+  }, a = async (c) => {
+    const l = await t().signPsbts(
+      c.map((u) => ({
+        psbt: f.from(u.unsignedPsbtHex, "hex"),
+        inputs: Tn(u)
+      }))
+    );
+    if (l.length !== c.length)
+      throw new Error(`${n} returned the wrong PSBT count.`);
+    return l.map((u, w) => U(u, c[w].noSignIdxes));
+  }, p = async (c, l, u, w, x, g) => {
+    const [y] = await a([
+      { unsignedPsbtHex: c, paymentAddr: l, ordAddr: u, ordAddrIdxes: w, useTweakSignerIdxes: x, noSignIdxes: g }
+    ]);
+    return y;
+  };
+  return {
+    getWallets: i,
+    getAccounts: async () => e()?.accounts() ?? [],
+    onAccountsChanged: (c) => e()?.onAccountsChanged(c) ?? (() => {
+    }),
+    signMessage: o,
+    signMessageDeterministic: r,
+    sendBTC: async (c, l, u) => {
+      if (!Number.isInteger(c) || c <= 0)
+        throw new Error("amountSats must be a positive integer (satoshis).");
+      if (u == null || !Number.isFinite(u) || u <= 0)
+        throw new Error(`feeRate (sat/vB) must be a positive number for ${n}.`);
+      const w = S();
+      if (!w) throw new Error("No payment wallet found.");
+      const x = new N(!1, null, w.address, null, w.pubkey), g = new N(!1, null, l, null, null), y = await gn(w.address), M = fn(
+        y,
+        [],
+        x,
+        [],
+        g,
+        x,
+        u,
+        c
+      ), ln = await pn(M.tx, y, x, []), X = await p(ln.toHex(), w.address, w.address, []), F = await hn([X.signedTxHex]);
+      if (F == null) throw new Error("Send BTC validation failed (testmempoolaccept failed).");
+      for (const O of F)
+        if (!O.allowed) throw new Error(O["reject-reason"]);
+      if (await K([X.signedTxHex]) == null)
+        throw new Error("Failed to broadcast transaction.");
+      return X.txId;
+    },
+    signPSBT: d,
+    sign: p,
+    getSignMany: () => e()?.signsManyAtOnce ? a : null
+  };
+}
+var Sn = function(n, e, t, s) {
+  if (t === "a" && !s) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof e == "function" ? n !== e || !s : !e.has(n)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return t === "m" ? s : t === "a" ? s.call(n) : s ? s.value : e.get(n);
+}, kn = function(n, e, t, s, i) {
+  if (s === "m") throw new TypeError("Private method is not writable");
+  if (s === "a" && !i) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof e == "function" ? n !== e || !i : !e.has(n)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return s === "a" ? i.call(n, t) : i ? i.value = t : e.set(n, t), t;
+}, A;
+let k;
+const $ = /* @__PURE__ */ new Set();
+function En(n) {
+  E = void 0, $.add(n);
+}
+function vn(n) {
+  E = void 0, $.delete(n);
+}
+const T = {};
+function Bn() {
+  if (k || (k = Object.freeze({ register: D, get: In, on: Mn }), typeof window > "u"))
+    return k;
+  const n = Object.freeze({ register: D });
+  try {
+    window.addEventListener("wallet-standard:register-wallet", ({ detail: e }) => e(n));
+  } catch (e) {
+    console.error(`wallet-standard:register-wallet event listener could not be added
+`, e);
+  }
+  try {
+    window.dispatchEvent(new An(n));
+  } catch (e) {
+    console.error(`wallet-standard:app-ready event could not be dispatched
+`, e);
+  }
+  return k;
+}
+function D(...n) {
+  return n = n.filter((e) => !$.has(e)), n.length ? (n.forEach((e) => En(e)), T.register?.forEach((e) => R(() => e(...n))), function() {
+    n.forEach((t) => vn(t)), T.unregister?.forEach((t) => R(() => t(...n)));
+  }) : () => {
+  };
+}
+let E;
+function In() {
+  return E || (E = [...$]), E;
+}
+function Mn(n, e) {
+  return T[n]?.push(e) || (T[n] = [e]), function() {
+    T[n] = T[n]?.filter((s) => e !== s);
+  };
+}
+function R(n) {
+  try {
+    n();
+  } catch (e) {
+    console.error(e);
+  }
+}
+class An extends Event {
+  get detail() {
+    return Sn(this, A, "f");
+  }
+  get type() {
+    return "wallet-standard:app-ready";
+  }
+  constructor(e) {
+    super("wallet-standard:app-ready", {
+      bubbles: !1,
+      cancelable: !1,
+      composed: !1
+    }), A.set(this, void 0), kn(this, A, e, "f");
+  }
+  /** @deprecated */
+  preventDefault() {
+    throw new Error("preventDefault cannot be called");
+  }
+  /** @deprecated */
+  stopImmediatePropagation() {
+    throw new Error("stopImmediatePropagation cannot be called");
+  }
+  /** @deprecated */
+  stopPropagation() {
+    throw new Error("stopPropagation cannot be called");
+  }
+}
+A = /* @__PURE__ */ new WeakMap();
+const V = "bitcoin:connect", J = "bitcoin:signTransaction", Q = "bitcoin:signMessage", Cn = ["bitcoin:events", "standard:events"];
+let j;
+function Y(n) {
+  return typeof window > "u" ? null : (j ??= Bn(), j.get().find(
+    (e) => n.test(e.name) && V in e.features && J in e.features && Q in e.features
+  ) ?? null);
+}
+function Hn(n) {
+  return n.length === 33 || n.length === 32 ? f.from(Array.from(n)).toString("hex") : null;
+}
+function Z(n) {
+  const e = (r) => n.features[r], t = () => `bitcoin:${h()}`, s = (r) => {
+    const d = n.accounts.find((a) => a.address === r);
+    if (!d) throw new Error(`${n.name} has no connected account ${r}.`);
+    return d;
+  }, i = async () => {
+    if (!n.chains.includes(t()))
+      throw new Error(`${n.name} does not support Bitcoin ${h()}.`);
+    const { accounts: r } = await e(V).connect({
+      purposes: ["payment", "ordinals"]
+    });
+    return r.slice(0, 2).map((d, a) => ({
+      address: d.address,
+      publicKey: Hn(d.publicKey),
+      purpose: a === 0 ? "payment" : "ordinals"
+    }));
+  }, o = Cn.map((r) => n.features[r]).find(
+    Boolean
+  );
+  return {
+    connect: i,
+    accounts: () => n.accounts.map((r) => r.address),
+    onAccountsChanged: (r) => o?.on("change", ({ accounts: d }) => {
+      d && r(d.map((a) => a.address));
+    }) ?? (() => {
+    }),
+    signMessage: async (r, d) => {
+      const [a] = await e(Q).signMessage({
+        account: s(r),
+        message: d
+      });
+      if (!a) throw new Error(`${n.name} returned no signature.`);
+      return a.signature;
+    },
+    signPsbts: async (r) => (await e(J).signTransaction(
+      ...r.map((a) => ({
+        psbt: a.psbt,
+        inputsToSign: a.inputs.map((p) => ({
+          account: s(p.address),
+          signingIndexes: p.signingIndexes
+        })),
+        chain: t()
+      }))
+    )).map((a) => a.signedPsbt),
+    signsManyAtOnce: !0
+  };
+}
+const $n = z("MetaMask", () => {
+  const n = Y(/metamask/i);
+  return n ? Z(n) : null;
+});
+async function Xn() {
+  if (!window.okxwallet) throw new Error("OKX extension not found.");
+  const n = h();
+  let e;
+  if (n === "mainnet") e = await window.okxwallet.bitcoin.connect();
+  else if (n === "testnet") e = await window.okxwallet.bitcoinTestnet.connect();
+  else if (n === "signet") e = await window.okxwallet.bitcoinSignet.connect();
+  else throw new Error("Unsupported network for OKX.");
+  if (!e) throw new Error("Error fetching wallet data.");
+  return [
+    {
+      address: e.address,
+      pubkey: e.publicKey,
+      purpose: "all"
+    }
+  ];
+}
+function q() {
+  const n = h();
+  if (n === "mainnet") return window.okxwallet?.bitcoin;
+  if (n === "testnet") return window.okxwallet?.bitcoinTestnet;
+  if (n === "signet") return window.okxwallet?.bitcoinSignet;
+}
+async function Fn() {
+  const n = q();
+  return typeof n?.getAccounts != "function" ? [] : await n.getAccounts() ?? [];
+}
+function On(n) {
+  const e = q();
+  if (typeof e?.on != "function") return () => {
+  };
+  const t = (s) => n(s?.address ? [s.address] : []);
+  return e.on("accountChanged", t), () => e.removeListener?.("accountChanged", t);
+}
+async function Kn(n) {
+  if (!window.okxwallet) throw new Error("OKX extension not found.");
+  const e = h();
+  let t;
+  if (e === "mainnet")
+    t = await window.okxwallet.bitcoin.signMessage(n, "bip322-simple");
+  else if (e === "testnet")
+    t = await window.okxwallet.bitcoinTestnet.signMessage(n, "bip322-simple");
+  else if (e === "signet")
+    t = await window.okxwallet.bitcoinSignet.signMessage(n, "bip322-simple");
+  else throw new Error("Unsupported network for OKX.");
+  return f.from(t, "base64").toString("hex");
+}
+async function Nn(n) {
+  if (!window.okxwallet) throw new Error("OKX extension not found.");
+  const e = S();
+  if (!e) throw new Error("No payment wallet found.");
+  const t = e.address, s = h();
+  let i;
+  if (s === "mainnet")
+    i = await window.okxwallet.bitcoin.signMessage(n, "ecdsa");
+  else if (s === "testnet")
+    i = await window.okxwallet.bitcoinTestnet.signMessage(n, "ecdsa");
+  else if (s === "signet")
+    i = await window.okxwallet.bitcoinSignet.signMessage(n, "ecdsa");
+  else throw new Error("Unsupported network for OKX.");
+  return {
+    signature: f.from(i, "base64").toString("hex"),
+    address: t
+  };
+}
+async function Wn(n, e) {
+  if (!window.okxwallet) throw new Error("OKX extension not found.");
+  const t = h();
+  let s;
+  if (t === "mainnet")
+    s = await window.okxwallet.bitcoin.sendBitcoin(e, n);
+  else if (t === "testnet")
+    s = await window.okxwallet.bitcoinTestnet.sendBitcoin(e, n);
+  else if (t === "signet")
+    s = await window.okxwallet.bitcoinSignet.sendBitcoin(e, n);
+  else
+    throw new Error("Unsupported network for OKX.");
+  return s;
+}
+async function nn(n, e, t) {
+  const s = L(n);
+  let i = null;
+  if (t.length !== 0) {
+    const o = [];
+    for (const r of t)
+      for (let d = 0; d < r.signingIndexes.length; d++)
+        o.push({
+          address: r.address,
+          index: r.signingIndexes[d]
+          // disableTweakSigner: i == 0 ? true : false // TODO: remove this hack!!
+        });
+    i = {
+      autoFinalized: !0,
+      toSignInputs: o
+    };
+  }
+  if (h() === "mainnet") {
+    let o = null;
+    return i ? o = await window.okxwallet.bitcoin.signPsbt(s, i) : o = await window.okxwallet.bitcoin.signPsbt(s), e && await window.okxwallet.bitcoin.pushPsbt(o), o;
+  } else if (h() === "testnet") {
+    if (e)
+      throw new Error("Cannot broadcast on testnet with okx");
+    let o = null;
+    return i ? o = await window.okxwallet.bitcoinTestnet.signPsbt(s, i) : o = await window.okxwallet.bitcoinTestnet.signPsbt(s), o;
+  } else if (h() === "signet") {
+    if (e)
+      throw new Error("Cannot broadcast on signet with okx");
+    let o = null;
+    return i ? o = await window.okxwallet.bitcoinSignet.signPsbt(s, i) : o = await window.okxwallet.bitcoinSignet.signPsbt(s), o;
+  } else
+    throw new Error("Unsupported network for OKX.");
+}
+function en(n) {
+  const { unsignedPsbtHex: e, paymentAddr: t, ordAddr: s, ordAddrIdxes: i, noSignIdxes: o } = n;
+  if (!t) return [];
+  const r = b.Psbt.fromHex(e), d = [];
+  for (let a = 0; a < r.inputCount; a++)
+    o && o.includes(a) || i.includes(a) || d.push(a);
+  return [
+    { address: t, signingIndexes: d },
+    { address: s, signingIndexes: i }
+  ];
+}
+function tn(n, e) {
+  const t = b.Psbt.fromHex(n);
+  C(t, e);
+  const s = t.extractTransaction();
+  return { txId: s.getId(), signedTxHex: s.toHex() };
+}
+async function _n(n, e, t, s, i, o) {
+  const r = en({
+    unsignedPsbtHex: n,
+    paymentAddr: e,
+    ordAddr: t,
+    ordAddrIdxes: s,
+    noSignIdxes: o
+  }), d = await nn(H(n), !1, r);
+  return tn(d, o);
+}
+function sn() {
+  const n = h();
+  if (n === "mainnet") return window.okxwallet?.bitcoin;
+  if (n === "testnet") return window.okxwallet?.bitcoinTestnet;
+  if (n === "signet") return window.okxwallet?.bitcoinSignet;
+}
+async function Un(n) {
+  const e = sn();
+  if (typeof e?.signPsbts != "function")
+    throw new Error("OKX cannot sign several PSBTs at once.");
+  const t = await e.signPsbts(
+    n.map((s) => s.unsignedPsbtHex),
+    n.map((s) => {
+      const i = en(s).flatMap(
+        (o) => o.signingIndexes.map((r) => ({ address: o.address, index: r }))
+      );
+      return i.length > 0 ? { autoFinalized: !0, toSignInputs: i } : { autoFinalized: !0 };
+    })
+  );
+  if (t.length !== n.length) throw new Error("OKX returned the wrong PSBT count.");
+  return t.map((s, i) => tn(s, n[i].noSignIdxes));
+}
+function Dn() {
+  return typeof window < "u" && typeof sn()?.signPsbts == "function" ? Un : null;
+}
+const Rn = {
+  getWallets: Xn,
+  getAccounts: Fn,
+  onAccountsChanged: On,
+  signMessage: Kn,
+  signMessageDeterministic: Nn,
+  sendBTC: Wn,
+  signPSBT: nn,
+  sign: _n,
+  getSignMany: Dn
+};
+function jn(n) {
+  return typeof n != "string" ? n : /^[0-9a-f]+$/i.test(n) ? f.from(n, "hex") : f.from(n, "base64");
+}
+function Gn(n) {
+  let e = [];
+  return {
+    connect: async () => {
+      const t = await n.requestAccounts();
+      return e = t.map((s) => s.address), t.map((s) => ({
+        address: s.address,
+        publicKey: s.publicKey || null,
+        purpose: s.purpose
+      }));
+    },
+    accounts: () => e,
+    onAccountsChanged: (t) => {
+      if (!n.on) return () => {
+      };
+      const s = (i) => {
+        e = (i ?? []).map((o) => o.address), t(e);
+      };
+      return n.on("accountsChanged", s), () => n.removeListener?.("accountsChanged", s);
+    },
+    signMessage: async (t, s) => (await n.signMessage(t, s)).signature,
+    signPsbts: async (t) => {
+      const s = [];
+      for (const i of t)
+        s.push(jn(await n.signPSBT(i.psbt, { inputsToSign: i.inputs })));
+      return s;
+    },
+    signsManyAtOnce: !1
+  };
+}
+function Ln() {
+  const n = Y(/phantom/i);
+  if (n) return Z(n);
+  if (typeof window > "u") return null;
+  const e = window.phantom?.bitcoin;
+  return e?.isPhantom ? Gn(e) : null;
+}
+const zn = z("Phantom", Ln);
+async function P() {
+  if (!window.unisat) throw new Error("UniSat not found.");
+  const n = await window.unisat.getNetwork(), e = h();
+  n !== "livenet" && e === "mainnet" ? await window.unisat.switchNetwork("livenet") : n === "livenet" && (e === "testnet" || e === "signet") && await window.unisat.switchNetwork("testnet");
+}
+async function Vn() {
+  await P();
+  const n = await window.unisat?.requestAccounts(), e = await window.unisat?.getPublicKey();
+  if (!n) throw new Error("Failed to get wallets.");
+  return n.map((s) => ({
+    address: s,
+    pubkey: e,
+    purpose: "all"
+  }));
+}
+async function Jn() {
+  return typeof window.unisat?.getAccounts != "function" ? [] : await window.unisat.getAccounts() ?? [];
+}
+function Qn(n) {
+  const e = window.unisat;
+  if (!e?.on) return () => {
+  };
+  const t = (s) => n(s ?? []);
+  return e.on("accountsChanged", t), () => e.removeListener?.("accountsChanged", t);
+}
+async function Yn(n) {
+  await P();
+  try {
+    const e = await window.unisat.signMessage(n, "bip322-simple");
+    return f.from(e, "base64").toString("hex");
+  } catch (e) {
+    throw console.error("Failed to sign message", e), new Error("Failed to sign message.");
+  }
+}
+async function Zn(n) {
+  await P();
+  const e = S();
+  if (!e) throw new Error("No payment wallet found.");
+  const t = e.address;
+  try {
+    const s = await window.unisat.signMessage(n, "ecdsa");
+    return {
+      signature: f.from(s, "base64").toString("hex"),
+      address: t
+    };
+  } catch (s) {
+    throw console.error("Failed to sign message", s), new Error("Failed to sign message.");
+  }
+}
+async function qn(n, e) {
+  await P();
+  try {
+    return await window.unisat.sendBitcoin(e, n);
+  } catch (t) {
+    throw console.error("Failed to send BTC", t), new Error("Failed to send BTC.");
+  }
+}
+async function on(n, e, t) {
+  if (await P(), !window.unisat) throw new Error("UniSat not found.");
+  const s = L(n);
+  let i = null;
+  return t.length === 0 ? i = await window.unisat.signPsbt(s) : i = await window.unisat.signPsbt(s, rn(t)), e && (i = await window.unisat.pushPsbt(i)), i;
+}
+function rn(n) {
+  const e = [];
+  for (const t of n)
+    for (let s = 0; s < t.signingIndexes.length; s++)
+      e.push({
+        address: t.address,
+        index: t.signingIndexes[s],
+        useTweakedSigner: t.useTweakedSigner ? t.useTweakedSigner[s] : void 0
+      });
+  return { autoFinalized: !0, toSignInputs: e };
+}
+function an(n) {
+  const { unsignedPsbtHex: e, paymentAddr: t, ordAddr: s, ordAddrIdxes: i, useTweakSignerIdxes: o, noSignIdxes: r } = n;
+  if (!t) return [];
+  const d = b.Psbt.fromHex(e), a = [], p = [], m = [];
+  for (let c = 0; c < d.inputCount; c++)
+    if (!(r && r.includes(c))) {
+      if (i.includes(c)) {
+        o && o.includes(c) ? m.push(!0) : o && m.push(!1);
+        continue;
+      }
+      a.push(c), o && o.includes(c) ? p.push(!0) : o && p.push(!1);
+    }
+  return [
+    {
+      address: t,
+      signingIndexes: a,
+      useTweakedSigner: p
+    },
+    {
+      address: s,
+      signingIndexes: i,
+      useTweakedSigner: m
+    }
+  ];
+}
+function dn(n, e) {
+  const t = b.Psbt.fromHex(n);
+  C(t, e);
+  const s = t.extractTransaction();
+  return { txId: s.getId(), signedTxHex: s.toHex() };
+}
+async function ne(n, e, t, s, i, o) {
+  const r = an({
+    unsignedPsbtHex: n,
+    paymentAddr: e,
+    ordAddr: t,
+    ordAddrIdxes: s,
+    useTweakSignerIdxes: i,
+    noSignIdxes: o
+  }), d = await on(H(n), !1, r);
+  return dn(d, o);
+}
+async function ee(n) {
+  if (await P(), !window.unisat?.signPsbts) throw new Error("UniSat cannot sign several PSBTs at once.");
+  const e = await window.unisat.signPsbts(
+    n.map((t) => t.unsignedPsbtHex),
+    n.map((t) => rn(an(t)))
+  );
+  if (e.length !== n.length) throw new Error("UniSat returned the wrong PSBT count.");
+  return e.map((t, s) => dn(t, n[s].noSignIdxes));
+}
+function te() {
+  return typeof window < "u" && typeof window.unisat?.signPsbts == "function" ? ee : null;
+}
+const se = {
+  checkNetwork: P,
+  getWallets: Vn,
+  getAccounts: Jn,
+  onAccountsChanged: Qn,
+  signMessage: Yn,
+  signMessageDeterministic: Zn,
+  sendBTC: qn,
+  signPSBT: on,
+  sign: ne,
+  getSignMany: te
+};
+function I() {
+  const n = h();
+  if (n === "mainnet") return "Mainnet";
+  if (n === "testnet") return "Testnet4";
+  if (n === "signet") return "Signet";
+  throw new Error("Unknown BTC network type.");
+}
+async function ie() {
+  if (!window.XverseProviders?.BitcoinProvider) throw new Error("Xverse extension not found.");
+  const n = v({
+    purposes: ["ordinals", "payment"],
+    message: "[Best in Slot] wants to know your addresses!",
+    network: {
+      type: I()
+    }
+  }), e = await window.XverseProviders.BitcoinProvider?.connect(n);
+  if (!e) throw new Error("Error fetching wallet data.");
+  return e.addresses.map((s) => ({
+    address: s.address,
+    pubkey: s.publicKey,
+    purpose: s.purpose
+  }));
+}
+async function oe(n, e, t) {
+  if (!window.XverseProviders?.BitcoinProvider) throw new Error("Xverse extension not found.");
+  const s = v({
+    address: t,
+    message: n,
+    protocol: "BIP322",
+    network: {
+      type: I()
+    }
+  }), i = await window.XverseProviders.BitcoinProvider.signMessage(s).catch(
+    (o) => {
+      throw console.error("Failed to sign message.", o), new Error("Failed to sign message.");
+    }
+  );
+  return f.from(i, "base64").toString("hex");
+}
+async function re(n) {
+  if (!window.XverseProviders?.BitcoinProvider) throw new Error("Xverse extension not found.");
+  const e = S();
+  if (!e) throw new Error("No payment wallet found.");
+  const t = e.address, s = v({
+    address: t,
+    message: n,
+    protocol: "ECDSA",
+    network: {
+      type: I()
+    }
+  }), i = await window.XverseProviders.BitcoinProvider.signMessage(s).catch(
+    (o) => {
+      throw console.error("Failed to sign message.", o), new Error("Failed to sign message.");
+    }
+  );
+  return {
+    signature: f.from(i, "base64").toString("hex"),
+    address: t
+  };
+}
+async function ae(n, e) {
+  if (!window.XverseProviders?.BitcoinProvider) throw new Error("Xverse extension not found.");
+  return (await window.XverseProviders.BitcoinProvider.request("sendTransfer", {
+    recipients: [
+      {
+        address: e,
+        amount: n
+      }
+    ]
+  })).result.txid;
+}
+async function cn(n, e, t, s) {
+  if (!window.XverseProviders?.BitcoinProvider) throw new Error("Xverse extension not found.");
+  const i = v({
+    network: {
+      type: I()
+    },
+    message: s || "Sign Transaction",
+    psbtBase64: n,
+    broadcast: e,
+    inputsToSign: t
+  });
+  return await window.XverseProviders.BitcoinProvider.signTransaction(i);
+}
+function un(n) {
+  const { unsignedPsbtHex: e, paymentAddr: t, ordAddr: s, ordAddrIdxes: i, noSignIdxes: o } = n, r = b.Psbt.fromHex(e), d = [];
+  for (let a = 0; a < r.inputCount; a++)
+    o && o.includes(a) || i.includes(a) || d.push(a);
+  return [
+    {
+      address: t,
+      signingIndexes: d,
+      sigHash: b.Transaction.SIGHASH_DEFAULT
+    },
+    {
+      address: s,
+      signingIndexes: i,
+      sigHash: b.Transaction.SIGHASH_DEFAULT
+    }
+  ];
+}
+function wn(n, e) {
+  const t = b.Psbt.fromBase64(n);
+  C(t, e);
+  const s = t.extractTransaction();
+  return { txId: s.getId(), signedTxHex: s.toHex() };
+}
+async function de(n, e, t, s, i, o) {
+  const r = await cn(
+    H(n),
+    !1,
+    un({
+      unsignedPsbtHex: n,
+      paymentAddr: e,
+      ordAddr: t,
+      ordAddrIdxes: s,
+      noSignIdxes: o
+    }),
+    "sign this pls"
+  );
+  return wn(r.psbtBase64, o);
+}
+async function ce(n) {
+  const e = window.XverseProviders?.BitcoinProvider;
+  if (typeof e?.signMultipleTransactions != "function")
+    throw new Error("Xverse cannot sign several PSBTs at once.");
+  const t = v({
+    network: { type: I() },
+    message: "Sign Transactions",
+    psbts: n.map((i) => ({
+      psbtBase64: H(i.unsignedPsbtHex),
+      inputsToSign: un(i)
+    }))
+  }), s = await e.signMultipleTransactions(t);
+  if (s.length !== n.length) throw new Error("Xverse returned the wrong PSBT count.");
+  return s.map((i, o) => wn(i.psbtBase64, n[o].noSignIdxes));
+}
+function ue() {
+  return typeof window < "u" && typeof window.XverseProviders?.BitcoinProvider?.signMultipleTransactions == "function" ? ce : null;
+}
+const we = {
+  getWallets: ie,
+  signMessage: oe,
+  signMessageDeterministic: re,
+  sendBTC: ae,
+  signPSBT: cn,
+  sign: de,
+  getSignMany: ue
+};
+B("okx", Rn);
+B("unisat", se);
+B("xverse", we);
+B("phantom", zn);
+B("metamask", $n);
+export {
+  Y as f
+};