@ledgerhq/live-common 34.47.0 → 34.48.0-nightly.1

package/src/bridge/crypto-assets/cal-store.ts

@@ -0,0 +1,63 @@
+import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+// Coins with case-sensitive addresses (b58, ...)
+const CASE_SENSITIVE_COINS = ["solana"];
+
+export class CALStore implements CryptoAssetsStore {
+  private tokenCache = new Map<string, TokenCurrency>();
+  private addressCache = new Map<string, TokenCurrency>();
+  private tickerCache = new Map<string, TokenCurrency>();
+
+  addTokens(tokens: TokenCurrency[]) {
+    tokens.forEach(token => {
+      this.tokenCache.set(token.id, token);
+      if (token.contractAddress) {
+        const isCaseSensitive = CASE_SENSITIVE_COINS.includes(token.parentCurrency.id);
+        const normalizedAddress = isCaseSensitive
+          ? token.contractAddress
+          : token.contractAddress.toLowerCase();
+        this.addressCache.set(normalizedAddress, token);
+      }
+      this.tickerCache.set(token.ticker, token);
+    });
+  }
+
+  findTokenByAddress(address: string): TokenCurrency | undefined {
+    const exactMatch = this.addressCache.get(address);
+    if (exactMatch) return exactMatch;
+
+    const lowercaseMatch = this.addressCache.get(address.toLowerCase());
+    return lowercaseMatch;
+  }
+
+  getTokenById(id: string): TokenCurrency {
+    const token = this.tokenCache.get(id);
+    if (!token) {
+      throw new Error(`Token not found: ${id}`);
+    }
+    return token;
+  }
+
+  findTokenById(id: string): TokenCurrency | undefined {
+    return this.tokenCache.get(id);
+  }
+
+  findTokenByAddressInCurrency(address: string, currencyId: string): TokenCurrency | undefined {
+    const isCaseSensitive = CASE_SENSITIVE_COINS.includes(currencyId);
+
+    if (isCaseSensitive) {
+      const token = this.addressCache.get(address);
+      if (token && token.parentCurrency.id === currencyId) return token;
+      return undefined;
+    }
+
+    const token = this.addressCache.get(address.toLowerCase());
+    if (token && token.parentCurrency.id === currencyId) return token;
+    return undefined;
+  }
+
+  findTokenByTicker(ticker: string): TokenCurrency | undefined {
+    return this.tickerCache.get(ticker);
+  }
+}

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

