wallet-stack 1.0.0-alpha.121

package/src/utils/ensureError.ts

@@ -0,0 +1,13 @@
+export function ensureError(value: unknown): Error {
+  if (value instanceof Error) return value
+
+  let stringified = '[Unable to stringify the thrown value]'
+  try {
+    stringified = JSON.stringify(value)
+  } catch {
+    // do nothing
+  }
+
+  const error = new Error(`Non 'Error' value thrown. Stringified value: ${stringified}`)
+  return error
+}

package/src/utils/fetchWithTimeout.test.ts

@@ -0,0 +1,55 @@
+import { FetchMock } from 'jest-fetch-mock'
+import { fetchWithTimeout } from 'src/utils/fetchWithTimeout'
+
+const mockFetch = fetch as FetchMock
+
+describe('fetchWithTimeout', () => {
+  beforeEach(() => {
+    mockFetch.resetMocks()
+  })
+
+  it('returns response if request completes within timeout', async () => {
+    mockFetch.mockResponseOnce('success')
+
+    const response = await fetchWithTimeout('https://does-not-matter')
+
+    expect(response.ok).toEqual(true)
+    expect(await response.text()).toEqual('success')
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    expect(mockFetch).toHaveBeenCalledWith('https://does-not-matter', {
+      signal: expect.any(AbortSignal),
+    })
+  })
+
+  it('returns response for request with options if it completes within timeout', async () => {
+    mockFetch.mockResponseOnce('success')
+
+    const response = await fetchWithTimeout('https://does-not-matter', {
+      method: 'POST',
+      body: JSON.stringify({ some: 'body' }),
+    })
+
+    expect(response.ok).toEqual(true)
+    expect(await response.text()).toEqual('success')
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    expect(mockFetch).toHaveBeenCalledWith('https://does-not-matter', {
+      method: 'POST',
+      body: JSON.stringify({ some: 'body' }),
+      signal: expect.any(AbortSignal),
+    })
+  })
+
+  it('throws if request does not complete within timeout', async () => {
+    mockFetch.mockResponseOnce(async () => {
+      jest.advanceTimersByTime(2000) // timeout is 1000
+      return 'success'
+    })
+
+    await expect(fetchWithTimeout('https://does-not-matter', null, 1000)).rejects.toThrow()
+
+    expect(mockFetch).toHaveBeenCalledTimes(1)
+    expect(mockFetch).toHaveBeenCalledWith('https://does-not-matter', {
+      signal: expect.any(AbortSignal),
+    })
+  })
+})

package/src/utils/fetchWithTimeout.ts

@@ -0,0 +1,15 @@
+import { FETCH_TIMEOUT_DURATION } from 'src/config'
+
+export const fetchWithTimeout = async (
+  url: string,
+  options: RequestInit | null = null,
+  duration: number = FETCH_TIMEOUT_DURATION
+): Promise<Response> => {
+  const controller = new AbortController()
+  const id = setTimeout(() => {
+    controller.abort()
+  }, duration)
+  const response = await fetch(url, { ...options, signal: controller.signal })
+  clearTimeout(id)
+  return response
+}

package/src/utils/formatting.test.ts

