wallet-stack 1.0.0-alpha.121

package/src/fiatExchanges/reducer.ts

@@ -0,0 +1,65 @@
+import { RehydrateAction } from 'redux-persist'
+import { Actions, ActionTypes } from 'src/fiatExchanges/actions'
+import { getRehydratePayload, REHYDRATE } from 'src/redux/persist-helper'
+import { RootState } from 'src/redux/reducers'
+
+export interface ProviderLogos {
+  [providerName: string]: string
+}
+
+export interface TxHashToProvider {
+  [txHash: string]: string | undefined
+}
+
+export interface ProviderFeedInfo {
+  name: string
+  icon: string
+}
+
+interface TxHashToDisplayInfo {
+  [txHash: string]: ProviderFeedInfo | undefined
+}
+
+interface State {
+  txHashToProvider: TxHashToDisplayInfo
+  providerLogos: ProviderLogos
+}
+
+const initialState = {
+  txHashToProvider: {},
+  providerLogos: {},
+}
+
+export const reducer = (
+  state: State = initialState,
+  action: ActionTypes | RehydrateAction
+): State => {
+  switch (action.type) {
+    case REHYDRATE: {
+      return {
+        ...state,
+        ...getRehydratePayload(action, 'fiatExchanges'),
+      }
+    }
+    case Actions.SET_PROVIDER_LOGOS:
+      return {
+        ...state,
+        providerLogos: action.providerLogos,
+      }
+    case Actions.ASSIGN_PROVIDER_TO_TX_HASH:
+      const { txHash, displayInfo } = action
+
+      return {
+        ...state,
+        txHashToProvider: {
+          ...state.txHashToProvider,
+          [txHash]: displayInfo,
+        },
+      }
+    default:
+      return state
+  }
+}
+
+export const txHashToFeedInfoSelector = (state: RootState) => state.fiatExchanges.txHashToProvider
+export const providerLogosSelector = (state: RootState) => state.fiatExchanges.providerLogos

package/src/fiatExchanges/saga.test.ts

