wallet-stack 1.0.0-alpha.121

package/src/fiatconnect/TransferStatusScreen.tsx

@@ -0,0 +1,351 @@
+import { NativeStackScreenProps } from '@react-navigation/native-stack'
+import React, { useEffect, useState, type JSX } from 'react'
+import { useTranslation } from 'react-i18next'
+import { ActivityIndicator, SafeAreaView, StyleSheet, Text, View } from 'react-native'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { FiatExchangeEvents } from 'src/analytics/Events'
+import BackButton from 'src/components/BackButton'
+import Button, { BtnSizes, BtnTypes } from 'src/components/Button'
+import TextButton from 'src/components/TextButton'
+import Touchable from 'src/components/Touchable'
+import FiatConnectQuote from 'src/fiatExchanges/quotes/FiatConnectQuote'
+import { SettlementEstimation, SettlementTime } from 'src/fiatExchanges/quotes/constants'
+import { getSettlementTimeString } from 'src/fiatExchanges/quotes/utils'
+import { CICOFlow } from 'src/fiatExchanges/types'
+import { fiatConnectTransferSelector } from 'src/fiatconnect/selectors'
+import { FiatAccount, SendingTransferStatus } from 'src/fiatconnect/slice'
+import Checkmark from 'src/icons/Checkmark'
+import CircledIcon from 'src/icons/CircledIcon'
+import ClockIcon from 'src/icons/ClockIcon'
+import OpenLinkIcon from 'src/icons/OpenLinkIcon'
+import { emptyHeader } from 'src/navigator/Headers'
+import { navigate, navigateInitialTab } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { StackParamList } from 'src/navigator/types'
+import { useSelector } from 'src/redux/hooks'
+import appTheme from 'src/styles/appTheme'
+import Colors from 'src/styles/colors'
+import { typeScale } from 'src/styles/fonts'
+import { Spacing } from 'src/styles/styles'
+import variables from 'src/styles/variables'
+import networkConfig, { blockExplorerUrls } from 'src/web3/networkConfig'
+import { walletAddressSelector } from 'src/web3/selectors'
+
+const LOADING_DESCRIPTION_TIMEOUT_MS = 8000
+
+const DESCRIPTION_STRINGS: Record<SettlementTime, string> = {
+  [SettlementTime.LESS_THAN_ONE_HOUR]: 'fiatConnectStatusScreen.success.descriptionWithin1Hour',
+  [SettlementTime.LESS_THAN_X_HOURS]: 'fiatConnectStatusScreen.success.descriptionWithinXHours',
+  [SettlementTime.X_TO_Y_HOURS]: 'fiatConnectStatusScreen.success.descriptionInXtoYHours',
+  [SettlementTime.LESS_THAN_X_DAYS]: 'fiatConnectStatusScreen.success.descriptionWithinXDays',
+  [SettlementTime.X_TO_Y_DAYS]: 'fiatConnectStatusScreen.success.descriptionXtoYDays',
+}
+
+type Props = NativeStackScreenProps<StackParamList, Screens.FiatConnectTransferStatus>
+
+function onBack(flow: CICOFlow, normalizedQuote: FiatConnectQuote, fiatAccount: FiatAccount) {
+  AppAnalytics.track(FiatExchangeEvents.cico_fc_transfer_error_retry, {
+    flow,
+    provider: normalizedQuote.getProviderId(),
+  })
+  navigate(Screens.FiatConnectReview, {
+    flow,
+    normalizedQuote,
+    fiatAccount,
+    shouldRefetchQuote: true,
+  })
+}
+
+function FailureSection({
+  normalizedQuote,
+  flow,
+  fiatAccount,
+}: {
+  normalizedQuote: FiatConnectQuote
+  flow: CICOFlow
+  fiatAccount: FiatAccount
+}) {
+  const { t } = useTranslation()
+  const provider = normalizedQuote.getProviderId()
+
+  const onPressSupport = () => {
+    AppAnalytics.track(FiatExchangeEvents.cico_fc_transfer_error_contact_support, {
+      flow,
+      provider,
+    })
+    navigate(Screens.SupportContact, {
+      prefilledText:
+        flow === CICOFlow.CashIn
+          ? t('fiatConnectStatusScreen.cashIn.contactSupportPrefill')
+          : t('fiatConnectStatusScreen.cashOut.contactSupportPrefill'),
+    })
+  }
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>{t('fiatConnectStatusScreen.requestNotCompleted.title')}</Text>
+      <Text style={styles.description}>
+        {t('fiatConnectStatusScreen.requestNotCompleted.description')}
+      </Text>
+      <Button
+        style={styles.button}
+        testID="TryAgain"
+        onPress={() => onBack(flow, normalizedQuote, fiatAccount)}
+        text={t('fiatConnectStatusScreen.tryAgain')}
+        type={BtnTypes.PRIMARY}
+        size={BtnSizes.MEDIUM}
+      />
+      <Button
+        style={styles.button}
+        testID="SupportContactLink"
+        onPress={onPressSupport}
+        text={t('contactSupport')}
+        type={BtnTypes.SECONDARY}
+        size={BtnSizes.MEDIUM}
+      />
+    </View>
+  )
+}
+
+function SuccessOrProcessingSection({
+  status,
+  flow,
+  txHash,
+  normalizedQuote,
+}: {
+  status: SendingTransferStatus.Completed | SendingTransferStatus.TxProcessing
+  flow: CICOFlow
+  txHash: string | null
+  normalizedQuote: FiatConnectQuote
+}) {
+  const { t } = useTranslation()
+  const provider = normalizedQuote.getProviderId()
+  const address = useSelector(walletAddressSelector)
+  const uri = txHash
+    ? new URL(txHash, blockExplorerUrls[networkConfig.defaultNetworkId].baseTxUrl).toString()
+    : new URL(
+        String(address),
+        blockExplorerUrls[networkConfig.defaultNetworkId].baseAddressUrl
+      ).toString()
+
+  let icon: JSX.Element
+  let title: string
+  let description: string
+  let continueEvent:
+    | FiatExchangeEvents.cico_fc_transfer_success_complete
+    | FiatExchangeEvents.cico_fc_transfer_processing_continue
+  let txDetailsEvent:
+    | FiatExchangeEvents.cico_fc_transfer_success_view_tx
+    | FiatExchangeEvents.cico_fc_transfer_processing_view_tx
+
+  const getTransferSettlementTimeString = (settlementEstimation: SettlementEstimation) => {
+    const { timeString, ...args } = getSettlementTimeString(
+      settlementEstimation,
+      DESCRIPTION_STRINGS
+    )
+    return timeString ? t(timeString, args) : t('fiatConnectStatusScreen.success.baseDescription')
+  }
+
+  if (status === SendingTransferStatus.Completed) {
+    icon = (
+      <CircledIcon>
+        <Checkmark color={Colors.contentTertiary} height={22} width={22} />
+      </CircledIcon>
+    )
+    title = t('fiatConnectStatusScreen.success.title')
+    description = getTransferSettlementTimeString(normalizedQuote.getTimeEstimation())
+    continueEvent = FiatExchangeEvents.cico_fc_transfer_success_complete
+    txDetailsEvent = FiatExchangeEvents.cico_fc_transfer_success_view_tx
+  } else {
+    icon = (
+      <CircledIcon>
+        <ClockIcon color={Colors.contentTertiary} height={22} width={22} />
+      </CircledIcon>
+    )
+    title = t('fiatConnectStatusScreen.txProcessing.title')
+    description = t('fiatConnectStatusScreen.txProcessing.description')
+    continueEvent = FiatExchangeEvents.cico_fc_transfer_processing_continue
+    txDetailsEvent = FiatExchangeEvents.cico_fc_transfer_processing_view_tx
+  }
+
+  const onPressTxDetails = () => {
+    AppAnalytics.track(txDetailsEvent, {
+      flow,
+      provider,
+      txHash,
+    })
+    navigate(Screens.WebViewScreen, { uri })
+  }
+
+  const onPressContinue = () => {
+    AppAnalytics.track(continueEvent, {
+      flow,
+      provider,
+      txHash,
+    })
+    navigateInitialTab()
+  }
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.iconContainer}>{icon}</View>
+      <Text style={styles.title}>{title}</Text>
+      <Text style={styles.description}>{description}</Text>
+      {flow === CICOFlow.CashOut && (
+        <Touchable testID={'txDetails'} borderless={true} onPress={onPressTxDetails}>
+          <View style={styles.txDetailsContainer}>
+            <Text style={styles.txDetails}>
+              {t('fiatConnectStatusScreen.success.viewOnCeloScan')}
+            </Text>
+            <OpenLinkIcon color={Colors.textLink} />
+          </View>
+        </Touchable>
+      )}
+      <Button
+        style={styles.button}
+        testID="Continue"
+        onPress={onPressContinue}
+        text={t('fiatConnectStatusScreen.success.continue')}
+        type={BtnTypes.SECONDARY}
+        size={BtnSizes.MEDIUM}
+      />
+    </View>
+  )
+}
+
+export default function FiatConnectTransferStatusScreen({ route, navigation }: Props) {
+  const { t } = useTranslation()
+  const { normalizedQuote, flow, fiatAccount } = route.params
+
+  const fiatConnectTransfer = useSelector(fiatConnectTransferSelector)!
+
+  const onPressCancel = () => {
+    AppAnalytics.track(FiatExchangeEvents.cico_fc_transfer_error_cancel, {
+      flow,
+      provider: normalizedQuote.getProviderId(),
+    })
+    navigateInitialTab()
+  }
+
+  // make loading description visible if sending is taking a while
+  const [loadingDescriptionColor, setLoadingDescriptionColor] = useState(
+    appTheme.colors.background.toString()
+  )
+  useEffect(() => {
+    const timeout = setTimeout(() => {
+      setLoadingDescriptionColor(() => appTheme.colors.text)
+    }, LOADING_DESCRIPTION_TIMEOUT_MS)
+    return () => clearTimeout(timeout)
+  }, [])
+
+  switch (fiatConnectTransfer.status) {
+    case SendingTransferStatus.Sending:
+      return (
+        <View style={styles.activityIndicatorContainer}>
+          <ActivityIndicator
+            testID="loadingTransferStatus"
+            size="large"
+            color={Colors.loadingIndicator}
+          />
+          <Text
+            style={{ ...styles.loadingDescription, color: loadingDescriptionColor }}
+            testID="loadingDescription"
+          >
+            {t('fiatConnectStatusScreen.stillProcessing')}
+          </Text>
+        </View>
+      )
+    case SendingTransferStatus.Failed:
+      navigation.setOptions({
+        ...emptyHeader,
+        headerLeft: () => (
+          <BackButton testID="Back" onPress={() => onBack(flow, normalizedQuote, fiatAccount)} />
+        ),
+        headerRight: () => (
+          <TextButton testID="Cancel" style={styles.cancelBtn} onPress={onPressCancel}>
+            {flow === CICOFlow.CashIn
+              ? t('fiatConnectStatusScreen.cashIn.cancel')
+              : t('fiatConnectStatusScreen.cashOut.cancel')}
+          </TextButton>
+        ),
+      })
+      return (
+        <SafeAreaView style={styles.content}>
+          <FailureSection flow={flow} normalizedQuote={normalizedQuote} fiatAccount={fiatAccount} />
+        </SafeAreaView>
+      )
+    case SendingTransferStatus.Completed:
+      navigation.setOptions({
+        ...emptyHeader,
+        headerLeft: () => <View />,
+        headerTitle: t('fiatConnectStatusScreen.success.header') ?? undefined,
+      })
+    // intentionally falls thru since TxProcessing and Completed use the same component
+    case SendingTransferStatus.TxProcessing:
+      return (
+        <SafeAreaView style={styles.content}>
+          <SuccessOrProcessingSection
+            status={fiatConnectTransfer.status}
+            flow={flow}
+            txHash={fiatConnectTransfer.txHash}
+            normalizedQuote={normalizedQuote}
+          />
+        </SafeAreaView>
+      )
+    default:
+      throw new Error('Invalid transfer status')
+  }
+}
+
+const styles = StyleSheet.create({
+  content: {
+    flex: 1,
+    flexDirection: 'column',
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  txDetailsContainer: {
+    flexDirection: 'row',
+  },
+  txDetails: {
+    color: Colors.textLink,
+  },
+  iconContainer: {
+    marginBottom: 24,
+  },
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  title: {
+    ...typeScale.titleSmall,
+  },
+  description: {
+    ...typeScale.bodyMedium,
+    textAlign: 'center',
+    marginTop: 12,
+    paddingHorizontal: 48,
+    paddingBottom: 24,
+  },
+  loadingDescription: {
+    ...typeScale.bodyLarge,
+    textAlign: 'center',
+    marginTop: 12,
+    paddingHorizontal: 48,
+    paddingBottom: 24,
+  },
+  activityIndicatorContainer: {
+    paddingVertical: variables.contentPadding,
+    flex: 1,
+    alignContent: 'center',
+    justifyContent: 'center',
+  },
+  button: {
+    marginTop: 13,
+  },
+  cancelBtn: {
+    ...typeScale.bodyMedium,
+    color: Colors.navigationTopSecondary,
+    paddingHorizontal: Spacing.Thick24,
+  },
+})

package/src/fiatconnect/clients.test.tsx

@@ -0,0 +1,83 @@
+import { FiatConnectClient } from '@fiatconnect/fiatconnect-sdk'
+import { getFiatConnectClient, getSiweSigningFunction } from 'src/fiatconnect/clients'
+import { getPassword } from 'src/pincode/authentication'
+import { getKeychainAccounts } from 'src/web3/contracts'
+import { KeychainAccounts } from 'src/web3/KeychainAccounts'
+
+jest.mock('src/web3/contracts', () => ({
+  getKeychainAccounts: jest.fn(() => ({
+    getAccounts: jest.fn(() => ['fake-account']),
+  })),
+}))
+
+jest.mock('src/pincode/authentication')
+jest.mock('src/statsig', () => ({
+  getDynamicConfigParams: jest.fn().mockReturnValue({ cico: 30 }),
+}))
+
+describe('getSigningFunction', () => {
+  const keychainAccounts = new KeychainAccounts()
+  const signMessage = jest.fn().mockResolvedValue('some signed message')
+
+  beforeEach(() => {
+    keychainAccounts.getAccounts = jest.fn().mockReturnValue(['fakeAccount'])
+    keychainAccounts.isUnlocked = jest.fn().mockReturnValue(true)
+    keychainAccounts.getViemAccount = jest.fn().mockReturnValue({
+      signMessage,
+    })
+    keychainAccounts.unlock = jest.fn().mockResolvedValue(undefined)
+  })
+  it('returns a signing function that signs a message', async () => {
+    const signingFunction = getSiweSigningFunction(keychainAccounts)
+    const signedMessage = await signingFunction('test')
+    expect(signMessage).toHaveBeenCalled()
+    expect(keychainAccounts.unlock).not.toHaveBeenCalled()
+    expect(signedMessage).toEqual('some signed message')
+  })
+  it('returns a signing function that attempts to unlock accout if locked', async () => {
+    keychainAccounts.isUnlocked = jest.fn().mockReturnValue(false)
+    const signingFunction = getSiweSigningFunction(keychainAccounts)
+    const signedMessage = await signingFunction('test')
+    expect(signMessage).toHaveBeenCalled()
+    expect(keychainAccounts.unlock).toHaveBeenCalled()
+    expect(getPassword).toHaveBeenCalled()
+    expect(signedMessage).toEqual('some signed message')
+  })
+})
+
+describe('getFiatConnectClient', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('makes and returns a new client the first time', async () => {
+    const fcClient = await getFiatConnectClient('provider1', 'https://provider1.url')
+    expect(getKeychainAccounts).toHaveBeenCalled()
+    expect(fcClient).toBeInstanceOf(FiatConnectClient)
+    expect(fcClient).toHaveProperty('config.timeout', 30000)
+  })
+
+  it('returns an already existing client', async () => {
+    const fcClient = await getFiatConnectClient('provider1', 'https://provider1.url')
+    expect(getKeychainAccounts).not.toHaveBeenCalled()
+    expect(fcClient).toBeInstanceOf(FiatConnectClient)
+  })
+
+  it('returns a new client if provider url changes', async () => {
+    const fcClient = await getFiatConnectClient('provider1', 'https://provider1.url/v2')
+    expect(getKeychainAccounts).toHaveBeenCalled()
+    expect(fcClient).toBeInstanceOf(FiatConnectClient)
+  })
+
+  it('returns a new client if provider API key changes', async () => {
+    const fcClient = await getFiatConnectClient('provider1', 'api-key', 'https://provider1.url/v2')
+    expect(getKeychainAccounts).toHaveBeenCalled()
+    expect(fcClient).toBeInstanceOf(FiatConnectClient)
+  })
+
+  it('returns a new client for a different provider', async () => {
+    const fcClient = await getFiatConnectClient('provider2', 'https://provider2.url')
+    expect(getKeychainAccounts).toHaveBeenCalled()
+    expect(fcClient).toBeInstanceOf(FiatConnectClient)
+  })
+})

