Merge pull request LedgerHQ#11395 from LedgerHQ/LIVE-20069-add-call-to-cal-ledger-service-in-the-bridge

feat: add call to CAL in bridge

Author: dilaouid

.changeset/orange-cows-crash.md

@@ -0,0 +1,6 @@
+---
+"@ledgerhq/types-live": minor
+"@ledgerhq/live-common": minor
+---
+
+feat: add call to CAL in bridge

libs/ledger-live-common/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);
+    });
+  });
+});

libs/ledger-live-common/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;
+}

libs/ledger-live-common/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);
+    });
+  });
+});

libs/ledger-live-common/src/bridge/crypto-assets/cal-store.ts

@@ -0,0 +1,46 @@
+import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+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) {
+        this.addressCache.set(token.contractAddress, token);
+      }
+      this.tickerCache.set(token.ticker, token);
+    });
+  }
+
+  findTokenByAddress(address: string): TokenCurrency | undefined {
+    return this.addressCache.get(address);
+  }
+
+  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 token = this.addressCache.get(address);
+    if (token && token.parentCurrency.id === currencyId) {
+      return token;
+    }
+    return undefined;
+  }
+
+  findTokenByTicker(ticker: string): TokenCurrency | undefined {
+    return this.tickerCache.get(ticker);
+  }
+}

libs/ledger-live-common/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();
+  });
 });

libs/ledger-live-common/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) {

libs/ledger-live-common/src/featureFlags/defaultFeatures.ts

@@ -108,6 +108,7 @@ export const DEFAULT_FEATURES: Features = {
   postOnboardingAssetsTransfer: DEFAULT_FEATURE,
   counterValue: DEFAULT_FEATURE,
   mockFeature: DEFAULT_FEATURE,
+  calLedgerService: DEFAULT_FEATURE,
   ptxServiceCtaExchangeDrawer: DEFAULT_FEATURE,
   ptxServiceCtaScreens: DEFAULT_FEATURE,
   ptxSwapReceiveTRC20WithoutTrx: DEFAULT_FEATURE,

libs/ledgerjs/packages/types-live/src/feature.ts

@@ -267,6 +267,7 @@ export type Features = CurrencyFeatures & {
   llmSentry: DefaultFeature;
   onboardingIgnoredOsUpdates: Feature_OnboardingIgnoredOSUpdates;
   supportDeviceApex: DefaultFeature;
+  calLedgerService: DefaultFeature;
 };
 
 /**