@@ -0,0 +1,281 @@
+import BigNumber from 'bignumber.js'
+import { expectSaga } from 'redux-saga-test-plan'
+import { call, select } from 'redux-saga/effects'
+import { SendOrigin } from 'src/analytics/types'
+import { activeScreenChanged } from 'src/app/actions'
+import { assignProviderToTxHash, bidaliPaymentRequested } from 'src/fiatExchanges/actions'
+import { providerLogosSelector } from 'src/fiatExchanges/reducer'
+import {
+  fetchTxHashesToProviderMapping,
+  tagTxsWithProviderInfo,
+  watchBidaliPaymentRequests,
+} from 'src/fiatExchanges/saga'
+import { Actions as IdentityActions, updateKnownAddresses } from 'src/identity/actions'
+import { navigate } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { AddressRecipient, RecipientType } from 'src/recipients/recipient'
+import { sendPayment, sendPaymentFailure, sendPaymentSuccess } from 'src/send/actions'
+import { tokensByCurrencySelector } from 'src/tokens/selectors'
+import { updateTransactions } from 'src/transactions/slice'
+import {
+  NetworkId,
+  TokenTransaction,
+  TokenTransactionTypeV2,
+  TransactionStatus,
+} from 'src/transactions/types'
+import Logger from 'src/utils/Logger'
+import { Currency } from 'src/utils/currencies'
+import { SerializableTransactionRequest } from 'src/viem/preparedTransactionSerialization'
+import {
+  mockAccount,
+  mockCeurAddress,
+  mockCeurTokenId,
+  mockCusdAddress,
+  mockCusdTokenId,
+} from 'test/values'
+
+const now = Date.now()
+Date.now = jest.fn(() => now)
+
+const loggerErrorSpy = jest.spyOn(Logger, 'error')
+const mockPreparedTransaction: SerializableTransactionRequest = {
+  from: '0xfrom',
+  to: '0xto',
+  data: '0xdata',
+}
+
+describe(watchBidaliPaymentRequests, () => {
+  const amount = new BigNumber(20)
+  const recipient: AddressRecipient = {
+    address: '0xTEST',
+    name: 'Bidali',
+    thumbnailPath:
+      'https://firebasestorage.googleapis.com/v0/b/celo-mobile-mainnet.appspot.com/o/images%2Fbidali.png?alt=media',
+    recipientType: RecipientType.Address,
+  }
+
+  beforeAll(() => {
+    jest.useRealTimers()
+  })
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it.each`
+    currencyCode | expectedCurrency   | expectedTokenAddress | expectedTokenId
+    ${'cUSD'}    | ${Currency.Dollar} | ${mockCusdAddress}   | ${mockCusdTokenId}
+    ${'cEUR'}    | ${Currency.Euro}   | ${mockCeurAddress}   | ${mockCeurTokenId}
+  `(
+    'triggers the payment flow with $currencyCode and calls `onPaymentSent` when successful',
+    async ({ currencyCode, expectedCurrency, expectedTokenAddress, expectedTokenId }) => {
+      const onPaymentSent = jest.fn()
+      const onCancelled = jest.fn()
+
+      await expectSaga(watchBidaliPaymentRequests)
+        .provide([
+          [
+            select(tokensByCurrencySelector),
+            { [expectedCurrency]: { address: expectedTokenAddress, tokenId: expectedTokenId } },
+          ],
+        ])
+        .put(
+          updateKnownAddresses({
+            '0xTEST': { name: recipient.name!, imageUrl: recipient.thumbnailPath || null },
+          })
+        )
+        .dispatch(
+          bidaliPaymentRequested(
+            '0xTEST',
+            '20',
+            currencyCode,
+            'Some description',
+            'TEST_CHARGE_ID',
+            onPaymentSent,
+            onCancelled
+          )
+        )
+        .dispatch(
+          sendPayment(
+            amount,
+            expectedTokenId,
+            new BigNumber('20'),
+            recipient,
+            true,
+            mockPreparedTransaction
+          )
+        )
+        .dispatch(sendPaymentSuccess({ amount, tokenId: expectedTokenId }))
+        .run()
+
+      expect(navigate).toHaveBeenCalledWith(Screens.SendConfirmation, {
+        origin: SendOrigin.Bidali,
+        transactionData: {
+          inputAmount: amount,
+          recipient,
+          amountIsInLocalCurrency: false,
+          tokenAddress: expectedTokenAddress,
+          tokenId: expectedTokenId,
+          tokenAmount: amount,
+        },
+        isFromScan: false,
+      })
+      expect(onPaymentSent).toHaveBeenCalledTimes(1)
+      expect(onCancelled).not.toHaveBeenCalled()
+    }
+  )
+
+  it('triggers the payment flow and calls `onCancelled` when navigating back to the Bidali screen after a failure', async () => {
+    const onPaymentSent = jest.fn()
+    const onCancelled = jest.fn()
+
+    await expectSaga(watchBidaliPaymentRequests)
+      .provide([
+        [
+          select(tokensByCurrencySelector),
+          { [Currency.Dollar]: { address: mockCusdAddress, tokenId: mockCusdTokenId } },
+        ],
+      ])
+      .not.put.actionType(IdentityActions.UPDATE_KNOWN_ADDRESSES)
+      .dispatch(
+        bidaliPaymentRequested(
+          '0xTEST',
+          '20',
+          'cUSD',
+          'Some description',
+          'TEST_CHARGE_ID',
+          onPaymentSent,
+          onCancelled
+        )
+      )
+      .dispatch(
+        sendPayment(
+          amount,
+          mockCusdTokenId,
+          new BigNumber('20'),
+          recipient,
+          true,
+          mockPreparedTransaction
+        )
+      )
+      .dispatch(sendPaymentFailure())
+      .dispatch(activeScreenChanged(Screens.BidaliScreen))
+      .run()
+
+    expect(navigate).toHaveBeenCalledWith(Screens.SendConfirmation, {
+      origin: SendOrigin.Bidali,
+      transactionData: {
+        inputAmount: amount,
+        recipient,
+        amountIsInLocalCurrency: false,
+        tokenAddress: mockCusdAddress,
+        tokenAmount: amount,
+        tokenId: mockCusdTokenId,
+      },
+      isFromScan: false,
+    })
+    expect(onPaymentSent).not.toHaveBeenCalled()
+    expect(onCancelled).toHaveBeenCalled()
+  })
+
+  it('logs an error when passing an unsupported currency', async () => {
+    const onPaymentSent = jest.fn()
+    const onCancelled = jest.fn()
+
+    await expectSaga(watchBidaliPaymentRequests)
+      .dispatch(
+        bidaliPaymentRequested(
+          '0xTEST',
+          '20',
+          'ETH',
+          'Some description',
+          'TEST_CHARGE_ID',
+          onPaymentSent,
+          onCancelled
+        )
+      )
+      .run()
+
+    expect(loggerErrorSpy).toHaveBeenCalledWith(
+      'utils/safely',
+      'Unhandled error in wrapped saga',
+      new Error('Unsupported payment currency from Bidali: ETH')
+    )
+    expect(navigate).not.toHaveBeenCalled()
+    expect(onPaymentSent).not.toHaveBeenCalled()
+    expect(onCancelled).not.toHaveBeenCalled()
+  })
+})
+
+describe(tagTxsWithProviderInfo, () => {
+  const mockAmount = {
+    value: '-0.2',
+    localAmount: {
+      value: '-0.2',
+      currencyCode: 'USD',
+      exchangeRate: '1',
+    },
+    tokenId: 'celo-mainnet:0xabc',
+  }
+
+  const providerTransferHash = '0x4607df6d11e63bb024cf1001956de7b6bd7adc253146f8412e8b3756752b8353'
+  const sentHash = '0x16fbd53c4871f0657f40e1b4515184be04bed8912c6e2abc2cda549e4ad8f852'
+  const nonProviderTransferHash =
+    '0x28147e5953639687915e9b152173076611cc9e51e8634fad3850374ccc87d7aa'
+  const mockProviderAccount = '0x30d5ca2a263e0c0d11e7a668ccf30b38f1482251'
+
+  const mockTransactionDetails = {
+    amount: mockAmount,
+    timestamp: 1578530602,
+    address: mockAccount,
+    networkId: NetworkId['celo-mainnet'],
+    block: '123',
+    fees: [],
+    metadata: {},
+    status: TransactionStatus.Complete,
+  }
+  const transactions: TokenTransaction[] = [
+    {
+      ...mockTransactionDetails,
+      type: TokenTransactionTypeV2.Received,
+      transactionHash: providerTransferHash,
+      timestamp: 1578530538,
+      address: mockProviderAccount,
+    },
+    {
+      ...mockTransactionDetails,
+      type: TokenTransactionTypeV2.Sent,
+      transactionHash: sentHash,
+    },
+    {
+      ...mockTransactionDetails,
+      type: TokenTransactionTypeV2.Received,
+      transactionHash: nonProviderTransferHash,
+      timestamp: 1578530602,
+      address: mockAccount,
+    },
+  ]
+
+  it('assigns specific display info for providers with tx hashes associated with the user', async () => {
+    const providerName = 'Provider'
+    const mockProviderLogo = 'www.provider.com/logo'
+    const mockDisplayInfo = {
+      name: providerName,
+      icon: mockProviderLogo,
+    }
+
+    const mockTxHashesToProvider = { [providerTransferHash]: providerName }
+    const mockProviderLogos = { [providerName]: mockProviderLogo }
+
+    await expectSaga(
+      tagTxsWithProviderInfo,
+      updateTransactions({ networkId: NetworkId['celo-alfajores'], transactions })
+    )
+      .provide([
+        [select(providerLogosSelector), mockProviderLogos],
+        [call(fetchTxHashesToProviderMapping), mockTxHashesToProvider],
+      ])
+      .put(assignProviderToTxHash(providerTransferHash, mockDisplayInfo))
+      .run()
+  })
+})

