@tcswap/wallet-extensions 4.1.16

package/src/onekey/evmSigner.ts

@@ -0,0 +1,116 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { Chain, DerivationPathArray } from "@tcswap/helpers";
+import { USwapError, WalletOption } from "@tcswap/helpers";
+import type { JsonRpcProvider, Provider, Signer, TypedDataDomain, TypedDataField } from "ethers";
+
+type OneKeyEVMSignerParams = {
+  chain: Chain;
+  derivationPath: DerivationPathArray;
+  provider: Provider | JsonRpcProvider;
+};
+
+export async function getEVMSigner({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
+  const { AbstractSigner, BrowserProvider } = await import("ethers");
+
+  class OneKeySigner extends AbstractSigner {
+    address: string;
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    readonly provider: Provider | JsonRpcProvider;
+
+    constructor({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
+      super(provider);
+
+      this.address = "";
+      this.chain = chain;
+      this.derivationPath = derivationPath;
+      this.provider = provider;
+    }
+
+    connect(provider: null | Provider): Signer {
+      if (!provider) {
+        throw new USwapError({
+          errorKey: "wallet_provider_not_found",
+          info: { chain: this.chain, wallet: WalletOption.ONEKEY },
+        });
+      }
+
+      return new OneKeySigner({ chain: this.chain, derivationPath: this.derivationPath, provider });
+    }
+
+    signTypedData(
+      domain: TypedDataDomain,
+      types: Record<string, TypedDataField[]>,
+      value: Record<string, any>,
+    ): Promise<string> {
+      if (!window.$onekey?.ethereum) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain: this.chain } });
+      }
+
+      return this.getAddress().then(async (_address) => {
+        try {
+          const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+          return signer.signTypedData(domain, types, value);
+        } catch (error) {
+          throw new USwapError({
+            errorKey: "core_wallet_sign_message_not_supported",
+            info: { error, wallet: WalletOption.ONEKEY },
+          });
+        }
+      });
+    }
+
+    getAddress = async () => {
+      if (this.address) return this.address;
+
+      if (!window.$onekey?.ethereum) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain: this.chain } });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      this.address = await signer.getAddress();
+      return this.address;
+    };
+
+    signMessage = async (message: string) => {
+      if (!window.$onekey?.ethereum) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain: this.chain } });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      return signer.signMessage(message);
+    };
+
+    signTransaction = async (transaction: any) => {
+      if (!window.$onekey?.ethereum) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain: this.chain } });
+      }
+
+      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
+      const { to, value, gasLimit, gasPrice, data, maxFeePerGas, maxPriorityFeePerGas } = transaction;
+
+      if (!to) throw new USwapError("toolbox_evm_no_to_address");
+      if (!gasLimit) throw new USwapError("toolbox_evm_no_gas_price");
+
+      const tx: any = { data, gasLimit, to };
+
+      if (value) {
+        tx.value = value;
+      }
+
+      if (maxFeePerGas && maxPriorityFeePerGas) {
+        tx.maxFeePerGas = maxFeePerGas;
+        tx.maxPriorityFeePerGas = maxPriorityFeePerGas;
+      } else if (gasPrice) {
+        tx.gasPrice = gasPrice;
+      }
+
+      return signer.signTransaction(tx);
+    };
+  }
+
+  return new OneKeySigner({ chain, derivationPath, provider });
+}

package/src/onekey/index.ts

