@ledgerhq/live-common 21.36.0 → 21.36.3

package/src/bridge/jsHelpers.ts

@@ -39,7 +39,6 @@ import type {
 import type { CurrencyBridge, AccountBridge } from "../types/bridge";
 import getAddress from "../hw/getAddress";
 import type { Result, GetAddressOptions } from "../hw/getAddress/types";
-import { open, close } from "../hw";
 import { withDevice } from "../hw/deviceAccess";
 
 // Customize the way to iterate on the keychain derivation
@@ -276,257 +275,258 @@ export const makeScanAccounts =
     ) => (opts: GetAddressOptions) => Promise<Result>;
   }): CurrencyBridge["scanAccounts"] =>
   ({ currency, deviceId, syncConfig }): Observable<ScanAccountEvent> =>
-    Observable.create((o) => {
-      let finished = false;
+    withDevice(deviceId)((transport) =>
+      Observable.create((o) => {
+        let finished = false;
 
-      const unsubscribe = () => {
-        finished = true;
-      };
+        const unsubscribe = () => {
+          finished = true;
+        };
 
-      const derivationsCache = {};
+        const derivationsCache = {};
 
-      async function stepAccount(
-        index,
-        res: Result,
-        derivationMode,
-        seedIdentifier,
-        transport
-      ): Promise<Account | null | undefined> {
-        if (finished) return;
+        async function stepAccount(
+          index,
+          res: Result,
+          derivationMode,
+          seedIdentifier,
+          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(
-          {
-            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: [
+          const accountShape: Partial<Account> = await getAccountShape(
             {
-              address: freshAddress,
+              transport,
+              currency,
+              index,
+              address,
               derivationPath: freshAddressPath,
+              derivationMode,
+              rest,
             },
-          ],
-          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);
-        }
-
-        if (!account.used) {
-          account.used = !isAccountEmpty(account);
-        }
+            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);
+          }
 
-        // 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);
+          }
 
-        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,
-            });
+          // Bitcoin needs to compute the freshAddressPath itself,
+          // so we update it afterwards
+          if (account?.freshAddressPath) {
+            res.address = account.freshAddress;
+            derivationsCache[account.freshAddressPath] = res;
+          }
 
-        const showNewAccount = shouldShowNewAccount(currency, derivationMode);
+          log("scanAccounts", "derivationsCache", res);
 
-        if (account.used || showNewAccount) {
           log(
-            "debug",
-            `Emit 'discovered' event for a new account found. AccountUsed: ${account.used} - showNewAccount: ${showNewAccount}`
+            "scanAccounts",
+            `scanning ${currency.id} at ${freshAddressPath}: ${
+              res.address
+            } resulted of ${
+              account
+                ? `Account with ${account.operations.length} txs`
+                : "no account"
+            }`
           );
-          o.next({
-            type: "discovered",
-            account,
-          });
-        }
-
-        return account;
-      }
+          if (!account) return;
+          account.name = !account.used
+            ? getNewAccountPlaceholderName({
+                currency,
+                index,
+                derivationMode,
+              })
+            : getAccountPlaceholderName({
+                currency,
+                index,
+                derivationMode,
+              });
 
-      async function main() {
-        // TODO switch to withDevice
-        let transport;
+          const showNewAccount = shouldShowNewAccount(currency, derivationMode);
 
-        try {
-          transport = await open(deviceId);
-          const getAddr = getAddressFn
-            ? getAddressFn(transport)
-            : (opts) => getAddress(transport, opts);
-          const derivationModes = getDerivationModesForCurrency(currency);
-
-          for (const derivationMode of derivationModes) {
-            if (finished) break;
-            const path = getSeedIdentifierDerivation(currency, derivationMode);
+          if (account.used || showNewAccount) {
             log(
-              "scanAccounts",
-              `scanning ${currency.id} on derivationMode=${derivationMode}`
+              "debug",
+              `Emit 'discovered' event for a new account found. AccountUsed: ${account.used} - showNewAccount: ${showNewAccount}`
             );
-            let result: Result = derivationsCache[path];
+            o.next({
+              type: "discovered",
+              account,
+            });
+          }
 
-            if (!result) {
-              try {
-                result = await getAddr({
-                  currency,
-                  path,
-                  derivationMode,
-                });
+          return account;
+        }
 
-                derivationsCache[path] = result;
-              } catch (e) {
-                if (e instanceof UnsupportedDerivation) {
-                  log(
-                    "scanAccounts",
-                    "ignore derivationMode=" + derivationMode
-                  );
-                  continue;
+        async function main() {
+          try {
+            const getAddr = getAddressFn
+              ? getAddressFn(transport)
+              : (opts) => getAddress(transport, opts);
+            const derivationModes = getDerivationModesForCurrency(currency);
+
+            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 getAddr({
+                    currency,
+                    path,
+                    derivationMode,
+                  });
+
+                  derivationsCache[path] = result;
+                } catch (e) {
+                  if (e instanceof UnsupportedDerivation) {
+                    log(
+                      "scanAccounts",
+                      "ignore derivationMode=" + derivationMode
+                    );
+                    continue;
+                  }
+                  throw e;
                 }
-                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);
-        } finally {
-          if (transport) {
-            close(transport, deviceId);
+            o.complete();
+          } catch (e) {
+            o.error(e);
           }
         }
-      }
 
-      main();
-      return unsubscribe;
-    });
+        main();
+        return unsubscribe;
+      })
+    );
 export function makeAccountBridgeReceive({
   injectGetAddressParams,
 }: {

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -113,7 +113,7 @@ const getCompleteSwapHistory = (
       day = startOfDay(swap.operation.date);
       data = [swap];
       continue;
-    } else if (!skip) {
+    } else if (!skip && !data.find((d) => d.swapId === swap.swapId)) {
       data.push(swap);
     }
 

package/src/families/bitcoin/js-signOperation.ts

@@ -5,7 +5,7 @@ import { log } from "@ledgerhq/logs";
 import type { Account, Operation, SignOperationEvent } from "./../../types";
 import { isSegwitDerivationMode } from "./../../derivation";
 import { encodeOperationId } from "./../../operation";
-import { open, close } from "./../../hw";
+import { withDevice } from "../../hw/deviceAccess";
 import type { Transaction } from "./types";
 import { getNetworkParameters } from "./networks";
 import { buildTransaction } from "./js-buildTransaction";
@@ -22,14 +22,13 @@ const signOperation = ({
   deviceId: any;
   transaction: Transaction;
 }): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const { currency } = account;
-      const transport = await open(deviceId);
-      const hwApp = new Btc(transport);
-      const walletAccount = getWalletAccount(account);
-
-      try {
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      async function main() {
+        const { currency } = account;
+        const hwApp = new Btc(transport);
+        const walletAccount = getWalletAccount(account);
+
         log("hw", `signTransaction ${currency.id} for account ${account.id}`);
         const txInfo = await buildTransaction(account, transaction);
         let senders = new Set<string>();
@@ -152,15 +151,13 @@ const signOperation = ({
             expirationDate: null,
           },
         });
-      } finally {
-        close(transport, deviceId);
       }
-    }
 
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+    })
+  );
 
 export default signOperation;

