wallet-stack 1.0.0-alpha.121

package/src/utils/address.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Reference file:
+ * https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/utils/src/address.test.ts
+ */
+import { getAddressChunks, isValidAddress } from 'src/utils/address'
+
+describe(getAddressChunks, () => {
+  test('splits the address into chunks of 4 chars', async () => {
+    expect(getAddressChunks('0xce10ce10ce10ce10ce10ce10ce10ce10ce10ce10')).toEqual([
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+      'ce10',
+    ])
+  })
+
+  describe('isValidAddress', () => {
+    describe('when nothing', () => {
+      it('returns false', () => {
+        expect(isValidAddress(null as any)).toBe(false)
+      })
+    })
+
+    describe('when a random string', () => {
+      it('returns false', () => {
+        expect(isValidAddress('532ttgs7')).toBe(false)
+      })
+    })
+    describe('when an address', () => {
+      it('returns true', () => {
+        expect(isValidAddress('0x52395FA87E9EB5b2FB3ec47a34a196AdA5bcF0D0')).toBe(true)
+      })
+    })
+    describe('when an zero address', () => {
+      it('returns true', () => {
+        expect(isValidAddress('0x0000000000000000000000000000000000000000')).toBe(true)
+      })
+    })
+
+    describe('when UPPERCASE', () => {
+      it('returns true', () => {
+        expect(isValidAddress('0x52395FA87E9EB5b2FB3ec47a34a196AdA5bcF0D0'.toUpperCase())).toBe(
+          true
+        )
+      })
+    })
+
+    describe('when LOWERCASE', () => {
+      it('returns true', () => {
+        expect(isValidAddress('0x52395FA87E9EB5b2FB3ec47a34a196AdA5bcF0D0'.toLowerCase())).toBe(
+          true
+        )
+      })
+    })
+  })
+})

package/src/utils/address.ts

@@ -0,0 +1,34 @@
+/**
+ * Reference files:
+ * https://github.com/celo-org/developer-tooling/blob/6e3372f5ada20bb59d88e275170be4dae1e99f01/packages/sdk/base/src/address.ts
+ * https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/utils/src/address.ts
+ */
+
+import { Address, isAddress } from 'viem'
+import { privateKeyToAddress as privateKeyToAddressViem } from 'viem/accounts'
+
+/**
+ * Turns '0xce10ce10ce10ce10ce10ce10ce10ce10ce10ce10'
+ * into ['ce10','ce10','ce10','ce10','ce10','ce10','ce10','ce10','ce10','ce10']
+ */
+export function getAddressChunks(address: string) {
+  return trimLeading0x(address).match(/.{1,4}/g) || []
+}
+
+export function trimLeading0x(address: string) {
+  return address.startsWith('0x') ? address.slice(2) : address
+}
+
+export const normalizeAddressWith0x = (a: string) => ensureLeading0x(a).toLowerCase() as Address
+
+const ensureLeading0x = (input: string): Address =>
+  input.startsWith('0x') ? (input as Address) : (`0x${input}` as const)
+
+export const privateKeyToAddress = (privateKey: string) =>
+  privateKeyToAddressViem(ensureLeading0x(privateKey))
+
+export const normalizeAddress = (a: string) => trimLeading0x(a).toLowerCase()
+
+export const isValidAddress = (input: string | null | undefined): input is Address => {
+  return input ? isAddress(input.toLowerCase()) : false
+}

package/src/utils/aes.test.ts

@@ -0,0 +1,36 @@
+// This test was initially copied from https://github.com/RaisinTen/aes-crypto-js/blob/2978af8e004d47539d767e751def003fe134b6e2/test.js
+// And adapted for this project
+import { aesDecrypt, aesEncrypt } from './aes'
+
+describe.each([
+  [
+    'normal characters',
+    'Hello, world!',
+    'umm, shhh ...',
+    'U2FsdGVkX1+W9o0WI1QJGehALRoGMaRfoN2YH36BGTk=',
+  ],
+  [
+    'weird characters in secret',
+    'Hello, world!',
+    'umm, šhhh ... 😀D◌̇랆탆𝐿 𑒹◌̴◌𑒺',
+    'U2FsdGVkX1/Eq6lXayqOFwfqTdefS3Zqi7LqOeWKrtA=',
+  ],
+  [
+    'bytes corresponding to a single character that are split between two buffers',
+    '\u{30a8}\u{30b9}\u{30af}\u{30fc}\u{30c8}\u{3099}',
+    'umm, shhh ...',
+    'U2FsdGVkX18JW+58n/s+37y5831hmabBUuwtVf+JkaDZjeVyRNDHc+I/1w8kpAEA',
+  ],
+])('AES encryption and decryption: %s', (scenario, plainText, secret, encryptedByCryptoJS) => {
+  it('decrypts strings encrypted by crypto-js', () => {
+    // Note: encryptedByCryptoJS is the result of CryptoJS.AES.encrypt(plainText, secret).toString()
+    const decrypted = aesDecrypt(encryptedByCryptoJS, secret)
+    expect(decrypted).toBe(plainText)
+  })
+
+  it('decrypts strings encrypted with encryptAES', () => {
+    const encrypted = aesEncrypt(plainText, secret)
+    const decrypted = aesDecrypt(encrypted, secret)
+    expect(decrypted).toBe(plainText)
+  })
+})

