@ledgerhq/live-common 34.51.0-nightly.6 → 34.51.0-nightly.8

package/src/dada-client/state-manager/api.ts

@@ -41,18 +41,20 @@ export const assetsDataApi = createApi({
           ...(pageParam?.cursor && { cursor: pageParam.cursor }),
           ...(queryArg?.useCase && { transaction: queryArg.useCase }),
           ...(queryArg?.currencyIds &&
-            queryArg?.currencyIds.length > 0 &&
-            !queryArg?.useCase && { currencyIds: queryArg.currencyIds }),
+            queryArg?.currencyIds.length > 0 && { currencyIds: queryArg.currencyIds }),
           ...(queryArg?.search && { search: queryArg.search }),
           product: queryArg.product,
           minVersion: queryArg.version,
-          additionalData: [AssetsAdditionalData.Apy, AssetsAdditionalData.MarketTrend],
+          additionalData: queryArg.additionalData || [
+            AssetsAdditionalData.Apy,
+            AssetsAdditionalData.MarketTrend,
+          ],
         };
 
         const baseUrl = queryArg.isStaging ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD");
 
         return {
-          url: `${baseUrl}assets`,
+          url: `${baseUrl}/assets`,
           params,
         };
       },
@@ -81,7 +83,10 @@ export const assetsDataApi = createApi({
             queryArg?.currencyIds.length > 0 && { currencyIds: queryArg.currencyIds }),
           product: queryArg.product,
           minVersion: queryArg.version,
-          additionalData: [AssetsAdditionalData.Apy, AssetsAdditionalData.MarketTrend],
+          additionalData: queryArg.additionalData || [
+            AssetsAdditionalData.Apy,
+            AssetsAdditionalData.MarketTrend,
+          ],
         };
 
         const baseUrl = queryArg.isStaging ? getEnv("DADA_API_STAGING") : getEnv("DADA_API_PROD");

package/src/dada-client/state-manager/types.ts

