@swapkit/wallets 4.0.0-beta.54 → 4.0.0-beta.56

package/src/ctrl/index.ts

@@ -1,248 +0,0 @@
-import {
-  Chain,
-  ChainToChainId,
-  type GenericTransferParams,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-
-import type { NearCreateTransactionParams } from "@swapkit/toolboxes/near";
-import { getWalletSupportedChains } from "../utils";
-import { getCtrlAddress, getCtrlMethods, getCtrlProvider, walletTransfer } from "./walletHelpers";
-
-export const ctrlWallet = createWallet({
-  name: "connectCtrl",
-  walletType: WalletOption.CTRL,
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.Berachain,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    Chain.Kujira,
-    Chain.Litecoin,
-    Chain.Maya,
-    Chain.Near,
-    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.Aurora:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.Berachain:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Gnosis:
-    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,
-        },
-      });
-    }
-
-    case Chain.Near: {
-      if (!window.xfi?.near) {
-        throw new SwapKitError("wallet_ctrl_not_found", { chain: Chain.Near });
-      }
-
-      const { createNearSignerFromProvider } = await import("../helpers/near");
-      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
-
-      const provider = window.xfi.near;
-      const signer = await createNearSignerFromProvider(provider, "CTRL");
-      const accountId = await signer.getAddress();
-      const toolbox = await getNearToolbox({ signer });
-
-      // Override transfer method to use CTRL's direct API
-      const transfer = async (params: GenericTransferParams) => {
-        const { transfer: transferAction } = await import("near-api-js/lib/transaction");
-
-        // Convert AssetValue to NEAR amount (yoctoNEAR)
-        const amountInYocto = params.assetValue.getBaseValue("string");
-
-        // Create transfer action
-        const action = transferAction(BigInt(amountInYocto));
-
-        // Create transaction object for CTRL
-        const transaction = {
-          signerId: accountId,
-          receiverId: params.recipient,
-          actions: [action],
-        };
-
-        const txHash: string = await provider.request({
-          method: "signAndSendTransaction",
-          params: {
-            transaction,
-          },
-        });
-
-        return txHash;
-      };
-
-      // Override createTransaction to build NEAR transactions for CTRL
-      const createTransaction = async (params: NearCreateTransactionParams) => {
-        const { functionCall, transfer: transferAction } = await import(
-          "near-api-js/lib/transaction"
-        );
-
-        if (params.functionCall) {
-          // Function call transaction
-          const { methodName, args, attachedDeposit } = params.functionCall;
-          const action = functionCall(
-            methodName,
-            args,
-            BigInt("30000000000000"), // 30 TGas default
-            BigInt(attachedDeposit || "0"),
-          );
-
-          return {
-            signerId: accountId,
-            receiverId: params.recipient,
-            actions: [action],
-          };
-        }
-
-        // Simple transfer transaction
-        const amountInYocto = params.assetValue.getBaseValue("string");
-        const action = transferAction(BigInt(amountInYocto));
-
-        return {
-          signerId: accountId,
-          receiverId: params.recipient,
-          actions: [action],
-        };
-      };
-
-      return {
-        ...toolbox,
-        transfer,
-        createTransaction,
-      };
-    }
-
-    default:
-      return null;
-  }
-}

package/src/ctrl/walletHelpers.ts