@@ -0,0 +1,93 @@
+import { Currency } from 'src/utils/currencies'
+import {
+  getCentAwareMoneyDisplay,
+  getMoneyDisplayValue,
+  getNetworkFeeDisplayValue,
+  roundDown,
+  roundUp,
+} from 'src/utils/formatting'
+
+describe('utils->formatting', () => {
+  describe('getMoneyDisplayValue', () => {
+    const UNROUNDED_NUMBER = 5.239835
+    const ROUNDED_NUMBER_2_DECIMALS = '5.24'
+    const ROUNDED_NUMBER_3_DECIMALS = '5.239'
+
+    it('formats correctly for default case', () => {
+      expect(getMoneyDisplayValue(UNROUNDED_NUMBER)).toBe(ROUNDED_NUMBER_2_DECIMALS)
+    })
+
+    it('formats correctly for dollars', () => {
+      expect(getMoneyDisplayValue(UNROUNDED_NUMBER, Currency.Dollar)).toBe(
+        ROUNDED_NUMBER_2_DECIMALS
+      )
+    })
+
+    it('formats correctly for Celo', () => {
+      expect(getMoneyDisplayValue(UNROUNDED_NUMBER, Currency.Celo)).toBe(ROUNDED_NUMBER_3_DECIMALS)
+    })
+
+    it('includes dollar symbol', () => {
+      expect(getMoneyDisplayValue(UNROUNDED_NUMBER, Currency.Dollar, true)).toBe(
+        '$' + ROUNDED_NUMBER_2_DECIMALS
+      )
+    })
+
+    it('includes gold symbol (which is nothing)', () => {
+      expect(getMoneyDisplayValue(UNROUNDED_NUMBER, Currency.Celo, true)).toBe(
+        ROUNDED_NUMBER_3_DECIMALS
+      )
+    })
+  })
+
+  describe('getCentAwareMoneyDisplay', () => {
+    const UNROUNDED_NUMBER = 5.239895
+    const ROUNDED_NUMBER = '5.23'
+
+    it('shows cents when they matter', () => {
+      expect(getCentAwareMoneyDisplay(UNROUNDED_NUMBER)).toBe(ROUNDED_NUMBER)
+    })
+    it('rounds to dollars when cents are 00', () => {
+      expect(getCentAwareMoneyDisplay(500.0)).toBe('500')
+    })
+    it('shows both cent digits when it shows any cents', () => {
+      expect(getCentAwareMoneyDisplay(500.2)).toBe('500.20')
+    })
+  })
+
+  describe('getNetworkFeeDisplayValue', () => {
+    it('rounds up for fees smaller than 0.001', () => {
+      const BELOW_DISPLAY_THRESHOLD = 0.0000002
+      expect(getNetworkFeeDisplayValue(BELOW_DISPLAY_THRESHOLD)).toBe('<0.001')
+    })
+    it('rounds up for fees smaller than 0.000001 when precise', () => {
+      const BELOW_DISPLAY_THRESHOLD = 0.0000002
+      expect(getNetworkFeeDisplayValue(BELOW_DISPLAY_THRESHOLD, true)).toBe('<0.000001')
+    })
+    it('shows right precision below 0.001 when precise', () => {
+      const BELOW_ROUNDING_THRESHOLD = 0.00002
+      expect(getNetworkFeeDisplayValue(BELOW_ROUNDING_THRESHOLD, true)).toBe('0.00002')
+    })
+    it('shows right precision above 0.001', () => {
+      const ABOVE_ROUNDING_THRESHOLD = 0.1
+      expect(getNetworkFeeDisplayValue(ABOVE_ROUNDING_THRESHOLD)).toBe('0.1')
+    })
+
+    it('shows right precision above 0.001 when precise', () => {
+      const ABOVE_ROUNDING_THRESHOLD = 0.100001
+      expect(getNetworkFeeDisplayValue(ABOVE_ROUNDING_THRESHOLD, true)).toBe('0.101')
+    })
+  })
+
+  describe('rounding', () => {
+    it('rounds up', () => {
+      expect(roundUp('0.50001', 4).toString()).toBe('0.5001')
+      expect(roundUp('0.599', 2).toString()).toBe('0.6')
+    })
+
+    it('rounds down', () => {
+      expect(roundDown('0.50001', 4).toString()).toBe('0.5')
+      expect(roundDown('0.599', 2).toString()).toBe('0.59')
+    })
+  })
+})

package/src/utils/formatting.ts

