@tcswap/wallet-extensions 4.1.16

package/src/helpers/near.ts

@@ -0,0 +1,174 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+//TBD @towan to be moved somewhere else
+
+import type { Account } from "@near-js/accounts";
+import { type Action, SignedTransaction, type Transaction } from "@near-js/transactions";
+import { USwapError } from "@tcswap/helpers";
+import type { NearSigner } from "@tcswap/toolboxes/near";
+
+/**
+ * NEAR Browser Wallet Provider Interface
+ * Common interface implemented by browser extension wallets
+ */
+export interface NearBrowserWalletProvider {
+  connect(params?: { contractId?: string; methodNames?: string[] }): Promise<Account[] | { accountId: string }>;
+  disconnect?(): Promise<void>;
+  signOut?(): Promise<void>; // Alternative to disconnect
+
+  getAccountId(): string | Promise<string>;
+  getAccounts?(): Promise<Account[]>;
+  isSignedIn(): boolean;
+  getPublicKey?(): Promise<string>;
+
+  signMessage?(params: any): Promise<any>;
+  signAndSendTransaction(params: { receiverId: string; actions: Action[]; signerId?: string }): Promise<any>;
+  signAndSendTransactions?(params: { transactions: Transaction[] }): Promise<any[]>;
+
+  request<T>(params: { method: string; params?: any }): Promise<T>;
+  verifyOwner?(params: { message: string; callbackUrl?: string }): Promise<any>;
+  getNetwork?(): Promise<{ networkId: string; nodeUrl: string }>;
+
+  on?(event: string, handler: (...args: any[]) => void): void;
+  off?(event: string, handler: (...args: any[]) => void): void;
+}
+
+/**
+ * Helper to create a NEAR signer from browser extension providers
+ */
+export async function createNearSignerFromProvider(provider: NearBrowserWalletProvider, walletName: string) {
+  const isConnected = provider.isSignedIn ? provider.isSignedIn() : false;
+  if (!isConnected) {
+    await provider.connect({ contractId: "swapkit", methodNames: ["transfer"] });
+  }
+
+  const signer = {
+    ...provider,
+
+    async getAddress() {
+      if (provider.getAccountId) {
+        return provider.getAccountId();
+      }
+
+      if (provider.isSignedIn && !provider.isSignedIn()) {
+        // Try connect method for wallets that don't have requestSignIn
+        const result = await provider.connect();
+        if (Array.isArray(result) && result.length > 0 && result[0]) {
+          return typeof result[0] === "string" ? result[0] : result[0].accountId;
+        }
+        throw new USwapError("wallet_connection_rejected_by_user", { wallet: walletName });
+      }
+
+      throw new USwapError("wallet_connection_rejected_by_user", { wallet: walletName });
+    },
+    async getPublicKey() {
+      const { PublicKey } = await import("@near-js/crypto");
+
+      if (provider.getPublicKey) {
+        const pubKey = await provider.getPublicKey();
+        return PublicKey.from(pubKey);
+      }
+
+      throw new USwapError("wallet_ledger_method_not_supported", { method: "getPublicKey", wallet: walletName });
+    },
+
+    signDelegateAction(_delegateAction: any) {
+      // Most browser wallets don't support delegate actions yet
+      return Promise.reject(
+        new USwapError("wallet_ledger_method_not_supported", { method: "signDelegateAction", wallet: walletName }),
+      );
+    },
+
+    async signNep413Message(
+      message: string,
+      _accountId: string,
+      recipient: string,
+      nonce: Uint8Array,
+      callbackUrl?: string,
+    ) {
+      if (!provider.signMessage) {
+        throw new USwapError("wallet_ledger_method_not_supported", { method: "signNep413Message", wallet: walletName });
+      }
+
+      const result = await (provider as Required<Pick<NearBrowserWalletProvider, "signMessage">>).signMessage({
+        callbackUrl,
+        message,
+        nonce: Buffer.from(nonce),
+        recipient,
+      });
+
+      return result;
+    },
+
+    async signTransaction(transaction: Transaction) {
+      if (!provider.request) {
+        throw new USwapError("wallet_near_method_not_supported", { method: "request", wallet: walletName });
+      }
+
+      const mappedTransaction = {
+        actions: transaction.actions.map((action) => actionToWalletJson(action)),
+        receiverId: transaction.receiverId,
+        signerId: transaction.signerId,
+      };
+
+      // @ts-expect-error
+      const result: any = await provider.requestSignTransactions({ transactions: [mappedTransaction] });
+
+      const signedTransaction = SignedTransaction.decode(Uint8Array.fromBase64(result.txs[0].signedTx));
+
+      return [signedTransaction.signature.ed25519Signature?.data, signedTransaction] as [
+        Uint8Array<ArrayBufferLike>,
+        SignedTransaction,
+      ];
+    },
+  };
+
+  return signer as NearSigner;
+}
+
+/**
+ * Detect if a wallet provider supports NEAR
+ */
+export function detectNearProvider(window: any, providerPath: string): NearBrowserWalletProvider | null {
+  const parts = providerPath.split(".");
+  let provider = window;
+
+  for (const part of parts) {
+    provider = provider?.[part];
+    if (!provider) return null;
+  }
+
+  return provider;
+}
+
+/**
+ * Get NEAR chain ID for WalletConnect
+ */
+export function getNearChainId(isTestnet: boolean): string {
+  return isTestnet ? "near:testnet" : "near:mainnet";
+}
+
+function actionToWalletJson(action: Transaction["actions"][number]) {
+  const kind = action.enum;
+  const data = action;
+
+  switch (kind) {
+    case "functionCall":
+    case "FunctionCall":
+      return {
+        params: {
+          // args must be base64 string for wallet JSON
+          args: typeof Buffer.from(data.functionCall?.args ?? "{}").toString("base64"),
+          deposit: (data.functionCall?.deposit ?? 0).toString(),
+          gas: (data.functionCall?.gas ?? 0).toString(),
+          methodName: data.functionCall?.methodName ?? "",
+        },
+        type: "FunctionCall",
+      };
+
+    default:
+      throw new Error(`Unsupported action kind for wallet JSON: ${kind}`);
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export {};

package/src/keepkey-bex/index.ts

@@ -0,0 +1,151 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { AssetValue, Chain, ChainId, filterSupportedChains, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import type { Eip1193Provider } from "ethers";
+import {
+  getKEEPKEYAddress,
+  getKEEPKEYMethods,
+  getKEEPKEYProvider,
+  getProviderNameFromChain,
+  type WalletTxParams,
+  walletTransfer,
+} from "./walletHelpers";
+
+export const keepkeyBexWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectKeepkeyBex(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const address = await getKEEPKEYAddress(chain);
+          const walletMethods = await getWalletMethods(chain);
+
+          addChain({ ...walletMethods, address, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectKeepkeyBex",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Avalanche,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.BitcoinCash,
+    Chain.Base,
+    Chain.Cosmos,
+    Chain.Dash,
+    Chain.Dogecoin,
+    Chain.Ethereum,
+    Chain.Kujira,
+    Chain.Litecoin,
+    Chain.Maya,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.Ripple,
+    Chain.Solana,
+    Chain.THORChain,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.KEEPKEY_BEX,
+});
+
+export const KEEPKEY_BEX_SUPPORTED_CHAINS = getWalletSupportedChains(keepkeyBexWallet);
+
+async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[number]) {
+  switch (chain) {
+    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: WalletTxParams) => walletTransfer({ ...tx, recipient: "" }, "deposit"),
+        transfer: (tx: WalletTxParams) => walletTransfer({ ...tx, gasLimit }, "transfer"),
+      };
+    }
+
+    case Chain.Cosmos:
+    case Chain.Kujira: {
+      const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+
+      // @ts-expect-error assumed available connection
+      const signer = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(ChainId[chain]);
+      if (!signer) throw new USwapError("wallet_keepkey_signer_not_found");
+      const toolbox = await getCosmosToolbox(chain, { signer });
+
+      const accounts = await signer.getAccounts();
+      if (!accounts?.[0]?.address) throw new USwapError("wallet_keepkey_no_accounts");
+
+      const [{ address }] = accounts;
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Dash:
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dogecoin:
+    case Chain.Litecoin: {
+      const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+      const toolbox = await getUtxoToolbox(chain);
+
+      const getBalance = async () => {
+        const providerChain = getProviderNameFromChain(chain);
+        // @ts-expect-error We assuming there chains via switch
+        const balance = await window?.keepkey?.[providerChain]?.request({ method: "request_balance" });
+        const assetValue = AssetValue.from({ chain, value: balance[0].balance });
+        return [assetValue];
+      };
+
+      return { ...toolbox, getBalance, transfer: walletTransfer };
+    }
+
+    case Chain.Ethereum:
+    case Chain.BinanceSmartChain:
+    case Chain.Base:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.Avalanche: {
+      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@tcswap/helpers");
+      const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+      const { BrowserProvider } = await import("ethers");
+      const ethereumWindowProvider = getKEEPKEYProvider(chain) as Eip1193Provider;
+
+      if (!ethereumWindowProvider) {
+        throw new USwapError("wallet_keepkey_not_found");
+      }
+
+      const provider = new BrowserProvider(ethereumWindowProvider, "any");
+      const signer = await provider.getSigner();
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+      const keepkeyMethods = getKEEPKEYMethods(provider, chain);
+
+      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.KEEPKEY },
+        });
+      }
+
+      return prepareNetworkSwitch({ chain, provider, toolbox: { ...toolbox, ...keepkeyMethods } });
+    }
+
+    default:
+      return null;
+  }
+}

