@ledgerhq/live-common 34.47.0 → 34.48.0-nightly.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ledgerhq/live-common",
   "description": "Common ground for the Ledger Live apps",
-  "version": "34.47.0",
+  "version": "34.48.0-nightly.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/LedgerHQ/ledger-live.git"
@@ -108,13 +108,14 @@
     "@dfinity/principal": "^0.15.6",
     "@ledgerhq/device-management-kit": "0.0.0-fix-lns-20250901094837",
     "@ledgerhq/live-app-sdk": "^0.8.1",
-    "@ledgerhq/wallet-api-client": "^1.9.1",
-    "@ledgerhq/wallet-api-core": "^1.21.1",
-    "@ledgerhq/wallet-api-server": "^1.10.1",
+    "@ledgerhq/wallet-api-client": "^1.10.0",
+    "@ledgerhq/wallet-api-core": "^1.22.0",
+    "@ledgerhq/wallet-api-server": "^1.11.0",
+    "@noble/curves": "^1.9.7",
     "@reduxjs/toolkit": "2.8.2",
     "@stellar/stellar-sdk": "^14.0.0",
     "@stricahq/typhonjs": "^3.0.0",
-    "@taquito/ledger-signer": "^22.0.0",
+    "@taquito/ledger-signer": "^23.0.0-RC.0",
     "@ton-community/ton-ledger": "^7.2.0",
     "@ton/core": "^0.60.1",
     "@ton/crypto": "^3.3.0",
@@ -154,7 +155,6 @@
     "reselect": "^4.1.5",
     "rlp": "^3.0.0",
     "rxjs": "^7.8.1",
-    "secp256k1": "^4.0.3",
     "semver": "^7.3.5",
     "sha.js": "^2.4.11",
     "triple-beam": "^1.3.0",
@@ -165,35 +165,35 @@
     "xstate": "^5.19.2",
     "yargs": "^17.0.0",
     "zod": "^3.22.4",
-    "@ledgerhq/coin-algorand": "^0.10.0",
-    "@ledgerhq/coin-aptos": "^3.2.0",
-    "@ledgerhq/coin-bitcoin": "^0.21.0",
-    "@ledgerhq/coin-canton": "^0.4.0",
-    "@ledgerhq/coin-cardano": "^0.12.0",
-    "@ledgerhq/coin-casper": "^2.1.0",
-    "@ledgerhq/coin-celo": "^1.3.0",
-    "@ledgerhq/coin-cosmos": "^0.17.0",
-    "@ledgerhq/coin-evm": "^2.29.0",
-    "@ledgerhq/coin-filecoin": "^1.11.0",
-    "@ledgerhq/coin-framework": "^6.3.0",
-    "@ledgerhq/coin-hedera": "^1.11.0",
-    "@ledgerhq/coin-icon": "^0.12.0",
-    "@ledgerhq/coin-internet_computer": "^1.8.0",
-    "@ledgerhq/coin-mina": "^1.2.0",
-    "@ledgerhq/coin-multiversx": "^0.5.0",
-    "@ledgerhq/coin-near": "^0.13.0",
-    "@ledgerhq/coin-polkadot": "^6.9.0",
-    "@ledgerhq/coin-solana": "^0.32.0",
-    "@ledgerhq/coin-stacks": "^0.9.0",
-    "@ledgerhq/coin-stellar": "^6.3.0",
-    "@ledgerhq/coin-sui": "^0.12.0",
-    "@ledgerhq/coin-tezos": "^6.3.0",
-    "@ledgerhq/coin-ton": "^0.14.0",
-    "@ledgerhq/coin-tron": "^5.3.0",
-    "@ledgerhq/coin-vechain": "^2.9.0",
-    "@ledgerhq/coin-xrp": "^7.3.0",
+    "@ledgerhq/coin-algorand": "^0.10.1-nightly.0",
+    "@ledgerhq/coin-aptos": "^3.2.1-nightly.0",
+    "@ledgerhq/coin-bitcoin": "^0.21.1-nightly.0",
+    "@ledgerhq/coin-canton": "^0.4.1-nightly.0",
+    "@ledgerhq/coin-cardano": "^0.12.1-nightly.0",
+    "@ledgerhq/coin-casper": "^2.1.1-nightly.0",
+    "@ledgerhq/coin-celo": "^1.3.1-nightly.0",
+    "@ledgerhq/coin-cosmos": "^0.17.1-nightly.0",
+    "@ledgerhq/coin-evm": "^2.29.1-nightly.0",
+    "@ledgerhq/coin-framework": "^6.4.0-nightly.0",
+    "@ledgerhq/coin-filecoin": "^1.11.1-nightly.0",
+    "@ledgerhq/coin-hedera": "^1.11.1-nightly.0",
+    "@ledgerhq/coin-icon": "^0.12.1-nightly.0",
+    "@ledgerhq/coin-internet_computer": "^1.8.1-nightly.0",
+    "@ledgerhq/coin-mina": "^1.2.1-nightly.0",
+    "@ledgerhq/coin-multiversx": "^0.5.1-nightly.0",
+    "@ledgerhq/coin-near": "^0.13.1-nightly.0",
+    "@ledgerhq/coin-polkadot": "^6.9.1-nightly.0",
+    "@ledgerhq/coin-solana": "^0.32.1-nightly.0",
+    "@ledgerhq/coin-stacks": "^0.9.1-nightly.0",
+    "@ledgerhq/coin-stellar": "^6.3.1-nightly.0",
+    "@ledgerhq/coin-sui": "^0.12.1-nightly.0",
+    "@ledgerhq/coin-tezos": "^6.3.1-nightly.0",
+    "@ledgerhq/coin-ton": "^0.14.1-nightly.0",
+    "@ledgerhq/coin-vechain": "^2.9.1-nightly.0",
+    "@ledgerhq/coin-xrp": "^7.3.1-nightly.0",
     "@ledgerhq/crypto-icons-ui": "^1.18.0",
     "@ledgerhq/cryptoassets": "^13.27.0",