@@ -1,297 +0,0 @@
-import type { Keplr } from "@keplr-wallet/types";
-import {
-  type AssetValue,
-  Chain,
-  ChainToChainId,
-  type EVMChain,
-  EVMChains,
-  type FeeOption,
-  SwapKitError,
-  WalletOption,
-  providerRequest,
-} from "@swapkit/helpers";
-import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
-import type { SolanaProvider } from "@swapkit/toolboxes/solana";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-
-type TransactionMethod = "transfer" | "deposit";
-
-type TransactionParams = {
-  asset: string | { chain: string; symbol: string; ticker: string };
-  amount: number | string | { amount: number; decimals?: number };
-  decimal?: number;
-  recipient: string;
-  memo?: string;
-};
-
-export type WalletTxParams = {
-  feeOptionKey?: FeeOption;
-  from?: string;
-  memo?: string;
-  recipient: string;
-  assetValue: AssetValue;
-  gasLimit?: string | bigint;
-};
-
-export async function getCtrlProvider<T extends Chain>(
-  chain: T,
-): 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");
-  const { match } = await import("ts-pattern");
-
-  // @ts-expect-error
-  return match(chain as Chain)
-    .with(
-      Chain.Arbitrum,
-      Chain.Aurora,
-      Chain.Avalanche,
-      Chain.Base,
-      Chain.Berachain,
-      Chain.BinanceSmartChain,
-      Chain.Ethereum,
-      Chain.Gnosis,
-      Chain.Optimism,
-      Chain.Polygon,
-      () => window.xfi?.ethereum,
-    )
-    .with(Chain.Cosmos, Chain.Kujira, () => 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)
-    .with(Chain.THORChain, () => window.xfi?.thorchain)
-    .with(Chain.Maya, () => window.xfi?.mayachain)
-    .otherwise(() => undefined);
-}
-
-async function transaction({
-  method,
-  params,
-  chain,
-}: {
-  method: TransactionMethod;
-  params: TransactionParams[];
-  chain: Chain;
-}): Promise<string> {
-  const client = await getCtrlProvider(chain);
-
-  return new Promise<string>((resolve, reject) => {
-    if (client && "request" in client) {
-      // @ts-ignore
-      client.request({ method, params }, (err: string, tx: string) => {
-        err ? reject(err) : resolve(tx);
-      });
-    }
-  });
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-export async function getCtrlAddress(chain: Chain) {
-  try {
-    const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
-    if (!eipProvider) {
-      throw new SwapKitError({
-        errorKey: "wallet_provider_not_found",
-        info: { wallet: WalletOption.CTRL, chain },
-      });
-    }
-
-    if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
-      const provider = await getCtrlProvider(Chain.Cosmos);
-      if (!provider || "request" in provider) {
-        throw new SwapKitError({
-          errorKey: "wallet_provider_not_found",
-          info: { wallet: WalletOption.CTRL, chain },
-        });
-      }
-
-      // Enabling before using the Keplr is recommended.
-      // This method will ask the user whether to allow access if they haven't visited this website.
-      // Also, it will request that the user unlock the wallet if the wallet is locked.
-      const chainId = ChainToChainId[chain];
-      await provider.enable(chainId);
-
-      const offlineSigner = provider.getOfflineSigner(chainId);
-
-      const [item] = await offlineSigner.getAccounts();
-      return item?.address;
-    }
-
-    if (EVMChains.includes(chain as EVMChain)) {
-      // For CTRL wallet, we need to use the request method directly on the provider
-      if ("request" in eipProvider && typeof eipProvider.request === "function") {
-        const accounts = await eipProvider.request({ method: "eth_requestAccounts" });
-        return accounts[0];
-      }
-      const { BrowserProvider } = await import("ethers");
-      const provider = new BrowserProvider(eipProvider, "any");
-      const [response] = await providerRequest({
-        provider,
-        method: "eth_requestAccounts",
-        params: [],
-      });
-      return response;
-    }
-
-    if (chain === Chain.Solana) {
-      const provider = await getCtrlProvider(Chain.Solana);
-
-      const accounts = await provider.connect();
-      return accounts.publicKey.toString();
-    }
-
-    if (chain === Chain.Near) {
-      if (!window.xfi?.near) {
-        throw new SwapKitError("wallet_ctrl_not_found", { chain: Chain.Near });
-      }
-
-      if (!window.xfi.near.isSignedIn?.()) {
-        const result = await window.xfi.near.request<string[]>?.({
-          method: "connect",
-        });
-        return result?.[0] || "";
-      }
-
-      return window.xfi.near.getAccountId?.() || "";
-    }
-
-    const accounts = await eipProvider.request({ method: "request_accounts", params: [] });
-    return accounts[0];
-  } catch (_error) {
-    throw new SwapKitError({
-      errorKey: "wallet_provider_not_found",
-      info: { wallet: WalletOption.CTRL, chain },
-    });
-  }
-}
-
-export async function walletTransfer(
-  { assetValue, recipient, memo, gasLimit }: WalletTxParams,
-  method: TransactionMethod = "transfer",
-) {
-  if (!assetValue) {
-    throw new SwapKitError("wallet_ctrl_asset_not_defined");
-  }
-
-  /**
-   * EVM requires amount to be hex string
-   * UTXO/Cosmos requires amount to be number
-   */
-
-  const from = await getCtrlAddress(assetValue.chain);
-  const params = [
-    {
-      amount: {
-        amount: assetValue.getBaseValue("number"),
-        decimals: assetValue.decimal,
-      },
-      asset: {
-        chain: assetValue.chain,
-        symbol: assetValue.symbol.toUpperCase(),
-        ticker: assetValue.symbol.toUpperCase(),
-      },
-      memo: memo || "",
-      from,
-      recipient,
-      gasLimit,
-    },
-  ];
-
-  return transaction({ method, params, chain: assetValue.chain });
-}
-
-export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
-  return {
-    call: async <T>({
-      contractAddress,
-      abi,
-      funcName,
-      funcParams = [],
-      txOverrides,
-    }: CallParams): Promise<T> => {
-      if (!contractAddress) {
-        throw new SwapKitError("wallet_ctrl_contract_address_not_provided");
-      }
-      const { createContract, getCreateContractTxObject, isStateChangingCall } = await import(
-        "@swapkit/toolboxes/evm"
-      );
-
-      const isStateChanging = isStateChangingCall({ abi, funcName });
-
-      if (isStateChanging) {
-        const createTx = getCreateContractTxObject({ provider, chain });
-        const { value, from, to, data } = await createTx({
-          contractAddress,
-          abi,
-          funcName,
-          funcParams,
-          txOverrides,
-        });
-
-        const signer = await provider.getSigner();
-        const tx = await signer.sendTransaction({
-          value: BigInt(value || 0),
-          from,
-          to,
-          data: data || "0x",
-        });
-        return tx.hash as T;
-      }
-      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, getCreateContractTxObject } = await import("@swapkit/toolboxes/evm");
-      const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
-      const txOverrides = { from };
-
-      const functionCallParams = {
-        contractAddress: assetAddress,
-        abi: erc20ABI,
-        funcName: "approve",
-        funcParams,
-        txOverrides,
-      };
-
-      const createTx = getCreateContractTxObject({ provider, chain });
-      const { value, to, data } = await createTx(functionCallParams);
-
-      const signer = await provider.getSigner();
-      const tx = await signer.sendTransaction({
-        value: BigInt(value || 0),
-        from,
-        to,
-        data: data || "0x",
-      });
-      return tx.hash;
-    },
-    sendTransaction: async (txParams: EVMTxParams) => {
-      const { from, to, data, value } = txParams;
-      if (!to) {
-        throw new SwapKitError("wallet_ctrl_send_transaction_no_address");
-      }
-
-      const signer = await provider.getSigner();
-      const tx = await signer.sendTransaction({
-        value: BigInt(value || 0),
-        from,
-        to,
-        data: data || "0x",
-      });
-      return tx.hash;
-    },
-  };
-}