package/src/utils/aes.ts

@@ -0,0 +1,46 @@
+// This file was copied from https://github.com/RaisinTen/aes-crypto-js/blob/2978af8e004d47539d767e751def003fe134b6e2/index.js
+// and modified slightly for TS compatibility.
+import crypto from 'crypto'
+
+// Refs: https://github.com/brix/crypto-js/issues/468#issuecomment-2060562277
+export function aesEncrypt(plainText: string, secret: string) {
+  const salt = crypto.randomBytes(8)
+  const password = Buffer.concat([Buffer.from(secret), salt])
+  const hash = []
+  let digest = password
+  for (let i = 0; i < 3; i++) {
+    hash[i] = crypto.createHash('md5').update(digest).digest()
+    digest = Buffer.concat([hash[i], password])
+  }
+  const keyDerivation = Buffer.concat(hash)
+  const key = keyDerivation.subarray(0, 32)
+  const iv = keyDerivation.subarray(32)
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
+  return Buffer.concat([
+    Buffer.from('Salted__', 'utf8'),
+    salt,
+    cipher.update(plainText),
+    cipher.final(),
+  ]).toString('base64')
+}
+
+// Refs: https://github.com/brix/crypto-js/issues/468#issuecomment-1783351942
+export function aesDecrypt(encryptedText: string, secret: string) {
+  // From https://gist.github.com/schakko/2628689?permalink_comment_id=3321113#gistcomment-3321113
+  // From https://gist.github.com/chengen/450129cb95c7159cb05001cc6bdbf6a1
+  const cypher = Buffer.from(encryptedText, 'base64')
+  const salt = cypher.slice(8, 16)
+  const password = Buffer.concat([Buffer.from(secret), salt])
+  const md5Hashes = []
+  let digest = password
+  for (let i = 0; i < 3; i++) {
+    md5Hashes[i] = crypto.createHash('md5').update(digest).digest()
+    digest = Buffer.concat([md5Hashes[i], password])
+  }
+  const key = Buffer.concat([md5Hashes[0], md5Hashes[1]])
+  const iv = md5Hashes[2]
+  const contents = cypher.slice(16)
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv)
+
+  return Buffer.concat([decipher.update(contents), decipher.final()]).toString('utf8')
+}

package/src/utils/contacts.ts

