@ledgerhq/live-common 34.42.1 → 34.43.0-nightly.1

package/src/bridge/impl.ts

@@ -20,6 +20,9 @@ import {
 import { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
 import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
 import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
 
 const alpacaized = {
   xrp: true,
@@ -100,6 +103,11 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
   return wrapAccountBridge(jsBridge.accountBridge);
 }
 
+export function setup(store: CryptoAssetsStore) {
+  setCryptoAssetsStore(store);
+  setCryptoAssetsStoreForCoinFramework(getCryptoAssetsStore());
+}
+
 function wrapAccountBridge<T extends TransactionCommon>(
   bridge: AccountBridge<T>,
 ): AccountBridge<T> {

package/src/bridge/useBridgeTransaction.test.ts

@@ -11,7 +11,7 @@ import useBridgeTransaction, {
   getGlobalOnBridgeError,
 } from "./useBridgeTransaction";
 import { setSupportedCurrencies } from "../currencies";
-import { LiveConfig } from "@ledgerhq/live-config/lib/LiveConfig";
+import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 
 const BTC = getCryptoCurrencyById("bitcoin");
 

package/src/e2e/families/osmosis.ts

@@ -0,0 +1,13 @@
+import { Delegate } from "../models/Delegate";
+import { containsSubstringInEvent, pressBoth, pressUntilTextFound, waitFor } from "../speculos";
+import { DeviceLabels } from "../enum/DeviceLabels";
+import expect from "expect";
+
+export async function delegateOsmosis(delegatingAccount: Delegate) {
+  await waitFor(DeviceLabels.PLEASE_REVIEW);
+  const events = await pressUntilTextFound(DeviceLabels.CAPS_APPROVE);
+  const amountInUosmo = (Number(delegatingAccount.amount) * 1_000_000).toString();
+  const isAmountCorrect = containsSubstringInEvent(amountInUosmo, events);
+  expect(isAmountCorrect).toBeTruthy();
+  await pressBoth();
+}

package/src/e2e/speculos.ts

@@ -11,7 +11,7 @@ import { createSpeculosDeviceCI, releaseSpeculosDeviceCI } from "./speculosCI";
 import type { AppCandidate } from "@ledgerhq/coin-framework/bot/types";
 import { DeviceModelId } from "@ledgerhq/devices";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
-import axios from "axios";
+import axios, { AxiosError, AxiosResponse } from "axios";
 import { getEnv } from "@ledgerhq/live-env";
 import { getCryptoCurrencyById } from "../currencies";
 import { DeviceLabels } from "../e2e/enum/DeviceLabels";
@@ -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,13 +415,59 @@ interface ResponseData {
   events: Event[];
 }
 
-export async function waitFor(text: string, maxAttempts = 10): Promise<string[]> {
+function getSpeculosAddress(): string {
+  const speculosAddress = process.env.SPECULOS_ADDRESS;
+  return speculosAddress || "http://127.0.0.1";
+}
+
+async function retryAxiosRequest<T>(
+  requestFn: () => Promise<AxiosResponse<T>>,
+  maxRetries: number = 5,
+  baseDelay: number = 1000,
+  retryableStatusCodes: number[] = [500, 502, 503, 504],
+): Promise<AxiosResponse<T>> {
+  let lastError: AxiosError | Error;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await requestFn();
+    } catch (error) {
+      lastError = error as AxiosError | Error;
+
+      const isRetryable =
+        axios.isAxiosError(error) &&
+        error.response &&
+        retryableStatusCodes.includes(error.response.status);
+
+      const isNetworkError = axios.isAxiosError(error) && !error.response;
+
+      if ((isRetryable || isNetworkError) && attempt < maxRetries) {
+        const delay = baseDelay * (attempt + 1);
+        console.warn(
+          `Axios request failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...`,
+          {
+            status: axios.isAxiosError(error) ? error.response?.status : "network error",
+            message: error.message,
+          },
+        );
+        await new Promise(resolve => setTimeout(resolve, delay));
+        continue;
+      }
+
+      throw lastError;
+    }
+  }
+
+  throw lastError!;
+}
+
+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 address = getSpeculosAddress();
   const url = `${address}:${port}/events?stream=false&currentscreenonly=true`;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const { data } = await axios.get<ResponseData>(url);
+    const { data } = await retryAxiosRequest(() => axios.get<ResponseData>(url));
     const texts = data.events.map(event => event.text);
 
     if (texts?.some(t => t?.toLowerCase().includes(text.toLowerCase()))) {
@@ -435,10 +482,12 @@ export async function waitFor(text: string, maxAttempts = 10): Promise<string[]>
 
 export async function pressBoth() {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
-  await axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
-    action: "press-and-release",
-  });
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
+      action: "press-and-release",
+    }),
+  );
 }
 
 export async function pressUntilTextFound(
@@ -464,27 +513,33 @@ export async function pressUntilTextFound(
 }
 
 async function fetchCurrentScreenTexts(speculosApiPort: number): Promise<string> {
-  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
-  const response = await axios.get<ResponseData>(
-    `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
+  const speculosAddress = getSpeculosAddress();
+  const response = await retryAxiosRequest(() =>
+    axios.get<ResponseData>(
+      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=true`,
+    ),
   );
   return response.data.events.map(event => event.text).join("");
 }
 
 async function fetchAllEvents(speculosApiPort: number): Promise<string[]> {
-  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
-  const response = await axios.get<ResponseData>(
-    `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=false`,
+  const speculosAddress = getSpeculosAddress();
+  const response = await retryAxiosRequest(() =>
+    axios.get<ResponseData>(
+      `${speculosAddress}:${speculosApiPort}/events?stream=false&currentscreenonly=false`,
+    ),
   );
   return response.data.events.map(event => event.text);
 }
 
 export async function pressRightButton(): Promise<void> {
   const speculosApiPort = getEnv("SPECULOS_API_PORT");
-  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
-  await axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
-    action: "press-and-release",
-  });
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
+      action: "press-and-release",
+    }),
+  );
 }
 
 export function containsSubstringInEvent(targetString: string, events: string[]): boolean {
@@ -502,12 +557,14 @@ export function containsSubstringInEvent(targetString: string, events: string[])
 }
 
 export async function takeScreenshot(port?: number): Promise<Buffer | undefined> {
-  const speculosAddress = process.env.SPECULOS_ADDRESS || "http://127.0.0.1";
+  const speculosAddress = getSpeculosAddress();
   const speculosApiPort = port ?? getEnv("SPECULOS_API_PORT");
   try {
-    const response = await axios.get(`${speculosAddress}:${speculosApiPort}/screenshot`, {
-      responseType: "arraybuffer",
-    });
+    const response = await retryAxiosRequest(() =>
+      axios.get(`${speculosAddress}:${speculosApiPort}/screenshot`, {
+        responseType: "arraybuffer",
+      }),
+    );
     return response.data;
   } catch (error) {
     console.error("Error downloading speculos screenshot:", error);
@@ -656,9 +713,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/e2e/speculosCI.ts

@@ -61,22 +61,44 @@ async function githubApiRequest<T = unknown>({
 function waitForSpeculosReady(url: string, { interval = 2000, timeout = 300_000 } = {}) {
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
+    let currentRequest: ReturnType<typeof https.get> | null = null;
+
+    function cleanup() {
+      if (currentRequest) {
+        currentRequest.destroy();
+        currentRequest = null;
+      }
+    }
 
     function check() {
-      https
-        .get(url, res => {
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
-            process.env.SPECULOS_ADDRESS = url;
-            resolve(true);
-          } else {
-            retry();
-          }
-        })
-        .on("error", retry);
+      cleanup();
+
+      currentRequest = https.get(url, { timeout: 10000 }, res => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 400) {
+          process.env.SPECULOS_ADDRESS = url;
+          cleanup();
+          console.warn(`Speculos is ready at ${url}`);
+          resolve(true);
+        } else {
+          console.warn(`Speculos not ready yet, status: ${res.statusCode}`);
+          retry();
+        }
+      });
+
+      currentRequest.on("error", error => {
+        console.error(`Request error: ${error.message}`);
+        retry();
+      });
+
+      currentRequest.on("timeout", () => {
+        console.error("Request timeout");
+        retry();
+      });
     }
 
     function retry() {
       if (Date.now() - startTime >= timeout) {
+        cleanup();
         reject(new Error(`Timeout: ${url} did not become available within ${timeout}ms`));
       } else {
         setTimeout(check, interval);

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