@ledgerhq/coin-stellar 6.26.0 → 6.26.2

package/src/logic/getBlock.ts

@@ -1,17 +1,21 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import type { RawOperation, StellarMemo } from '../types'
 import type {
   AssetInfo,
   Block,
   BlockInfo,
   BlockOperation,
   BlockTransaction,
-} from "@ledgerhq/coin-module-framework/api/index";
-import { fetchAllLedgerOperations, fetchLedgerRecord } from "../network";
-import type { RawOperation } from "../types";
-import { parseAPIValue } from "./common";
-import { assertUnreachable } from "./utils";
-import BigNumber from "bignumber.js";
+} from '@ledgerhq/coin-module-framework/api/index'
+import BigNumber from 'bignumber.js'
+import { fetchAllLedgerOperations, fetchLedgerRecord } from '../network'
+import { decodeMemo, parseSequence } from '../network/serialization'
+import { parseAPIValue } from './common'
+import { assertUnreachable } from './utils'
 
-const NATIVE_ASSET: AssetInfo = { type: "native", name: "XLM" };
+const NATIVE_ASSET: AssetInfo = { type: 'native', name: 'XLM' }
 
 /**
  * Horizon `type` strings that `getBlock` maps into `BlockOperation` entries.
@@ -20,148 +24,148 @@ const NATIVE_ASSET: AssetInfo = { type: "native", name: "XLM" };
  * other operation kinds are ignored until a later iteration expands coverage.
  */
 const SUPPORTED_GETBLOCK_OP_TYPES = new Set<string>([
-  "create_account",
-  "payment",
-  "path_payment_strict_send",
-  "path_payment_strict_receive",
-  "change_trust",
-]);
+  'create_account',
+  'payment',
+  'path_payment_strict_send',
+  'path_payment_strict_receive',
+  'change_trust',
+])
 
-type RawPathStrictSendOp = Extract<RawOperation, { type: "path_payment_strict_send" }>;
-type RawPathStrictReceiveOp = Extract<RawOperation, { type: "path_payment_strict_receive" }> & {
-  send_max?: string;
-};
+type RawPathStrictSendOp = Extract<RawOperation, { type: 'path_payment_strict_send' }>
+type RawPathStrictReceiveOp = Extract<RawOperation, { type: 'path_payment_strict_receive' }> & {
+  send_max?: string
+}
 
 /** Horizon ops mapped by `getBlock`; kept in sync with `SUPPORTED_GETBLOCK_OP_TYPES`. */
 type SupportedGetBlockOperation = Extract<
   RawOperation,
-  | { type: "payment" }
-  | { type: "create_account" }
-  | { type: "change_trust" }
-  | { type: "path_payment_strict_send" }
-  | { type: "path_payment_strict_receive" }
->;
+  | { type: 'payment' }
+  | { type: 'create_account' }
+  | { type: 'change_trust' }
+  | { type: 'path_payment_strict_send' }
+  | { type: 'path_payment_strict_receive' }
+>
 
 function pathStrictDualLegTransfers(params: {
-  fromAddr: string | undefined;
-  toAddr: string | undefined;
-  sourceAsset: AssetInfo;
-  destAsset: AssetInfo;
-  sourceStroops: bigint;
-  destStroops: bigint;
+  fromAddr: string | undefined
+  toAddr: string | undefined
+  sourceAsset: AssetInfo
+  destAsset: AssetInfo
+  sourceStroops: bigint
+  destStroops: bigint
 }): BlockOperation[] {
-  const { fromAddr, toAddr, sourceAsset, destAsset, sourceStroops, destStroops } = params;
-  const ops: BlockOperation[] = [];
+  const { fromAddr, toAddr, sourceAsset, destAsset, sourceStroops, destStroops } = params
+  const ops: BlockOperation[] = []
   if (fromAddr && sourceStroops !== 0n) {
     ops.push({
-      type: "transfer",
+      type: 'transfer',
       address: fromAddr,
       ...(toAddr && { peer: toAddr }),
       asset: sourceAsset,
       amount: -sourceStroops,
-    });
+    })
   }
   if (toAddr && destStroops !== 0n) {
     ops.push({
-      type: "transfer",
+      type: 'transfer',
       address: toAddr,
       ...(fromAddr && { peer: fromAddr }),
       asset: destAsset,
       amount: destStroops,
-    });
+    })
   }