+    "@ledgerhq/coin-tron": "^5.3.1-nightly.0",
     "@ledgerhq/device-core": "^0.6.2",
     "@ledgerhq/devices": "8.5.1",
     "@ledgerhq/errors": "^6.25.0",
@@ -219,18 +219,18 @@
     "@ledgerhq/hw-transport-mocker": "^6.29.10",
     "@ledgerhq/ledger-cal-service": "^1.3.1",
     "@ledgerhq/live-config": "^3.2.0",
-    "@ledgerhq/live-countervalues": "^0.7.0",
-    "@ledgerhq/live-countervalues-react": "^0.5.1",
+    "@ledgerhq/live-countervalues": "^0.7.1-nightly.0",
+    "@ledgerhq/live-countervalues-react": "^0.5.2-nightly.0",
     "@ledgerhq/live-dmk-shared": "^0.12.3",
     "@ledgerhq/live-env": "^2.15.0",
     "@ledgerhq/live-hooks": "0.1.0",
     "@ledgerhq/live-network": "^2.0.16",
-    "@ledgerhq/live-nft": "^0.8.19",
+    "@ledgerhq/live-nft": "^0.8.20-nightly.0",
     "@ledgerhq/live-promise": "^0.1.1",
-    "@ledgerhq/live-signer-canton": "^0.2.3",
-    "@ledgerhq/live-signer-evm": "^0.7.4",
-    "@ledgerhq/live-signer-solana": "^0.5.4",
-    "@ledgerhq/live-wallet": "^0.13.0",
+    "@ledgerhq/live-signer-canton": "^0.2.4-nightly.0",
+    "@ledgerhq/live-signer-evm": "^0.7.5-nightly.0",
+    "@ledgerhq/live-signer-solana": "^0.5.5-nightly.0",
+    "@ledgerhq/live-wallet": "^0.13.1-nightly.0",
     "@ledgerhq/logs": "^6.13.0",
     "@ledgerhq/speculos-transport": "^0.2.9",
     "@ledgerhq/wallet-api-acre-module": "^0.6.0",
@@ -307,6 +307,6 @@
     "test-bridge-update": "UPDATE_BACKEND_MOCKS=1 env-cmd -f .ci.integration.env pnpm jest --ci --updateSnapshot --passWithNoTests",
     "test-account-migration": "tsx src/__tests__/migration/account-migration.ts",
     "unimported": "unimported",
-    "coverage": "env-cmd -f .ci.unit.env pnpm jest --coverage --ci --updateSnapshot"
+    "coverage": "env-cmd -f .ci.unit.env pnpm jest --coverage --ci"
   }
 }

package/src/bridge/crypto-assets/cal-integration.test.ts

