feat: support FoxWallet

packages/wallet-ts/src/strategies/wallet-strategy/WalletStrategy.ts

@@ -19,6 +19,8 @@ import WalletConnect from './strategies/WalletConnect.js'
 import LedgerLive from './strategies/Ledger/LedgerLive.js'
 import LedgerLegacy from './strategies/Ledger/LedgerLegacy.js'
 import Magic from './strategies/Magic.js'
+import FoxWallet from './strategies/FoxWallet/index.js'
+import FoxWalletCosmos from './strategies/FoxWalletCosmos/index.js'
 import { isEthWallet, isCosmosWallet } from './utils.js'
 import { Wallet, WalletDeviceType } from '../../types/enums.js'
 import { MagicMetadata, SendTransactionOptions } from './types.js'
@@ -101,6 +103,10 @@ const createStrategy = ({
       return new Okx(ethWalletArgs)
     case Wallet.BitGet:
       return new BitGet(ethWalletArgs)
+    case Wallet.FoxWallet:
+      return new FoxWallet(ethWalletArgs)
+    case Wallet.FoxWalletCosmos:
+      return new FoxWalletCosmos({ ...args })
     case Wallet.WalletConnect:
       return new WalletConnect({
         ...ethWalletArgs,

packages/wallet-ts/src/strategies/wallet-strategy/strategies/FoxWallet/index.ts

@@ -0,0 +1,287 @@
+/* eslint-disable class-methods-use-this */
+import { sleep } from '@injectivelabs/utils'
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types'
+import {
+  ErrorType,
+  CosmosWalletException,
+  WalletException,
+  UnspecifiedErrorCode,
+  TransactionException,
+} from '@injectivelabs/exceptions'
+import { DirectSignResponse } from '@cosmjs/proto-signing'
+import { TxRaw, toUtf8, TxGrpcApi, TxResponse } from '@injectivelabs/sdk-ts'
+import {
+  ConcreteWalletStrategy,
+  EthereumWalletStrategyArgs,
+} from '../../../types'
+import { BrowserEip1993Provider, SendTransactionOptions } from '../../types'
+import BaseConcreteStrategy from './../Base'
+import {
+  WalletAction,
+  WalletDeviceType,
+  WalletEventListener,
+} from '../../../../types/enums'
+import { getFoxWalletProvider } from './utils'
+
+export default class FoxWallet
+  extends BaseConcreteStrategy
+  implements ConcreteWalletStrategy
+{
+  constructor(args: EthereumWalletStrategyArgs) {
+    super(args)
+  }
+
+  async getWalletDeviceType(): Promise<WalletDeviceType> {
+    return Promise.resolve(WalletDeviceType.Browser)
+  }
+
+  async enable(): Promise<boolean> {
+    return Promise.resolve(true)
+  }
+
+  public async disconnect() {
+    if (this.listeners[WalletEventListener.ChainIdChange]) {
+      const ethereum = await this.getEthereum()
+
+      ethereum.removeListener(
+        'chainChanged',
+        this.listeners[WalletEventListener.ChainIdChange],
+      )
+    }
+
+    this.listeners = {}
+  }
+
+  async getAddresses(): Promise<string[]> {
+    const ethereum = await this.getEthereum()
+
+    try {
+      return await ethereum.request({
+        method: 'eth_requestAccounts',
+      })
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.GetAccounts,
+      })
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getSessionOrConfirm(address: AccountAddress): Promise<string> {
+    return Promise.resolve(
+      `0x${Buffer.from(
+        `Confirmation for ${address} at time: ${Date.now()}`,
+      ).toString('hex')}`,
+    )
+  }
+
+  async sendEthereumTransaction(
+    transaction: unknown,
+    _options: { address: AccountAddress; ethereumChainId: EthereumChainId },
+  ): Promise<string> {
+    const ethereum = await this.getEthereum()
+
+    try {
+      return await ethereum.request({
+        method: 'eth_sendTransaction',
+        params: [transaction],
+      })
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.SendEthereumTransaction,
+      })
+    }
+  }
+
+  async sendTransaction(
+    transaction: TxRaw,
+    options: SendTransactionOptions,
+  ): Promise<TxResponse> {
+    const { endpoints, txTimeout } = options
+
+    if (!endpoints) {
+      throw new WalletException(
+        new Error(
+          'You have to pass endpoints within the options for using Ethereum native wallets',
+        ),
+      )
+    }
+
+    const txApi = new TxGrpcApi(endpoints.grpc)
+    const response = await txApi.broadcast(transaction, { txTimeout })
+
+    if (response.code !== 0) {
+      throw new TransactionException(new Error(response.rawLog), {
+        code: UnspecifiedErrorCode,
+        contextCode: response.code,
+        contextModule: response.codespace,
+      })
+    }
+
+    return response
+  }
+
+  /** @deprecated */
+  async signTransaction(
+    eip712json: string,
+    address: AccountAddress,
+  ): Promise<string> {
+    return this.signEip712TypedData(eip712json, address)
+  }
+
+  async signEip712TypedData(
+    eip712json: string,
+    address: AccountAddress,
+  ): Promise<string> {
+    const ethereum = await this.getEthereum()
+
+    try {
+      return await ethereum.request({
+        method: 'eth_signTypedData_v4',
+        params: [eip712json, address],
+      })
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.SignTransaction,
+      })
+    }
+  }
+
+  async signAminoCosmosTransaction(_transaction: {
+    signDoc: any
+    accountNumber: number
+    chainId: string
+    address: string
+  }): Promise<string> {
+    throw new WalletException(
+      new Error('This wallet does not support signing Cosmos transactions'),
+      {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.SendTransaction,
+      },
+    )
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async signCosmosTransaction(_transaction: {
+    txRaw: TxRaw
+    accountNumber: number
+    chainId: string
+    address: string
+  }): Promise<DirectSignResponse> {
+    throw new WalletException(
+      new Error('This wallet does not support signing Cosmos transactions'),
+      {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.SendTransaction,
+      },
+    )
+  }
+
+  async signArbitrary(
+    signer: AccountAddress,
+    data: string | Uint8Array,
+  ): Promise<string> {
+    const ethereum = await this.getEthereum()
+
+    try {
+      const signature = await ethereum.request({
+        method: 'personal_sign',
+        params: [toUtf8(data), signer],
+      })
+
+      return signature
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.SignArbitrary,
+      })
+    }
+  }
+
+  async getEthereumChainId(): Promise<string> {
+    const ethereum = await this.getEthereum()
+
+    try {
+      return ethereum.request({ method: 'eth_chainId' })
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.GetChainId,
+      })
+    }
+  }
+
+  async getEthereumTransactionReceipt(txHash: string): Promise<string> {
+    const ethereum = await this.getEthereum()
+
+    const interval = 1000
+    const transactionReceiptRetry = async () => {
+      const receipt = await ethereum.request({
+        method: 'eth_getTransactionReceipt',
+        params: [txHash],
+      })
+
+      if (!receipt) {
+        await sleep(interval)
+        await transactionReceiptRetry()
+      }
+
+      return receipt
+    }
+
+    try {
+      return await transactionReceiptRetry()
+    } catch (e: unknown) {
+      throw new CosmosWalletException(new Error((e as any).message), {
+        code: UnspecifiedErrorCode,
+        type: ErrorType.WalletError,
+        contextModule: WalletAction.GetEthereumTransactionReceipt,
+      })
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getPubKey(): Promise<string> {
+    throw new WalletException(
+      new Error('You can only fetch PubKey from Cosmos native wallets'),
+    )
+  }
+
+  async onChainIdChanged(callback: (chain: string) => void): Promise<void> {
+    const ethereum = await this.getEthereum()
+
+    this.listeners = {
+      [WalletEventListener.ChainIdChange]: callback,
+    }
+
+    ethereum.on('chainChanged', callback)
+  }
+
+  private async getEthereum(): Promise<BrowserEip1993Provider> {
+    const provider = await getFoxWalletProvider()
+
+    if (!provider) {
+      throw new CosmosWalletException(
+        new Error('Please install the FoxWallet wallet extension.'),
+        {
+          code: UnspecifiedErrorCode,
+          type: ErrorType.WalletNotInstalledError,
+          contextModule: WalletAction.GetAccounts,
+        },
+      )
+    }
+
+    return provider
+  }
+}

packages/wallet-ts/src/strategies/wallet-strategy/strategies/FoxWallet/utils.ts

@@ -0,0 +1,66 @@
+import { isServerSide } from '@injectivelabs/sdk-ts'
+import { BrowserEip1993Provider, WindowWithEip1193Provider } from '../../types'
+
+const $window = (isServerSide()
+  ? {}
+  : window) as unknown as WindowWithEip1193Provider
+
+export async function getFoxWalletProvider({ timeout } = { timeout: 3000 }) {
+  const provider = getFoxWalletFromWindow()
+
+  if (provider) {
+    return provider
+  }
+
+  return listenForFoxWalletInitialized({
+    timeout,
+  }) as Promise<BrowserEip1993Provider>
+}
+
+async function listenForFoxWalletInitialized(
+  { timeout } = { timeout: 3000 },
+) {
+  return new Promise((resolve) => {
+    const handleInitialization = () => {
+      resolve(getFoxWalletFromWindow())
+    }
+
+    $window.addEventListener('foxwallet#initialized', handleInitialization, {
+      once: true,
+    })
+
+    setTimeout(() => {
+      $window.removeEventListener(
+        'foxwallet#initialized',
+        handleInitialization,
+      )
+      resolve(null)
+    }, timeout)
+  })
+}
+
+function getFoxWalletFromWindow() {
+  const injectedProviderExist =
+    typeof window !== 'undefined' &&
+    (typeof $window.ethereum !== 'undefined' ||
+      typeof $window.foxwallet !== 'undefined')
+
+  // No injected providers exist.
+  if (!injectedProviderExist) {
+    return
+  }
+
+  if ($window.foxwallet?.ethereum) {
+    return $window.foxwallet.ethereum
+  }
+
+  if ($window.ethereum.isFoxWallet) {
+    return $window.ethereum
+  }
+
+  if ($window.providers) {
+    return $window.providers.find((p) => p.isFoxWallet)
+  }
+
+  return
+}