@bit-buccaneers/wallet-abstraction 0.0.10 → 0.0.11

package/dist/dev.js

@@ -1,6 +1,6 @@
 import { injected, metaMask, coinbaseWallet } from '@wagmi/connectors';
-import { createConfig, getConnectors, signMessage, disconnect, getConnections, 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;
@@ -929,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",
@@ -1046,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));
 };
@@ -1060,11 +1104,21 @@ var getEvmConnectors = () => {
     wallet: {
       _connector: c,
       connect: async () => {
-        const connections = getConnections(getEvmConfig());
-        if (connections.length > 0) await disconnect(getEvmConfig());
-        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();
@@ -1081,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 = {
@@ -1363,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);
@@ -1370,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) {
@@ -1506,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();
@@ -1571,7 +1737,8 @@ var WalletProvider = (props) => {
     disconnectEvm,
     connectSolana: solana.connectSolana,
     disconnectSolana,
-    signMessage
+    signMessage,
+    evmTx
   };
   return createComponent(WalletContext.Provider, {
     value,

package/dist/dev.jsx

@@ -28,7 +28,6 @@ var getEvmConfig = () => {
 import {
   connect,
   disconnect,
-  getConnections,
   getConnectors,
   signMessage as wagmiSignMessage
 } from "@wagmi/core";
@@ -166,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",
@@ -193,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 = {
@@ -588,6 +586,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;
@@ -943,11 +989,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",
@@ -1063,6 +1105,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));
 };
@@ -1077,11 +1120,21 @@ var getEvmConnectors = () => {
     wallet: {
       _connector: c,
       connect: async () => {
-        const connections = getConnections(getEvmConfig());
-        if (connections.length > 0) await disconnect(getEvmConfig());
-        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();
@@ -1102,6 +1155,71 @@ var watchEvmConnections = (onChange) => {
   return watchConnections(getEvmConfig(), { onChange });
 };
 
+// src/lib/evm/transactions.ts
+import {
+  sendTransaction as wagmiSendTransaction,
+  switchChain as wagmiSwitchChain,
+  waitForTransactionReceipt as wagmiWaitForReceipt
+} from "@wagmi/core";
+var switchChain = async (chainId) => {
+  await wagmiSwitchChain(getEvmConfig(), { chainId });
+};
+var sendTransaction = async (params) => {
+  const hash = await wagmiSendTransaction(getEvmConfig(), {
+    to: params.to,
+    value: params.value,
+    data: params.data
+  });
+  return { hash };
+};
+var waitForTransactionReceipt = async (hash) => {
+  const receipt = await wagmiWaitForReceipt(getEvmConfig(), { hash });
+  return {
+    hash: receipt.transactionHash,
+    status: receipt.status,
+    blockNumber: receipt.blockNumber
+  };
+};
+
+// src/lib/evm/erc20.ts
+import { readContract, writeContract } from "@wagmi/core";
+import { erc20Abi } from "viem";
+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 = {
   connection: null,
@@ -1400,6 +1518,60 @@ var useEvmWallet = (options) => {
   };
 };
 
+// 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
+  };
+};
+
 // src/lib/context/hooks/useSolanaWallet.ts
 import { createSignal as createSignal2, onCleanup as onCleanup2, onMount as onMount2 } from "solid-js";
 var useSolanaWallet = () => {
@@ -1409,13 +1581,16 @@ var useSolanaWallet = () => {
     null
   );
   onMount2(() => {
-    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) {
@@ -1547,6 +1722,7 @@ var WalletProvider = (props) => {
     onEvmConnection: evm.setEvmConnection,
     onSolanaConnection: solana.setSolanaConnection
   });
+  const evmTx = useEvmTransactions(wc.hasWcEvmSession);
   const disconnectEvm = async () => {
     if (evm.connectedEvmConnector()) {
       await evm.disconnectEvm();
@@ -1612,7 +1788,8 @@ var WalletProvider = (props) => {
     disconnectEvm,
     connectSolana: solana.connectSolana,
     disconnectSolana,
-    signMessage
+    signMessage,
+    evmTx
   };
   return <WalletContext.Provider value={value}>{props.children}</WalletContext.Provider>;
 };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { injected, metaMask, coinbaseWallet } from '@wagmi/connectors';
-import { createConfig, getConnectors, signMessage, disconnect, getConnections, 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 = {
@@ -572,6 +571,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;
@@ -924,11 +971,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",
@@ -1041,6 +1084,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));
 };
@@ -1055,11 +1099,21 @@ var getEvmConnectors = () => {
     wallet: {
       _connector: c,
       connect: async () => {
-        const connections = getConnections(getEvmConfig());
-        if (connections.length > 0) await disconnect(getEvmConfig());
-        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();
@@ -1076,6 +1130,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 = {
@@ -1356,6 +1464,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);
@@ -1363,13 +1525,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) {
@@ -1499,6 +1664,7 @@ var WalletProvider = (props) => {
     onEvmConnection: evm.setEvmConnection,
     onSolanaConnection: solana.setSolanaConnection
   });
+  const evmTx = useEvmTransactions(wc.hasWcEvmSession);
   const disconnectEvm = async () => {
     if (evm.connectedEvmConnector()) {
       await evm.disconnectEvm();
@@ -1564,7 +1730,8 @@ var WalletProvider = (props) => {
     disconnectEvm,
     connectSolana: solana.connectSolana,
     disconnectSolana,
-    signMessage
+    signMessage,
+    evmTx
   };
   return createComponent(WalletContext.Provider, {
     value,

package/dist/index.jsx

@@ -28,7 +28,6 @@ var getEvmConfig = () => {
 import {
   connect,
   disconnect,
-  getConnections,
   getConnectors,
   signMessage as wagmiSignMessage
 } from "@wagmi/core";
@@ -166,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",
@@ -193,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 = {
@@ -583,6 +581,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;
@@ -938,11 +984,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",
@@ -1058,6 +1100,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));
 };
@@ -1072,11 +1115,21 @@ var getEvmConnectors = () => {
     wallet: {
       _connector: c,
       connect: async () => {
-        const connections = getConnections(getEvmConfig());
-        if (connections.length > 0) await disconnect(getEvmConfig());
-        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();
@@ -1097,6 +1150,71 @@ var watchEvmConnections = (onChange) => {
   return watchConnections(getEvmConfig(), { onChange });
 };
 
+// src/lib/evm/transactions.ts
+import {
+  sendTransaction as wagmiSendTransaction,
+  switchChain as wagmiSwitchChain,
+  waitForTransactionReceipt as wagmiWaitForReceipt
+} from "@wagmi/core";
+var switchChain = async (chainId) => {
+  await wagmiSwitchChain(getEvmConfig(), { chainId });
+};
+var sendTransaction = async (params) => {
+  const hash = await wagmiSendTransaction(getEvmConfig(), {
+    to: params.to,
+    value: params.value,
+    data: params.data
+  });
+  return { hash };
+};
+var waitForTransactionReceipt = async (hash) => {
+  const receipt = await wagmiWaitForReceipt(getEvmConfig(), { hash });
+  return {
+    hash: receipt.transactionHash,
+    status: receipt.status,
+    blockNumber: receipt.blockNumber
+  };
+};
+
+// src/lib/evm/erc20.ts
+import { readContract, writeContract } from "@wagmi/core";
+import { erc20Abi } from "viem";
+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 = {
   connection: null,
@@ -1393,6 +1511,60 @@ var useEvmWallet = (options) => {
   };
 };
 
+// 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
+  };
+};
+
 // src/lib/context/hooks/useSolanaWallet.ts
 import { createSignal as createSignal2, onCleanup as onCleanup2, onMount as onMount2 } from "solid-js";
 var useSolanaWallet = () => {
@@ -1402,13 +1574,16 @@ var useSolanaWallet = () => {
     null
   );
   onMount2(() => {
-    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) {
@@ -1540,6 +1715,7 @@ var WalletProvider = (props) => {
     onEvmConnection: evm.setEvmConnection,
     onSolanaConnection: solana.setSolanaConnection
   });
+  const evmTx = useEvmTransactions(wc.hasWcEvmSession);
   const disconnectEvm = async () => {
     if (evm.connectedEvmConnector()) {
       await evm.disconnectEvm();
@@ -1605,7 +1781,8 @@ var WalletProvider = (props) => {
     disconnectEvm,
     connectSolana: solana.connectSolana,
     disconnectSolana,
-    signMessage
+    signMessage,
+    evmTx
   };
   return <WalletContext.Provider value={value}>{props.children}</WalletContext.Provider>;
 };

package/dist/lib/connectors/shared/constants.d.ts

@@ -3,7 +3,7 @@ export declare const WC_CHAINS: {
     readonly SOLANA_MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 };
 export declare const WC_METHODS: {
-    readonly EVM: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData"];
+    readonly EVM: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData", "wallet_switchEthereumChain"];
     readonly SOLANA: readonly ["solana_signTransaction", "solana_signMessage"];
 };
 export declare const WC_EVENTS: {
@@ -12,7 +12,7 @@ export declare const WC_EVENTS: {
 };
 export declare const EVM_WC_CONFIG: {
     readonly chains: readonly ["eip155:1"];
-    readonly methods: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData"];
+    readonly methods: readonly ["eth_sendTransaction", "personal_sign", "eth_signTypedData", "wallet_switchEthereumChain"];
     readonly events: readonly ["chainChanged", "accountsChanged"];
 };
 export declare const SOLANA_WC_CONFIG: {

package/dist/lib/context/WalletContext.d.ts

@@ -3,6 +3,7 @@ import { type ChainType, type ConnectedResult, type ConnectResult, type GroupedW
 import { type EvmChains, type EvmWalletConnector } from '../evm';
 import { type SolanaWalletConnector } from '../solana';
 import { type WalletConnectConfig } from '../walletconnect';
+import { type UseEvmTransactionsReturn } from './hooks';
 export interface WalletContextValue {
     evmConnectors: Accessor<EvmWalletConnector[]>;
     evmConnection: Accessor<ConnectedResult | null>;
@@ -14,6 +15,7 @@ export interface WalletContextValue {
     connectSolana: (connector: SolanaWalletConnector) => Promise<ConnectResult>;
     disconnectSolana: () => Promise<void>;
     signMessage: (chainType: ChainType, message: string) => Promise<string>;
+    evmTx: UseEvmTransactionsReturn;
 }
 export interface WalletProviderProps {
     evmChains: EvmChains;

package/dist/lib/context/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { useEvmWallet, type UseEvmWalletReturn } from './useEvmWallet';
+export { useEvmTransactions, type UseEvmTransactionsReturn } from './useEvmTransactions';
 export { useSolanaWallet, type UseSolanaWalletReturn } from './useSolanaWallet';
 export { useWalletConnect, type UseWalletConnectOptions, type UseWalletConnectReturn, } from './useWalletConnect';

package/dist/lib/context/hooks/useEvmTransactions.d.ts

@@ -0,0 +1,17 @@
+import { type ApproveParams, type HashAddress, type SendTransactionParams, type TransactionReceipt, type TransactionResult } from '../../evm';
+export interface UseEvmTransactionsReturn {
+    switchChain: (chainId: number) => Promise<void>;
+    sendTransaction: (params: SendTransactionParams) => Promise<TransactionResult>;
+    sendAndWait: (params: SendTransactionParams) => Promise<TransactionReceipt>;
+    waitForReceipt: (hash: HashAddress) => Promise<TransactionReceipt>;
+    approve: (params: ApproveParams) => Promise<TransactionReceipt>;
+    ensureAllowance: (params: ApproveParams & {
+        owner: HashAddress;
+    }) => Promise<TransactionReceipt | null>;
+    getAllowance: (params: {
+        tokenAddress: HashAddress;
+        owner: HashAddress;
+        spender: HashAddress;
+    }) => Promise<bigint>;
+}
+export declare const useEvmTransactions: (hasWcSession: () => boolean) => UseEvmTransactionsReturn;

package/dist/lib/core/types.d.ts

@@ -1,5 +1,6 @@
 import { EvmWalletConnector } from '../evm';
 import { SolanaWalletConnector } from '../solana';
+import { WalletId } from '../wallets';
 export type ChainType = 'evm' | 'solana';
 export interface ConnectedResult {
     status: 'connected';
@@ -22,7 +23,7 @@ export interface Wallet {
     signMessage: (message: string) => Promise<string>;
 }
 export interface WalletConnector {
-    id: string;
+    id: WalletId;
     name: string;
     icon?: string;
     type: ChainType;
@@ -30,7 +31,7 @@ export interface WalletConnector {
     wallet: Wallet;
 }
 export interface GroupedWallet {
-    id: string;
+    id: WalletId;
     name: string;
     icon: string;
     chromeExtensionUrl?: string;

package/dist/lib/evm/connectors.d.ts

@@ -1,3 +1,4 @@
 import type { EvmWalletConnector } from './types';
+export declare const sleep: (ms: number) => Promise<unknown>;
 export declare const cleanupWalletLocalStorage: () => void;
 export declare const getEvmConnectors: () => EvmWalletConnector[];

package/dist/lib/evm/erc20.d.ts

@@ -0,0 +1,19 @@
+import { type HashAddress, type TransactionReceipt } from './transactions';
+export interface ApproveParams {
+    tokenAddress: HashAddress;
+    spender: HashAddress;
+    amount: bigint;
+}
+export interface GetAllowanceParams {
+    tokenAddress: HashAddress;
+    owner: HashAddress;
+    spender: HashAddress;
+}
+export declare const getAllowance: (params: GetAllowanceParams) => Promise<bigint>;
+export declare const approve: (params: ApproveParams) => Promise<TransactionReceipt>;
+export declare const approveWithReset: (params: ApproveParams & {
+    owner: HashAddress;
+}) => Promise<TransactionReceipt>;
+export declare const ensureAllowance: (params: ApproveParams & {
+    owner: HashAddress;
+}) => Promise<TransactionReceipt | null>;

package/dist/lib/evm/index.d.ts

@@ -1,4 +1,6 @@
 export { createEvmConfig, getEvmConfig, type Config, type EvmChains } from './config';
 export { getEvmConnectors } from './connectors';
 export { watchEvmConnections } from './connection';
+export { sendTransaction, sendAndWaitTransaction, switchChain, waitForTransactionReceipt, type HashAddress, type SendTransactionParams, type TransactionReceipt, type TransactionResult, } from './transactions';
+export { approve, approveWithReset, ensureAllowance, getAllowance, type ApproveParams, type GetAllowanceParams, } from './erc20';
 export type { EvmWallet, EvmWalletConnector } from './types';

package/dist/lib/evm/transactions.d.ts

@@ -0,0 +1,18 @@
+export type HashAddress = `0x${string}`;
+export interface SendTransactionParams {
+    to: HashAddress;
+    value?: bigint;
+    data?: HashAddress;
+}
+export interface TransactionResult {
+    hash: HashAddress;
+}
+export interface TransactionReceipt {
+    hash: HashAddress;
+    status: 'success' | 'reverted';
+    blockNumber: bigint;
+}
+export declare const switchChain: (chainId: number) => Promise<void>;
+export declare const sendTransaction: (params: SendTransactionParams) => Promise<TransactionResult>;
+export declare const waitForTransactionReceipt: (hash: HashAddress) => Promise<TransactionReceipt>;
+export declare const sendAndWaitTransaction: (params: SendTransactionParams) => Promise<TransactionReceipt>;

package/dist/lib/walletconnect/index.d.ts

@@ -1 +1,2 @@
 export { connectWalletConnect, type ConnectOptions, disconnectWalletConnect, getCurrentSession, getSignClient, initWalletConnect, onWalletConnectSessionChange, requestWalletConnect, setCurrentSession, type WalletConnectConfig, type WalletConnectSession, } from './client';
+export { getWcEvmAddress, getWcEvmChainId, wcSendTransaction, wcSwitchChain, type WcSendTransactionParams, type WcTransactionResult, } from './transactions';

package/dist/lib/walletconnect/transactions.d.ts

@@ -0,0 +1,15 @@
+import { type HashAddress } from '../evm';
+export interface WcSendTransactionParams {
+    from: HashAddress;
+    to: HashAddress;
+    value?: string;
+    data?: HashAddress;
+    chainId: number;
+}
+export interface WcTransactionResult {
+    hash: HashAddress;
+}
+export declare const wcSwitchChain: (chainId: number) => Promise<void>;
+export declare const wcSendTransaction: (params: WcSendTransactionParams) => Promise<WcTransactionResult>;
+export declare const getWcEvmAddress: () => HashAddress | null;
+export declare const getWcEvmChainId: () => number | null;

package/dist/lib/wallets/mappers.d.ts

@@ -1,2 +1,3 @@
-export declare const normalizeEvmWalletId: (id: string) => string;
-export declare const normalizeSolanaWalletId: (id: string) => string;
+import { type WalletId } from './config';
+export declare const normalizeEvmWalletId: (id: string) => WalletId;
+export declare const normalizeSolanaWalletId: (id: string) => WalletId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bit-buccaneers/wallet-abstraction",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Solid.js web3 wallet abstraction for EVM and Solana",
   "license": "MIT",
   "author": "Bit Buccaneers",