@swapkit/wallets 3.0.0-beta.3 → 3.0.0-beta.31

package/src/ctrl/walletHelpers.ts

@@ -8,6 +8,7 @@ import {
   type FeeOption,
   SwapKitError,
   WalletOption,
+  providerRequest,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
 import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
@@ -59,12 +60,14 @@ export async function getCtrlProvider<T extends Chain>(
       Chain.Polygon,
       () => window.xfi?.ethereum,
     )
-    .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, () => window.xfi?.keplr)
+    .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);
 }
 
@@ -89,56 +92,84 @@ async function transaction({
   });
 }
 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
 export async function getCtrlAddress(chain: Chain) {
-  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) {
+  try {
+    const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
+    if (!eipProvider) {
       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);
+    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 },
+        });
+      }
 
-    const offlineSigner = provider.getOfflineSigner(chainId);
+      // 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 [item] = await offlineSigner.getAccounts();
-    return item?.address;
-  }
+      const offlineSigner = provider.getOfflineSigner(chainId);
 
-  if (EVMChains.includes(chain as EVMChain)) {
-    const [response] = await eipProvider.request({ method: "eth_requestAccounts", params: [] });
+      const [item] = await offlineSigner.getAccounts();
+      return item?.address;
+    }
 
-    return response;
-  }
+    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);
+    if (chain === Chain.Solana) {
+      const provider = await getCtrlProvider(Chain.Solana);
 
-    const accounts = await provider.connect();
-    return accounts.publicKey.toString();
-  }
+      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?.() || "";
+    }
 
-  return new Promise((resolve, reject) =>
-    eipProvider.request(
-      { method: "request_accounts", params: [] },
-      // @ts-expect-error
-      (error: any, [response]: string[]) => (error ? reject(error) : resolve(response)),
-    ),
-  );
+    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(
@@ -188,8 +219,9 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       if (!contractAddress) {
         throw new SwapKitError("wallet_ctrl_contract_address_not_provided");
       }
-      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } =
-        await import("@swapkit/toolboxes/evm");
+      const { createContract, getCreateContractTxObject, isStateChangingCall } = await import(
+        "@swapkit/toolboxes/evm"
+      );
 
       const isStateChanging = isStateChangingCall({ abi, funcName });
 
@@ -203,14 +235,14 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
           txOverrides,
         });
 
-        return provider.send("eth_sendTransaction", [
-          {
-            value: toHexString(BigInt(value || 0)),
-            from,
-            to,
-            data: data || "0x",
-          } as any,
-        ]);
+        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);
 
@@ -219,9 +251,7 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       return typeof result?.hash === "string" ? result?.hash : result;
     },
     approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
-      const { MAX_APPROVAL, getCreateContractTxObject, toHexString } = await import(
-        "@swapkit/toolboxes/evm"
-      );
+      const { MAX_APPROVAL, getCreateContractTxObject } = await import("@swapkit/toolboxes/evm");
       const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
       const txOverrides = { from };
 
@@ -236,31 +266,29 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       const createTx = getCreateContractTxObject({ provider, chain });
       const { value, to, data } = await createTx(functionCallParams);
 
-      return provider.send("eth_sendTransaction", [
-        {
-          value: toHexString(BigInt(value || 0)),
-          from,
-          to,
-          data: data || "0x",
-        } as any,
-      ]);
+      const signer = await provider.getSigner();
+      const tx = await signer.sendTransaction({
+        value: BigInt(value || 0),
+        from,
+        to,
+        data: data || "0x",
+      });
+      return tx.hash;
     },
