@swapkit/wallets 3.0.0-beta.0 → 3.0.0-beta.2

package/src/coinbase/signer.ts

@@ -1,48 +1,55 @@
 import type { CoinbaseWalletProvider } from "@coinbase/wallet-sdk";
+import type { createCoinbaseWalletSDK } from "@coinbase/wallet-sdk/dist/createCoinbaseWalletSDK.js";
 import { Chain } from "@swapkit/helpers";
-import type { getToolboxByChain } from "@swapkit/toolboxes/evm";
-import { AbstractSigner, type Provider } from "ethers";
+import type { Provider } from "ethers";
 
-import type { createCoinbaseWalletSDK } from "@coinbase/wallet-sdk/dist/createCoinbaseWalletSDK.js";
+async function getCoinbaseMobileSigner(
+  walletProvider: CoinbaseWalletProvider,
+  provider?: Provider,
+) {
+  const { AbstractSigner } = await import("ethers");
 
-class CoinbaseMobileSigner extends AbstractSigner {
-  #coinbaseProvider: CoinbaseWalletProvider;
+  class CoinbaseMobileSigner extends AbstractSigner {
+    #coinbaseProvider: CoinbaseWalletProvider;
 
-  constructor(coinbaseProvider: CoinbaseWalletProvider, provider?: Provider) {
-    super(provider);
-    this.#coinbaseProvider = coinbaseProvider;
-  }
+    constructor(coinbaseProvider: CoinbaseWalletProvider, provider?: Provider) {
+      super(provider);
+      this.#coinbaseProvider = coinbaseProvider;
+    }
 
-  async getAddress() {
-    const accounts = await this.#coinbaseProvider.request<string[]>({
-      method: "eth_requestAccounts",
-    });
+    async getAddress() {
+      const accounts = await this.#coinbaseProvider.request<string[]>({
+        method: "eth_requestAccounts",
+      });
 
-    if (!accounts[0]) throw new Error("No Account found");
+      if (!accounts[0]) throw new Error("No Account found");
 
-    return accounts[0];
-  }
+      return accounts[0];
+    }
 
-  async signTransaction() {
-    return await this.#coinbaseProvider.request<string>({
-      method: "eth_signTransaction",
-    });
-  }
+    async signTransaction() {
+      return await this.#coinbaseProvider.request<string>({
+        method: "eth_signTransaction",
+      });
+    }
 
-  async signMessage(message: string | Uint8Array) {
-    return await this.#coinbaseProvider.request<string>({
-      method: "personal_sign",
-      params: [message, await this.getAddress()],
-    });
-  }
+    async signMessage(message: string | Uint8Array) {
+      return await this.#coinbaseProvider.request<string>({
+        method: "personal_sign",
+        params: [message, await this.getAddress()],
+      });
+    }
 
-  signTypedData = () => {
-    throw new Error("this method is not implemented");
-  };
+    signTypedData = () => {
+      throw new Error("this method is not implemented");
+    };
 