@@ -16,6 +16,7 @@ export interface GetAssetsDataParams {
   product: "llm" | "lld";
   version: string;
   isStaging?: boolean;
+  additionalData?: AssetsAdditionalData[];
 }
 
 export interface PageParam {

package/src/e2e/data/deviceLabelsData.ts

@@ -65,7 +65,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.VERIFY_ETHEREUM,
       [AppInfos.POLKADOT.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.POLYGON.name]: DeviceLabels.VERIFY_POLYGON,
-      [AppInfos.SOLANA.name]: DeviceLabels.VERIFY_SOLANA_ADDRESS,
+      [AppInfos.SOLANA.name]: DeviceLabels.PUBKEY,
       default: DeviceLabels.ADDRESS,
     },
     receiveConfirm: {
@@ -75,14 +75,13 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.CONFIRM,
       [AppInfos.POLKADOT.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.POLYGON.name]: DeviceLabels.CONFIRM,
-      [AppInfos.SOLANA.name]: DeviceLabels.CONFIRM,
       default: DeviceLabels.APPROVE,
     },
     delegateVerify: {
       [AppInfos.COSMOS.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.RECEIVER,
       [AppInfos.NEAR.name]: DeviceLabels.VIEW_HEADER,
-      [AppInfos.SOLANA.name]: DeviceLabels.REVIEW_TRANSACTION,
+      [AppInfos.SOLANA.name]: DeviceLabels.DELEGATE_FROM,
       default: DeviceLabels.REVIEW_OPERATION,
     },
     delegateConfirm: {
@@ -92,7 +91,6 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.INJECTIVE.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.SIGN,
       [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
-      [AppInfos.SOLANA.name]: DeviceLabels.SIGN_TRANSACTION,
       [AppInfos.OSMOSIS.name]: DeviceLabels.CAPS_APPROVE,
       default: DeviceLabels.APPROVE,
     },

package/src/e2e/enum/Device.ts

@@ -1,7 +1,10 @@
 export class Device {
-  constructor(public readonly name: string) {}
+  constructor(
+    public readonly name: string,
+    public readonly targetId: number,
+  ) {}
 
-  static readonly LNS = "nanoS";
-  static readonly LNX = "nanoX";
-  static readonly LNSP = "nanoSP";
+  static readonly LNS = new Device("nanoS", 823132164);
+  static readonly LNX = new Device("nanoX", 855638020);
+  static readonly LNSP = new Device("nanoSP", 856686596);
 }

package/src/e2e/families/bitcoin.ts

@@ -1,12 +1,7 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
-import {
-  pressBoth,
-  pressUntilTextFound,
-  waitFor,
-  containsSubstringInEvent,
-  getSpeculosModel,
-} from "../speculos";
+import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
+import { getSpeculosModel } from "../speculosAppVersion";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import invariant from "invariant";
@@ -27,7 +22,7 @@ export async function sendBTC(tx: Transaction) {
   const speculosDevice = getSpeculosModel();
   try {
     const events =
-      speculosDevice === Device.LNS
+      speculosDevice === Device.LNS.name
         ? await pressUntilTextFound(DeviceLabels.CONTINUE)
         : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
     const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
@@ -35,7 +30,7 @@ export async function sendBTC(tx: Transaction) {
     const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
     expect(isAddressCorrect).toBeTruthy();
     await pressBoth();
-    if (speculosDevice === Device.LNS) {
+    if (speculosDevice === Device.LNS.name) {
       await pressUntilTextFound(DeviceLabels.SIGN);
       await pressBoth();
       await waitFor(DeviceLabels.BITCOIN_IS_READY);

package/src/e2e/families/cardano.ts

@@ -11,7 +11,7 @@ import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 
 export async function sendCardano(tx: Transaction) {
-  const isNanoS = process.env.SPECULOS_DEVICE === Device.LNS;
+  const isNanoS = process.env.SPECULOS_DEVICE === Device.LNS.name;
   await waitFor(DeviceLabels.NEW_ORDINARY);
   await (isNanoS ? pressRightButton() : pressBoth());
   if (isNanoS) {
@@ -66,7 +66,7 @@ export async function delegateCardano() {
     [DeviceLabels.CONFIRM, "right"],
   ] as const;
 
-  const steps = process.env.SPECULOS_DEVICE === Device.LNS ? LNSSpecificSteps : commonSteps;
+  const steps = process.env.SPECULOS_DEVICE === Device.LNS.name ? LNSSpecificSteps : commonSteps;
 
   for (const [label, action] of steps) {
     try {

package/src/e2e/families/evm.ts

@@ -1,12 +1,7 @@
 import expect from "expect";
 import { NFTTransaction, Transaction } from "../models/Transaction";
-import {
-  pressBoth,
-  pressUntilTextFound,
-  containsSubstringInEvent,
-  waitFor,
-  getSpeculosModel,
-} from "../speculos";
+import { pressBoth, pressUntilTextFound, containsSubstringInEvent, waitFor } from "../speculos";
+import { getSpeculosModel } from "../speculosAppVersion";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import { DeviceModelId } from "@ledgerhq/types-devices";
@@ -18,7 +13,7 @@ export async function sendEVM(tx: Transaction) {
       : await pressUntilTextFound(DeviceLabels.ACCEPT);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
-  if (tx.accountToCredit.ensName && process.env.SPECULOS_DEVICE !== Device.LNS) {
+  if (tx.accountToCredit.ensName && process.env.SPECULOS_DEVICE !== Device.LNS.name) {
     const isENSNameCorrect = containsSubstringInEvent(tx.accountToCredit.ensName, events);
     expect(isENSNameCorrect).toBeTruthy();
   } else {

package/src/e2e/families/solana.ts

@@ -4,13 +4,11 @@ import {
   pressUntilTextFound,
   containsSubstringInEvent,
   getDelegateEvents,
-  getSpeculosModel,
 } from "../speculos";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import { Transaction } from "../models/Transaction";
 import { Delegate } from "../models/Delegate";
-import { DeviceModelId } from "@ledgerhq/types-devices";
 
 export async function delegateSolana(delegatingAccount: Delegate) {
   await getDelegateEvents(delegatingAccount);
@@ -18,13 +16,10 @@ export async function delegateSolana(delegatingAccount: Delegate) {
 }
 
 export async function sendSolana(tx: Transaction) {
-  const events =
-    getSpeculosModel() !== DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION)
-      : await pressUntilTextFound(DeviceLabels.APPROVE);
+  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
-  if (process.env.SPECULOS_DEVICE !== Device.LNS) {
+  if (process.env.SPECULOS_DEVICE !== Device.LNS.name) {
     const isAddressCorrect = containsSubstringInEvent(
       tx.accountToCredit.parentAccount?.address ?? tx.accountToCredit.address,
       events,

package/src/e2e/families/tezos.ts

@@ -1,10 +1,5 @@
-import {
-  getDelegateEvents,
-  getDeviceLabels,
-  getSpeculosModel,
-  pressBoth,
-  pressUntilTextFound,
-} from "../speculos";
+import { getDelegateEvents, getDeviceLabels, pressBoth, pressUntilTextFound } from "../speculos";
+import { getSpeculosModel } from "../speculosAppVersion";
 import { Delegate } from "../models/Delegate";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { DeviceLabels } from "../enum/DeviceLabels";

package/src/e2e/speculos.ts

@@ -16,7 +16,6 @@ import { getEnv } from "@ledgerhq/live-env";
 import { getCryptoCurrencyById } from "../currencies";
 import { DeviceLabels } from "./enum/DeviceLabels";
 import { Account } from "./enum/Account";
-import { Device as CryptoWallet } from "./enum/Device";
 import { Currency } from "./enum/Currency";
 import expect from "expect";
 import { sendBTC, sendBTCBasedCoin } from "./families/bitcoin";
@@ -43,6 +42,7 @@ import { delegateOsmosis } from "./families/osmosis";
 import { AppInfos } from "./enum/AppInfos";
 import { DEVICE_LABELS_CONFIG } from "./data/deviceLabelsData";
 import { sendSui } from "./families/sui";
+import { getAppVersionFromCatalog, getSpeculosModel } from "./speculosAppVersion";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -51,6 +51,7 @@ export type Spec = {
   appQuery: {
     model: DeviceModelId;
     appName: string;
+    appVersion?: string;
   };
   /** @deprecated */
   dependency?: string;
@@ -74,19 +75,6 @@ export function setExchangeDependencies(dependencies: Dependency[]) {
   specs["Exchange"].dependencies = Array.from(map.values());
 }
 
-export function getSpeculosModel() {
-  const speculosDevice = process.env.SPECULOS_DEVICE;
-  switch (speculosDevice) {
-    case CryptoWallet.LNS:
-      return DeviceModelId.nanoS;
-    case CryptoWallet.LNX:
-      return DeviceModelId.nanoX;
-    case CryptoWallet.LNSP:
-    default:
-      return DeviceModelId.nanoSP;
-  }
-}
-
 type Specs = {
   [key: string]: Spec;
 };
@@ -312,7 +300,6 @@ export const specs: Specs = {
     },
     dependency: "",
   },
-
   Celo: {
     currency: getCryptoCurrencyById("celo"),
     appQuery: {
@@ -367,13 +354,21 @@ export async function startSpeculos(
   invariant(seed, "SEED is not set");
   const coinapps = COINAPPS;
   invariant(coinapps, "COINAPPS is not set");
-  let appCandidates;
+  const appCandidates = await listAppCandidates(coinapps);
 
-  if (!appCandidates) {
-    appCandidates = await listAppCandidates(coinapps);
-  }
+  const nanoAppCatalogPath = getEnv("E2E_NANO_APP_VERSION_PATH");
 
   const { appQuery, dependency, onSpeculosDeviceCreated } = spec;
+  try {
+    const displayName = spec.currency?.managerAppName || appQuery.appName;
+    const catalogVersion = await getAppVersionFromCatalog(displayName, nanoAppCatalogPath);
+    if (catalogVersion) {
+      appQuery.appVersion = catalogVersion;
+    }
+  } catch (e) {
+    console.warn("[speculos] Unable to fetch app version from catalog", e);
+  }
+
   const appCandidate = findLatestAppCandidate(appCandidates, appQuery);
   const { model } = appQuery;
   const { dependencies } = spec;
@@ -806,10 +801,7 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
 
 export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  const events =
-    getSpeculosModel() === DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
-      : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+  const events = await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND);
   verifySwapData(swap, events, amount);
   await pressBoth();
 }
@@ -829,11 +821,14 @@ export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
 }
 
 function verifySwapData(swap: Swap, events: string[], amount: string) {
-  const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;
+  // Uncoment when new exchange nanoApp is in prod
+
+  // const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;
+
+  // if (getSpeculosModel() !== DeviceModelId.nanoS) {
+  //   expectDeviceScreenContains(swapPair, events, "Swap pair not found on the device screen");
+  // }
 
-  if (getSpeculosModel() !== DeviceModelId.nanoS) {
-    expectDeviceScreenContains(swapPair, events, "Swap pair not found on the device screen");
-  }
   expectDeviceScreenContains(amount, events, `Amount ${amount} not found on the device screen`);
 }
 

package/src/e2e/speculosAppVersion.ts

@@ -0,0 +1,86 @@
+import { HttpManagerApiRepository, ApplicationV2Entity } from "@ledgerhq/device-core";
+import { version } from "@ledgerhq/device-core/package.json";
+import { getEnv } from "@ledgerhq/live-env";
+import { DeviceModelId } from "@ledgerhq/devices";
+import { Device as CryptoWallet } from "./enum/Device";
+import * as fs from "fs";
+import * as path from "path";
+
+export function getSpeculosModel(): DeviceModelId {
+  const speculosDevice = process.env.SPECULOS_DEVICE;
+  switch (speculosDevice) {
+    case CryptoWallet.LNS.name:
+      return DeviceModelId.nanoS;
+    case CryptoWallet.LNX.name:
+      return DeviceModelId.nanoX;
+    case CryptoWallet.LNSP.name:
+    default:
+      return DeviceModelId.nanoSP;
+  }
+}
+
+function getDeviceTargetId(device: DeviceModelId): number {
+  const modelToTargetIdMap = {
+    [DeviceModelId.nanoS]: CryptoWallet.LNS.targetId,
+    [DeviceModelId.nanoX]: CryptoWallet.LNX.targetId,
+    [DeviceModelId.nanoSP]: CryptoWallet.LNSP.targetId,
+  };
+  return modelToTargetIdMap[device];
+}
+
+export async function getNanoAppCatalog(
+  device: DeviceModelId,
+  deviceFirmware: string,
+): Promise<ApplicationV2Entity[]> {
+  const repository = new HttpManagerApiRepository(getEnv("MANAGER_API_BASE"), version);
+  const targetId = getDeviceTargetId(device);
+  return await repository.catalogForDevice({
+    provider: 1,
+    targetId: targetId,
+    firmwareVersion: deviceFirmware,
+  });
+}
+
+function getDeviceFirmwareVersion(): string {
+  const firmwareVersion = process.env.SPECULOS_FIRMWARE_VERSION;
+  if (!firmwareVersion) {
+    throw new Error("SPECULOS_FIRMWARE_VERSION environment variable is not set");
+  }
+  return firmwareVersion;
+}
+
+export async function createNanoAppJsonFile(nanoAppFilePath: string): Promise<void> {
+  try {
+    const device = getSpeculosModel();
+    const firmware = getDeviceFirmwareVersion();
+    const appCatalog = await getNanoAppCatalog(device, firmware);
+    const jsonFilePath = path.join(process.cwd(), nanoAppFilePath);
+    const dirPath = path.dirname(jsonFilePath);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.writeFileSync(jsonFilePath, JSON.stringify(appCatalog, null, 2), "utf8");
+  } catch (error) {
+    console.error("Unable to create app version file:", error);
+  }
+}
+
+export async function getAppVersionFromCatalog(
+  currency: string,
+  nanoAppFilePath: string,
+): Promise<string | undefined> {
+  try {
+    await createNanoAppJsonFile(nanoAppFilePath);
+    const rootDir = process.cwd();
+    const jsonFilePath = path.join(rootDir, nanoAppFilePath);
+    type CatalogApp = { versionDisplayName: string; version: string };
+    const raw = fs.readFileSync(jsonFilePath, "utf8");
+    const catalog: CatalogApp[] = JSON.parse(raw);
+
+    const app = catalog.find(entry => entry.versionDisplayName === currency);
+
+    return app?.version ?? "";
+  } catch (error) {
+    console.error(`Unable to get app version for ${currency} from catalog:`, error);
+  }
+}

package/src/e2e/speculosCI.ts

@@ -7,7 +7,7 @@ import {
 import { SpeculosDevice } from "./speculos";
 import https from "https";
 
-const { SEED, GITHUB_TOKEN, AWS_ROLE, CLUSTER } = process.env;
+const { SEED, GITHUB_TOKEN, AWS_ROLE, CLUSTER, SPECULOS_IMAGE_TAG } = process.env;
 const GIT_API_URL = "https://api.github.com/repos/LedgerHQ/actions/actions/";
 const START_WORKFLOW_ID = "workflows/161487603/dispatches";
 const STOP_WORKFLOW_ID = "workflows/161487604/dispatches";
@@ -147,6 +147,7 @@ function createStartPayload(deviceParams: DeviceParams, runId: string) {
   return {
     ref: GITHUB_REF,
     inputs: {
+      speculos_version: SPECULOS_IMAGE_TAG?.split(":")[1] || "master",
       coin_app: appName,
       coin_app_version: appVersion,
       device: reverseModelMap[model],

package/src/featureFlags/defaultFeatures.ts

@@ -129,6 +129,10 @@ export const DEFAULT_FEATURES: Features = {
   receiveStakingFlowConfigDesktop: initFeature(),
   brazePushNotifications: initFeature(),
   stakeAccountBanner: initFeature(),
+  mixpanelAnalytics: initFeature({
+    enabled: false,
+    params: { record_sessions_percent: 100 },
+  }),
 
   ptxSwapDetailedView: initFeature({
     enabled: false,
@@ -688,6 +692,12 @@ export const DEFAULT_FEATURES: Features = {
   supportDeviceApex: DEFAULT_FEATURE,
   llmSyncOnboardingIncr1: DEFAULT_FEATURE,
   noah: DEFAULT_FEATURE,
+  lldSessionReplay: {
+    ...DEFAULT_FEATURE,
+    params: {
+      sampling: 100,
+    },
+  },
 };
 
 // Firebase SDK treat JSON values as strings

package/src/load/speculos.ts

@@ -128,6 +128,7 @@ export const findLatestAppCandidate = (
   appCandidates: AppCandidate[],
   search: AppSearch,
 ): AppCandidate | null => {
+  search.firmware = process.env.SPECULOS_FIRMWARE_VERSION;
   let apps = appCandidates.filter(c => appCandidatesMatches(c, search));
   if (apps.length === 0) {
     return null;

package/src/modularDrawer/hooks/__test__/useAssetAccountCounts.test.ts

@@ -0,0 +1,40 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { useAssetAccountCounts } from "../useAssetAccountCounts";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+
+const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
+const ethereumAccountHigh = genAccount("ethereum-account-high", {
+  currency: ethereumCurrency,
+});
+
+describe("useAssetAccountCounts", () => {
+  it("should return the count for one account", () => {
+    const assetAccountCounts = useAssetAccountCounts({
+      assets: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh],
+      accountIds: new Map([[ethereumAccountHigh.id, true]]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(1);
+    expect(assetAccountCounts[0].label).toBe("1");
+  });
+
+  it("should return the count for two accounts on ethereum", () => {
+    const ethereumAccountLow = genAccount("ethereum-account-low", {
+      currency: ethereumCurrency,
+    });
+    const assetAccountCounts = useAssetAccountCounts({
+      assets: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh, ethereumAccountLow],
+      accountIds: new Map([
+        [ethereumAccountHigh.id, true],
+        [ethereumAccountLow.id, true],
+      ]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(2);
+    expect(assetAccountCounts[0].label).toBe("2");
+  });
+});

package/src/modularDrawer/hooks/__test__/useCurrenciesUnderFeatureFlag.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useCurrenciesUnderFeatureFlag } from "../useCurrenciesUnderFeatureFlag";
+import { useFeature } from "../../../featureFlags";
+import useEnv from "../../../hooks/useEnv";
+
+jest.mock("../../../featureFlags", () => ({ useFeature: jest.fn() }));
+jest.mock("../../../hooks/useEnv", () => jest.fn());
+
+const mockUseFeature = jest.mocked(useFeature);
+const mockedEnvironment = jest.mocked(useEnv);
+
+describe("useCurrenciesUnderFeatureFlag", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return empty deactivatedCurrencyIds when all features are enabled", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toEqual(0);
+    expect(result.current.featureFlaggedCurrencies).toBeDefined();
+  });
+
+  it("should include disabled currencies in deactivatedCurrencyIds", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBeGreaterThan(0);
+  });
+
+  it("should return empty deactivatedCurrencyIds when MOCK is true", () => {
+    mockedEnvironment.mockReturnValue(true);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBe(0);
+  });
+
+  it("should contain currency mappings", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    const currencies = result.current.featureFlaggedCurrencies;
+    expect(currencies).toHaveProperty("aptos");
+    expect(currencies).toHaveProperty("stacks");
+    expect(currencies).toHaveProperty("optimism");
+  });
+});