wallet-stack 1.0.0-alpha.121

package/src/public/hooks/useWallet.ts

@@ -0,0 +1,52 @@
+/**
+ * With the current structure of the wallet-stack package there is a requirement to initialize
+ * missingGlobals.ts before everything else. It is imported in the src/public/createApp.ts.
+ * For this reason we cannot use top level imports using absolute internal paths like `src/redux/hooks`
+ * as it can cause those resolved paths to be included in the runtime before the globals file.
+ * The same issue happens if we try to use absolute imports like 'wallet-stack/src/redux/hooks'.
+ *
+ * Until we resolve this issue, the approach to include any code from src folder should be as following:
+ *   - top level imports of external modules are allowed (e.g. 'react')
+ *   - internal modules should be included with an inline require
+ *   - "import type" can be used to persist type-safety as it doesn't include types in the runtime
+ *   - when using "import type" - use relative paths (e.g. ../../redux/hooks)
+ */
+
+import type { EarnPosition } from 'src/positions/types'
+import type { UseSelector } from '../../redux/hooks'
+import type { SortedTokensWithBalanceOrShowZeroBalanceSelector } from '../../tokens/selectors'
+import type { TokenBalance } from '../../tokens/slice'
+import type { WalletAddressSelector } from '../../web3/selectors'
+
+function useTokens() {
+  const useSelector = require('../../redux/hooks').useSelector as UseSelector
+  const sortedTokensWithBalanceOrShowZeroBalanceSelector = require('../../tokens/selectors')
+    .sortedTokensWithBalanceOrShowZeroBalanceSelector as SortedTokensWithBalanceOrShowZeroBalanceSelector
+
+  // explicitly allow zero state tokens to be shown for exploration purposes for
+  // new users with no balance
+  const tokens = useSelector(sortedTokensWithBalanceOrShowZeroBalanceSelector)
+  return tokens
+}
+
+function useEarnPositions() {
+  const useSelector = require('../../redux/hooks').useSelector as UseSelector
+  const earnPositionsSelector = require('../../positions/selectors').earnPositionsSelector
+  const positions = useSelector(earnPositionsSelector)
+  return positions
+}
+
+export function useWallet() {
+  const useSelector = require('../../redux/hooks').useSelector as UseSelector
+  const walletAddressSelector = require('../../web3/selectors')
+    .walletAddressSelector as WalletAddressSelector
+  const address = useSelector(walletAddressSelector) as string | null
+  const tokens = useTokens() as TokenBalance[]
+
+  const earnPositions = useEarnPositions() as EarnPosition[]
+  return {
+    address,
+    tokens,
+    earnPositions,
+  }
+}

package/src/public/hooks/useWalletClient.test.ts

@@ -0,0 +1,35 @@
+import { renderHook, waitFor } from '@testing-library/react-native'
+import { getWalletClient } from '../getWalletClient'
+import { useWalletClient } from './useWalletClient'
+
+jest.mock('../getWalletClient')
+const mockGetWalletClient = jest.mocked(getWalletClient)
+
+// This test focuses on the key integration points of the hook, avoiding testing react-async-hook which is already tested
+describe('useWalletClient', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockGetWalletClient.mockReset()
+  })
+
+  it('should get wallet client and expose result', async () => {
+    const mockWalletClient = {} as any
+    mockGetWalletClient.mockResolvedValueOnce(mockWalletClient)
+
+    const { result } = renderHook(() => useWalletClient({ networkId: 'celo-mainnet' }))
+
+    await waitFor(() => expect(result.current.data).toEqual(mockWalletClient))
+    expect(mockGetWalletClient).toHaveBeenCalledTimes(1)
+    expect(result.current.status).toEqual('success')
+  })
+
+  it('should expose errors when getting wallet client fails', async () => {
+    const mockError = new Error('Failed to get wallet client')
+    mockGetWalletClient.mockRejectedValueOnce(mockError)
+
+    const { result } = renderHook(() => useWalletClient({ networkId: 'celo-mainnet' }))
+
+    await waitFor(() => expect(result.current.error).toBe(mockError))
+    expect(result.current.status).toEqual('error')
+  })
+})

package/src/public/hooks/useWalletClient.ts