@@ -0,0 +1,107 @@
+import BigNumber from 'bignumber.js'
+import { LocalCurrencyCode, LocalCurrencySymbol } from 'src/localCurrency/consts'
+import { CURRENCIES, Currency } from 'src/utils/currencies'
+
+// Returns a localized string that represents the number with the right decimal points.
+export const getMoneyDisplayValue = (
+  value: BigNumber.Value,
+  currency: Currency = Currency.Dollar,
+  includeSymbol: boolean = false,
+  roundingTolerance: number = 1
+): string => {
+  const moneyValue = new BigNumber(value)
+  const decimals = CURRENCIES[currency].displayDecimals
+  const symbol = CURRENCIES[currency].symbol
+  // For stable currencies, if the value is lower than 0.01 we show an extra decimal point.
+  // If the value is lower than 0.001, we just show <$0.001.
+  const minValueToShow = Math.pow(10, -decimals - (currency === Currency.Celo ? 0 : 1))
+  if (moneyValue.isGreaterThan(0) && moneyValue.isLessThan(minValueToShow)) {
+    return `<${includeSymbol ? symbol : ''}${minValueToShow}`
+  }
+  const decimalsToUse =
+    currency === Currency.Celo ||
+    moneyValue.isLessThanOrEqualTo(0) ||
+    moneyValue.isGreaterThanOrEqualTo(Math.pow(10, -decimals))
+      ? decimals
+      : decimals + 1
+  const formattedValue = roundDown(value, decimalsToUse, roundingTolerance).toFormat(decimalsToUse)
+  return includeSymbol ? symbol + formattedValue : formattedValue
+}
+
+export const getLocalCurrencyDisplayValue = (
+  value: BigNumber.Value,
+  currency: LocalCurrencyCode,
+  includeSymbol: boolean = false,
+  roundingTolerance: number = 1
+): string => {
+  const symbol = LocalCurrencySymbol[currency]
+  const formattedValue = roundDown(value, 2, roundingTolerance).toFormat(2)
+  return includeSymbol ? symbol + formattedValue : formattedValue
+}
+
+// like getMoneyDisplayValue but only returns cents if they are significant
+export const getCentAwareMoneyDisplay = (value: BigNumber.Value): string => {
+  const bigValue = new BigNumber(value)
+  return bigValue.isInteger() ? bigValue.toFixed(0) : roundDown(value).toFormat(2)
+}
+
+export const getExchangeRateDisplayValue = (value: BigNumber.Value): string => {
+  return new BigNumber(value).decimalPlaces(4).toFormat()
+}
+
+export const getFeeDisplayValue = (value: BigNumber.Value | null | undefined): string => {
+  return value
+    ? // Show 0.001 if fee > 0 and <= 0.001
+      BigNumber.max(value, new BigNumber(value).isZero() ? 0 : 0.001)
+        .decimalPlaces(4)
+        .toFormat()
+    : ''
+}
+
+/**
+ * More precise getFeeDisplayValue with built in rounding
+ * Used for small Network Fees
+ * @param value fee amount
+ * @param precise true if additional precision to 6 digits for <0.001 needed
+ */
+export const getNetworkFeeDisplayValue = (
+  value: BigNumber.Value,
+  precise: boolean = false
+): string => {
+  const roundedNumber = new BigNumber(value)
+  if (precise && roundedNumber.isLessThan(0.000001)) {
+    return `<${new BigNumber(0.000001).toFormat()}`
+  } else if (roundedNumber.isLessThan(0.001)) {
+    return precise ? roundUp(value, 6).toFormat() : `<${new BigNumber(0.001).toFormat()}`
+  } else {
+    return roundUp(value, 3).toFormat()
+  }
+}
+
+export function roundDown(
+  value: BigNumber.Value,
+  decimals: number = 2,
+  roundingTolerance: number = 0
+): BigNumber {
+  if (roundingTolerance) {
+    value = new BigNumber(value).decimalPlaces(
+      decimals + roundingTolerance,
+      BigNumber.ROUND_HALF_DOWN
+    )
+  }
+  return new BigNumber(value).decimalPlaces(decimals, BigNumber.ROUND_DOWN)
+}
+
+export function roundUp(
+  value: BigNumber.Value,
+  decimals: number = 2,
+  roundingTolerance: number = 0
+): BigNumber {
+  if (roundingTolerance) {
+    value = new BigNumber(value).decimalPlaces(
+      decimals + roundingTolerance,
+      BigNumber.ROUND_HALF_DOWN
+    )
+  }
+  return new BigNumber(value).decimalPlaces(decimals, BigNumber.ROUND_UP)
+}