package/src/families/crypto_org/js-signOperation.ts

@@ -1,16 +1,16 @@
 import { BigNumber } from "bignumber.js";
 import { Observable } from "rxjs";
+import { utils } from "@crypto-com/chain-jslib";
 import { FeeNotLoaded } from "@ledgerhq/errors";
+import CryptoOrgApp from "@ledgerhq/hw-app-cosmos";
 import {
   CryptoOrgWrongSignatureHeader,
   CryptoOrgSignatureSize,
 } from "./errors";
 import type { Transaction } from "./types";
 import type { Account, Operation, SignOperationEvent } from "../../types";
-import { open, close } from "../../hw";
 import { encodeOperationId } from "../../operation";
-import CryptoOrgApp from "@ledgerhq/hw-app-cosmos";
-import { utils } from "@crypto-com/chain-jslib";
+import { withDevice } from "../../hw/deviceAccess";
 import { buildTransaction } from "./js-buildTransaction";
 import { isTestNet } from "./logic";
 
@@ -104,11 +104,9 @@ const signOperation = ({
   deviceId: any;
   transaction: Transaction;
 }): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const transport = await open(deviceId);
-
-      try {
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      async function main() {
         o.next({
           type: "device-signature-requested",
         });
@@ -165,15 +163,13 @@ const signOperation = ({
             },
           });
         }
-      } finally {
-        close(transport, deviceId);
       }
-    }
 
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+    })
+  );
 
 export default signOperation;

package/src/families/elrond/js-signOperation.ts

@@ -3,7 +3,7 @@ import { Observable } from "rxjs";
 import { FeeNotLoaded } from "@ledgerhq/errors";
 import type { Transaction } from "./types";
 import type { Account, Operation, SignOperationEvent } from "../../types";
-import { open, close } from "../../hw";
+import { withDevice } from "../../hw/deviceAccess";
 import { encodeOperationId } from "../../operation";
 import Elrond from "./hw-app-elrond";
 import { buildTransaction } from "./js-buildTransaction";
@@ -48,11 +48,9 @@ const signOperation = ({
   deviceId: any;
   transaction: Transaction;
 }): Observable<SignOperationEvent> =>
-  Observable.create((o) => {
-    async function main() {
-      const transport = await open(deviceId);
-
-      try {
+  withDevice(deviceId)((transport) =>
+    Observable.create((o) => {
+      async function main() {
         if (!transaction.fees) {
           throw new FeeNotLoaded();
         }
@@ -89,15 +87,13 @@ const signOperation = ({
             expirationDate: null,
           },
         });
-      } finally {
-        close(transport, deviceId);
       }
-    }
 
-    main().then(
-      () => o.complete(),
-      (e) => o.error(e)
-    );
-  });
+      main().then(
+        () => o.complete(),
+        (e) => o.error(e)
+      );
+    })
+  );
 
 export default signOperation;