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

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,
           ),

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 {