@@ -0,0 +1,182 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  addEVMWalletNetwork,
+  Chain,
+  filterSupportedChains,
+  type NetworkParams,
+  prepareNetworkSwitch,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import { Psbt } from "bitcoinjs-lib";
+import type { BitcoinProvider, GetAddressOptions, GetAddressResponse, SignTransactionOptions } from "sats-connect";
+
+async function getWalletMethodsForExtension(chain: Chain) {
+  switch (chain) {
+    case Chain.Bitcoin: {
+      if (!window.$onekey?.btc) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain } });
+      }
+
+      const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+      const {
+        signTransaction: satsSignTransaction,
+        getAddress,
+        AddressPurpose,
+        BitcoinNetworkType,
+      } = await import("sats-connect");
+
+      let address = "";
+
+      const getProvider = () => new Promise<BitcoinProvider>((res) => res(window.$onekey?.btc));
+
+      const getAddressOptions: GetAddressOptions = {
+        getProvider,
+        onCancel: () => {
+          throw new USwapError("wallet_connection_rejected_by_user");
+        },
+        onFinish: (response: GetAddressResponse) => {
+          if (response.addresses[0]?.address) {
+            address = response.addresses[0].address;
+          }
+        },
+        payload: {
+          message: "Address for receiving and sending payments",
+          network: { type: BitcoinNetworkType.Mainnet },
+          purposes: [AddressPurpose.Payment],
+        },
+      };
+
+      await getAddress(getAddressOptions);
+
+      async function signTransaction(psbt: Psbt) {
+        let signedPsbt: Psbt | undefined;
+        const signPsbtOptions: SignTransactionOptions = {
+          getProvider,
+          onCancel: () => {
+            throw new USwapError("wallet_connection_rejected_by_user");
+          },
+          onFinish: (response) => {
+            signedPsbt = Psbt.fromBase64(response.psbtBase64);
+          },
+          payload: {
+            broadcast: false,
+            inputsToSign: [{ address, signingIndexes: psbt.txInputs.map((_: any, index: number) => index) }],
+            message: "Sign transaction",
+            network: { type: BitcoinNetworkType.Mainnet },
+            psbtBase64: psbt.toBase64(),
+          },
+        };
+
+        await satsSignTransaction(signPsbtOptions);
+        if (!signedPsbt) throw new USwapError("wallet_onekey_sign_transaction_error");
+        return signedPsbt;
+      }
+
+      const signer = { getAddress: () => Promise.resolve(address), signTransaction };
+
+      const toolbox = await getUtxoToolbox(chain, { signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Solana: {
+      if (!window.$onekey?.sol) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain } });
+      }
+
+      const { getSolanaToolbox } = await import("@tcswap/toolboxes/solana");
+
+      const signer = window.$onekey.sol;
+      const address = await signer.getAddress();
+      const toolbox = await getSolanaToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Arbitrum:
+    case Chain.Aurora:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Gnosis:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.XLayer: {
+      const { getProvider, getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+      if (!window.$onekey?.ethereum) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { chain } });
+      }
+
+      const { BrowserProvider } = await import("ethers");
+      const provider = new BrowserProvider(window.$onekey.ethereum, "any");
+
+      await provider.send("eth_requestAccounts", []);
+      const jsonRpcProvider = await getProvider(chain);
+      const signer = await provider.getSigner();
+      const address = await signer.getAddress();
+
+      const toolbox = await getEvmToolbox(chain, { provider: jsonRpcProvider, signer });
+      try {
+        if (chain !== Chain.Ethereum) {
+          const networkParams = toolbox.getNetworkParams() as NetworkParams;
+
+          await addEVMWalletNetwork(provider, networkParams);
+        }
+      } catch (error) {
+        throw new USwapError({ errorKey: "wallet_failed_to_add_or_switch_network", info: { chain, error } });
+      }
+
+      return { address, ...prepareNetworkSwitch({ chain, provider, toolbox }) };
+    }
+
+    default:
+      throw new USwapError({ errorKey: "wallet_chain_not_supported", info: { chain, wallet: WalletOption.ONEKEY } });
+  }
+}
+
+export const onekeyWallet = createWallet({
+  connect: ({ addChain, walletType, supportedChains }) =>
+    async function connectOnekeyWallet(chains: Chain[]) {
+      if (!window.$onekey) {
+        throw new USwapError({ errorKey: "wallet_onekey_not_found", info: { wallet: WalletOption.ONEKEY } });
+      }
+
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethodsForExtension(chain);
+
+          const address = (await walletMethods.getAddress()) || "F";
+
+          addChain({ ...walletMethods, address, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectOnekeyWallet",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Aurora,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.Ethereum,
+    Chain.Gnosis,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Solana,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.ONEKEY,
+});
+
+export const ONEKEY_WALLET_SUPPORTED_CHAINS = getWalletSupportedChains(onekeyWallet);

package/src/phantom/index.ts

@@ -0,0 +1,136 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  type AssetValue,
+  Chain,
+  filterSupportedChains,
+  type GenericTransferParams,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+export const phantomWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectPhantom(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      try {
+        await Promise.all(
+          filteredChains.map(async (chain) => {
+            const { address, ...methods } = await getWalletMethods(chain);
+
+            addChain({ ...methods, address, chain, walletType });
+          }),
+        );
+
+        return true;
+      } catch (error) {
+        if (error instanceof USwapError) throw error;
+
+        throw new USwapError("wallet_connection_rejected_by_user", error);
+      }
+    },
+  name: "connectPhantom",
+  supportedChains: [Chain.Bitcoin, Chain.Ethereum, Chain.Monad, Chain.Solana],
+  walletType: WalletOption.PHANTOM,
+});
+
+export const PHANTOM_SUPPORTED_CHAINS = getWalletSupportedChains(phantomWallet);
+export type PhantomSupportedChain = (typeof PHANTOM_SUPPORTED_CHAINS)[number];
+
+async function getWalletMethods(chain: PhantomSupportedChain) {
+  const phantom: any = window?.phantom;
+
+  switch (chain) {
+    case Chain.Bitcoin: {
+      const provider = phantom?.bitcoin;
+      if (!provider?.isPhantom) {
+        throw new USwapError("wallet_phantom_not_found");
+      }
+
+      const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+      const [{ address }] = await provider.requestAccounts();
+      const toolbox = await getUtxoToolbox(chain);
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Ethereum:
+    case Chain.Monad: {
+      const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@tcswap/helpers");
+      const { BrowserProvider } = await import("ethers");
+
+      const provider = new BrowserProvider(phantom?.ethereum, "any");
+      const [address] = await provider.send("eth_requestAccounts", []);
+
+      const signer = await provider.getSigner();
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+      if (chain !== Chain.Ethereum) {
+        const networkParams = toolbox.getNetworkParams();
+        await switchEVMWalletNetwork(provider, chain, networkParams);
+      }
+
+      return { ...prepareNetworkSwitch({ chain, provider, toolbox }), address };
+    }
+
+    case Chain.Solana: {
+      const { getSolanaToolbox } = await import("@tcswap/toolboxes/solana");
+      const provider = phantom?.solana;
+      if (!provider?.isPhantom) {
+        throw new USwapError("wallet_phantom_not_found");
+      }
+
+      const providerConnection = await provider.connect();
+      const address: string = providerConnection.publicKey.toString();
+      const toolbox = await getSolanaToolbox({ signer: provider });
+
+      const transfer = async ({
+        recipient,
+        assetValue,
+        isProgramDerivedAddress,
+      }: GenericTransferParams & { assetValue: AssetValue; isProgramDerivedAddress?: boolean }) => {
+        const { PublicKey } = await import("@solana/web3.js");
+        const validateAddress = await toolbox.getAddressValidator();
+
+        if (!(isProgramDerivedAddress || validateAddress(recipient))) {
+          throw new USwapError("core_transaction_invalid_recipient_address");
+        }
+
+        const fromPubkey = new PublicKey(address);
+        const connection = await toolbox.getConnection();
+
+        const transaction = await toolbox.createTransaction({
+          assetValue,
+          isProgramDerivedAddress,
+          recipient,
+          sender: address,
+        });
+
+        if (!transaction) {
+          throw new USwapError("core_transaction_invalid_sender_address");
+        }
+
+        const blockHash = await connection.getLatestBlockhash();
+        transaction.recentBlockhash = blockHash.blockhash;
+        transaction.feePayer = fromPubkey;
+
+        const signedTransaction = await provider.signTransaction(transaction);
+
+        const txid = await connection.sendRawTransaction(signedTransaction.serialize());
+
+        return txid;
+      };
+
+      return { ...toolbox, address, transfer };
+    }
+
+    default: {
+      throw new USwapError("wallet_chain_not_supported", { chain, wallet: WalletOption.PHANTOM });
+    }
+  }
+}

package/src/polkadotjs/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, filterSupportedChains, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+
+export const polkadotWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectPolkadotJs(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const { address, ...walletMethods } = await getWalletMethods(chain);
+
+          addChain({ ...walletMethods, address, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectPolkadotJs",
+  supportedChains: [Chain.Polkadot],
+  walletType: WalletOption.POLKADOT_JS,
+});
+
+export const POLKADOT_SUPPORTED_CHAINS = getWalletSupportedChains(polkadotWallet);
+
+async function getWalletMethods(chain: Chain) {
+  switch (chain) {
+    case Chain.Polkadot: {
+      const { getSubstrateToolbox } = await import("@tcswap/toolboxes/substrate");
+      const injectedExtension = window?.injectedWeb3?.["polkadot-js"];
+
+      const rawExtension = await injectedExtension?.enable?.("polkadot-js");
+      if (!rawExtension) {
+        throw new USwapError({ errorKey: "wallet_polkadot_not_found", info: { chain } });
+      }
+
+      const toolbox = await getSubstrateToolbox(chain, { signer: rawExtension.signer });
+      const [account] = await rawExtension.accounts.get();
+
+      if (!account?.address) {
+        throw new USwapError({
+          errorKey: "wallet_missing_params",
+          info: { address: account?.address, wallet: WalletOption.POLKADOT_JS },
+        });
+      }
+
+      const address = toolbox.convertAddress(account.address, 0);
+      return { ...toolbox, address, getAddress: () => address };
+    }
+
+    default:
+      throw new USwapError({
+        errorKey: "wallet_chain_not_supported",
+        info: { chain, wallet: WalletOption.POLKADOT_JS },
+      });
+  }
+}

package/src/talisman/index.ts

@@ -0,0 +1,132 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  Chain,
+  type EVMChain,
+  filterSupportedChains,
+  prepareNetworkSwitch,
+  switchEVMWalletNetwork,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import type { Eip1193Provider } from "ethers";
+
+export const talismanWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectTalisman(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: "connectTalisman",
+  supportedChains: [
+    Chain.Ethereum,
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.Monad,
+    Chain.Polygon,
+    Chain.BinanceSmartChain,
+    Chain.Optimism,
+    Chain.XLayer,
+    Chain.Polkadot,
+    Chain.Chainflip,
+  ],
+  walletType: WalletOption.TALISMAN,
+});
+
+export const TALISMAN_SUPPORTED_CHAINS = getWalletSupportedChains(talismanWallet);
+
+async function getWeb3WalletMethods({
+  walletProvider,
+  chain,
+}: {
+  walletProvider: Eip1193Provider | undefined;
+  chain: EVMChain;
+}) {
+  const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+  const { BrowserProvider } = await import("ethers");
+
+  if (!walletProvider) {
+    throw new USwapError({ errorKey: "wallet_provider_not_found", info: { chain, wallet: WalletOption.TALISMAN } });
+  }
+
+  const provider = new BrowserProvider(walletProvider, "any");
+  const signer = await provider.getSigner();
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+  try {
+    if (chain !== Chain.Ethereum) {
+      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
+    }
+  } catch {
+    throw new USwapError({
+      errorKey: "wallet_failed_to_add_or_switch_network",
+      info: { chain, wallet: WalletOption.TALISMAN },
+    });
+  }
+
+  return prepareNetworkSwitch({ chain, provider, toolbox });
+}
+
+async function getWalletMethods(chain: Chain) {
+  switch (chain) {
+    case Chain.Ethereum:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.Avalanche:
+    case Chain.BinanceSmartChain:
+    case Chain.Base:
+    case Chain.Monad:
+    case Chain.XLayer: {
+      if (!(window.talismanEth && "send" in window.talismanEth)) {
+        throw new USwapError({ errorKey: "wallet_talisman_not_found", info: { chain } });
+      }
+
+      const evmWallet = await getWeb3WalletMethods({ chain, walletProvider: window.talismanEth });
+      const address: string = (await window.talismanEth.send("eth_requestAccounts", []))[0];
+
+      return { ...evmWallet, address };
+    }
+
+    case Chain.Polkadot:
+    case Chain.Chainflip: {
+      const { getSubstrateToolbox, SubstrateNetwork } = await import("@tcswap/toolboxes/substrate");
+
+      const injectedExtension = window?.injectedWeb3?.talisman;
+      const rawExtension = await injectedExtension?.enable?.("talisman");
+
+      if (!rawExtension) {
+        throw new USwapError({ errorKey: "wallet_talisman_not_enabled", info: { chain } });
+      }
+
+      const toolbox = await getSubstrateToolbox(chain, { signer: rawExtension.signer });
+      const accounts = await rawExtension.accounts.get();
+
+      if (!accounts[0]?.address) {
+        throw new USwapError({
+          errorKey: "wallet_missing_params",
+          info: { accounts, address: accounts[0]?.address, wallet: WalletOption.TALISMAN },
+        });
+      }
+      const address = toolbox.convertAddress(accounts[0].address, SubstrateNetwork[chain].prefix);
+
+      return { ...toolbox, address };
+    }
+
+    default:
+      throw new USwapError({ errorKey: "wallet_chain_not_supported", info: { chain, wallet: WalletOption.TALISMAN } });
+  }
+}