@ledgerhq/live-common 34.54.0 → 34.55.0-nightly.20251210100832

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

@@ -86,6 +86,19 @@ export const genericSignOperation =
         const alpacaApi = getAlpacaApi(account.currency.id, kind);
         if (!transaction.fees) throw new FeeNotLoaded();
         const fees = BigInt(transaction.fees?.toString() || "0");
+        const feesParameters = {
+          ...(transaction.gasLimit ? { gasLimit: BigInt(transaction.gasLimit.toFixed()) } : {}),
+          ...(transaction.gasPrice ? { gasPrice: BigInt(transaction.gasPrice.toFixed()) } : {}),
+          ...(transaction.maxFeePerGas
+            ? { maxFeePerGas: BigInt(transaction.maxFeePerGas.toFixed()) }
+            : {}),
+          ...(transaction.maxPriorityFeePerGas
+            ? { maxPriorityFeePerGas: BigInt(transaction.maxPriorityFeePerGas.toFixed()) }
+            : {}),
+          ...(transaction.additionalFees
+            ? { additionalFees: BigInt(transaction.additionalFees.toFixed()) }
+            : {}),
+        };
         if (transaction.useAllAmount) {
           const draftTransaction = {
             mode: transaction.mode,
@@ -98,10 +111,12 @@ export const genericSignOperation =
             family: transaction.family,
             feesStrategy: transaction.feesStrategy,
             data: transaction.data,
+            type: transaction.type,
           };
+          // TODO Remove the call to `validateIntent` https://ledgerhq.atlassian.net/browse/LIVE-22227
           const { amount } = await alpacaApi.validateIntent(
             transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
-            { value: fees },
+            { value: fees, parameters: feesParameters },
           );
           transaction.amount = new BigNumber(amount.toString());
         }
@@ -119,7 +134,7 @@ export const genericSignOperation =
           // Enrich with memo and asset information
           transactionIntent = enrichTransactionIntent(transactionIntent, transaction, publicKey);
 
-          if (typeof transactionIntent.sequence !== "bigint") {
+          if (typeof transactionIntent.sequence !== "bigint" || transactionIntent.sequence < 0n) {
             // TODO: should compute it and pass it down to craftTransaction (duplicate call right now)
             const sequenceNumber = await alpacaApi.getSequence(transactionIntent.sender);
             transactionIntent.sequence = sequenceNumber;
@@ -128,6 +143,7 @@ export const genericSignOperation =
           /* Craft unsigned blob via Alpaca */
           const { transaction: unsigned } = await alpacaApi.craftTransaction(transactionIntent, {
             value: fees,
+            parameters: feesParameters,
           });
 
           /* Notify UI that the device is now showing the tx */

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

@@ -1,6 +1,6 @@
 import { filter, firstValueFrom } from "rxjs";
 import { EvmAddress, EvmSignature, EvmSigner } from "@ledgerhq/coin-evm/types/signer";
-import { CreateSigner } from "../../setup";
+import { CreateSigner, executeWithSigner } from "../../setup";
 import { DeviceManagementKit } from "@ledgerhq/device-management-kit";
 import { DmkSignerEth, LegacySignerEth } from "@ledgerhq/live-signer-evm";
 import Transport from "@ledgerhq/hw-transport";
@@ -8,6 +8,7 @@ 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";
+import resolver from "@ledgerhq/coin-evm/hw-getAddress";
 
 export type Signer = {
   getAddress: (path: string) => Promise<EvmAddress>;
@@ -70,3 +71,6 @@ export const createSigner: CreateSigner<Signer> = (transport: Transport) => {
     },
   };
 };
+
+export const context = executeWithSigner(createSigner);
+export const getAddress = resolver(context);

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

@@ -10,6 +10,7 @@ import { AlpacaSigner } from "./types";
 import { DerivationType, LedgerSigner as TaquitoLedgerSigner } from "@taquito/ledger-signer";
 import tezosGetAddress from "@ledgerhq/coin-tezos/signer/getAddress";
 import Tezos from "@ledgerhq/hw-app-tezos";
+import { context as evmContext, getAddress as evmGetAddress } from "./Eth";
 
 const createSignerXrp: CreateSigner<Xrp> = (transport: Transport) => {
   return new Xrp(transport);
@@ -97,6 +98,12 @@ export function getSigner(network: string): AlpacaSigner {
         context: signerContextTezos,
       };
     }
+    case "evm": {
+      return {
+        getAddress: evmGetAddress,
+        context: evmContext,
+      };
+    }
   }
   throw new Error(`signer for ${network} not implemented`);
 }

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