package/src/utils/getCountryEmoji.ts

@@ -0,0 +1,28 @@
+/**
+ * Reference file:
+ * https://github.com/celo-org/developer-tooling/blob/754b286d43bdc3f5b204897d495b2a9f4a117a8a/packages/sdk/phone-utils/src/getCountryEmoji.ts
+ */
+
+import CountryData from 'country-data'
+import { getCountryCode, getRegionCode } from 'src/utils/phoneNumbers'
+
+export function getCountryEmoji(
+  e164PhoneNumber: string,
+  countryCodePossible?: number,
+  regionCodePossible?: string
+) {
+  // The country code and region code can both be passed in, or it can be inferred from the e164PhoneNumber
+  let countryCode: any
+  let regionCode: any
+  countryCode = countryCodePossible
+  regionCode = regionCodePossible
+  if (!countryCode || !regionCode) {
+    countryCode = getCountryCode(e164PhoneNumber)
+    regionCode = getRegionCode(e164PhoneNumber)
+  }
+  const countries = CountryData.lookup.countries({ countryCallingCodes: `+${countryCode}` })
+  const userCountryArray = countries.filter((c: any) => c.alpha2 === regionCode)
+  const country = userCountryArray.length > 0 ? userCountryArray[0] : undefined
+
+  return country ? country.emoji : ''
+}

package/src/utils/getPhoneHash.ts

@@ -0,0 +1,29 @@
+/**
+ * Reference file:
+ * https://github.com/celo-org/developer-tooling/blob/8572a0f978d1aa01a36775ef4be48c3eafdbb204/packages/sdk/phone-utils/src/getPhoneHash.ts
+ *
+ * The file was removed in later versions of @celo/phone-utils so the function
+ * is taken in its final form before removal.
+ */
+
+import { getIdentifierHash, getPrefixedIdentifier, IdentifierPrefix } from 'src/utils/identifier'
+import { soliditySha3 } from 'web3-utils'
+
+/**
+ * Rerefence implementation uses "web3-utils" version 1.3.6:
+ * https://github.com/celo-org/developer-tooling/blob/8572a0f978d1aa01a36775ef4be48c3eafdbb204/packages/sdk/base/package.json#L30
+ *
+ * In that version the function "soliditySha3" returns "string | null" while the latest version of "web3-utils"
+ * returns "string | undefined". For the sake of compatibility with the original implementation while
+ * also using the latest version of "web3-utils" "?? null" was added to replace possible undefined with null.
+ */
+const sha3 = (v: string): string | null => soliditySha3({ type: 'string', value: v }) ?? null
+const getPhoneHash = (phoneNumber: string, salt?: string): string => {
+  if (salt) {
+    return getIdentifierHash(sha3, phoneNumber, IdentifierPrefix.PHONE_NUMBER, salt)
+  }
+  // backwards compatibility for old phoneUtils getPhoneHash
+  return sha3(getPrefixedIdentifier(phoneNumber, IdentifierPrefix.PHONE_NUMBER)) as string
+}
+
+export default getPhoneHash

package/src/utils/gql.ts

@@ -0,0 +1,8 @@
+/**
+ * A fake GraphQL template literal tag that turns GraphQL queries into just the original query string.
+ * It helps with syntax highlighting and formatting.
+ */
+export function gql(strings: TemplateStringsArray, ...values: any[]): string {
+  // Using String.raw to get the raw string representation
+  return String.raw(strings, ...values)
+}

package/src/utils/identifier.ts

