@bestinslot/wallet-kit 0.7.0

package/dist/react.js

@@ -0,0 +1,14 @@
+import { useSyncExternalStore as u, useCallback as r, useState as i } from "react";
+import { w as c, d as t, i as l, h as n } from "./mint-BXVHw4CQ.js";
+function m() {
+  const e = u(c, t, t), s = r((o) => l(o), []);
+  return [e, s];
+}
+function S() {
+  const e = u(c, t, t), [s, o] = i(() => n() ?? null), a = r(() => o(n() ?? null), []), k = r((w) => l(w), []);
+  return { session: s, network: e, setNetwork: k, refresh: a };
+}
+export {
+  m as useNetwork,
+  S as useWallet
+};

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

@@ -0,0 +1,499 @@
+import { x as l, y as x, z as k, d, A as B, B as p, f as S, C as P, D as T } from "./mint-BXVHw4CQ.js";
+async function X() {
+  if (!window.LeatherProvider)
+    throw new Error("Leather extension not found.");
+  const n = await window.LeatherProvider.request("getAddresses");
+  if (!n)
+    throw new Error("Failed to get wallets.");
+  return n.result.addresses.map((t) => ({
+    address: t.address,
+    pubkey: t.publicKey || null,
+    purpose: t.type === "p2wpkh" ? "payment" : t.type === "p2tr" ? "ordinals" : "stx"
+  }));
+}
+async function $(n, e) {
+  if (!window.LeatherProvider)
+    throw new Error("Leather extension not found.");
+  if (!e)
+    throw new Error("Wallet type is required for signing messages with Leather.");
+  try {
+    const t = await window.LeatherProvider.request("signMessage", {
+      message: n,
+      paymentType: e === "ordinals" ? "p2tr" : "p2wpkh",
+      network: d()
+    });
+    return p.from(t.result.signature, "base64").toString("hex");
+  } catch (t) {
+    throw new Error(`Failed to sign message: ${t.message}`);
+  }
+}
+async function F(n) {
+  if (!window.LeatherProvider)
+    throw new Error("Leather extension not found.");
+  try {
+    const e = await window.LeatherProvider.request("signMessage", {
+      message: n,
+      paymentType: "p2wpkh",
+      network: d()
+    });
+    return {
+      signature: p.from(e.result.signature, "base64").toString("hex"),
+      address: e.result.address
+    };
+  } catch (e) {
+    throw new Error(`Failed to sign message: ${e.message}`);
+  }
+}
+async function L(n, e) {
+  if (!window.LeatherProvider)
+    throw new Error("Leather extension not found.");
+  try {
+    return (await window.LeatherProvider.request("sendTransfer", {
+      recipients: [
+        {
+          address: e,
+          amount: n.toString()
+        }
+      ],
+      network: d()
+    })).result.txid;
+  } catch (t) {
+    throw new Error(`Failed to send BTC: ${t.message}`);
+  }
+}
+async function M(n, e, t) {
+  if (!window.LeatherProvider)
+    throw new Error("Leather extension not found.");
+  const s = [];
+  for (let i = 0; i < t.length; i++)
+    for (let r = 0; r < t[i].signingIndexes.length; r++)
+      s.push(t[i].signingIndexes[r]);
+  return (await window.LeatherProvider.request("signPsbt", {
+    hex: B(n),
+    network: d(),
+    broadcast: e,
+    signAtIndex: s
+  })).result?.hex ?? "";
+}
+async function C(n, e, t, s, o, i) {
+  const r = l.Psbt.fromHex(n), a = [];
+  for (let w = 0; w < r.inputCount; w++)
+    i && i.includes(w) || s.includes(w) || a.push(w);
+  const c = await M(x(n), !1, [
+    {
+      address: e,
+      signingIndexes: a,
+      sigHash: l.Transaction.SIGHASH_DEFAULT
+    },
+    {
+      address: t,
+      signingIndexes: s,
+      sigHash: l.Transaction.SIGHASH_DEFAULT
+    }
+  ]), g = l.Psbt.fromHex(c);
+  k(g, i);
+  const u = g.extractTransaction(), f = u.toHex();
+  return {
+    txId: u.getId(),
+    signedTxHex: f
+  };
+}
+const I = {
+  getWallets: X,
+  signMessage: $,
+  signMessageDeterministic: F,
+  sendBTC: L,
+  signPSBT: M,
+  sign: C
+};
+async function K() {
+  if (!window.okxwallet)
+    throw new Error("OKX extension not found.");
+  const n = d();
+  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"
+    }
+  ];
+}
+async function U(n) {
+  if (!window.okxwallet)
+    throw new Error("OKX extension not found.");
+  const e = d();
+  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 p.from(t, "base64").toString("hex");
+}
+async function D(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 = d();
+  let o;
+  if (s === "mainnet")
+    o = await window.okxwallet.bitcoin.signMessage(n, "ecdsa");
+  else if (s === "testnet")
+    o = await window.okxwallet.bitcoinTestnet.signMessage(n, "ecdsa");
+  else if (s === "signet")
+    o = await window.okxwallet.bitcoinSignet.signMessage(n, "ecdsa");
+  else throw new Error("Unsupported network for OKX.");
+  return {
+    signature: p.from(o, "base64").toString("hex"),
+    address: t
+  };
+}
+async function q(n, e) {
+  if (!window.okxwallet)
+    throw new Error("OKX extension not found.");
+  const t = d();
+  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 E(n, e, t) {
+  const s = B(n);
+  let o = null;
+  if (t.length !== 0) {
+    const i = [];
+    for (const r of t)
+      for (let a = 0; a < r.signingIndexes.length; a++)
+        i.push({
+          address: r.address,
+          index: r.signingIndexes[a]
+          // disableTweakSigner: i == 0 ? true : false // TODO: remove this hack!!
+        });
+    o = {
+      autoFinalized: !0,
+      toSignInputs: i
+    };
+  }
+  if (d() === "mainnet") {
+    let i = null;
+    return o ? i = await window.okxwallet.bitcoin.signPsbt(s, o) : i = await window.okxwallet.bitcoin.signPsbt(s), e && await window.okxwallet.bitcoin.pushPsbt(i), i;
+  } else if (d() === "testnet") {
+    if (e)
+      throw new Error("Cannot broadcast on testnet with okx");
+    let i = null;
+    return o ? i = await window.okxwallet.bitcoinTestnet.signPsbt(s, o) : i = await window.okxwallet.bitcoinTestnet.signPsbt(s), i;
+  } else if (d() === "signet") {
+    if (e)
+      throw new Error("Cannot broadcast on signet with okx");
+    let i = null;
+    return o ? i = await window.okxwallet.bitcoinSignet.signPsbt(s, o) : i = await window.okxwallet.bitcoinSignet.signPsbt(s), i;
+  } else
+    throw new Error("Unsupported network for OKX.");
+}
+async function N(n, e, t, s, o, i) {
+  let r = null;
+  if (!e)
+    r = await E(x(n), !1, []);
+  else {
+    const u = l.Psbt.fromHex(n), f = [];
+    for (let w = 0; w < u.inputCount; w++)
+      i && i.includes(w) || s.includes(w) || f.push(w);
+    r = await E(x(n), !1, [
+      {
+        address: e,
+        signingIndexes: f
+      },
+      {
+        address: t,
+        signingIndexes: s
+      }
+    ]);
+  }
+  const a = l.Psbt.fromHex(r);
+  k(a, i);
+  const c = a.extractTransaction(), g = c.toHex();
+  return {
+    txId: c.getId(),
+    signedTxHex: g
+  };
+}
+const O = {
+  getWallets: K,
+  signMessage: U,
+  signMessageDeterministic: D,
+  sendBTC: q,
+  signPSBT: E,
+  sign: N
+};
+async function b() {
+  if (!window.unisat)
+    throw new Error("UniSat not found.");
+  const n = await window.unisat.getNetwork(), e = d();
+  n !== "livenet" && e === "mainnet" ? await window.unisat.switchNetwork("livenet") : n === "livenet" && (e === "testnet" || e === "signet") && await window.unisat.switchNetwork("testnet");
+}
+async function W() {
+  await b();
+  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 A(n) {
+  await b();
+  try {
+    const e = await window.unisat.signMessage(n, "bip322-simple");
+    return p.from(e, "base64").toString("hex");
+  } catch (e) {
+    throw console.error("Failed to sign message", e), new Error("Failed to sign message.");
+  }
+}
+async function _(n) {
+  await b();
+  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: p.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 z(n, e) {
+  await b();
+  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 v(n, e, t) {
+  if (await b(), !window.unisat)
+    throw new Error("UniSat not found.");
+  const s = B(n);
+  let o = null;
+  if (t.length === 0)
+    o = await window.unisat.signPsbt(s);
+  else {
+    const i = [];
+    for (const a of t)
+      for (let c = 0; c < a.signingIndexes.length; c++)
+        i.push({
+          address: a.address,
+          index: a.signingIndexes[c],
+          useTweakedSigner: a.useTweakedSigner ? a.useTweakedSigner[c] : void 0
+        });
+    const r = {
+      autoFinalized: !0,
+      toSignInputs: i
+    };
+    o = await window.unisat.signPsbt(s, r);
+  }
+  return e && (o = await window.unisat.pushPsbt(o)), o;
+}
+async function G(n, e, t, s, o, i) {
+  let r = null;
+  if (!e)
+    r = await v(x(n), !1, []);
+  else {
+    const u = l.Psbt.fromHex(n), f = [], w = [], y = [];
+    for (let h = 0; h < u.inputCount; h++)
+      if (!(i && i.includes(h))) {
+        if (s.includes(h)) {
+          o && o.includes(h) ? y.push(!0) : o && y.push(!1);
+          continue;
+        }
+        f.push(h), o && o.includes(h) ? w.push(!0) : o && w.push(!1);
+      }
+    r = await v(x(n), !1, [
+      {
+        address: e,
+        signingIndexes: f,
+        useTweakedSigner: w
+      },
+      {
+        address: t,
+        signingIndexes: s,
+        useTweakedSigner: y
+      }
+    ]);
+  }
+  const a = l.Psbt.fromHex(r);
+  k(a, i);
+  const c = a.extractTransaction(), g = c.toHex();
+  return {
+    txId: c.getId(),
+    signedTxHex: g
+  };
+}
+const R = {
+  checkNetwork: b,
+  getWallets: W,
+  signMessage: A,
+  signMessageDeterministic: _,
+  sendBTC: z,
+  signPSBT: v,
+  sign: G
+};
+function m() {
+  const n = d();
+  if (n === "mainnet")
+    return "Mainnet";
+  if (n === "testnet")
+    return "Testnet4";
+  if (n === "signet")
+    return "Signet";
+  throw new Error("Unknown BTC network type.");
+}
+async function j() {
+  if (!window.XverseProviders?.BitcoinProvider)
+    throw new Error("Xverse extension not found.");
+  const n = P({
+    purposes: ["ordinals", "payment"],
+    message: "[Best in Slot] wants to know your addresses!",
+    network: {
+      type: m()
+    }
+  }), 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 V(n, e) {
+  if (!window.XverseProviders?.BitcoinProvider)
+    throw new Error("Xverse extension not found.");
+  const t = P({
+    address: e,
+    message: n,
+    protocol: "BIP322",
+    network: {
+      type: m()
+    }
+  }), s = await window.XverseProviders.BitcoinProvider.signMessage(t).catch(
+    (o) => {
+      throw console.error("Failed to sign message.", o), new Error("Failed to sign message.");
+    }
+  );
+  return p.from(s, "base64").toString("hex");
+}
+async function J(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 = P({
+    address: t,
+    message: n,
+    protocol: "ECDSA",
+    network: {
+      type: m()
+    }
+  }), o = await window.XverseProviders.BitcoinProvider.signMessage(s).catch(
+    (i) => {
+      throw console.error("Failed to sign message.", i), new Error("Failed to sign message.");
+    }
+  );
+  return {
+    signature: p.from(o, "base64").toString("hex"),
+    address: t
+  };
+}
+async function Q(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 H(n, e, t, s) {
+  if (!window.XverseProviders?.BitcoinProvider)
+    throw new Error("Xverse extension not found.");
+  const o = P({
+    network: {
+      type: m()
+    },
+    message: s || "Sign Transaction",
+    psbtBase64: n,
+    broadcast: e,
+    inputsToSign: t
+  });
+  return await window.XverseProviders.BitcoinProvider.signTransaction(o);
+}
+async function Y(n, e, t, s, o, i) {
+  const r = l.Psbt.fromHex(n), a = [];
+  for (let w = 0; w < r.inputCount; w++)
+    i && i.includes(w) || s.includes(w) || a.push(w);
+  const c = await H(
+    x(n),
+    !1,
+    [
+      {
+        address: e,
+        signingIndexes: a,
+        sigHash: l.Transaction.SIGHASH_DEFAULT
+      },
+      {
+        address: t,
+        signingIndexes: s,
+        sigHash: l.Transaction.SIGHASH_DEFAULT
+      }
+    ],
+    "sign this pls"
+  ), g = l.Psbt.fromBase64(c.psbtBase64);
+  k(g, i);
+  const u = g.extractTransaction(), f = u.toHex();
+  return {
+    txId: u.getId(),
+    signedTxHex: f
+  };
+}
+const Z = {
+  getWallets: j,
+  signMessage: V,
+  signMessageDeterministic: J,
+  sendBTC: Q,
+  signPSBT: H,
+  sign: Y
+};
+T("leather", I);
+T("okx", O);
+T("unisat", R);
+T("xverse", Z);

package/dist/types/adapters/react/use-network.d.ts

@@ -0,0 +1,8 @@
+import { BISNetwork } from '../../types/common';
+/**
+ * React adapter: subscribes to the framework-agnostic network store. Returns the
+ * current network and a setter, mirroring the Vue `useNetwork()` composable.
+ *
+ * @returns A `[network, setNetwork]` tuple.
+ */
+export declare function useNetwork(): [BISNetwork, (network: BISNetwork) => void];

package/dist/types/adapters/react/use-wallet.d.ts

@@ -0,0 +1,15 @@
+import { BISNetwork, BISSession } from '../../types/common';
+/**
+ * React adapter: convenience hook bundling the connected session and the
+ * reactive network. `session` is read on mount and refreshable via `refresh()`
+ * (call it after your own connect flow resolves).
+ *
+ * @returns The current session (or null), the reactive network, a network
+ * setter, and a `refresh` to re-read the stored session.
+ */
+export declare function useWallet(): {
+    session: BISSession | null;
+    network: BISNetwork;
+    setNetwork: (network: BISNetwork) => void;
+    refresh: () => void;
+};

package/dist/types/adapters/vue/use-network.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { BISNetwork } from '../../types/common';
+/**
+ * Browser/Vue-only adapter: a reactive ref two-way synced to the framework-agnostic
+ * network store in `./store-network`. Reading reflects the current network; writing
+ * (e.g. via `v-model`) updates the shared store and every other consumer.
+ *
+ * Not part of the server build — it imports Vue.
+ *
+ * @returns A reactive ref to the current network.
+ */
+export declare function useNetwork(): Ref<BISNetwork>;

package/dist/types/api/balances.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Interface representing the balance information for a base BRC-20 token, including the available balance, transferrable balance, decimals, and ticker.
+ * The balances are represented in 18 decimals as per the BRC-20 standard, and the decimals field indicates the actual number of decimals for the token. The ticker field provides the symbol for the token.
+ *
+ * The availableBalanceIn18Decimals and transferrableBalanceIn18Decimals fields are returned as strings from the API and converted to bigint in the checkBaseBRC20BalanceOfAddress function for easier handling of large numbers. The decimals field is used to determine how to convert the 18-decimal balances to the actual token balance based on the token's specific decimal places. The ticker field is used for display purposes to show the token symbol alongside the balance information.
+ *
+ * availableBalanceIn18Decimals: The total balance of the specified BRC-20 token that is available in the Bitcoin address, represented in 18 decimals as per the BRC-20 standard. This balance includes all tokens that are currently held in the address, regardless of whether they are transferrable or not.
+ * transferrableBalanceIn18Decimals: The portion of the available balance that is currently transferrable, represented in 18 decimals. This balance indicates how many tokens can be transferred from the address at the current time, taking into account any restrictions or locks on the tokens.
+ * decimals: The number of decimal places that the specific BRC-20 token uses. This field is important for converting the 18-decimal balances to the actual token balance, as different tokens may have different decimal places.
+ * ticker: The symbol or abbreviation for the BRC-20 token, used for display purposes to identify the token alongside its balance information.
+ */
+export interface BaseBRC20Balance {
+    availableBalanceIn18Decimals: bigint;
+    transferrableBalanceIn18Decimals: bigint;
+    decimals: number;
+    ticker: string;
+}
+/**
+ * Checks the base BRC-20 token balance for a given Bitcoin address and token address by making an API call to the swap backend.
+ *
+ * @param btcAddress The Bitcoin address to check the BRC-20 balance for.
+ * @param tokenAddress The address of the BRC-20 token to check the balance for.
+ *
+ * @returns {Promise<BaseBRC20Balance>} A promise that resolves to an object containing the available balance, transferrable balance, decimals, and ticker for the specified Bitcoin address and BRC-20 token address. The balances are returned as strings from the API and converted to bigint in this function.
+ */
+export declare function getBaseBRC20BalanceOfAddress(btcAddress: string, tokenAddress: string): Promise<BaseBRC20Balance>;
+/**
+ * Checks the BRC2.0 token balance for a given Bitcoin address and token address by making an API call to the swap backend. This function is used for checking the balance of BRC-20 tokens that are not based on the base BRC-20 standard, and it returns the balance as a single bigint value representing the total balance in 18 decimals.
+ *
+ * @param bitcoinAddress The Bitcoin address to check the BRC-20 balance for.
+ * @param tokenAddress The address of the BRC-20 token to check the balance for.
+ *
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the total balance in 18 decimals for the specified Bitcoin address and BRC-20 token address.
+ */
+export declare function getBRC20ProgBalanceOfAddress(bitcoinAddress: string, tokenAddress: string): Promise<bigint>;
+/**
+ * Checks the BRC2.0 token balance for a given Bitcoin address and ticker by making an API call to the swap backend. This function is used for checking the balance of BRC-20 tokens that are not based on the base BRC-20 standard, and it returns the balance as a single bigint value representing the total balance in 18 decimals.
+ *
+ * @param bitcoinAddress The Bitcoin address to check the BRC-20 balance for.
+ * @param ticker The ticker of the BRC-20 token to check the balance for.
+ *
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the total balance in 18 decimals for the specified Bitcoin address and BRC-20 token.
+ */
+export declare function getBRC20ProgBalanceOfTicker(bitcoinAddress: string, ticker: string): Promise<bigint>;
+/**
+ * Get token address of a ticker in BRC2.0 by making an API call to the public RPC.
+ *
+ * @param ticker The ticker of the BRC-20 token.
+ *
+ * @returns {Promise<string>} A promise that resolves to a string representing the token address of the specified ticker.
+ */
+export declare function getBRC20ProgTokenAddressOfTicker(ticker: string): Promise<string>;