@@ -0,0 +1,24 @@
+import { useAsync } from 'react-async-hook'
+
+import { useMemo } from 'react'
+import { getWalletClient } from '../getWalletClient'
+import { NetworkId } from '../types'
+import { toAsyncStatus } from './toAsyncStatus'
+
+export function useWalletClient({ networkId }: { networkId: NetworkId }) {
+  const params = useMemo(
+    () => ({
+      networkId,
+    }),
+    [networkId]
+  )
+  const asyncCallback = useAsync(getWalletClient, [params])
+
+  return {
+    status: toAsyncStatus(asyncCallback.status),
+    error: asyncCallback.error,
+    data: asyncCallback.result,
+    refresh: asyncCallback.execute,
+    reset: asyncCallback.reset,
+  }
+}

package/src/public/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Public API exports for the mobile library.
+ * We use explicit exports instead of 'export *' to:
+ * - Maintain a clear and intentional public API surface
+ * - Enable better tree-shaking
+ * - Prevent accidental exposure of internal implementation details
+ */
+export { Button, type ButtonSize, type ButtonTextSize, type ButtonType } from './components/Button'
+export { createApp } from './createApp'
+export { getFees } from './getFees'
+export { getPublicClient } from './getPublicClient'
+export { getWalletClient } from './getWalletClient'
+export { usePrepareTransactions } from './hooks/usePrepareTransactions'
+export { usePublicClient } from './hooks/usePublicClient'
+export { useSendTransactions } from './hooks/useSendTransactions'
+export { useWallet } from './hooks/useWallet'
+export { useWalletClient } from './hooks/useWalletClient'
+export { navigate, type NativeStackScreenProps, type StackParamList } from './navigate'
+export {
+  prepareTransactions,
+  type PreparedTransactionsNeedDecreaseSpendAmountForGas,
+  type PreparedTransactionsNotEnoughBalanceForGas,
+  type PreparedTransactionsPossible,
+  type PreparedTransactionsResult,
+  type TransactionRequest,
+} from './prepareTransactions'
+export { sendTransactions } from './sendTransactions'
+export { type NetworkId, type PublicAppConfig } from './types'
+export { unlockAccount, type UnlockResult } from './unlockAccount'

package/src/public/navigate.test.ts