@@ -0,0 +1,53 @@
+import { isCALIntegrationEnabled, getCALStore } from "./cal-integration";
+import { CALStore } from "./cal-store";
+import { isFeature } from "../../featureFlags/firebaseFeatureFlags";
+
+jest.mock("../../featureFlags/firebaseFeatureFlags", () => ({
+  isFeature: jest.fn(),
+}));
+
+const mockIsFeature = jest.mocked(isFeature);
+
+describe("CAL Integration", () => {
+  beforeEach(() => {
+    mockIsFeature.mockClear();
+  });
+
+  describe("isCALIntegrationEnabled", () => {
+    it("should return false when feature flag is disabled", () => {
+      mockIsFeature.mockReturnValue(false);
+
+      expect(isCALIntegrationEnabled()).toBe(false);
+      expect(mockIsFeature).toHaveBeenCalledWith("calLedgerService");
+    });
+
+    it("should return true when feature flag is enabled (assuming MOCK is false)", () => {
+      mockIsFeature.mockReturnValue(true);
+
+      const result = isCALIntegrationEnabled();
+      expect(mockIsFeature).toHaveBeenCalledWith("calLedgerService");
+      expect(result).toEqual(true);
+    });
+
+    it("should return false when feature check throws", () => {
+      mockIsFeature.mockImplementation(() => {
+        throw new Error("Feature check error");
+      });
+
+      expect(isCALIntegrationEnabled()).toBe(false);
+    });
+  });
+
+  describe("getCALStore", () => {
+    it("should return a CALStore instance", () => {
+      const store = getCALStore();
+      expect(store).toBeInstanceOf(CALStore);
+    });
+
+    it("should return the same instance on multiple calls", () => {
+      const store1 = getCALStore();
+      const store2 = getCALStore();
+      expect(store1).toBe(store2);
+    });
+  });
+});

package/src/bridge/crypto-assets/cal-integration.ts

@@ -0,0 +1,23 @@
+import { getEnv } from "@ledgerhq/live-env";
+import { log } from "@ledgerhq/logs";
+import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { CALStore } from "./cal-store";
+import { isFeature } from "../../featureFlags/firebaseFeatureFlags";
+
+let calStoreInstance: CALStore | undefined;
+
+export function isCALIntegrationEnabled(): boolean {
+  try {
+    return !getEnv("MOCK") && isFeature("calLedgerService");
+  } catch (error) {
+    log("cal", "Error checking CAL integration:", error);
+    return false;
+  }
+}
+
+export function getCALStore(): CryptoAssetsStore {
+  if (!calStoreInstance) {
+    calStoreInstance = new CALStore();
+  }
+  return calStoreInstance;
+}

package/src/bridge/crypto-assets/cal-store.test.ts

@@ -0,0 +1,93 @@
+import { CALStore } from "./cal-store";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+describe("CALStore", () => {
+  let store: CALStore;
+
+  beforeEach(() => {
+    store = new CALStore();
+  });
+
+  describe("Token cache operations", () => {
+    const token = {
+      id: "ethereum/erc20/usdt",
+      name: "Tether USD",
+      ticker: "USDT",
+      contractAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      parentCurrency: { id: "ethereum" },
+      type: "TokenCurrency",
+      units: [
+        {
+          name: "USDT",
+          code: "USDT",
+          magnitude: 6,
+        },
+      ],
+    } as TokenCurrency;
+
+    it("should store and retrieve tokens by ID", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenById("ethereum/erc20/usdt");
+      expect(foundToken).toEqual(token);
+    });
+
+    it("should store and retrieve tokens by address", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenByAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7");
+      expect(foundToken).toEqual(token);
+    });
+
+    it("should store and retrieve tokens by ticker", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenByTicker("USDT");
+      expect(foundToken).toEqual(token);
+    });
+
+    it("should find token by address in specific currency", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenByAddressInCurrency(
+        "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        "ethereum",
+      );
+      expect(foundToken).toEqual(token);
+    });
+
+    it("should not find token by address in different currency", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenByAddressInCurrency(
+        "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        "polygon",
+      );
+      expect(foundToken).toBeUndefined();
+    });
+
+    it("should return undefined for non-existent address in findTokenByAddressInCurrency", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.findTokenByAddressInCurrency("0xNONEXISTENT", "ethereum");
+      expect(foundToken).toBeUndefined();
+    });
+
+    it("should return undefined for non-existent tokens", () => {
+      expect(store.findTokenById("non-existent")).toBeUndefined();
+      expect(store.findTokenByAddress("0x0000")).toBeUndefined();
+      expect(store.findTokenByTicker("FAKE")).toBeUndefined();
+    });
+
+    it("should throw error when getting non-existent token by ID", () => {
+      expect(() => store.getTokenById("non-existent")).toThrow("Token not found: non-existent");
+    });
+
+    it("should get existing token by ID", () => {
+      store.addTokens([token]);
+
+      const foundToken = store.getTokenById("ethereum/erc20/usdt");
+      expect(foundToken).toEqual(token);
+    });
+  });
+});