@@ -0,0 +1,81 @@
+/**
+ * Reference file:
+ * https://github.com/celo-org/developer-tooling/blob/8572a0f978d1aa01a36775ef4be48c3eafdbb204/packages/sdk/base/src/identifier.ts
+ */
+
+// These functions were moved from the identity SDK because the protocol package
+// and @celo/phone-utils both need these core identifier generation functions as well.
+// The protocol package cannot depend on the identity SDK as is since this creates
+// a non-trivial dependency cycle (currently, if A->B means "A depends on B",
+// identity -> phone-number-privacy-common -> contractkit -> protocol).
+
+const PEPPER_SEPARATOR = '__'
+
+// Docstring is duplicated in @celo/identity; make sure to update in both places.
+/**
+ * Standardized prefixes for ODIS identifiers.
+ *
+ * @remarks These prefixes prevent collisions between off-chain identifiers.
+ * i.e. if a user's instagram and twitter handles are the same,
+ * these prefixes prevent the ODIS identifers from being the same.
+ *
+ * If you would like to use a prefix that isn't included, please put up a PR
+ * adding it to @celo/base (in celo-monorepo/packages/sdk/base/src/identifier.ts)
+ * to ensure interoperability with other projects. When adding new prefixes,
+ * please use either the full platform name in all lowercase (e.g. 'facebook')
+ * or DID methods https://w3c.github.io/did-spec-registries/#did-methods.
+ * Make sure to add the expected value for the unit test case in
+ * `celo-monorepo/packages/sdk/base/src/identifier.test.ts`,
+ * otherwise the test will fail.
+ *
+ * The NULL prefix is included to allow projects to use the sdk without selecting
+ * a predefined prefix or adding their own. Production use of the NULL prefix is
+ * discouraged since identifiers will not be interoperable with other projects.
+ * Please think carefully before using the NULL prefix.
+ */
+export enum IdentifierPrefix {
+  PHONE_NUMBER = 'tel',
+}
+
+// Docstring is duplicated in @celo/identity; make sure to update in both places.
+/**
+ * Concatenates the identifierPrefix and plaintextIdentifier with the separator '://'
+ *
+ * @param plaintextIdentifier Off-chain identifier, ex: phone number, twitter handle, email, etc.
+ * @param identifierPrefix Standardized prefix used to prevent collisions between identifiers
+ */
+export const getPrefixedIdentifier = (
+  plaintextIdentifier: string,
+  identifierPrefix: IdentifierPrefix
+): string => identifierPrefix + '://' + plaintextIdentifier
+
+/**
+ * Helper function for getIdentifierHash in @celo/identity, so that this can
+ * be used in protocol tests without dependency issues.
+ *
+ * @remarks
+ * Concatenates the plaintext prefixed identifier with the pepper derived by hashing the unblinded
+ * signature returned by ODIS.
+ *
+ * @param sha3 Hash function (i.e. soliditySha3) to use to generate the identifier
+ * @param plaintextIdentifier Off-chain identifier, ex: phone number, twitter handle, email, etc.
+ * @param identifierPrefix Standardized prefix used to prevent collisions between identifiers
+ * @param pepper Hash of the unblinded signature returned by ODIS
+ */
+export const getIdentifierHash = (
+  sha3: (a: string) => string | null,
+  plaintextIdentifier: string,
+  identifierPrefix: IdentifierPrefix,
+  pepper: string
+): string => {
+  // hashing the identifier before appending the pepper to avoid domain collisions where the
+  // identifier may contain underscores
+  // not doing this for phone numbers to maintain backwards compatibility
+  const value =
+    identifierPrefix === IdentifierPrefix.PHONE_NUMBER
+      ? getPrefixedIdentifier(plaintextIdentifier, identifierPrefix) + PEPPER_SEPARATOR + pepper
+      : (sha3(getPrefixedIdentifier(plaintextIdentifier, identifierPrefix)) as string) +
+        PEPPER_SEPARATOR +
+        pepper
+  return sha3(value) as string
+}