@@ -0,0 +1,168 @@
+import { getAppConfig } from 'src/appConfig'
+import { getMockStoreData } from 'test/utils'
+import { mockAaveArbUsdcTokenId, mockTokenBalances, mockUSDCTokenId } from 'test/values'
+import { CICOFlow, FiatExchangeFlow } from '../fiatExchanges/types'
+import { navigate as internalNavigate } from '../navigator/NavigationService'
+import { Screens } from '../navigator/Screens'
+import { store } from '../redux/store'
+import { navigate } from './navigate'
+
+jest.mock('../navigator/NavigationService')
+
+jest.mock('../redux/store', () => ({ store: { getState: jest.fn() } }))
+
+const mockStore = jest.mocked(store)
+mockStore.getState.mockImplementation(() =>
+  getMockStoreData({
+    tokens: {
+      tokenBalances: {
+        ...mockTokenBalances,
+      },
+    },
+  })
+)
+
+// Note: when adding a new public route, add a test for it only if it's a non trivial mapping to an internal screen
+describe('navigate', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  // This is a sanity check to ensure that the navigate function is type-safe
+  // Using a couple of examples is enough.
+  it('should type check navigation parameters', () => {
+    // These should compile without type errors
+    navigate('Swap')
+    navigate('Swap', undefined)
+    navigate('Swap', {
+      fromTokenId: 'token1',
+    })
+    navigate('Swap', {
+      fromTokenId: 'token1',
+      toTokenId: 'token2',
+      toTokenNetworkId: 'celo-mainnet',
+    })
+
+    // @ts-expect-error - Invalid parameter
+    navigate('Swap', { invalidParam: 'foo' })
+
+    // @ts-expect-error - Extra invalid parameter
+    navigate('Swap', { fromTokenId: 'token1', invalidParam: 'foo' })
+
+    // Just to have an assertion and avoid linting error
+    expect(internalNavigate).toHaveBeenCalled()
+  })
+
+  describe('Swap', () => {
+    it('should navigate to swap screen without params', () => {
+      navigate('Swap')
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.SwapScreenWithBack, undefined)
+    })
+
+    it('should navigate to swap screen with valid params', () => {
+      navigate('Swap', {
+        fromTokenId: 'token1',
+        toTokenId: 'token2',
+        toTokenNetworkId: 'celo-mainnet',
+      })
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.SwapScreenWithBack, {
+        fromTokenId: 'token1',
+        toTokenId: 'token2',
+        toTokenNetworkId: 'celo-mainnet',
+      })
+    })
+  })
+
+  describe('Add', () => {
+    it('should navigate to FiatExchangeAmount for cash-in eligible token', () => {
+      const tokenId = mockUSDCTokenId
+      navigate('Add', { tokenId })
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeAmount, {
+        tokenId,
+        flow: CICOFlow.CashIn,
+        tokenSymbol: 'USDC',
+      })
+    })
+
+    it('should navigate to FiatExchangeCurrencyBottomSheet for cash-in ineligible token', () => {
+      const tokenId = mockAaveArbUsdcTokenId
+      navigate('Add', { tokenId })
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeCurrencyBottomSheet, {
+        flow: FiatExchangeFlow.CashIn,
+      })
+    })
+
+    it('should navigate to FiatExchangeCurrencyBottomSheet when no tokenId is provided', () => {
+      navigate('Add')
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeCurrencyBottomSheet, {
+        flow: FiatExchangeFlow.CashIn,
+      })
+    })
+  })
+
+  describe('Withdraw', () => {
+    it('should navigate to FiatExchangeAmount for cash-out eligible token', () => {
+      const tokenId = mockUSDCTokenId
+      navigate('Withdraw', { tokenId })
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeAmount, {
+        tokenId,
+        flow: CICOFlow.CashOut,
+        tokenSymbol: 'USDC',
+      })
+    })
+
+    it('should navigate to FiatExchangeCurrencyBottomSheet for cash-out ineligible token', () => {
+      const tokenId = mockAaveArbUsdcTokenId
+      navigate('Withdraw', { tokenId })
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeCurrencyBottomSheet, {
+        flow: FiatExchangeFlow.CashOut,
+      })
+    })
+
+    it('should navigate to FiatExchangeCurrencyBottomSheet when no tokenId is provided and bidali is disabled', () => {
+      navigate('Withdraw')
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.FiatExchangeCurrencyBottomSheet, {
+        flow: FiatExchangeFlow.CashOut,
+      })
+    })
+
+    it('should navigate to WithdrawSpend when no tokenId is provided and bidali is enabled', () => {
+      jest.mocked(getAppConfig).mockReturnValueOnce({
+        displayName: 'Test App',
+        deepLinkUrlScheme: 'testapp',
+        registryName: 'test',
+        experimental: {
+          bidali: { url: 'bidali' },
+        },
+      })
+      navigate('Withdraw')
+
+      expect(internalNavigate).toHaveBeenCalledWith(Screens.WithdrawSpend)
+    })
+  })
+
+  describe('Custom', () => {
+    it('should allow navigation to custom screens', () => {
+      // Using type assertion to simulate a custom screen
+      navigate('CustomScreen' as any)
+
+      expect(internalNavigate).toHaveBeenCalledWith('CustomScreen', undefined)
+    })
+
+    it('should allow navigation to custom screens with params', () => {
+      navigate('CustomScreenWithParams' as any, { customParam: 'test' } as any)
+
+      expect(internalNavigate).toHaveBeenCalledWith('CustomScreenWithParams', {
+        customParam: 'test',
+      })
+    })
+  })
+})

package/src/public/navigate.ts

