@ledgerhq/live-common 21.35.0 → 21.36.2

package/src/__tests__/families/bitcoin/wallet-btc/bitcoin.test.ts

@@ -82,7 +82,7 @@ describe("Unit tests for various bitcoin functions", () => {
     testAddresses(p2shTestnet, "bitcoin_testnet");
   });
 
-  it("Test taproot address generation", () => {
+  it("Test taproot address generation", async () => {
     const bitcoin = cryptoFactory("bitcoin_testnet");
     // Test data taken from project app-bitcoin-new, file test_get_wallet_address.py
     // Also generated using eg
@@ -298,28 +298,29 @@ describe("Unit tests for various bitcoin functions", () => {
       "tb1pkhlmr4xz5w8x8py8x7670zp9lzykhepw74jltvpleff3qpxc3m2sgsmgnu",
       "tb1ptp5mua0w462ahk56y8uvqgkv3pxk44dz67vjtax4jnu4ajm8ykgqd80ndj",
     ];
-
     const xpub =
       "tpubDDKYE6BREvDsSWMazgHoyQWiJwYaDDYPbCFjYxN3HFXJP5fokeiK4hwK5tTLBNEDBwrDXn8cQ4v9b2xdW62Xr5yxoQdMu1v6c7UDXYVH27U";
-    extAddrs.forEach((expected, index) => {
+    extAddrs.forEach(async (expected, index) => {
       expect(
-        bitcoin.getAddress(DerivationModes.TAPROOT, xpub, 0, index)
+        await bitcoin.getAddress(DerivationModes.TAPROOT, xpub, 0, index)
       ).toEqual(expected);
     });
-    changeAddrs.forEach((expected, index) => {
+    changeAddrs.forEach(async (expected, index) => {
       expect(
-        bitcoin.getAddress(DerivationModes.TAPROOT, xpub, 1, index)
+        await bitcoin.getAddress(DerivationModes.TAPROOT, xpub, 1, index)
       ).toEqual(expected);
     });
-
-    expect(
-      bitcoin.getAddress(DerivationModes.NATIVE_SEGWIT, xpub, 0, 0).slice(0, 4)
-    ).toEqual("tb1q");
-    expect(
-      bitcoin.getAddress(DerivationModes.LEGACY, xpub, 0, 0).slice(0, 1)
-    ).toMatch(new RegExp("[mn]"));
-    expect(
-      bitcoin.getAddress(DerivationModes.SEGWIT, xpub, 0, 0).slice(0, 1)
-    ).toEqual("2");
+    let prefix = (
+      await bitcoin.getAddress(DerivationModes.NATIVE_SEGWIT, xpub, 0, 0)
+    ).slice(0, 4);
+    expect(prefix).toEqual("tb1q");
+    prefix = (
+      await bitcoin.getAddress(DerivationModes.LEGACY, xpub, 0, 0)
+    ).slice(0, 1);
+    expect(prefix).toMatch(new RegExp("[mn]"));
+    prefix = (
+      await bitcoin.getAddress(DerivationModes.SEGWIT, xpub, 0, 0)
+    ).slice(0, 1);
+    expect(prefix).toEqual("2");
   });
 });

package/src/__tests__/families/bitcoin/wallet-btc/utils.test.ts

@@ -162,6 +162,7 @@ describe("Unit tests for various utils functions", () => {
     validateAddrs(["Xh13o3cWixDBYJMGuJmFX17TZb9guXcBik"], "dash", true);
     validateAddrs(["MFYvHZcZ35typC4k2XyvRVooCDZxnoDS4B"], "qtum", true);
     validateAddrs(["t1b1Rbw2shhJkP6MCnCyxCPuyFedHrwKty8"], "zcash", true);
+    validateAddrs(["t3PU1j7YW3fJ67jUbkGhSRto8qK2qXCUiW3"], "zcash", true);
     validateAddrs(["AYRf8r4SJhmfaEwmWvY8ujmrepbrWyenFr"], "bitcoin_gold", true);
     validateAddrs(["D8cMCRimfjwQ9E8jJvgUswt18WnZbCUAaW"], "dogecoin", true);
     validateAddrs(
@@ -193,6 +194,7 @@ describe("Unit tests for various utils functions", () => {
     validateAddrs(["Xh13o3cWixDBYJMGuJmFX17TZb9guXcBii"], "dash", false);
     validateAddrs(["MFYvHZcZ35typC4k2XyvRVooCDZxnoDS44"], "qtum", false);
     validateAddrs(["t1b1Rbw2shhJkP6MCnCyxCPuyFedHrwKtyy"], "zcash", false);
+    validateAddrs(["t3PU1j7YW3fJ67jUbkGySRto8qK2qXCUiW3"], "zcash", false);
     validateAddrs(
       ["AYRf8r4SJhmfaEwmWvY8ujmrepbrWyenFF"],
       "bitcoin_gold",

package/src/__tests__/families/bitcoin/wallet-btc/wallet.errorpropagation.test.ts

@@ -0,0 +1,41 @@
+import { DerivationModes } from "../../../../families/bitcoin/wallet-btc/types";
+import BitcoinLikeWallet from "../../../../families/bitcoin/wallet-btc/wallet";
+import {
+  getSecp256k1Instance,
+  setSecp256k1Instance,
+} from "../../../../families/bitcoin/wallet-btc/crypto/secp256k1";
+
+jest.setTimeout(180000);
+
+describe("testing resilience of failures", () => {
+  const wallet = new BitcoinLikeWallet();
+  const defaultImpl = getSecp256k1Instance();
+  it("should generate an account", async () => {
+    setSecp256k1Instance({
+      publicKeyTweakAdd: () => {
+        throw new Error("FAILCRYPTO");
+      },
+    });
+    try {
+      await expect(
+        wallet
+          .generateAccount({
+            xpub: "xpub6CV2NfQJYxHn7MbSQjQip3JMjTZGUbeoKz5xqkBftSZZPc7ssVPdjKrgh6N8U1zoQDxtSo6jLarYAQahpd35SJoUKokfqf1DZgdJWZhSMqP",
+            path: "44'/0'",
+            index: 0,
+            currency: "bitcoin",
+            network: "mainnet",
+            derivationMode: DerivationModes.LEGACY,
+            explorer: "ledgerv3",
+            explorerURI:
+              "https://explorers.api.vault.ledger.com/blockchain/v3/btc",
+            storage: "mock",
+            storageParams: [],
+          })
+          .then((a) => wallet.syncAccount(a))
+      ).rejects.toEqual(new Error("FAILCRYPTO"));
+    } finally {
+      setSecp256k1Instance(defaultImpl);
+    }
+  });
+});

package/src/__tests__/families/bitcoin/wallet-btc/xpub.getAddress.ts

@@ -62,11 +62,19 @@ describe("Unit tests for getAddress", () => {
         .toOutputScript("1F1tAaz5x1HUXrCNLbtMDqcw6o5GNn4xqX")
         .toString("hex")
     ).toEqual("76a91499bc78ba577a95a11f1a344d4d2ae55f2f857b9888ac");
+    // Legacy zcash address
     expect(
       zecCrypto
         .toOutputScript("t1T5XJvzQhh2gTsi3c5Vn9x5SMhpSWLSnVy")
         .toString("hex")
     ).toEqual("76a91464fa33fb6f8d72455af2a4e73ae30412af2c97ba88ac");
+    // P2SH zcash address
+    expect(
+      zecCrypto
+        .toOutputScript("t3PU1j7YW3fJ67jUbkGhSRto8qK2qXCUiW3")
+        .toString("hex")
+    ).toEqual("a91435c929cb2ee32626e1f5c8d773ab4fe9d94686e087");
+    // Legacy zen address
     expect(
       zenCrypto
         .toOutputScript("znjbHth4PxBJM8FmHgvXYHkuq99nKFkWvMg")
@@ -74,5 +82,43 @@ describe("Unit tests for getAddress", () => {
     ).toEqual(
       "76a914cb009bf12fc17d28e61527951101fdabfeaa187288ac209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4"
     );
+    // P2SH zen address
+    expect(
+      zenCrypto
+        .toOutputScript("zszpcLB6C5B8QvfDbF2dYWXsrpac5DL9WRk")
+        .toString("hex")
+    ).toEqual(
+      "a914df23c5eaba30b4d95798c5d5d0e2ecc2a3dc4ff287209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4"
+    );
+  }, 30000);
+  it.skip("Get legacy address benchmark", async () => {
+    const btcCrypto = new BTCCrypto({
+      network: coininfo.bitcoin.main.toBitcoinJS(),
+    });
+    for (let i = 0; i < 1; i++) {
+      for (let j = 0; j < 1000; j++) {
+        btcCrypto.getAddress(
+          DerivationModes.LEGACY,
+          "xpub6CThYZbX4PTeA7KRYZ8YXP3F6HwT2eVKPQap3Avieds3p1eos35UzSsJtTbJ3vQ8d3fjRwk4bCEz4m4H6mkFW49q29ZZ6gS8tvahs4WCZ9X",
+          i,
+          j
+        );
+      }
+    }
+  }, 30000);
+  it.skip("Get taproot address benchmark", async () => {
+    const btcCrypto = new BTCCrypto({
+      network: coininfo.bitcoin.main.toBitcoinJS(),
+    });
+    for (let i = 0; i < 1; i++) {
+      for (let j = 0; j < 1000; j++) {
+        btcCrypto.getAddress(
+          DerivationModes.TAPROOT,
+          "xpub6CThYZbX4PTeA7KRYZ8YXP3F6HwT2eVKPQap3Avieds3p1eos35UzSsJtTbJ3vQ8d3fjRwk4bCEz4m4H6mkFW49q29ZZ6gS8tvahs4WCZ9X",
+          i,
+          j
+        );
+      }
+    }
   }, 30000);
 });

package/src/__tests__/families/bitcoin/wallet-btc/xpub.txs.integration.test.ts

@@ -175,8 +175,8 @@ describe.skip("testing xpub legacy transactions", () => {
     expect((await xpubs[1].xpub.getXpubBalance()).toNumber()).toEqual(
       100000000
     );
-    let pendings0 = await xpubs[0].xpub.storage.getLastTx({ confirmed: false });
-    let pendings1 = await xpubs[1].xpub.storage.getLastTx({ confirmed: false });
+    let pendings0 = await xpubs[0].xpub.storage.getLastUnconfirmedTx();
+    let pendings1 = await xpubs[1].xpub.storage.getLastUnconfirmedTx();
     expect(pendings0).toBeTruthy();
     expect(pendings1).toBeTruthy();
 
@@ -200,8 +200,8 @@ describe.skip("testing xpub legacy transactions", () => {
     expect((await xpubs[1].xpub.getXpubBalance()).toNumber()).toEqual(
       100000000
     );
-    pendings0 = await xpubs[0].xpub.storage.getLastTx({ confirmed: false });
-    pendings1 = await xpubs[1].xpub.storage.getLastTx({ confirmed: false });
+    pendings0 = await xpubs[0].xpub.storage.getLastUnconfirmedTx();
+    pendings1 = await xpubs[1].xpub.storage.getLastUnconfirmedTx();
     expect(pendings0).toBeFalsy();
     expect(pendings1).toBeFalsy();
   }, 150000);

package/src/account/support.ts

@@ -20,7 +20,7 @@ import { getMainAccount } from "../account";
 import { getAccountBridge } from "../bridge";
 import jsBridges from "../generated/bridge/js";
 
-const experimentalIntegrations = ["tezos", "cosmos"];
+const experimentalIntegrations: string[] = [];
 
 export function shouldUseJS(currency: CryptoCurrency) {
   const jsBridge = jsBridges[currency.family];

package/src/apps/support.ts

@@ -29,7 +29,7 @@ export function shouldUpgrade(
 const appVersionsRequired = {
   Cosmos: ">= 2.14",
   Algorand: ">= 1.2.9",
-  Polkadot: ">= 10.9160.1",
+  Polkadot: ">= 11.9170.0",
   Elrond: ">= 1.0.11",
   Ethereum: ">= 1.9.17",
 };

package/src/bot/engine.ts

@@ -52,6 +52,8 @@ import type {
   TransactionRes,
 } from "./types";
 import { makeBridgeCacheSystem } from "../bridge/cache";
+import { accountDataToAccount, accountToAccountData } from "../cross";
+
 let appCandidates;
 const localCache = {};
 const cache = makeBridgeCacheSystem({
@@ -64,6 +66,15 @@ const cache = makeBridgeCacheSystem({
     return Promise.resolve(localCache[c.id]);
   },
 });
+
+// simulate the export/inport of an account
+async function crossAccount(account: Account): Promise<Account> {
+  const a = accountDataToAccount(accountToAccountData(account));
+  const synced = await syncAccount(a);
+  synced.name += " cross";
+  return synced;
+}
+
 export async function runWithAppSpec<T extends Transaction>(
   spec: AppSpec<T>,
   reportLog: (arg0: string) => void
@@ -146,6 +157,15 @@ export async function runWithAppSpec<T extends Transaction>(
       )
       .toPromise();
     appReport.scanTime = scanTime;
+    // "Migrate" the FIRST and every {crossAccountFrequency} account to simulate an export/import (same logic as export to mobile) – default to every 10
+    // this is made a subset of the accounts to help identify problem that would be specific to the "cross" or not.
+    for (
+      let i = 0;
+      i < accounts.length;
+      i += spec.crossAccountFrequency || 10
+    ) {
+      accounts[i] = await crossAccount(accounts[i]);
+    }
     appReport.accountsBefore = accounts;
     invariant(
       accounts.length > 0,
@@ -184,8 +204,8 @@ export async function runWithAppSpec<T extends Transaction>(
     let mutationsCount = {};
     // we sequentially iterate on the initial account set to perform mutations
     const length = accounts.length;
-
     const totalTries = spec.multipleRuns || 1;
+
     for (let j = 0; j < totalTries; j++) {
       for (let i = 0; i < length; i++) {
         log(

package/src/bot/index.ts

@@ -1,4 +1,6 @@
 /* eslint-disable no-console */
+import fs from "fs";
+import path from "path";
 import { BigNumber } from "bignumber.js";
 import groupBy from "lodash/groupBy";
 import { log } from "@ledgerhq/logs";
@@ -8,6 +10,7 @@ import { getEnv } from "../env";
 import allSpecs from "../generated/specs";
 import network from "../network";
 import { withLibcore } from "../libcore/access";
+import type { Account } from "../types";
 import type { MutationReport, SpecReport } from "./types";
 import { promiseAllBatched } from "../promise";
 import {
@@ -16,7 +19,7 @@ import {
   formatCurrencyUnit,
   getFiatCurrencyByTicker,
 } from "../currencies";
-import { isAccountEmpty } from "../account";
+import { isAccountEmpty, toAccountRaw } from "../account";
 import { runWithAppSpec } from "./engine";
 import { formatReportForConsole, formatError } from "./formatters";
 import {
@@ -32,6 +35,22 @@ type Arg = Partial<{
   mutation: string;
 }>;
 const usd = getFiatCurrencyByTicker("USD");
+
+function makeAppJSON(accounts: Account[]) {
+  const jsondata = {
+    data: {
+      settings: {
+        hasCompletedOnboarding: true,
+      },
+      accounts: accounts.map((account) => ({
+        data: toAccountRaw(account),
+        version: 1,
+      })),
+    },
+  };
+  return JSON.stringify(jsondata);
+}
+
 export async function bot({ currency, family, mutation }: Arg = {}) {
   const SEED = getEnv("SEED");
   invariant(SEED, "SEED required");
@@ -93,6 +112,7 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
       }));
     }
   );
+  const allAccountsBefore = flatMap(results, (r) => r.accountsBefore || []);
   const allAccountsAfter = flatMap(results, (r) => r.accountsAfter || []);
   let countervaluesError;
   const countervaluesState = await loadCountervalues(initialState, {
@@ -400,17 +420,37 @@ export async function bot({ currency, family, mutation }: Arg = {}) {
       body += "|\n";
     });
     body += "\n</details>\n\n";
+
+    const { SLACK_API_TOKEN, SLACK_CHANNEL, BOT_REPORT_FOLDER } = process.env;
+
+    if (BOT_REPORT_FOLDER) {
+      await Promise.all([
+        fs.promises.writeFile(
+          path.join(BOT_REPORT_FOLDER, "full-report.md"),
+          body,
+          "utf-8"
+        ),
+        fs.promises.writeFile(
+          path.join(BOT_REPORT_FOLDER, "before-app.json"),
+          makeAppJSON(allAccountsBefore),
+          "utf-8"
+        ),
+        fs.promises.writeFile(
+          path.join(BOT_REPORT_FOLDER, "after-app.json"),
+          makeAppJSON(allAccountsAfter),
+          "utf-8"
+        ),
+      ]);
+    }
+
     const { data: githubComment } = await network({
       url: `https://api.github.com/repos/LedgerHQ/ledger-live-common/commits/${GITHUB_SHA}/comments`,
       method: "POST",
       headers: {
         Authorization: `Bearer ${GITHUB_TOKEN}`,
       },
-      data: {
-        body,
-      },
+      data: { body },
     });
-    const { SLACK_API_TOKEN, SLACK_CHANNEL } = process.env;
 
     if (SLACK_API_TOKEN && githubComment) {
       const text = `${String(GITHUB_WORKFLOW)}: ${title} (<${

package/src/bot/types.ts

@@ -86,6 +86,8 @@ export type AppSpec<T extends Transaction> = {
   testTimeout?: number;
   // if define, will run the mutations {multipleRuns} times in order to cover 2 txs in the same run and detect possible issues at the "second tx time"
   multipleRuns?: number;
+  // define the frequency of exporting/importing back the account to simulate mobile export
+  crossAccountFrequency?: number;
   // if the nano app depends on an app, name of this app
   dependency?: string;
   // a query to select one nano app. the most up to date version is selected when fields aren't set.

package/src/bridge/jsHelpers.ts

@@ -42,6 +42,22 @@ 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
+type IterateResult = ({
+  transport: Transport,
+  index: number,
+  derivationsCache: Object,
+  derivationScheme: string,
+  derivationMode: DerivationMode,
+  currency: CryptoCurrency,
+}) => Promise<Result | null>;
+
+export type IterateResultBuilder = ({
+  result: Result, // derivation on the "root" of the derivation
+  derivationMode: DerivationMode, // identify the current derivation scheme
+  derivationScheme: string,
+}) => Promise<IterateResult>;
+
 export type GetAccountShapeArg0 = {
   currency: CryptoCurrency;
   address: string;
@@ -151,10 +167,13 @@ export const mergeNfts = (oldNfts: NFT[], newNfts: NFT[]): NFT[] => {
 };
 
 export const makeSync =
-  (
-    getAccountShape: GetAccountShape,
-    postSync: (initial: Account, synced: Account) => Account = (_, a) => a
-  ): AccountBridge<any>["sync"] =>
+  ({
+    getAccountShape,
+    postSync = (_, a) => a,
+  }: {
+    getAccountShape: GetAccountShape;
+    postSync?: (initial: Account, synced: Account) => Account;
+  }): AccountBridge<any>["sync"] =>
   (initial, syncConfig): Observable<AccountUpdater> =>
     Observable.create((o) => {
       async function main() {
@@ -217,13 +236,45 @@ export const makeSync =
       main();
     });
 
+const iterateResultWithAddressDerivation: IterateResult = async ({
+  transport,
+  index,
+  derivationsCache,
+  derivationScheme,
+  derivationMode,
+  currency,
+}) => {
+  let res;
+  const freshAddressPath = runDerivationScheme(derivationScheme, currency, {
+    account: index,
+  });
+  res = derivationsCache[freshAddressPath];
+  if (!res) {
+    res = await getAddress(transport, {
+      currency,
+      path: freshAddressPath,
+      derivationMode,
+    });
+    derivationsCache[freshAddressPath] = res;
+  }
+  return res;
+};
+
+const defaultIterateResultBuilder = () =>
+  Promise.resolve(iterateResultWithAddressDerivation);
+
 export const makeScanAccounts =
-  (
-    getAccountShape: GetAccountShape,
+  ({
+    getAccountShape,
+    buildIterateResult = defaultIterateResultBuilder,
+    getAddressFn,
+  }: {
+    getAccountShape: GetAccountShape;
+    buildIterateResult?: IterateResultBuilder;
     getAddressFn?: (
       transport: Transport
-    ) => (opts: GetAddressOptions) => Promise<Result>
-  ): CurrencyBridge["scanAccounts"] =>
+    ) => (opts: GetAddressOptions) => Promise<Result>;
+  }): CurrencyBridge["scanAccounts"] =>
   ({ currency, deviceId, syncConfig }): Observable<ScanAccountEvent> =>
     Observable.create((o) => {
       let finished = false;
@@ -234,17 +285,17 @@ export const makeScanAccounts =
 
       const derivationsCache = {};
 
-      // in future ideally what we want is:
-      // return mergeMap(addressesObservable, address => fetchAccount(address))
       async function stepAccount(
         index,
-        { address, path: freshAddressPath, ...rest },
+        res: Result,
         derivationMode,
         seedIdentifier,
         transport
       ): Promise<Account | null | undefined> {
         if (finished) return;
 
+        const { address, path: freshAddressPath, ...rest } = res;
+
         const accountShape: Partial<Account> = await getAccountShape(
           {
             transport,
@@ -313,6 +364,51 @@ export const makeScanAccounts =
           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",
+          `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(
+            "debug",
+            `Emit 'discovered' event for a new account found. AccountUsed: ${account.used} - showNewAccount: ${showNewAccount}`
+          );
+          o.next({
+            type: "discovered",
+            account,
+          });
+        }
+
         return account;
       }
 
@@ -334,7 +430,7 @@ export const makeScanAccounts =
               "scanAccounts",
               `scanning ${currency.id} on derivationMode=${derivationMode}`
             );
-            let result = derivationsCache[path];
+            let result: Result = derivationsCache[path];
 
             if (!result) {
               try {
@@ -343,6 +439,7 @@ export const makeScanAccounts =
                   path,
                   derivationMode,
                 });
+
                 derivationsCache[path] = result;
               } catch (e) {
                 if (e instanceof UnsupportedDerivation) {
@@ -365,10 +462,7 @@ export const makeScanAccounts =
               derivationMode,
               currency,
             });
-            const showNewAccount = shouldShowNewAccount(
-              currency,
-              derivationMode
-            );
+
             const stopAt = isIterableDerivationMode(derivationMode) ? 255 : 1;
             const startsAt = getDerivationModeStartsAt(derivationMode);
 
@@ -377,6 +471,12 @@ export const makeScanAccounts =
               `start scanning account process. MandatoryEmptyAccountSkip ${mandatoryEmptyAccountSkip} / StartsAt: ${startsAt} - StopAt: ${stopAt}`
             );
 
+            const iterateResult = await buildIterateResult({
+              result,
+              derivationMode,
+              derivationScheme,
+            });
+
             for (let index = startsAt; index < stopAt; index++) {
               log("debug", `start to scan a new account. Index: ${index}`);
 
@@ -386,23 +486,17 @@ export const makeScanAccounts =
               }
 
               if (!derivationModeSupportsIndex(derivationMode, index)) continue;
-              const freshAddressPath = runDerivationScheme(
+
+              const res = await iterateResult({
+                transport,
+                index,
+                derivationsCache,
+                derivationMode,
                 derivationScheme,
                 currency,
-                {
-                  account: index,
-                }
-              );
-              let res = derivationsCache[freshAddressPath];
+              });
 
-              if (!res) {
-                res = await getAddress(transport, {
-                  currency,
-                  path: freshAddressPath,
-                  derivationMode,
-                });
-                derivationsCache[freshAddressPath] = res;
-              }
+              if (!res) break;
 
               const account = await stepAccount(
                 index,
@@ -411,54 +505,14 @@ export const makeScanAccounts =
                 seedIdentifier,
                 transport
               );
-              // 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",
-                `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,
-                  });
-
-              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 (!account.used) {
+              if (account && !account.used) {
                 if (emptyCount >= mandatoryEmptyAccountSkip) break;
                 emptyCount++;
               }
             }
           }
+          // }
 
           o.complete();
         } catch (e) {

package/src/cross.ts

@@ -307,14 +307,15 @@ export const accountDataToAccount = ({
     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" ||
-    currency.family === "tezos"
+    currency.family === "bitcoin"
   ) {
     // In libcore implementation, xpubOrAddress field always go in the xpub
     // In JS implementation, only Bitcoin-like currencies store the xpub
     xpub = xpubOrAddress;
   } else {
-    if (!freshAddress) {
+    if (currency.family === "tezos") {
+      xpub = xpubOrAddress;
+    } else if (!freshAddress) {
       // otherwise, it's the freshAddress
       freshAddress = xpubOrAddress;
     }