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

package/src/account/ordering.ts

@@ -2,10 +2,7 @@ import { BigNumber } from "bignumber.js";
 import { flattenAccounts, getAccountCurrency } from "./helpers";
 import type { FlattenAccountsOptions } from "./helpers";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
-import type {
-  CryptoCurrency,
-  TokenCurrency,
-} from "@ledgerhq/types-cryptoassets";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 export type AccountComparator = (a: AccountLike, b: AccountLike) => number;
 
@@ -29,8 +26,8 @@ export const sortAccountsComparatorFromOrder = (
   orderAccounts: string,
   calculateCountervalue: (
     currency: TokenCurrency | CryptoCurrency,
-    value: BigNumber
-  ) => BigNumber | null | undefined
+    value: BigNumber,
+  ) => BigNumber | null | undefined,
 ): AccountComparator => {
   const [order, sort] = orderAccounts.split("|");
   const ascValue = sort === "desc" ? -1 : 1;
@@ -47,9 +44,7 @@ export const sortAccountsComparatorFromOrder = (
 
   const lazyCalcCV = (a: AccountLike) => {
     if (a.id in cvCaches) return cvCaches[a.id];
-    const v =
-      calculateCountervalue(getAccountCurrency(a), a.balance) ||
-      new BigNumber(-1);
+    const v = calculateCountervalue(getAccountCurrency(a), a.balance) || new BigNumber(-1);
     cvCaches[a.id] = v;
     return v;
   };
@@ -62,7 +57,7 @@ export const sortAccountsComparatorFromOrder = (
 };
 export const comparatorSortAccounts = <TA extends AccountLike>(
   accounts: TA[],
-  comparator: AccountComparator
+  comparator: AccountComparator,
 ): TA[] => {
   const meta = accounts
     .map((ta, index) => ({
@@ -77,24 +72,24 @@ export const comparatorSortAccounts = <TA extends AccountLike>(
   }
 
   // otherwise, need to reorder
-  return meta.map((m) => accounts[m.index]);
+  return meta.map(m => accounts[m.index]);
 };
 // flatten accounts and sort between them (used for grid mode)
 export const flattenSortAccounts = (
   accounts: Account[],
   comparator: AccountComparator,
-  o?: FlattenAccountsOptions
+  o?: FlattenAccountsOptions,
 ): AccountLike[] => {
   return comparatorSortAccounts(flattenAccounts(accounts, o), comparator);
 };
 // sort top level accounts and the inner sub accounts if necessary (used for lists)
 export const nestedSortAccounts = (
   topAccounts: Account[],
-  comparator: AccountComparator
+  comparator: AccountComparator,
 ): Account[] => {
   let oneAccountHaveChanged = false;
   // first of all we sort the inner token accounts
-  const accounts = topAccounts.map((a) => {
+  const accounts = topAccounts.map(a => {
     if (!a.subAccounts) return a;
     const subAccounts = comparatorSortAccounts(a.subAccounts, comparator);
     if (subAccounts === a.subAccounts) return a;
@@ -102,8 +97,5 @@ export const nestedSortAccounts = (
     return { ...a, subAccounts };
   });
   // then we sort again between them
-  return comparatorSortAccounts(
-    oneAccountHaveChanged ? accounts : topAccounts,
-    comparator
-  );
+  return comparatorSortAccounts(oneAccountHaveChanged ? accounts : topAccounts, comparator);
 };

package/src/account/pending.ts

@@ -1,9 +1,6 @@
 import type { Account, Operation, SubAccount } from "@ledgerhq/types-live";
 import { getEnv } from "@ledgerhq/live-env";
-export function shouldRetainPendingOperation(
-  account: Account,
-  op: Operation
-): boolean {
+export function shouldRetainPendingOperation(account: Account, op: Operation): boolean {
   // FIXME: valueOf to compare dates in typescript
   const delay = new Date().valueOf() - op.date.valueOf();
   const last = account.operations[0];
@@ -22,22 +19,19 @@ export function shouldRetainPendingOperation(
 
 const appendPendingOp = (ops: Operation[], op: Operation) => {
   const filtered: Operation[] = ops.filter(
-    (o) => o.transactionSequenceNumber !== op.transactionSequenceNumber
+    o => o.transactionSequenceNumber !== op.transactionSequenceNumber,
   );
   filtered.unshift(op);
   return filtered;
 };
 
-export const addPendingOperation = (
-  account: Account,
-  operation: Operation
-): Account => {
+export const addPendingOperation = (account: Account, operation: Operation): Account => {
   const accountCopy = { ...account };
   const { subOperations } = operation;
   const { subAccounts } = account;
 
   function addInSubAccount(subaccounts: SubAccount[], op: Operation) {
-    const acc = subaccounts.find((sub) => sub.id === op.accountId);
+    const acc = subaccounts.find(sub => sub.id === op.accountId);
 
     if (acc) {
       const copy: SubAccount = { ...acc };
@@ -48,17 +42,14 @@ export const addPendingOperation = (
 
   if (subOperations && subAccounts) {
     const taCopy: SubAccount[] = subAccounts.slice(0);
-    subOperations.forEach((op) => {
+    subOperations.forEach(op => {
       addInSubAccount(taCopy, op);
     });
     accountCopy.subAccounts = taCopy;
   }
 
   if (accountCopy.id === operation.accountId) {
-    accountCopy.pendingOperations = appendPendingOp(
-      accountCopy.pendingOperations,
-      operation
-    );
+    accountCopy.pendingOperations = appendPendingOp(accountCopy.pendingOperations, operation);
   } else if (subAccounts) {
     const taCopy: SubAccount[] = subAccounts.slice(0);
     addInSubAccount(taCopy, operation);

package/src/account/serialization.ts

@@ -1,9 +1,7 @@
 import { BigNumber } from "bignumber.js";
 import type { Operation, OperationRaw, SubAccount } from "@ledgerhq/types-live";
 
-export type ExtractExtraFn = (
-  extra: Record<string, any>
-) => Record<string, any>;
+export type ExtractExtraFn = (extra: Record<string, any>) => Record<string, any>;
 
 export const toOperationRaw = (
   {
@@ -30,7 +28,7 @@ export const toOperationRaw = (
     tokenId,
     transactionRaw,
   }: Operation,
-  preserveSubOperation?: boolean
+  preserveSubOperation?: boolean,
 ): OperationRaw => {
   const copy: OperationRaw = {
     id,
@@ -64,9 +62,7 @@ export const toOperationRaw = (
   }
 
   if (internalOperations) {
-    copy.internalOperations = internalOperations.map((o: Operation) =>
-      toOperationRaw(o)
-    );
+    copy.internalOperations = internalOperations.map((o: Operation) => toOperationRaw(o));
   }
 
   if (nftOperations) {
@@ -79,10 +75,7 @@ export const toOperationRaw = (
 
   return copy;
 };
-export const inferSubOperations = (
-  txHash: string,
-  subAccounts: SubAccount[]
-): Operation[] => {
+export const inferSubOperations = (txHash: string, subAccounts: SubAccount[]): Operation[] => {
   const all: Operation[] = [];
 
   for (let i = 0; i < subAccounts.length; i++) {
@@ -132,7 +125,7 @@ export const fromOperationRaw = (
     transactionRaw,
   }: OperationRaw,
   accountId: string,
-  subAccounts?: SubAccount[] | null | undefined
+  subAccounts?: SubAccount[] | null | undefined,
 ): Operation => {
   const res: Operation = {
     id,
@@ -164,21 +157,17 @@ export const fromOperationRaw = (
   if (subAccounts) {
     res.subOperations = inferSubOperations(hash, subAccounts);
   } else if (subOperations) {
-    res.subOperations = subOperations.map((o: OperationRaw) =>
-      fromOperationRaw(o, o.accountId)
-    );
+    res.subOperations = subOperations.map((o: OperationRaw) => fromOperationRaw(o, o.accountId));
   }
 
   if (internalOperations) {
     res.internalOperations = internalOperations.map((o: OperationRaw) =>
-      fromOperationRaw(o, o.accountId)
+      fromOperationRaw(o, o.accountId),
     );
   }
 
   if (nftOperations) {
-    res.nftOperations = nftOperations.map((o: OperationRaw) =>
-      fromOperationRaw(o, o.accountId)
-    );
+    res.nftOperations = nftOperations.map((o: OperationRaw) => fromOperationRaw(o, o.accountId));
   }
 
   if (transactionRaw !== undefined) {

package/src/account/support.ts

@@ -4,10 +4,7 @@ import {
   UnavailableTezosOriginatedAccountReceive,
 } from "@ledgerhq/errors";
 import { getEnv } from "@ledgerhq/live-env";
-import {
-  getAllDerivationModes,
-  getDerivationModesForCurrency,
-} from "../derivation";
+import { getAllDerivationModes, getDerivationModesForCurrency } from "../derivation";
 import { isCurrencySupported } from "../currencies";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
@@ -15,7 +12,7 @@ import type { DerivationMode } from "../derivation";
 
 export const shouldShowNewAccount = (
   currency: CryptoCurrency,
-  derivationMode: DerivationMode
+  derivationMode: DerivationMode,
 ): boolean => {
   const modes = getDerivationModesForCurrency(currency);
   // last mode is always creatable by convention
@@ -37,25 +34,18 @@ export const shouldShowNewAccount = (
 };
 export const getReceiveFlowError = (
   account: AccountLike,
-  parentAccount: Account | null | undefined
+  parentAccount: Account | null | undefined,
 ): Error | null | undefined => {
   if (parentAccount && parentAccount.currency.id === "tezos") {
     return new UnavailableTezosOriginatedAccountReceive("");
   }
 };
 
-export function checkAccountSupported(
-  account: Account
-): Error | null | undefined {
-  if (
-    !getAllDerivationModes().includes(account.derivationMode as DerivationMode)
-  ) {
-    return new AccountNotSupported(
-      "derivation not supported " + account.derivationMode,
-      {
-        reason: account.derivationMode,
-      }
-    );
+export function checkAccountSupported(account: Account): Error | null | undefined {
+  if (!getAllDerivationModes().includes(account.derivationMode as DerivationMode)) {
+    return new AccountNotSupported("derivation not supported " + account.derivationMode, {
+      reason: account.derivationMode,
+    });
   }
 
   if (!isCurrencySupported(account.currency)) {

package/src/account.test.ts

@@ -1,11 +1,7 @@
 import "./test-helpers/staticTime";
 import { BigNumber } from "bignumber.js";
 import flatMap from "lodash/flatMap";
-import {
-  getCryptoCurrencyById,
-  getTokenById,
-  setSupportedCurrencies,
-} from "./currencies";
+import { getCryptoCurrencyById, getTokenById, setSupportedCurrencies } from "./currencies";
 import {
   groupAccountOperationsByDay,
   groupAccountsOperationsByDay,
@@ -35,10 +31,10 @@ describe("groupAccountOperationsByDay", () => {
     expect(res2.completed).toBe(true);
     expect(
       // $FlowFixMe
-      flatMap(res2.sections, (s) => s.data).slice(0, 10)
+      flatMap(res2.sections, s => s.data).slice(0, 10),
     ).toMatchObject(
       // $FlowFixMe
-      flatMap(res1.sections, (s) => s.data)
+      flatMap(res1.sections, s => s.data),
     );
   });
   test("basic 2", () => {
@@ -56,10 +52,10 @@ describe("groupAccountOperationsByDay", () => {
     expect(res2.completed).toBe(true);
     expect(
       // $FlowFixMe
-      flatMap(res2.sections, (s) => s.data).slice(0, 100)
+      flatMap(res2.sections, s => s.data).slice(0, 100),
     ).toMatchObject(
       // $FlowFixMe
-      flatMap(res1.sections, (s) => s.data)
+      flatMap(res1.sections, s => s.data),
     );
   });
   test("filterOperation", () => {
@@ -78,7 +74,7 @@ describe("groupAccountOperationsByDay", () => {
     expect(res2).toEqual(
       groupAccountOperationsByDay(account, {
         count: 10,
-      })
+      }),
     );
     const res3 = groupAccountOperationsByDay(account, {
       count: 10,
@@ -91,15 +87,13 @@ describe("groupAccountOperationsByDay", () => {
       groupAccountOperationsByDay(
         {
           ...account,
-          operations: account.operations.filter((op) => op.type === "OUT"),
-          pendingOperations: account.pendingOperations.filter(
-            (op) => op.type === "OUT"
-          ),
+          operations: account.operations.filter(op => op.type === "OUT"),
+          pendingOperations: account.pendingOperations.filter(op => op.type === "OUT"),
         },
         {
           count: 10,
-        }
-      )
+        },
+      ),
     );
   });
   test("provide at least the requested count even if some op yield nothing", () => {
@@ -119,8 +113,7 @@ describe("groupAccountOperationsByDay", () => {
     });
     expect(res1.completed).toBe(false);
     expect(
-      res1.sections.reduce((acc, s) => acc.concat(s.data), <Operation[]>[])
-        .length
+      res1.sections.reduce((acc, s) => acc.concat(s.data), <Operation[]>[]).length,
     ).toBeGreaterThanOrEqual(100);
   });
   test("to dedup", () => {
@@ -137,12 +130,12 @@ describe("groupAccountOperationsByDay", () => {
   });
 });
 test("shortAddressPreview", () => {
-  expect(
-    shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF")
-  ).toBe("0x112233...cCdDeEfF");
-  expect(
-    shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF", 30)
-  ).toBe("0x11223344556...0aAbBcCdDeEfF");
+  expect(shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF")).toBe(
+    "0x112233...cCdDeEfF",
+  );
+  expect(shortAddressPreview("0x112233445566778899001234567890aAbBcCdDeEfF", 30)).toBe(
+    "0x11223344556...0aAbBcCdDeEfF",
+  );
 });
 test("accountWithMandatoryTokens ethereum", () => {
   const currency = getCryptoCurrencyById("ethereum");
@@ -150,9 +143,7 @@ test("accountWithMandatoryTokens ethereum", () => {
     currency,
     subAccountsCount: 5,
   });
-  const enhance = accountWithMandatoryTokens(account, [
-    getTokenById("ethereum/erc20/0x_project"),
-  ]);
+  const enhance = accountWithMandatoryTokens(account, [getTokenById("ethereum/erc20/0x_project")]);
   const doubleEnhance = accountWithMandatoryTokens(enhance, [
     getTokenById("ethereum/erc20/0x_project"),
   ]);
@@ -161,7 +152,7 @@ test("accountWithMandatoryTokens ethereum", () => {
     ...account,
     subAccounts: [],
   });
-  expect((enhance.subAccounts || []).map((a) => a.id)).toMatchSnapshot();
+  expect((enhance.subAccounts || []).map(a => a.id)).toMatchSnapshot();
 });
 test("withoutToken ethereum", () => {
   const isTokenAccount = (account: SubAccount, tokenId: string) =>
@@ -179,10 +170,7 @@ test("withoutToken ethereum", () => {
     subAccountsCount: 0,
   });
   //Enhance the account with some tokens
-  const enhance = accountWithMandatoryTokens(
-    account,
-    tokenIds.map(getTokenById)
-  );
+  const enhance = accountWithMandatoryTokens(account, tokenIds.map(getTokenById));
   //Get a version of that account without all the tokens
   let demote = enhance;
 
@@ -195,8 +183,8 @@ test("withoutToken ethereum", () => {
 
   //See if we have added/removed them correctly
   for (const tokenId of tokenIds) {
-    expect(saTokens.find((a) => isTokenAccount(a, tokenId))).toBeTruthy();
-    expect(saNoTokens.find((a) => isTokenAccount(a, tokenId))).toBeFalsy();
+    expect(saTokens.find(a => isTokenAccount(a, tokenId))).toBeTruthy();
+    expect(saNoTokens.find(a => isTokenAccount(a, tokenId))).toBeFalsy();
   }
 });
 test("withoutToken tron", () => {
@@ -215,10 +203,7 @@ test("withoutToken tron", () => {
     subAccountsCount: 0,
   });
   //Enhance the account with some tokens
-  const enhance = accountWithMandatoryTokens(
-    account,
-    tokenIds.map(getTokenById)
-  );
+  const enhance = accountWithMandatoryTokens(account, tokenIds.map(getTokenById));
   //Get a version of that account without all the tokens
   let demote = enhance;
 
@@ -231,7 +216,7 @@ test("withoutToken tron", () => {
 
   //See if we have added/removed them correctly
   for (const tokenId of tokenIds) {
-    expect(saTokens.find((a) => isTokenAccount(a, tokenId))).toBeTruthy();
-    expect(saNoTokens.find((a) => isTokenAccount(a, tokenId))).toBeFalsy();
+    expect(saTokens.find(a => isTokenAccount(a, tokenId))).toBeTruthy();
+    expect(saNoTokens.find(a => isTokenAccount(a, tokenId))).toBeFalsy();
   }
 });

package/src/bot/specs.ts

@@ -4,11 +4,7 @@ import { log } from "@ledgerhq/logs";
 import expect from "expect";
 import sample from "lodash/sample";
 import { isAccountEmpty } from "../account";
-import type {
-  DeviceAction,
-  DeviceActionArg,
-  TransactionDestinationTestInput,
-} from "./types";
+import type { DeviceAction, DeviceActionArg, TransactionDestinationTestInput } from "./types";
 import { Account, TransactionCommon } from "@ledgerhq/types-live";
 import { botTest } from "./bot-test-context";
 import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
@@ -21,16 +17,13 @@ const stepValueTransformDefault = (s: string) => s.trim();
 
 // TODO should weight the choice to favorize accounts with small amounts
 export function pickSiblings(siblings: Account[], maxAccount = 5): Account {
-  const withoutEmpties = siblings.filter((a) => a.used);
+  const withoutEmpties = siblings.filter(a => a.used);
 
   if (withoutEmpties.length >= maxAccount) {
     // we are no longer creating accounts
     const maybeAccount = sample(withoutEmpties);
     if (!maybeAccount) {
-      throw new Error(
-        "at least one non-empty sibling account exists. maxAccount=" +
-          maxAccount
-      );
+      throw new Error("at least one non-empty sibling account exists. maxAccount=" + maxAccount);
     }
     return maybeAccount;
   }
@@ -40,14 +33,12 @@ export function pickSiblings(siblings: Account[], maxAccount = 5): Account {
   empties.sort((a, b) => a.index - b.index);
 
   if (empties.length > 0) {
-    empties = empties.filter((e) => e.index === empties[0].index);
+    empties = empties.filter(e => e.index === empties[0].index);
   }
 
   const maybeAccount = sample(withoutEmpties.concat(empties));
   if (!maybeAccount) {
-    throw new Error(
-      "at least one sibling account exists. maxAccount=" + maxAccount
-    );
+    throw new Error("at least one sibling account exists. maxAccount=" + maxAccount);
   }
   return maybeAccount;
 }
@@ -77,7 +68,7 @@ type Step<T extends TransactionCommon> = {
     acc: Array<{
       title: string;
       value: string;
-    }>
+    }>,
   ) => string;
   ignoreAssertionFailure?: boolean;
   trimValue?: boolean;
@@ -92,7 +83,7 @@ type FlowDesc<T extends TransactionCommon> = {
 };
 // generalized logic of device actions
 export function deviceActionFlow<T extends TransactionCommon>(
-  description: FlowDesc<T>
+  description: FlowDesc<T>,
 ): DeviceAction<T, State<T>> {
   return (arg: DeviceActionArg<T, State<T>>) => {
     const { transport, event, state, disableStrictStepValueValidation } = arg;
@@ -111,8 +102,7 @@ export function deviceActionFlow<T extends TransactionCommon>(
         // there were accumulated text and we are on new step, we need to release it and compare to expected
         if (currentStep && currentStep.expectedValue) {
           const { expectedValue, ignoreAssertionFailure } = currentStep;
-          const stepValueTransform =
-            currentStep.stepValueTransform || stepValueTransformDefault;
+          const stepValueTransform = currentStep.stepValueTransform || stepValueTransformDefault;
 
           if (!ignoreAssertionFailure && !disableStrictStepValueValidation) {
             botTest("deviceAction confirm step '" + stepTitle + "'", () => {
@@ -122,10 +112,7 @@ export function deviceActionFlow<T extends TransactionCommon>(
                 // FIXME: OCR of speculos couldn't retrieve S properly
                 // Issue on speculos repository : https://github.com/LedgerHQ/speculos/issues/204
                 [stepTitle]: expectedValue(arg, acc)
-                  .replace(
-                    /S/g,
-                    arg.appCandidate.model === DeviceModelId.nanoS ? "S" : ""
-                  )
+                  .replace(/S/g, arg.appCandidate.model === DeviceModelId.nanoS ? "S" : "")
                   .trim(),
               });
             });
@@ -155,13 +142,12 @@ export function deviceActionFlow<T extends TransactionCommon>(
     }
 
     if (!finalState) {
-      let possibleKnownStep: Step<T> | null | undefined =
-        description.steps.find((s) => {
-          if (s.maxY) {
-            return event.text.startsWith(s.title) && event.y < s.maxY;
-          }
-          return event.text.startsWith(s.title);
-        });
+      let possibleKnownStep: Step<T> | null | undefined = description.steps.find(s => {
+        if (s.maxY) {
+          return event.text.startsWith(s.title) && event.y < s.maxY;
+        }
+        return event.text.startsWith(s.title);
+      });
 
       // if there is a fallback provided, we will run it to try to detect another possible known step
       if (!possibleKnownStep && description.fallback) {
@@ -211,7 +197,7 @@ const sep = " ";
 export function formatDeviceAmount(
   currency: CryptoCurrency | TokenCurrency,
   value: BigNumber,
-  options: Partial<DeviceAmountFormatOptions> = defaultFormatOptions
+  options: Partial<DeviceAmountFormatOptions> = defaultFormatOptions,
 ): string {
   const [unit] = currency.units;
   let code = unit.code;
@@ -220,9 +206,7 @@ export function formatDeviceAmount(
     if (deviceTicker) code = deviceTicker;
   }
   const fValue = value.div(new BigNumber(10).pow(unit.magnitude));
-  let v = options.showAllDigits
-    ? fValue.toFixed(unit.magnitude)
-    : fValue.toString(10);
+  let v = options.showAllDigits ? fValue.toFixed(unit.magnitude) : fValue.toString(10);
   if (options.forceFloating) {
     if (!v.includes(".")) {
       // if the value is pure integer, in the app it will automatically add an .0
@@ -238,20 +222,17 @@ export function formatDeviceAmount(
 // Usage: put these in your spec, on the mutation transaction functions that intend to do more "delegations"
 export function expectSiblingsHaveSpendablePartGreaterThan(
   siblings: Account[],
-  threshold: number
+  threshold: number,
 ): void {
   const spendableTotal = siblings.reduce(
     (acc, a) => acc.plus(a.spendableBalance),
-    new BigNumber(0)
-  );
-  const total = siblings.reduce(
-    (acc, a) => acc.plus(a.balance),
-    new BigNumber(0)
+    new BigNumber(0),
   );
+  const total = siblings.reduce((acc, a) => acc.plus(a.balance), new BigNumber(0));
   invariant(
     spendableTotal.div(total).gt(threshold),
     "the spendable part of accounts is sufficient (threshold: %s)",
-    threshold
+    threshold,
   );
 }
 
@@ -264,8 +245,8 @@ export const genericTestDestination = <T>({
   const amount = sendingOperation.value.minus(sendingOperation.fee);
   botTest("account balance increased with transaction amount", () =>
     expect(destination.balance.toString()).toBe(
-      destinationBeforeTransaction.balance.plus(amount).toString()
-    )
+      destinationBeforeTransaction.balance.plus(amount).toString(),
+    ),
   );
   botTest("operation amount is consistent with sendingOperation", () =>
     expect({
@@ -274,6 +255,6 @@ export const genericTestDestination = <T>({
     }).toMatchObject({
       type: "IN",
       amount: amount.toString(),
-    })
+    }),
   );
 };

package/src/bot/types.ts

@@ -56,7 +56,7 @@ export type DeviceActionArg<T extends TransactionCommon, S> = {
   disableStrictStepValueValidation?: boolean;
 };
 export type DeviceAction<T extends TransactionCommon, S> = (
-  arg0: DeviceActionArg<T, S>
+  arg0: DeviceActionArg<T, S>,
 ) => S | null | undefined;
 export type TransactionArg<T extends TransactionCommon> = {
   appCandidate: AppCandidate;

package/src/bridge/getAddressWrapper.ts

@@ -1,27 +1,19 @@
 import Transport from "@ledgerhq/hw-transport";
-import {
-  DeviceAppVerifyNotSupported,
-  StatusCodes,
-  UserRefusedAddress,
-} from "@ledgerhq/errors";
+import { DeviceAppVerifyNotSupported, StatusCodes, UserRefusedAddress } from "@ledgerhq/errors";
 import { log } from "@ledgerhq/logs";
 import type { Result, GetAddressOptions } from "../derivation";
 
-export type Resolver = (
-  transport: Transport,
-  addressOpt: GetAddressOptions
-) => Promise<Result>;
+export type Resolver = (transport: Transport, addressOpt: GetAddressOptions) => Promise<Result>;
 
 const getAddressWrapper =
-  (getAddressFn: Resolver) =>
-  (transport: Transport, opts: GetAddressOptions) => {
+  (getAddressFn: Resolver) => (transport: Transport, opts: GetAddressOptions) => {
     const { currency, path, verify } = opts;
     return getAddressFn(transport, opts)
-      .then((result) => {
+      .then(result => {
         log("hw", `getAddress ${currency.id} on ${path}`, result);
         return result;
       })
-      .catch((e) => {
+      .catch(e => {
         log("hw", `getAddress ${currency.id} on ${path} FAILED ${String(e)}`);
 
         if (e && e.name === "TransportStatusError") {