@@ -0,0 +1,78 @@
+import { Platform } from 'react-native'
+import { getAll, getMinimal, MinimalContact } from 'react-native-contacts'
+import {
+  check as checkPermission,
+  RESULTS as PERMISSION_RESULTS,
+  PERMISSIONS,
+} from 'react-native-permissions'
+import Logger from 'src/utils/Logger'
+
+const TAG = 'utils/contacts'
+
+export const CONTACTS_PERMISSION =
+  Platform.OS === 'ios' ? PERMISSIONS.IOS.CONTACTS : PERMISSIONS.ANDROID.READ_CONTACTS
+
+export async function hasGrantedContactsPermission() {
+  const contactPermissionStatus = await checkPermission(CONTACTS_PERMISSION)
+  return contactPermissionStatus === PERMISSION_RESULTS.GRANTED
+}
+
+// Stop gap solution since getMinimal is not yet implement on iOS
+function customGetAll(callback: (error: any, contacts: MinimalContact[]) => void) {
+  getAll((error, fullContacts) => {
+    if (error) {
+      callback(error, [])
+      return
+    }
+
+    const minimalContacts = fullContacts
+      .map(
+        ({
+          recordID,
+          givenName,
+          middleName,
+          familyName,
+          company,
+          phoneNumbers,
+          thumbnailPath,
+        }): MinimalContact => ({
+          recordID,
+          displayName: [givenName, middleName, familyName].filter(Boolean).join(' ') || company,
+          phoneNumbers,
+          thumbnailPath,
+        })
+      )
+      // some contacts are only email and number
+      .filter((minimalContact) => !!minimalContact.displayName)
+
+    callback(null, minimalContacts)
+  })
+}
+
+export async function getAllContacts(): Promise<MinimalContact[] | null> {
+  const contactPermissionStatusGranted = await hasGrantedContactsPermission()
+  if (!contactPermissionStatusGranted) {
+    Logger.warn(TAG, 'Permissions not given for retrieving contacts')
+    return null
+  }
+
+  const getMethod = Platform.OS === 'android' ? getMinimal : customGetAll
+
+  return new Promise((resolve, reject) => {
+    getMethod((error, contacts) => {
+      if (error) {
+        Logger.error(TAG, 'Error getting all contacts', error)
+        reject(error)
+        return
+      }
+
+      if (!contacts) {
+        Logger.error(TAG, 'Contacts is null')
+        reject('Contacts is null')
+        return
+      }
+
+      resolve(contacts)
+    })
+  })
+}

package/src/utils/contentTranslations.ts

@@ -0,0 +1,18 @@
+import i18n from 'src/i18n'
+
+export const getContentForCurrentLang = (content: { [lang: string]: any }) => {
+  const language = i18n.language?.toLowerCase() ?? 'en'
+  const texts = content[language] || content[language.slice(0, 2)] || content.en
+
+  if (typeof texts === 'string') {
+    return texts
+  }
+
+  for (const key of Object.keys(texts)) {
+    if (typeof texts[key] === 'string') {
+      // This is needed for newlines to show properly.
+      texts[key] = texts[key].replace(/\\n/g, '\n')
+    }
+  }
+  return texts
+}

package/src/utils/country.json