-  return ops;
+  return ops
 }
 
 function toStroops(amountStr: string | undefined): bigint {
   if (!amountStr) {
-    return 0n;
+    return 0n
   }
-  return BigInt(parseAPIValue(amountStr).integerValue(BigNumber.ROUND_FLOOR).toFixed(0));
+  return BigInt(parseAPIValue(amountStr).integerValue(BigNumber.ROUND_FLOOR).toFixed(0))
 }
 
 function assetFromHorizonFields(
   assetType: string | undefined,
   assetCode: string | undefined,
-  assetIssuer: string | undefined,
+  assetIssuer: string | undefined
 ): AssetInfo {
-  if (!assetType || assetType === "native") {
-    return NATIVE_ASSET;
+  if (!assetType || assetType === 'native') {
+    return NATIVE_ASSET
   }
   return {
-    type: "token",
-    assetReference: assetCode ?? "",
-    assetOwner: assetIssuer ?? "",
-  };
+    type: 'token',
+    assetReference: assetCode ?? '',
+    assetOwner: assetIssuer ?? '',
+  }
 }
 
 function isSupportedGetBlockOperation(op: RawOperation): op is SupportedGetBlockOperation {
-  return SUPPORTED_GETBLOCK_OP_TYPES.has(op.type);
+  return SUPPORTED_GETBLOCK_OP_TYPES.has(op.type)
 }
 
 function orderTransactionHashes(rawOps: RawOperation[]): string[] {
-  const order: string[] = [];
-  const seen = new Set<string>();
+  const order: string[] = []
+  const seen = new Set<string>()
   for (const op of rawOps) {
-    const h = op.transaction_hash;
+    const h = op.transaction_hash
     if (!seen.has(h)) {
-      seen.add(h);
-      order.push(h);
+      seen.add(h)
+      order.push(h)
     }
   }
-  return order;
+  return order
 }
 
 function groupOpsByHash(rawOps: RawOperation[]): Map<string, RawOperation[]> {
-  const map = new Map<string, RawOperation[]>();
+  const map = new Map<string, RawOperation[]>()
   for (const op of rawOps) {
-    const h = op.transaction_hash;
-    const list = map.get(h);
-    if (list) list.push(op);
-    else map.set(h, [op]);
+    const h = op.transaction_hash
+    const list = map.get(h)
+    if (list) list.push(op)
+    else map.set(h, [op])
   }
-  return map;
+  return map
 }
 
 function mapPaymentLikeTransfer(
   fromAddr: string | undefined,
   toAddr: string | undefined,
   amountStr: string | undefined,
-  asset: AssetInfo,
+  asset: AssetInfo
 ): BlockOperation[] {
-  const amount = toStroops(amountStr);
+  const amount = toStroops(amountStr)
   if (amount === 0n) {
-    return [];
+    return []
   }
-  const ops: BlockOperation[] = [];
+  const ops: BlockOperation[] = []
   if (fromAddr) {
     ops.push({
-      type: "transfer",
+      type: 'transfer',
       address: fromAddr,
       ...(toAddr && { peer: toAddr }),
       asset,
       amount: -amount,
-    });
+    })
   }
   if (toAddr) {
     ops.push({
-      type: "transfer",
+      type: 'transfer',
       address: toAddr,
       ...(fromAddr && { peer: fromAddr }),
       asset,
       amount,
-    });
+    })
   }
-  return ops;
+  return ops
 }
 
 function blockOperationsPathStrictSend(op: RawPathStrictSendOp): BlockOperation[] {
-  const destAsset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer);
+  const destAsset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer)
   const sourceAsset = assetFromHorizonFields(
     op.source_asset_type,
     op.source_asset_code,
-    op.source_asset_issuer,
-  );
+    op.source_asset_issuer
+  )
   return pathStrictDualLegTransfers({
     fromAddr: op.from,
     toAddr: op.to,
@@ -169,18 +173,18 @@ function blockOperationsPathStrictSend(op: RawPathStrictSendOp): BlockOperation[
     destAsset,
     sourceStroops: toStroops(op.source_amount),
     destStroops: toStroops(op.amount),
-  });
+  })
 }
 
 function blockOperationsPathStrictReceive(op: RawPathStrictReceiveOp): BlockOperation[] {
-  const destAsset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer);
+  const destAsset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer)
   const sourceAsset = assetFromHorizonFields(
     op.source_asset_type,
     op.source_asset_code,
-    op.source_asset_issuer,
-  );
+    op.source_asset_issuer
+  )
   // Horizon reports actual source debit in `source_amount`; `send_max` is only the envelope cap.
