@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/bridge/impl.ts

@@ -8,10 +8,10 @@ import type {
 } from "../types";
 import { decodeAccountId, getMainAccount } from "../account";
 import { getEnv } from "../env";
-import { checkAccountSupported, shouldUseJS } from "../account/support";
+import { checkAccountSupported } from "../account/support";
 import jsBridges from "../generated/bridge/js";
 import mockBridges from "../generated/bridge/mock";
-import libcoreBridges from "../generated/bridge/libcore";
+
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
     const mockBridge = mockBridges[currency.family];
@@ -25,16 +25,10 @@ export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   }
 
   const jsBridge = jsBridges[currency.family];
-  const libcoreBridge = libcoreBridges[currency.family];
-
-  if (jsBridge && (!libcoreBridge || shouldUseJS(currency))) {
+  if (jsBridge) {
     return jsBridge.currencyBridge;
   }
 
-  if (libcoreBridge) {
-    return libcoreBridge.currencyBridge;
-  }
-
   throw new CurrencyNotSupported(
     "no implementation available for currency " + currency.id,
     {
@@ -68,17 +62,11 @@ export const getAccountBridge = (
   }
 
   const jsBridge = jsBridges[family];
-
   if (type === "libcore") {
-    if (jsBridge && shouldUseJS(currency)) {
+    // migrate from libcore via JS
+    if (jsBridge) {
       return jsBridge.accountBridge;
     }
-
-    // TODO at this point, we might want to check if an impl in JS exists
-    // and if it's not flagged as experimental, we make an implicit migration that would happen to change ids and change bridge implementation
-    // FIXME: how will addAccount reconciliate accounts?
-    const libcoreBridge = libcoreBridges[family];
-    if (libcoreBridge) return libcoreBridge.accountBridge;
     throw new CurrencyNotSupported(
       "no libcore implementation available for currency " + currency.id,
       {

package/src/bridge/jsHelpers.ts

@@ -34,12 +34,11 @@ import type {
   SyncConfig,
   CryptoCurrency,
   DerivationMode,
-  NFT,
+  ProtoNFT,
 } from "../types";
 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
@@ -137,9 +136,12 @@ Operation[] {
   return all;
 }
 
-export const mergeNfts = (oldNfts: NFT[], newNfts: NFT[]): NFT[] => {
+export const mergeNfts = (
+  oldNfts: ProtoNFT[],
+  newNfts: ProtoNFT[]
+): ProtoNFT[] => {
   // Getting a map of id => NFT
-  const newNftsPerId: Record<string, NFT> = {};
+  const newNftsPerId: Record<string, ProtoNFT> = {};
   newNfts.forEach((n) => {
     newNftsPerId[n.id] = n;
   });
@@ -276,257 +278,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/cross.ts

@@ -295,7 +295,7 @@ export const accountDataToAccount = ({
   derivationMode: derivationModeStr,
   seedIdentifier,
 }: AccountData): Account => {
-  const { type, xpubOrAddress } = decodeAccountId(id); // TODO rename in AccountId xpubOrAddress
+  const { xpubOrAddress } = decodeAccountId(id); // TODO rename in AccountId xpubOrAddress
 
   const derivationMode = asDerivationMode(derivationModeStr);
   const currency = getCryptoCurrencyById(currencyId);
@@ -304,13 +304,11 @@ export const accountDataToAccount = ({
   let freshAddressPath = "";
 
   if (
-    type === "libcore" ||
     // FIXME Dirty hack, since we have no way here to know if "xpubOrAddress" is one or the other.
     // Proposed fix: https://ledgerhq.atlassian.net/browse/LL-7437
     currency.family === "bitcoin"
   ) {
-    // In libcore implementation, xpubOrAddress field always go in the xpub
-    // In JS implementation, only Bitcoin-like currencies store the xpub
+    // In bitcoin implementation, xpubOrAddress field always go in the xpub
     xpub = xpubOrAddress;
   } else {
     if (currency.family === "tezos") {