@@ -0,0 +1,257 @@
+{
+  "AF": "Afganist\u00e1n",
+  "AL": "Albania",
+  "DE": "Alemania",
+  "AD": "Andorra",
+  "AO": "Angola",
+  "AI": "Anguila",
+  "AQ": "Ant\u00e1rtida",
+  "AG": "Antigua y Barbuda",
+  "SA": "Arabia Saud\u00ed",
+  "DZ": "Argelia",
+  "AR": "Argentina",
+  "AM": "Armenia",
+  "AW": "Aruba",
+  "AU": "Australia",
+  "AT": "Austria",
+  "AZ": "Azerbaiy\u00e1n",
+  "BS": "Bahamas",
+  "BD": "Banglad\u00e9s",
+  "BB": "Barbados",
+  "BH": "Bar\u00e9in",
+  "BE": "B\u00e9lgica",
+  "BZ": "Belice",
+  "BJ": "Ben\u00edn",
+  "BM": "Bermudas",
+  "BY": "Bielorrusia",
+  "BO": "Bolivia",
+  "BA": "Bosnia y Herzegovina",
+  "BW": "Botsuana",
+  "BR": "Brasil",
+  "BN": "Brun\u00e9i",
+  "BG": "Bulgaria",
+  "BF": "Burkina Faso",
+  "BI": "Burundi",
+  "BT": "But\u00e1n",
+  "CV": "Cabo Verde",
+  "KH": "Camboya",
+  "CM": "Camer\u00fan",
+  "CA": "Canad\u00e1",
+  "IC": "Canarias",
+  "BQ": "Caribe neerland\u00e9s",
+  "QA": "Catar",
+  "EA": "Ceuta y Melilla",
+  "TD": "Chad",
+  "CZ": "Chequia",
+  "CL": "Chile",
+  "CN": "China",
+  "CY": "Chipre",
+  "VA": "Ciudad del Vaticano",
+  "CO": "Colombia",
+  "KM": "Comoras",
+  "CG": "Congo",
+  "KP": "Corea del Norte",
+  "KR": "Corea del Sur",
+  "CR": "Costa Rica",
+  "CI": "C\u00f4te d\u2019Ivoire",
+  "HR": "Croacia",
+  "CU": "Cuba",
+  "CW": "Curazao",
+  "DG": "Diego Garc\u00eda",
+  "DK": "Dinamarca",
+  "DM": "Dominica",
+  "EC": "Ecuador",
+  "EG": "Egipto",
+  "SV": "El Salvador",
+  "AE": "Emiratos \u00c1rabes Unidos",
+  "ER": "Eritrea",
+  "SK": "Eslovaquia",
+  "SI": "Eslovenia",
+  "ES": "Espa\u00f1a",
+  "US": "Estados Unidos",
+  "EE": "Estonia",
+  "SZ": "Esuatini",
+  "ET": "Etiop\u00eda",
+  "PH": "Filipinas",
+  "FI": "Finlandia",
+  "FJ": "Fiyi",
+  "FR": "Francia",
+  "GA": "Gab\u00f3n",
+  "GM": "Gambia",
+  "GE": "Georgia",
+  "GH": "Ghana",
+  "GI": "Gibraltar",
+  "GD": "Granada",
+  "GR": "Grecia",
+  "GL": "Groenlandia",
+  "GP": "Guadalupe",
+  "GU": "Guam",
+  "GT": "Guatemala",
+  "GF": "Guayana Francesa",
+  "GG": "Guernsey",
+  "GN": "Guinea",
+  "GQ": "Guinea Ecuatorial",
+  "GW": "Guinea-Bis\u00e1u",
+  "GY": "Guyana",
+  "HT": "Hait\u00ed",
+  "HN": "Honduras",
+  "HU": "Hungr\u00eda",
+  "IN": "India",
+  "ID": "Indonesia",
+  "IQ": "Irak",
+  "IR": "Ir\u00e1n",
+  "IE": "Irlanda",
+  "AC": "Isla de la Ascensi\u00f3n",
+  "IM": "Isla de Man",
+  "CX": "Isla de Navidad",
+  "NF": "Isla Norfolk",
+  "IS": "Islandia",
+  "AX": "Islas \u00c5land",
+  "KY": "Islas Caim\u00e1n",
+  "CC": "Islas Cocos",
+  "CK": "Islas Cook",
+  "FO": "Islas Feroe",
+  "GS": "Islas Georgia del Sur y Sandwich del Sur",
+  "FK": "Islas Malvinas",
+  "MP": "Islas Marianas del Norte",
+  "MH": "Islas Marshall",
+  "UM": "Islas menores alejadas de EE. UU.",
+  "PN": "Islas Pitcairn",
+  "SB": "Islas Salom\u00f3n",
+  "TC": "Islas Turcas y Caicos",
+  "VG": "Islas V\u00edrgenes Brit\u00e1nicas",
+  "VI": "Islas V\u00edrgenes de EE. UU.",
+  "IL": "Israel",
+  "IT": "Italia",
+  "JM": "Jamaica",
+  "JP": "Jap\u00f3n",
+  "JE": "Jersey",
+  "JO": "Jordania",
+  "KZ": "Kazajist\u00e1n",
+  "KE": "Kenia",
+  "KG": "Kirguist\u00e1n",
+  "KI": "Kiribati",
+  "XK": "Kosovo",
+  "KW": "Kuwait",
+  "LA": "Laos",
+  "LS": "Lesoto",
+  "LV": "Letonia",
+  "LB": "L\u00edbano",
+  "LR": "Liberia",
+  "LY": "Libia",
+  "LI": "Liechtenstein",
+  "LT": "Lituania",
+  "LU": "Luxemburgo",
+  "MK": "Macedonia",
+  "MG": "Madagascar",
+  "MY": "Malasia",
+  "MW": "Malaui",
+  "MV": "Maldivas",
+  "ML": "Mali",
+  "MT": "Malta",
+  "MA": "Marruecos",
+  "MQ": "Martinica",
+  "MU": "Mauricio",
+  "MR": "Mauritania",
+  "YT": "Mayotte",
+  "MX": "M\u00e9xico",
+  "FM": "Micronesia",
+  "MD": "Moldavia",
+  "MC": "M\u00f3naco",
+  "MN": "Mongolia",
+  "ME": "Montenegro",
+  "MS": "Montserrat",
+  "MZ": "Mozambique",
+  "MM": "Myanmar (Birmania)",
+  "NA": "Namibia",
+  "NR": "Nauru",
+  "NP": "Nepal",
+  "NI": "Nicaragua",
+  "NE": "N\u00edger",
+  "NG": "Nigeria",
+  "NU": "Niue",
+  "NO": "Noruega",
+  "NC": "Nueva Caledonia",
+  "NZ": "Nueva Zelanda",
+  "OM": "Om\u00e1n",
+  "NL": "Pa\u00edses Bajos",
+  "PK": "Pakist\u00e1n",
+  "PW": "Palaos",
+  "PA": "Panam\u00e1",
+  "PG": "Pap\u00faa Nueva Guinea",
+  "PY": "Paraguay",
+  "PE": "Per\u00fa",
+  "PF": "Polinesia Francesa",
+  "PL": "Polonia",
+  "PT": "Portugal",
+  "XA": "Pseudo-Accents",
+  "XB": "Pseudo-Bidi",
+  "PR": "Puerto Rico",
+  "HK": "RAE de Hong Kong (China)",
+  "MO": "RAE de Macao (China)",
+  "GB": "Reino Unido",
+  "CF": "Rep\u00fablica Centroafricana",
+  "CD": "Rep\u00fablica Democr\u00e1tica del Congo",
+  "DO": "Rep\u00fablica Dominicana",
+  "RE": "Reuni\u00f3n",
+  "RW": "Ruanda",
+  "RO": "Ruman\u00eda",
+  "RU": "Rusia",
+  "EH": "S\u00e1hara Occidental",
+  "WS": "Samoa",
+  "AS": "Samoa Americana",
+  "BL": "San Bartolom\u00e9",
+  "KN": "San Crist\u00f3bal y Nieves",
+  "SM": "San Marino",
+  "MF": "San Mart\u00edn",
+  "PM": "San Pedro y Miquel\u00f3n",
+  "VC": "San Vicente y las Granadinas",
+  "SH": "Santa Elena",
+  "LC": "Santa Luc\u00eda",
+  "ST": "Santo Tom\u00e9 y Pr\u00edncipe",
+  "SN": "Senegal",
+  "RS": "Serbia",
+  "SC": "Seychelles",
+  "SL": "Sierra Leona",
+  "SG": "Singapur",
+  "SX": "Sint Maarten",
+  "SY": "Siria",
+  "SO": "Somalia",
+  "LK": "Sri Lanka",
+  "ZA": "Sud\u00e1frica",
+  "SD": "Sud\u00e1n",
+  "SS": "Sud\u00e1n del Sur",
+  "SE": "Suecia",
+  "CH": "Suiza",
+  "SR": "Surinam",
+  "SJ": "Svalbard y Jan Mayen",
+  "TH": "Tailandia",
+  "TW": "Taiw\u00e1n",
+  "TZ": "Tanzania",
+  "TJ": "Tayikist\u00e1n",
+  "IO": "Territorio Brit\u00e1nico del Oc\u00e9ano \u00cdndico",
+  "TF": "Territorios Australes Franceses",
+  "PS": "Territorios Palestinos",
+  "TL": "Timor-Leste",
+  "TG": "Togo",
+  "TK": "Tokelau",
+  "TO": "Tonga",
+  "TT": "Trinidad y Tobago",
+  "TA": "Trist\u00e1n de Acu\u00f1a",
+  "TN": "T\u00fanez",
+  "TM": "Turkmenist\u00e1n",
+  "TR": "Turqu\u00eda",
+  "TV": "Tuvalu",
+  "UA": "Ucrania",
+  "UG": "Uganda",
+  "UY": "Uruguay",
+  "UZ": "Uzbekist\u00e1n",
+  "VU": "Vanuatu",
+  "VE": "Venezuela",
+  "VN": "Vietnam",
+  "WF": "Wallis y Futuna",
+  "YE": "Yemen",
+  "DJ": "Yibuti",
+  "ZM": "Zambia",
+  "ZW": "Zimbabue"
+}

