@ledgerhq/live-common 34.53.0-nightly.20251120023735 → 34.53.0-nightly.20251121023744

package/src/__tests__/accounts/groupPerDay.ts

@@ -2,8 +2,7 @@ import flatMap from "lodash/flatMap";
 import { fromAccountRaw, groupAccountOperationsByDay } from "../../account";
 import { TezosAccountRaw } from "../../families/tezos/types";
 import { setSupportedCurrencies } from "../../currencies";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { setup } from "../../bridge/impl";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 setSupportedCurrencies(["tezos"]);
 
@@ -14,8 +13,7 @@ LiveConfig.setConfig({
   },
 });
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setup({} as CryptoAssetsStore);
+setupMockCryptoAssetsStore();
 
 let account: Awaited<ReturnType<typeof fromAccountRaw>>;
 

package/src/__tests__/csvExport.ts

@@ -5,10 +5,10 @@ import { getCryptoCurrencyById } from "../currencies";
 import { accountsOpToCSV } from "../csvExport";
 import { initialState, loadCountervalues } from "@ledgerhq/live-countervalues/logic";
 import { getFiatCurrencyByTicker, setSupportedCurrencies } from "../currencies";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
-initializeLegacyTokens(addTokens);
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 setSupportedCurrencies(["ethereum", "ripple"]);
 setEnv("MOCK", "1");
 setEnv("MOCK_COUNTERVALUES", "1");

package/src/__tests__/currencies.ts