-  const sourceStroops = toStroops(op.source_amount ?? op.send_max);
+  const sourceStroops = toStroops(op.source_amount ?? op.send_max)
   return pathStrictDualLegTransfers({
     fromAddr: op.from,
     toAddr: op.to,
@@ -188,63 +192,74 @@ function blockOperationsPathStrictReceive(op: RawPathStrictReceiveOp): BlockOper
     destAsset,
     sourceStroops,
     destStroops: toStroops(op.amount),
-  });
+  })
 }
 
-function mapSupportedOperationToBlockOperations(op: SupportedGetBlockOperation): BlockOperation[] {
-  if (op.type === "payment") {
-    const asset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer);
-    const toAddr = op.to_muxed || op.to;
-    return mapPaymentLikeTransfer(op.from, toAddr, op.amount, asset);
+type TxContext = {
+  memo: StellarMemo | undefined
+  sequence: string | undefined
+  feeCharged: string
+}
+
+function mapSupportedOperationToBlockOperations(
+  op: SupportedGetBlockOperation,
+  txCtx: TxContext
+): BlockOperation[] {
+  if (op.type === 'payment') {
+    const asset = assetFromHorizonFields(op.asset_type, op.asset_code, op.asset_issuer)
+    const toAddr = op.to_muxed || op.to
+    return mapPaymentLikeTransfer(op.from, toAddr, op.amount, asset)
   }
-  if (op.type === "create_account") {
-    return mapPaymentLikeTransfer(op.funder, op.account, op.starting_balance, NATIVE_ASSET);
+  if (op.type === 'create_account') {
+    return mapPaymentLikeTransfer(op.funder, op.account, op.starting_balance, NATIVE_ASSET)
   }
-  if (op.type === "change_trust") {
-    const isOptOut = new BigNumber(op.limit || "0").eq(0);
+  if (op.type === 'change_trust') {
+    const isOptOut = new BigNumber(op.limit || '0').eq(0)
+    // Align with listOperations: assetAmount = fee_charged (not the trustline limit)
     return [
       {
-        type: "other",
-        ledgerOpType: isOptOut ? "OPT_OUT" : "OPT_IN",
-        trustor: op.trustor,
-        assetCode: op.asset_code,
-        assetIssuer: op.asset_issuer,
-        limit: op.limit,
+        type: 'other',
+        ledgerOpType: isOptOut ? 'OPT_OUT' : 'OPT_IN',
+        assetAmount: op.asset_code ? txCtx.feeCharged : undefined,
+        ...(txCtx.memo && { memo: txCtx.memo }),
+        ...(txCtx.sequence && { sequence: txCtx.sequence }),
       },
-    ];
+    ]
   }
-  if (op.type === "path_payment_strict_send") {
-    return blockOperationsPathStrictSend(op);
+  if (op.type === 'path_payment_strict_send') {
+    return blockOperationsPathStrictSend(op)
   }
-  if (op.type === "path_payment_strict_receive") {
-    return blockOperationsPathStrictReceive(op);
+  if (op.type === 'path_payment_strict_receive') {
+    return blockOperationsPathStrictReceive(op)
   }
-  return assertUnreachable(op);
+  return assertUnreachable(op)
 }
 
 async function blockTransactionForHash(
   hash: string,
-  ops: RawOperation[],
+  ops: RawOperation[]
 ): Promise<BlockTransaction | null> {
-  if (ops.length === 0) return null;
-  const failed = !ops[0].transaction_successful;
+  if (ops.length === 0) return null
+  const failed = !ops[0].transaction_successful
 
-  let blockOperations: BlockOperation[] = [];
+  const tx = await ops[0].transaction()
+  const txCtx: TxContext = {
+    memo: decodeMemo(tx),
+    sequence: parseSequence(tx.source_account_sequence),
+    feeCharged: new BigNumber(tx.fee_charged || '0').toString(),
+  }
+
+  let blockOperations: BlockOperation[] = []
   if (!failed) {
     for (const op of ops) {
       if (isSupportedGetBlockOperation(op)) {
-        blockOperations = blockOperations.concat(mapSupportedOperationToBlockOperations(op));
+        blockOperations = blockOperations.concat(mapSupportedOperationToBlockOperations(op, txCtx))
       }
     }
   }
 
-  if (!failed && blockOperations.length === 0) {
-    return null;
-  }
-
-  const tx = await ops[0].transaction();
-  const fees = BigInt(tx.fee_charged || "0");
-  const feesPayer = tx.fee_account || tx.source_account;
+  const fees = BigInt(tx.fee_charged || '0')
+  const feesPayer = tx.fee_account || tx.source_account
 
   return {
     hash,
@@ -252,24 +267,24 @@ async function blockTransactionForHash(
     fees,
     ...(feesPayer ? { feesPayer } : {}),
     operations: blockOperations,
-  };
+  }
 }
 
 async function buildBlockTransactions(rawOps: RawOperation[]): Promise<BlockTransaction[]> {
-  const order = orderTransactionHashes(rawOps);
-  const byHash = groupOpsByHash(rawOps);
-  const out: BlockTransaction[] = [];
+  const order = orderTransactionHashes(rawOps)
+  const byHash = groupOpsByHash(rawOps)
+  const out: BlockTransaction[] = []
 
   for (const hash of order) {
     // `order` and `byHash` are built from the same `rawOps`; every ordered hash has a non-empty op list.
-    const ops = byHash.get(hash)!;
-    const row = await blockTransactionForHash(hash, ops);
+    const ops = byHash.get(hash)!
+    const row = await blockTransactionForHash(hash, ops)
     if (row) {
-      out.push(row);
+      out.push(row)
     }
   }
 
-  return out;
+  return out
 }
 
 /**
@@ -284,22 +299,22 @@ async function buildBlockTransactions(rawOps: RawOperation[]): Promise<BlockTran
  */
 export async function getBlock(height: number): Promise<Block> {
   if (!Number.isSafeInteger(height) || height <= 0) {
-    throw new Error(`getBlock: height must be a positive integer, got ${height}`);
+    throw new Error(`getBlock: height must be a positive integer, got ${height}`)
   }
 
   const [ledger, rawOps] = await Promise.all([
     fetchLedgerRecord(height),
     fetchAllLedgerOperations(height),
-  ]);
+  ])
 
-  let parent: BlockInfo["parent"];
+  let parent: BlockInfo['parent']
   if (height > 1) {
-    const prevHash = (ledger as { prev_hash?: string }).prev_hash;
+    const prevHash = (ledger as { prev_hash?: string }).prev_hash
     if (prevHash) {
-      parent = { height: height - 1, hash: prevHash };
+      parent = { height: height - 1, hash: prevHash }
     } else {
-      const parentLedger = await fetchLedgerRecord(height - 1);
-      parent = { height: parentLedger.sequence, hash: parentLedger.hash };
+      const parentLedger = await fetchLedgerRecord(height - 1)
+      parent = { height: parentLedger.sequence, hash: parentLedger.hash }
     }
   }
 
@@ -308,8 +323,8 @@ export async function getBlock(height: number): Promise<Block> {
     hash: ledger.hash,
     time: new Date(ledger.closed_at),
     ...(parent && { parent }),
-  };
+  }
 
-  const transactions = await buildBlockTransactions(rawOps);
-  return { info, transactions };
+  const transactions = await buildBlockTransactions(rawOps)
+  return { info, transactions }
 }

package/src/logic/getBlockInfo.test.ts

@@ -1,21 +1,24 @@
-import { getBlockInfo } from "./getBlockInfo";
-import * as network from "../network";
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
 
-jest.mock("../network", () => ({
-  ...jest.requireActual<typeof import("../network")>("../network"),
+import * as network from '../network'
+import { getBlockInfo } from './getBlockInfo'
+
+jest.mock('../network', () => ({
+  ...jest.requireActual<typeof import('../network')>('../network'),
   fetchLedgerRecord: jest.fn(),
-}));
+}))
 
 const fetchLedgerRecordMock = network.fetchLedgerRecord as jest.MockedFunction<
   typeof network.fetchLedgerRecord
->;
+>
 
-describe("getBlockInfo", () => {
+describe('getBlockInfo', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
-  });
+    jest.clearAllMocks()
+  })
 