@@ -0,0 +1,168 @@
+// See useWallet for why we don't directly import internal modules, except for the types
+import { ParamListBase } from '@react-navigation/native'
+import { createNativeStackNavigator } from '@react-navigation/native-stack'
+import { getAppConfig } from 'src/appConfig'
+import type { CICOFlowType, FiatExchangeFlowType } from '../fiatExchanges/types'
+import type { Navigate } from '../navigator/NavigationService'
+import type { ScreensType } from '../navigator/Screens'
+import type { Store } from '../redux/store'
+import type { TokensByIdSelector } from '../tokens/selectors'
+import type { NetworkId as InternalNetworkId } from '../transactions/types'
+import type { LoggerType } from '../utils/Logger'
+import type { NetworkId } from './types'
+
+const TAG = 'public/navigate'
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace DivviNavigation {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface RootParamList extends StackParamList {}
+  }
+}
+
+export type NavigatorScreen = ReturnType<
+  // TODO: this weird looking type works around a type error when checking the lib vs example app
+  // Maybe we can get rid of this once we're able to ship declaration files
+  typeof createNativeStackNavigator<
+    DivviNavigation.RootParamList extends ParamListBase ? DivviNavigation.RootParamList : never
+  >
+>['Screen']
+
+export type StackParamList = {
+  Send: undefined
+  Receive: undefined
+  Swap:
+    | {
+        fromTokenId?: string
+        toTokenId?: string
+        toTokenNetworkId?: NetworkId
+      }
+    | undefined
+  Add:
+    | {
+        tokenId: string
+      }
+    | undefined
+  Withdraw:
+    | {
+        tokenId: string
+      }
+    | undefined
+  TabWallet: undefined
+  TabActivity: undefined
+  TabEarn: undefined
+  TabDiscover: undefined
+}
+
+export type { NativeStackScreenProps } from '@react-navigation/native-stack'
+
+type NavigateArgs<ParamList = DivviNavigation.RootParamList> = {
+  [RouteName in keyof ParamList]: undefined extends ParamList[RouteName]
+    ? [RouteName] | [RouteName, ParamList[RouteName]]
+    : [RouteName, ParamList[RouteName]]
+}[keyof ParamList]
+
+export function navigate(...args: NavigateArgs): void {
+  const internalNavigate = require('../navigator/NavigationService').navigate as Navigate
+  const Logger = require('../utils/Logger').default as LoggerType
+  const store = require('../redux/store').store as Store
+  const tokensByIdSelector = require('../tokens/selectors').tokensByIdSelector as TokensByIdSelector
+  const Screens = require('../navigator/Screens').Screens as ScreensType
+  const FiatExchangeFlow = require('../fiatExchanges/types')
+    .FiatExchangeFlow as FiatExchangeFlowType
+  const CICOFlow = require('../fiatExchanges/types').CICOFlow as CICOFlowType
+
+  // TODO: remove the need to cast once we're able to ship declaration files
+  const [routeName, params] = args as NavigateArgs<StackParamList>
+
+  switch (routeName) {
+    case 'Send':
+      internalNavigate(Screens.SendSelectRecipient)
+      break
+    case 'Receive':
+      internalNavigate(Screens.QRNavigator, {
+        screen: Screens.QRCode,
+      })
+      break
+    case 'Swap':
+      internalNavigate(
+        Screens.SwapScreenWithBack,
+        params
+          ? {
+              fromTokenId: params.fromTokenId,
+              toTokenId: params.toTokenId,
+              toTokenNetworkId: params.toTokenNetworkId as InternalNetworkId,
+            }
+          : undefined
+      )
+      break
+    case 'Add':
+      if (params?.tokenId) {
+        const tokens = tokensByIdSelector(store.getState())
+        const tokenInfo = params ? tokens[params.tokenId] : undefined
+        if (tokenInfo && tokenInfo.isCashInEligible) {
+          // TODO: we should refactor FiatExchangeAmount so it can accept just a tokenId, without the need for the tokenSymbol
+          internalNavigate(Screens.FiatExchangeAmount, {
+            tokenId: params.tokenId,
+            flow: CICOFlow.CashIn,
+            tokenSymbol: tokenInfo.symbol,
+          })
+          return
+        } else {
+          Logger.warn(
+            TAG,
+            `Unable to find a token eligible for cash in with tokenId: ${params?.tokenId}`
+          )
+        }
+      }
+
+      internalNavigate(Screens.FiatExchangeCurrencyBottomSheet, { flow: FiatExchangeFlow.CashIn })
+      break
+    case 'Withdraw':
+      if (params?.tokenId) {
+        const tokens = tokensByIdSelector(store.getState())
+        const tokenInfo = params ? tokens[params.tokenId] : undefined
+        if (tokenInfo && tokenInfo.isCashOutEligible) {
+          internalNavigate(Screens.FiatExchangeAmount, {
+            tokenId: params.tokenId,
+            flow: CICOFlow.CashOut,
+            tokenSymbol: tokenInfo.symbol,
+          })
+          return
+        } else {
+          Logger.warn(
+            TAG,
+            `Unable to find a token eligible for cash out with tokenId: ${params?.tokenId}`
+          )
+        }
+      }
+
+      if (getAppConfig().experimental?.bidali) {
+        internalNavigate(Screens.WithdrawSpend)
+      } else {
+        internalNavigate(Screens.FiatExchangeCurrencyBottomSheet, {
+          flow: FiatExchangeFlow.CashOut,
+        })
+      }
+      break
+    case 'TabWallet':
+      internalNavigate(Screens.TabWallet)
+      break
+    case 'TabActivity':
+      internalNavigate(Screens.TabHome)
+      break
+    case 'TabEarn':
+      internalNavigate(Screens.TabEarn)
+      break
+    case 'TabDiscover':
+      internalNavigate(Screens.TabDiscover)
+      break
+    default:
+      const exhaustiveCheck: never = routeName
+      // This handles custom defined screens
+      // Though also allows navigating to internal screens...
+      internalNavigate(routeName, params)
+      return exhaustiveCheck
+  }
+}

