@tcswap/wallet-extensions 4.1.16

package/src/ctrl/walletHelpers.ts

@@ -0,0 +1,186 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { Keplr } from "@keplr-wallet/types";
+import {
+  type AssetValue,
+  Chain,
+  ChainToChainId,
+  type CosmosChain,
+  type EVMChain,
+  EVMChains,
+  type FeeOption,
+  providerRequest,
+  type TCLikeChain,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import type { SolanaProvider } from "@tcswap/toolboxes/solana";
+import type { Eip1193Provider } from "ethers";
+import { match } from "ts-pattern";
+import type { NearBrowserWalletProvider } from "../helpers/near";
+
+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;
+};
+
+type CtrlProviderType<T> = T extends typeof Chain.Solana
+  ? SolanaProvider
+  : T extends Exclude<CosmosChain, TCLikeChain>
+    ? Keplr
+    : T extends EVMChain
+      ? Eip1193Provider
+      : T extends typeof Chain.Near
+        ? NearBrowserWalletProvider
+        : undefined;
+
+export function getCtrlProvider<T extends Chain>(chain: T): CtrlProviderType<T> {
+  if (!window.ctrl) throw new USwapError("wallet_ctrl_not_found");
+
+  // @ts-expect-error
+  return match(chain as Chain)
+    .with(...EVMChains, () => window.ctrl?.ethereum)
+    .with(Chain.Cosmos, Chain.Kujira, Chain.Noble, () => window.ctrl?.keplr)
+    .with(Chain.Bitcoin, () => window.ctrl?.bitcoin)
+    .with(Chain.BitcoinCash, () => window.ctrl?.bitcoincash)
+    .with(Chain.Dogecoin, () => window.ctrl?.dogecoin)
+    .with(Chain.Litecoin, () => window.ctrl?.litecoin)
+    .with(Chain.Solana, () => window.ctrl?.solana)
+    .with(Chain.THORChain, () => window.ctrl?.thorchain)
+    .with(Chain.Maya, () => window.ctrl?.mayachain)
+    .with(Chain.Near, () => window.ctrl?.near)
+    .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-expect-error
+      client.request({ method, params }, (err: string, tx: string) => {
+        err ? reject(err) : resolve(tx);
+      });
+    }
+  });
+}
+
+export async function getCtrlAddress(chain: Chain) {
+  try {
+    const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
+    if (!eipProvider) {
+      throw new USwapError({ errorKey: "wallet_provider_not_found", info: { chain, wallet: WalletOption.CTRL } });
+    }
+
+    if ([Chain.Cosmos, Chain.Kujira, Chain.Noble].includes(chain as Exclude<CosmosChain, TCLikeChain>)) {
+      const provider = await getCtrlProvider(Chain.Cosmos);
+      if (!provider || "request" in provider) {
+        throw new USwapError({ errorKey: "wallet_provider_not_found", info: { chain, wallet: WalletOption.CTRL } });
+      }
+
+      // 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({ method: "eth_requestAccounts", params: [], provider });
+      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.ctrl?.near) {
+        throw new USwapError("wallet_ctrl_not_found", { chain: Chain.Near });
+      }
+
+      if (!window.ctrl.near.isSignedIn?.()) {
+        const result = await window.ctrl.near.request<string[]>?.({ method: "connect" });
+        return result?.[0] || "";
+      }
+
+      return window.ctrl.near.getAccountId?.() || "";
+    }
+
+    const accounts = await eipProvider.request({ method: "request_accounts", params: [] });
+    return accounts[0];
+  } catch {
+    throw new USwapError({ errorKey: "wallet_provider_not_found", info: { chain, wallet: WalletOption.CTRL } });
+  }
+}
+
+export async function walletTransfer(
+  { assetValue, recipient, memo, gasLimit }: WalletTxParams,
+  method: TransactionMethod = "transfer",
+) {
+  if (!assetValue) {
+    throw new USwapError("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(),
+      },
+      from,
+      gasLimit,
+      memo: memo || "",
+      recipient,
+    },
+  ];
+
+  return transaction({ chain: assetValue.chain, method, params });
+}

package/src/evm-extensions/index.ts