package/src/utils/inputValidation.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Reference file:
+ * https://github.com/celo-org/developer-tooling/blob/f1677581b90675e37a4846ce53b29d8615a056e6/packages/sdk/phone-utils/src/inputValidation.test.ts
+ */
+
+import { validateInput, ValidatorKind, type BaseProps } from 'src/utils/inputValidation'
+
+describe('inputValidation', () => {
+  const validateFunction = (
+    itStr: string,
+    inputs: string[],
+    validator: ValidatorKind,
+    expected: string,
+    props?: BaseProps
+  ) => {
+    // eslint-disable-next-line jest/valid-title
+    it(itStr, () =>
+      inputs.forEach((input) => {
+        const result = validateInput(input, { validator, countryCallingCode: '1', ...props })
+        expect(result).toEqual(expected)
+      })
+    )
+  }
+
+  const numbers = ['bu1.23n', '1.2.3', '1.23', '1.2.-_[`/,zx3.....', '1.b.23']
+
+  validateFunction('validates integers', numbers, ValidatorKind.Integer, '123')
+
+  validateFunction('validates decimals', numbers, ValidatorKind.Decimal, '1.23')
+
+  validateFunction(
+    'allows comma decimals',
+    numbers.map((val) => val.replace('.', ',')),
+    ValidatorKind.Decimal,
+    '1,23',
+    { decimalSeparator: ',' }
+  )
+
+  validateFunction(
+    'validates phone numbers',
+    [
+      '4023939889',
+      '(402)3939889',
+      '(402)393-9889',
+      '402bun393._=988-9',
+      '402 393 9889',
+      '(4023) 9-39-88-9',
+      '4-0-2-3-9-3-9-8-8-9', // phone-kebab
+    ],
+    ValidatorKind.Phone,
+    '(402) 393-9889'
+  )
+})

package/src/utils/inputValidation.ts

@@ -0,0 +1,76 @@
+/**
+ * Reference files (this file is a combination of both):
+ * https://github.com/celo-org/developer-tooling/blob/6148646a29e5e719df9a1b32d1580ea7e6e61be8/packages/sdk/base/src/inputValidation.ts
+ * https://github.com/celo-org/developer-tooling/blob/754b286d43bdc3f5b204897d495b2a9f4a117a8a/packages/sdk/phone-utils/src/inputValidation.ts
+ */
+
+import { getDisplayPhoneNumber } from 'src/utils/phoneNumbers'
+
+export enum ValidatorKind {
+  Custom = 'custom',
+  Decimal = 'decimal',
+  Integer = 'integer',
+  Phone = 'phone',
+}
+
+export interface BaseProps {
+  validator?: ValidatorKind
+  customValidator?: (input: string) => string
+  countryCallingCode?: string
+  decimalSeparator?: string
+}
+
+function validateInteger(input: string): string {
+  return input.replace(/[^0-9]/g, '')
+}
+
+function validateDecimal(input: string, decimalSeparator: string = '.'): string {
+  const regex = decimalSeparator === ',' ? /[^0-9,]/g : /[^0-9.]/g
+
+  const cleanedArray = input.replace(regex, '').split(decimalSeparator)
+
+  if (cleanedArray.length <= 1) {
+    // Empty string or no decimals
+    return cleanedArray.join('')
+  } else {
+    return cleanedArray.shift() + decimalSeparator + cleanedArray.join('')
+  }
+}
+
+function validatePhone(input: string, countryCallingCode?: string): string {
+  input = input.replace(/[^0-9()\- ]/g, '')
+
+  if (!countryCallingCode) {
+    return input
+  }
+
+  const displayNumber = getDisplayPhoneNumber(input, countryCallingCode)
+
+  if (!displayNumber) {
+    return input
+  }
+
+  return displayNumber
+}
+
+export function validateInput(input: string, props: BaseProps): string {
+  if (!props.validator && !props.customValidator) {
+    return input
+  }
+
+  switch (props.validator) {
+    case 'decimal':
+      return validateDecimal(input, props.decimalSeparator)
+    case 'integer':
+      return validateInteger(input)
+    case 'phone':
+      return validatePhone(input, props.countryCallingCode)
+    case 'custom': {
+      if (props.customValidator) {
+        return props.customValidator(input)
+      }
+    }
+  }
+
+  throw new Error('Unhandled input validator')
+}