package/src/public/prepareTransactions.test.ts

@@ -0,0 +1,76 @@
+import { getMockStoreData } from 'test/utils'
+import { mockAccount, mockTokenBalances } from 'test/values'
+import { store } from '../redux/store'
+import { feeCurrenciesSelector } from '../tokens/selectors'
+import { NetworkId } from '../transactions/types'
+import { prepareTransactions as internalPrepareTransactions } from '../viem/prepareTransactions'
+import { prepareTransactions, type TransactionRequest } from './prepareTransactions'
+
+// Note: Statsig is not directly used by this module, but mocking it prevents
+// require cycles from impacting the tests.
+jest.mock('src/statsig')
+
+jest.mock('../viem/prepareTransactions')
+jest.mock('../redux/store', () => ({ store: { getState: jest.fn() } }))
+
+const mockStore = jest.mocked(store)
+
+describe('prepareTransactions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(internalPrepareTransactions).mockReset()
+    mockStore.getState.mockImplementation(() =>
+      getMockStoreData({
+        tokens: {
+          tokenBalances: {
+            ...mockTokenBalances,
+          },
+        },
+      })
+    )
+  })
+
+  it('should correctly prepare transactions', async () => {
+    const feeCurrencies = feeCurrenciesSelector(store.getState(), NetworkId['celo-mainnet'])
+    const mockPrepareResult = { type: 'possible' } as any
+
+    jest.mocked(internalPrepareTransactions).mockResolvedValue(mockPrepareResult)
+
+    const txRequests: TransactionRequest[] = [
+      {
+        to: '0x1234567890123456789012345678901234567890',
+        data: '0x',
+        value: BigInt(1000),
+        estimatedGasUse: BigInt(21000),
+      },
+    ]
+
+    const result = await prepareTransactions({
+      networkId: 'celo-mainnet',
+      transactionRequests: txRequests,
+    })
+
+    expect(result).toEqual(mockPrepareResult)
+    expect(internalPrepareTransactions).toHaveBeenCalledWith({
+      feeCurrencies: feeCurrencies,
+      decreasedAmountGasFeeMultiplier: 1,
+      baseTransactions: [
+        {
+          from: mockAccount.toLowerCase(),
+          to: txRequests[0].to,
+          data: txRequests[0].data,
+          value: txRequests[0].value,
+          _estimatedGasUse: txRequests[0].estimatedGasUse,
+        },
+      ],
+      origin: 'framework',
+    })
+  })
+
+  it('should throw if no wallet address is found', async () => {
+    mockStore.getState.mockImplementation(() => getMockStoreData({ web3: { account: null } }))
+    await expect(
+      prepareTransactions({ networkId: 'celo-mainnet', transactionRequests: [] })
+    ).rejects.toThrow('Wallet address not found')
+  })
+})

package/src/public/prepareTransactions.ts

