@ledgerhq/coin-framework 0.3.5 → 0.3.6-next.0

package/src/currencies/BigNumberToLocaleString.test.ts

@@ -9,12 +9,8 @@ test("basic toLocaleString usage", () => {
   expect(toLocaleString(new BigNumber(123.01))).toBe("123.01");
   expect(toLocaleString(new BigNumber(123.012))).toBe("123.012");
   expect(toLocaleString(new BigNumber(1123))).toBe("1,123");
-  expect(toLocaleString(new BigNumber("9999999999999999"))).toBe(
-    "9,999,999,999,999,999"
-  );
-  expect(toLocaleString(new BigNumber("9999999999999.99"))).toBe(
-    "9,999,999,999,999.99"
-  );
+  expect(toLocaleString(new BigNumber("9999999999999999"))).toBe("9,999,999,999,999,999");
+  expect(toLocaleString(new BigNumber("9999999999999.99"))).toBe("9,999,999,999,999.99");
 });
 test("toLocaleString to default maximumFractionDigits to 3", () => {
   expect(toLocaleString(new BigNumber(4.44444))).toBe("4.444");
@@ -36,62 +32,62 @@ test("toLocaleString minimumFractionDigits", () => {
   expect(
     toLocaleString(new BigNumber(0), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("0.0");
   expect(
     toLocaleString(new BigNumber(8), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("8.0");
   expect(
     toLocaleString(new BigNumber(123), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("123.0");
   expect(
     toLocaleString(new BigNumber(0.001), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("0.001");
   expect(
     toLocaleString(new BigNumber(9.5), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("9.5");
   expect(
     toLocaleString(new BigNumber(9.6), "en", {
       minimumFractionDigits: 2,
-    })
+    }),
   ).toBe("9.60");
   expect(
     toLocaleString(new BigNumber(13.1), "en", {
       minimumFractionDigits: 3,
-    })
+    }),
   ).toBe("13.100");
   expect(
     toLocaleString(new BigNumber(123.01), "en", {
       minimumFractionDigits: 5,
-    })
+    }),
   ).toBe("123.01000");
   expect(
     toLocaleString(new BigNumber(123.012), "en", {
       minimumFractionDigits: 10,
-    })
+    }),
   ).toBe("123.0120000000");
   expect(
     toLocaleString(new BigNumber(1123), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("1,123.0");
   expect(
     toLocaleString(new BigNumber("9999999999999999"), "en", {
       minimumFractionDigits: 1,
-    })
+    }),
   ).toBe("9,999,999,999,999,999.0");
   expect(
     toLocaleString(new BigNumber("9999999999999.999"), "en", {
       minimumFractionDigits: 5,
-    })
+    }),
   ).toBe("9,999,999,999,999.99900");
 });
 test("toLocaleString minimumFractionDigits and maximumFractionDigits", () => {
@@ -99,57 +95,53 @@ test("toLocaleString minimumFractionDigits and maximumFractionDigits", () => {
     toLocaleString(new BigNumber(1), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("1.0");
   expect(
     toLocaleString(new BigNumber(1.003), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("1.003");
   expect(
     toLocaleString(new BigNumber(1.000003), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("1.0");
   expect(
     toLocaleString(new BigNumber(1.333333333333), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("1.33333");
   expect(
     toLocaleString(new BigNumber(0), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("0.0");
   expect(
     toLocaleString(new BigNumber(0.003), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("0.003");
   expect(
     toLocaleString(new BigNumber(0.000003), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 5,
-    })
+    }),
   ).toBe("0.0");
   expect(
     toLocaleString(new BigNumber(9.7), "en", {
       minimumFractionDigits: 1,
       maximumFractionDigits: 1,
-    })
+    }),
   ).toBe("9.7");
   expect(
-    toLocaleString(
-      new BigNumber("4.4444444444444444444411111111111111"),
-      "en",
-      {
-        maximumFractionDigits: 20,
-      }
-    )
+    toLocaleString(new BigNumber("4.4444444444444444444411111111111111"), "en", {
+      maximumFractionDigits: 20,
+    }),
   ).toBe("4.44444444444444444444");
 });

package/src/currencies/BigNumberToLocaleString.ts

@@ -28,14 +28,12 @@ const getFormatForLocale = (locale: string) => {
 export const toLocaleString = (
   n: BigNumber,
   localeInput?: string,
-  options: Partial<SupportedOptions> = {}
+  options: Partial<SupportedOptions> = {},
 ): string => {
   let locale = localeInput;
   if (!locale) locale = "en";
   const minimumFractionDigits: number =
-    "minimumFractionDigits" in options
-      ? (options.minimumFractionDigits as number)
-      : 0;
+    "minimumFractionDigits" in options ? (options.minimumFractionDigits as number) : 0;
   const maximumFractionDigits: number =
     "maximumFractionDigits" in options
       ? (options.maximumFractionDigits as number)
@@ -54,10 +52,7 @@ export const toLocaleString = (
   const maxDecimals = bn.toFormat(maximumFractionDigits, BigNumber.ROUND_FLOOR);
 
   if (maximumFractionDigits !== minimumFractionDigits) {
-    const minDecimals = bn.toFormat(
-      minimumFractionDigits,
-      BigNumber.ROUND_FLOOR
-    );
+    const minDecimals = bn.toFormat(minimumFractionDigits, BigNumber.ROUND_FLOOR);
     let i = maxDecimals.length;
 
     // cleanup useless '0's from the right until the minimumFractionDigits

package/src/currencies/CurrencyURIScheme.ts

@@ -46,9 +46,7 @@ export function decodeURIScheme(str: string): Data {
   }
 
   const [, , scheme, address, , queryStr] = m;
-  const query: Record<string, any> = queryStr
-    ? querystring.parse(queryStr)
-    : {};
+  const query: Record<string, any> = queryStr ? querystring.parse(queryStr) : {};
   const currency = findCryptoCurrencyByScheme(scheme);
 
   if (!currency) {

package/src/currencies/chopCurrencyUnitDecimals.ts

@@ -7,10 +7,7 @@
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 
 // - useGrouping: true
-export const chopCurrencyUnitDecimals = (
-  unit: Unit,
-  valueString: string
-): string => {
+export const chopCurrencyUnitDecimals = (unit: Unit, valueString: string): string => {
   let str = "";
   let decimals = -1;
 

package/src/currencies/formatCurrencyUnit.ts

@@ -53,7 +53,7 @@ type FormatFragmentTypes = "value" | "sign" | "code" | "separator";
 export function formatCurrencyUnitFragment(
   unit: Unit,
   value: BigNumber,
-  _options?: formatCurrencyUnitOptions
+  _options?: formatCurrencyUnitOptions,
 ): FormatFragment[] {
   if (!BigNumber.isBigNumber(value)) {
     console.warn("formatCurrencyUnit called with value=", value);
@@ -70,10 +70,7 @@ export function formatCurrencyUnitFragment(
     return [];
   }
 
-  const options: Record<
-    string,
-    formatCurrencyUnitOptions[keyof formatCurrencyUnitOptions]
-  > = {};
+  const options: Record<string, formatCurrencyUnitOptions[keyof formatCurrencyUnitOptions]> = {};
 
   if (_options) {
     let k: keyof formatCurrencyUnitOptions;
@@ -109,20 +106,14 @@ export function formatCurrencyUnitFragment(
         Math.max(
           0, // dynamic max number of digits based on the value itself. to only show significant part
           Math.min(
-            dynamicSignificantDigits -
-              Math.ceil(Math.log10(floatValueAbs.toNumber())),
+            dynamicSignificantDigits - Math.ceil(Math.log10(floatValueAbs.toNumber())),
             magnitude + subMagnitude,
-            staticSignificantDigits
-          )
-        )
+            staticSignificantDigits,
+          ),
+        ),
       );
   const fragValueByKind = {
-    sign:
-      alwaysShowSign || floatValue.isNegative()
-        ? floatValue.isNegative()
-          ? "-"
-          : "+"
-        : null,
+    sign: alwaysShowSign || floatValue.isNegative() ? (floatValue.isNegative() ? "-" : "+") : null,
     code: showCode ? code : null,
     value: discreet
       ? "***"
@@ -136,7 +127,7 @@ export function formatCurrencyUnitFragment(
   const frags: FormatFragment[] = [];
   let nonSepIndex = -1;
   let sepConsumed = true;
-  (unit.prefixCode ? prefixFormat : suffixFormat).forEach((kind) => {
+  (unit.prefixCode ? prefixFormat : suffixFormat).forEach(kind => {
     const v = fragValueByKind[kind];
     if (!v) return;
     const isSep = kind === "separator";
@@ -156,12 +147,11 @@ export function formatCurrencyUnitFragment(
 export function formatCurrencyUnit(
   unit: Unit,
   value: BigNumber,
-  options?: formatCurrencyUnitOptions
+  options?: formatCurrencyUnitOptions,
 ): string {
   const joinFragmentsSeparator =
-    (options && options.joinFragmentsSeparator) ||
-    defaultFormatOptions.joinFragmentsSeparator;
+    (options && options.joinFragmentsSeparator) || defaultFormatOptions.joinFragmentsSeparator;
   return formatCurrencyUnitFragment(unit, value, options)
-    .map((f) => f.value)
+    .map(f => f.value)
     .join(joinFragmentsSeparator);
 }

package/src/currencies/index.ts

@@ -27,10 +27,7 @@ import {
 export * from "./support";
 import { parseCurrencyUnit } from "./parseCurrencyUnit";
 import { chopCurrencyUnitDecimals } from "./chopCurrencyUnitDecimals";
-import {
-  formatCurrencyUnit,
-  formatCurrencyUnitFragment,
-} from "./formatCurrencyUnit";
+import { formatCurrencyUnit, formatCurrencyUnitFragment } from "./formatCurrencyUnit";
 import { formatShort } from "./formatShort";
 import { valueFromUnit } from "./valueFromUnit";
 import type { Currency } from "@ledgerhq/types-cryptoassets";

package/src/currencies/localeUtility.ts

@@ -25,10 +25,8 @@ export type GetSeparators = (locale: string) => {
   decimal: string | null | undefined;
   thousands: string | null | undefined;
 };
-export const getSeparators: GetSeparators = memoize((locale) => {
-  const res = localeNotAvailable
-    ? getFallback(locale)[1]
-    : (10000.2).toLocaleString(locale);
+export const getSeparators: GetSeparators = memoize(locale => {
+  const res = localeNotAvailable ? getFallback(locale)[1] : (10000.2).toLocaleString(locale);
   let decimal;
   let thousands;
 

package/src/currencies/parseCurrencyUnit.ts

@@ -5,10 +5,7 @@ import { BigNumber } from "bignumber.js";
 // make sure you have at least following options set on the formatter:
 // - useGrouping: true
 // - showCode: false
-export const parseCurrencyUnit = (
-  unit: Unit,
-  valueString: string
-): BigNumber => {
+export const parseCurrencyUnit = (unit: Unit, valueString: string): BigNumber => {
   const str = valueString.replace(/,/g, ".");
   const value = new BigNumber(str);
   if (value.isNaN()) return new BigNumber(0);

package/src/currencies/sanitizeValueString.ts

@@ -4,7 +4,7 @@ const numbers = "0123456789";
 export const sanitizeValueString = (
   unit: Unit,
   valueString: string,
-  locale?: string
+  locale?: string,
 ): {
   display: string;
   value: string;

package/src/currencies/support.ts

@@ -3,11 +3,7 @@ import {
   getCryptoCurrencyById,
   hasCryptoCurrencyId,
 } from "@ledgerhq/cryptoassets";
-import {
-  CryptoCurrency,
-  CryptoCurrencyId,
-  FiatCurrency,
-} from "@ledgerhq/types-cryptoassets";
+import { CryptoCurrency, CryptoCurrencyId, FiatCurrency } from "@ledgerhq/types-cryptoassets";
 import { getEnv } from "@ledgerhq/live-env";
 
 // set by user side effect to precise which currencies are considered supported (typically by live)
@@ -81,16 +77,14 @@ export function listSupportedFiats(): FiatCurrency[] {
 
 export function setSupportedCurrencies(ids: CryptoCurrencyId[]) {
   userSupportedCurrencies = Array.from(new Set(ids)) // Make sure to remove duplicates
-    .map((id) => getCryptoCurrencyById(id));
+    .map(id => getCryptoCurrencyById(id));
 }
 
 function getExperimentalSupports() {
   return getEnv("EXPERIMENTAL_CURRENCIES")
     .split(",")
     .filter(
-      (id: string) =>
-        hasCryptoCurrencyId(id) &&
-        !userSupportedCurrencies.find((c) => c.id === id)
+      (id: string) => hasCryptoCurrencyId(id) && !userSupportedCurrencies.find(c => c.id === id),
     )
     .map(getCryptoCurrencyById);
 }

package/src/derivation.test.ts

@@ -1,8 +1,5 @@
 import { getCryptoCurrencyById } from "./currencies";
-import {
-  getPreferredNewAccountScheme,
-  getDefaultPreferredNewAccountScheme,
-} from "./derivation";
+import { getPreferredNewAccountScheme, getDefaultPreferredNewAccountScheme } from "./derivation";
 describe("derivation", () => {
   test("getPreferredNewAccountScheme should return a list of schemes for a given currency", () => {
     const testData = [

package/src/derivation.ts

@@ -1,12 +1,6 @@
 import invariant from "invariant";
 import { Observable, defer, of, range, empty } from "rxjs";
-import {
-  catchError,
-  switchMap,
-  concatMap,
-  takeWhile,
-  map,
-} from "rxjs/operators";
+import { catchError, switchMap, concatMap, takeWhile, map } from "rxjs/operators";
 import { log } from "@ledgerhq/logs";
 import { TransportStatusError, UserRefusedAddress } from "@ledgerhq/errors";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
@@ -227,55 +221,32 @@ const legacyDerivationsPerFamily: Record<string, DerivationMode[]> = {
 };
 
 export const asDerivationMode = (derivationMode: string): DerivationMode => {
-  invariant(
-    derivationMode in modes,
-    "not a derivationMode. Got: '%s'",
-    derivationMode
-  );
+  invariant(derivationMode in modes, "not a derivationMode. Got: '%s'", derivationMode);
   return derivationMode as DerivationMode;
 };
-export const getAllDerivationModes = (): DerivationMode[] =>
-  Object.keys(modes) as DerivationMode[];
-export const getMandatoryEmptyAccountSkip = (
-  derivationMode: DerivationMode
-): number =>
-  (modes[derivationMode] as { mandatoryEmptyAccountSkip: number })
-    .mandatoryEmptyAccountSkip || 0;
-export const isInvalidDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
+export const getAllDerivationModes = (): DerivationMode[] => Object.keys(modes) as DerivationMode[];
+export const getMandatoryEmptyAccountSkip = (derivationMode: DerivationMode): number =>
+  (modes[derivationMode] as { mandatoryEmptyAccountSkip: number }).mandatoryEmptyAccountSkip || 0;
+export const isInvalidDerivationMode = (derivationMode: DerivationMode): boolean =>
   (modes[derivationMode] as { isInvalid: boolean }).isInvalid || false;
-export const isSegwitDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
+export const isSegwitDerivationMode = (derivationMode: DerivationMode): boolean =>
   (modes[derivationMode] as { isSegwit: boolean }).isSegwit || false;
-export const isNativeSegwitDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
-  (modes[derivationMode] as { isNativeSegwit: boolean }).isNativeSegwit ||
-  false;
-export const isTaprootDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
+export const isNativeSegwitDerivationMode = (derivationMode: DerivationMode): boolean =>
+  (modes[derivationMode] as { isNativeSegwit: boolean }).isNativeSegwit || false;
+export const isTaprootDerivationMode = (derivationMode: DerivationMode): boolean =>
   (modes[derivationMode] as { isTaproot: boolean }).isTaproot || false;
 
-export const isUnsplitDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
+export const isUnsplitDerivationMode = (derivationMode: DerivationMode): boolean =>
   (modes[derivationMode] as { isUnsplit: boolean }).isUnsplit || false;
-export const isIterableDerivationMode = (
-  derivationMode: DerivationMode
-): boolean =>
+export const isIterableDerivationMode = (derivationMode: DerivationMode): boolean =>
   !(modes[derivationMode] as { isNonIterable: boolean }).isNonIterable;
-export const getDerivationModeStartsAt = (
-  derivationMode: DerivationMode
-): number => (modes[derivationMode] as { startsAt: number }).startsAt || 0;
-export const getPurposeDerivationMode = (
-  derivationMode: DerivationMode
-): number => (modes[derivationMode] as { purpose: number }).purpose || 44;
+export const getDerivationModeStartsAt = (derivationMode: DerivationMode): number =>
+  (modes[derivationMode] as { startsAt: number }).startsAt || 0;
+export const getPurposeDerivationMode = (derivationMode: DerivationMode): number =>
+  (modes[derivationMode] as { purpose: number }).purpose || 44;
 export const getTagDerivationMode = (
   currency: CryptoCurrency,
-  derivationMode: DerivationMode
+  derivationMode: DerivationMode,
 ): string | null | undefined => {
   const mode = modes[derivationMode] as { tag: any; isInvalid: any };
 
@@ -293,14 +264,11 @@ export const getTagDerivationMode = (
 
   return null;
 };
-export const getAddressFormatDerivationMode = (
-  derivationMode: DerivationMode
-): string =>
-  (modes[derivationMode] as { addressFormat: string }).addressFormat ||
-  "legacy";
+export const getAddressFormatDerivationMode = (derivationMode: DerivationMode): string =>
+  (modes[derivationMode] as { addressFormat: string }).addressFormat || "legacy";
 export const derivationModeSupportsIndex = (
   derivationMode: DerivationMode,
-  index: number
+  index: number,
 ): boolean => {
   const mode = modes[derivationMode];
   if ((mode as { skipFirst: boolean }).skipFirst && index === 0) return false;
@@ -326,8 +294,7 @@ export const getDerivationScheme = ({
     overridesCoinType: string;
   };
   if (overridesDerivation) return overridesDerivation;
-  const splitFrom =
-    isUnsplitDerivationMode(derivationMode) && currency.forkedFrom;
+  const splitFrom = isUnsplitDerivationMode(derivationMode) && currency.forkedFrom;
   const coinType = splitFrom
     ? getCryptoCurrencyById(splitFrom).coinType
     : typeof overridesCoinType === "number"
@@ -350,7 +317,7 @@ export const runDerivationScheme = (
     account?: number | string;
     node?: number | string;
     address?: number | string;
-  } = {}
+  } = {},
 ) =>
   derivationScheme
     .replace("<coin_type>", String(coinType))
@@ -365,7 +332,7 @@ export const runAccountDerivationScheme = (
   },
   opts: {
     account?: number | string;
-  } = {}
+  } = {},
 ) =>
   runDerivationScheme(scheme, currency, {
     ...opts,
@@ -401,15 +368,11 @@ const seedIdentifierPath: Record<string, SeedPathFn> = {
 };
 export const getSeedIdentifierDerivation = (
   currency: CryptoCurrency,
-  derivationMode: DerivationMode
+  derivationMode: DerivationMode,
 ): string => {
-  const unsplitFork = isUnsplitDerivationMode(derivationMode)
-    ? currency.forkedFrom
-    : null;
+  const unsplitFork = isUnsplitDerivationMode(derivationMode) ? currency.forkedFrom : null;
   const purpose = getPurposeDerivationMode(derivationMode);
-  const { coinType } = unsplitFork
-    ? getCryptoCurrencyById(unsplitFork)
-    : currency;
+  const { coinType } = unsplitFork ? getCryptoCurrencyById(unsplitFork) : currency;
   const f = seedIdentifierPath[currency.id] || seedIdentifierPath._;
   return f({
     purpose,
@@ -417,9 +380,7 @@ export const getSeedIdentifierDerivation = (
   });
 };
 // return an array of ways to derivate, by convention the latest is the standard one.
-export const getDerivationModesForCurrency = (
-  currency: CryptoCurrency
-): DerivationMode[] => {
+export const getDerivationModesForCurrency = (currency: CryptoCurrency): DerivationMode[] => {
   let all: DerivationMode[] = [];
   if (currency.family in legacyDerivationsPerFamily) {
     all = all.concat(legacyDerivationsPerFamily[currency.family]);
@@ -465,32 +426,25 @@ export const getDerivationModesForCurrency = (
   }
 
   if (!getEnv("SCAN_FOR_INVALID_PATHS")) {
-    return all.filter((a) => !isInvalidDerivationMode(a));
+    return all.filter(a => !isInvalidDerivationMode(a));
   }
 
   return all;
 };
-const preferredList: DerivationMode[] = [
-  "native_segwit",
-  "taproot",
-  "segwit",
-  "",
-];
+const preferredList: DerivationMode[] = ["native_segwit", "taproot", "segwit", ""];
 // null => no settings
 // [ .. ]
 export const getPreferredNewAccountScheme = (
-  currency: CryptoCurrency
+  currency: CryptoCurrency,
 ): DerivationMode[] | null | undefined => {
   if (currency.family !== "bitcoin") return null;
   const derivationsModes = getDerivationModesForCurrency(currency);
-  const list = preferredList.filter((p) =>
-    derivationsModes.includes(p as DerivationMode)
-  );
+  const list = preferredList.filter(p => derivationsModes.includes(p as DerivationMode));
   if (list.length === 1) return null;
   return list as DerivationMode[];
 };
 export const getDefaultPreferredNewAccountScheme = (
-  currency: CryptoCurrency
+  currency: CryptoCurrency,
 ): DerivationMode | null | undefined => {
   const list = getPreferredNewAccountScheme(currency);
   return list && list[0];
@@ -527,23 +481,19 @@ export function walletDerivation<R>({
       path,
       derivationMode,
     }).pipe(
-      catchError((e) => {
-        if (
-          e instanceof TransportStatusError ||
-          e instanceof UserRefusedAddress
-        ) {
+      catchError(e => {
+        if (e instanceof TransportStatusError || e instanceof UserRefusedAddress) {
           log("scanAccounts", "ignore derivationMode=" + derivationMode);
         }
 
         return empty();
-      })
-    )
+      }),
+    ),
   ).pipe(
-    switchMap((parentDerivation) => {
+    switchMap(parentDerivation => {
       const seedIdentifier = parentDerivation.publicKey;
       const emptyCount = 0;
-      const mandatoryEmptyAccountSkip =
-        getMandatoryEmptyAccountSkip(derivationMode);
+      const mandatoryEmptyAccountSkip = getMandatoryEmptyAccountSkip(derivationMode);
       const derivationScheme = getDerivationScheme({
         derivationMode,
         currency,
@@ -552,7 +502,7 @@ export function walletDerivation<R>({
       const startsAt = getDerivationModeStartsAt(derivationMode);
       return range(startsAt, stopAt - startsAt).pipe(
         // derivate addresses/xpubs
-        concatMap((index) => {
+        concatMap(index => {
           if (!derivationModeSupportsIndex(derivationMode, index)) {
             return empty();
           }
@@ -569,11 +519,11 @@ export function walletDerivation<R>({
             path,
             derivationMode,
           }).pipe(
-            map((accountDerivation) => ({
+            map(accountDerivation => ({
               parentDerivation,
               accountDerivation,
               index,
-            }))
+            })),
           );
         }), // do action with these derivations (e.g. synchronize)
         concatMap(({ parentDerivation, accountDerivation, index }) =>
@@ -584,12 +534,12 @@ export function walletDerivation<R>({
             derivationMode,
             shouldSkipEmpty: emptyCount < mandatoryEmptyAccountSkip,
             seedIdentifier,
-          })
+          }),
         ), // take until the list is complete (based on criteria defined by stepAddress)
         // $FlowFixMe
-        takeWhile((r) => !r.complete, true), // emit just the results
-        concatMap(({ result }) => (result ? of(result) : empty()))
+        takeWhile(r => !r.complete, true), // emit just the results
+        concatMap(({ result }) => (result ? of(result) : empty())),
       );
-    })
+    }),
   );
 }

package/src/errors.test.ts

@@ -15,7 +15,7 @@ describe("custom errors", () => {
 
   test("promise error instanceof", () => {
     expect(Promise.reject(new UnsupportedDerivation())).rejects.toBeInstanceOf(
-      UnsupportedDerivation
+      UnsupportedDerivation,
     );
   });
 });

package/src/errors.ts

@@ -1,9 +1,5 @@
 import { createCustomErrorClass } from "@ledgerhq/errors";
 
-export const FreshAddressIndexInvalid = createCustomErrorClass(
-  "FreshAddressIndexInvalid"
-);
+export const FreshAddressIndexInvalid = createCustomErrorClass("FreshAddressIndexInvalid");
 
-export const UnsupportedDerivation = createCustomErrorClass(
-  "UnsupportedDerivation"
-);
+export const UnsupportedDerivation = createCustomErrorClass("UnsupportedDerivation");