-  it("returns block info with parent when height > 1 (uses ledger prev_hash)", async () => {
+  it('returns block info with parent when height > 1 (uses ledger prev_hash)', async () => {
     fetchLedgerRecordMock.mockImplementation(
       async (seq: number) =>
         ({
@@ -23,94 +26,94 @@ describe("getBlockInfo", () => {
           hash: `hash-${seq}`,
           closed_at: `2020-01-0${seq}T00:00:00Z`,
           ...(seq > 1 && { prev_hash: `hash-${seq - 1}` }),
-        }) as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>,
-    );
+        }) as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>
+    )
 
-    const result = await getBlockInfo(5);
+    const result = await getBlockInfo(5)
 
-    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(1);
-    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(5);
+    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(1)
+    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(5)
     expect(result).toEqual({
       height: 5,
-      hash: "hash-5",
-      time: new Date("2020-01-05T00:00:00Z"),
-      parent: { height: 4, hash: "hash-4" },
-    });
-  });
+      hash: 'hash-5',
+      time: new Date('2020-01-05T00:00:00Z'),
+      parent: { height: 4, hash: 'hash-4' },
+    })
+  })
 
-  it("falls back to fetching parent ledger when prev_hash is missing", async () => {
+  it('falls back to fetching parent ledger when prev_hash is missing', async () => {
     fetchLedgerRecordMock.mockImplementation(
       async (seq: number) =>
         ({
           sequence: seq,
           hash: `hash-${seq}`,
           closed_at: `2020-01-0${seq}T00:00:00Z`,
-        }) as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>,
-    );
+        }) as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>
+    )
 
-    const result = await getBlockInfo(5);
+    const result = await getBlockInfo(5)
 
-    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(5);
-    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(4);
-    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(2);
+    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(5)
+    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(4)
+    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(2)
     expect(result).toEqual({
       height: 5,
-      hash: "hash-5",
-      time: new Date("2020-01-05T00:00:00Z"),
-      parent: { height: 4, hash: "hash-4" },
-    });
-  });
+      hash: 'hash-5',
+      time: new Date('2020-01-05T00:00:00Z'),
+      parent: { height: 4, hash: 'hash-4' },
+    })
+  })
 