package/src/fiatconnect/clients.ts

@@ -0,0 +1,69 @@
+import { FiatConnectApiClient, FiatConnectClient } from '@fiatconnect/fiatconnect-sdk'
+import { FIATCONNECT_NETWORK } from 'src/config'
+import { getPassword } from 'src/pincode/authentication'
+import { getDynamicConfigParams } from 'src/statsig'
+import { DynamicConfigs } from 'src/statsig/constants'
+import { StatsigDynamicConfigs } from 'src/statsig/types'
+import { KeychainAccounts } from 'src/web3/KeychainAccounts'
+import { UNLOCK_DURATION } from 'src/web3/consts'
+import { getKeychainAccounts } from 'src/web3/contracts'
+
+const fiatConnectClients: Record<
+  string,
+  { url: string; apiKey: string | undefined; client: FiatConnectApiClient }
+> = {}
+
+/**
+ * A helper function used by SIWE clients for signing SIWE login messages
+ *
+ * @param wallet
+ */
+export function getSiweSigningFunction(
+  keychainAccounts: KeychainAccounts
+): (message: string) => Promise<string> {
+  return async function (message: string): Promise<string> {
+    const [account] = keychainAccounts.getAccounts()
+    if (!keychainAccounts.isUnlocked(account)) {
+      await keychainAccounts.unlock(account, await getPassword(account), UNLOCK_DURATION)
+    }
+    const viemAccount = keychainAccounts.getViemAccount(account)
+    if (!viemAccount) {
+      // This should never happen
+      throw new Error('Viem account not found')
+    }
+    return await viemAccount.signMessage({ message })
+  }
+}
+
+export async function getFiatConnectClient(
+  providerId: string,
+  providerBaseUrl: string,
+  providerApiKey?: string
+): Promise<FiatConnectApiClient> {
+  if (
+    !fiatConnectClients[providerId] ||
+    fiatConnectClients[providerId].url !== providerBaseUrl ||
+    fiatConnectClients[providerId].apiKey !== providerApiKey
+  ) {
+    const accounts = await getKeychainAccounts()
+    const [account] = accounts.getAccounts()
+    fiatConnectClients[providerId] = {
+      url: providerBaseUrl,
+      apiKey: providerApiKey,
+      client: new FiatConnectClient(
+        {
+          baseUrl: providerBaseUrl,
+          network: FIATCONNECT_NETWORK,
+          accountAddress: account,
+          apiKey: providerApiKey,
+          timeout:
+            getDynamicConfigParams(
+              DynamicConfigs[StatsigDynamicConfigs.WALLET_NETWORK_TIMEOUT_SECONDS]
+            ).cico * 1000,
+        },
+        getSiweSigningFunction(accounts)
+      ),
+    }
+  }
+  return fiatConnectClients[providerId].client
+}

