@tcswap/wallet-extensions 4.1.16

package/package.json

@@ -0,0 +1,133 @@
+{
+  "author": "swapkit-oss",
+  "dependencies": {
+    "@keplr-wallet/types": "0.12.285",
+    "@near-js/accounts": "~2.5.0",
+    "@near-js/crypto": "~2.5.0",
+    "@near-js/transactions": "~2.5.0",
+    "@solana/web3.js": "~1.98.0",
+    "@tcswap/helpers": "4.5.15",
+    "@tcswap/toolboxes": "4.3.15",
+    "@tcswap/wallet-core": "4.0.59",
+    "ethers": "^6.14.0",
+    "sats-connect": "~1.0.0",
+    "ts-pattern": "~5.9.0"
+  },
+  "description": "USwap - Wallet Extension",
+  "devDependencies": {
+    "@keplr-wallet/types": "0.12.285",
+    "@near-js/accounts": "2.5.0",
+    "@near-js/crypto": "2.5.0",
+    "@near-js/transactions": "2.5.0",
+    "@solana/web3.js": "1.98.4",
+    "ethers": "6.15.0",
+    "sats-connect": "1.0.0",
+    "ts-pattern": "5.9.0"
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "default": "./dist/src/index.js",
+      "require": "./dist/src/index.cjs",
+      "types": "./dist/types/types.d.ts"
+    },
+    "./bitget": {
+      "bun": "./src/bitget/index.ts",
+      "default": "./dist/src/bitget/index.js",
+      "require": "./dist/src/bitget/index.cjs",
+      "types": "./dist/types/bitget/index.d.ts"
+    },
+    "./cosmostation": {
+      "bun": "./src/cosmostation/index.ts",
+      "default": "./dist/src/cosmostation/index.js",
+      "require": "./dist/src/cosmostation/index.cjs",
+      "types": "./dist/types/cosmostation/index.d.ts"
+    },
+    "./ctrl": {
+      "bun": "./src/ctrl/index.ts",
+      "default": "./dist/src/ctrl/index.js",
+      "require": "./dist/src/ctrl/index.cjs",
+      "types": "./dist/types/ctrl/index.d.ts"
+    },
+    "./evm-extensions": {
+      "bun": "./src/evm-extensions/index.ts",
+      "default": "./dist/src/evm-extensions/index.js",
+      "require": "./dist/src/evm-extensions/index.cjs",
+      "types": "./dist/types/evm-extensions/index.d.ts"
+    },
+    "./keepkey-bex": {
+      "bun": "./src/keepkey-bex/index.ts",
+      "default": "./dist/src/keepkey-bex/index.js",
+      "require": "./dist/src/keepkey-bex/index.cjs",
+      "types": "./dist/types/keepkey-bex/index.d.ts"
+    },
+    "./keplr": {
+      "bun": "./src/keplr/index.ts",
+      "default": "./dist/src/keplr/index.js",
+      "require": "./dist/src/keplr/index.cjs",
+      "types": "./dist/types/keplr/index.d.ts"
+    },
+    "./okx": {
+      "bun": "./src/okx/index.ts",
+      "default": "./dist/src/okx/index.js",
+      "require": "./dist/src/okx/index.cjs",
+      "types": "./dist/types/okx/index.d.ts"
+    },
+    "./onekey": {
+      "bun": "./src/onekey/index.ts",
+      "default": "./dist/src/onekey/index.js",
+      "require": "./dist/src/onekey/index.cjs",
+      "types": "./dist/types/onekey/index.d.ts"
+    },
+    "./phantom": {
+      "bun": "./src/phantom/index.ts",
+      "default": "./dist/src/phantom/index.js",
+      "require": "./dist/src/phantom/index.cjs",
+      "types": "./dist/types/phantom/index.d.ts"
+    },
+    "./polkadotjs": {
+      "bun": "./src/polkadotjs/index.ts",
+      "default": "./dist/src/polkadotjs/index.js",
+      "require": "./dist/src/polkadotjs/index.cjs",
+      "types": "./dist/types/polkadotjs/index.d.ts"
+    },
+    "./talisman": {
+      "bun": "./src/talisman/index.ts",
+      "default": "./dist/src/talisman/index.js",
+      "require": "./dist/src/talisman/index.cjs",
+      "types": "./dist/types/talisman/index.d.ts"
+    },
+    "./tronlink": {
+      "bun": "./src/tronlink/index.ts",
+      "default": "./dist/src/tronlink/index.js",
+      "require": "./dist/src/tronlink/index.cjs",
+      "types": "./dist/types/tronlink/index.d.ts"
+    },
+    "./vultisig": {
+      "bun": "./src/vultisig/index.ts",
+      "default": "./dist/src/vultisig/index.js",
+      "require": "./dist/src/vultisig/index.cjs",
+      "types": "./dist/types/vultisig/index.d.ts"
+    }
+  },
+  "files": ["dist/", "src/"],
+  "homepage": "https://github.com/thorchain/TCSwap",
+  "license": "Apache-2.0",
+  "name": "@tcswap/wallet-extensions",
+  "repository": {
+    "directory": "packages/wallet-extension",
+    "type": "git",
+    "url": "git+https://github.com/thorchain/TCSwap.git"
+  },
+  "scripts": {
+    "build": "bun run ./build.ts",
+    "build:clean": "rm -rf dist && bun run ./build.ts",
+    "clean": "rm -rf dist node_modules *.tsbuildinfo",
+    "test": "echo 'bun test'",
+    "test:ci": "echo 'bun test --coverage'",
+    "type-check": "bun tsc --noEmit",
+    "type-check:go": "tsgo"
+  },
+  "type": "module",
+  "version": "4.1.16"
+}