@@ -1,6 +1,5 @@
 import { BigNumber } from "bignumber.js";
 import {
-  listTokens,
   getCryptoCurrencyById,
   getFiatCurrencyByTicker,
   formatCurrencyUnit,
@@ -10,43 +9,6 @@ import {
   encodeURIScheme,
   sanitizeValueString,
 } from "../currencies";
-import { byContractAddressAndChainId } from "@ledgerhq/hw-app-eth/erc20";
-
-/*
-  skipped because ledgerjs data is now lighter (from the POV of hw-app-eth)
-  (using cryptoassets-evm-signatures instead of cryptoassets)
-*/
-test.skip("erc20 are all consistent with those on ledgerjs side", () => {
-  const normalList = listTokens();
-  const delistedList = listTokens({
-    withDelisted: true,
-  });
-  expect(delistedList.length).toBeGreaterThan(normalList.length);
-
-  for (const token of delistedList) {
-    if (token.delisted) {
-      expect(normalList.find(o => o.id === token.id)).toBeUndefined();
-    }
-
-    if (token.tokenType === "erc20") {
-      if (token.parentCurrency.family === "filecoin") {
-        continue;
-      }
-      const tokenData = byContractAddressAndChainId(
-        token.contractAddress,
-        token.parentCurrency.ethereumLikeInfo?.chainId || 0,
-      );
-
-      if (!tokenData) {
-        throw new Error(token.name + " not available in ledgerjs data");
-      }
-
-      expect(token.ticker.toLowerCase()).toBe(tokenData.ticker.toLowerCase());
-      expect(token.contractAddress.toLowerCase()).toBe(tokenData.contractAddress.toLowerCase());
-      expect(token.units[0].magnitude).toBe(tokenData.decimals);
-    }
-  }
-});
 
 test("can format a currency unit", () => {
   const btc = getCryptoCurrencyById("bitcoin").units[0];

package/src/__tests__/test-helpers/setup.integration.ts

@@ -0,0 +1,17 @@
+import { setupCalClientStore } from "../../test-helpers/cryptoAssetsStore";
+import "./environment";
+import BigNumber from "bignumber.js";
+
+// Integration tests use the real CAL API
+setupCalClientStore();
+
+jest.setTimeout(360000);
+
+expect.extend({
+  toBeBigNumber(value) {
+    const pass = BigNumber.isBigNumber(value);
+    const message = pass ? () => `${value} is a BigNumber` : () => `${value} is not a BigNumber`;
+
+    return { message, pass };
+  },
+});

package/src/__tests__/test-helpers/setup.ts

@@ -1,11 +1,9 @@
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "../../test-helpers/cryptoAssetsStore";
 import "./environment";
 import BigNumber from "bignumber.js";
 
-initializeLegacyTokens(addTokens);
+// Unit tests use mock store
+setupMockCryptoAssetsStore();
 
 jest.setTimeout(360000);
 
@@ -17,6 +15,3 @@ expect.extend({
     return { message, pass };
   },
 });
-
-// Use legacyCryptoAssetsStore for integration tests so tokens can be found
-setCryptoAssetsStoreForCoinFramework(legacyCryptoAssetsStore);

package/src/account/helpers.test.ts

@@ -1,8 +1,8 @@
 import { loadBlacklistedTokenSections } from "./helpers";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
-jest.mock("../bridge/crypto-assets/index");
+jest.mock("@ledgerhq/cryptoassets/state");
 
 const mockGetCryptoAssetsStore = getCryptoAssetsStore as jest.MockedFunction<
   typeof getCryptoAssetsStore

package/src/account/helpers.ts

@@ -12,10 +12,11 @@ import {
   type TronAccount,
 } from "@ledgerhq/coin-tron/index";
 import { isAccountEmpty as isVechainAccountEmpty } from "@ledgerhq/coin-vechain/index";
+import { isAccountEmpty as isCantonAccountEmpty } from "@ledgerhq/coin-canton";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 import { isAccountDelegating } from "../families/tezos/staking";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 // TODO: remove this export and prefer import from root file.
 export {
@@ -46,6 +47,9 @@ export const isAccountEmpty = (a: AccountLike): boolean => {
     if (a.currency.family == "vechain") {
       return isVechainAccountEmpty(a);
     }
+    if (a.currency.family == "canton") {
+      return isCantonAccountEmpty(a);
+    }
   }
 
   return commonIsAccountEmpty(a);

package/src/account/serialization.test.ts

@@ -3,7 +3,7 @@ import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/mocks/acco
 import { toAccountRaw, fromAccountRaw } from "./serialization";
 import { setWalletAPIVersion } from "../wallet-api/version";
 import { WALLET_API_VERSION } from "../wallet-api/constants";
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { setCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
 import solanaSplTokenData from "../__fixtures__/solana-spl-epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v.json";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
@@ -17,7 +17,7 @@ const Solana = getCryptoCurrencyById("solana");
 const USDC = solanaSplTokenData as TokenCurrency;
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setCryptoAssetsStoreForCoinFramework({
+setCryptoAssetsStore({
   findTokenById: async (id: string) => {
     if (id === "solana/spl/epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v") {
       return USDC;

package/src/bridge/crypto-assets/index.test.ts

@@ -1,54 +1,19 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
+import { getCryptoAssetsStore, setCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
 describe("Testing CryptoAssetStore", () => {
-  it("should return the default methods from cryptoassets libs when feature flag does not exists", () => {
-    LiveConfig.setConfig({
-      some_other_feature: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toBe(legacyCryptoAssetsStore);
-  });
-
-  it("should return the default methods from cryptoassets libs when feature flag is disabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: false,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toBe(legacyCryptoAssetsStore);
+  beforeEach(() => {
+    // Reset the store before each test
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    setCryptoAssetsStore(undefined as unknown as CryptoAssetsStore);
   });
 
-  it("should throw an error when no store is set and feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    expect(() => getCryptoAssetsStore()).toThrow(
-      "CryptoAssetsStore is not set. Please call setCryptoAssetsStore first.",
-    );
+  it("should throw an error when no store is set", () => {
+    expect(() => getCryptoAssetsStore()).toThrow("CryptoAssetsStore is not set");
   });
 
-  it("should throw return the new store when feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
+  it("should return the store when it is set", () => {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const newStore = {} as unknown as CryptoAssetsStore;
     setCryptoAssetsStore(newStore);
@@ -56,4 +21,10 @@ describe("Testing CryptoAssetStore", () => {
     const store = getCryptoAssetsStore();
     expect(store).toBe(newStore);
   });
+
+  it("should work with mock store", () => {
+    const mockStore = setupMockCryptoAssetsStore();
+    const store = getCryptoAssetsStore();
+    expect(store).toBe(mockStore);
+  });
 });

package/src/bridge/generic-alpaca/utils.test.ts

@@ -466,8 +466,7 @@ describe("Alpaca utils", () => {
         ...baseOp,
         type: "OUT",
         value: BigInt(100),
-        tx: { ...baseOp.tx, fees: BigInt(25) },
-        details: { status: "failed" },
+        tx: { ...baseOp.tx, fees: BigInt(25), failed: true },
       };
 
       const result = adaptCoreOperationToLiveOperation(accountId, failedOp);

package/src/bridge/generic-alpaca/utils.ts

@@ -107,7 +107,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     extra.memo = op.details.memo as string;
   }
   const bnFees = new BigNumber(op.tx.fees.toString());
-  const hasFailed = op.details?.status === "failed";
+  const hasFailed = op.tx.failed;
 
   let value: BigNumber;
   if (hasFailed) {

package/src/bridge/impl.ts

@@ -20,9 +20,7 @@ import {
 import { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
 import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
 import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
+// Removed: stores are now managed globally by @ledgerhq/cryptoassets/cal-client/store
 
 const alpacaized = {
   xrp: true,
@@ -105,10 +103,8 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
   return wrapAccountBridge(jsBridge.accountBridge);
 }
 
-export function setup(store: CryptoAssetsStore) {
-  setCryptoAssetsStore(store);
-  setCryptoAssetsStoreForCoinFramework(getCryptoAssetsStore());
-}
+// Removed: setup() is no longer needed. The store is now managed globally by @ledgerhq/cryptoassets/cal-client/store.
+// Use setupCalClientStore() or setupMockCryptoAssetsStore() from @ledgerhq/cryptoassets/cal-client/test-helpers instead.
 
 function wrapAccountBridge<T extends TransactionCommon>(
   bridge: AccountBridge<T>,

package/src/currencies/cryptoIcons.test.ts

@@ -1,11 +1,30 @@
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens as addTokensLegacy } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "../test-helpers/cryptoAssetsStore";
 import { inferCryptoCurrencyIcon } from "./cryptoIcons";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 beforeAll(() => {
-  initializeLegacyTokens(addTokensLegacy);
+  // Setup mock store for unit tests
+  setupMockCryptoAssetsStore({
+    findTokenById: async (id: string) => {
+      // Return a mock token for the test
+      if (id === "ethereum/erc20/usd_tether__erc20_") {
+        return {
+          type: "TokenCurrency",
+          id: "ethereum/erc20/usd_tether__erc20_",
+          contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+          parentCurrency: getCryptoCurrencyById("ethereum"),
+          tokenType: "erc20",
+          name: "Tether USD",
+          ticker: "USDT",
+          delisted: false,
+          disableCountervalue: false,
+          units: [{ name: "USDT", code: "USDT", magnitude: 6 }],
+        } as any;
+      }
+      return undefined;
+    },
+  });
 });
 
 describe("inferCryptoCurrencyIcon", () => {

package/src/currencies/helpers.test.ts

@@ -0,0 +1,13 @@
+import "../__tests__/test-helpers/setup";
+import { isCryptoCurrency } from "./helpers";
+import { listCryptoCurrencies } from ".";
+
+describe("Currencies helpers", () => {
+  test("listCryptoCurrencies returns only crypto currencies", () => {
+    const currencies = listCryptoCurrencies();
+
+    currencies.forEach(currency => {
+      expect(isCryptoCurrency(currency)).toBeTruthy();
+    });
+  });
+});

package/src/currencies/index.ts

@@ -11,9 +11,6 @@ export {
   findCryptoCurrencyByScheme,
   findCryptoCurrencyByKeyword,
   findCryptoCurrencyByTicker,
-  listTokens,
-  listTokensForCryptoCurrency,
-  listTokenTypesForCryptoCurrency,
   getAbandonSeedAddress,
 } from "@ledgerhq/cryptoassets";
 export {

package/src/currencies/sortByMarketcap.test.ts

@@ -1,31 +1,5 @@
 import { sortCurrenciesByIds } from "./sortByMarketcap";
-import { listCryptoCurrencies, listTokens } from ".";
-import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
-import { findCryptoCurrencyByTicker, findFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/index";
-import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
-import { setup } from "../bridge/impl";
-
-initializeLegacyTokens(addTokens);
-setup(legacyCryptoAssetsStore);
-
-test("sortCurrenciesByIds snapshot", async () => {
-  const list = [...listCryptoCurrencies(), ...listTokens()];
-  const ids: string[] = [];
-  for (const k in getBTCValues()) {
-    const c =
-      findCryptoCurrencyByTicker(k) ||
-      findFiatCurrencyByTicker(k) ||
-      (await getCryptoAssetsStore().findTokenById(k));
-    if (c && (c.type == "CryptoCurrency" || c.type == "TokenCurrency")) {
-      ids.push(c.id);
-    }
-  }
-  expect(sortCurrenciesByIds(list, ids).map(c => c.id)[0]).toEqual("bitcoin");
-});
 
 test("sortCurrenciesByIds simulate staking from portfolio", () => {
   expect(sortCurrenciesByIds(CURRENCIES_LIST, IDS).map(c => c.id)).toEqual([

package/src/domain/getTokensWithFunds.test.ts

@@ -1,18 +1,47 @@
 import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
 import { getCryptoCurrencyById } from "../currencies/index";
 import { Account } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
 import { getTokensWithFunds } from "./getTokensWithFunds";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
-initializeLegacyTokens(addTokens);
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 
 const ETH = getCryptoCurrencyById("ethereum");
 
+// Create mock tokens for tests
+const ZRX_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/0x_project",
+  contractAddress: "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "0x Project",
+  ticker: "ZRX",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "ZRX", code: "ZRX", magnitude: 18 }],
+};
+
+const REP_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/augur",
+  contractAddress: "0x1985365e9f78359a9B6AD760e32412f4a445E862",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "Augur",
+  ticker: "REP",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "REP", code: "REP", magnitude: 18 }],
+};
+
 const mockedAccounts: Account[] = [
   genAccount("mocked-account-2", {
     currency: ETH,
+    tokensData: [ZRX_TOKEN, REP_TOKEN],
   }),
 ];
 

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -1,4 +1,4 @@
-import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { AccountLike, SwapOperation } from "@ledgerhq/types-live";
 import { accountWithMandatoryTokens, getAccountCurrency } from "../../account";
 import type { MappedSwapOperation, SwapHistorySection } from "./types";

package/src/exchange/swap/hooks/useSelectableCurrencies.test.ts

@@ -5,6 +5,10 @@ import { renderHook, waitFor } from "@testing-library/react";
 
 import { useSelectableCurrencies } from "./useSelectableCurrencies";
 import { getCryptoCurrencyById } from "../../../currencies";
+import { setupMockCryptoAssetsStore } from "../../../test-helpers/cryptoAssetsStore";
+
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 
 describe("useSelectableCurrencies", () => {
   test("returns an empty array when empty list are passed", async () => {

package/src/exchange/swap/hooks/useSelectableCurrencies.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { getCryptoAssetsStore } from "../../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 export const useSelectableCurrencies = ({

package/src/families/algorand/__snapshots__/bridge.integration.test.ts.snap

@@ -22,39 +22,39 @@ exports[`algorand currency bridge scanAccounts algorand seed 1 1`] = `
     "xpub": "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
   },
   {
-    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
-    "operationsCount": 11,
+    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438828",
+    "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
     "pendingOperations": [],
     "swapHistory": [],
-    "tokenId": "algorand/asa/312769",
+    "tokenId": "algorand/asa/438828",
     "type": "TokenAccountRaw",
   },
   {
-    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438828",
-    "operationsCount": 0,
+    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
+    "operationsCount": 11,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
     "pendingOperations": [],
     "swapHistory": [],
-    "tokenId": "algorand/asa/438828",
+    "tokenId": "algorand/asa/312769",
     "type": "TokenAccountRaw",
   },
   {
-    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438837",
+    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+2757561",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
     "pendingOperations": [],
     "swapHistory": [],
-    "tokenId": "algorand/asa/438837",
+    "tokenId": "algorand/asa/2757561",
     "type": "TokenAccountRaw",
   },
   {
-    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+2757561",
+    "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438837",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
     "pendingOperations": [],
     "swapHistory": [],
-    "tokenId": "algorand/asa/2757561",
+    "tokenId": "algorand/asa/438837",
     "type": "TokenAccountRaw",
   },
   {
@@ -2772,6 +2772,7 @@ exports[`algorand currency bridge scanAccounts algorand seed 1 2`] = `
       "value": "1010",
     },
   ],
+  [],
   [
     {
       "accountId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
@@ -2965,7 +2966,6 @@ exports[`algorand currency bridge scanAccounts algorand seed 1 2`] = `
   [],
   [],
   [],
-  [],
   [
     {
       "accountId": "js:2:algorand:EGZQNDFCXGR3BMP4NDM6ZPLBMY7WSV6GRKOHM6VBJKFLWQ3RQDTE3JYNFE:",

package/src/families/algorand/bridge.integration.test.ts

@@ -1,4 +1,4 @@
-import "../../__tests__/test-helpers/setup";
+import "../../__tests__/test-helpers/setup.integration";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import { dataset } from "@ledgerhq/coin-algorand/test/bridge.dataset";