@@ -71,7 +71,7 @@ describe("genericGetAccountShape", () => {
         "sync-hash",
         {
           minHeight: 11,
-          order: "asc",
+          order: "desc",
           lastPagingToken: "pt1",
         },
         [
@@ -82,11 +82,16 @@ describe("genericGetAccountShape", () => {
           },
           {
             hash: "h2",
-            type: "IN",
+            type: "OUT",
             blockHeight: 12,
             subOperations: [{ id: `${currency.id}_subOp1` }],
             extra: { assetReference: "ar2", assetOwner: "ow2" },
           },
+          {
+            blockHeight: 16,
+            hash: "h4",
+            type: "IN",
+          },
           {
             hash: "h1",
             blockHeight: 10,
@@ -100,7 +105,7 @@ describe("genericGetAccountShape", () => {
         "outdated-sync-hash",
         {
           minHeight: 0,
-          order: "asc",
+          order: "desc",
         },
         [
           {
@@ -110,11 +115,16 @@ describe("genericGetAccountShape", () => {
           },
           {
             hash: "h2",
-            type: "IN",
+            type: "OUT",
             blockHeight: 12,
             subOperations: [{ id: `${currency.id}_subOp1` }],
             extra: { assetReference: "ar2", assetOwner: "ow2" },
           },
+          {
+            blockHeight: 16,
+            hash: "h4",
+            type: "IN",
+          },
         ],
       ],
     ])(
@@ -150,8 +160,13 @@ describe("genericGetAccountShape", () => {
           asset.symbol === "TOK1" ? { id: `${currency.id}_token1` } : null,
         );
 
-        const coreOp = { hash: "h2", height: 12 };
-        listOperationsMock.mockResolvedValue([[coreOp]]);
+        listOperationsMock.mockResolvedValue([
+          [
+            { hash: "h2", type: "OUT", height: 12 },
+            { hash: "h3", type: "IN", tx: { failed: true }, height: 14 }, // won't appear in final shape
+            { hash: "h4", type: "IN", tx: { failed: false }, height: 16 },
+          ],
+        ]);
         refreshOperationsMock.mockImplementation(ops => {
           const op = ops[0];
           if (op?.hash === "h0") {
@@ -162,8 +177,8 @@ describe("genericGetAccountShape", () => {
 
         adaptCoreOperationToLiveOperationMock.mockImplementation((_accId, op) => ({
           hash: op.hash,
-          type: "IN",
-          blockHeight: 12,
+          type: op.type,
+          blockHeight: op.height,
           extra: { assetReference: "ar2", assetOwner: "ow2" },
         }));
 
@@ -206,8 +221,26 @@ describe("genericGetAccountShape", () => {
         ]);
 
         const assetOpsPassed = buildSubAccountsMock.mock.calls[0][0].operations;
-        expect(assetOpsPassed).toHaveLength(1);
-        expect(assetOpsPassed[0].hash).toBe("h2");
+        expect(assetOpsPassed).toEqual([
+          {
+            blockHeight: 12,
+            extra: {
+              assetOwner: "ow2",
+              assetReference: "ar2",
+            },
+            hash: "h2",
+            type: "OUT",
+          },
+          {
+            blockHeight: 16,
+            extra: {
+              assetOwner: "ow2",
+              assetReference: "ar2",
+            },
+            hash: "h4",
+            type: "IN",
+          },
+        ]);
 
         expect(result).toMatchObject({
           balance: new BigNumber(1000),

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

@@ -2,6 +2,9 @@ import { genericPrepareTransaction } from "../prepareTransaction";
 import { getAlpacaApi } from "../alpaca";
 import { transactionToIntent } from "../utils";
 import BigNumber from "bignumber.js";
+import { GenericTransaction } from "../types";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../alpaca", () => ({
   getAlpacaApi: jest.fn(),
@@ -95,6 +98,11 @@ describe("genericPrepareTransaction", () => {
   it.each([
     ["type", 2, 2],
     ["storageLimit", 300n, new BigNumber(300)],
+    ["gasLimit", 300n, new BigNumber(300)],
+    ["gasPrice", 300n, new BigNumber(300)],
+    ["maxFeePerGas", 300n, new BigNumber(300)],
+    ["maxPriorityFeePerGas", 300n, new BigNumber(300)],
+    ["additionalFees", 300n, new BigNumber(300)],
   ])(
     "propagates %s from estimation parameters",
     async (parameterName, parameterValue, expectedValue) => {
@@ -122,4 +130,70 @@ describe("genericPrepareTransaction", () => {
       );
     },
   );
+
+  it("estimates using the token account spendable balance when sending all amount", async () => {
+    const estimateFees = jest.fn().mockResolvedValue({ value: new BigNumber(50) });
+    (transactionToIntent as jest.Mock).mockImplementation((_, transaction) => ({
+      amount: BigInt(transaction.amount.toFixed()),
+    }));
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees,
+      validateIntent: intent => Promise.resolve({ amount: intent.amount }),
+    });
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+
+    await prepareTransaction(
+      {
+        ...account,
+        subAccounts: [{ id: "test-sub-account", spendableBalance: new BigNumber(100) }],
+      },
+      {
+        subAccountId: "test-sub-account",
+        useAllAmount: true,
+        amount: new BigNumber(0),
+      } as GenericTransaction,
+    );
+
+    expect(estimateFees).toHaveBeenCalledWith(expect.objectContaining({ amount: 100n }), {});
+  });
+
+  it("fills 'assetOwner' and 'assetReference' from 'subAccountId' for retro compatibility", async () => {
+    setupMockCryptoAssetsStore({
+      findTokenById: tokenId =>
+        Promise.resolve(tokenId === "usdc" ? ({ id: tokenId } as TokenCurrency) : undefined),
+    });
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: () => Promise.resolve({ value: 0n }),
+      getAssetFromToken: (token, owner) =>
+        token.id === "usdc" ? { assetOwner: owner, assetReference: token.id } : undefined,
+    });
+    const prepareTransaction = genericPrepareTransaction(network, kind);
+
+    await prepareTransaction(
+      {
+        ...account,
+        freshAddress: "test-account-address",
+        subAccounts: [{ id: "test-sub-account+usdc" }],
+      },
+      {
+        subAccountId: "test-sub-account+usdc",
+        amount: new BigNumber(10),
+      } as GenericTransaction,
+    );
+
+    expect(transactionToIntent).toHaveBeenCalledWith(
+      {
+        ...account,
+        freshAddress: "test-account-address",
+        subAccounts: [{ id: "test-sub-account+usdc" }],
+      },
+      {
+        subAccountId: "test-sub-account+usdc",
+        amount: new BigNumber(10),
+        assetOwner: "test-account-address",
+        assetReference: "usdc",
+      },
+      undefined,
+    );
+  });
 });

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

@@ -70,7 +70,9 @@ export type GenericTransaction = TransactionCommon & {
   gasPrice?: BigNumber | null;
   maxFeePerGas?: BigNumber | null;
   maxPriorityFeePerGas?: BigNumber | null;
+  additionalFees?: BigNumber | null;
   gasOptions?: GasOptions;
+  sponsored?: boolean;
 };
 
 export type GenericTransactionRaw = TransactionCommonRaw & {
@@ -104,7 +106,9 @@ export type GenericTransactionRaw = TransactionCommonRaw & {
   gasPrice?: string | null;
   maxFeePerGas?: string | null;
   maxPriorityFeePerGas?: string | null;
+  additionalFees?: string | null;
   gasOptions?: GasOptionsRaw;
+  sponsored?: boolean;
 };
 
 export interface OperationCommon extends Operation {

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

@@ -166,10 +166,12 @@ describe("Alpaca utils", () => {
           },
           ...params,
         } as GenericTransaction,
+        3n,
       );
 
       expect(operation).toMatchObject({
         id: `parent-account-id--${expected.parentType}`,
+        transactionSequenceNumber: new BigNumber(3),
         type: expected.parentType,
         value: expected.parentValue,
         accountId: "parent-account-id",
@@ -194,10 +196,12 @@ describe("Alpaca utils", () => {
               subOperations: [
                 {
                   id: `sub-account-id--${expected.subType}`,
+                  transactionSequenceNumber: new BigNumber(3),
                   accountId: "sub-account-id",
                   type: expected.subType,
                   senders: ["account-address"],
                   recipients: ["recipient-address"],
+                  fee: new BigNumber(12),
                   value: new BigNumber(50),
                   blockHash: null,
                   blockHeight: null,

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

@@ -72,6 +72,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     parentRecipients?: string[];
     ledgerOpType?: string | undefined;
     memo?: string | undefined;
+    internal?: boolean;
   } = {};
 
   if (op.details?.ledgerOpType !== undefined) {
@@ -106,6 +107,11 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   if (op.details?.memo) {
     extra.memo = op.details.memo as string;
   }
+
+  if (op.details?.internal === true) {
+    extra.internal = op.details?.internal;
+  }
+
   const bnFees = new BigNumber(op.tx.fees.toString());
   const hasFailed = op.tx.failed;
 
@@ -214,6 +220,7 @@ export function transactionToIntent(
       transaction.nonce !== null && transaction.nonce !== undefined
         ? BigInt(transaction.nonce.toString())
         : undefined,
+    sponsored: transaction.sponsored,
   };
   if (transaction.assetReference && transaction.assetOwner) {
     const { subAccountId } = transaction;
@@ -265,8 +272,11 @@ function toGenericTransactionRaw(transaction: GenericTransaction): GenericTransa
     family: transaction.family,
   };
 
-  if ("useAllAmount" in transaction) {
-    raw.useAllAmount = transaction.useAllAmount;
+  const booleanFieldsToPropagate = ["useAllAmount", "sponsored"] as const;
+  for (const field of booleanFieldsToPropagate) {
+    if (field in transaction) {
+      raw[field] = transaction[field];
+    }
   }
 
   const stringFieldsToPropagate = [
@@ -296,6 +306,7 @@ function toGenericTransactionRaw(transaction: GenericTransaction): GenericTransa
     "gasPrice",
     "maxFeePerGas",
     "maxPriorityFeePerGas",
+    "additionalFees",
   ] as const;
   for (const field of bigNumberFieldsToPropagate) {
     if (field in transaction) {
@@ -407,11 +418,12 @@ export const buildOptimisticOperation = (
         hash: "",
         type,
         value: transaction.useAllAmount ? tokenAccount.balance : transaction.amount,
-        fee: new BigNumber(0),
+        fee: new BigNumber(fees.toString()),
         blockHash: null,
         blockHeight: null,
         senders: [account.freshAddress],
         recipients: [transaction.recipient],
+        transactionSequenceNumber: new BigNumber(sequenceNumber?.toString() ?? 0),
         accountId: subAccountId,
         date: new Date(),
         transactionRaw: toGenericTransactionRaw({

package/src/bridge/impl.ts

@@ -23,6 +23,7 @@ import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/erro
 // Removed: stores are now managed globally by @ledgerhq/cryptoassets/cal-client/store
 
 const alpacaized = {
+  evm: true,
   xrp: true,
   stellar: true,
   tezos: true,
@@ -35,7 +36,13 @@ const currencyBridgeCache: Record<string, CurrencyBridge> = {};
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
     const mockBridge = mockBridges[currency.family];
-    if (mockBridge) return mockBridge.currencyBridge;
+    // TODO Remove once we delete mock bridges tests
+    if (mockBridge) {
+      if (typeof mockBridge.loadCoinConfig === "function") {
+        mockBridge.loadCoinConfig();
+      }
+      return mockBridge.currencyBridge;
+    }
     throw new CurrencyNotSupported("no mock implementation available for currency " + currency.id, {
       currencyName: currency.id,
     });
@@ -85,13 +92,19 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
 
     if (type === "mock") {
       const mockBridge = mockBridges[family];
-      if (mockBridge) return wrapAccountBridge(mockBridge.accountBridge);
+      // TODO Remove once we delete mock bridges tests
+      if (mockBridge) {
+        if (typeof mockBridge.loadCoinConfig === "function") {
+          mockBridge.loadCoinConfig();
+        }
+        return wrapAccountBridge(mockBridge.accountBridge);
+      }
     }
   }
 
   if (alpacaized[family]) {
     if (!bridgeCache[family]) {
-      bridgeCache[family] = getAlpacaAccountBridge(family, "local");
+      bridgeCache[family] = wrapAccountBridge(getAlpacaAccountBridge(family, "local"));
     }
     return bridgeCache[family];
   }

package/src/currencies/helpers.test.ts

@@ -1,5 +1,5 @@
 import "../__tests__/test-helpers/setup";
-import { isCryptoCurrency } from "./helpers";
+import { isCryptoCurrency, getFamilyByCurrencyId } from "./helpers";
 import { listCryptoCurrencies } from ".";
 
 describe("Currencies helpers", () => {
@@ -10,4 +10,13 @@ describe("Currencies helpers", () => {
       expect(isCryptoCurrency(currency)).toBeTruthy();
     });
   });
+
+  test("getFamilyByCurrencyId returns correct family for a known currency id", () => {
+    expect(getFamilyByCurrencyId("bitcoin")).toBe("bitcoin");
+    expect(getFamilyByCurrencyId("ethereum")).toBe("evm");
+  });
+
+  test("getFamilyByCurrencyId returns undefined for an unknown currency id", () => {
+    expect(getFamilyByCurrencyId("unknown_currency_id")).toBeUndefined();
+  });
 });

package/src/currencies/helpers.ts

@@ -1,4 +1,5 @@
 import { Currency, CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 
 export function isCryptoCurrency(currency: Currency): currency is CryptoCurrency {
   return currency.type === "CryptoCurrency";
@@ -15,3 +16,8 @@ export function isUTXOCompliant(currencyFamily: string): boolean {
 export type CurrencyFilters = {
   currencies?: string[];
 };
+
+export function getFamilyByCurrencyId(currencyId: string): CryptoCurrency["family"] | undefined {
+  const currency = findCryptoCurrencyById(currencyId);
+  return currency?.family;
+}

package/src/domain/getTokensWithFunds.ts

@@ -1,11 +1,8 @@
 import { getParentAccount } from "@ledgerhq/coin-framework/account/helpers";
 import { Account } from "@ledgerhq/types-live";
 
-export const getTokensWithFunds = (accounts: Account[]): string[] => {
-  if (!accounts?.length) return [];
-
-  const tokensMap = new Map<string, { ticker: string; networkName: string }>();
-
+export const getTokensWithFundsMap = (accounts: Account[]) => {
+  const tokensMap = new Map<string, { ticker: string; networkName: string; id: string }>();
   for (const account of accounts) {
     const { balance, currency } = account || {};
     if (!balance?.gt(0) || !currency) continue;
@@ -18,6 +15,7 @@ export const getTokensWithFunds = (accounts: Account[]): string[] => {
     tokensMap.set(mainKey, {
       ticker: currency.ticker,
       networkName,
+      id: currency.id,
     });
 
     account.subAccounts?.forEach(subAccount => {
@@ -28,9 +26,24 @@ export const getTokensWithFunds = (accounts: Account[]): string[] => {
       tokensMap.set(subKey, {
         ticker: token.ticker,
         networkName,
+        id: token.id,
       });
     });
   }
+  return tokensMap;
+};
+/** Format defaults to "USDT on Ethereum". format: "currencyId" returns the id of each token, e.g. "ethereum/erc20/usde". */
+export const getTokensWithFunds = (
+  accounts: Account[],
+  customFormat: "currencyId" | "default" = "default",
+) => {
+  if (!accounts?.length) return [];
+
+  const tokensMap = getTokensWithFundsMap(accounts);
+
+  if (customFormat === "currencyId") {
+    return Array.from(tokensMap.values(), token => token.id);
+  }
 
   return Array.from(tokensMap.values(), ({ ticker, networkName }) => `${ticker} on ${networkName}`);
 };