-  it("omits parent for genesis ledger sequence 1", async () => {
+  it('omits parent for genesis ledger sequence 1', async () => {
     fetchLedgerRecordMock.mockResolvedValue({
       sequence: 1,
-      hash: "genesis-hash",
-      closed_at: "2015-09-30T00:00:00Z",
-    } as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>);
+      hash: 'genesis-hash',
+      closed_at: '2015-09-30T00:00:00Z',
+    } as unknown as Awaited<ReturnType<typeof network.fetchLedgerRecord>>)
 
-    const result = await getBlockInfo(1);
+    const result = await getBlockInfo(1)
 
-    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(1);
-    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(1);
-    expect(result.parent).toBeUndefined();
-    expect(result.height).toBe(1);
-  });
+    expect(fetchLedgerRecordMock).toHaveBeenCalledTimes(1)
+    expect(fetchLedgerRecordMock).toHaveBeenCalledWith(1)
+    expect(result.parent).toBeUndefined()
+    expect(result.height).toBe(1)
+  })
 
-  describe("height validation", () => {
-    it("rejects height 0", async () => {
+  describe('height validation', () => {
+    it('rejects height 0', async () => {
       await expect(getBlockInfo(0)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer, got 0",
-      );
-    });
+        'getBlockInfo: height must be a positive integer, got 0'
+      )
+    })
 
-    it("rejects negative height", async () => {
+    it('rejects negative height', async () => {
       await expect(getBlockInfo(-3)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer, got -3",
-      );
-    });
+        'getBlockInfo: height must be a positive integer, got -3'
+      )
+    })
 
-    it("rejects non-integer height", async () => {
+    it('rejects non-integer height', async () => {
       await expect(getBlockInfo(3.5)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer, got 3.5",
-      );
-    });
+        'getBlockInfo: height must be a positive integer, got 3.5'
+      )
+    })
 
-    it("rejects NaN", async () => {
+    it('rejects NaN', async () => {
       await expect(getBlockInfo(Number.NaN)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer, got NaN",
-      );
-    });
+        'getBlockInfo: height must be a positive integer, got NaN'
+      )
+    })
 
-    it("rejects unsafe integer", async () => {
+    it('rejects unsafe integer', async () => {
       await expect(getBlockInfo(Number.MAX_SAFE_INTEGER + 1)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer",
-      );
-    });
+        'getBlockInfo: height must be a positive integer'
+      )
+    })
 
-    it("rejects Infinity", async () => {
+    it('rejects Infinity', async () => {
       await expect(getBlockInfo(Number.POSITIVE_INFINITY)).rejects.toThrow(
-        "getBlockInfo: height must be a positive integer, got Infinity",
-      );
-    });
-  });
-});
+        'getBlockInfo: height must be a positive integer, got Infinity'
+      )
+    })
+  })
+})