@ledgerhq/live-common 34.50.0-nightly.1 → 34.50.0-nightly.3

package/src/e2e/enum/Account.ts

@@ -110,6 +110,12 @@ export class Account {
     "0xa1baa625c5E6A9304cB7AcD86d2fee6B710eC3eB",
     1,
   );
+  static readonly BSC_POL = new Account(
+    Currency.BSC_POL,
+    "BNB Chain 1",
+    "0x4BE2E2B8872AA298D6d123b9211B53E41f611566",
+    0,
+  );
   static readonly BSC_SHIBA = new Account(
     Currency.BSC_SHIBA,
     "BNB Chain 1",
@@ -242,6 +248,8 @@ export class Account {
     undefined,
     [Nft.ANTITUS, Nft.PODIUM, Nft.NY_LA_MUSE],
   );
+  // don't use this account as a recipient, it's balance
+  // should stay close to null to allow for error message testing
   static readonly ETH_2 = new Account(
     Currency.ETH,
     "Ethereum 2",
@@ -276,6 +284,8 @@ export class Account {
     0,
   );
 
+  static readonly HEDERA_1 = new Account(Currency.HBAR, "Hedera 1", "0.0.9374930", 0);
+
   static readonly INJ_1 = new Account(
     Currency.INJ,
     "Injective 1",
@@ -516,6 +526,19 @@ export class Account {
     1,
   );
 
+  static readonly SUI_1 = new Account(
+    Currency.SUI,
+    "Sui 1",
+    "0xc6169bcce8718609e43d179b087e6c1e2ac28e5325660af34d22fb5ce284031e",
+    0,
+  );
+  static readonly SUI_2 = new Account(
+    Currency.SUI,
+    "Sui 2",
+    "0x6644c1ce77c5e5ef8d8bd3ae2a4e18239e5d418a5e0800ed5037818399e3a7f6",
+    1,
+  );
+
   static readonly EMPTY = new Account(Currency.BTC, "Empty", "", 0);
 }
 
@@ -630,6 +653,24 @@ export class TokenAccount extends Account {
     TokenType.TRC20,
     Account.TRX_1,
   );
+
+  static readonly SUI_USDC_1 = new TokenAccount(
+    Currency.SUI_USDC,
+    "SUI USDC 1",
+    Account.SUI_1.address,
+    0,
+    TokenType.ERC20,
+    Account.SUI_1,
+  );
+
+  static readonly SUI_USDC_2 = new TokenAccount(
+    Currency.SUI_USDC,
+    "SUI USDC 2",
+    Account.SUI_2.address,
+    1,
+    TokenType.ERC20,
+    Account.SUI_2,
+  );
 }
 
 export type AccountType = Account | TokenAccount;

package/src/e2e/enum/AppInfos.ts

@@ -33,6 +33,8 @@ export class AppInfos {
 
   static readonly STELLAR = new AppInfos("Stellar");
 
+  static readonly SUI = new AppInfos("Sui");
+
   static readonly BITCOIN_CASH = new AppInfos("Bitcoin Cash");
 
   static readonly ALGORAND = new AppInfos("Algorand");
@@ -62,4 +64,6 @@ export class AppInfos {
   static readonly LTC = new AppInfos("Litecoin");
 
   static readonly KASPA = new AppInfos("Kaspa");
+
+  static readonly HEDERA = new AppInfos("Hedera");
 }

package/src/e2e/enum/Currency.ts

@@ -27,6 +27,10 @@ export class Currency {
 
   static readonly KAS = new Currency("Kaspa", "KAS", "kaspa", AppInfos.KASPA, [Network.KASPA]);
 
+  static readonly HBAR = new Currency("Hedera", "HBAR", "hedera", AppInfos.HEDERA, [
+    Network.HEDERA,
+  ]);
+
   static readonly tBTC = new Currency(
     "Bitcoin Testnet",
     "𝚝BTC",
@@ -79,6 +83,7 @@ export class Currency {
   static readonly XLM = new Currency("Stellar", "XLM", "stellar", AppInfos.STELLAR, [
     Network.STELLAR,
   ]);
+  static readonly SUI = new Currency("Sui", "SUI", "sui", AppInfos.SUI, [Network.SUI]);
   static readonly BCH = new Currency("Bitcoin Cash", "BCH", "bitcoin_cash", AppInfos.BITCOIN_CASH, [
     Network.BITCOIN_CASH,
   ]);
@@ -152,6 +157,13 @@ export class Currency {
     AppInfos.BNB_CHAIN,
     [Network.BNB_CHAIN, Network.POLYGON],
   );
+  static readonly BSC_POL = new Currency(
+    "Matic Token",
+    "MATIC",
+    "bsc/bep20/matic_token",
+    AppInfos.BNB_CHAIN,
+    [Network.BNB_CHAIN],
+  );
   static readonly BSC_SHIBA = new Currency("Shiba Inu", "SHIB", "bsc", AppInfos.BNB_CHAIN, [
     Network.BNB_CHAIN,
     Network.ETHEREUM,
@@ -196,4 +208,13 @@ export class Currency {
   static readonly OP = new Currency("OP Mainnet", "OP", "optimism", AppInfos.ETHEREUM, [
     Network.OPTIMISM,
   ]);
+
+  static readonly SUI_USDC = new Currency(
+    "USDC",
+    "USDC",
+    "sui/coin/usdc_0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::usdc",
+    AppInfos.SUI,
+    [Network.SUI],
+    "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7",
+  );
 }

package/src/e2e/enum/Network.ts

@@ -16,6 +16,7 @@ export enum Network {
   XRP = "XRP",
   CARDANO = "Cardano",
   STELLAR = "Stellar",
+  SUI = "Sui",
   BITCOIN_CASH = "Bitcoin Cash",
   ALGORAND = "Algorand",
   COSMOS = "Cosmos",
@@ -32,4 +33,5 @@ export enum Network {
   MULTIVERS_X = "MultiversX",
   LITECOIN = "Litecoin",
   KASPA = "Kaspa",
+  HEDERA = "Hedera",
 }

package/src/e2e/enum/TokenType.ts

@@ -2,4 +2,5 @@ export enum TokenType {
   ERC20 = "erc20",
   TRC20 = "trc20",
   SPL = "spl",
+  SUI = "sui",
 }

package/src/e2e/enum/TransactionStatus.ts

@@ -2,8 +2,11 @@ export enum TransactionStatus {
   RECEIVED = "Received",
   DELEGATED = "Delegated",
   NFT_RECEIVED = "NFT Received",
+  SEND = "Send",
   SENT = "Sent",
   FEES = "Fees",
   STAKED = "Staked",
   SENDING = "Sending",
+  TRANSACTION_SENT = "Transaction sent",
+  CONFIRMED = "Confirmed",
 }

package/src/e2e/families/hedera.ts

@@ -0,0 +1,7 @@
+import { pressBoth, pressUntilTextFound } from "../speculos";
+import { DeviceLabels } from "../enum/DeviceLabels";
+
+export async function sendHedera() {
+  await pressUntilTextFound(DeviceLabels.APPROVE);
+  await pressBoth();
+}

package/src/e2e/families/sui.ts

@@ -0,0 +1,7 @@
+import { pressBoth, pressUntilTextFound } from "../speculos";
+import { DeviceLabels } from "../enum/DeviceLabels";
+
+export async function sendSui() {
+  await pressUntilTextFound(DeviceLabels.ACCEPT);
+  await pressBoth();
+}

package/src/e2e/speculos.ts

@@ -28,6 +28,7 @@ import { sendStellar } from "./families/stellar";
 import { delegateCardano, sendCardano } from "./families/cardano";
 import { sendXRP } from "./families/xrp";
 import { delegateAptos, sendAptos } from "./families/aptos";
+import { sendHedera } from "./families/hedera";
 import { delegateNear } from "./families/near";
 import { delegateCosmos, sendCosmos } from "./families/cosmos";
 import { sendKaspa } from "./families/kaspa";
@@ -41,6 +42,7 @@ import { Swap } from "./models/Swap";
 import { delegateOsmosis } from "./families/osmosis";
 import { AppInfos } from "./enum/AppInfos";
 import { DEVICE_LABELS_CONFIG } from "./data/deviceLabelsData";
+import { sendSui } from "./families/sui";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -222,6 +224,14 @@ export const specs: Specs = {
     },
     dependency: "",
   },
+  Sui: {
+    currency: getCryptoCurrencyById("sui"),
+    appQuery: {
+      model: getSpeculosModel(),
+      appName: "Sui",
+    },
+    dependency: "",
+  },
   Bitcoin_Cash: {
     currency: getCryptoCurrencyById("bitcoin_cash"),
     appQuery: {
@@ -335,6 +345,14 @@ export const specs: Specs = {
     },
     dependency: "",
   },
+  Hedera: {
+    currency: getCryptoCurrencyById("hedera"),
+    appQuery: {
+      model: getSpeculosModel(),
+      appName: "Hedera",
+    },
+    dependency: "",
+  },
 };
 
 export async function startSpeculos(
@@ -623,6 +641,10 @@ export async function goToSettings() {
   await pressBoth();
 }
 
+export async function providePublicKey() {
+  await pressRightButton();
+}
+
 type DeviceLabelsReturn = {
   delegateConfirmLabel: string;
   delegateVerifyLabel: string;
@@ -651,6 +673,9 @@ export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
 }
 
 export async function expectValidAddressDevice(account: Account, addressDisplayed: string) {
+  if (account.currency === Currency.SUI_USDC) {
+    providePublicKey();
+  }
   const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(account.currency.speculosApp);
 
   await waitFor(receiveVerifyLabel);
@@ -709,6 +734,15 @@ export async function signSendTransaction(tx: Transaction) {
     case Currency.KAS:
       await sendKaspa();
       break;
+    case Currency.HBAR:
+      await sendHedera();
+      break;
+    case Currency.SUI:
+      await sendSui();
+      break;
+    case Currency.SUI_USDC:
+      await sendSui();
+      break;
     default:
       throw new Error(`Unsupported currency: ${currencyName.ticker}`);
   }

package/src/exchange/platform/types.ts

@@ -1,3 +1,4 @@
+import type { DeviceModelId } from "@ledgerhq/devices";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, AccountLike, AccountRaw, AccountRawLike } from "@ledgerhq/types-live";
 import type { ExchangeTypes, RateTypes } from "@ledgerhq/hw-app-exchange";
@@ -42,6 +43,7 @@ export type StartExchangeInput = {
 
 interface CompleteExchangeInputCommon {
   rateType?: RateTypes;
+  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   binaryPayload: string;

package/src/exchange/swap/completeExchange.ts

@@ -1,3 +1,4 @@
+import type { Account } from "@ledgerhq/types-live";
 import {
   DisconnectedDeviceDuringOperation,
   TransportStatusError,
@@ -13,12 +14,14 @@ import {
 import { getDefaultAccountName } from "@ledgerhq/live-wallet/accountName";
 import { log } from "@ledgerhq/logs";
 import BigNumber from "bignumber.js";
+import invariant from "invariant";
 import { Observable } from "rxjs";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { getCurrencyExchangeConfig } from "../";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import { getAccountBridge } from "../../bridge";
 import { TransactionRefusedOnDevice } from "../../errors";
+import { handleHederaTrustedFlow } from "../../families/hedera/exchange";
 import { withDevicePromise } from "../../hw/deviceAccess";
 import { delay } from "../../promise";
 import { CompleteExchangeStep, convertTransportError } from "../error";
@@ -27,6 +30,7 @@ import { convertToAppExchangePartnerKey, getSwapProvider } from "../providers";
 import { CEXProviderConfig } from "../providers/swap";
 import { isAddressSanctioned } from "@ledgerhq/coin-framework/sanction/index";
 import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
+import { getCryptoCurrencyById } from "../../currencies";
 
 const COMPLETE_EXCHANGE_LOG = "SWAP-CompleteExchange";
 
@@ -34,8 +38,16 @@ const completeExchange = (
   input: CompleteExchangeInputSwap,
 ): Observable<CompleteExchangeRequestEvent> => {
   let { transaction } = input; // TODO build a tx from the data
-
-  const { deviceId, exchange, provider, binaryPayload, signature, rateType, exchangeType } = input;
+  const {
+    deviceId,
+    deviceModelId,
+    exchange,
+    provider,
+    binaryPayload,
+    signature,
+    rateType,
+    exchangeType,
+  } = input;
 
   const { fromAccount, fromParentAccount } = exchange;
   const { toAccount, toParentAccount } = exchange;
@@ -152,6 +164,24 @@ const completeExchange = (
         await exchange.checkTransactionSignature(goodSign);
         if (unsubscribed) return;
 
+        // Hedera swap payload is filled with user account address,
+        // but the device app requires the related public key for verification.
+        // Since this key is stored on-chain, we use the TrustedService
+        // to fetch a signed descriptor linking the address to its public key.
+        const hederaCurrency = getCryptoCurrencyById("hedera");
+        let hederaAccount: Account | null = null;
+        if (payoutAccount.currency.family === hederaCurrency.family) {
+          hederaAccount = payoutAccount;
+        } else if (refundAccount.currency.family === hederaCurrency.family) {
+          hederaAccount = refundAccount;
+        }
+
+        if (hederaAccount) {
+          invariant(deviceModelId, "hedera: deviceModelId is not available");
+          await handleHederaTrustedFlow({ exchange, hederaAccount, deviceModelId });
+          if (unsubscribed) return;
+        }
+
         const payoutAddressParameters = payoutAccountBridge.getSerializedAddressParameters(
           payoutAccount,
           mainPayoutCurrency.id,

package/src/exchange/swap/getIncompatibleCurrencyKeys.ts

@@ -59,6 +59,10 @@ const INCOMPATIBLE_NANO_S_CURRENCY_KEYS: Keys = {
     title: "swap.incompatibility.cosmos_title",
     description: "swap.incompatibility.cosmos_description",
   },
+  hedera: {
+    title: "swap.incompatibility.hedera_title",
+    description: "swap.incompatibility.hedera_description",
+  },
   osmo: {
     title: "swap.incompatibility.osmo_title",
     description: "swap.incompatibility.osmo_description",
@@ -71,6 +75,10 @@ const INCOMPATIBLE_NANO_S_CURRENCY_KEYS: Keys = {
     title: "swap.incompatibility.sui_title",
     description: "swap.incompatibility.sui_description",
   },
+  kaspa: {
+    title: "swap.incompatibility.kaspa_title",
+    description: "swap.incompatibility.kaspa_description",
+  },
 };
 
 export const getIncompatibleCurrencyKeys = (exchange: ExchangeSwap) => {

package/src/families/hedera/exchange.ts

@@ -0,0 +1,48 @@
+import { LatestFirmwareVersionRequired, TransportStatusError } from "@ledgerhq/errors";
+import Exchange from "@ledgerhq/hw-app-exchange";
+import { loadPKI } from "@ledgerhq/hw-bolos";
+import calService from "@ledgerhq/ledger-cal-service";
+import trustService from "@ledgerhq/ledger-trust-service";
+import { getEnv } from "@ledgerhq/live-env";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { Account } from "@ledgerhq/types-live";
+
+function isPKIUnsupportedError(err: unknown): err is TransportStatusError {
+  return err instanceof TransportStatusError && err.message.includes("0x6a81");
+}
+
+export async function handleHederaTrustedFlow({
+  exchange,
+  hederaAccount,
+  deviceModelId,
+}: {
+  exchange: Exchange;
+  hederaAccount: Account;
+  deviceModelId: DeviceModelId;
+}) {
+  const serviceEnv = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
+
+  const cert = await calService.getCertificate(deviceModelId, "trusted_name", "latest", {
+    env: serviceEnv,
+    signatureKind: serviceEnv,
+  });
+
+  try {
+    await loadPKI(exchange.transport, "TRUSTED_NAME", cert.descriptor, cert.signature);
+  } catch (err) {
+    if (isPKIUnsupportedError(err)) {
+      throw new LatestFirmwareVersionRequired("LatestFirmwareVersionRequired");
+    }
+  }
+
+  const challenge = await exchange.getChallenge();
+  const hexChallenge = challenge.toString(16);
+
+  const trustServiceResult = await trustService.hedera.getPublicKey(
+    hederaAccount.freshAddress,
+    hexChallenge,
+  );
+  const signedDescriptorBuffer = Buffer.from(trustServiceResult.signedDescriptor, "hex");
+
+  await exchange.sendTrustedDescriptor(signedDescriptorBuffer);
+}

package/src/hw/actions/completeExchange.ts

@@ -3,6 +3,7 @@ import { scan, tap } from "rxjs/operators";
 import { useEffect, useState } from "react";
 import type { Action, Device } from "./types";
 import type { AppState } from "./app";
+import type { DeviceModelId } from "@ledgerhq/devices";
 import { log } from "@ledgerhq/logs";
 import { Exchange } from "../../exchange/types";
 import { Transaction } from "../../generated/types";
@@ -18,6 +19,7 @@ type State = {
 
 type CompleteExchangeState = AppState & State;
 type CompleteExchangeRequest = {
+  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   transaction: Transaction;
@@ -130,6 +132,7 @@ export const createAction = (
         }),
         completeExchangeExec({
           deviceId: reduxDeviceFrozen?.deviceId,
+          deviceModelId: reduxDeviceFrozen?.modelId,
           provider,
           transaction,
           binaryPayload,

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -0,0 +1,231 @@
+import { useMemo } from "react";
+import { CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
+import { Feature } from "@ledgerhq/types-live";
+import { useFeature } from "../../featureFlags";
+import useEnv from "../../hooks/useEnv";
+
+export function useCurrenciesUnderFeatureFlag() {
+  const mock = useEnv("MOCK");
+
+  const aptos = useFeature("currencyAptos");
+  const aptosTestnet = useFeature("currencyAptosTestnet");
+  const axelar = useFeature("currencyAxelar");
+  const stargaze = useFeature("currencyStargaze");
+  const secretNetwork = useFeature("currencySecretNetwork");
+  const umee = useFeature("currencyUmee");
+  const desmos = useFeature("currencyDesmos");
+  const dydx = useFeature("currencyDydx");
+  const onomy = useFeature("currencyOnomy");
+  const seiNetwork = useFeature("currencySeiNetwork");
+  const quicksilver = useFeature("currencyQuicksilver");
+  const persistence = useFeature("currencyPersistence");
+  const avaxCChain = useFeature("currencyAvalancheCChain");
+  const stacks = useFeature("currencyStacks");
+  const optimism = useFeature("currencyOptimism");
+  const optimismSepolia = useFeature("currencyOptimismSepolia");
+  const arbitrum = useFeature("currencyArbitrum");
+  const arbitrumSepolia = useFeature("currencyArbitrumSepolia");
+  const rsk = useFeature("currencyRsk");
+  const bittorrent = useFeature("currencyBittorrent");
+  const energyWeb = useFeature("currencyEnergyWeb");
+  const astar = useFeature("currencyAstar");
+  const metis = useFeature("currencyMetis");
+  const boba = useFeature("currencyBoba");
+  const moonriver = useFeature("currencyMoonriver");
+  const velasEvm = useFeature("currencyVelasEvm");
+  const syscoin = useFeature("currencySyscoin");
+  const internetComputer = useFeature("currencyInternetComputer");
+  const telosEvm = useFeature("currencyTelosEvm");
+  const coreum = useFeature("currencyCoreum");
+  const polygonZkEvm = useFeature("currencyPolygonZkEvm");
+  const polygonZkEvmTestnet = useFeature("currencyPolygonZkEvmTestnet");
+  const base = useFeature("currencyBase");
+  const baseSepolia = useFeature("currencyBaseSepolia");
+  const klaytn = useFeature("currencyKlaytn");
+  const injective = useFeature("currencyInjective");
+  const vechain = useFeature("currencyVechain");
+  const casper = useFeature("currencyCasper");
+  const neonEvm = useFeature("currencyNeonEvm");
+  const lukso = useFeature("currencyLukso");
+  const linea = useFeature("currencyLinea");
+  const lineaSepolia = useFeature("currencyLineaSepolia");
+  const blast = useFeature("currencyBlast");
+  const blastSepolia = useFeature("currencyBlastSepolia");
+  const scroll = useFeature("currencyScroll");
+  const scrollSepolia = useFeature("currencyScrollSepolia");
+  const icon = useFeature("currencyIcon");
+  const ton = useFeature("currencyTon");
+  const etherlink = useFeature("currencyEtherlink");
+  const zksync = useFeature("currencyZkSync");
+  const zksyncSepolia = useFeature("currencyZkSyncSepolia");
+  const mantra = useFeature("currencyMantra");
+  const xion = useFeature("currencyXion");
+  const zenrock = useFeature("currencyZenrock");
+  const sonic = useFeature("currencySonic");
+  const sonicBlaze = useFeature("currencySonicBlaze");
+  const sui = useFeature("currencySui");
+  const mina = useFeature("currencyMina");
+  const babylon = useFeature("currencyBabylon");
+  const seiNetworkEvm = useFeature("currencySeiNetworkEvm");
+  const berachain = useFeature("currencyBerachain");
+  const hyperevm = useFeature("currencyHyperevm");
+  const canton = useFeature("currencyCantonNetwork");
+  const kaspa = useFeature("currencyKaspa");
+  const core = useFeature("currencyCore");
+  const ethereumHoodi = useFeature("currencyEthereumHoodi");
+
+  const featureFlaggedCurrencies = useMemo(
+    (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
+      aptos,
+      aptos_testnet: aptosTestnet,
+      axelar,
+      stargaze,
+      secret_network: secretNetwork,
+      umee,
+      desmos,
+      dydx,
+      onomy,
+      sei_network: seiNetwork,
+      quicksilver,
+      persistence,
+      avalanche_c_chain: avaxCChain,
+      stacks,
+      optimism,
+      optimism_sepolia: optimismSepolia,
+      arbitrum,
+      arbitrum_sepolia: arbitrumSepolia,
+      rsk,
+      bittorrent,
+      energy_web: energyWeb,
+      astar,
+      metis,
+      boba,
+      moonriver,
+      velas_evm: velasEvm,
+      syscoin,
+      internet_computer: internetComputer,
+      telos_evm: telosEvm,
+      sei_network_evm: seiNetworkEvm,
+      berachain: berachain,
+      hyperevm: hyperevm,
+      coreum,
+      polygon_zk_evm: polygonZkEvm,
+      polygon_zk_evm_testnet: polygonZkEvmTestnet,
+      base,
+      base_sepolia: baseSepolia,
+      klaytn,
+      injective,
+      vechain,
+      casper,
+      neon_evm: neonEvm,
+      lukso,
+      linea,
+      ton,
+      linea_sepolia: lineaSepolia,
+      blast,
+      blast_sepolia: blastSepolia,
+      scroll,
+      scroll_sepolia: scrollSepolia,
+      icon,
+      etherlink,
+      zksync,
+      zksync_sepolia: zksyncSepolia,
+      mantra,
+      xion,
+      zenrock,
+      sonic,
+      sonic_blaze: sonicBlaze,
+      sui,
+      mina,
+      babylon,
+      canton_network: canton,
+      kaspa,
+      core,
+      ethereum_hoodi: ethereumHoodi,
+    }),
+    [
+      aptos,
+      aptosTestnet,
+      axelar,
+      stargaze,
+      secretNetwork,
+      umee,
+      desmos,
+      dydx,
+      onomy,
+      seiNetwork,
+      quicksilver,
+      persistence,
+      avaxCChain,
+      stacks,
+      optimism,
+      optimismSepolia,
+      arbitrum,
+      arbitrumSepolia,
+      rsk,
+      bittorrent,
+      energyWeb,
+      astar,
+      metis,
+      boba,
+      moonriver,
+      velasEvm,
+      syscoin,
+      internetComputer,
+      telosEvm,
+      seiNetworkEvm,
+      berachain,
+      hyperevm,
+      coreum,
+      polygonZkEvm,
+      polygonZkEvmTestnet,
+      base,
+      baseSepolia,
+      klaytn,
+      injective,
+      vechain,
+      casper,
+      neonEvm,
+      lukso,
+      linea,
+      ton,
+      lineaSepolia,
+      blast,
+      blastSepolia,
+      scroll,
+      scrollSepolia,
+      icon,
+      etherlink,
+      zksync,
+      zksyncSepolia,
+      mantra,
+      xion,
+      zenrock,
+      sonic,
+      sonicBlaze,
+      sui,
+      mina,
+      babylon,
+      canton,
+      kaspa,
+      core,
+      ethereumHoodi,
+    ],
+  );
+
+  const deactivatedCurrencyIds = useMemo(
+    () =>
+      new Set(
+        mock
+          ? [] // mock mode: all currencies are available for playwrigth tests
+          : Object.entries(featureFlaggedCurrencies)
+              .filter(([, feature]) => !feature?.enabled)
+              .map(([id]) => id),
+      ),
+    [mock, featureFlaggedCurrencies],
+  );
+  return {
+    featureFlaggedCurrencies,
+    deactivatedCurrencyIds,
+  };
+}