package/src/utils/countryFeatures.ts

@@ -0,0 +1,21 @@
+import { createSelector } from 'reselect'
+import { countryFeatures } from 'src/flags'
+import { userLocationDataSelector } from 'src/networkInfo/selectors'
+
+type CountryFeatures = typeof countryFeatures
+type SpecificCountryFeatures = { [K in keyof CountryFeatures]: boolean }
+
+type Entries<T> = Array<{ [K in keyof T]: [K, T[K]] }[keyof T]>
+
+export function getCountryFeatures(countryCodeAlpha2: string | null): SpecificCountryFeatures {
+  const features = {} as SpecificCountryFeatures
+  for (const [key, value] of Object.entries(countryFeatures) as Entries<CountryFeatures>) {
+    features[key] = countryCodeAlpha2 ? ((value as any)[countryCodeAlpha2] ?? false) : false
+  }
+  return features
+}
+
+export const userInSanctionedCountrySelector = createSelector(
+  userLocationDataSelector,
+  ({ countryCodeAlpha2 }) => getCountryFeatures(countryCodeAlpha2 ?? '').SANCTIONED_COUNTRY ?? false
+)

package/src/utils/currencies.ts

@@ -0,0 +1,72 @@
+export enum Currency {
+  Celo = 'cGLD',
+  Dollar = 'cUSD',
+  Euro = 'cEUR',
+}
+
+/**
+ * @deprecated Should use tokenIds / symbols from token list instead.
+ */
+export enum CiCoCurrency {
+  CELO = 'CELO',
+  cUSD = 'cUSD',
+  cEUR = 'cEUR',
+  cREAL = 'cREAL',
+}
+
+export const tokenSymbolToAnalyticsCurrency = (symbol: string): string => {
+  switch (symbol) {
+    case 'cREAL':
+      return 'cReal'
+    case 'CELO':
+      return 'cGLD'
+    default:
+      return symbol
+  }
+}
+export interface CurrencyInfo {
+  symbol: string
+  displayDecimals: number
+  cashTag: string
+}
+
+type CurrencyObject = { [key in Currency]: CurrencyInfo }
+
+export const CURRENCIES: CurrencyObject = {
+  [Currency.Celo]: {
+    symbol: '',
+    displayDecimals: 3,
+    cashTag: 'CELO',
+  },
+  [Currency.Dollar]: {
+    symbol: '$',
+    displayDecimals: 2,
+    cashTag: 'cUSD',
+  },
+  [Currency.Euro]: {
+    symbol: '€',
+    displayDecimals: 2,
+    cashTag: 'cEUR',
+  },
+}
+
+export function resolveCurrency(currencyCode: string): Currency | undefined {
+  const mapping: Record<string, Currency | undefined> = {
+    CELO: Currency.Celo,
+    CGLD: Currency.Celo,
+    CUSD: Currency.Dollar,
+    CEUR: Currency.Euro,
+  }
+  return mapping[currencyCode.toUpperCase()]
+}
+
+export function resolveCICOCurrency(currencyCode: string): CiCoCurrency {
+  const mapping: Record<string, CiCoCurrency | undefined> = {
+    CELO: CiCoCurrency.CELO,
+    CGLD: CiCoCurrency.CELO,
+    CUSD: CiCoCurrency.cUSD,
+    CEUR: CiCoCurrency.cEUR,
+    CREAL: CiCoCurrency.cREAL,
+  }
+  return mapping[currencyCode.toUpperCase()] || CiCoCurrency.CELO
+}