package/src/fiatExchanges/saga.ts

@@ -0,0 +1,195 @@
+import { Action, Predicate } from '@redux-saga/types'
+import BigNumber from 'bignumber.js'
+import { SendOrigin } from 'src/analytics/types'
+import { ActionTypes as AppActionTypes, Actions as AppActions } from 'src/app/actions'
+import { FIREBASE_ENABLED } from 'src/config'
+import {
+  Actions,
+  BidaliPaymentRequestedAction,
+  assignProviderToTxHash,
+  setProviderLogos,
+} from 'src/fiatExchanges/actions'
+import { ProviderLogos, TxHashToProvider, providerLogosSelector } from 'src/fiatExchanges/reducer'
+import { readOnceFromFirebase } from 'src/firebase/firebase'
+import i18n from 'src/i18n'
+import { updateKnownAddresses } from 'src/identity/actions'
+import { navigate } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { AddressRecipient, RecipientType, getDisplayName } from 'src/recipients/recipient'
+import { Actions as SendActions } from 'src/send/actions'
+import { TransactionDataInput } from 'src/send/types'
+import { CurrencyTokens, tokensByCurrencySelector } from 'src/tokens/selectors'
+import {
+  UpdateTransactionsPayload,
+  updateFeedFirstPage,
+  updateTransactions,
+} from 'src/transactions/slice'
+import { Network, TokenTransactionTypeV2 } from 'src/transactions/types'
+import Logger from 'src/utils/Logger'
+import { resolveCurrency } from 'src/utils/currencies'
+import { safely } from 'src/utils/safely'
+import { networkIdToNetwork } from 'src/web3/networkConfig'
+import { getAccount } from 'src/web3/saga'
+import { call, put, race, select, spawn, take, takeEvery, takeLeading } from 'typed-redux-saga'
+
+const TAG = 'fiatExchanges/saga'
+
+function* bidaliPaymentRequest({
+  amount,
+  address,
+  currency: currencyString,
+  description,
+  chargeId,
+  onPaymentSent,
+  onCancelled,
+}: BidaliPaymentRequestedAction) {
+  Logger.debug(
+    `${TAG}@bidaliPaymentRequest`,
+    `Send ${amount} ${currencyString} to ${address} for ${description} (${chargeId})`
+  )
+
+  const currency = resolveCurrency(currencyString)
+  if (!currency) {
+    // This is not supposed to happen in production
+    throw new Error(`Unsupported payment currency from Bidali: ${currencyString}`)
+  }
+
+  const tokens: CurrencyTokens = yield* select(tokensByCurrencySelector)
+  const tokenInfo = tokens[currency]
+  const tokenAddress = tokenInfo?.address
+  const tokenId = tokenInfo?.tokenId
+  if (!tokenId) {
+    // This is not supposed to happen in production
+    throw new Error(`No token ID found for currency: ${currency}`)
+  }
+
+  const recipient: AddressRecipient = {
+    address,
+    name: 'Bidali',
+    thumbnailPath:
+      'https://firebasestorage.googleapis.com/v0/b/celo-mobile-mainnet.appspot.com/o/images%2Fbidali.png?alt=media',
+    recipientType: RecipientType.Address,
+  }
+  const transactionData: TransactionDataInput = {
+    recipient,
+    tokenId,
+    inputAmount: new BigNumber(amount),
+    amountIsInLocalCurrency: false,
+    tokenAddress,
+    tokenAmount: new BigNumber(amount),
+  }
+
+  navigate(Screens.SendConfirmation, {
+    transactionData,
+    origin: SendOrigin.Bidali,
+    isFromScan: false,
+  })
+
+  while (true) {
+    const { cancel } = yield* race({
+      sendStart: take(SendActions.SEND_PAYMENT),
+      cancel: take(
+        ((action: AppActionTypes) =>
+          action.type === AppActions.ACTIVE_SCREEN_CHANGED &&
+          action.activeScreen === Screens.BidaliScreen) as Predicate<Action>
+      ),
+    })
+    if (cancel) {
+      Logger.debug(`${TAG}@bidaliPaymentRequest`, 'Cancelled')
+      yield* call(onCancelled)
+      return
+    }
+
+    const { success } = yield* race({
+      success: take(SendActions.SEND_PAYMENT_SUCCESS),
+      failure: take(SendActions.SEND_PAYMENT_FAILURE),
+    })
+
+    if (success) {
+      Logger.debug(`${TAG}@bidaliPaymentRequest`, 'Payment Sent')
+      yield* call(onPaymentSent)
+
+      // Keep address mapping locally
+      yield* put(
+        updateKnownAddresses({
+          [address]: {
+            name: getDisplayName(recipient, i18n.t),
+            imageUrl: recipient.thumbnailPath || null,
+          },
+        })
+      )
+      break
+    }
+
+    // Failure, loop again and see if the user is gonna try to send it again or just navigate back
+  }
+}
+
+export function* fetchTxHashesToProviderMapping() {
+  const account = yield* call(getAccount)
+  const txHashesToProvider: TxHashToProvider | null = yield* call(
+    readOnceFromFirebase,
+    `registrations/${account}/txHashes`
+  )
+  return txHashesToProvider
+}
+
+export function* tagTxsWithProviderInfo(action: UpdateTransactionsPayload) {
+  const { transactions, networkId } = action.payload
+  try {
+    if (!transactions || !transactions.length || networkIdToNetwork[networkId] !== Network.Celo) {
+      return
+    }
+
+    Logger.debug(`${TAG}@tagTxsWithProviderInfo`, `Checking ${transactions.length} txs`)
+
+    const providerLogos = yield* select(providerLogosSelector)
+    const txHashesToProvider = yield* call(fetchTxHashesToProviderMapping)
+
+    for (const tx of transactions) {
+      if (tx.type !== TokenTransactionTypeV2.Received) {
+        continue
+      }
+
+      const provider = txHashesToProvider?.[tx.transactionHash]
+      const providerLogo = providerLogos[provider || '']
+
+      if (provider && providerLogo) {
+        yield* put(
+          assignProviderToTxHash(tx.transactionHash, { name: provider, icon: providerLogo })
+        )
+      }
+    }
+
+    Logger.debug(`${TAG}@tagTxsWithProviderInfo`, 'Done checking txs')
+  } catch (error) {
+    Logger.error(`${TAG}@tagTxsWithProviderInfo`, 'Failed to tag txs with provider info', error)
+  }
+}
+
+export function* importProviderLogos() {
+  if (!FIREBASE_ENABLED) {
+    Logger.info(`${TAG}/importProviderLogos`, 'Firebase disabled')
+    return
+  }
+
+  const providerLogos: ProviderLogos = yield readOnceFromFirebase('providerLogos')
+  yield* put(setProviderLogos(providerLogos))
+}
+
+export function* watchBidaliPaymentRequests() {
+  yield* takeLeading(Actions.BIDALI_PAYMENT_REQUESTED, safely(bidaliPaymentRequest))
+}
+
+function* watchNewFeedTransactions() {
+  yield* takeEvery(
+    [updateTransactions.type, updateFeedFirstPage.type],
+    safely(tagTxsWithProviderInfo)
+  )
+}
+
+export function* fiatExchangesSaga() {
+  yield* spawn(watchBidaliPaymentRequests)
+  yield* spawn(watchNewFeedTransactions)
+  yield* spawn(importProviderLogos)
+}