package/src/keepkey-bex/walletHelpers.ts

@@ -0,0 +1,241 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  type AssetValue,
+  Chain,
+  type EVMChain,
+  EVMChains,
+  type FeeOption,
+  USwapError,
+  WalletOption,
+} from "@tcswap/helpers";
+import { erc20ABI } from "@tcswap/helpers/contracts";
+import type { ApproveParams, CallParams, EVMTxParams } from "@tcswap/toolboxes/evm";
+import type { BrowserProvider, Eip1193Provider } from "ethers";
+
+interface UTXOProvider {
+  request: (
+    args: {
+      method: string;
+      params?: {
+        amount: { amount: string; decimals?: number };
+        asset: { chain: Chain; symbol: string; ticker: string };
+        memo: string | undefined;
+        from?: string;
+        recipient: string;
+        gasLimit?: string | bigint;
+      }[];
+    },
+    callback: (err: string, tx: string) => void,
+  ) => void;
+}
+
+type TransactionMethod = "transfer" | "deposit";
+
+type TransactionParams = {
+  asset: string | { chain: string; symbol: string; ticker: string };
+  amount: number | string | { amount: string | 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 | undefined;
+};
+
+export const getProviderNameFromChain = (chain: Chain): string => {
+  switch (chain) {
+    case Chain.Bitcoin:
+      return "bitcoin";
+    case Chain.BitcoinCash:
+      return "bitcoincash";
+    case Chain.Dash:
+      return "dash";
+    case Chain.Dogecoin:
+      return "dogecoin";
+    case Chain.Litecoin:
+      return "litecoin";
+    default:
+      throw new USwapError("wallet_keepkey_chain_not_supported", { chain });
+  }
+};
+
+declare const window: {
+  keepkey?: {
+    binance: Eip1193Provider;
+    bitcoin: Eip1193Provider;
+    bitcoincash: Eip1193Provider;
+    dogecoin: Eip1193Provider;
+    ethereum: Eip1193Provider;
+    cosmos: Eip1193Provider;
+    dash: Eip1193Provider;
+    litecoin: Eip1193Provider;
+    thorchain: Eip1193Provider;
+    mayachain: Eip1193Provider;
+  };
+} & Window;
+
+export function getKEEPKEYProvider<T extends Chain>(chain: T) {
+  if (!window.keepkey) throw new USwapError("wallet_keepkey_not_found");
+
+  switch (chain) {
+    case Chain.Ethereum:
+    case Chain.Base:
+    case Chain.Avalanche:
+    case Chain.BinanceSmartChain:
+    case Chain.Arbitrum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.XLayer:
+      return window.keepkey.ethereum as Eip1193Provider;
+    case Chain.Cosmos:
+      return window.keepkey.cosmos as Eip1193Provider;
+    case Chain.Bitcoin:
+      return window.keepkey.bitcoin as UTXOProvider;
+    case Chain.BitcoinCash:
+      return window.keepkey.bitcoincash as UTXOProvider;
+    case Chain.Dogecoin:
+      return window.keepkey.dogecoin as UTXOProvider;
+    case Chain.Litecoin:
+      return window.keepkey.litecoin as UTXOProvider;
+    case Chain.Dash:
+      return window.keepkey.dash as UTXOProvider;
+    case Chain.THORChain:
+      return window.keepkey.thorchain as UTXOProvider;
+    case Chain.Maya:
+      return window.keepkey.mayachain as UTXOProvider;
+
+    default:
+      return undefined;
+  }
+}
+
+function transaction({
+  method,
+  params,
+  chain,
+}: {
+  method: TransactionMethod;
+  params: TransactionParams[];
+  chain: Chain;
+}): Promise<string> {
+  const client = getKEEPKEYProvider(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);
+      });
+    } else {
+      reject(new USwapError("wallet_provider_not_found"));
+    }
+  });
+}
+
+export async function getKEEPKEYAddress(chain: Chain) {
+  const eipProvider = getKEEPKEYProvider(chain) as Eip1193Provider;
+  if (!eipProvider) {
+    throw new USwapError({ errorKey: "wallet_provider_not_found", info: { chain, wallet: WalletOption.KEEPKEY } });
+  }
+
+  let method = "request_accounts";
+  if (EVMChains.includes(chain as EVMChain)) {
+    method = "eth_requestAccounts";
+  }
+
+  const [response] = await eipProvider.request({ method, params: [] });
+  return response;
+}
+
+export async function walletTransfer(
+  { assetValue, recipient, memo, gasLimit }: WalletTxParams & { assetValue: AssetValue },
+  method: TransactionMethod = "transfer",
+) {
+  if (!assetValue) {
+    throw new USwapError("wallet_keepkey_asset_not_defined");
+  }
+
+  const from = await getKEEPKEYAddress(assetValue.chain);
+  const params = [
+    {
+      amount: { amount: assetValue.getValue("string"), decimals: assetValue.decimal },
+      asset: {
+        chain: assetValue.chain,
+        symbol: assetValue.symbol.toUpperCase(),
+        ticker: assetValue.symbol.toUpperCase(),
+      },
+      from,
+      gasLimit,
+      memo,
+      recipient,
+    },
+  ];
+
+  return transaction({ chain: assetValue.chain, method, params });
+}
+
+export function getKEEPKEYMethods(provider: BrowserProvider, chain: EVMChain) {
+  return {
+    approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
+      const { MAX_APPROVAL, getCreateContractTxObject, toHexString } = await import("@tcswap/toolboxes/evm");
+
+      const createTx = getCreateContractTxObject({ chain, provider });
+      const { value, to, data } = await createTx({
+        abi: erc20ABI,
+        contractAddress: assetAddress,
+        funcName: "approve",
+        funcParams: [spenderAddress, BigInt(amount || MAX_APPROVAL)],
+        txOverrides: { from },
+      });
+
+      return provider.send("eth_sendTransaction", [
+        { data: data || "0x", from, to, value: toHexString(BigInt(value || 0)) },
+      ]);
+    },
+    call: async <T>({ contractAddress, abi, funcName, funcParams = [], txOverrides }: CallParams): Promise<T> => {
+      if (!contractAddress) {
+        throw new USwapError("wallet_keepkey_contract_address_not_provided");
+      }
+      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } = await import(
+        "@tcswap/toolboxes/evm"
+      );
+
+      const isStateChanging = isStateChangingCall({ abi, funcName });
+
+      if (isStateChanging) {
+        const createTx = getCreateContractTxObject({ chain, provider });
+        const { value, from, to, data } = await createTx({ abi, contractAddress, funcName, funcParams, txOverrides });
+
+        return provider.send("eth_sendTransaction", [
+          { data: data || "0x", from, to, value: toHexString(BigInt(value || 0)) },
+        ]);
+      }
+      const contract = createContract(contractAddress, abi, provider);
+
+      const result = await contract[funcName]?.(...funcParams);
+
+      return typeof result?.hash === "string" ? result?.hash : result;
+    },
+    sendTransaction: async (tx: EVMTxParams) => {
+      const { from, to, data, value } = tx;
+      if (!to) {
+        throw new USwapError("wallet_keepkey_send_transaction_no_address");
+      }
+
+      const { toHexString } = await import("@tcswap/toolboxes/evm");
+
+      return provider.send("eth_sendTransaction", [
+        { data: data || "0x", from, to, value: toHexString(BigInt(value || 0)) },
+      ]);
+    },
+  };
+}