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

package/src/bridge/jsHelpers.ts

@@ -82,13 +82,12 @@ export type AccountShapeInfo = {
 
 export type GetAccountShape = (
   arg0: AccountShapeInfo,
-  arg1: SyncConfig
+  arg1: SyncConfig,
 ) => Promise<Partial<Account>>;
 type AccountUpdater = (arg0: Account) => Account;
 
 // compare that two dates are roughly the same date in order to update the case it would have drastically changed
-const sameDate = (a: Date, b: Date) =>
-  Math.abs(a.getTime() - b.getTime()) < 1000 * 60 * 30;
+const sameDate = (a: Date, b: Date) => Math.abs(a.getTime() - b.getTime()) < 1000 * 60 * 30;
 
 // an operation is relatively immutable, however we saw that sometimes it can temporarily change due to reorg,..
 export const sameOp = (a: Operation, b: Operation): boolean =>
@@ -104,7 +103,7 @@ export const sameOp = (a: Operation, b: Operation): boolean =>
 // efficiently prepend newFetched operations to existing operations
 export function mergeOps( // existing operations. sorted (newer to older). deduped.
   existing: Operation[], // new fetched operations. not sorted. not deduped. time is allowed to overlap inside existing.
-  newFetched: Operation[]
+  newFetched: Operation[],
 ): // return a list of operations, deduped and sorted from newer to older
 Operation[] {
   // there is new fetched
@@ -118,12 +117,12 @@ Operation[] {
 
   // only keep the newFetched that are not in existing. this array will be mutated
   let newOps = newFetched
-    .filter((o) => !existingIds[o.id] || !sameOp(existingIds[o.id], o))
+    .filter(o => !existingIds[o.id] || !sameOp(existingIds[o.id], o))
     .sort((a, b) => b.date.valueOf() - a.date.valueOf());
 
   // Deduplicate new ops to guarantee operations don't have dups
   const newOpsIds: Record<string, Operation> = {};
-  newOps.forEach((op) => {
+  newOps.forEach(op => {
     newOpsIds[op.id] = op;
   });
   newOps = Object.values(newOpsIds);
@@ -149,13 +148,10 @@ Operation[] {
   return all;
 }
 
-export const mergeNfts = (
-  oldNfts: ProtoNFT[],
-  newNfts: ProtoNFT[]
-): ProtoNFT[] => {
+export const mergeNfts = (oldNfts: ProtoNFT[], newNfts: ProtoNFT[]): ProtoNFT[] => {
   // Getting a map of id => NFT
   const newNftsPerId: Record<string, ProtoNFT> = {};
-  newNfts.forEach((n) => {
+  newNfts.forEach(n => {
     newNftsPerId[n.id] = n;
   });
 
@@ -206,7 +202,7 @@ export const makeSync =
         try {
           const freshAddressPath = getSeedIdentifierDerivation(
             initial.currency,
-            initial.derivationMode as DerivationMode
+            initial.derivationMode as DerivationMode,
           );
 
           const shape = await getAccountShape(
@@ -218,7 +214,7 @@ export const makeSync =
               derivationMode: initial.derivationMode as DerivationMode,
               initialAccount: needClear ? clearAccount(initial) : initial,
             },
-            syncConfig
+            syncConfig,
           );
 
           const updater = (acc: Account): Account => {
@@ -240,13 +236,11 @@ export const makeSync =
               operationsCount: shape.operationsCount || operations.length,
               lastSyncDate: new Date(),
               creationDate:
-                operations.length > 0
-                  ? operations[operations.length - 1].date
-                  : new Date(),
+                operations.length > 0 ? operations[operations.length - 1].date : new Date(),
               ...shape,
               operations,
-              pendingOperations: a.pendingOperations.filter((op) =>
-                shouldRetainPendingOperation(a, op)
+              pendingOperations: a.pendingOperations.filter(op =>
+                shouldRetainPendingOperation(a, op),
               ),
             });
 
@@ -271,7 +265,7 @@ export const makeSync =
 
 // Use for withDevice
 export type DeviceCommunication = (
-  deviceId: string
+  deviceId: string,
 ) => <T>(job: (transport: Transport) => Observable<T>) => Observable<T>;
 
 const defaultIterateResultBuilder = (getAddressFn: Resolver) => () =>
@@ -304,7 +298,7 @@ const defaultIterateResultBuilder = (getAddressFn: Resolver) => () =>
         derivationsCache[freshAddressPath] = res;
       }
       return res as Result;
-    }
+    },
   );
 
 export const makeScanAccounts =
@@ -320,266 +314,235 @@ export const makeScanAccounts =
     getAddressFn: Resolver;
   }): CurrencyBridge["scanAccounts"] =>
   ({ currency, deviceId, syncConfig }): Observable<ScanAccountEvent> =>
-    deviceCommunication(deviceId)((transport) =>
-      Observable.create(
-        (o: Observer<{ type: "discovered"; account: Account }>) => {
-          let finished = false;
+    deviceCommunication(deviceId)(transport =>
+      Observable.create((o: Observer<{ type: "discovered"; account: Account }>) => {
+        let finished = false;
 
-          const unsubscribe = () => {
-            finished = true;
-          };
+        const unsubscribe = () => {
+          finished = true;
+        };
 
-          const derivationsCache: Record<string, Result> = {};
+        const derivationsCache: Record<string, Result> = {};
 
-          async function stepAccount(
-            index: number,
-            res: Result,
-            derivationMode: DerivationMode,
-            seedIdentifier: string,
-            transport: Transport
-          ): Promise<Account | null | undefined> {
-            if (finished) return;
+        async function stepAccount(
+          index: number,
+          res: Result,
+          derivationMode: DerivationMode,
+          seedIdentifier: string,
+          transport: Transport,
+        ): Promise<Account | null | undefined> {
+          if (finished) return;
 
-            const { address, path: freshAddressPath, ...rest } = res;
+          const { address, path: freshAddressPath, ...rest } = res;
 
-            const accountShape: Partial<Account> = await getAccountShape(
+          const accountShape: Partial<Account> = await getAccountShape(
+            {
+              transport,
+              currency,
+              index,
+              address,
+              derivationPath: freshAddressPath,
+              derivationMode,
+              rest,
+            },
+            syncConfig,
+          );
+          if (finished) return;
+
+          const freshAddress = address;
+          const operations = accountShape.operations || [];
+          const operationsCount = accountShape.operationsCount || operations.length;
+          const creationDate =
+            operations.length > 0 ? operations[operations.length - 1].date : new Date();
+          const balance = accountShape.balance || new BigNumber(0);
+          const spendableBalance = accountShape.spendableBalance || new BigNumber(0);
+          if (!accountShape.id) throw new Error("account ID must be provided");
+          if (balance.isNaN()) throw new Error("invalid balance NaN");
+          const initialAccount: Account = {
+            type: "Account",
+            id: accountShape.id,
+            seedIdentifier,
+            freshAddress,
+            freshAddressPath,
+            freshAddresses: [
               {
-                transport,
-                currency,
-                index,
-                address,
+                address: freshAddress,
                 derivationPath: freshAddressPath,
-                derivationMode,
-                rest,
               },
-              syncConfig
-            );
-            if (finished) return;
-
-            const freshAddress = address;
-            const operations = accountShape.operations || [];
-            const operationsCount =
-              accountShape.operationsCount || operations.length;
-            const creationDate =
-              operations.length > 0
-                ? operations[operations.length - 1].date
-                : new Date();
-            const balance = accountShape.balance || new BigNumber(0);
-            const spendableBalance =
-              accountShape.spendableBalance || new BigNumber(0);
-            if (!accountShape.id)
-              throw new Error("account ID must be provided");
-            if (balance.isNaN()) throw new Error("invalid balance NaN");
-            const initialAccount: Account = {
-              type: "Account",
-              id: accountShape.id,
-              seedIdentifier,
-              freshAddress,
-              freshAddressPath,
-              freshAddresses: [
-                {
-                  address: freshAddress,
-                  derivationPath: freshAddressPath,
-                },
-              ],
-              derivationMode,
-              name: "",
-              starred: false,
-              used: false,
-              index,
-              currency,
-              operationsCount,
-              operations: [],
-              swapHistory: [],
-              pendingOperations: [],
-              unit: currency.units[0],
-              lastSyncDate: new Date(),
-              creationDate,
-              // overrides
-              balance,
-              spendableBalance,
-              blockHeight: 0,
-              balanceHistoryCache: emptyHistoryCache,
-            };
-            const account = { ...initialAccount, ...accountShape };
-
-            if (account.balanceHistoryCache === emptyHistoryCache) {
-              account.balanceHistoryCache =
-                generateHistoryFromOperations(account);
-            }
+            ],
+            derivationMode,
+            name: "",
+            starred: false,
+            used: false,
+            index,
+            currency,
+            operationsCount,
+            operations: [],
+            swapHistory: [],
+            pendingOperations: [],
+            unit: currency.units[0],
+            lastSyncDate: new Date(),
+            creationDate,
+            // overrides
+            balance,
+            spendableBalance,
+            blockHeight: 0,
+            balanceHistoryCache: emptyHistoryCache,
+          };
+          const account = { ...initialAccount, ...accountShape };
 
-            if (!account.used) {
-              account.used = !isAccountEmpty(account);
-            }
+          if (account.balanceHistoryCache === emptyHistoryCache) {
+            account.balanceHistoryCache = generateHistoryFromOperations(account);
+          }
 
-            // Bitcoin needs to compute the freshAddressPath itself,
-            // so we update it afterwards
-            if (account?.freshAddressPath) {
-              res.address = account.freshAddress;
-              derivationsCache[account.freshAddressPath] = res;
-            }
+          if (!account.used) {
+            account.used = !isAccountEmpty(account);
+          }
+
+          // Bitcoin needs to compute the freshAddressPath itself,
+          // so we update it afterwards
+          if (account?.freshAddressPath) {
+            res.address = account.freshAddress;
+            derivationsCache[account.freshAddressPath] = res;
+          }
+
+          log("scanAccounts", "derivationsCache", res);
 
-            log("scanAccounts", "derivationsCache", res);
+          log(
+            "scanAccounts",
+            `scanning ${currency.id} at ${freshAddressPath}: ${res.address} resulted of ${
+              account ? `Account with ${account.operations.length} txs` : "no account"
+            }`,
+          );
+          if (!account) return;
+          account.name = !account.used
+            ? getNewAccountPlaceholderName({
+                currency,
+                index,
+                derivationMode,
+              })
+            : getAccountPlaceholderName({
+                currency,
+                index,
+                derivationMode,
+              });
+
+          const showNewAccount = shouldShowNewAccount(currency, derivationMode);
 
+          if (account.used || showNewAccount) {
             log(
-              "scanAccounts",
-              `scanning ${currency.id} at ${freshAddressPath}: ${
-                res.address
-              } resulted of ${
-                account
-                  ? `Account with ${account.operations.length} txs`
-                  : "no account"
-              }`
+              "debug",
+              `Emit 'discovered' event for a new account found. AccountUsed: ${account.used} - showNewAccount: ${showNewAccount}`,
             );
-            if (!account) return;
-            account.name = !account.used
-              ? getNewAccountPlaceholderName({
-                  currency,
-                  index,
-                  derivationMode,
-                })
-              : getAccountPlaceholderName({
-                  currency,
-                  index,
-                  derivationMode,
-                });
+            o.next({
+              type: "discovered",
+              account,
+            });
+          }
 
-            const showNewAccount = shouldShowNewAccount(
-              currency,
-              derivationMode
-            );
+          return account;
+        }
 
-            if (account.used || showNewAccount) {
-              log(
-                "debug",
-                `Emit 'discovered' event for a new account found. AccountUsed: ${account.used} - showNewAccount: ${showNewAccount}`
-              );
-              o.next({
-                type: "discovered",
-                account,
-              });
-            }
+        if (buildIterateResult === undefined) {
+          buildIterateResult = defaultIterateResultBuilder(getAddressFn);
+        }
 
-            return account;
-          }
+        async function main() {
+          try {
+            const derivationModes = getDerivationModesForCurrency(currency);
 
-          if (buildIterateResult === undefined) {
-            buildIterateResult = defaultIterateResultBuilder(getAddressFn);
-          }
+            for (const derivationMode of derivationModes) {
+              if (finished) break;
+              const path = getSeedIdentifierDerivation(currency, derivationMode);
+              log("scanAccounts", `scanning ${currency.id} on derivationMode=${derivationMode}`);
+              let result: Result = derivationsCache[path];
 
-          async function main() {
-            try {
-              const derivationModes = getDerivationModesForCurrency(currency);
+              if (!result) {
+                try {
+                  result = await getAddressFn(transport, {
+                    currency,
+                    path,
+                    derivationMode,
+                  });
 
-              for (const derivationMode of derivationModes) {
-                if (finished) break;
-                const path = getSeedIdentifierDerivation(
-                  currency,
-                  derivationMode
-                );
-                log(
-                  "scanAccounts",
-                  `scanning ${currency.id} on derivationMode=${derivationMode}`
-                );
-                let result: Result = derivationsCache[path];
-
-                if (!result) {
-                  try {
-                    result = await getAddressFn(transport, {
-                      currency,
-                      path,
-                      derivationMode,
-                    });
-
-                    derivationsCache[path] = result;
-                  } catch (e) {
-                    if (e instanceof UnsupportedDerivation) {
-                      log(
-                        "scanAccounts",
-                        "ignore derivationMode=" + derivationMode
-                      );
-                      continue;
-                    }
-                    throw e;
+                  derivationsCache[path] = result;
+                } catch (e) {
+                  if (e instanceof UnsupportedDerivation) {
+                    log("scanAccounts", "ignore derivationMode=" + derivationMode);
+                    continue;
                   }
+                  throw e;
                 }
+              }
 
-                if (!result) continue;
-                const seedIdentifier = result.publicKey;
-                let emptyCount = 0;
-                const mandatoryEmptyAccountSkip =
-                  getMandatoryEmptyAccountSkip(derivationMode);
-                const derivationScheme = getDerivationScheme({
-                  derivationMode,
-                  currency,
-                });
+              if (!result) continue;
+              const seedIdentifier = result.publicKey;
+              let emptyCount = 0;
+              const mandatoryEmptyAccountSkip = getMandatoryEmptyAccountSkip(derivationMode);
+              const derivationScheme = getDerivationScheme({
+                derivationMode,
+                currency,
+              });
 
-                const stopAt = isIterableDerivationMode(derivationMode)
-                  ? 255
-                  : 1;
-                const startsAt = getDerivationModeStartsAt(derivationMode);
+              const stopAt = isIterableDerivationMode(derivationMode) ? 255 : 1;
+              const startsAt = getDerivationModeStartsAt(derivationMode);
 
-                log(
-                  "debug",
-                  `start scanning account process. MandatoryEmptyAccountSkip ${mandatoryEmptyAccountSkip} / StartsAt: ${startsAt} - StopAt: ${stopAt}`
-                );
+              log(
+                "debug",
+                `start scanning account process. MandatoryEmptyAccountSkip ${mandatoryEmptyAccountSkip} / StartsAt: ${startsAt} - StopAt: ${stopAt}`,
+              );
 
-                const iterateResult = await buildIterateResult!({
-                  result,
-                  derivationMode,
-                  derivationScheme,
-                });
+              const iterateResult = await buildIterateResult!({
+                result,
+                derivationMode,
+                derivationScheme,
+              });
 
-                for (let index = startsAt; index < stopAt; index++) {
-                  log("debug", `start to scan a new account. Index: ${index}`);
+              for (let index = startsAt; index < stopAt; index++) {
+                log("debug", `start to scan a new account. Index: ${index}`);
 
-                  if (finished) {
-                    log(
-                      "debug",
-                      `new account scanning process has been finished`
-                    );
-                    break;
-                  }
+                if (finished) {
+                  log("debug", `new account scanning process has been finished`);
+                  break;
+                }
 
-                  if (!derivationModeSupportsIndex(derivationMode, index))
-                    continue;
+                if (!derivationModeSupportsIndex(derivationMode, index)) continue;
 
-                  const res = await iterateResult({
-                    transport,
-                    index,
-                    derivationsCache,
-                    derivationMode,
-                    derivationScheme,
-                    currency,
-                  });
+                const res = await iterateResult({
+                  transport,
+                  index,
+                  derivationsCache,
+                  derivationMode,
+                  derivationScheme,
+                  currency,
+                });
 
-                  if (!res) break;
+                if (!res) break;
 
-                  const account = await stepAccount(
-                    index,
-                    res,
-                    derivationMode,
-                    seedIdentifier,
-                    transport
-                  );
+                const account = await stepAccount(
+                  index,
+                  res,
+                  derivationMode,
+                  seedIdentifier,
+                  transport,
+                );
 
-                  if (account && !account.used) {
-                    if (emptyCount >= mandatoryEmptyAccountSkip) break;
-                    emptyCount++;
-                  }
+                if (account && !account.used) {
+                  if (emptyCount >= mandatoryEmptyAccountSkip) break;
+                  emptyCount++;
                 }
               }
-
-              o.complete();
-            } catch (e) {
-              o.error(e);
             }
-          }
 
-          main();
-          return unsubscribe;
+            o.complete();
+          } catch (e) {
+            o.error(e);
+          }
         }
-      )
+
+        main();
+        return unsubscribe;
+      }),
     );
 export function makeAccountBridgeReceive(
   getAddressFn: Resolver,
@@ -588,7 +551,7 @@ export function makeAccountBridgeReceive(
     injectGetAddressParams,
   }: {
     injectGetAddressParams?: (account: Account) => any;
-  } = {}
+  } = {},
 ): (
   account: Account,
   option: {
@@ -596,7 +559,7 @@ export function makeAccountBridgeReceive(
     deviceId: string;
     subAccountId?: string;
     freshAddressIndex?: number;
-  }
+  },
 ) => Observable<{
   address: string;
   path: string;
@@ -616,30 +579,23 @@ export function makeAccountBridgeReceive(
       verify,
       currency: account.currency,
       derivationMode: account.derivationMode,
-      path: freshAddress
-        ? freshAddress.derivationPath
-        : account.freshAddressPath,
+      path: freshAddress ? freshAddress.derivationPath : account.freshAddressPath,
       ...(injectGetAddressParams && injectGetAddressParams(account)),
     };
     return deviceCommunication(deviceId)((transport: Transport) =>
       from(
-        getAddressFn(transport, arg).then((r) => {
-          const accountAddress = freshAddress
-            ? freshAddress.address
-            : account.freshAddress;
+        getAddressFn(transport, arg).then(r => {
+          const accountAddress = freshAddress ? freshAddress.address : account.freshAddress;
 
           if (r.address !== accountAddress) {
-            throw new WrongDeviceForAccount(
-              `WrongDeviceForAccount ${account.name}`,
-              {
-                accountName: account.name,
-              }
-            );
+            throw new WrongDeviceForAccount(`WrongDeviceForAccount ${account.name}`, {
+              accountName: account.name,
+            });
           }
 
           return r;
-        })
-      )
+        }),
+      ),
     );
   };
 }

package/src/cache.ts

@@ -15,20 +15,20 @@ export type CacheRes<A extends Array<any>, T> = {
 export type LRUCacheFn = <A extends Array<any>, T>(
   f: (...args: A) => Promise<T>,
   keyExtractor?: (...args: A) => string,
-  lruOpts?: LRU.Options<string, any>
+  lruOpts?: LRU.Options<string, any>,
 ) => CacheRes<A, T>;
 
 export const makeNoCache: LRUCacheFn = <A extends Array<any>, T>(
-  f: (...args: A) => Promise<T>
+  f: (...args: A) => Promise<T>,
 ): CacheRes<A, T> => {
   const result = (...args: A) => {
-    return f(...args).catch((e) => {
+    return f(...args).catch(e => {
       throw e;
     });
   };
 
   result.force = (...args: A) => {
-    return f(...args).catch((e) => {
+    return f(...args).catch(e => {
       throw e;
     });
   };