@@ -0,0 +1,122 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  type Chain,
+  type EVMChain,
+  EVMChains,
+  filterSupportedChains,
+  getChainConfig,
+  prepareNetworkSwitch,
+  switchEVMWalletNetwork,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import type { BrowserProvider, Eip1193Provider } from "ethers";
+
+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
+    | WalletOption.EIP6963,
+) => {
+  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 USwapError("wallet_evm_extensions_not_found");
+  const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+
+  const signer = await provider.getSigner();
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
+  const { chainIdHex } = getChainConfig(chain);
+
+  const currentNetwork = await provider.getNetwork();
+  if (currentNetwork.chainId.toString() !== chainIdHex) {
+    try {
+      const networkParams = toolbox.getNetworkParams();
+      await switchEVMWalletNetwork(provider, chain, networkParams);
+    } catch {
+      throw new USwapError("wallet_evm_extensions_failed_to_switch_network", { chain });
+    }
+  }
+
+  return prepareNetworkSwitch({
+    chain,
+    provider,
+    toolbox: { ...toolbox, getBalance: () => toolbox.getBalance(address) },
+  });
+};
+
+export const evmWallet = createWallet({
+  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 && !eip1193Provider)
+            throw new USwapError("wallet_evm_extensions_no_provider");
+
+          const windowProvider = eip1193Provider || getWalletForType(walletType);
+          const browserProvider = new BrowserProvider(windowProvider, "any");
+
+          await browserProvider.send("eth_requestAccounts", []);
+          const signer = await browserProvider.getSigner();
+          const address = await signer.getAddress();
+
+          const walletMethods = await getWeb3WalletMethods({
+            address,
+            chain,
+            provider: browserProvider,
+            walletProvider: windowProvider,
+          });
+
+          const disconnect = () => browserProvider.send("wallet_revokePermissions", [{ eth_accounts: {} }]);
+          addChain({ ...walletMethods, address, chain, disconnect, walletType });
+          return;
+        }),
+      );
+
+      return true;
+    },
+  name: "connectEVMWallet",
+  supportedChains: [...EVMChains] as EVMChain[],
+});
+
+export const EVM_EXTENSIONS_SUPPORTED_CHAINS = getWalletSupportedChains(evmWallet);

package/src/evm-extensions/types.ts

@@ -0,0 +1,15 @@
+import type { Eip1193Provider } from "ethers";
+
+export interface EIP6963ProviderInfo {
+  walletId: string;
+  uuid: string;
+  name: string;
+  icon: string;
+}
+
+export interface EIP6963ProviderDetail {
+  info: EIP6963ProviderInfo;
+  provider: Eip1193Provider;
+}
+
+export type EIP6963AnnounceProviderEvent = { detail: { info: EIP6963ProviderInfo; provider: Eip1193Provider } };

package/src/helpers/near-browser-provider.d.ts