package/src/utils/io.ts

@@ -0,0 +1,39 @@
+/**
+ * TODO
+ * Refactor to replace `io-ts` usage with `zod`
+ */
+
+import { either } from 'fp-ts/lib/Either'
+import * as t from 'io-ts'
+import { isValidAddress } from 'src/utils/address'
+import { isE164NumberStrict } from 'src/utils/phoneNumbers'
+import { checksumAddress } from 'viem'
+
+// Ref: https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/phone-utils/src/io.ts#L6
+export const E164PhoneNumberType = new t.Type<string, string, unknown>(
+  'E164Number',
+  t.string.is,
+  (input, context) =>
+    either.chain(t.string.validate(input, context), (stringValue) =>
+      isE164NumberStrict(stringValue)
+        ? t.success(stringValue)
+        : t.failure(stringValue, context, 'is not a valid e164 number')
+    ),
+  String
+)
+
+// Ref: https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/phone-utils/src/io.ts#L25
+export type E164Number = t.TypeOf<typeof E164PhoneNumberType>
+
+// Ref: https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/utils/src/io.ts#L38
+export const AddressType = new t.Type<string, string, unknown>(
+  'Address',
+  t.string.is,
+  (input, context) =>
+    either.chain(t.string.validate(input, context), (stringValue) =>
+      isValidAddress(stringValue)
+        ? t.success(checksumAddress(stringValue))
+        : t.failure(stringValue, context, 'is not a valid address')
+    ),
+  String
+)

package/src/utils/linking.ts

@@ -0,0 +1,42 @@
+import { Linking, Platform } from 'react-native'
+import DeviceInfo from 'react-native-device-info'
+import { APP_STORE_ID, DEEP_LINK_URL_SCHEME } from 'src/config'
+import Logger from 'src/utils/Logger'
+
+const TAG = 'utils/linking'
+
+export function navigateToWalletStorePage() {
+  if (Platform.OS === 'android') {
+    navigateToURI(`market://details?id=${DeviceInfo.getBundleId()}`)
+  } else {
+    navigateToURI(`https://apps.apple.com/app/id${APP_STORE_ID}`)
+  }
+}
+
+export function isDeepLink(url: string): boolean {
+  return url.startsWith(`${DEEP_LINK_URL_SCHEME}:`)
+}
+
+export function navigateToURI(uri: string, backupUri?: string) {
+  Logger.debug(TAG, 'Navigating to URI', uri)
+
+  // We're NOT using `Linking.canOpenURL` here because we would need
+  // the scheme to be added to LSApplicationQueriesSchemes on iOS
+  // which is not possible for arbitrary callbacks from other apps (DAppKit used to do this)
+  Linking.openURL(uri).catch((reason) => {
+    Logger.debug(TAG, 'URI not supported', uri)
+    if (backupUri) {
+      Logger.debug(TAG, 'Trying backup URI', backupUri)
+      navigateToURI(backupUri)
+    } else {
+      Logger.error(TAG, `Error navigating to URI`, reason)
+    }
+  })
+}
+
+export function navigateToPhoneSettings() {
+  Logger.debug(TAG, 'Navigating phone settings')
+  Linking.openSettings().catch((reason) =>
+    Logger.error(TAG, `Error navigating to phone settings`, reason)
+  )
+}

package/src/utils/moneyAmount.ts

@@ -0,0 +1,16 @@
+import BigNumber from 'bignumber.js'
+
+export interface LocalMoneyAmount {
+  value: BigNumber.Value
+  currencyCode: string
+  exchangeRate: BigNumber.Value
+}
+
+/**
+ * @deprecated Use TokenAmount instead
+ */
+export interface MoneyAmount {
+  value: BigNumber.Value
+  currencyCode: string
+  localAmount?: LocalMoneyAmount | null
+}