-  connect(provider: Provider) {
-    return new CoinbaseMobileSigner(this.#coinbaseProvider, provider);
+    connect(provider: Provider) {
+      return new CoinbaseMobileSigner(this.#coinbaseProvider, provider);
+    }
   }
+
+  return new CoinbaseMobileSigner(walletProvider, provider);
 }
 
 export const getWalletMethods = async ({
@@ -51,7 +58,7 @@ export const getWalletMethods = async ({
 }: {
   chain: Chain;
   coinbaseSdk: ReturnType<typeof createCoinbaseWalletSDK>;
-}): Promise<ReturnType<ReturnType<typeof getToolboxByChain>> & { address: string }> => {
+}) => {
   switch (chain) {
     case Chain.Ethereum:
     case Chain.Avalanche:
@@ -60,17 +67,14 @@ export const getWalletMethods = async ({
     case Chain.Polygon:
     case Chain.BinanceSmartChain: {
       const walletProvider = coinbaseSdk.getProvider() as CoinbaseWalletProvider;
+      const { getEvmToolbox, getProvider } = await import("@swapkit/toolboxes/evm");
 
-      const { getToolboxByChain, getProvider } = await import("@swapkit/toolboxes/evm");
-
-      const provider = getProvider(chain);
-      const signer = new CoinbaseMobileSigner(walletProvider, provider);
-      const toolbox = getToolboxByChain(chain)({ provider, signer });
+      const provider = await getProvider(chain);
+      const signer = await getCoinbaseMobileSigner(walletProvider, provider);
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+      const address = await signer.getAddress();
 
-      return {
-        address: await signer.getAddress(),
-        ...toolbox,
-      };
+      return { ...toolbox, address };
     }
 
     default:

package/src/ctrl/index.ts

@@ -1,24 +1,159 @@
-import type { Keplr } from "@keplr-wallet/types";
-import type { SolanaProvider } from "@swapkit/toolboxes/solana";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-
-export { ctrlWallet, CTRL_SUPPORTED_CHAINS } from "./ctrlWallet";
-
-type CtrlSolana = SolanaProvider & { isXDEFI: boolean };
-
-declare global {
-  interface Window {
-    xfi?: {
-      binance: Eip1193Provider;
-      bitcoin: Eip1193Provider;
-      bitcoincash: Eip1193Provider;
-      dogecoin: Eip1193Provider;
-      ethereum: BrowserProvider;
-      keplr: Keplr;
-      litecoin: Eip1193Provider;
-      thorchain: Eip1193Provider;
-      mayachain: Eip1193Provider;
-      solana: CtrlSolana;
-    };
+import {
+  Chain,
+  ChainToChainId,
+  type GenericTransferParams,
+  SwapKitError,
+  WalletOption,
+  createWallet,
+  filterSupportedChains,
+} from "@swapkit/helpers";
+
+import { getWalletSupportedChains } from "../utils";
+import { getCtrlAddress, getCtrlMethods, getCtrlProvider, walletTransfer } from "./walletHelpers";
+
+export const ctrlWallet = createWallet({
+  name: "connectCtrl",
+  walletType: WalletOption.CTRL,
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Cosmos,
+    Chain.Dogecoin,
+    Chain.Ethereum,
+    Chain.Kujira,
+    Chain.Litecoin,
+    Chain.Maya,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Solana,
+    Chain.THORChain,
+  ],
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectCtrl(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      const promises = filteredChains.map(async (chain) => {
+        const address = await getCtrlAddress(chain);
+        const walletMethods = await getWalletMethods(chain);
+
+        addChain({ ...walletMethods, address, chain, walletType });
+      });
+
+      await Promise.all(promises);
+
+      return true;
+    },
+});
+
+export const CTRL_SUPPORTED_CHAINS = getWalletSupportedChains(ctrlWallet);
+
+async function getWalletMethods(chain: (typeof CTRL_SUPPORTED_CHAINS)[number]) {
+  switch (chain) {
+    case Chain.Solana: {
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+
+      const solanaProvider = window.xfi?.solana;
+
+      if (!solanaProvider) {
+        throw new SwapKitError("wallet_ctrl_not_found");
+      }
+      const toolbox = getSolanaToolbox({ signer: solanaProvider });
+
+      return { ...toolbox };
+    }
+
+    case Chain.Maya:
+    case Chain.THORChain: {
+      const { getCosmosToolbox, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import(
+        "@swapkit/toolboxes/cosmos"
+      );
+
+      const gasLimit = chain === Chain.Maya ? MAYA_GAS_VALUE : THORCHAIN_GAS_VALUE;
+      const toolbox = await getCosmosToolbox(chain);
+
+      return {
+        ...toolbox,
+        deposit: (tx: GenericTransferParams) => walletTransfer({ ...tx, recipient: "" }, "deposit"),
+        transfer: (tx: GenericTransferParams) => walletTransfer({ ...tx, gasLimit }, "transfer"),
+      };
+    }
+
+    case Chain.Cosmos:
+    case Chain.Kujira: {
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
+      const chainId = ChainToChainId[chain];
+      const provider = await getCtrlProvider(chain);
+
+      await provider?.enable(chainId);
+      const signer = provider?.getOfflineSignerOnlyAmino(chainId);
+
+      if (!signer) {
+        throw new SwapKitError("wallet_ctrl_not_found");
+      }
+
+      const toolbox = getCosmosToolbox(chain, { signer });
+
+      return toolbox;
+    }
+
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const toolbox = await getUtxoToolbox(chain);
+
+      return { ...toolbox, transfer: walletTransfer };
+    }
+
+    case Chain.Arbitrum:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Optimism:
+    case Chain.Polygon: {
+      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@swapkit/helpers");
+      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+      const { BrowserProvider } = await import("ethers");
+      const ethereumWindowProvider = await getCtrlProvider(chain);
+
+      if (!ethereumWindowProvider) {
+        throw new SwapKitError("wallet_ctrl_not_found");
+      }
+
+      const provider = new BrowserProvider(ethereumWindowProvider, "any");
+      const signer = await provider.getSigner();
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+      const ctrlMethods = getCtrlMethods(provider, chain);
+
+      try {
+        if (chain !== Chain.Ethereum) {
+          const networkParams = toolbox.getNetworkParams();
+          await switchEVMWalletNetwork(provider, chain, networkParams);
+        }
+      } catch (_error) {
+        throw new SwapKitError({
+          errorKey: "wallet_failed_to_add_or_switch_network",
+          info: { wallet: WalletOption.CTRL, chain },
+        });
+      }
+
+      return prepareNetworkSwitch({
+        provider: window.xfi?.ethereum,
+        chain,
+        toolbox: {
+          ...toolbox,
+          ...ctrlMethods,
+        },
+      });
+    }
+
+    default:
+      return null;
   }
 }

package/src/ctrl/walletHelpers.ts

@@ -1,5 +1,4 @@
 import type { Keplr } from "@keplr-wallet/types";
-import type { PublicKey } from "@solana/web3.js";
 import {
   type AssetValue,
   Chain,
@@ -11,9 +10,8 @@ import {
   WalletOption,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { TransferParams } from "@swapkit/toolboxes/cosmos";
 import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
-import type { SOLToolbox, SolanaProvider } from "@swapkit/toolboxes/solana";
+import type { SolanaProvider } from "@swapkit/toolboxes/solana";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
 
 type TransactionMethod = "transfer" | "deposit";
@@ -35,59 +33,39 @@ export type WalletTxParams = {
   gasLimit?: string | bigint;
 };
 
-export function getCtrlProvider<T extends Chain>(
+export async function getCtrlProvider<T extends Chain>(
   chain: T,
-): T extends Chain.Solana
-  ? SolanaProvider
-  : T extends Chain.Cosmos | Chain.Kujira
-    ? Keplr
-    : T extends EVMChain
-      ? Eip1193Provider
-      : undefined {
+): Promise<
+  T extends Chain.Solana
+    ? SolanaProvider
+    : T extends Chain.Cosmos | Chain.Kujira
+      ? Keplr
+      : T extends EVMChain
+        ? Eip1193Provider
+        : undefined
+> {
   if (!window.xfi) throw new SwapKitError("wallet_ctrl_not_found");
-
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-      // @ts-expect-error
-      return window.xfi.ethereum;
-
-    case Chain.Cosmos:
-    case Chain.Kujira:
-      // @ts-expect-error
-      return window.xfi.keplr;
-
-    case Chain.Bitcoin:
-      // @ts-expect-error
-      return window.xfi.bitcoin;
-    case Chain.BitcoinCash:
-      // @ts-expect-error
-      return window.xfi.bitcoincash;
-    case Chain.Dogecoin:
-      // @ts-expect-error
-      return window.xfi.dogecoin;
-    case Chain.Litecoin:
-      // @ts-expect-error
-      return window.xfi.litecoin;
-    case Chain.THORChain:
-      // @ts-expect-error
-      return window.xfi.thorchain;
-    case Chain.Maya:
-      // @ts-expect-error
-      return window.xfi.mayachain;
-    case Chain.Solana:
-      // @ts-expect-error
-      return window.xfi.solana;
-
-    default:
-      // @ts-expect-error
-      return undefined;
-  }
+  const { match } = await import("ts-pattern");
+
+  // @ts-expect-error
+  return match(chain as Chain)
+    .with(
+      Chain.Arbitrum,
+      Chain.Avalanche,
+      Chain.Base,
+      Chain.BinanceSmartChain,
+      Chain.Ethereum,
+      Chain.Optimism,
+      Chain.Polygon,
+      () => window.xfi?.ethereum,
+    )
+    .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, () => window.xfi?.keplr)
+    .with(Chain.Bitcoin, () => window.xfi?.bitcoin)
+    .with(Chain.BitcoinCash, () => window.xfi?.bitcoincash)
+    .with(Chain.Dogecoin, () => window.xfi?.dogecoin)
+    .with(Chain.Litecoin, () => window.xfi?.litecoin)
+    .with(Chain.Solana, () => window.xfi?.solana)
+    .otherwise(() => undefined);
 }
 
 async function transaction({
@@ -99,7 +77,7 @@ async function transaction({
   params: TransactionParams[];
   chain: Chain;
 }): Promise<string> {
-  const client = getCtrlProvider(chain);
+  const client = await getCtrlProvider(chain);
 
   return new Promise<string>((resolve, reject) => {
     if (client && "request" in client) {
@@ -112,7 +90,7 @@ async function transaction({
 }
 
 export async function getCtrlAddress(chain: Chain) {
-  const eipProvider = getCtrlProvider(chain) as Eip1193Provider;
+  const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
   if (!eipProvider) {
     throw new SwapKitError({
       errorKey: "wallet_provider_not_found",
@@ -121,7 +99,7 @@ export async function getCtrlAddress(chain: Chain) {
   }
 
   if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
-    const provider = getCtrlProvider(Chain.Cosmos);
+    const provider = await getCtrlProvider(Chain.Cosmos);
     if (!provider || "request" in provider) {
       throw new SwapKitError({
         errorKey: "wallet_provider_not_found",
@@ -148,7 +126,7 @@ export async function getCtrlAddress(chain: Chain) {
   }
 
   if (chain === Chain.Solana) {
-    const provider = getCtrlProvider(Chain.Solana);
+    const provider = await getCtrlProvider(Chain.Solana);
 
     const accounts = await provider.connect();
     return accounts.publicKey.toString();
@@ -198,35 +176,7 @@ export async function walletTransfer(
   return transaction({ method, params, chain: assetValue.chain });
 }
 
-export function solanaTransfer(
-  solToolbox: ReturnType<typeof SOLToolbox>,
-  walletPublicKey: PublicKey,
-) {
-  return async ({
-    recipient,
-    assetValue,
-    memo,
-    isProgramDerivedAddress,
-  }: TransferParams & { isProgramDerivedAddress?: boolean }) => {
-    const transaction = await solToolbox.createSolanaTransaction({
-      recipient,
-      assetValue,
-      memo,
-      fromPublicKey: walletPublicKey,
-      isProgramDerivedAddress,
-    });
-
-    const signedTransaction = await window.xfi?.solana.signTransaction(transaction);
-
-    if (!signedTransaction) {
-      throw new SwapKitError("core_transaction_failed");
-    }
-
-    return solToolbox.broadcastTransaction(signedTransaction);
-  };
-}
-
-export function getCtrlMethods(provider: BrowserProvider) {
+export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
   return {
     call: async <T>({
       contractAddress,
@@ -235,17 +185,17 @@ export function getCtrlMethods(provider: BrowserProvider) {
       funcParams = [],
       txOverrides,
     }: CallParams): Promise<T> => {
-      const contractProvider = provider;
       if (!contractAddress) {
         throw new SwapKitError("wallet_ctrl_contract_address_not_provided");
       }
-      const { createContract, createContractTxObject, isStateChangingCall, toHexString } =
+      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } =
         await import("@swapkit/toolboxes/evm");
 
-      const isStateChanging = isStateChangingCall(abi, funcName);
+      const isStateChanging = isStateChangingCall({ abi, funcName });
 
       if (isStateChanging) {
-        const { value, from, to, data } = await createContractTxObject(contractProvider, {
+        const createTx = getCreateContractTxObject({ provider, chain });
+        const { value, from, to, data } = await createTx({
           contractAddress,
           abi,
           funcName,
@@ -262,14 +212,14 @@ export function getCtrlMethods(provider: BrowserProvider) {
           } as any,
         ]);
       }
-      const contract = createContract(contractAddress, abi, contractProvider);
+      const contract = createContract(contractAddress, abi, provider);
 
       const result = await contract[funcName]?.(...funcParams);
 
       return typeof result?.hash === "string" ? result?.hash : result;
     },
     approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
-      const { MAX_APPROVAL, createContractTxObject, toHexString } = await import(
+      const { MAX_APPROVAL, getCreateContractTxObject, toHexString } = await import(
         "@swapkit/toolboxes/evm"
       );
       const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
@@ -283,7 +233,8 @@ export function getCtrlMethods(provider: BrowserProvider) {
         txOverrides,
       };
 
-      const { value, to, data } = await createContractTxObject(provider, functionCallParams);
+      const createTx = getCreateContractTxObject({ provider, chain });
+      const { value, to, data } = await createTx(functionCallParams);
 
       return provider.send("eth_sendTransaction", [
         {

package/src/evm-extensions/index.ts

@@ -3,23 +3,14 @@ import {
   ChainToHexChainId,
   type EVMChain,
   EVMChains,
-  type EthereumWindowProvider,
   WalletOption,
   createWallet,
   filterSupportedChains,
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { NonETHToolbox } from "@swapkit/toolboxes/evm";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../helpers";
-
-declare const window: {
-  ethereum: EthereumWindowProvider;
-  trustwallet: EthereumWindowProvider;
-  coinbaseWalletExtension: EthereumWindowProvider;
-  braveSolana: any;
-} & Window;
+import { getWalletSupportedChains } from "../utils";
 
 export type EVMWalletOptions =
   | WalletOption.BRAVE
@@ -48,22 +39,27 @@ const getWalletForType = (
 };
 
 export const getWeb3WalletMethods = async ({
+  address,
   walletProvider,
   chain,
   provider,
-}: { walletProvider?: Eip1193Provider; chain: EVMChain; provider: BrowserProvider }) => {
+}: {
+  address: string;
+  walletProvider?: Eip1193Provider;
+  chain: EVMChain;
+  provider: BrowserProvider;
+}) => {
   if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
-  const { getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
   const signer = await provider.getSigner();
-
-  const toolbox = getToolboxByChain(chain)({ provider, signer });
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
 
   if (chain !== Chain.Ethereum) {
     const currentNetwork = await provider.getNetwork();
     if (currentNetwork.chainId.toString() !== ChainToHexChainId[chain]) {
       try {
-        const networkParams = (toolbox as NonETHToolbox).getNetworkParams();
+        const networkParams = toolbox.getNetworkParams();
         await switchEVMWalletNetwork(provider, chain, networkParams);
       } catch (_error) {
         throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
@@ -71,7 +67,11 @@ export const getWeb3WalletMethods = async ({
     }
   }
 
-  return prepareNetworkSwitch<typeof toolbox>({ toolbox, chain, provider });
+  return prepareNetworkSwitch({
+    toolbox: { ...toolbox, getBalance: () => toolbox.getBalance(address) },
+    chain,
+    provider,
+  });
 };
 
 export const evmWallet = createWallet({
@@ -84,35 +84,26 @@ export const evmWallet = createWallet({
       eip1193Provider?: Eip1193Provider,
     ) {
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const { getProvider } = await import("@swapkit/toolboxes/evm");
       const { BrowserProvider } = await import("ethers");
 
       await Promise.all(
         filteredChains.map(async (chain) => {
           if (walletType === WalletOption.EIP6963) {
             if (!eip1193Provider) throw new Error("Missing provider");
+
             const provider = new BrowserProvider(eip1193Provider, "any");
             await provider.send("eth_requestAccounts", []);
             const signer = await provider.getSigner();
             const address = await signer.getAddress();
 
             const walletMethods = await getWeb3WalletMethods({
+              address,
               chain,
               provider,
               walletProvider: eip1193Provider,
             });
 
-            const getBalance = async (potentialScamFilter = true) =>
-              walletMethods.getBalance(address, potentialScamFilter, getProvider(chain));
-
-            addChain({
-              ...walletMethods,
-              address,
-              balance: [],
-              chain,
-              getBalance,
-              walletType,
-            });
+            addChain({ ...walletMethods, address, chain, walletType });
             return;
           }
 
@@ -122,26 +113,16 @@ export const evmWallet = createWallet({
           const address = await signer.getAddress();
 
           const walletMethods = await getWeb3WalletMethods({
+            address,
             chain,
             walletProvider: getWalletForType(walletType),
             provider: web3provider,
           });
 
-          const getBalance = (potentialScamFilter = true) =>
-            walletMethods.getBalance(address, potentialScamFilter, getProvider(chain));
-
           const disconnect = () =>
             web3provider.send("wallet_revokePermissions", [{ eth_accounts: {} }]);
 
-          addChain({
-            ...walletMethods,
-            address,
-            balance: [],
-            chain,
-            disconnect,
-            getBalance,
-            walletType,
-          });
+          addChain({ ...walletMethods, address, chain, disconnect, walletType });
         }),
       );