package/src/bridge/crypto-assets/cal-store.ts

@@ -0,0 +1,63 @@
+import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+// Coins with case-sensitive addresses (b58, ...)
+const CASE_SENSITIVE_COINS = ["solana"];
+
+export class CALStore implements CryptoAssetsStore {
+  private tokenCache = new Map<string, TokenCurrency>();
+  private addressCache = new Map<string, TokenCurrency>();
+  private tickerCache = new Map<string, TokenCurrency>();
+
+  addTokens(tokens: TokenCurrency[]) {
+    tokens.forEach(token => {
+      this.tokenCache.set(token.id, token);
+      if (token.contractAddress) {
+        const isCaseSensitive = CASE_SENSITIVE_COINS.includes(token.parentCurrency.id);
+        const normalizedAddress = isCaseSensitive
+          ? token.contractAddress
+          : token.contractAddress.toLowerCase();
+        this.addressCache.set(normalizedAddress, token);
+      }
+      this.tickerCache.set(token.ticker, token);
+    });
+  }
+
+  findTokenByAddress(address: string): TokenCurrency | undefined {
+    const exactMatch = this.addressCache.get(address);
+    if (exactMatch) return exactMatch;
+
+    const lowercaseMatch = this.addressCache.get(address.toLowerCase());
+    return lowercaseMatch;
+  }
+
+  getTokenById(id: string): TokenCurrency {
+    const token = this.tokenCache.get(id);
+    if (!token) {
+      throw new Error(`Token not found: ${id}`);
+    }
+    return token;
+  }
+
+  findTokenById(id: string): TokenCurrency | undefined {
+    return this.tokenCache.get(id);
+  }
+
+  findTokenByAddressInCurrency(address: string, currencyId: string): TokenCurrency | undefined {
+    const isCaseSensitive = CASE_SENSITIVE_COINS.includes(currencyId);
+
+    if (isCaseSensitive) {
+      const token = this.addressCache.get(address);
+      if (token && token.parentCurrency.id === currencyId) return token;
+      return undefined;
+    }
+
+    const token = this.addressCache.get(address.toLowerCase());
+    if (token && token.parentCurrency.id === currencyId) return token;
+    return undefined;
+  }
+
+  findTokenByTicker(ticker: string): TokenCurrency | undefined {
+    return this.tickerCache.get(ticker);
+  }
+}

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

