wallet-stack 1.0.0-alpha.121

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

@@ -0,0 +1,53 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getIbanNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/ibanNumber'
+import { FormFieldParam } from 'src/fiatconnect/fiatAccountSchemas/types'
+
+const validIbanNumber = 'GB29 NWBK 6016 1331 9268 19'
+const invalidIbanNumber = 'GB94 BARC 2020 1530 0934 59' // fails checksum
+
+describe(getIbanNumberSchema, () => {
+  describe('ibanNumber.validate', () => {
+    const { validate } = getIbanNumberSchema({
+      country: 'US',
+      fiatAccountType: FiatAccountType.BankAccount,
+    }).iban as FormFieldParam
+    it('fails on invalid input', () => {
+      expect(validate(invalidIbanNumber).isValid).toBeFalsy()
+      // failure returns default error message
+      expect(validate(invalidIbanNumber).errorMessage).toEqual(
+        'fiatAccountSchema.ibanNumber.errorMessage'
+      )
+    })
+    it('succeeds on valid input', () => {
+      expect(validate(validIbanNumber).isValid).toBeTruthy()
+      expect(validate(validIbanNumber).errorMessage).toBeUndefined()
+    })
+    it('handles overrides', () => {
+      const { validate: validateWithOverride } = getIbanNumberSchema(
+        { country: 'US', fiatAccountType: FiatAccountType.BankAccount },
+        {
+          US: {
+            [FiatAccountSchema.IBANNumber]: {
+              // Hypothetical override looking for the exact string 123456
+              iban: {
+                regex: '^123456A$',
+                errorString: 'notExactMatch',
+                errorParams: { expected: '123456A' },
+              },
+            },
+          },
+        }
+      ).iban as FormFieldParam
+
+      const failure = validateWithOverride('123')
+      expect(failure.isValid).toBeFalsy()
+      expect(failure.errorMessage).toEqual(
+        'fiatAccountSchema.ibanNumber.notExactMatch, {"expected":"123456A"}'
+      )
+
+      const success = validateWithOverride('123456A')
+      expect(success.isValid).toBeTruthy()
+      expect(success.errorMessage).toBeUndefined()
+    })
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/ibanNumber.ts

@@ -0,0 +1,56 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { validateIBAN } from 'ibantools'
+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 getIbanNumberSchema = (
+  implicitParams: {
+    country: string
+    fiatAccountType: FiatAccountType
+  },
+  countryOverrides?: FiatAccountSchemaCountryOverrides
+): FiatAccountFormSchema<FiatAccountSchema.IBANNumber> => {
+  const overrides = countryOverrides?.[implicitParams.country]?.[FiatAccountSchema.IBANNumber]
+  // Ensure spaces/lower case don't lead to invalid input
+  const clean = (input: string) => input.replace(/\s/g, '').toUpperCase()
+  const ibanNumberValidator = (input: string) => {
+    const cleanInput = clean(input)
+    const isValid = overrides?.iban?.regex
+      ? new RegExp(overrides.iban.regex).test(cleanInput)
+      : validateIBAN(cleanInput).valid
+    const errorMessageText = overrides?.iban?.errorString
+      ? i18n.t(
+          `fiatAccountSchema.ibanNumber.${overrides.iban.errorString}`,
+          overrides.iban.errorParams
+        )
+      : i18n.t(`fiatAccountSchema.ibanNumber.errorMessage`)
+
+    // If we want more descriptive error messages in the future we can look at
+    // validateIBAN(cleanInput).errorCodes to show the user more helpful messages
+    return {
+      isValid,
+      errorMessage: isValid ? undefined : errorMessageText,
+    }
+  }
+
+  return {
+    institutionName: INSTITUTION_NAME_FIELD,
+    iban: {
+      name: 'iban',
+      label: i18n.t('fiatAccountSchema.ibanNumber.label'),
+      validate: ibanNumberValidator,
+      placeholderText: i18n.t('fiatAccountSchema.ibanNumber.placeholderText'),
+      keyboardType: 'default',
+    },
+    country: { name: 'country', value: implicitParams.country },
+    fiatAccountType: { name: 'fiatAccountType', value: FiatAccountType.BankAccount },
+    accountName: {
+      name: 'accountName',
+      computeValue: ({ institutionName, iban = '' }) =>
+        `${institutionName} (${getObfuscatedAccountNumber(clean(iban))})`,
+    },
+  }
+}

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

@@ -0,0 +1,45 @@
+import { FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getIfscAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/ifscAccount'
+import { FormFieldParam } from 'src/fiatconnect/fiatAccountSchemas/types'
+
+describe('getIfscAccountSchema', () => {
+  const schema = getIfscAccountSchema({
+    country: 'IN',
+    fiatAccountType: FiatAccountType.BankAccount,
+  })
+
+  describe('ifsc', () => {
+    const { validate, format } = schema.ifsc as FormFieldParam
+
+    it('validate fails on invalid input', () => {
+      const { isValid, errorMessage } = validate('abcd01234')
+      expect(isValid).toBeFalsy()
+      expect(errorMessage).toEqual('fiatAccountSchema.ifsc.errorMessage')
+    })
+    it('validate succeeds on valid input', () => {
+      const { isValid, errorMessage } = validate('ABCD0123456')
+      expect(isValid).toBeTruthy()
+      expect(errorMessage).toBeUndefined()
+    })
+    it('format converts to upper case', () => {
+      expect(format!('')).toEqual('')
+      expect(format!('12345')).toEqual('12345')
+      expect(format!('abcd12345z')).toEqual('ABCD12345Z')
+    })
+  })
+
+  describe('accountNumber', () => {
+    const { validate } = schema.accountNumber as FormFieldParam
+
+    it('validate fails on invalid input', () => {
+      const { isValid, errorMessage } = validate('abcd01234')
+      expect(isValid).toBeFalsy()
+      expect(errorMessage).toEqual('fiatAccountSchema.accountNumber.errorMessageDigit')
+    })
+    it('validate succeeds on valid input', () => {
+      const { isValid, errorMessage } = validate('123456')
+      expect(isValid).toBeTruthy()
+      expect(errorMessage).toBeUndefined()
+    })
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/ifscAccount.ts

@@ -0,0 +1,58 @@
+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 i18n from 'src/i18n'
+
+export const getIfscAccountSchema = (implicitParams: {
+  country: string
+  fiatAccountType: FiatAccountType
+}): FiatAccountFormSchema<FiatAccountSchema.IFSCAccount> => {
+  const accountNumberValidator = (input: string) => {
+    const isValid = /^[0-9]+$/.test(input)
+    return {
+      isValid,
+      errorMessage: isValid
+        ? undefined
+        : i18n.t('fiatAccountSchema.accountNumber.errorMessageDigit'),
+    }
+  }
+
+  const ifscValidator = (input: string) => {
+    const isValid = /^[A-Z]{4}0[A-Z0-9]{6}$/.test(input)
+    return {
+      isValid,
+      errorMessage: isValid ? undefined : i18n.t('fiatAccountSchema.ifsc.errorMessage'),
+    }
+  }
+
+  const ifscFormatter = (input: string) => {
+    return input.toUpperCase()
+  }
+
+  return {
+    institutionName: INSTITUTION_NAME_FIELD,
+    ifsc: {
+      name: 'ifsc',
+      label: i18n.t('fiatAccountSchema.ifsc.label'),
+      validate: ifscValidator,
+      format: ifscFormatter,
+      placeholderText: i18n.t('fiatAccountSchema.ifsc.placeholderText'),
+      keyboardType: 'default',
+    },
+    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!)})`,
+    },
+  }
+}

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

@@ -0,0 +1,119 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getSchema } from 'src/fiatconnect/fiatAccountSchemas'
+import { getAccountNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/accountNumber'
+import { getIbanNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/ibanNumber'
+import { getIfscAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/ifscAccount'
+import { getMobileMoneySchema } from 'src/fiatconnect/fiatAccountSchemas/mobileMoney'
+import { getPixAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/pixAccount'
+import { FiatAccountSchemaCountryOverrides } from 'src/fiatconnect/types'
+
+jest.mock('src/fiatconnect/fiatAccountSchemas/accountNumber', () => ({
+  getAccountNumberSchema: jest.fn(() => 'account-number-schema'),
+}))
+
+jest.mock('src/fiatconnect/fiatAccountSchemas/ibanNumber', () => ({
+  getIbanNumberSchema: jest.fn(() => 'iban-number-schema'),
+}))
+
+jest.mock('src/fiatconnect/fiatAccountSchemas/mobileMoney', () => ({
+  getMobileMoneySchema: jest.fn(() => 'mobile-money-schema'),
+}))
+
+jest.mock('src/fiatconnect/fiatAccountSchemas/ifscAccount', () => ({
+  getIfscAccountSchema: jest.fn(() => 'ifsc-account-schema'),
+}))
+
+jest.mock('src/fiatconnect/fiatAccountSchemas/pixAccount', () => ({
+  getPixAccountSchema: jest.fn(() => 'pix-account-schema'),
+}))
+
+describe(getSchema, () => {
+  const params: {
+    fiatAccountSchema: FiatAccountSchema
+    country: string | null
+    fiatAccountType: FiatAccountType
+    schemaCountryOverrides: FiatAccountSchemaCountryOverrides
+  } = {
+    fiatAccountSchema: FiatAccountSchema.AccountNumber,
+    country: 'GB',
+    fiatAccountType: FiatAccountType.BankAccount,
+    schemaCountryOverrides: {
+      GB: {},
+    },
+  }
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+  it('throws an error when country is null', () => {
+    expect(() =>
+      getSchema({
+        ...params,
+        country: null,
+      })
+    ).toThrow()
+  })
+  it('throws an error when there is an unsupported schema type', () => {
+    expect(() =>
+      getSchema({
+        ...params,
+        fiatAccountSchema: 'Foo' as FiatAccountSchema,
+      })
+    ).toThrow()
+  })
+  it('calls getAccountNumberSchema for AccountNumber schema', () => {
+    const schema = getSchema(params)
+    expect(getAccountNumberSchema).toHaveBeenCalledWith(
+      {
+        country: params.country,
+        fiatAccountType: params.fiatAccountType,
+      },
+      params.schemaCountryOverrides
+    )
+    expect(schema).toEqual('account-number-schema')
+  })
+  it('calls getIbanNumberSchema for IbanNumber schema', () => {
+    const schema = getSchema({
+      ...params,
+      fiatAccountSchema: FiatAccountSchema.IBANNumber,
+    })
+    expect(getIbanNumberSchema).toHaveBeenCalledWith(
+      {
+        country: params.country,
+        fiatAccountType: params.fiatAccountType,
+      },
+      params.schemaCountryOverrides
+    )
+    expect(schema).toEqual('iban-number-schema')
+  })
+  it('calls getMobileMoneySchema for MobileMoney schema', () => {
+    const schema = getSchema({
+      ...params,
+      fiatAccountType: FiatAccountType.MobileMoney,
+      fiatAccountSchema: FiatAccountSchema.MobileMoney,
+    })
+    expect(getMobileMoneySchema).toHaveBeenCalledWith({
+      country: params.country,
+      fiatAccountType: FiatAccountType.MobileMoney,
+    })
+    expect(schema).toEqual('mobile-money-schema')
+  })
+  it('calls getIfscAccountSchema for IfscAccount schema', () => {
+    const schema = getSchema({
+      ...params,
+      fiatAccountSchema: FiatAccountSchema.IFSCAccount,
+    })
+    expect(getIfscAccountSchema).toHaveBeenCalledWith({
+      country: params.country,
+      fiatAccountType: params.fiatAccountType,
+    })
+    expect(schema).toEqual('ifsc-account-schema')
+  })
+  it('calls getPIXAccountSchema for PIXAccount schema', () => {
+    const schema = getSchema({
+      ...params,
+      fiatAccountSchema: FiatAccountSchema.PIXAccount,
+    })
+    expect(getPixAccountSchema).toHaveBeenCalled()
+    expect(schema).toEqual('pix-account-schema')
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/index.ts

@@ -0,0 +1,89 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getAccountNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/accountNumber'
+import { getIbanNumberSchema } from 'src/fiatconnect/fiatAccountSchemas/ibanNumber'
+import { getIfscAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/ifscAccount'
+import { getMobileMoneySchema } from 'src/fiatconnect/fiatAccountSchemas/mobileMoney'
+import { getPixAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/pixAccount'
+import {
+  ComputedParam,
+  FormFieldParam,
+  ImplicitParam,
+} from 'src/fiatconnect/fiatAccountSchemas/types'
+import { FiatAccountSchemaCountryOverrides } from 'src/fiatconnect/types'
+import i18n from 'src/i18n'
+
+export const getSchema = ({
+  fiatAccountSchema,
+  country,
+  fiatAccountType,
+  schemaCountryOverrides,
+}: {
+  fiatAccountSchema: FiatAccountSchema
+  country: string | null
+  fiatAccountType: FiatAccountType
+  schemaCountryOverrides: FiatAccountSchemaCountryOverrides
+}) => {
+  if (!country) {
+    // should never happen
+    throw new Error('Country not supported')
+  }
+  switch (fiatAccountSchema) {
+    case FiatAccountSchema.AccountNumber:
+      return getAccountNumberSchema(
+        {
+          country,
+          fiatAccountType,
+        },
+        schemaCountryOverrides
+      )
+    case FiatAccountSchema.IBANNumber:
+      return getIbanNumberSchema(
+        {
+          country,
+          fiatAccountType,
+        },
+        schemaCountryOverrides
+      )
+    case FiatAccountSchema.MobileMoney:
+      return getMobileMoneySchema({
+        country,
+        fiatAccountType,
+      })
+    case FiatAccountSchema.IFSCAccount:
+      return getIfscAccountSchema({
+        country,
+        fiatAccountType,
+      })
+    case FiatAccountSchema.PIXAccount:
+      return getPixAccountSchema()
+    default:
+      // should never happen
+      throw new Error('Unsupported schema type')
+  }
+}
+
+export const INSTITUTION_NAME_FIELD: FormFieldParam = {
+  name: 'institutionName',
+  label: i18n.t('fiatAccountSchema.institutionName.label'),
+  validate: (input: string) => ({
+    isValid: input.length > 0,
+  }),
+  placeholderText: i18n.t('fiatAccountSchema.institutionName.placeholderText'),
+  keyboardType: 'default',
+}
+
+export function isFormFieldParam<T, K extends keyof T>(
+  item: FormFieldParam | ImplicitParam<T, K> | ComputedParam<T, K>
+): item is FormFieldParam {
+  return 'keyboardType' in item
+}
+export function isImplicitParam<T, K extends keyof T>(
+  item: FormFieldParam | ImplicitParam<T, K> | ComputedParam<T, K>
+): item is ImplicitParam<T, K> {
+  return 'value' in item
+}
+export function isComputedParam<T, K extends keyof T>(
+  item: FormFieldParam | ImplicitParam<T, K> | ComputedParam<T, K>
+): item is ComputedParam<T, K> {
+  return 'computeValue' in item
+}

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

@@ -0,0 +1,29 @@
+import { FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getMobileMoneySchema } from 'src/fiatconnect/fiatAccountSchemas/mobileMoney'
+import { FormFieldParam } from 'src/fiatconnect/fiatAccountSchemas/types'
+
+const validPhoneNumber = '+123456789'
+const invalidPhoneNumber = '+1234567890123456789' // too long
+
+describe('getMobileMoneySchema', () => {
+  const { validate, format } = getMobileMoneySchema({
+    country: 'US',
+    fiatAccountType: FiatAccountType.MobileMoney,
+  }).mobile as FormFieldParam
+  it('validate fails on invalid input', () => {
+    expect(validate(invalidPhoneNumber).isValid).toBeFalsy()
+    // failure returns default error message
+    expect(validate(invalidPhoneNumber).errorMessage).toEqual(
+      'fiatAccountSchema.mobileMoney.mobile.errorMessage'
+    )
+  })
+  it('validate succeeds on valid input', () => {
+    expect(validate(validPhoneNumber).isValid).toBeTruthy()
+    expect(validate(validPhoneNumber).errorMessage).toBeUndefined()
+  })
+  it('formatter adds "+" symbol', () => {
+    //Doesn't add when text is empty
+    expect(format!('')).toEqual('')
+    expect(format!('12345')).toEqual('+12345')
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/mobileMoney.ts

@@ -0,0 +1,61 @@
+import { FiatAccountSchema, FiatAccountType } from '@fiatconnect/fiatconnect-types'
+import { getObfuscatedAccountNumber } from 'src/fiatconnect'
+import { FiatAccountFormSchema } from 'src/fiatconnect/fiatAccountSchemas/types'
+import i18n from 'src/i18n'
+
+export const getMobileMoneySchema = (implicitParams: {
+  country: string
+  fiatAccountType: FiatAccountType
+}): FiatAccountFormSchema<FiatAccountSchema.MobileMoney> => {
+  const mobileValidator = (input: string) => {
+    //Phone numbers should start with a plus sign and be 6-15 digits long
+    const regex = /^\+[0-9]{6,15}$/
+    const isValid = regex.test(input)
+    const errorMessageText = i18n.t('fiatAccountSchema.mobileMoney.mobile.errorMessage')
+    return {
+      isValid,
+      errorMessage: isValid ? undefined : errorMessageText,
+    }
+  }
+
+  const mobileFormatter = (input: string) => {
+    if (input.length && input[0] !== '+') {
+      return `+${input}`
+    }
+    return input
+  }
+
+  return {
+    operator: {
+      name: 'operator',
+      label: i18n.t('fiatAccountSchema.mobileMoney.operator.label'),
+      placeholderText: i18n.t('fiatAccountSchema.mobileMoney.operator.placeholderText'),
+      validate: (input: string) => ({ isValid: !!input }),
+      keyboardType: 'default',
+    },
+    mobile: {
+      name: 'mobile',
+      label: i18n.t('fiatAccountSchema.mobileMoney.mobile.label'),
+      infoDialog: {
+        title: i18n.t('fiatAccountSchema.mobileMoney.mobileDialog.title'),
+        actionText: i18n.t('fiatAccountSchema.mobileMoney.mobileDialog.dismiss'),
+        body: i18n.t('fiatAccountSchema.mobileMoney.mobileDialog.body'),
+      },
+      format: mobileFormatter,
+      validate: mobileValidator,
+      placeholderText: i18n.t('fiatAccountSchema.mobileMoney.mobile.placeholderText'),
+      keyboardType: 'phone-pad',
+    },
+    country: { name: 'country', value: implicitParams.country },
+    fiatAccountType: { name: 'fiatAccountType', value: FiatAccountType.MobileMoney },
+    accountName: {
+      name: 'accountName',
+      computeValue: ({ operator, mobile = '' }) =>
+        `${operator} (${getObfuscatedAccountNumber(mobile)})`,
+    },
+    institutionName: {
+      name: 'institutionName',
+      computeValue: ({ operator = '' }) => operator,
+    },
+  }
+}

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

@@ -0,0 +1,45 @@
+import { PIXKeyTypeEnum } from '@fiatconnect/fiatconnect-types'
+import { getPixAccountSchema } from 'src/fiatconnect/fiatAccountSchemas/pixAccount'
+import { FormFieldParam } from 'src/fiatconnect/fiatAccountSchemas/types'
+
+describe('getPixAccountSchema', () => {
+  const schema = getPixAccountSchema()
+
+  describe('key', () => {
+    const { isVisible, validate } = schema.key as FormFieldParam
+
+    it('isVisible is true only if keyType is not empty', () => {
+      expect(isVisible?.({})).toEqual(false)
+      expect(isVisible?.({ keyType: '' })).toEqual(false)
+      expect(isVisible?.({ keyType: PIXKeyTypeEnum.CPF })).toEqual(true)
+    })
+
+    it.each([
+      PIXKeyTypeEnum.CPF,
+      PIXKeyTypeEnum.EMAIL,
+      PIXKeyTypeEnum.PHONE,
+      PIXKeyTypeEnum.RANDOM,
+    ])('validate fails for invalid %s', (keyType: PIXKeyTypeEnum) => {
+      const { isValid, errorMessage } = validate('badInput', { keyType })
+      expect(isValid).toEqual(false)
+      expect(errorMessage).toEqual('fiatAccountSchema.pix.key.errorMessage')
+    })
+
+    it.each([
+      [PIXKeyTypeEnum.CPF, '000.000.000-00'],
+      [PIXKeyTypeEnum.EMAIL, 'goodEmail@domain.com'],
+      [PIXKeyTypeEnum.PHONE, '12345678901'],
+      [PIXKeyTypeEnum.RANDOM, 'ca2e0d3e-a7f0-4b84-b5da-d09c3e156d8c'],
+    ])('validate succeeds for valid %s', (keyType: PIXKeyTypeEnum, input: string) => {
+      const { isValid, errorMessage } = validate(input, { keyType })
+      expect(isValid).toEqual(true)
+      expect(errorMessage).toBeUndefined()
+    })
+
+    it('Invalid keyType will show error if pix key is also invalid', () => {
+      const { isValid, errorMessage } = validate('badInput', { keyType: 'notValidPixKeyType' })
+      expect(isValid).toEqual(false)
+      expect(errorMessage).toEqual('fiatAccountSchema.pix.key.errorMessage')
+    })
+  })
+})

package/src/fiatconnect/fiatAccountSchemas/pixAccount.ts

@@ -0,0 +1,62 @@
+import {
+  EMAIL_REGEX,
+  FiatAccountSchema,
+  FiatAccountType,
+  PIXKeyTypeEnum,
+  PIX_CPF_KEY_REGEX,
+  PIX_PHONE_KEY_REGEX,
+} from '@fiatconnect/fiatconnect-types'
+import { getObfuscatedEmail } from 'src/fiatconnect'
+import { INSTITUTION_NAME_FIELD } from 'src/fiatconnect/fiatAccountSchemas'
+import { FiatAccountFormSchema } from 'src/fiatconnect/fiatAccountSchemas/types'
+import i18n from 'src/i18n'
+
+const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/g
+const REGEXES: Record<PIXKeyTypeEnum, RegExp> = {
+  [PIXKeyTypeEnum.CPF]: PIX_CPF_KEY_REGEX,
+  [PIXKeyTypeEnum.EMAIL]: EMAIL_REGEX,
+  [PIXKeyTypeEnum.PHONE]: PIX_PHONE_KEY_REGEX,
+  [PIXKeyTypeEnum.RANDOM]: UUID_REGEX,
+}
+const DEFAULT_REGEX = new RegExp(
+  Object.values(REGEXES)
+    .map((regex) => regex.source)
+    .join('|')
+)
+
+export const getPixAccountSchema = (): FiatAccountFormSchema<FiatAccountSchema.PIXAccount> => {
+  const keyValidation = (input: string, fieldNamesToValues: Record<string, string>) => {
+    const keyType = fieldNamesToValues['keyType']
+    const regex = REGEXES[keyType as PIXKeyTypeEnum] ?? DEFAULT_REGEX
+    const isValid = regex.test(input)
+    const errorMessageText = i18n.t('fiatAccountSchema.pix.key.errorMessage')
+    return {
+      isValid,
+      errorMessage: isValid ? undefined : errorMessageText,
+    }
+  }
+
+  return {
+    institutionName: INSTITUTION_NAME_FIELD,
+    keyType: {
+      name: 'keyType',
+      label: i18n.t('fiatAccountSchema.pix.keyType.label'),
+      placeholderText: '', //Unused field, always a dropdown
+      validate: (input: string) => ({ isValid: !!input }),
+      keyboardType: 'default',
+    },
+    key: {
+      name: 'key',
+      placeholderText: i18n.t('fiatAccountSchema.pix.key.placeholderText'),
+      validate: keyValidation,
+      keyboardType: 'default',
+      isVisible: (fieldNamesToValues: Record<string, string>) => !!fieldNamesToValues['keyType'],
+    },
+    fiatAccountType: { name: 'fiatAccountType', value: FiatAccountType.BankAccount },
+    accountName: {
+      name: 'accountName',
+      computeValue: ({ institutionName, key = '' }) =>
+        `${institutionName} (${getObfuscatedEmail(key)})`,
+    },
+  }
+}

package/src/fiatconnect/fiatAccountSchemas/types.ts

@@ -0,0 +1,40 @@
+import { FiatAccountSchema, FiatAccountSchemas } from '@fiatconnect/fiatconnect-types'
+import { KeyboardType } from 'react-native'
+
+export interface FormFieldParam {
+  name: string
+  label?: string | null
+  infoDialog?: {
+    title: string
+    actionText: string
+    body: string
+  }
+  format?(input: string): string
+  validate(
+    input: string,
+    fieldNamesToValues?: Record<string, string>
+  ): {
+    isValid: boolean
+    errorMessage?: string
+  }
+  placeholderText: string
+  keyboardType: KeyboardType
+  isVisible?(fieldNamesToValues: Record<string, string>): boolean
+}
+
+export interface ImplicitParam<T, K extends keyof T> {
+  name: string
+  value: T[K]
+}
+
+export interface ComputedParam<T, K extends keyof T> {
+  name: string
+  computeValue: (otherFields: Partial<T>) => T[K]
+}
+
+export type FiatAccountFormSchema<T extends FiatAccountSchema> = {
+  [Property in keyof FiatAccountSchemas[T]]:
+    | FormFieldParam
+    | ImplicitParam<FiatAccountSchemas[T], Property>
+    | ComputedParam<FiatAccountSchemas[T], Property>
+}