package/src/fiatconnect/consts.ts

@@ -0,0 +1,41 @@
+import { CryptoType, FiatType } from '@fiatconnect/fiatconnect-types'
+import { LocalCurrencyCode } from 'src/localCurrency/consts'
+
+export const FIATCONNECT_CURRENCY_TO_WALLET_CURRENCY: Record<FiatType, LocalCurrencyCode> = {
+  [FiatType.ARS]: LocalCurrencyCode.ARS,
+  [FiatType.BOB]: LocalCurrencyCode.BOB,
+  [FiatType.BRL]: LocalCurrencyCode.BRL,
+  [FiatType.CLP]: LocalCurrencyCode.CLP,
+  [FiatType.CNY]: LocalCurrencyCode.CNY,
+  [FiatType.COP]: LocalCurrencyCode.COP,
+  [FiatType.EUR]: LocalCurrencyCode.EUR,
+  [FiatType.FKP]: LocalCurrencyCode.FKP,
+  [FiatType.GBP]: LocalCurrencyCode.GBP,
+  [FiatType.GHS]: LocalCurrencyCode.GHS,
+  [FiatType.GNF]: LocalCurrencyCode.GNF,
+  [FiatType.GYD]: LocalCurrencyCode.GYD,
+  [FiatType.INR]: LocalCurrencyCode.INR,
+  [FiatType.KES]: LocalCurrencyCode.KES,
+  [FiatType.MXN]: LocalCurrencyCode.MXN,
+  [FiatType.NGN]: LocalCurrencyCode.NGN,
+  [FiatType.PAB]: LocalCurrencyCode.PAB,
+  [FiatType.PEN]: LocalCurrencyCode.PEN,
+  [FiatType.PHP]: LocalCurrencyCode.PHP,
+  [FiatType.PYG]: LocalCurrencyCode.PYG,
+  [FiatType.RWF]: LocalCurrencyCode.RWF,
+  [FiatType.SRD]: LocalCurrencyCode.SRD,
+  [FiatType.UGX]: LocalCurrencyCode.UGX,
+  [FiatType.USD]: LocalCurrencyCode.USD,
+  [FiatType.UYU]: LocalCurrencyCode.UYU,
+  [FiatType.VES]: LocalCurrencyCode.VES,
+  [FiatType.XAF]: LocalCurrencyCode.XAF,
+  [FiatType.XOF]: LocalCurrencyCode.XOF,
+  [FiatType.ZAR]: LocalCurrencyCode.ZAR,
+}
+
+export const WALLET_CRYPTO_TO_FIATCONNECT_CRYPTO: Record<string, CryptoType | undefined> = {
+  CELO: CryptoType.CELO,
+  cEUR: CryptoType.cEUR,
+  cUSD: CryptoType.cUSD,
+  cREAL: CryptoType.cREAL,
+}