@@ -2,8 +2,22 @@ import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import * as calIntegration from "./cal-integration";
 
 describe("Testing CryptoAssetStore", () => {
+  let isCALIntegrationEnabledSpy: jest.SpyInstance;
+  let getCALStoreSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    isCALIntegrationEnabledSpy = jest
+      .spyOn(calIntegration, "isCALIntegrationEnabled")
+      .mockReturnValue(false);
+    getCALStoreSpy = jest.spyOn(calIntegration, "getCALStore");
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
   it("should return the default methods from cryptoassets libs when feature flag does not exists", () => {
     LiveConfig.setConfig({
       some_other_feature: {
@@ -68,4 +82,37 @@ describe("Testing CryptoAssetStore", () => {
     const store = getCryptoAssetsStore();
     expect(store).toBe(newStore);
   });
+
+  it("should return CAL store when CAL integration is enabled", () => {
+    isCALIntegrationEnabledSpy.mockReturnValue(true);
+
+    const mockCALStore = {} as unknown as CryptoAssetsStore;
+    getCALStoreSpy.mockReturnValue(mockCALStore);
+
+    const store = getCryptoAssetsStore();
+
+    expect(isCALIntegrationEnabledSpy).toHaveBeenCalled();
+    expect(getCALStoreSpy).toHaveBeenCalled();
+    expect(store).toBe(mockCALStore);
+  });
+
+  it("should prioritize CAL integration over feature flags", () => {
+    isCALIntegrationEnabledSpy.mockReturnValue(true);
+
+    LiveConfig.setConfig({
+      feature_cal_lazy_loading: {
+        type: "boolean",
+        default: true,
+      },
+    });
+
+    const mockCALStore = {} as unknown as CryptoAssetsStore;
+    getCALStoreSpy.mockReturnValue(mockCALStore);
+
+    const store = getCryptoAssetsStore();
+
+    expect(store).toBe(mockCALStore);
+    expect(isCALIntegrationEnabledSpy).toHaveBeenCalled();
+    expect(getCALStoreSpy).toHaveBeenCalled();
+  });
 });

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

@@ -1,6 +1,7 @@
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { isCALIntegrationEnabled, getCALStore } from "./cal-integration";
 
 const legacyStore: CryptoAssetsStore = {
   findTokenByAddress: legacy.findTokenByAddress,
@@ -17,6 +18,10 @@ export function setCryptoAssetsStore(store: CryptoAssetsStore) {
 }
 
 export function getCryptoAssetsStore(): CryptoAssetsStore {
+  if (isCALIntegrationEnabled()) {
+    return getCALStore();
+  }
+
   const featureEnabled =
     LiveConfig.isConfigSet() && LiveConfig.getValueByKey("feature_cal_lazy_loading");
   if (!featureEnabled) {

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

@@ -1,16 +1,19 @@
 import { createApi as createXrpApi } from "@ledgerhq/coin-xrp/api/index";
 import { createApi as createStellarApi } from "@ledgerhq/coin-stellar/api/index";
+import { createApi as createCantonApi } from "@ledgerhq/coin-canton/api/index";
+import { createApi as createTronApi } from "@ledgerhq/coin-tron/api/index";
 import { getCurrencyConfiguration } from "../../../config";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getNetworkAlpacaApi } from "./network/network-alpaca";
 import { Api } from "@ledgerhq/coin-framework/api/types";
 import { XrpCoinConfig } from "@ledgerhq/coin-xrp/config";
 import { StellarCoinConfig } from "@ledgerhq/coin-stellar/config";
+import { CantonCoinConfig } from "@ledgerhq/coin-canton/config";
+import { TronCoinConfig } from "@ledgerhq/coin-tron/config";
 
 export function getAlpacaApi(network, kind): Api<any> {
   if (kind === "local") {
     switch (network) {
-      case "ripple":
       case "xrp":
         return createXrpApi(
           getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple")),
@@ -19,6 +22,16 @@ export function getAlpacaApi(network, kind): Api<any> {
         return createStellarApi(
           getCurrencyConfiguration<StellarCoinConfig>(getCryptoCurrencyById("stellar")),
         ) as Api<any>;
+      case "canton":
+        return createCantonApi(
+          getCurrencyConfiguration<CantonCoinConfig>(
+            getCryptoCurrencyById("canton_network_devnet"),
+          ),
+        ) as Api<any>;
+      case "tron":
+        return createTronApi(
+          getCurrencyConfiguration<TronCoinConfig>(getCryptoCurrencyById("tron")),
+        ) as Api<any>;
     }
   }
   return getNetworkAlpacaApi(network) satisfies Partial<Api<any>> as Api<any>;

package/src/bridge/generic-alpaca/alpaca/index.unit.test.ts

@@ -0,0 +1,78 @@
+import { getAlpacaApi } from "./index";
+import * as xrpModule from "@ledgerhq/coin-xrp/api/index";
+import * as stellarModule from "@ledgerhq/coin-stellar/api/index";
+import * as cantonModule from "@ledgerhq/coin-canton/api/index";
+import * as tronModule from "@ledgerhq/coin-tron/api/index";
+import * as config from "../../../config";
+import * as networkApi from "./network/network-alpaca";
+import * as cryptoAssets from "@ledgerhq/cryptoassets/currencies";
+
+const mockApiInstance = { mock: "api" };
+
+jest.mock("@ledgerhq/cryptoassets/currencies", () => ({
+  getCryptoCurrencyById: jest.fn(),
+}));
+
+jest.mock("../../../config", () => ({
+  getCurrencyConfiguration: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-xrp/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-stellar/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-canton/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-tron/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("./network/network-alpaca", () => ({
+  getNetworkAlpacaApi: jest.fn(),
+}));
+
+describe("getAlpacaApi", () => {
+  const mockCurrency = { id: "mock-currency" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Common mocks
+    (cryptoAssets.getCryptoCurrencyById as jest.Mock).mockReturnValue(mockCurrency);
+    (config.getCurrencyConfiguration as jest.Mock).mockReturnValue({ config: true });
+
+    // API mocks
+    jest.spyOn(xrpModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(stellarModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(cantonModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(tronModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(networkApi, "getNetworkAlpacaApi").mockReturnValue(mockApiInstance as any);
+  });
+
+  const testCases = [
+    { network: "xrp", module: xrpModule, label: "XRP" },
+    { network: "stellar", module: stellarModule, label: "Stellar" },
+    { network: "tron", module: tronModule, label: "Tron" },
+    { network: "canton", module: cantonModule, label: "Canton" },
+  ];
+
+  testCases.forEach(({ network, module, label }) => {
+    it(`should return ${label} API for network "${network}" and kind "local"`, () => {
+      const result = getAlpacaApi(network, "local");
+      expect(result).toEqual(mockApiInstance);
+      expect(module.createApi).toHaveBeenCalledWith({ config: true });
+    });
+  });
+
+  it("should return network API for kind !== 'local'", () => {
+    const result = getAlpacaApi("xrp", "remote");
+    expect(networkApi.getNetworkAlpacaApi).toHaveBeenCalledWith("xrp");
+    expect(result).toEqual(mockApiInstance);
+  });
+});

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

@@ -134,7 +134,7 @@ const buildGetSequence = (networkFamily: string) =>
 const buildListOperations = networkFamily =>
   async function listOperations(
     address: string,
-    pagination: Pagination = { minHeight: 0 },
+    pagination: Pagination = { minHeight: 0, order: "asc" },
   ): Promise<[Operation<any>[], string]> {
     const { data } = await network<{ operations: Operation<any>[] }, unknown>({
       method: "GET",

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

@@ -1,11 +1,10 @@
 import BigNumber from "bignumber.js";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Operation, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import { AssetInfo, Balance } from "@ledgerhq/coin-framework/api/types";
-import { findTokenById } from "@ledgerhq/cryptoassets/tokens";
 
 export interface OperationCommon extends Operation {
   extra: Record<string, any>;
@@ -13,11 +12,6 @@ export interface OperationCommon extends Operation {
 
 export const getAssetIdFromTokenId = (tokenId: string): string => tokenId.split("/")[2];
 
-export const getAssetIdFromAsset = (asset: AssetInfo) =>
-  asset.type !== "native" && "assetReference" in asset && "assetOwner" in asset
-    ? `${asset.assetReference}:${asset.assetOwner}`
-    : "";
-
 function buildTokenAccount({
   parentAccountId,
   assetBalance,
@@ -29,8 +23,7 @@ function buildTokenAccount({
   token: TokenCurrency;
   operations: OperationCommon[];
 }): TokenAccount {
-  const assetId = getAssetIdFromTokenId(token.id);
-  const id = `${parentAccountId}+${assetId}`;
+  const id = encodeTokenAccountId(parentAccountId, token);
   const balance = new BigNumber(assetBalance.value.toString() || "0");
 
   // TODO: recheck this logic
@@ -68,12 +61,14 @@ export function buildSubAccounts({
   assetsBalance,
   syncConfig,
   operations,
+  getTokenFromAsset,
 }: {
   currency: CryptoCurrency;
   accountId: string;
   assetsBalance: Balance[];
   syncConfig: SyncConfig;
   operations: OperationCommon[];
+  getTokenFromAsset?: (asset: AssetInfo) => TokenCurrency | undefined;
 }): TokenAccount[] | undefined {
   const { blacklistedTokenIds = [] } = syncConfig;
   const allTokens = listTokensForCryptoCurrency(currency);
@@ -85,7 +80,7 @@ export function buildSubAccounts({
   assetsBalance
     .filter(b => b.asset.type !== "native") // NOTE: this could be removed, keeping here while fixing things up
     .map(balance => {
-      const token = findToken(currency, balance);
+      const token = getTokenFromAsset && getTokenFromAsset(balance.asset);
       // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
       if (token && !blacklistedTokenIds.includes(token.id)) {
         tokenAccounts.push(
@@ -104,7 +99,3 @@ export function buildSubAccounts({
     });
   return tokenAccounts;
 }
-
-export function findToken(currency: CryptoCurrency, balance: Balance): TokenCurrency | undefined {
-  return findTokenById(`${currency.family}/asset/${getAssetIdFromAsset(balance.asset)}`);
-}