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

package/src/bridge/generic-alpaca/getAccountShape.ts

@@ -2,7 +2,7 @@ import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
 import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
-import { adaptCoreOperationToLiveOperation } from "./utils";
+import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
 
 export function genericGetAccountShape(network: string, kind: "local" | "remote"): GetAccountShape {
   return async info => {
@@ -18,15 +18,14 @@ export function genericGetAccountShape(network: string, kind: "local" | "remote"
 
       const blockInfo = await getAlpacaApi(network, kind).lastBlock();
 
-      const balanceRes = await getAlpacaApi(network, kind).getBalance(address);
-      // FIXME: fix type Balance -> check "native" balance
-      // is balance[0] always the native ?
-      const balance = BigNumber(balanceRes[0].value.toString());
+      const balances = await getAlpacaApi(network, kind).getBalance(address);
+      const nativeBalance = extractBalance(balances, "native");
+      const balance = BigNumber(nativeBalance.value.toString());
 
       let spendableBalance: BigNumber;
-      if (balanceRes[0]?.locked) {
+      if (nativeBalance.locked) {
         spendableBalance = BigNumber.max(
-          balance.minus(BigNumber(balanceRes[0].locked.toString())),
+          balance.minus(BigNumber(nativeBalance.locked.toString())),
           BigNumber(0),
         );
       } else {

package/src/bridge/generic-alpaca/signOperation.ts

@@ -40,7 +40,7 @@ export const genericSignOperation =
           const transactionIntent = transactionToIntent(account, transaction);
           transactionIntent.senderPublicKey = publicKey;
           // NOTE: is setting the memo here instead of transactionToIntent sensible?
-          const txWithMemo = transactionIntent as TransactionIntent<any, MapMemo<string, string>>;
+          const txWithMemo = transactionIntent as TransactionIntent<MapMemo<string, string>>;
           if (transaction["tag"]) {
             const txMemo = String(transaction["tag"]);
             txWithMemo.memo = {

package/src/bridge/generic-alpaca/utils.test.ts

@@ -0,0 +1,19 @@
+import { extractBalance } from "./utils";
+
+describe("Alpaca utils", () => {
+  describe("extractBalance", () => {
+    it("extracts an existing balance", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({
+        value: 4n,
+        asset: { type: "type1" },
+      });
+    });
+
+    it("generates an empty balance for a missing type", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type2")).toEqual({
+        value: 0n,
+        asset: { type: "type2" },
+      });
+    });
+  });
+});

package/src/bridge/generic-alpaca/utils.ts

@@ -1,17 +1,18 @@
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { Account, Operation, OperationType, TransactionCommon } from "@ledgerhq/types-live";
 import {
+  Balance,
   Operation as CoreOperation,
-  Asset,
   TransactionIntent,
 } from "@ledgerhq/coin-framework/api/types";
 import BigNumber from "bignumber.js";
 import { fromBigNumberToBigInt } from "@ledgerhq/coin-framework/utils";
 
-export function adaptCoreOperationToLiveOperation(
-  accountId: string,
-  op: CoreOperation<Asset>,
-): Operation {
+export function extractBalance(balances: Balance[], type: string): Balance {
+  return balances.find(balance => balance.asset.type === type) ?? { asset: { type }, value: 0n };
+}
+
+export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOperation): Operation {
   return {
     id: encodeOperationId(accountId, op.tx.hash, op.type),
     hash: op.tx.hash,
@@ -38,7 +39,7 @@ export function transactionToIntent(
     sender: account.freshAddress,
     recipient: transaction.recipient,
     amount: fromBigNumberToBigInt(transaction.amount, BigInt(0)),
-    asset: null,
+    asset: { type: "native" },
   };
 }
 

package/src/currencies/sortByMarketcap.test.ts

@@ -2,6 +2,13 @@ import { sortCurrenciesByIds } from "./sortByMarketcap";
 import { findCurrencyByTicker, listCryptoCurrencies, listTokens } from ".";
 import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+setCryptoAssetsStoreForCoinFramework({
+  findTokenByTicker: (_: string) => undefined,
+} as CryptoAssetsStore);
 
 test("sortCurrenciesByIds snapshot", () => {
   const list = [...listCryptoCurrencies(), ...listTokens()];

package/src/e2e/enum/Currency.ts

@@ -87,7 +87,7 @@ export class Currency {
   static readonly ETH_LIDO = new Currency(
     "LIDO Staked ETH",
     "STETH",
-    "ethereum",
+    "ethereum/erc20/steth",
     AppInfos.ETHEREUM,
   );
   static readonly XLM_USCD = new Currency("USDC", "usdc", "stellar", AppInfos.STELLAR);

package/src/e2e/enum/Provider.ts

@@ -19,6 +19,7 @@ export class Provider {
   static readonly KILN = new Provider("kiln", "Kiln staking Pool", false, true, true);
   static readonly STADER_LABS = new Provider("stader", "Stader Labs", false, true, true);
   static readonly LIDO = new Provider("lido", "Lido", false, true, true);
+  static readonly TRANSAK = new Provider("transak", "Transak", false, true, true);
 
   static getNameByUiName(uiName: string): string {
     const provider = Object.values(Provider).find(p => p.uiName === uiName);

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";
@@ -415,13 +415,59 @@ interface ResponseData {
   events: Event[];
 }
 
+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()))) {
@@ -436,10 +482,12 @@ export async function waitFor(text: string, maxAttempts = 15): 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(
@@ -465,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 {
@@ -503,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);

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/families/bitcoin/satstack.test.ts

@@ -18,6 +18,8 @@ import { inferDescriptorFromAccount, AccountDescriptor } from "@ledgerhq/coin-bi
 import { setEnv } from "@ledgerhq/live-env";
 import { fromAccountRaw } from "../../account";
 import { setSupportedCurrencies } from "../../currencies";
+import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { CryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/type";
 
 setSupportedCurrencies(["bitcoin"]);
 jest.setTimeout(10000);
@@ -230,6 +232,11 @@ describe("stringifySatStackConfig", () => {
   });
 });
 describe("editSatStackConfig", () => {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  setCryptoAssetsStoreForCoinFramework({
+    findTokenById: (_: string) => undefined,
+    findTokenByAddressInCurrency: (_: string, __: string) => undefined,
+  } as CryptoAssetsStore);
   const config = {
     node: { ...mockConfig, tls: false },
     extra: {

package/src/families/canton/bridge.integration.test.ts

@@ -0,0 +1,6 @@
+import "../../__tests__/test-helpers/setup";
+
+import { dataset } from "@ledgerhq/coin-canton/test/index";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+
+testBridge(dataset);

package/src/families/canton/config.ts

@@ -0,0 +1,12 @@
+import { ConfigInfo } from "@ledgerhq/live-config/LiveConfig";
+
+export const cantonConfig: Record<string, ConfigInfo> = {
+  config_currency_canton: {
+    type: "object",
+    default: {
+      status: {
+        type: "active",
+      },
+    },
+  },
+};

package/src/families/canton/logic.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-canton/common-logic/index";

package/src/families/canton/setup.ts

@@ -0,0 +1,34 @@
+// Goal of this file is to inject all necessary device/signer dependency to coin-modules
+
+import { createBridges } from "@ledgerhq/coin-canton/bridge/index";
+import Transport from "@ledgerhq/hw-transport";
+import { CantonSigner } from "@ledgerhq/coin-canton";
+import cantonResolver from "@ledgerhq/coin-canton/signer";
+import type { Account, Bridge } from "@ledgerhq/types-live";
+import makeCliTools from "@ledgerhq/coin-canton/test/cli";
+import { CantonCoinConfig } from "@ledgerhq/coin-canton/config";
+import { TransactionStatus, Transaction } from "@ledgerhq/coin-canton/types";
+import { LegacySignerCanton } from "@ledgerhq/live-signer-canton";
+import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
+import { Resolver } from "../../hw/getAddress/types";
+import { getCurrencyConfiguration } from "../../config";
+import { getCryptoCurrencyById } from "../../currencies";
+
+const createSigner: CreateSigner<CantonSigner> = (transport: Transport) => {
+  return new LegacySignerCanton(transport);
+};
+
+const getCurrencyConfig = () => {
+  return getCurrencyConfiguration<CantonCoinConfig>(getCryptoCurrencyById("canton_network"));
+};
+
+const bridge: Bridge<Transaction, Account, TransactionStatus> = createBridges(
+  executeWithSigner(createSigner),
+  getCurrencyConfig,
+);
+
+const resolver: Resolver = createResolver(createSigner, cantonResolver);
+
+const cliTools = makeCliTools();
+
+export { bridge, cliTools, resolver };

package/src/families/canton/types.ts

@@ -0,0 +1,2 @@
+// Encapsulate for LLD & LLM
+export * from "@ledgerhq/coin-canton/types/index";