package/src/utils/displayFormatting.ts

@@ -0,0 +1,11 @@
+// Ref: https://github.com/celo-org/developer-tooling/blob/5cfd16214ca7ef7a7ff428c7d397933b3e1eeb51/packages/sdk/base/src/displayFormatting.ts#L2
+export function getErrorMessage(error: Error) {
+  // This replacement is because when the error reaches here, it's been wrapped
+  // by Error: multiple times
+  let errorMsg = error.message || error.name || 'unknown'
+  errorMsg = errorMsg.replace(/Error:/g, '')
+  if (error.stack) {
+    errorMsg += ' in ' + error.stack.substring(0, 100)
+  }
+  return errorMsg
+}

package/src/utils/ensureError.test.ts

@@ -0,0 +1,32 @@
+import { ensureError } from 'src/utils/ensureError'
+
+describe('ensureError', () => {
+  it('returns the same error', () => {
+    const error = new Error('test')
+    expect(ensureError(error)).toBe(error)
+  })
+  it('returns a new error with the stringified value for strings', () => {
+    const error = ensureError('test')
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe('Non \'Error\' value thrown. Stringified value: "test"')
+  })
+  it('returns a new error with the stringified value for numbers', () => {
+    const error = ensureError(1)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe("Non 'Error' value thrown. Stringified value: 1")
+  })
+  it('returns a new error with the stringified value for objects', () => {
+    const error = ensureError({ test: 1 })
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe('Non \'Error\' value thrown. Stringified value: {"test":1}')
+  })
+  it('returns a new error for a value that cannot be stringified', () => {
+    const circularObject = { a: {}, b: {} }
+    circularObject.a = { b: circularObject }
+    const error = ensureError(circularObject)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe(
+      `Non 'Error' value thrown. Stringified value: [Unable to stringify the thrown value]`
+    )
+  })
+})