-    sendTransaction: async (tx: EVMTxParams) => {
-      const { from, to, data, value } = tx;
+    sendTransaction: async (txParams: EVMTxParams) => {
+      const { from, to, data, value } = txParams;
       if (!to) {
         throw new SwapKitError("wallet_ctrl_send_transaction_no_address");
       }
 
-      const { toHexString } = await import("@swapkit/toolboxes/evm");
-
-      return provider.send("eth_sendTransaction", [
-        {
-          value: toHexString(BigInt(value || 0)),
-          from,
-          to,
-          data: data || "0x",
-        } as any,
-      ]);
+      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

@@ -3,6 +3,7 @@ import {
   ChainToHexChainId,
   type EVMChain,
   EVMChains,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -49,7 +50,7 @@ export const getWeb3WalletMethods = async ({
   chain: EVMChain;
   provider: BrowserProvider;
 }) => {
-  if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
+  if (!walletProvider) throw new SwapKitError("wallet_evm_extensions_not_found");
   const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
   const signer = await provider.getSigner();
@@ -62,7 +63,7 @@ export const getWeb3WalletMethods = async ({
         const networkParams = toolbox.getNetworkParams();
         await switchEVMWalletNetwork(provider, chain, networkParams);
       } catch (_error) {
-        throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
+        throw new SwapKitError("wallet_evm_extensions_failed_to_switch_network", { chain });
       }
     }
   }
@@ -89,7 +90,7 @@ export const evmWallet = createWallet({
       await Promise.all(
         filteredChains.map(async (chain) => {
           if (walletType === WalletOption.EIP6963) {
-            if (!eip1193Provider) throw new Error("Missing provider");
+            if (!eip1193Provider) throw new SwapKitError("wallet_evm_extensions_no_provider");
 
             const provider = new BrowserProvider(eip1193Provider, "any");
             await provider.send("eth_requestAccounts", []);

package/src/exodus/index.ts

@@ -9,7 +9,7 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { Psbt } from "bitcoinjs-lib";
+import { Psbt } from "bitcoinjs-lib";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
 import {
   AddressPurpose,
@@ -34,7 +34,6 @@ async function getWalletMethods({
 }) {
   switch (chain) {
     case Chain.Bitcoin: {
-      const { Psbt } = await import("bitcoinjs-lib");
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
       let address = "";
@@ -50,11 +49,11 @@ async function getWalletMethods({
           network: { type: BitcoinNetworkType.Mainnet },
         },
         onFinish: (response: GetAddressResponse) => {
-          if (!response.addresses[0]) throw new Error("No address found");
+          if (!response.addresses[0]) throw new SwapKitError("wallet_exodus_no_address");
           address = response.addresses[0].address;
         },
         onCancel: () => {
-          throw new Error("Request canceled");
+          throw new SwapKitError("wallet_exodus_request_canceled");
         },
       };
 
@@ -80,7 +79,7 @@ async function getWalletMethods({
             signedPsbt = Psbt.fromBase64(response.psbtBase64);
           },
           onCancel: () => {
-            throw new Error("Signature canceled");
+            throw new SwapKitError("wallet_exodus_signature_canceled");
           },
         };
 
@@ -104,7 +103,7 @@ async function getWalletMethods({
     case Chain.Ethereum:
     case Chain.Optimism:
     case Chain.Polygon: {
-      if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
+      if (!walletProvider) throw new SwapKitError("wallet_exodus_not_found");
       const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
       const jsonRpcProvider = await getProvider(chain);
@@ -122,13 +121,13 @@ async function getWalletMethods({
           await switchEVMWalletNetwork(browserProvider, chain, networkParams);
         }
       } catch (_error) {
-        throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
+        throw new SwapKitError("wallet_exodus_failed_to_switch_network", { chain });
       }
 
       return { ...prepareNetworkSwitch({ toolbox, chain, provider: browserProvider }), address };
     }
     default:
-      throw new Error(`Unsupported chain: ${chain}`);
+      throw new SwapKitError("wallet_exodus_chain_not_supported", { chain });
   }
 }
 
@@ -138,7 +137,7 @@ export const exodusWallet = createWallet({
   supportedChains: [...EVMChains, Chain.Bitcoin],
   connect: ({ addChain, walletType, supportedChains }) =>
     async function connectExodusWallet(chains: Chain[], wallet: Wallet) {
-      if (!wallet) throw new Error("Missing Exodus Wallet instance");
+      if (!wallet) throw new SwapKitError("wallet_exodus_instance_missing");
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
       const { BrowserProvider } = await import("ethers");
 

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

@@ -0,0 +1,286 @@
+/**
+ * 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-api-js/lib/utils";
+
+/**
+ * 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: Function): void;
+  off?(event: string, handler: Function): void;
+  removeListener?(event: string, handler: Function): 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;
+    };
+
+    xfi?: {
+      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;
+}