@@ -0,0 +1,270 @@
+/**
+ * NEAR Browser Wallet Provider Interface Definitions
+ *
+ * This file contains the standard TypeScript interface definitions for NEAR browser wallet providers
+ * that inject themselves into the window object (e.g., OKX, XDEFI/CTRL, etc.)
+ *
+ * Based on:
+ * - NEAR Protocol wallet-selector library
+ * - Common patterns from OKX, XDEFI/CTRL, and other NEAR wallet implementations
+ * - NEAR API JS types
+ */
+
+import type { PublicKey } from "@near-js/crypto";
+
+/**
+ * Transaction action types supported by NEAR
+ */
+export interface NearAction {
+  type: "FunctionCall" | "Transfer" | "Stake" | "AddKey" | "DeleteKey" | "DeleteAccount";
+  params?: {
+    methodName?: string;
+    args?: object;
+    gas?: string;
+    deposit?: string;
+    publicKey?: string;
+    beneficiaryId?: string;
+  };
+}
+
+/**
+ * Transaction structure for NEAR
+ */
+export interface NearTransaction {
+  receiverId: string;
+  actions: NearAction[];
+  // Optional fields
+  signerId?: string;
+  publicKey?: string;
+  nonce?: number;
+  recentBlockHash?: string;
+}
+
+/**
+ * Message signing parameters
+ */
+export interface NearSignMessageParams {
+  message: string;
+  recipient: string;
+  nonce: Buffer | Uint8Array;
+  callbackUrl?: string;
+  state?: string;
+}
+
+/**
+ * Signed message response
+ */
+export interface NearSignedMessage {
+  accountId: string;
+  publicKey: string;
+  signature: string;
+  // Optional callback data
+  callbackUrl?: string;
+  state?: string;
+}
+
+/**
+ * Sign-in request parameters
+ */
+export interface NearSignInParams {
+  contractId?: string;
+  methodNames?: string[];
+  // Success and failure URLs for browser wallets
+  successUrl?: string;
+  failureUrl?: string;
+}
+
+/**
+ * Account information
+ */
+export interface NearAccount {
+  accountId: string;
+  publicKey?: string;
+}
+
+/**
+ * Access key information
+ */
+export interface NearAccessKey {
+  publicKey: PublicKey;
+  accessKey: {
+    nonce: number;
+    permission: "FullAccess" | { FunctionCall: { allowance?: string; receiverId: string; methodNames: string[] } };
+  };
+}
+
+/**
+ * Transaction execution result
+ */
+export interface NearFinalExecutionOutcome {
+  status: object;
+  transaction: object;
+  transaction_outcome: object;
+  receipts_outcome: object[];
+}
+
+/**
+ * Standard NEAR browser wallet provider interface
+ *
+ * This interface represents the common API surface that NEAR browser wallets
+ * expose when they inject themselves into the window object.
+ */
+export interface NearBrowserWalletProvider {
+  // Connection Management
+  /**
+   * Request connection to the wallet
+   * Returns array of account IDs that were connected
+   */
+  connect(): Promise<string[]>;
+
+  /**
+   * Alternative connection method used by some wallets
+   */
+  request?(params: { method: "connect"; params?: any }): Promise<string[]>;
+
+  /**
+   * Disconnect from the wallet
+   */
+  disconnect(): Promise<void>;
+
+  /**
+   * Sign out from the wallet (some wallets use this instead of disconnect)
+   */
+  signOut?(): void;
+
+  // Account Management
+  /**
+   * Check if user is signed in
+   */
+  isSignedIn?(): boolean;
+
+  /**
+   * Get the current account ID
+   */
+  getAccountId(): string | Promise<string>;
+
+  /**
+   * Get list of accounts (some wallets support multiple accounts)
+   */
+  getAccounts?(): Promise<NearAccount[]>;
+
+  /**
+   * Get the public key for the current account
+   */
+  getPublicKey?(): Promise<string>;
+
+  // Legacy sign-in methods (used by some wallets)
+  /**
+   * Request sign in (legacy method)
+   */
+  requestSignIn?(params: NearSignInParams): Promise<NearAccount>;
+
+  // Signing Operations
+  /**
+   * Sign a message
+   */
+  signMessage(params: NearSignMessageParams): Promise<NearSignedMessage>;
+
+  /**
+   * Sign and send a single transaction
+   */
+  signAndSendTransaction(params: {
+    receiverId: string;
+    actions: NearAction[];
+    // Optional parameters
+    signerId?: string;
+    publicKey?: string;
+    nonce?: number;
+    recentBlockHash?: string;
+  }): Promise<NearFinalExecutionOutcome>;
+
+  /**
+   * Sign and send multiple transactions
+   */
+  signAndSendTransactions(params: { transactions: NearTransaction[] }): Promise<NearFinalExecutionOutcome[]>;
+
+  /**
+   * Request signing of transactions (alternative method used by some wallets)
+   */
+  requestSignTransactions?(params: { transactions: NearTransaction[] }): Promise<any>;
+
+  // Verification
+  /**
+   * Verify ownership of an account
+   */
+  verifyOwner?(params: {
+    message: string;
+    // Additional parameters may vary by wallet
+  }): Promise<{
+    accountId: string;
+    publicKey: string;
+    signature: string;
+    // Additional fields may be returned
+  }>;
+
+  // Network Information
+  /**
+   * Get the current network (mainnet, testnet, etc.)
+   */
+  getNetwork?(): string | Promise<string>;
+
+  /**
+   * Check if wallet is connected to mainnet
+   */
+  isMainnet?(): boolean;
+
+  // Wallet Metadata
+  /**
+   * Wallet name or identifier
+   */
+  name?: string;
+
+  /**
+   * Wallet version
+   */
+  version?: string;
+
+  /**
+   * Check if this is a specific wallet (used for wallet detection)
+   */
+  isOKX?: boolean;
+  isXDEFI?: boolean;
+  isCTRL?: boolean;
+
+  // Event Handling (not all wallets support events)
+  on?(event: "accountsChanged" | "networkChanged" | "disconnect", handler: (...args: any[]) => void): void;
+  off?(event: string, handler: (...args: any[]) => void): void;
+  removeListener?(event: string, handler: (...args: any[]) => void): void;
+}
+
+/**
+ * Extended window interface for NEAR wallets
+ */
+declare global {
+  interface Window {
+    // Generic NEAR provider (if wallet uses this pattern)
+    near?: NearBrowserWalletProvider;
+
+    // Specific wallet providers
+    okxwallet?: { near: NearBrowserWalletProvider };
+
+    ctrl?: { near: NearBrowserWalletProvider };
+
+    // Add other wallet-specific providers as needed
+  }
+}
+
+/**
+ * Helper type for wallet detection
+ */
+export type NearWalletType = "okx" | "xdefi" | "ctrl" | "generic";
+
+/**
+ * Configuration for NEAR network
+ */
+export interface NearNetworkConfig {
+  networkId: "mainnet" | "testnet" | "betanet";
+  nodeUrl: string;
+  walletUrl?: string;
+  helperUrl?: string;
+}