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

package/src/account/recentAddresses.test.ts

@@ -0,0 +1,104 @@
+import { RecentAddressesStore, setupRecentAddressesStore, getRecentAddressesStore } from ".";
+import { RECENT_ADDRESSES_COUNT_LIMIT } from "./recentAddresses";
+
+describe("RecentAddressesStore", () => {
+  const onAddAddressCompleteMock = jest.fn();
+  let store: RecentAddressesStore;
+
+  beforeEach(() => {
+    onAddAddressCompleteMock.mockClear();
+    setupRecentAddressesStore({}, onAddAddressCompleteMock);
+    store = getRecentAddressesStore();
+  });
+
+  it("should add one address and return this only address", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    const addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+  });
+
+  it("should add a second address and return addresses sorted by insertion", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress2, newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
+  });
+
+  it("should replace at first place when an address is already saved", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress2, newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress2, newAddress] });
+
+    await store.addAddress("ethereum", newAddress);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress, newAddress2]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(3);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress, newAddress2] });
+  });
+
+  it("should replace at first place and remove last element when addresses exceed count limit", async () => {
+    let expectedAddresses: string[] = [];
+    for (let index = 0; index < RECENT_ADDRESSES_COUNT_LIMIT; index++) {
+      await store.addAddress("ethereum", `0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
+      expectedAddresses.unshift(`0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3${index}`);
+    }
+
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual(expectedAddresses);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
+
+    const newAddress2 = "0xB69B37A4Fb4A18b3258f974ff6e9f529AD2647b1";
+    expectedAddresses.splice(expectedAddresses.length - 1, 1);
+    expectedAddresses = [newAddress2, ...expectedAddresses];
+
+    await store.addAddress("ethereum", newAddress2);
+    addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual(expectedAddresses);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(RECENT_ADDRESSES_COUNT_LIMIT + 1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: expectedAddresses });
+  });
+
+  it("should add an address of a different currency", async () => {
+    const newAddress = "0x66c4371aE8FFeD2ec1c2EBbbcCfb7E494181E1E3";
+    await store.addAddress("ethereum", newAddress);
+
+    let addresses = store.getAddresses("ethereum");
+    expect(addresses).toEqual([newAddress]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(1);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({ ethereum: [newAddress] });
+
+    const newAddress2 = "bc1pxlmrudqyq8qd8pfsc4mpmlaw56x6vtcr9m8nvp8kj3gckefc4kmqhkg4l7";
+    await store.addAddress("bitcoin", newAddress2);
+
+    addresses = store.getAddresses("bitcoin");
+    expect(addresses).toEqual([newAddress2]);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledTimes(2);
+    expect(onAddAddressCompleteMock).toHaveBeenCalledWith({
+      ethereum: [newAddress],
+      bitcoin: [newAddress2],
+    });
+  });
+});

package/src/account/recentAddresses.ts

@@ -0,0 +1,84 @@
+export const RECENT_ADDRESSES_COUNT_LIMIT = 12;
+
+export type RecentAddressesCache = Record<string, string[]>;
+
+export interface RecentAddressesStore {
+  addAddress(currency: string, address: string): void;
+  syncAddresses(cache: RecentAddressesCache): void;
+  getAddresses(currency: string): string[];
+}
+
+type CallbackMode = "triggerCallback" | "skipCallback";
+
+let recentAddressesStore: RecentAddressesStore | null = null;
+
+export function getRecentAddressesStore(): RecentAddressesStore {
+  if (recentAddressesStore === null) {
+    throw new Error(
+      "Recent addresses store instance is null, please call function setupRecentAddressesStore in application initialization",
+    );
+  }
+  return recentAddressesStore;
+}
+
+export function setupRecentAddressesStore(
+  addressesByCurrency: RecentAddressesCache,
+  onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
+): void {
+  recentAddressesStore = new RecentAddressesStoreImpl(addressesByCurrency, onAddAddressComplete);
+}
+
+class RecentAddressesStoreImpl implements RecentAddressesStore {
+  private addressesByCurrency: RecentAddressesCache = {};
+  private readonly onAddAddressComplete: (addressesByCurrency: Record<string, string[]>) => void;
+
+  constructor(
+    addressesByCurrency: RecentAddressesCache,
+    onAddAddressComplete: (addressesByCurrency: RecentAddressesCache) => void,
+  ) {
+    this.addressesByCurrency = { ...addressesByCurrency };
+    this.onAddAddressComplete = onAddAddressComplete;
+  }
+
+  addAddress(currency: string, address: string): void {
+    this.addAddressToCache(currency, address, "triggerCallback");
+  }
+
+  syncAddresses(cache: RecentAddressesCache): void {
+    const previousAddresses = { ...this.addressesByCurrency };
+    this.addressesByCurrency = { ...cache };
+    for (const currency in previousAddresses) {
+      for (const address of previousAddresses[currency]) {
+        this.addAddressToCache(currency, address, "skipCallback");
+      }
+    }
+
+    this.onAddAddressComplete(this.addressesByCurrency);
+  }
+
+  getAddresses(currency: string): string[] {
+    const addresses = this.addressesByCurrency[currency];
+    return addresses ?? [];
+  }
+
+  private addAddressToCache(currency: string, address: string, callbackMode: CallbackMode): void {
+    if (!this.addressesByCurrency[currency]) {
+      this.addressesByCurrency[currency] = [];
+    }
+
+    const addresses = this.addressesByCurrency[currency];
+    const addressIndex = addresses.indexOf(address);
+    if (addressIndex !== -1) {
+      addresses.splice(addressIndex, 1);
+    } else if (addresses.length >= RECENT_ADDRESSES_COUNT_LIMIT) {
+      addresses.pop();
+    }
+
+    addresses.unshift(address);
+    this.addressesByCurrency[currency] = [...addresses];
+
+    if (callbackMode === "triggerCallback") {
+      this.onAddAddressComplete(this.addressesByCurrency);
+    }
+  }
+}

package/src/account/serialization.ts

@@ -99,7 +99,7 @@ const inferFamilyFromAccountId: (accountId: string) => string | null | undefined
     try {
       const { currencyId } = decodeAccountId(accountId);
       return getCryptoCurrencyById(currencyId).family;
-    } catch (e) {
+    } catch {
       return null;
     }
   },

package/src/account/support.ts

@@ -13,7 +13,7 @@ export function canSend(account: AccountLike, parentAccount: Account | null | un
       getMainAccount(account, parentAccount),
     );
     return true;
-  } catch (e) {
+  } catch {
     return false;
   }
 }

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

@@ -1,4 +1,4 @@
-import { AccountBridge } from "@ledgerhq/types-live";
+import type { AccountBridge } from "@ledgerhq/types-live";
 import { makeSync } from "../jsHelpers";
 import { genericGetAccountShape } from "./getAccountShape";
 import {
@@ -16,6 +16,7 @@ import { genericBroadcast } from "./broadcast";
 import { genericSignOperation } from "./signOperation";
 import { genericSignRawOperation } from "./signRawOperation";
 import type { AlpacaSigner } from "./signer/types";
+import { postSync } from "./postSync";
 
 export function getAlpacaAccountBridge(
   network: string,
@@ -24,7 +25,7 @@ export function getAlpacaAccountBridge(
 ): AccountBridge<any> {
   const signer = customSigner ?? getSigner(network);
   return {
-    sync: makeSync({ getAccountShape: genericGetAccountShape(network, kind) }),
+    sync: makeSync({ getAccountShape: genericGetAccountShape(network, kind), postSync }),
     receive: makeAccountBridgeReceive(getAddressWrapper(signer.getAddress)),
     createTransaction: createTransaction,
     updateTransaction: updateTransaction<any>,

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

@@ -1,11 +1,14 @@
 import { AccountBridge, TransactionCommon } from "@ledgerhq/types-live";
-import { patchOperationWithHash } from "../../operation";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
 import { getAlpacaApi } from "./alpaca";
 
 export const genericBroadcast: (network, kind) => AccountBridge<TransactionCommon>["broadcast"] =
   (network, kind) =>
-  async ({ signedOperation: { signature, operation }, account }) => {
-    const hash = await getAlpacaApi(account.currency.id, kind).broadcast(signature);
+  async ({ signedOperation: { signature, operation }, account, broadcastConfig }) => {
+    const hash = await getAlpacaApi(account.currency.id, kind).broadcast(
+      signature,
+      broadcastConfig,
+    );
 
     return patchOperationWithHash(operation, hash);
   };

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

@@ -3,6 +3,7 @@ import { CurrencyBridge } from "@ledgerhq/types-live";
 import { genericGetAccountShape } from "./getAccountShape";
 import { getSigner } from "./signer";
 import type { AlpacaSigner } from "./signer/types";
+import { postSync } from "./postSync";
 
 export function getAlpacaCurrencyBridge(
   network: string,
@@ -12,12 +13,11 @@ export function getAlpacaCurrencyBridge(
   const signer = customSigner ?? getSigner(network);
   return {
     preload: () => Promise.resolve({}),
-    hydrate: () => {
-      return;
-    },
+    hydrate: () => undefined,
     scanAccounts: makeScanAccounts({
       getAccountShape: genericGetAccountShape(network, kind),
       getAddressFn: signer.getAddress.bind(signer),
+      postSync,
     }),
   };
 }

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

@@ -30,11 +30,12 @@ export function genericEstimateMaxSpendable(
         )
       ).value;
     }
+    // TODO Remove the call to `validateIntent` https://ledgerhq.atlassian.net/browse/LIVE-22229
     const { amount } = await alpacaApi.validateIntent(
       transactionToIntent(account, { ...draftTransaction }, alpacaApi.computeIntentType),
       { value: transaction?.fees ? BigInt(transaction.fees.toString()) : 0n },
     );
-    if (["stellar", "tezos"].includes(network)) {
+    if (["stellar", "tezos", "evm"].includes(network)) {
       return amount > 0 ? new BigNumber(amount.toString()) : new BigNumber(0);
     }
     const bnFee = BigNumber(fees.toString());

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

@@ -17,6 +17,19 @@ function isNftCoreOp(operation: Operation): boolean {
   );
 }
 
+function isIncomingCoreOp(operation: Operation): boolean {
+  const type =
+    typeof operation.details?.ledgerOpType === "string"
+      ? operation.details.ledgerOpType
+      : operation.type;
+
+  return type === "IN";
+}
+
+function isInternalLiveOp(operation: OperationCommon): boolean {
+  return !!operation.extra?.internal;
+}
+
 export function genericGetAccountShape(network: string, kind: string): GetAccountShape {
   return async (info, syncConfig) => {
     const { address, initialAccount, currency, derivationMode } = info;
@@ -58,14 +71,14 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
 
     // Calculate minHeight for pagination
     const minHeight = syncFromScratch ? 0 : (oldOps[0]?.blockHeight ?? 0) + 1;
-    const paginationParams: Pagination = { minHeight, order: "asc" };
+    const paginationParams: Pagination = { minHeight, order: "desc" };
     if (lastPagingToken && !syncFromScratch) {
       paginationParams.lastPagingToken = lastPagingToken;
     }
 
     const [newCoreOps] = await alpacaApi.listOperations(address, paginationParams);
     const newOps = newCoreOps
-      .filter(op => !isNftCoreOp(op))
+      .filter(op => !isNftCoreOp(op) && (!isIncomingCoreOp(op) || !op.tx.failed))
       .map(op => adaptCoreOperationToLiveOperation(accountId, op)) as OperationCommon[];
 
     const newAssetOperations = newOps.filter(
@@ -74,6 +87,7 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
         operation?.extra?.assetOwner &&
         !["OPT_IN", "OPT_OUT"].includes(operation.type),
     );
+    const newInternalOperations = newOps.filter(isInternalLiveOp);
     const newSubAccounts = await buildSubAccounts({
       accountId,
       allTokenAssetsBalances,
@@ -85,22 +99,31 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
       ? newSubAccounts
       : mergeSubAccounts(initialAccount?.subAccounts ?? [], newSubAccounts);
 
-    const newOpsWithSubs = newOps.map(op => {
-      const subOperations = inferSubOperations(op.hash, newSubAccounts);
+    const newOpsWithSubs = newOps
+      .filter(operation => !isInternalLiveOp(operation))
+      .map(op => {
+        const subOperations = inferSubOperations(op.hash, newSubAccounts);
+        const internalOperations = newInternalOperations.filter(it => it.hash === op.hash);
 
-      return cleanedOperation({
-        ...op,
-        subOperations,
+        return cleanedOperation({
+          ...op,
+          subOperations,
+          internalOperations,
+        });
       });
-    });
+    // Try to refresh known pending and broadcasted operations (if not already updated)
+    // Useful for integrations without explorers
+    const operationsToRefresh = initialAccount?.pendingOperations.filter(
+      pendingOp =>
+        pendingOp.hash && // operation has been broadcasted
+        !newOpsWithSubs.some(newOp => pendingOp.hash === newOp.hash), // operation is not confirmed yet
+    );
     const confirmedOperations =
-      alpacaApi.refreshOperations && initialAccount?.pendingOperations.length
-        ? await alpacaApi.refreshOperations(initialAccount.pendingOperations)
+      alpacaApi.refreshOperations && operationsToRefresh?.length
+        ? await alpacaApi.refreshOperations(operationsToRefresh)
         : [];
     const newOperations = [...confirmedOperations, ...newOpsWithSubs];
-    const operations = syncFromScratch
-      ? newOperations
-      : (mergeOps(oldOps, newOperations) as OperationCommon[]);
+    const operations = mergeOps(syncFromScratch ? [] : oldOps, newOperations) as OperationCommon[];
 
     const res: Partial<Account> = {
       id: accountId,

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

@@ -26,6 +26,7 @@ export function genericGetTransactionStatus(
       feesStrategy: transaction.feesStrategy,
       data: transaction.data,
       type: transaction.type,
+      sponsored: transaction.sponsored,
     };
 
     if (alpacaApi.getChainSpecificRules) {
@@ -37,10 +38,24 @@ export function genericGetTransactionStatus(
       }
     }
 
+    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()) }
+        : {}),
+    };
     const { errors, warnings, estimatedFees, amount, totalSpent, totalFees } =
       await alpacaApi.validateIntent(
         transactionToIntent(account, draftTransaction, alpacaApi.computeIntentType),
-        { value: transaction.fees ? BigInt(transaction.fees.toString()) : 0n },
+        { value: fees, parameters: feesParameters },
       );
 
     return {

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

@@ -0,0 +1,97 @@
+import type { Account } from "@ledgerhq/types-live";
+import { postSync } from "./postSync";
+import BigNumber from "bignumber.js";
+
+describe("postSync", () => {
+  it("removes confirmed and outdated native operations from the pending pool", () => {
+    const initialAccount = {
+      operations: [{ hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" }],
+      pendingOperations: [
+        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+    } as Account;
+    const synced = {
+      operations: [
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
+        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
+      ],
+      pendingOperations: [
+        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+    } as Account;
+
+    expect(postSync(initialAccount, synced)).toMatchObject({
+      operations: [
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" },
+        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
+      ],
+      pendingOperations: [
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+    });
+  });
+
+  it("removes confirmed and outdated token operations from the pending pool", () => {
+    const initialAccount = {
+      operations: [{ hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" }],
+      pendingOperations: [
+        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "NONE" },
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+      subAccounts: [
+        {
+          pendingOperations: [
+            { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
+            { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
+          ],
+        },
+      ],
+    } as Account;
+    const synced = {
+      operations: [
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
+        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
+      ],
+      pendingOperations: [
+        { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "NONE" },
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+      subAccounts: [
+        {
+          operations: [{ hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "OUT" }],
+          pendingOperations: [
+            { hash: "outdated", transactionSequenceNumber: new BigNumber(3), type: "IN" },
+          ],
+        },
+      ],
+    } as Account;
+
+    expect(postSync(initialAccount, synced)).toMatchObject({
+      operations: [
+        { hash: "hash1", transactionSequenceNumber: new BigNumber(5), type: "FEES" },
+        { hash: "hash0", transactionSequenceNumber: new BigNumber(4), type: "OUT" },
+      ],
+      pendingOperations: [
+        { hash: "hash2", transactionSequenceNumber: new BigNumber(6), type: "IN" },
+      ],
+      subAccounts: [
+        {
+          operations: [
+            {
+              hash: "hash1",
+              transactionSequenceNumber: new BigNumber(5),
+              type: "OUT",
+            },
+          ],
+          pendingOperations: [],
+        },
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,42 @@
+import type { Account, AccountLike, Operation } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+/**
+ * After each sync or scan, remove operations from the pending pools if necessary
+ * Operations stay pending if and only if
+ *  - they are confirmed, i.e. their hash appear in the operation list
+ *  - they are not outdated, i.e. their sequence number is at least greater than the
+ *    sequence number of the latest transaction
+ * NOTE Compared to the default behaviour
+ *  - pending operations of token accounts are cleaned up, so we don't see both pending and completed
+ *    sub operations in the operation details drawer
+ *  - pending operations are cleaned if their hash already belong to the completed operations, preventing
+ *    undesired replacement (ex: optimistic operation for self token sending on EVM is incomplete, since
+ *    it only contains the OUT sub operation)
+ */
+export function postSync(initial: Account, synced: Account): Account {
+  const lastOperation = synced.operations.find(op => ["OUT", "FEES"].includes(op.type));
+  const latestSequence = lastOperation?.transactionSequenceNumber || new BigNumber(-1);
+
+  function isPending(account: AccountLike, op: Operation): boolean {
+    return (
+      // Operation is not confirmed
+      !account.operations.some(o => o.hash === op.hash) &&
+      // Operation is not outdated
+      op.transactionSequenceNumber !== undefined &&
+      op.transactionSequenceNumber.gt(latestSequence)
+    );
+  }
+
+  const pendingOperations = initial.pendingOperations.length
+    ? initial.pendingOperations.filter(op => isPending(synced, op))
+    : [];
+  const subAccounts = synced.subAccounts?.length
+    ? synced.subAccounts.map(subAccount => ({
+        ...subAccount,
+        pendingOperations: subAccount.pendingOperations.filter(op => isPending(subAccount, op)),
+      }))
+    : [];
+
+  return { ...synced, pendingOperations, subAccounts };
+}

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

@@ -31,6 +31,11 @@ function propagateField(estimation: FeeEstimation, field: string, dest: GenericT
       dest[field] = Number(value.toString());
       return;
     case "storageLimit":
+    case "gasLimit":
+    case "gasPrice":
+    case "maxFeePerGas":
+    case "maxPriorityFeePerGas":
+    case "additionalFees":
       dest[field] = new BigNumber(value.toString());
       return;
     default:
@@ -51,17 +56,42 @@ export function genericPrepareTransaction(
       ? await getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
       : assetInfosFallback(transaction);
     const customParametersFees = transaction.customFees?.parameters?.fees;
+
+    /**
+     * Ticking `useAllAmount` constantly resets the amount to 0. This is problematic
+     * because some Blockchain need the actual transaction amount to compute the fees
+     * (Example with EVM and ERC20 transactions)
+     * In case of `useAllAmount` and token transaction, we read the token account spendable
+     * balance instead.
+     */
+    let amount = transaction.amount;
+    if (transaction.useAllAmount && transaction.subAccountId) {
+      const subAccount = account.subAccounts?.find(acc => acc.id === transaction.subAccountId);
+      amount = subAccount?.spendableBalance ?? amount;
+    }
+
+    // Pass any parameters that help estimating fees
+    // This includes `assetOwner` and `assetReference` that are not used by some apps that only rely on `subAccountId`
+    // TODO Remove `assetOwner` and `assetReference` in order to maintain one unique way of identifying the type of asset
+    // https://ledgerhq.atlassian.net/browse/LIVE-24044
+    const intent = transactionToIntent(
+      account,
+      {
+        ...transaction,
+        assetOwner,
+        assetReference,
+        amount,
+      },
+      computeIntentType,
+    );
     const estimation: FeeEstimation = customParametersFees
       ? { value: BigInt(customParametersFees.toFixed()) }
-      : await estimateFees(
-          transactionToIntent(
-            account,
-            {
-              ...transaction,
-            },
-            computeIntentType,
-          ),
-        );
+      : await estimateFees(intent, {
+          gasPrice: transaction.gasPrice,
+          maxFeePerGas: transaction.maxFeePerGas,
+          maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+          gasOptions: transaction.gasOptions,
+        });
     const fees = new BigNumber(estimation.value.toString());
 
     if (!bnEq(transaction.fees, fees)) {
@@ -78,7 +108,15 @@ export function genericPrepareTransaction(
       };
 
       // Propagate needed fields
-      const fieldsToPropagate = ["type", "storageLimit"];
+      const fieldsToPropagate = [
+        "type",
+        "storageLimit",
+        "gasLimit",
+        "gasPrice",
+        "maxFeePerGas",
+        "maxPriorityFeePerGas",
+        "additionalFees",
+      ];
 
       for (const field of fieldsToPropagate) {
         propagateField(estimation, field, next);
@@ -86,11 +124,14 @@ export function genericPrepareTransaction(
 
       // align with stellar/xrp: when send max (or staking intents), reflect validated amount in UI
       if (transaction.useAllAmount || ["stake", "unstake"].includes(transaction.mode ?? "")) {
+        // TODO Remove the call to `validateIntent` https://ledgerhq.atlassian.net/browse/LIVE-22228
         const { amount } = await validateIntent(
           transactionToIntent(
             account,
             {
               ...transaction,
+              assetOwner,
+              assetReference,
             },
             computeIntentType,
           ),