package/src/bitget/helpers.ts

@@ -0,0 +1,181 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  Chain,
+  type EVMChain,
+  GAIAConfig,
+  prepareNetworkSwitch,
+  switchEVMWalletNetwork,
+  USwapError,
+} from "@tcswap/helpers";
+import type { TronTransaction } from "@tcswap/toolboxes/tron";
+import { Psbt } from "bitcoinjs-lib";
+import type { Eip1193Provider } from "ethers";
+
+export async function getWalletMethods(chain: Chain) {
+  const { match, P } = await import("ts-pattern");
+  const bitget = window.bitkeep;
+
+  return match(chain)
+    .with(
+      P.union(
+        Chain.Arbitrum,
+        Chain.Aurora,
+        Chain.Avalanche,
+        Chain.Base,
+        Chain.Berachain,
+        Chain.BinanceSmartChain,
+        Chain.Ethereum,
+        Chain.Gnosis,
+        Chain.Monad,
+        Chain.Optimism,
+        Chain.Polygon,
+        Chain.XLayer,
+      ),
+      async () => {
+        if (!(bitget && "ethereum" in bitget)) {
+          throw new USwapError("wallet_bitkeep_not_found");
+        }
+
+        const wallet = bitget.ethereum;
+
+        const [address]: [string] = await wallet.send("eth_requestAccounts", []);
+        const evmWallet = await getWeb3WalletMethods({ chain: chain as EVMChain, walletProvider: wallet });
+
+        return { ...evmWallet, address };
+      },
+    )
+    .with(Chain.Bitcoin, async () => {
+      if (!(bitget && "unisat" in bitget)) {
+        throw new USwapError("wallet_bitkeep_not_found");
+      }
+      const { unisat: wallet } = bitget;
+
+      const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+      const [address] = await wallet.requestAccounts();
+
+      async function signTransaction(psbt: Psbt) {
+        const signedPsbt = await wallet.signPsbt(psbt.toHex(), { autoFinalized: false });
+
+        return Psbt.fromHex(signedPsbt);
+      }
+
+      const signer = { getAddress: () => Promise.resolve(address), signTransaction };
+
+      const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
+
+      return { ...toolbox, address };
+    })
+    .with(Chain.Cosmos, async () => {
+      if (!(bitget && "keplr" in bitget)) {
+        throw new USwapError("wallet_bitkeep_not_found");
+      }
+      const { keplr: wallet } = bitget;
+
+      await wallet.enable(GAIAConfig.chainId);
+      const offlineSigner = wallet.getOfflineSignerOnlyAmino(GAIAConfig.chainId);
+      const accounts = await offlineSigner.getAccounts();
+      if (!accounts?.[0]) throw new USwapError("wallet_bitkeep_no_accounts", { chain: Chain.Cosmos });
+
+      const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+      const [{ address }] = accounts;
+
+      const signer = {
+        ...offlineSigner,
+        getAddress: () => Promise.resolve(address),
+        signTransaction: async () => Promise.resolve({} as any),
+      };
+
+      const toolbox = await getCosmosToolbox(Chain.Cosmos, { signer });
+
+      return { ...toolbox, address };
+    })
+    .with(Chain.Solana, async () => {
+      if (!(bitget && "solana" in bitget)) {
+        throw new USwapError("wallet_bitkeep_not_found");
+      }
+
+      const { getSolanaToolbox } = await import("@tcswap/toolboxes/solana");
+      const provider = bitget?.solana;
+
+      // Connect to get the public key
+      const providerConnection = await provider.connect();
+      const address: string = providerConnection.publicKey.toString();
+
+      // Create a proper signer object that wraps the provider
+      const signer = { ...provider, getAddress: async () => address, publicKey: providerConnection.publicKey };
+
+      const toolbox = await getSolanaToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .with(Chain.Tron, async () => {
+      if (!(bitget && "tronLink" in bitget && "tronWeb" in bitget)) {
+        throw new USwapError("wallet_bitkeep_not_found");
+      }
+
+      const { createTronToolbox } = await import("@tcswap/toolboxes/tron");
+      const { tronLink, tronWeb } = bitget;
+
+      // Request account access
+      const response = await tronLink.request({ method: "tron_requestAccounts" });
+
+      // Check if the request was successful
+      if (response.code !== 200) {
+        throw new USwapError("wallet_connection_rejected_by_user", {
+          message: response.message || "User rejected connection",
+        });
+      }
+
+      // After successful approval, the address should be available in tronWeb.defaultAddress
+      const address = tronWeb.defaultAddress?.base58;
+
+      if (!address) {
+        throw new USwapError("wallet_bitkeep_no_accounts", { chain: Chain.Tron });
+      }
+
+      // Create signer compatible with TronSigner interface
+      const signer = {
+        getAddress: () => Promise.resolve(address),
+        signTransaction: async (transaction: TronTransaction) => {
+          const signedTx = await tronWeb.trx.sign(transaction);
+          return signedTx;
+        },
+      };
+
+      const toolbox = await createTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    })
+    .otherwise(() => {
+      throw new USwapError("wallet_chain_not_supported");
+    });
+}
+
+export const getWeb3WalletMethods = async ({
+  chain,
+  walletProvider,
+}: {
+  walletProvider?: Eip1193Provider;
+  chain: EVMChain;
+}) => {
+  const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+  const { BrowserProvider } = await import("ethers");
+  if (!walletProvider) throw new USwapError("wallet_provider_not_found");
+
+  const provider = new BrowserProvider(walletProvider, "any");
+  const signer = await provider.getSigner();
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+  try {
+    if (chain !== Chain.Ethereum && "getNetworkParams" in toolbox) {
+      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
+    }
+  } catch {
+    throw new USwapError("wallet_bitkeep_failed_to_switch_network", { chain });
+  }
+
+  return prepareNetworkSwitch({ chain, provider, toolbox });
+};

package/src/bitget/index.ts

@@ -0,0 +1,26 @@
+import { Chain, EVMChains, filterSupportedChains, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+import { getWalletMethods } from "./helpers";
+
+export const bitgetWallet = createWallet({
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectBitget(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods(chain);
+
+          addChain({ ...walletMethods, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectBitget",
+  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana, Chain.Tron],
+  walletType: WalletOption.BITGET,
+});
+
+export const BITGET_SUPPORTED_CHAINS = getWalletSupportedChains(bitgetWallet);

package/src/cosmostation/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { Keplr } from "@keplr-wallet/types";
+import { Chain, ChainId, ChainToChainId, filterSupportedChains, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+const cosmostationSupportedChainIds = [ChainId.Cosmos, ChainId.Kujira, ChainId.Noble, ChainId.THORChain] as const;
+const cosmostationSupportedEVMChains = [
+  Chain.Ethereum,
+  Chain.BinanceSmartChain,
+  Chain.Avalanche,
+  Chain.Polygon,
+  Chain.Arbitrum,
+  Chain.Optimism,
+  Chain.Base,
+  Chain.XLayer,
+] as const;
+
+declare global {
+  interface Window {
+    cosmostation?: { providers?: { keplr?: Keplr } };
+  }
+}
+
+async function connectCosmosChains(chains: Chain[], addChain: any, keplrProvider: Keplr) {
+  await Promise.all(
+    chains.map(async (chain) => {
+      const chainId = ChainToChainId[chain] as (typeof cosmostationSupportedChainIds)[number];
+
+      await keplrProvider.enable(chainId);
+      const signer = keplrProvider.getOfflineSignerOnlyAmino(chainId);
+      if (!signer) throw new USwapError("wallet_cosmostation_signer_not_found");
+
+      const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+
+      const accounts = await signer.getAccounts();
+      if (!accounts?.[0]?.address) throw new USwapError("wallet_cosmostation_no_accounts");
+
+      const [{ address }] = accounts;
+      const toolbox = await getCosmosToolbox(chain as any, { signer });
+
+      addChain({ ...toolbox, address, chain, walletType: WalletOption.COSMOSTATION });
+    }),
+  );
+}
+
+async function connectEvmChains(chains: Chain[], addChain: any) {
+  const provider = window.ethereum;
+
+  if (!provider) {
+    throw new USwapError("wallet_cosmostation_evm_provider_not_found");
+  }
+
+  const accounts = (await provider.request({ method: "eth_requestAccounts" })) as string[];
+
+  if (!accounts || accounts.length === 0) {
+    throw new USwapError("wallet_cosmostation_no_evm_accounts");
+  }
+
+  const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+
+  for (const chain of chains) {
+    const toolbox = getEvmToolbox(chain as any, { provider });
+    const [address] = accounts;
+
+    if (!address) {
+      throw new USwapError("wallet_cosmostation_no_evm_address");
+    }
+
+    addChain({ ...toolbox, address, chain, walletType: WalletOption.COSMOSTATION });
+  }
+}
+
+export const cosmostationWallet = createWallet({
+  connect: ({ addChain, supportedChains }) =>
+    async function connectCosmostation(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType: WalletOption.COSMOSTATION });
+
+      if (!window.cosmostation) {
+        throw new USwapError("wallet_cosmostation_not_found");
+      }
+
+      const cosmosChains = filteredChains.filter((chain) =>
+        cosmostationSupportedChainIds.includes(ChainToChainId[chain] as any),
+      );
+      const evmChains = filteredChains.filter((chain) => cosmostationSupportedEVMChains.includes(chain as any));
+
+      if (cosmosChains.length > 0) {
+        const keplrProvider = window.cosmostation.providers?.keplr;
+        if (!keplrProvider) {
+          throw new USwapError("wallet_cosmostation_keplr_provider_not_found");
+        }
+
+        await connectCosmosChains(cosmosChains, addChain, keplrProvider);
+      }
+
+      if (evmChains.length > 0) {
+        await connectEvmChains(evmChains, addChain);
+      }
+
+      return true;
+    },
+  name: "connectCosmostation",
+  supportedChains: [
+    Chain.Cosmos,
+    Chain.Kujira,
+    Chain.Noble,
+    Chain.THORChain,
+    Chain.Ethereum,
+    Chain.BinanceSmartChain,
+    Chain.Avalanche,
+    Chain.Polygon,
+    Chain.Arbitrum,
+    Chain.Optimism,
+    Chain.Base,
+    Chain.XLayer,
+  ],
+});
+
+export const COSMOSTATION_SUPPORTED_CHAINS = getWalletSupportedChains(cosmostationWallet);

package/src/ctrl/index.ts

@@ -0,0 +1,194 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  Chain,
+  ChainToChainId,
+  filterSupportedChains,
+  type GenericTransferParams,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+import { getCtrlAddress, getCtrlProvider, walletTransfer } from "./walletHelpers";
+
+export const ctrlWallet = createWallet({
+  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;
+    },
+  name: "connectCtrl",
+  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.Monad,
+    Chain.Near,
+    Chain.Noble,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Solana,
+    Chain.THORChain,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.CTRL,
+});
+
+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("@tcswap/toolboxes/solana");
+      const provider = getCtrlProvider(chain);
+
+      if (!provider) {
+        throw new USwapError("wallet_ctrl_not_found");
+      }
+      const toolbox = await getSolanaToolbox({ signer: provider });
+
+      return toolbox;
+    }
+
+    case Chain.Maya:
+    case Chain.THORChain: {
+      const { getCosmosToolbox, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import("@tcswap/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:
+    case Chain.Noble: {
+      const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+      const chainId = ChainToChainId[chain];
+      const provider = getCtrlProvider(chain);
+
+      await provider?.enable(chainId);
+      const signer = provider?.getOfflineSignerOnlyAmino(chainId, { preferNoSetFee: true });
+
+      if (!signer) {
+        throw new USwapError("wallet_ctrl_not_found");
+      }
+
+      const toolbox = await getCosmosToolbox(chain, { signer });
+
+      return toolbox;
+    }
+
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      const { getUtxoToolbox } = await import("@tcswap/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.Monad:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.XLayer: {
+      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@tcswap/helpers");
+      const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+      const { BrowserProvider } = await import("ethers");
+      const ethereumWindowProvider = getCtrlProvider(chain);
+
+      if (!ethereumWindowProvider) {
+        throw new USwapError("wallet_ctrl_not_found");
+      }
+
+      const provider = new BrowserProvider(ethereumWindowProvider, "any");
+      const signer = await provider.getSigner();
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+      try {
+        if (chain !== Chain.Ethereum) {
+          const networkParams = toolbox.getNetworkParams();
+          await switchEVMWalletNetwork(provider, chain, networkParams);
+        }
+      } catch {
+        throw new USwapError({
+          errorKey: "wallet_failed_to_add_or_switch_network",
+          info: { chain, wallet: WalletOption.CTRL },
+        });
+      }
+
+      return prepareNetworkSwitch({ chain, provider, toolbox });
+    }
+
+    case Chain.Near: {
+      const provider = getCtrlProvider(chain);
+
+      if (!provider) {
+        throw new USwapError("wallet_ctrl_not_found", { chain: Chain.Near });
+      }
+
+      const { createNearSignerFromProvider } = await import("../helpers/near");
+      const { getNearToolbox } = await import("@tcswap/toolboxes/near");
+
+      const signer = await createNearSignerFromProvider(provider, "CTRL");
+      const accountId = await signer.getAddress();
+      const toolbox = await getNearToolbox({ signer });
+
+      const transfer = async (params: GenericTransferParams) => {
+        const { actionCreators } = await import("@near-js/transactions");
+
+        const amountInYocto = params.assetValue.getBaseValue("string");
+        const action = actionCreators.transfer(BigInt(amountInYocto));
+
+        const transaction = { actions: [action], receiverId: params.recipient, signerId: accountId };
+
+        const txHash: string = await provider.request({ method: "signAndSendTransaction", params: { transaction } });
+
+        return txHash;
+      };
+
+      return { ...toolbox, transfer };
+    }
+
+    default:
+      return null;
+  }
+}