@bit-buccaneers/wallet-abstraction 0.0.9 → 0.0.11

package/dist/dev.js

@@ -1,6 +1,6 @@
 import { injected, metaMask, coinbaseWallet } from '@wagmi/connectors';
-import { createConfig, getConnectors, signMessage, disconnect, connect, watchConnections } from '@wagmi/core';
-import { http } from 'viem';
+import { createConfig, getConnectors, signMessage, disconnect, connect, watchConnections, switchChain as switchChain$1, sendTransaction as sendTransaction$1, waitForTransactionReceipt as waitForTransactionReceipt$1, readContract, writeContract } from '@wagmi/core';
+import { http, erc20Abi } from 'viem';
 import { mainnet } from 'viem/chains';
 import bs582 from 'bs58';
 import nacl from 'tweetnacl';
@@ -165,7 +165,6 @@ var WALLETS = [
 // src/lib/wallets/mappers.ts
 var EVM_WALLET_ID_MAP = {
   "app.phantom": "phantom",
-  "app.backpack": "backpack",
   "com.trustwallet.app": "trust",
   "com.binance.wallet": "binance",
   "com.bitget.web3": "bitget",
@@ -192,7 +191,7 @@ var WC_CHAINS = {
   SOLANA_MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
 };
 var WC_METHODS = {
-  EVM: ["eth_sendTransaction", "personal_sign", "eth_signTypedData"],
+  EVM: ["eth_sendTransaction", "personal_sign", "eth_signTypedData", "wallet_switchEthereumChain"],
   SOLANA: ["solana_signTransaction", "solana_signMessage"]
 };
 var WC_EVENTS = {
@@ -577,6 +576,54 @@ var requestWalletConnect = async (method, params, chainId) => {
   }
 };
 
+// src/lib/walletconnect/transactions.ts
+var toHex = (value) => `0x${value.toString(16)}`;
+var getWcChainId = (chainId) => `eip155:${chainId}`;
+var wcSwitchChain = async (chainId) => {
+  const session = getCurrentSession();
+  if (!session) throw new Error("No WalletConnect session");
+  await requestWalletConnect(
+    "wallet_switchEthereumChain",
+    [{ chainId: toHex(chainId) }],
+    getWcChainId(chainId)
+  );
+};
+var wcSendTransaction = async (params) => {
+  const session = getCurrentSession();
+  if (!session) throw new Error("No WalletConnect session");
+  const txParams = {
+    from: params.from,
+    to: params.to
+  };
+  if (params.value) {
+    txParams.value = params.value;
+  }
+  if (params.data) {
+    txParams.data = params.data;
+  }
+  const hash = await requestWalletConnect(
+    "eth_sendTransaction",
+    [txParams],
+    getWcChainId(params.chainId)
+  );
+  return { hash };
+};
+var getWcEvmAddress = () => {
+  const session = getCurrentSession();
+  if (!session) return null;
+  const account = session.namespaces.eip155?.accounts?.[0];
+  if (!account) return null;
+  return account.split(":")[2];
+};
+var getWcEvmChainId = () => {
+  const session = getCurrentSession();
+  if (!session) return null;
+  const account = session.namespaces.eip155?.accounts?.[0];
+  if (!account) return null;
+  const chainId = account.split(":")[1];
+  return chainId ? parseInt(chainId, 10) : null;
+};
+
 // src/lib/connectors/shared/walletconnect.ts
 var connectViaWalletConnect = async (wcConfig, parseSession, getDeeplink) => {
   let qrUri = null;
@@ -810,10 +857,12 @@ var createMetaMaskSolanaDappBrowserConnector = () => createDappBrowserSolanaConn
 // src/lib/connectors/solflare.ts
 var SOLFLARE_CONNECT_URL = "https://solflare.com/ul/v1/connect";
 var SOLFLARE_SIGN_MESSAGE_URL = "https://solflare.com/ul/v1/signMessage";
-var SOLFLARE_BROWSE_URL = "https://solflare.com/ul/v1/browse";
+var buildSolflareBrowseUrl = () => `https://solflare.com/ul/v1/browse/${encodeURIComponent(
+  window.location.href
+)}?ref=${encodeURIComponent(window.location.origin)}`;
 var createSolflareSolanaDappBrowserConnector = () => createDappBrowserSolanaConnector({
   walletId: "solflare",
-  browseUrl: SOLFLARE_BROWSE_URL,
+  buildUrl: buildSolflareBrowseUrl,
   injectedKey: "isSolflare"
 });
 var SOLFLARE_CONFIG = {
@@ -885,12 +934,12 @@ var TRUST_CONFIG = {
   wcDeeplink: "https://link.trustwallet.com/wc",
   injectedKey: "isTrust"
 };
-var TRUST_BROWSE_URL = "https://link.trustwallet.com/open_url";
+var buildTrustBrowseUrl = () => `https://link.trustwallet.com/open_url?url=${encodeURIComponent(window.location.href)}`;
 var createTrustEvmMobileConnector = () => createWcEvmConnector(TRUST_CONFIG);
 var createTrustSolanaMobileConnector = () => createWcSolanaConnector(TRUST_CONFIG);
 var createTrustSolanaDappBrowserConnector = () => createDappBrowserSolanaConnector({
   walletId: "trust",
-  browseUrl: TRUST_BROWSE_URL,
+  buildUrl: buildTrustBrowseUrl,
   injectedKey: "isTrust"
 });
 
@@ -908,14 +957,8 @@ var EXODUS_CONFIG = {
   wcDeeplink: "https://exodus.com/wc",
   injectedKey: "isExodus"
 };
-var EXODUS_BROWSE_URL = "https://exodus.com/m/browser";
 var createExodusEvmMobileConnector = () => createWcEvmConnector(EXODUS_CONFIG);
 var createExodusSolanaMobileConnector = () => createWcSolanaConnector(EXODUS_CONFIG);
-var createExodusSolanaDappBrowserConnector = () => createDappBrowserSolanaConnector({
-  walletId: "exodus",
-  browseUrl: EXODUS_BROWSE_URL,
-  injectedKey: "isExodus"
-});
 
 // src/lib/connectors/binance.ts
 var BINANCE_CONFIG = {
@@ -933,11 +976,7 @@ var createBinanceSolanaDappBrowserConnector = () => createDappBrowserSolanaConne
 });
 
 // src/lib/connectors/okx.ts
-var buildOkxBrowseUrl = () => {
-  const dappUrl = window.location.href;
-  const deepLink = `okx://wallet/dapp/url?dappUrl=${encodeURIComponent(dappUrl)}`;
-  return `https://web3.okx.com/download?deeplink=${encodeURIComponent(deepLink)}`;
-};
+var buildOkxBrowseUrl = () => `okx://wallet/dapp/url?dappUrl=${encodeURIComponent(window.location.href)}`;
 var createOkxSolanaDappBrowserConnector = () => createDappBrowserSolanaConnector({
   walletId: "okx",
   injectedKey: "isOkxWallet",
@@ -953,12 +992,17 @@ var createCoinbaseSolanaDappBrowserConnector = () => createDappBrowserSolanaConn
 });
 
 // src/lib/connectors/bitget.ts
-var BITGET_BROWSE_URL = "https://bkcode.vip/dapp";
+var BITGET_CONFIG = {
+  walletId: "bitget",
+  wcDeeplink: "bitkeep://bkconnect",
+  injectedKey: "isBitKeep"
+};
+var buildBitgetBrowseUrl = () => `https://bkcode.vip?action=dapp&url=${encodeURIComponent(window.location.href)}`;
+var createBitgetSolanaConnector = () => createWcSolanaConnector(BITGET_CONFIG);
 var createBitgetSolanaDappBrowserConnector = () => createDappBrowserSolanaConnector({
   walletId: "bitget",
-  browseUrl: BITGET_BROWSE_URL,
   injectedKey: "isBitKeep",
-  stripProtocol: true
+  buildUrl: buildBitgetBrowseUrl
 });
 var walletConfig = WALLETS.find((w) => w.id === "walletconnect");
 var disconnectWc2 = async () => {
@@ -1045,6 +1089,7 @@ var EVM_FALLBACK_CONNECTORS = [
   { id: "rainbow", create: createRainbowEvmMobileConnector },
   { id: "exodus", create: createExodusEvmMobileConnector }
 ];
+var sleep = (ms) => new Promise((r) => window.setTimeout(r, ms));
 var cleanupWalletLocalStorage = () => {
   Object.keys(window.localStorage).filter((key) => key.startsWith("wagmi.")).forEach((key) => window.localStorage.removeItem(key));
 };
@@ -1059,9 +1104,21 @@ var getEvmConnectors = () => {
     wallet: {
       _connector: c,
       connect: async () => {
-        const result = await connect(getEvmConfig(), { connector: c });
-        if (!result.accounts[0]) throw new Error("No accounts returned");
-        return connectedResult(result.accounts[0], { chainId: result.chainId });
+        try {
+          const result = await connect(getEvmConfig(), { connector: c });
+          if (!result.accounts[0]) throw new Error("No accounts returned");
+          return connectedResult(result.accounts[0], { chainId: result.chainId });
+        } catch (err) {
+          if (err instanceof Error && err.name === "ConnectorAlreadyConnectedError") {
+            cleanupWalletLocalStorage();
+            await disconnect(getEvmConfig(), { connector: c });
+            await sleep(100);
+            const result = await connect(getEvmConfig(), { connector: c });
+            if (!result.accounts[0]) throw new Error("No accounts returned");
+            return connectedResult(result.accounts[0], { chainId: result.chainId });
+          }
+          throw err;
+        }
       },
       disconnect: async () => {
         cleanupWalletLocalStorage();
@@ -1078,6 +1135,60 @@ var getEvmConnectors = () => {
 var watchEvmConnections = (onChange) => {
   return watchConnections(getEvmConfig(), { onChange });
 };
+var switchChain = async (chainId) => {
+  await switchChain$1(getEvmConfig(), { chainId });
+};
+var sendTransaction = async (params) => {
+  const hash = await sendTransaction$1(getEvmConfig(), {
+    to: params.to,
+    value: params.value,
+    data: params.data
+  });
+  return { hash };
+};
+var waitForTransactionReceipt = async (hash) => {
+  const receipt = await waitForTransactionReceipt$1(getEvmConfig(), { hash });
+  return {
+    hash: receipt.transactionHash,
+    status: receipt.status,
+    blockNumber: receipt.blockNumber
+  };
+};
+var getAllowance = async (params) => {
+  return readContract(getEvmConfig(), {
+    abi: erc20Abi,
+    address: params.tokenAddress,
+    functionName: "allowance",
+    args: [params.owner, params.spender]
+  });
+};
+var approve = async (params) => {
+  const hash = await writeContract(getEvmConfig(), {
+    address: params.tokenAddress,
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [params.spender, params.amount]
+  });
+  return waitForTransactionReceipt(hash);
+};
+var ensureAllowance = async (params) => {
+  const currentAllowance = await getAllowance({
+    tokenAddress: params.tokenAddress,
+    owner: params.owner,
+    spender: params.spender
+  });
+  if (currentAllowance >= params.amount) {
+    return null;
+  }
+  if (currentAllowance > 0n) {
+    await approve({
+      tokenAddress: params.tokenAddress,
+      spender: params.spender,
+      amount: 0n
+    });
+  }
+  return approve(params);
+};
 
 // src/lib/solana/connection.ts
 var currentConnection = {
@@ -1194,11 +1305,10 @@ var SOLANA_FALLBACK_CONNECTORS = isMobile() ? [
   },
   {
     id: "exodus",
-    create: () => createSolanaMobileConnector(createExodusSolanaDappBrowserConnector())
+    create: () => createSolanaMobileConnector(createExodusSolanaMobileConnector())
   }
 ] : [
   { id: "phantom", create: () => createSolanaMobileConnector(createPhantomSolanaConnector()) },
-  // { id: 'metamask', create: () => createSolanaMobileConnector(createMetaMaskSolanaConnector()) },
   {
     id: "solflare",
     create: () => createSolanaMobileConnector(createSolflareSolanaMobileConnector())
@@ -1208,6 +1318,7 @@ var SOLANA_FALLBACK_CONNECTORS = isMobile() ? [
     create: () => createSolanaMobileConnector(createTrustSolanaMobileConnector())
   },
   { id: "binance", create: () => createSolanaMobileConnector(createBinanceSolanaConnector()) },
+  { id: "bitget", create: createBitgetSolanaConnector },
   {
     id: "exodus",
     create: () => createSolanaMobileConnector(createExodusSolanaMobileConnector())
@@ -1219,6 +1330,8 @@ var getSolanaWallets = () => {
   const connectors = wallets.filter(isWalletAdapterCompatibleStandardWallet).filter((w) => {
     return w.constructor.name !== "SolflareMetaMaskWallet";
   }).map(createSolanaConnector);
+  console.log({ wallets });
+  console.log({ connectors });
   addFallbackConnectors(connectors, SOLANA_FALLBACK_CONNECTORS);
   return connectors;
 };
@@ -1358,6 +1471,60 @@ var useEvmWallet = (options) => {
     connectedEvmConnector: connectedConnector
   };
 };
+
+// src/lib/context/hooks/useEvmTransactions.ts
+var useEvmTransactions = (hasWcSession) => {
+  const isWc = () => hasWcSession() && getCurrentSession();
+  const switchChain2 = async (chainId) => {
+    if (isWc()) {
+      await wcSwitchChain(chainId);
+    } else {
+      await switchChain(chainId);
+    }
+  };
+  const sendTransaction2 = async (params) => {
+    if (isWc()) {
+      const address = getWcEvmAddress();
+      if (!address) throw new Error("No WalletConnect EVM address");
+      const chainId = getWcEvmChainId();
+      if (!chainId) throw new Error("No WalletConnect chain ID");
+      const result = await wcSendTransaction({
+        from: address,
+        to: params.to,
+        value: params.value !== void 0 ? `0x${params.value.toString(16)}` : void 0,
+        data: params.data,
+        chainId
+      });
+      return { hash: result.hash };
+    }
+    return sendTransaction(params);
+  };
+  const sendAndWait = async (params) => {
+    const { hash } = await sendTransaction2(params);
+    return waitForTransactionReceipt(hash);
+  };
+  const approve2 = async (params) => {
+    if (isWc()) {
+      throw new Error("ERC20 approve via WalletConnect not yet supported");
+    }
+    return approve(params);
+  };
+  const ensureAllowance2 = async (params) => {
+    if (isWc()) {
+      throw new Error("ERC20 ensureAllowance via WalletConnect not yet supported");
+    }
+    return ensureAllowance(params);
+  };
+  return {
+    switchChain: switchChain2,
+    sendTransaction: sendTransaction2,
+    sendAndWait,
+    waitForReceipt: waitForTransactionReceipt,
+    approve: approve2,
+    ensureAllowance: ensureAllowance2,
+    getAllowance
+  };
+};
 var useSolanaWallet = () => {
   const [solanaConnectors, setSolanaConnectors] = createSignal([]);
   const [solanaConnection, setSolanaConnection] = createSignal(null);
@@ -1365,13 +1532,16 @@ var useSolanaWallet = () => {
     null
   );
   onMount(() => {
-    const connectors = getSolanaWallets();
     const wcConnector = createWalletConnectSolanaConnector();
-    if (wcConnector) {
-      connectors.unshift(wcConnector);
-    }
-    setSolanaConnectors(connectors);
-    const unsubscribeWallets = onSolanaWalletsChange(setSolanaConnectors);
+    const getConnectorsWithWc = () => {
+      const connectors = getSolanaWallets();
+      if (wcConnector) connectors.unshift(wcConnector);
+      return connectors;
+    };
+    setSolanaConnectors(getConnectorsWithWc());
+    const unsubscribeWallets = onSolanaWalletsChange(() => {
+      setSolanaConnectors(getConnectorsWithWc());
+    });
     const unsubscribeConnection = watchSolanaConnection((state) => {
       setSolanaConnection(state.connection);
       if (state.connector) {
@@ -1501,6 +1671,7 @@ var WalletProvider = (props) => {
     onEvmConnection: evm.setEvmConnection,
     onSolanaConnection: solana.setSolanaConnection
   });
+  const evmTx = useEvmTransactions(wc.hasWcEvmSession);
   const disconnectEvm = async () => {
     if (evm.connectedEvmConnector()) {
       await evm.disconnectEvm();
@@ -1566,7 +1737,8 @@ var WalletProvider = (props) => {
     disconnectEvm,
     connectSolana: solana.connectSolana,
     disconnectSolana,
-    signMessage
+    signMessage,
+    evmTx
   };
   return createComponent(WalletContext.Provider, {
     value,