package/src/evm-extensions/index.ts

@@ -1,134 +0,0 @@
-import {
-  Chain,
-  ChainToHexChainId,
-  type EVMChain,
-  EVMChains,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-  prepareNetworkSwitch,
-  switchEVMWalletNetwork,
-} from "@swapkit/helpers";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../utils";
-
-export type EVMWalletOptions =
-  | WalletOption.BRAVE
-  | WalletOption.OKX_MOBILE
-  | WalletOption.METAMASK
-  | WalletOption.TRUSTWALLET_WEB
-  | WalletOption.COINBASE_WEB
-  | WalletOption.EIP6963;
-
-const getWalletForType = (
-  walletType:
-    | WalletOption.BRAVE
-    | WalletOption.OKX_MOBILE
-    | WalletOption.METAMASK
-    | WalletOption.TRUSTWALLET_WEB
-    | WalletOption.COINBASE_WEB,
-) => {
-  switch (walletType) {
-    case WalletOption.COINBASE_WEB:
-      return window.coinbaseWalletExtension;
-    case WalletOption.TRUSTWALLET_WEB:
-      return window.trustwallet;
-    default:
-      return window.ethereum;
-  }
-};
-
-export const getWeb3WalletMethods = async ({
-  address,
-  walletProvider,
-  chain,
-  provider,
-}: {
-  address: string;
-  walletProvider?: Eip1193Provider;
-  chain: EVMChain;
-  provider: BrowserProvider;
-}) => {
-  if (!walletProvider) throw new SwapKitError("wallet_evm_extensions_not_found");
-  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-  const signer = await provider.getSigner();
-  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.getNetworkParams();
-        await switchEVMWalletNetwork(provider, chain, networkParams);
-      } catch (_error) {
-        throw new SwapKitError("wallet_evm_extensions_failed_to_switch_network", { chain });
-      }
-    }
-  }
-
-  return prepareNetworkSwitch({
-    toolbox: { ...toolbox, getBalance: () => toolbox.getBalance(address) },
-    chain,
-    provider,
-  });
-};
-
-export const evmWallet = createWallet({
-  name: "connectEVMWallet",
-  supportedChains: [...EVMChains] as EVMChain[],
-  connect: ({ addChain, supportedChains }) =>
-    async function connectEVMWallet(
-      chains: Chain[],
-      walletType: EVMWalletOptions = WalletOption.METAMASK,
-      eip1193Provider?: Eip1193Provider,
-    ) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const { BrowserProvider } = await import("ethers");
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          if (walletType === WalletOption.EIP6963) {
-            if (!eip1193Provider) throw new SwapKitError("wallet_evm_extensions_no_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,
-            });
-
-            addChain({ ...walletMethods, address, chain, walletType });
-            return;
-          }
-
-          const web3provider = new BrowserProvider(getWalletForType(walletType), "any");
-          await web3provider.send("eth_requestAccounts", []);
-          const signer = await web3provider.getSigner();
-          const address = await signer.getAddress();
-
-          const walletMethods = await getWeb3WalletMethods({
-            address,
-            chain,
-            walletProvider: getWalletForType(walletType),
-            provider: web3provider,
-          });
-
-          const disconnect = () =>
-            web3provider.send("wallet_revokePermissions", [{ eth_accounts: {} }]);
-
-          addChain({ ...walletMethods, address, chain, disconnect, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const EVM_EXTENSIONS_SUPPORTED_CHAINS = getWalletSupportedChains(evmWallet);