@ledgerhq/live-common 34.52.0-nightly.9 → 34.53.0-nightly.20251107095716

package/src/__tests__/test-helpers/setup.ts

@@ -1,8 +1,12 @@
 import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
+import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
+import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
 import "./environment";
 import BigNumber from "bignumber.js";
 
+initializeLegacyTokens(addTokens);
+
 jest.setTimeout(360000);
 
 expect.extend({
@@ -14,8 +18,5 @@ expect.extend({
   },
 });
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setCryptoAssetsStoreForCoinFramework({
-  findTokenById: (_: string) => undefined,
-  findTokenByAddressInCurrency: (_: string, __: string) => undefined,
-} as CryptoAssetsStore);
+// Use legacyCryptoAssetsStore for integration tests so tokens can be found
+setCryptoAssetsStoreForCoinFramework(legacyCryptoAssetsStore);

package/src/account/serialization.test.ts

@@ -18,19 +18,19 @@ const USDC = solanaSplTokenData as TokenCurrency;
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 setCryptoAssetsStoreForCoinFramework({
-  findTokenById: (id: string) => {
+  findTokenById: async (id: string) => {
     if (id === "solana/spl/epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v") {
       return USDC;
     }
 
     return undefined;
   },
-  findTokenByAddressInCurrency: (_: string, __: string) => undefined,
-  getTokensSyncHash: (_: string) => Promise.resolve("0"),
-} as CryptoAssetsStore);
+  findTokenByAddressInCurrency: async (_: string, __: string) => undefined,
+  getTokensSyncHash: async (_: string) => "0",
+} as unknown as CryptoAssetsStore);
 
 describe("serialization", () => {
-  test("TokenAccount extra fields should be serialized/deserialized", () => {
+  test("TokenAccount extra fields should be serialized/deserialized", async () => {
     const acc: any = genAccount("mocked-account-1", { currency: Solana });
     const tokenAcc: any = genTokenAccount(1, acc, USDC);
     tokenAcc.state = "initialized";
@@ -39,7 +39,7 @@ describe("serialization", () => {
     const accRaw: any = toAccountRaw(acc);
     expect(accRaw.subAccounts?.[0]?.state).toBe("initialized");
 
-    const deserializedAcc: any = fromAccountRaw(accRaw);
+    const deserializedAcc: any = await fromAccountRaw(accRaw);
     expect(deserializedAcc.subAccounts?.[0]?.state).toBe("initialized");
   });
 });

package/src/account/serialization.ts

@@ -62,11 +62,11 @@ export const fromOperationRaw = (
   return commonFromOperationRaw(operationRaw, accountId, subAccounts, fromOperationRaw);
 };
 
-export function fromAccountRaw(rawAccount: AccountRaw): Account {
+export async function fromAccountRaw(rawAccount: AccountRaw): Promise<Account> {
   const currency = getCryptoCurrencyById(rawAccount.currencyId);
   const bridge = getAccountBridgeByFamily(currency.family, rawAccount.id);
 
-  return commonFromAccountRaw(rawAccount, {
+  return await commonFromAccountRaw(rawAccount, {
     assignFromAccountRaw: bridge.assignFromAccountRaw,
     assignFromTokenAccountRaw: bridge.assignFromTokenAccountRaw,
     fromOperationExtraRaw: bridge.fromOperationExtraRaw,

package/src/api/ofacGeoBlockApi.ts

@@ -0,0 +1,19 @@
+import { createApi, fetchBaseQuery } from "@reduxjs/toolkit/query/react";
+import { getEnv } from "@ledgerhq/live-env";
+
+export const ofacGeoBlockApi = createApi({
+  reducerPath: "ofacGeoBlockApi",
+  baseQuery: fetchBaseQuery({
+    baseUrl: getEnv("LEDGER_COUNTERVALUES_API"),
+    validateStatus: response => [200, 451].includes(response.status), // Treat both 200 (not blocked) and 451 (blocked) as successful responses
+  }),
+
+  endpoints: build => ({
+    check: build.query<boolean, void>({
+      query: () => ({
+        url: "/v3/markets",
+      }),
+      transformResponse: (response: unknown, meta) => meta?.response?.status === 451,
+    }),
+  }),
+});

package/src/apps/config.ts

@@ -42,6 +42,7 @@ const appConfig: Record<string, ConfigInfo> = {
     type: "object",
     default: {
       minVersion: "1.5.0",
+      nanosMinVersion: "1.3.2",
     },
   },
   config_nanoapp_cardano_ada: {

package/src/bot/engine.ts

@@ -50,7 +50,7 @@ import type {
   SignOperationEvent,
   TransactionCommon,
 } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus } from "../generated/types";
+import type { TransactionStatus } from "../generated/types";
 import { botTest } from "@ledgerhq/coin-framework/bot/bot-test-context";
 import { getDefaultAccountNameForCurrencyIndex } from "@ledgerhq/live-wallet/accountName";
 
@@ -70,7 +70,7 @@ const cache = makeBridgeCacheSystem({
 const defaultScanAccountsRetries = 2;
 const delayBetweenScanAccountRetries = 5000;
 
-export async function runWithAppSpec<T extends Transaction>(
+export async function runWithAppSpec<T extends TransactionCommon>(
   spec: AppSpec<T>,
   reportLog: (arg0: string) => void,
 ): Promise<SpecReport<T>> {
@@ -276,7 +276,7 @@ export async function runWithAppSpec<T extends Transaction>(
           }
         }
         // eslint-disable-next-line no-console
-        console.log(formatReportForConsole(report));
+        console.log(formatReportForConsole(report as any));
         mutationReports.push(report);
         appReport.mutations = mutationReports;
 
@@ -343,7 +343,7 @@ export async function runWithAppSpec<T extends Transaction>(
 
   return appReport;
 }
-export async function runOnAccount<T extends Transaction>({
+export async function runOnAccount<T extends TransactionCommon>({
   appCandidate,
   spec,
   device,
@@ -761,7 +761,7 @@ async function syncAccount(initialAccount: Account): Promise<Account> {
   return deepFreezeAccount(acc);
 }
 
-export function autoSignTransaction<T extends Transaction>({
+export function autoSignTransaction<T extends TransactionCommon>({
   transport,
   deviceAction,
   appCandidate,

package/src/bridge/cache.test.ts

@@ -10,10 +10,12 @@ describe("Bridge Cache", () => {
 
   beforeAll(() => {
     setEnv("MOCK", "1");
+    setEnv("PLAYWRIGHT_RUN", true);
   });
 
   afterAll(() => {
     setEnv("MOCK", "");
+    setEnv("PLAYWRIGHT_RUN", false);
   });
 
   it("does not re-generate the LRU cache by default", async () => {

package/src/bridge/crypto-assets/index.test.ts

@@ -1,6 +1,6 @@
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/tokens";
+import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
 
 describe("Testing CryptoAssetStore", () => {
@@ -13,10 +13,7 @@ describe("Testing CryptoAssetStore", () => {
     });
 
     const store = getCryptoAssetsStore();
-    expect(store.findTokenById).toBe(legacyCryptoAssetsStore.findTokenById);
-    expect(store.findTokenByAddressInCurrency).toBe(
-      legacyCryptoAssetsStore.findTokenByAddressInCurrency,
-    );
+    expect(store).toBe(legacyCryptoAssetsStore);
   });
 
   it("should return the default methods from cryptoassets libs when feature flag is disabled", () => {
@@ -28,10 +25,7 @@ describe("Testing CryptoAssetStore", () => {
     });
 
     const store = getCryptoAssetsStore();
-    expect(store.findTokenById).toBe(legacyCryptoAssetsStore.findTokenById);
-    expect(store.findTokenByAddressInCurrency).toBe(
-      legacyCryptoAssetsStore.findTokenByAddressInCurrency,
-    );
+    expect(store).toBe(legacyCryptoAssetsStore);
   });
 
   it("should throw an error when no store is set and feature flag is enabled", () => {

package/src/bridge/crypto-assets/index.ts

@@ -1,6 +1,6 @@
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/tokens";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
 
 let cryptoAssetsStore: CryptoAssetsStore | undefined = undefined;
 

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

@@ -124,8 +124,8 @@ const buildGetBalance = (networkFamily: string) =>
   };
 
 const buildGetSequence = (networkFamily: string) =>
-  async function getSequence(address: string): Promise<number> {
-    const { data } = await network<number, unknown>({
+  async function getSequence(address: string): Promise<bigint> {
+    const { data } = await network<bigint, unknown>({
       method: "GET",
       url: `${ALPACA_URL}/${networkFamily}/account/${address}/info`,
     });
@@ -191,7 +191,7 @@ export const getNetworkAlpacaApi = (networkFamily: string) =>
       _transaction: string,
       _sender: string,
       _publicKey: string,
-      _sequence: number,
+      _sequence: bigint,
     ): Promise<CraftedTransaction> => {
       throw new Error("craftRawTransaction is not supported");
     },

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

@@ -43,12 +43,17 @@ export function createTransaction(account: Account | TokenAccount): GenericTrans
       };
     case "evm": {
       return {
-        mode: "send-eip1559",
+        mode: "send",
+        type: 2,
         family: currency.family,
         amount: new BigNumber(0),
         recipient: "",
         useAllAmount: false,
         feesStrategy: "medium",
+        chainId: currency.ethereumLikeInfo?.chainId ?? 0,
+        gasLimit: new BigNumber(21000),
+        maxFeePerGas: new BigNumber(0),
+        maxPriorityFeePerGas: new BigNumber(0),
       };
     }
     default:

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

@@ -25,6 +25,7 @@ export function genericGetTransactionStatus(
       family: transaction.family,
       feesStrategy: transaction.feesStrategy,
       data: transaction.data,
+      type: transaction.type,
     };
 
     if (alpacaApi.getChainSpecificRules) {

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

@@ -2,7 +2,7 @@ import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
-import { AssetInfo } from "@ledgerhq/coin-framework/api/types";
+import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 import { decodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { GenericTransaction } from "./types";
@@ -21,6 +21,23 @@ function assetInfosFallback(transaction: GenericTransaction): {
   };
 }
 
+function propagateField(estimation: FeeEstimation, field: string, dest: GenericTransaction): void {
+  const value = estimation?.parameters?.[field];
+
+  if (typeof value !== "bigint" && typeof value !== "number" && typeof value !== "string") return;
+
+  switch (field) {
+    case "type":
+      dest[field] = Number(value.toString());
+      return;
+    case "storageLimit":
+      dest[field] = new BigNumber(value.toString());
+      return;
+    default:
+      return;
+  }
+}
+
 export function genericPrepareTransaction(
   network: string,
   kind,
@@ -31,13 +48,12 @@ export function genericPrepareTransaction(
       kind,
     );
     const { assetReference, assetOwner } = getAssetFromToken
-      ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
+      ? await getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
     const customParametersFees = transaction.customFees?.parameters?.fees;
-    let fees: BigNumber | bigint | null = customParametersFees || null;
-    if (fees === null) {
-      fees = (
-        await estimateFees(
+    const estimation: FeeEstimation = customParametersFees
+      ? { value: BigInt(customParametersFees.toFixed()) }
+      : await estimateFees(
           transactionToIntent(
             account,
             {
@@ -45,14 +61,13 @@ export function genericPrepareTransaction(
             },
             computeIntentType,
           ),
-        )
-      ).value;
-    }
+        );
+    const fees = new BigNumber(estimation.value.toString());
 
-    if (!bnEq(transaction.fees, new BigNumber(fees.toString()))) {
+    if (!bnEq(transaction.fees, fees)) {
       const next: GenericTransaction = {
         ...transaction,
-        fees: new BigNumber(fees.toString()),
+        fees,
         assetReference,
         assetOwner,
         customFees: {
@@ -62,35 +77,15 @@ export function genericPrepareTransaction(
         },
       };
 
-      // propagate storageLimit fee parameter when present (ex: tezos)
-      const feeEstimation = await estimateFees(
-        transactionToIntent(
-          account,
-          {
-            ...transaction,
-          },
-          computeIntentType,
-        ),
-      );
-      const params = feeEstimation?.parameters;
-      if (params) {
-        const storageLimit = params["storageLimit"];
-        if (
-          storageLimit !== undefined &&
-          (typeof storageLimit === "bigint" ||
-            typeof storageLimit === "number" ||
-            typeof storageLimit === "string")
-        ) {
-          next.storageLimit = new BigNumber(storageLimit.toString());
-        }
+      // Propagate needed fields
+      const fieldsToPropagate = ["type", "storageLimit"];
+
+      for (const field of fieldsToPropagate) {
+        propagateField(estimation, field, next);
       }
 
       // align with stellar/xrp: when send max (or staking intents), reflect validated amount in UI
-      if (
-        transaction.useAllAmount ||
-        transaction["mode"] === "stake" ||
-        transaction["mode"] === "unstake"
-      ) {
+      if (transaction.useAllAmount || ["stake", "unstake"].includes(transaction.mode ?? "")) {
         const { amount } = await validateIntent(
           transactionToIntent(
             account,
@@ -109,16 +104,16 @@ export function genericPrepareTransaction(
   };
 }
 
-export function getAssetInfos(
+export async function getAssetInfos(
   tr: GenericTransaction,
   owner: string,
   getAssetFromToken: (token: TokenCurrency, owner: string) => AssetInfo,
-): {
+): Promise<{
   assetReference: string;
   assetOwner: string;
-} {
+}> {
   if (tr.subAccountId) {
-    const { token } = decodeTokenAccountId(tr.subAccountId);
+    const { token } = await decodeTokenAccountId(tr.subAccountId);
 
     if (!token) return assetInfosFallback(tr);
 

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

@@ -119,9 +119,11 @@ export const genericSignOperation =
           // Enrich with memo and asset information
           transactionIntent = enrichTransactionIntent(transactionIntent, transaction, publicKey);
 
-          // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
-          const sequenceNumber = await alpacaApi.getSequence(transactionIntent.sender);
-          transactionIntent.sequence = sequenceNumber;
+          if (typeof transactionIntent.sequence !== "bigint") {
+            // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
+            const sequenceNumber = await alpacaApi.getSequence(transactionIntent.sender);
+            transactionIntent.sequence = sequenceNumber;
+          }
 
           /* Craft unsigned blob via Alpaca */
           const { transaction: unsigned } = await alpacaApi.craftTransaction(transactionIntent, {
@@ -131,7 +133,11 @@ export const genericSignOperation =
           /* Notify UI that the device is now showing the tx */
           o.next({ type: "device-signature-requested" });
           /* Sign on Ledger device */
-          const txnSig = await signer.signTransaction(derivationPath, unsigned);
+          const txnSig = await signer.signTransaction(
+            derivationPath,
+            unsigned,
+            transaction.recipientDomain,
+          );
           return { unsigned, txnSig, publicKey, sequence: transactionIntent.sequence };
         });
 

package/src/bridge/generic-alpaca/signer/Eth.ts

@@ -7,10 +7,11 @@ import Transport from "@ledgerhq/hw-transport";
 import { getEnv } from "@ledgerhq/live-env";
 import { ResolutionConfig, LoadConfig } from "@ledgerhq/hw-app-eth/lib/services/types";
 import { Signature } from "ethers";
+import type { DomainServiceResolution } from "@ledgerhq/types-live";
 
 export type Signer = {
   getAddress: (path: string) => Promise<EvmAddress>;
-  signTransaction: (path: string, tx: string) => Promise<string>;
+  signTransaction: (path: string, tx: string, domain?: DomainServiceResolution) => Promise<string>;
 };
 
 const isDmkTransport = (
@@ -37,13 +38,14 @@ export const createSigner: CreateSigner<Signer> = (transport: Transport) => {
 
   return {
     getAddress: signer.getAddress.bind(signer),
-    signTransaction: async (path, tx) => {
+    signTransaction: async (path, tx, domain) => {
       // Configure type of resolutions necessary for the clear signing
       const resolutionConfig: ResolutionConfig = {
         externalPlugins: true,
         erc20: true,
         nft: false,
         uniswapV3: true,
+        domains: domain && [domain],
       };
       const loadConfig: LoadConfig = {
         cryptoassetsBaseURL: getEnv("DYNAMIC_CAL_BASE_URL"),

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -92,81 +92,34 @@ describe("genericPrepareTransaction", () => {
     expect(result).toBe(baseTransaction); // still same reference
   });
 
-  it("propagates storageLimit from second estimation", async () => {
-    const estimatedFee = new BigNumber(491);
-
-    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 300 },
-    });
-
-    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 0 },
-    });
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest
-        .fn()
-        .mockImplementationOnce(() => estimateFeesFirstCall())
-        .mockImplementationOnce(() => estimateFeesSecondCall()),
-    });
-
-    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, txWithoutCustomFees);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        fees: estimatedFee,
-        storageLimit: new BigNumber(0),
-        customFees: {
-          parameters: {
-            fees: undefined,
-          },
-        },
-      }),
-    );
-
-    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
-  });
-
-  it("propagates storageLimit showing new account scenario", async () => {
-    const estimatedFee = new BigNumber(491);
-
-    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 300 },
-    });
-
-    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
-      value: estimatedFee,
-      parameters: { storageLimit: 277 },
-    });
-
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest
-        .fn()
-        .mockImplementationOnce(() => estimateFeesFirstCall())
-        .mockImplementationOnce(() => estimateFeesSecondCall()),
-    });
-
-    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
-    const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(account, txWithoutCustomFees);
-
-    expect(result).toEqual(
-      expect.objectContaining({
-        fees: estimatedFee,
-        storageLimit: new BigNumber(277),
-        customFees: {
-          parameters: {
-            fees: undefined,
+  it.each([
+    ["type", 2, 2],
+    ["storageLimit", 300n, new BigNumber(300)],
+  ])(
+    "propagates %s from estimation parameters",
+    async (parameterName, parameterValue, expectedValue) => {
+      (getAlpacaApi as jest.Mock).mockReturnValue({
+        estimateFees: jest.fn().mockResolvedValue({
+          value: new BigNumber(491),
+          parameters: { [parameterName]: parameterValue },
+        }),
+      });
+
+      const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
+      const prepareTransaction = genericPrepareTransaction(network, kind);
+      const result = await prepareTransaction(account, txWithoutCustomFees);
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          fees: new BigNumber(491),
+          [parameterName]: expectedValue,
+          customFees: {
+            parameters: {
+              fees: undefined,
+            },
           },
-        },
-      }),
-    );
-
-    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
-  });
+        }),
+      );
+    },
+  );
 });

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

@@ -27,6 +27,10 @@ describe("genericSignOperation", () => {
     amount: 100_000n,
     fees: 500n,
     tag: 1234,
+    recipientDomain: {
+      domain: "recipient.gen",
+      address: "recipient-address",
+    },
   } as any;
 
   const deviceId = "mockDevice";
@@ -38,7 +42,7 @@ describe("genericSignOperation", () => {
     },
   };
 
-  const unsignedTx = "unsignedTx";
+  const unsignedTx = { transaction: "unsignedTx" };
   const signedTx = "signedTx";
   const pubKey = "pubKey";
 
@@ -49,7 +53,7 @@ describe("genericSignOperation", () => {
       craftTransaction: jest.fn().mockResolvedValue(unsignedTx),
       getAccountInfo: jest.fn().mockResolvedValue(pubKey),
       combine: jest.fn().mockResolvedValue(signedTx),
-      getSequence: jest.fn().mockResolvedValue(1),
+      getSequence: jest.fn().mockResolvedValue(1n),
     });
 
     (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
@@ -84,6 +88,10 @@ describe("genericSignOperation", () => {
       });
 
       expect(transactionToIntent).toHaveBeenCalledWith(account, transaction, undefined);
+      expect(mockSigner.signTransaction).toHaveBeenCalledWith("44'/144'/0'/0/0", "unsignedTx", {
+        domain: "recipient.gen",
+        address: "recipient-address",
+      });
       expect(txIntent.memo.memos.get("destinationTag")).toBe("1234");
     });