package/src/fiatconnect/fiatAccountSchemas/accountNumber.test.ts

@@ -0,0 +1,60 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getAccountNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/accountNumber'
+import { FormFieldParam } from 'src/fiatconnect/fiatAccountSchemas/types'
+
+describe(getAccountNumberSchema, () => {
+  describe('accountNumber.validate', () => {
+    const { validate } = getAccountNumberSchema({
+      country: 'US',
+      fiatAccountType: FiatAccountType.BankAccount,
+    }).accountNumber as FormFieldParam
+    it('fails on invalid input', () => {
+      // special characters not allowed
+      expect(validate('83274#').isValid).toBeFalsy()
+      // alphabetic characters not allowed
+      expect(validate('83274A38f').isValid).toBeFalsy()
+      // empty input not allowed
+      expect(validate('').isValid).toBeFalsy()
+      // spaces in the middle not allowed
+      expect(validate('834834 4343').isValid).toBeFalsy()
+      // failure returns default error message
+      expect(validate('834834 4343').errorMessage).toEqual(
+        'fiatAccountSchema.accountNumber.errorMessageDigit'
+      )
+    })
+    it('succeeds on valid input', () => {
+      // Any numeric value valid
+      expect(validate('83274').isValid).toBeTruthy()
+      expect(validate('83274').isValid).toBeTruthy()
+      expect(validate('83274382432432423').isValid).toBeTruthy()
+      expect(validate('83274382432432423').errorMessage).toBeUndefined()
+    })
+    it('handles overrides', () => {
+      const { validate: validateWithOverride } = getAccountNumberSchema(
+        { country: 'US', fiatAccountType: FiatAccountType.BankAccount },
+        {
+          US: {
+            [FiatAccountSchema.AccountNumber]: {
+              // Hypothetical override looking for the exact string 123456
+              accountNumber: {
+                regex: '^123456A$',
+                errorString: 'notExactMatch',
+                errorParams: { expected: '123456A' },
+              },
+            },
+          },
+        }
+      ).accountNumber as FormFieldParam
+
+      const failure = validateWithOverride('123')
+      expect(failure.isValid).toBeFalsy()
+      expect(failure.errorMessage).toEqual(
+        'fiatAccountSchema.accountNumber.notExactMatch, {"expected":"123456A"}'
+      )
+
+      const success = validateWithOverride('123456A')
+      expect(success.isValid).toBeTruthy()
+      expect(success.errorMessage).toBeUndefined()
+    })
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/accountNumber.ts

@@ -0,0 +1,55 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getObfuscatedAccountNumber } from 'src/fiatconnect'
+import { INSTITUTION_NAME_FIELD } from 'src/fiatconnect/fiatAccountSchemas'
+import { FiatAccountFormSchema } from 'src/fiatconnect/fiatAccountSchemas/types'
+import { FiatAccountSchemaCountryOverrides } from 'src/fiatconnect/types'
+import i18n from 'src/i18n'
+
+export const getAccountNumberSchema = (
+  implicitParams: {
+    country: string
+    fiatAccountType: FiatAccountType
+  },
+  countryOverrides?: FiatAccountSchemaCountryOverrides
+): FiatAccountFormSchema<FiatAccountSchema.AccountNumber> => {
+  // NOTE: the schema for overrides supports overriding any field's regex or
+  // errorMessage, but the below currently applies it to just the
+  // `accountNumber` field in the `AccountNumber` schema.
+  // This can be extended to support overriding other params and applied more
+  // generically if more fields/schemas require it.
+  const overrides = countryOverrides?.[implicitParams.country]?.[FiatAccountSchema.AccountNumber]
+  const accountNumberValidator = (input: string) => {
+    const regex = overrides?.accountNumber?.regex
+      ? new RegExp(overrides.accountNumber.regex)
+      : /^[0-9]+$/
+    const isValid = regex.test(input)
+    const errorMessageText = overrides?.accountNumber?.errorString
+      ? i18n.t(
+          `fiatAccountSchema.accountNumber.${overrides.accountNumber.errorString}`,
+          overrides.accountNumber.errorParams
+        )
+      : i18n.t('fiatAccountSchema.accountNumber.errorMessageDigit')
+    return {
+      isValid,
+      errorMessage: isValid ? undefined : errorMessageText,
+    }
+  }
+
+  return {
+    institutionName: INSTITUTION_NAME_FIELD,
+    accountNumber: {
+      name: 'accountNumber',
+      label: i18n.t('fiatAccountSchema.accountNumber.label'),
+      validate: accountNumberValidator,
+      placeholderText: i18n.t('fiatAccountSchema.accountNumber.placeholderText'),
+      keyboardType: 'number-pad',
+    },
+    country: { name: 'country', value: implicitParams.country },
+    fiatAccountType: { name: 'fiatAccountType', value: FiatAccountType.BankAccount },
+    accountName: {
+      name: 'accountName',
+      computeValue: ({ institutionName, accountNumber }) =>
+        `${institutionName} (${getObfuscatedAccountNumber(accountNumber!)})`,
+    },
+  }
+}