package/src/fiatExchanges/types.ts

@@ -0,0 +1,104 @@
+import { LocalCurrencyCode } from 'src/localCurrency/consts'
+import { UserLocationData } from 'src/networkInfo/saga'
+
+export enum SelectProviderExchangesText {
+  CryptoExchange = 'CryptoExchange',
+  DepositFrom = 'DepositFrom',
+}
+
+export enum SelectProviderExchangesLink {
+  ExternalExchangesScreen = 'ExternalExchangesScreen',
+  ExchangeQRScreen = 'ExchangeQRScreen',
+}
+
+export interface ProviderSelectionAnalyticsData {
+  centralizedExchangesAvailable: boolean
+  totalOptions: number
+  paymentMethodsAvailable: Record<PaymentMethod, boolean>
+  transferCryptoAmount: number
+  cryptoType: string
+  lowestFeeKycRequired: boolean | undefined
+  lowestFeeCryptoAmount: number | undefined
+  lowestFeeProvider: string | undefined
+  lowestFeePaymentMethod: PaymentMethod | undefined
+  networkId: string | undefined
+}
+
+export type FiatExchangeFlowType = typeof FiatExchangeFlow
+export enum FiatExchangeFlow {
+  CashIn = 'CashIn',
+  CashOut = 'CashOut',
+  Spend = 'Spend',
+}
+
+export type CICOFlowType = typeof CICOFlow
+export enum CICOFlow {
+  CashIn = 'CashIn',
+  CashOut = 'CashOut',
+}
+
+export enum PaymentMethod {
+  Bank = 'Bank',
+  Card = 'Card',
+  MobileMoney = 'MobileMoney', // legacy mobile money
+  FiatConnectMobileMoney = 'FiatConnectMobileMoney',
+  Airtime = 'Airtime',
+}
+
+export type SimplexQuote = {
+  user_id: string
+  quote_id: string
+  wallet_id: string
+  digital_money: {
+    currency: string
+    amount: number
+  }
+  fiat_money: {
+    currency: string
+    base_amount: number
+    total_amount: number
+  }
+  valid_until: string
+  supported_digital_currencies: string[]
+}
+
+export type GetCicoQuotesRequest = {
+  tokenId: string
+  fiatCurrency: LocalCurrencyCode
+  address: string
+  userLocation: UserLocationData
+} & (
+  | {
+      txType: 'cashIn'
+      fiatAmount: string
+    }
+  | {
+      txType: 'cashOut'
+      cryptoAmount: string
+    }
+)
+
+export interface CicoQuote {
+  paymentMethod: 'Bank' | 'Card' | 'Airtime' | 'MobileMoney'
+  url?: string
+  fiatCurrency: LocalCurrencyCode
+  tokenId: string
+  txType: 'cashIn' | 'cashOut'
+  fiatAmount: string
+  cryptoAmount: string
+  fiatFee?: string
+  provider: {
+    id: string
+    displayName: string
+    logoUrl: string
+    logoWideUrl: string
+  }
+  additionalInfo?: {
+    mobileCarrier?: 'Safaricom' | 'MTN' // mobile carrier used for airtime
+    simplexQuote?: SimplexQuote | undefined // raw quote from Simplex, there is a wallet dependency on this
+  }
+}
+
+export interface GetCicoQuotesResponse {
+  quotes: CicoQuote[]
+}