@@ -2,8 +2,22 @@ import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import * as calIntegration from "./cal-integration";
 
 describe("Testing CryptoAssetStore", () => {
+  let isCALIntegrationEnabledSpy: jest.SpyInstance;
+  let getCALStoreSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    isCALIntegrationEnabledSpy = jest
+      .spyOn(calIntegration, "isCALIntegrationEnabled")
+      .mockReturnValue(false);
+    getCALStoreSpy = jest.spyOn(calIntegration, "getCALStore");
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
   it("should return the default methods from cryptoassets libs when feature flag does not exists", () => {
     LiveConfig.setConfig({
       some_other_feature: {
@@ -68,4 +82,37 @@ describe("Testing CryptoAssetStore", () => {
     const store = getCryptoAssetsStore();
     expect(store).toBe(newStore);
   });
+
+  it("should return CAL store when CAL integration is enabled", () => {
+    isCALIntegrationEnabledSpy.mockReturnValue(true);
+
+    const mockCALStore = {} as unknown as CryptoAssetsStore;
+    getCALStoreSpy.mockReturnValue(mockCALStore);
+
+    const store = getCryptoAssetsStore();
+
+    expect(isCALIntegrationEnabledSpy).toHaveBeenCalled();
+    expect(getCALStoreSpy).toHaveBeenCalled();
+    expect(store).toBe(mockCALStore);
+  });
+
+  it("should prioritize CAL integration over feature flags", () => {
+    isCALIntegrationEnabledSpy.mockReturnValue(true);
+
+    LiveConfig.setConfig({
+      feature_cal_lazy_loading: {
+        type: "boolean",
+        default: true,
+      },
+    });
+
+    const mockCALStore = {} as unknown as CryptoAssetsStore;
+    getCALStoreSpy.mockReturnValue(mockCALStore);
+
+    const store = getCryptoAssetsStore();
+
+    expect(store).toBe(mockCALStore);
+    expect(isCALIntegrationEnabledSpy).toHaveBeenCalled();
+    expect(getCALStoreSpy).toHaveBeenCalled();
+  });
 });

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

@@ -1,6 +1,7 @@
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import * as legacy from "@ledgerhq/cryptoassets/tokens";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { isCALIntegrationEnabled, getCALStore } from "./cal-integration";
 
 const legacyStore: CryptoAssetsStore = {
   findTokenByAddress: legacy.findTokenByAddress,
@@ -17,6 +18,10 @@ export function setCryptoAssetsStore(store: CryptoAssetsStore) {
 }
 
 export function getCryptoAssetsStore(): CryptoAssetsStore {
+  if (isCALIntegrationEnabled()) {
+    return getCALStore();
+  }
+
   const featureEnabled =
     LiveConfig.isConfigSet() && LiveConfig.getValueByKey("feature_cal_lazy_loading");
   if (!featureEnabled) {

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

@@ -1,16 +1,19 @@
 import { createApi as createXrpApi } from "@ledgerhq/coin-xrp/api/index";
 import { createApi as createStellarApi } from "@ledgerhq/coin-stellar/api/index";
+import { createApi as createCantonApi } from "@ledgerhq/coin-canton/api/index";
+import { createApi as createTronApi } from "@ledgerhq/coin-tron/api/index";
 import { getCurrencyConfiguration } from "../../../config";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getNetworkAlpacaApi } from "./network/network-alpaca";
 import { Api } from "@ledgerhq/coin-framework/api/types";
 import { XrpCoinConfig } from "@ledgerhq/coin-xrp/config";
 import { StellarCoinConfig } from "@ledgerhq/coin-stellar/config";
+import { CantonCoinConfig } from "@ledgerhq/coin-canton/config";
+import { TronCoinConfig } from "@ledgerhq/coin-tron/config";
 
 export function getAlpacaApi(network, kind): Api<any> {
   if (kind === "local") {
     switch (network) {
-      case "ripple":
       case "xrp":
         return createXrpApi(
           getCurrencyConfiguration<XrpCoinConfig>(getCryptoCurrencyById("ripple")),
@@ -19,6 +22,16 @@ export function getAlpacaApi(network, kind): Api<any> {
         return createStellarApi(
           getCurrencyConfiguration<StellarCoinConfig>(getCryptoCurrencyById("stellar")),
         ) as Api<any>;
+      case "canton":
+        return createCantonApi(
+          getCurrencyConfiguration<CantonCoinConfig>(
+            getCryptoCurrencyById("canton_network_devnet"),
+          ),
+        ) as Api<any>;
+      case "tron":
+        return createTronApi(
+          getCurrencyConfiguration<TronCoinConfig>(getCryptoCurrencyById("tron")),
+        ) as Api<any>;
     }
   }
   return getNetworkAlpacaApi(network) satisfies Partial<Api<any>> as Api<any>;

package/src/bridge/generic-alpaca/alpaca/index.unit.test.ts

@@ -0,0 +1,78 @@
+import { getAlpacaApi } from "./index";
+import * as xrpModule from "@ledgerhq/coin-xrp/api/index";
+import * as stellarModule from "@ledgerhq/coin-stellar/api/index";
+import * as cantonModule from "@ledgerhq/coin-canton/api/index";
+import * as tronModule from "@ledgerhq/coin-tron/api/index";
+import * as config from "../../../config";
+import * as networkApi from "./network/network-alpaca";
+import * as cryptoAssets from "@ledgerhq/cryptoassets/currencies";
+
+const mockApiInstance = { mock: "api" };
+
+jest.mock("@ledgerhq/cryptoassets/currencies", () => ({
+  getCryptoCurrencyById: jest.fn(),
+}));
+
+jest.mock("../../../config", () => ({
+  getCurrencyConfiguration: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-xrp/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-stellar/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-canton/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-tron/api/index", () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock("./network/network-alpaca", () => ({
+  getNetworkAlpacaApi: jest.fn(),
+}));
+
+describe("getAlpacaApi", () => {
+  const mockCurrency = { id: "mock-currency" };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Common mocks
+    (cryptoAssets.getCryptoCurrencyById as jest.Mock).mockReturnValue(mockCurrency);
+    (config.getCurrencyConfiguration as jest.Mock).mockReturnValue({ config: true });
+
+    // API mocks
+    jest.spyOn(xrpModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(stellarModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(cantonModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(tronModule, "createApi").mockReturnValue(mockApiInstance as any);
+    jest.spyOn(networkApi, "getNetworkAlpacaApi").mockReturnValue(mockApiInstance as any);
+  });
+
+  const testCases = [
+    { network: "xrp", module: xrpModule, label: "XRP" },
+    { network: "stellar", module: stellarModule, label: "Stellar" },
+    { network: "tron", module: tronModule, label: "Tron" },
+    { network: "canton", module: cantonModule, label: "Canton" },
+  ];
+
+  testCases.forEach(({ network, module, label }) => {
+    it(`should return ${label} API for network "${network}" and kind "local"`, () => {
+      const result = getAlpacaApi(network, "local");
+      expect(result).toEqual(mockApiInstance);
+      expect(module.createApi).toHaveBeenCalledWith({ config: true });
+    });
+  });
+
+  it("should return network API for kind !== 'local'", () => {
+    const result = getAlpacaApi("xrp", "remote");
+    expect(networkApi.getNetworkAlpacaApi).toHaveBeenCalledWith("xrp");
+    expect(result).toEqual(mockApiInstance);
+  });
+});

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

@@ -13,6 +13,7 @@ import type {
   Page,
   Stake,
   Reward,
+  CraftedTransaction,
 } from "@ledgerhq/coin-framework/api/index";
 import network from "@ledgerhq/live-network";
 
@@ -134,7 +135,7 @@ const buildGetSequence = (networkFamily: string) =>
 const buildListOperations = networkFamily =>
   async function listOperations(
     address: string,
-    pagination: Pagination = { minHeight: 0 },
+    pagination: Pagination = { minHeight: 0, order: "asc" },
   ): Promise<[Operation<any>[], string]> {
     const { data } = await network<{ operations: Operation<any>[] }, unknown>({
       method: "GET",
@@ -160,8 +161,8 @@ const buildLastBlock = networkFamily =>
   };
 
 const buildCraftTransaction = networkFamily =>
-  async function craftTransaction(intent: TransactionIntent<any>): Promise<string> {
-    const { data } = await network<any, unknown>({
+  async function craftTransaction(intent: TransactionIntent<any>): Promise<CraftedTransaction> {
+    const { data } = await network<CraftedTransaction, unknown>({
       method: "POST",
       url: `${ALPACA_URL}/${networkFamily}/transaction/encode`,
       data: {
@@ -171,7 +172,7 @@ const buildCraftTransaction = networkFamily =>
         },
       },
     });
-    return data.rawTransaction;
+    return data;
   };
 
 export const getNetworkAlpacaApi = (networkFamily: string) =>

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

@@ -1,11 +1,10 @@
 import BigNumber from "bignumber.js";
-import { emptyHistoryCache } from "@ledgerhq/coin-framework/account/index";
+import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Operation, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import { AssetInfo, Balance } from "@ledgerhq/coin-framework/api/types";
-import { findTokenById } from "@ledgerhq/cryptoassets/tokens";
 
 export interface OperationCommon extends Operation {
   extra: Record<string, any>;
@@ -13,11 +12,6 @@ export interface OperationCommon extends Operation {
 
 export const getAssetIdFromTokenId = (tokenId: string): string => tokenId.split("/")[2];
 
-export const getAssetIdFromAsset = (asset: AssetInfo) =>
-  asset.type !== "native" && "assetReference" in asset && "assetOwner" in asset
-    ? `${asset.assetReference}:${asset.assetOwner}`
-    : "";
-
 function buildTokenAccount({
   parentAccountId,
   assetBalance,
@@ -29,8 +23,7 @@ function buildTokenAccount({
   token: TokenCurrency;
   operations: OperationCommon[];
 }): TokenAccount {
-  const assetId = getAssetIdFromTokenId(token.id);
-  const id = `${parentAccountId}+${assetId}`;
+  const id = encodeTokenAccountId(parentAccountId, token);
   const balance = new BigNumber(assetBalance.value.toString() || "0");
 
   // TODO: recheck this logic
@@ -68,12 +61,14 @@ export function buildSubAccounts({
   assetsBalance,
   syncConfig,
   operations,
+  getTokenFromAsset,
 }: {
   currency: CryptoCurrency;
   accountId: string;
   assetsBalance: Balance[];
   syncConfig: SyncConfig;
   operations: OperationCommon[];
+  getTokenFromAsset?: (asset: AssetInfo) => TokenCurrency | undefined;
 }): TokenAccount[] | undefined {
   const { blacklistedTokenIds = [] } = syncConfig;
   const allTokens = listTokensForCryptoCurrency(currency);
@@ -85,7 +80,7 @@ export function buildSubAccounts({
   assetsBalance
     .filter(b => b.asset.type !== "native") // NOTE: this could be removed, keeping here while fixing things up
     .map(balance => {
-      const token = findToken(currency, balance);
+      const token = getTokenFromAsset && getTokenFromAsset(balance.asset);
       // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
       if (token && !blacklistedTokenIds.includes(token.id)) {
         tokenAccounts.push(
@@ -104,7 +99,3 @@ export function buildSubAccounts({
     });
   return tokenAccounts;
 }
-
-export function findToken(currency: CryptoCurrency, balance: Balance): TokenCurrency | undefined {
-  return findTokenById(`${currency.family}/asset/${getAssetIdFromAsset(balance.asset)}`);
-}

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

@@ -4,7 +4,6 @@ import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
 import { inferSubOperations } from "@ledgerhq/coin-framework/serialization";
-import { findToken } from "./buildSubAccounts";
 import { buildSubAccounts, OperationCommon } from "./buildSubAccounts";
 
 export function genericGetAccountShape(network: string, kind: string): GetAccountShape {
@@ -33,8 +32,7 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
 
     const assetsBalance = balanceRes
       .filter(b => b.asset.type !== "native")
-      .filter(b => findToken(currency, b));
-
+      .filter(b => alpacaApi.getTokenFromAsset && alpacaApi.getTokenFromAsset(b.asset));
     const nativeBalance = BigInt(nativeAsset?.value ?? "0");
 
     const spendableBalance = BigInt(nativeBalance - BigInt(nativeAsset?.locked ?? "0"));
@@ -43,7 +41,7 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
     const lastPagingToken = oldOps[0]?.extra?.pagingToken || "";
 
     const blockHeight = oldOps.length ? (oldOps[0].blockHeight ?? 0) + 1 : 0;
-    const paginationParams: any = { minHeight: blockHeight };
+    const paginationParams: any = { minHeight: blockHeight, order: "asc" };
     if (lastPagingToken) {
       paginationParams.lastPagingToken = lastPagingToken;
     }
@@ -72,6 +70,7 @@ export function genericGetAccountShape(network: string, kind: string): GetAccoun
         assetsBalance,
         syncConfig,
         operations: assetOperations,
+        getTokenFromAsset: alpacaApi.getTokenFromAsset,
       }) || [];
 
     const operationsWithSubs = mergedOps.map(op => {

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

@@ -3,7 +3,6 @@ import { AccountAwaitingSendPendingOperations } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
-// import { FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 
 // => alpaca validateIntent
 export function genericGetTransactionStatus(

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

@@ -2,27 +2,41 @@ import { Account, AccountBridge, TransactionCommon } from "@ledgerhq/types-live"
 import { getAlpacaApi } from "./alpaca";
 import { transactionToIntent } from "./utils";
 import BigNumber from "bignumber.js";
-import { FeeEstimation } 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";
 
 function bnEq(a: BigNumber | null | undefined, b: BigNumber | null | undefined): boolean {
   return !a && !b ? true : !a || !b ? false : a.eq(b);
 }
 
+type TransactionParam = TransactionCommon & {
+  fees: BigNumber | null | undefined;
+  customFees?: FeeEstimation;
+  assetReference?: string;
+  assetOwner?: string;
+  subAccountId?: string;
+};
+
+function assetInfosFallback(transaction: TransactionParam): {
+  assetReference: string;
+  assetOwner: string;
+} {
+  return {
+    assetReference: transaction.assetReference ?? "",
+    assetOwner: transaction.assetOwner ?? "",
+  };
+}
+
 export function genericPrepareTransaction(
   network: string,
   kind,
 ): AccountBridge<TransactionCommon, Account, any, any>["prepareTransaction"] {
-  return async (
-    account,
-    transaction: TransactionCommon & {
-      fees: BigNumber | null | undefined;
-      customFees?: FeeEstimation;
-      assetReference?: string;
-      assetOwner?: string;
-      subAccountId?: string;
-    },
-  ) => {
-    const [assetReference, assetOwner] = getAssetInfos(transaction);
+  return async (account, transaction: TransactionParam) => {
+    const { getAssetFromToken } = getAlpacaApi(network, kind);
+    const { assetReference, assetOwner } = getAssetFromToken
+      ? getAssetInfos(transaction, account.freshAddress, getAssetFromToken)
+      : assetInfosFallback(transaction);
 
     let fees = transaction.customFees?.parameters?.fees || null;
     if (fees === null) {
@@ -54,11 +68,24 @@ export function genericPrepareTransaction(
 }
 
 export function getAssetInfos(
-  tr: TransactionCommon & { assetReference?: string; assetOwner?: string },
-): string[] {
+  tr: TransactionParam,
+  owner: string,
+  getAssetFromToken: (token: TokenCurrency, owner: string) => AssetInfo,
+): {
+  assetReference: string;
+  assetOwner: string;
+} {
   if (tr.subAccountId) {
-    const assetString = tr.subAccountId.split("+")[1];
-    return assetString.split(":");
+    const { token } = decodeTokenAccountId(tr.subAccountId);
+
+    if (!token) return assetInfosFallback(tr);
+
+    const asset = getAssetFromToken(token, owner);
+
+    return {
+      assetOwner: ("assetOwner" in asset && asset.assetOwner) || "",
+      assetReference: ("assetReference" in asset && asset.assetReference) || "",
+    };
   }
-  return [tr.assetReference || "", tr.assetOwner || ""];
+  return assetInfosFallback(tr);
 }

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

@@ -123,7 +123,7 @@ export const genericSignOperation =
           transactionIntent.sequence = sequenceNumber;
 
           /* Craft unsigned blob via Alpaca */
-          const unsigned: string = await getAlpacaApi(network, kind).craftTransaction(
+          const { transaction: unsigned } = await getAlpacaApi(network, kind).craftTransaction(
             transactionIntent,
             { value: fees },
           );

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

@@ -0,0 +1,133 @@
+import { adaptCoreOperationToLiveOperation, extractBalance } from "./utils";
+import BigNumber from "bignumber.js";
+import { Operation as CoreOperation } from "@ledgerhq/coin-framework/api/types";
+
+describe("Alpaca utils", () => {
+  describe("extractBalance", () => {
+    it("extracts an existing balance", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type1")).toEqual({
+        value: 4n,
+        asset: { type: "type1" },
+      });
+    });
+
+    it("generates an empty balance for a missing type", () => {
+      expect(extractBalance([{ value: 4n, asset: { type: "type1" } }], "type2")).toEqual({
+        value: 0n,
+        asset: { type: "type2" },
+      });
+    });
+  });
+
+  jest.mock("@ledgerhq/coin-framework/operation", () => ({
+    encodeOperationId: jest.fn((accountId, txHash, opType) => `${accountId}-${txHash}-${opType}`),
+  }));
+
+  describe("adaptCoreOperationToLiveOperation", () => {
+    const accountId = "acc_123";
+    const baseOp: CoreOperation = {
+      id: "op_123",
+      asset: { type: "native" },
+      type: "OUT",
+      value: BigInt(100),
+      tx: {
+        hash: "txhash123",
+        fees: BigInt(10),
+        block: {
+          hash: "blockhash123",
+          height: 123456,
+        },
+        date: new Date("2025-08-29T12:00:00Z"),
+      },
+      senders: ["sender1"],
+      recipients: ["recipient1"],
+    };
+
+    it("does not include fees in non native asset value", () => {
+      expect(
+        adaptCoreOperationToLiveOperation("account", {
+          id: "operation",
+          asset: { type: "token", assetOwner: "owner", assetReference: "reference" },
+          type: "OUT",
+          value: BigInt(100),
+          tx: {
+            hash: "hash",
+            fees: BigInt(10),
+            block: {
+              hash: "block_hash",
+              height: 123456,
+            },
+            date: new Date("2025-08-29T12:00:00Z"),
+          },
+          senders: ["sender"],
+          recipients: ["recipient"],
+        }),
+      ).toEqual({
+        id: "account-hash-OUT",
+        hash: "hash",
+        accountId: "account",
+        type: "OUT",
+        value: new BigNumber(100), // value only
+        fee: new BigNumber(10),
+        extra: {
+          assetOwner: "owner",
+          assetReference: "reference",
+        },
+        blockHash: "block_hash",
+        blockHeight: 123456,
+        senders: ["sender"],
+        recipients: ["recipient"],
+        date: new Date("2025-08-29T12:00:00Z"),
+        transactionSequenceNumber: undefined,
+        hasFailed: false,
+      });
+    });
+
+    it("adapts a basic OUT operation", () => {
+      const result = adaptCoreOperationToLiveOperation(accountId, baseOp);
+
+      expect(result).toEqual({
+        id: "acc_123-txhash123-OUT",
+        hash: "txhash123",
+        accountId,
+        type: "OUT",
+        value: new BigNumber(110), // value + fee
+        fee: new BigNumber(10),
+        blockHash: "blockhash123",
+        blockHeight: 123456,
+        senders: ["sender1"],
+        recipients: ["recipient1"],
+        date: new Date("2025-08-29T12:00:00Z"),
+        transactionSequenceNumber: undefined,
+        hasFailed: false,
+        extra: {},
+      });
+    });
+
+    it("handles FEES operation where value = value + fees", () => {
+      const op = {
+        ...baseOp,
+        type: "FEES",
+        value: BigInt(5),
+        tx: { ...baseOp.tx, fees: BigInt(2) },
+      };
+
+      const result = adaptCoreOperationToLiveOperation(accountId, op);
+
+      expect(result.value.toString()).toEqual("7");
+    });
+
+    it("handles non-FEES/OUT operation where value = value only", () => {
+      const op = {
+        ...baseOp,
+        type: "IN",
+        value: BigInt(50),
+        tx: { ...baseOp.tx, fees: BigInt(2) },
+      };
+
+      const result = adaptCoreOperationToLiveOperation(accountId, op);
+
+      expect(result.value.toString()).toEqual("50");
+    });
+  });
+});

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

@@ -44,15 +44,17 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   if (op.details?.memo) {
     extra.memo = op.details.memo as string;
   }
+  const bnFees = new BigNumber(op.tx.fees.toString());
   const res = {
-    id: extra.ledgerOpType
-      ? encodeOperationId(accountId, op.tx.hash, extra.ledgerOpType)
-      : encodeOperationId(accountId, op.tx.hash, op.type),
+    id: encodeOperationId(accountId, op.tx.hash, op.type),
     hash: op.tx.hash,
     accountId,
     type: opType,
-    value: new BigNumber(op.value.toString()),
-    fee: new BigNumber(op.tx.fees.toString()),
+    value:
+      op.asset.type === "native" && ["OUT", "FEES"].includes(opType)
+        ? new BigNumber(op.value.toString()).plus(bnFees)
+        : new BigNumber(op.value.toString()),
+    fee: bnFees,
     blockHash: op.tx.block.hash,
     blockHeight: op.tx.block.height,
     senders: op.senders,