@@ -0,0 +1,78 @@
+// See useWallet for why we don't directly import internal modules, except for the types
+import type { Address, Hex } from 'viem'
+import type { Store } from '../redux/store'
+import type { FeeCurrenciesSelector } from '../tokens/selectors'
+import type { NetworkId as InternalNetworkId } from '../transactions/types'
+import type {
+  TransactionRequest as InternalTransactionRequest,
+  PrepareTransactions,
+} from '../viem/prepareTransactions'
+import type { WalletAddressSelector } from '../web3/selectors'
+import type { NetworkId } from './types'
+
+export type {
+  PreparedTransactionsNeedDecreaseSpendAmountForGas,
+  PreparedTransactionsNotEnoughBalanceForGas,
+  PreparedTransactionsPossible,
+  PreparedTransactionsResult,
+} from '../viem/prepareTransactions'
+
+export type TransactionRequest = {
+  to: Address
+  data?: Hex
+  value?: bigint
+  // These are needed when preparing more than one transaction
+  gas?: bigint // in wei
+  estimatedGasUse?: bigint // in wei
+}
+
+function toInternalTransactionRequest(
+  tx: TransactionRequest,
+  walletAddress: Address
+): InternalTransactionRequest {
+  return {
+    from: walletAddress,
+    to: tx.to,
+    value: tx.value,
+    data: tx.data,
+    gas: tx.gas,
+    _estimatedGasUse: tx.estimatedGasUse,
+  }
+}
+
+function toInternalTransactionRequests(
+  txs: TransactionRequest[],
+  walletAddress: Address
+): InternalTransactionRequest[] {
+  return txs.map((tx) => toInternalTransactionRequest(tx, walletAddress))
+}
+
+export async function prepareTransactions({
+  networkId,
+  transactionRequests,
+}: {
+  networkId: NetworkId
+  transactionRequests: TransactionRequest[]
+}) {
+  const store = require('../redux/store').store as Store
+  const feeCurrenciesSelector = require('../tokens/selectors')
+    .feeCurrenciesSelector as FeeCurrenciesSelector
+  const prepareTransactions = require('../viem/prepareTransactions')
+    .prepareTransactions as PrepareTransactions
+  const walletAddressSelector = require('../web3/selectors')
+    .walletAddressSelector as WalletAddressSelector
+
+  const state = store.getState()
+  const feeCurrencies = feeCurrenciesSelector(state, networkId as InternalNetworkId)
+  const walletAddress = walletAddressSelector(state)
+  if (!walletAddress) {
+    throw new Error('Wallet address not found')
+  }
+  const result = await prepareTransactions({
+    feeCurrencies,
+    decreasedAmountGasFeeMultiplier: 1,
+    baseTransactions: toInternalTransactionRequests(transactionRequests, walletAddress as Address),
+    origin: 'framework',
+  })
+  return result
+}

package/src/public/sendTransactions.test.ts

@@ -0,0 +1,37 @@
+import { mockAccount, mockCeloTokenBalance } from '../../test/values'
+import { getSerializablePreparedTransactions } from '../viem/preparedTransactionSerialization'
+import { sendPreparedTransactions as sendPreparedTransactionsSaga } from '../viem/saga'
+import type { PreparedTransactionsPossible } from './prepareTransactions'
+import { sendTransactions } from './sendTransactions'
+
+jest.mock('../viem/saga')
+
+describe('sendTransactions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.mocked(sendPreparedTransactionsSaga).mockReset()
+  })
+
+  it('should correctly send prepared transactions', async () => {
+    const mockTxHashes = ['0x123', '0x456']
+    const mockPrepared = {
+      type: 'possible',
+      transactions: [
+        { to: mockAccount, value: BigInt(1000) },
+        { to: mockAccount, value: BigInt(1000) },
+      ],
+      feeCurrency: mockCeloTokenBalance,
+    } as PreparedTransactionsPossible
+
+    jest.mocked(sendPreparedTransactionsSaga).mockReturnValue(mockTxHashes as any)
+
+    const result = await sendTransactions(mockPrepared as any)
+
+    expect(result).toEqual(mockTxHashes)
+    expect(sendPreparedTransactionsSaga).toHaveBeenCalledWith(
+      getSerializablePreparedTransactions(mockPrepared.transactions),
+      'celo-alfajores',
+      expect.any(Array)
+    )
+  })
+})