@ledgerhq/live-common 34.42.0 → 34.42.2-nightly.0

package/src/e2e/speculos.ts

@@ -38,6 +38,7 @@ import { delegateMultiversX } from "./families/multiversX";
 import { NFTTransaction, Transaction } from "./models/Transaction";
 import { Delegate } from "./models/Delegate";
 import { Swap } from "./models/Swap";
+import { delegateOsmosis } from "./families/osmosis";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -414,7 +415,7 @@ interface ResponseData {
   events: Event[];
 }
 
-export async function waitFor(text: string, maxAttempts = 10): Promise<string[]> {
+export async function waitFor(text: string, maxAttempts = 15): Promise<string[]> {
   const port = getEnv("SPECULOS_API_PORT");
   const address = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
   const url = `${address}:${port}/events?stream=false&currentscreenonly=true`;
@@ -656,9 +657,11 @@ export async function signDelegationTransaction(delegatingAccount: Delegate) {
       break;
     case Account.ATOM_1.currency.name:
     case Account.INJ_1.currency.name:
-    case Account.OSMO_1.currency.name:
       await delegateCosmos(delegatingAccount);
       break;
+    case Account.OSMO_1.currency.name:
+      await delegateOsmosis(delegatingAccount);
+      break;
     case Account.MULTIVERS_X_1.currency.name:
       await delegateMultiversX();
       break;

package/src/exchange/error.ts

@@ -13,10 +13,12 @@ export type CompleteExchangeStep =
 
 export class CompleteExchangeError extends Error {
   step: CompleteExchangeStep;
+  title?: string;
 
-  constructor(step: CompleteExchangeStep, message?: string) {
+  constructor(step: CompleteExchangeStep, title?: string, message?: string) {
     super(message);
     this.name = "CompleteExchangeError";
+    this.title = title;
     this.step = step;
   }
 }
@@ -26,8 +28,8 @@ export function convertTransportError(
   err: unknown,
 ): CompleteExchangeError | unknown {
   if (err instanceof TransportStatusError) {
-    const errorMessage = getExchangeErrorMessage(err.statusCode, step);
-    return new CompleteExchangeError(step, errorMessage);
+    const { errorName, errorMessage } = getExchangeErrorMessage(err.statusCode, step);
+    return new CompleteExchangeError(step, errorName, errorMessage);
   }
   return err;
 }

package/src/exchange/swap/completeExchange.ts

@@ -175,7 +175,7 @@ const completeExchange = (
         } catch (e) {
           if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
             throw new WrongDeviceForAccountPayout(
-              getExchangeErrorMessage(e.statusCode, currentStep),
+              getExchangeErrorMessage(e.statusCode, currentStep).errorMessage,
               {
                 accountName: getDefaultAccountName(payoutAccount),
               },
@@ -217,7 +217,7 @@ const completeExchange = (
           if (e instanceof TransportStatusError && e.statusCode === 0x6a83) {
             log(COMPLETE_EXCHANGE_LOG, "transport error");
             throw new WrongDeviceForAccountRefund(
-              getExchangeErrorMessage(e.statusCode, currentStep),
+              getExchangeErrorMessage(e.statusCode, currentStep).errorMessage,
               {
                 accountName: getDefaultAccountName(refundAccount),
               },

package/src/families/evm/config.ts

@@ -612,6 +612,57 @@ const evmConfig: CurrencyLiveConfigDefinition = {
       showNfts: false,
     },
   },
+  config_currency_sei_network_evm: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      node: {
+        type: "external",
+        uri: "https://sei-evm-rpc.publicnode.com",
+      },
+      explorer: {
+        type: "etherscan",
+        uri: "https://proxyetherscan.api.live.ledger.com/v2/api/1329",
+      },
+      showNfts: false,
+    },
+  },
+  config_currency_berachain: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      node: {
+        type: "external",
+        uri: "https://rpc.berachain.com",
+      },
+      explorer: {
+        type: "etherscan",
+        uri: "https://proxyetherscan.api.live.ledger.com/v2/api/80094",
+      },
+      showNfts: false,
+    },
+  },
+  config_currency_hyperevm: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+      node: {
+        type: "external",
+        uri: "https://rpc.hypurrscan.io",
+      },
+      explorer: {
+        type: "etherscan",
+        uri: "https://proxyetherscan.api.live.ledger.com/v2/api/999",
+      },
+      showNfts: false,
+    },
+  },
   config_currency_polygon_zk_evm: {
     type: "object",
     default: {

package/src/families/evm/walletApiAdapter.ts

@@ -48,7 +48,7 @@ const convertToLiveTransaction: ConvertToLiveTransaction<
 
   /**
    * We explicitly set unrelated type specific fields to undefined to avoid transaction
-   * type assertion errors during the `prepareTransaction` logic (libs/coin-evm/src/prepareTransaction.ts)
+   * type assertion errors during the `prepareTransaction` logic (libs/coin-modules/coin-evm/src/bridge/prepareTransaction.ts)
    * when performing an `updateTransaction` with a newly created tx
    * Which is what happen in this case (in apps/ledger-live-desktop/src/renderer/modals/SignTransaction/Body.tsx):
       // `createTransaction` will create a type 2 tx by default with `maxFeePerGas` and `maxPriorityFeePerGas` set to 0

package/src/featureFlags/defaultFeatures.ts

@@ -92,6 +92,9 @@ export const CURRENCY_DEFAULT_FEATURES = {
   currencySui: DEFAULT_FEATURE,
   currencyMina: DEFAULT_FEATURE,
   currencyBabylon: DEFAULT_FEATURE,
+  currencySeiNetworkEvm: DEFAULT_FEATURE,
+  currencyBerachain: DEFAULT_FEATURE,
+  currencyHyperevm: DEFAULT_FEATURE,
 };
 
 /**
@@ -619,6 +622,7 @@ export const DEFAULT_FEATURES: Features = {
       enableModularization: false,
     },
   },
+  lldModularDrawerBackendData: DEFAULT_FEATURE,
   llmModularDrawer: {
     ...DEFAULT_FEATURE,
     params: {

package/src/modularDrawer/__mocks__/currencies.mock.ts

@@ -0,0 +1,62 @@
+import { getCryptoCurrencyById } from "@ledgerhq/live-common/currencies/index";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+export const mockBtcCryptoCurrency = getCryptoCurrencyById("bitcoin");
+export const mockEthCryptoCurrency = getCryptoCurrencyById("ethereum");
+export const mockArbitrumCryptoCurrency = getCryptoCurrencyById("arbitrum");
+export const mockBaseCryptoCurrency = getCryptoCurrencyById("base");
+export const mockScrollCryptoCurrency = getCryptoCurrencyById("scroll");
+export const mockInjectiveCryptoCurrency = getCryptoCurrencyById("injective");
+
+export const arbitrumToken: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "arbitrum/erc20/arbitrum",
+  contractAddress: "0x912CE59144191C1204E64559FE8253a0e49E6548",
+  parentCurrency: mockArbitrumCryptoCurrency,
+  tokenType: "erc20",
+  name: "Arbitrum",
+  ticker: "ARB",
+  units: [
+    {
+      name: "Arbitrum",
+      code: "ARB",
+      magnitude: 18,
+    },
+  ],
+};
+export const usdcToken: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/usd__coin",
+  contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  parentCurrency: mockEthCryptoCurrency,
+  tokenType: "erc20",
+  name: "USD Coin",
+  ticker: "USDC",
+  units: [
+    {
+      name: "USD Coin",
+      code: "USDC",
+      magnitude: 6,
+    },
+  ],
+};
+
+export const findCryptoCurrencyById = (id: string) =>
+  [mockBtcCryptoCurrency, mockEthCryptoCurrency, mockArbitrumCryptoCurrency].find(a => a.id === id);
+export const getTokenOrCryptoCurrencyById = (id: string) =>
+  [
+    mockBtcCryptoCurrency,
+    mockEthCryptoCurrency,
+    mockArbitrumCryptoCurrency,
+    arbitrumToken,
+    usdcToken,
+  ].find(a => a.id === id);
+
+export const mockCurrenciesByProvider = [
+  {
+    providerId: "ethereum",
+    currenciesByNetwork: [mockEthCryptoCurrency],
+  },
+];
+
+export const mockCurrencyIds = ["bitcoin", "ethereum", "arbitrum", "base"];

package/src/modularDrawer/__mocks__/useGroupedCurrenciesByProvider.mock.ts

@@ -0,0 +1,49 @@
+import { LoadingStatus } from "@ledgerhq/live-common/deposit/type";
+import {
+  arbitrumToken,
+  mockArbitrumCryptoCurrency,
+  mockBaseCryptoCurrency,
+  mockBtcCryptoCurrency,
+  mockEthCryptoCurrency,
+  mockInjectiveCryptoCurrency,
+  mockScrollCryptoCurrency,
+  usdcToken,
+} from "./currencies.mock";
+
+export const providers = [
+  {
+    providerId: "bitcoin",
+    currenciesByNetwork: [mockBtcCryptoCurrency],
+  },
+  {
+    providerId: "ethereum",
+    currenciesByNetwork: [
+      mockEthCryptoCurrency,
+      mockArbitrumCryptoCurrency,
+      mockBaseCryptoCurrency,
+      mockScrollCryptoCurrency,
+    ],
+  },
+  { providerId: "arbitrum", currenciesByNetwork: [arbitrumToken] },
+  { providerId: "usd-coin", currenciesByNetwork: [usdcToken] },
+  { providerId: "injective-protocol", currenciesByNetwork: [mockInjectiveCryptoCurrency] },
+];
+
+export const res = {
+  result: {
+    currenciesByProvider: providers,
+    sortedCryptoCurrencies: [
+      mockBtcCryptoCurrency,
+      mockEthCryptoCurrency,
+      mockArbitrumCryptoCurrency,
+      mockBaseCryptoCurrency,
+      mockScrollCryptoCurrency,
+      mockInjectiveCryptoCurrency,
+    ],
+  },
+};
+
+export const useGroupedCurrenciesByProvider: jest.Mock = jest.fn(() => ({
+  ...res,
+  loadingStatus: LoadingStatus.Success,
+}));

package/src/modularDrawer/utils/__tests__/haveOneCommonProvider.test.ts

@@ -0,0 +1,34 @@
+import { haveOneCommonProvider } from "../haveOneCommonProvider";
+import { useGroupedCurrenciesByProvider } from "../../__mocks__/useGroupedCurrenciesByProvider.mock";
+import { LoadingBasedGroupedCurrencies } from "@ledgerhq/live-common/deposit/type";
+
+jest.mock("@ledgerhq/live-common/deposit/useGroupedCurrenciesByProvider.hook", () => ({
+  useGroupedCurrenciesByProvider: () => useGroupedCurrenciesByProvider(),
+}));
+
+describe("haveOneCommonProvider", () => {
+  it("should return false for an empty array", () => {
+    expect(haveOneCommonProvider([], [])).toBe(false);
+  });
+
+  it("should return true for a single currency with one provider", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["bitcoin"], currenciesByProvider)).toBe(true);
+  });
+
+  it("should return false for multiple currencies with different providers", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["bitcoin", "ethereum"], currenciesByProvider)).toBe(false);
+  });
+
+  it("should return true for multiple currencies with the same provider", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["ethereum", "arbitrum"], currenciesByProvider)).toBe(true);
+  });
+});

package/src/modularDrawer/utils/haveOneCommonProvider.ts

@@ -0,0 +1,31 @@
+import { CurrenciesByProviderId } from "@ledgerhq/live-common/deposit/type";
+
+/**
+ * This function checks if all currencies in the provided array
+ * it stopped at the first currency that does not match to prevent unnecessary iterations.
+ *
+ * @param currenciesIdsArray array of currency IDs to check
+ * @param currenciesByProvider array of currencies grouped by provider
+ * @returns boolean indicating whether all currencies in the array have one common provider
+ */
+export const haveOneCommonProvider = (
+  currenciesIdsArray: string[],
+  currenciesByProvider: CurrenciesByProviderId[],
+): boolean => {
+  if (currenciesIdsArray.length === 0) return false;
+
+  const providerIds = new Set<string>();
+
+  for (const currencyId of currenciesIdsArray) {
+    for (const provider of currenciesByProvider) {
+      if (provider.currenciesByNetwork.some(currency => currency.id === currencyId)) {
+        providerIds.add(provider.providerId);
+        if (providerIds.size > 1) {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+};

package/src/modularDrawer/utils/index.ts

@@ -1,5 +1,6 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { CurrenciesByProviderId } from "../../deposit/type";
+import { haveOneCommonProvider } from "./haveOneCommonProvider";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,
@@ -26,4 +27,4 @@ const getEffectiveCurrency = (
   return provider.currenciesByNetwork.find(elem => currencyIds.includes(elem.id)) ?? currency;
 };
 
-export { isCorrespondingCurrency, getEffectiveCurrency };
+export { isCorrespondingCurrency, getEffectiveCurrency, haveOneCommonProvider };

package/src/wallet-api/Exchange/server.ts

@@ -51,6 +51,7 @@ import { getSwapStepFromError } from "../../exchange/error";
 import { postSwapCancelled } from "../../exchange/swap";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { setBroadcastTransaction } from "../../exchange/swap/setBroadcastTransaction";
+import { FAMILIES_MAPPING_LL_TO_WAPI } from "../constants";
 
 export { ExchangeType };
 
@@ -485,7 +486,9 @@ export const handlers = ({
       });
 
       const mainFromAccount = getMainAccount(fromAccount, fromParentAccount);
-      const mainFromAccountFamily = mainFromAccount.currency.family;
+      const mainFromAccountFamily =
+        FAMILIES_MAPPING_LL_TO_WAPI[mainFromAccount.currency.family] ||
+        mainFromAccount.currency.family;
 
       if (transaction.family !== mainFromAccountFamily) {
         return Promise.reject(
@@ -741,9 +744,7 @@ async function getStrategy(
   customErrorType?: any,
 ): Promise<Transaction> {
   const family =
-    currency.type === "TokenCurrency"
-      ? (currency.parentCurrency?.family as Transaction["family"])
-      : (currency.family as Transaction["family"]);
+    currency.type === "TokenCurrency" ? currency.parentCurrency?.family : currency.family;
 
   if (!family) {
     throw new Error(`TokenCurrency missing parentCurrency family: ${currency.id}`);
@@ -755,7 +756,7 @@ async function getStrategy(
   }
 
   // Normalize family key for strategy lookup
-  const familyKey = family === "evm" ? "ethereum" : family;
+  const familyKey = FAMILIES_MAPPING_LL_TO_WAPI[family] || family;
   const strategy = transactionStrategy?.[familyKey];
 
   if (!strategy) {
@@ -764,7 +765,7 @@ async function getStrategy(
 
   try {
     return await strategy({
-      family,
+      family: familyKey,
       amount,
       recipient,
       customFeeConfig: customFeeConfig || {},