@ledgerhq/coin-hedera 1.15.0-nightly.20251127023715 → 1.15.0-nightly.20251127103328

package/src/logic/getBlock.ts

@@ -0,0 +1,74 @@
+import type {
+  AssetInfo,
+  Block,
+  BlockOperation,
+  BlockTransaction,
+} from "@ledgerhq/coin-framework/api/types";
+import { getBlockInfo } from "./getBlockInfo";
+import { apiClient } from "../network/api";
+import type { HederaMirrorCoinTransfer, HederaMirrorTokenTransfer } from "../types";
+import { getTimestampRangeFromBlockHeight } from "./utils";
+
+function toHederaAsset(
+  mirrorTransfer: HederaMirrorCoinTransfer | HederaMirrorTokenTransfer,
+): AssetInfo {
+  if ("token_id" in mirrorTransfer) {
+    return {
+      type: "hts",
+      assetReference: mirrorTransfer.token_id,
+    };
+  }
+
+  return { type: "native" };
+}
+
+function toBlockOperation(
+  payerAccount: string,
+  chargedFee: number,
+  mirrorTransfer: HederaMirrorCoinTransfer | HederaMirrorTokenTransfer,
+): BlockOperation {
+  const isTokenTransfer = "token_id" in mirrorTransfer;
+  const address = mirrorTransfer.account;
+  const asset = toHederaAsset(mirrorTransfer);
+  let amount = BigInt(mirrorTransfer.amount);
+
+  // exclude fee from payer's operation amount (fees are accounted for separately, so operations must not represent fees)
+  if (payerAccount === address && !isTokenTransfer) {
+    amount += BigInt(chargedFee);
+  }
+
+  return {
+    type: "transfer",
+    address,
+    asset,
+    amount,
+  };
+}
+
+export async function getBlock(height: number): Promise<Block> {
+  const { start, end } = getTimestampRangeFromBlockHeight(height);
+  const blockInfo = await getBlockInfo(height);
+  const transactions = await apiClient.getTransactionsByTimestampRange(start, end);
+
+  const blockTransactions: BlockTransaction[] = transactions.map(tx => {
+    const payerAccount = tx.transaction_id.split("-")[0];
+    const allTransfers = [...tx.transfers, ...tx.token_transfers];
+
+    const operations = allTransfers.map(transfer =>
+      toBlockOperation(payerAccount, tx.charged_tx_fee, transfer),
+    );
+
+    return {
+      hash: tx.transaction_hash,
+      failed: tx.result !== "SUCCESS",
+      operations,
+      fees: BigInt(tx.charged_tx_fee),
+      feesPayer: payerAccount,
+    };
+  });
+
+  return {
+    info: blockInfo,
+    transactions: blockTransactions,
+  };
+}

package/src/logic/getBlockInfo.test.ts

@@ -0,0 +1,37 @@
+import { SYNTHETIC_BLOCK_WINDOW_SECONDS } from "../constants";
+import { getBlockInfo } from "./getBlockInfo";
+
+describe("getBlockInfo", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should calculate time correctly based on block height and default window", async () => {
+    const blockHeight = 100;
+    const expectedSeconds = blockHeight * SYNTHETIC_BLOCK_WINDOW_SECONDS;
+    const expectedTime = new Date(expectedSeconds * 1000);
+
+    const result = await getBlockInfo(blockHeight);
+
+    expect(result).toMatchObject({
+      height: blockHeight,
+      hash: expect.any(String),
+      time: expectedTime,
+    });
+  });
+
+  it("should use custom block window seconds when provided", async () => {
+    const blockHeight = 50;
+    const customWindow = 120;
+    const expectedSeconds = blockHeight * customWindow;
+    const expectedTime = new Date(expectedSeconds * 1000);
+
+    const result = await getBlockInfo(blockHeight, customWindow);
+
+    expect(result).toMatchObject({
+      height: blockHeight,
+      hash: expect.any(String),
+      time: expectedTime,
+    });
+  });
+});

package/src/logic/getBlockInfo.ts

@@ -0,0 +1,25 @@
+import type { BlockInfo } from "@ledgerhq/coin-framework/lib-es/api/types";
+import { SYNTHETIC_BLOCK_WINDOW_SECONDS } from "../constants";
+import { getBlockHash } from "./utils";
+
+/**
+ * Retrieves synthetic block information based on the provided block height.
+ *
+ * @param blockHeight - The height of the block for which to retrieve information.
+ * @param blockWindowSeconds - The duration in seconds that defines the synthetic block window (default is SYNTHETIC_BLOCK_WINDOW_SECONDS).
+ * @returns An object containing the block height, block hash, and block time.
+ */
+export const getBlockInfo = async (
+  blockHeight: number,
+  blockWindowSeconds = SYNTHETIC_BLOCK_WINDOW_SECONDS,
+): Promise<BlockInfo> => {
+  const seconds = blockHeight * blockWindowSeconds;
+  const hash = getBlockHash(blockHeight);
+  const time = new Date(seconds * 1000);
+
+  return {
+    height: blockHeight,
+    hash,
+    time,
+  };
+};

package/src/logic/index.ts

@@ -3,6 +3,8 @@ export { combine } from "./combine";
 export { craftTransaction } from "./craftTransaction";
 export { estimateFees } from "./estimateFees";
 export { getBalance } from "./getBalance";
+export { getBlock } from "./getBlock";
+export { getBlockInfo } from "./getBlockInfo";
 export { lastBlock } from "./lastBlock";
 export { listOperations } from "./listOperations";
 export { getAssetFromToken } from "./getAssetFromToken";

package/src/logic/utils.test.ts

@@ -33,6 +33,8 @@ import {
   fromEVMAddress,
   toEVMAddress,
   formatTransactionId,
+  getTimestampRangeFromBlockHeight,
+  getBlockHash,
 } from "./utils";
 
 jest.mock("../network/api");
@@ -517,4 +519,82 @@ describe("logic utils", () => {
       expect(fromEVMAddress(undefined as unknown as string)).toBeNull();
     });
   });
+
+  describe("getBlockHash", () => {
+    it("produces consistent 64-character hex hash", () => {
+      const hash = getBlockHash(12345);
+
+      expect(hash).toMatch(/^[0-9a-f]{64}$/);
+    });
+
+    it("produces same hash for same block height", () => {
+      const hash1 = getBlockHash(100);
+      const hash2 = getBlockHash(100);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it("produces different hashes for different block heights", () => {
+      const hash1 = getBlockHash(100);
+      const hash2 = getBlockHash(101);
+
+      expect(hash1).not.toBe(hash2);
+    });
+  });
+
+  describe("getTimestampRangeFromBlockHeight", () => {
+    it("calculates consensus timestamp for block height 0 with default window", () => {
+      const result = getTimestampRangeFromBlockHeight(0);
+
+      expect(result).toEqual({
+        start: "0.000000000",
+        end: "10.000000000",
+      });
+    });
+
+    it("calculates consensus timestamp for block height 1 with default window", () => {
+      const result = getTimestampRangeFromBlockHeight(1);
+
+      expect(result).toEqual({
+        start: "10.000000000",
+        end: "20.000000000",
+      });
+    });
+
+    it("calculates consensus timestamp with custom block window of 1 second", () => {
+      const result = getTimestampRangeFromBlockHeight(42, 1);
+
+      expect(result).toEqual({
+        start: "42.000000000",
+        end: "43.000000000",
+      });
+    });
+
+    it("handles large block heights correctly", () => {
+      const result = getTimestampRangeFromBlockHeight(1000000);
+
+      expect(result).toEqual({
+        start: "10000000.000000000",
+        end: "10000010.000000000",
+      });
+    });
+
+    it("ensures start and end timestamps are within the same block window", () => {
+      const blockHeight = 50;
+      const blockWindowSeconds = 10;
+      const result = getTimestampRangeFromBlockHeight(blockHeight, blockWindowSeconds);
+
+      const startSeconds = parseInt(result.start.split(".")[0]);
+      const endSeconds = parseInt(result.end.split(".")[0]);
+
+      expect(endSeconds - startSeconds).toBe(blockWindowSeconds);
+    });
+
+    it("maintains correct nanosecond precision format", () => {
+      const result = getTimestampRangeFromBlockHeight(123);
+
+      expect(result.start).toMatch(/^\d+\.000000000$/);
+      expect(result.end).toMatch(/^\d+\.000000000$/);
+    });
+  });
 });

package/src/logic/utils.ts

@@ -7,7 +7,7 @@ import {
   Transaction as HederaSDKTransaction,
   TransactionId,
 } from "@hashgraph/sdk";
-import { AssetInfo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
+import type { AssetInfo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/fiats";
 import cvsApi from "@ledgerhq/live-countervalues/api/index";
@@ -242,6 +242,10 @@ export const safeParseAccountId = (
   }
 };
 
+export function getBlockHash(blockHeight: number): string {
+  return createHash("sha256").update(blockHeight.toString()).digest("hex");
+}
+
 /**
  * Calculates a synthetic block height based on Hedera consensus timestamp.
  *
@@ -260,12 +264,32 @@ export function getSyntheticBlock(
   }
 
   const blockHeight = Math.floor(seconds / blockWindowSeconds);
-  const blockHash = createHash("sha256").update(blockHeight.toString()).digest("hex");
+  const blockHash = getBlockHash(blockHeight);
   const blockTime = new Date(seconds * 1000);
 
   return { blockHeight, blockHash, blockTime };
 }
 
+/**
+ * Calculates the timestamp range based on a synthetic block height.
+ *
+ * @param blockHeight - The synthetic block height
+ * @param blockWindowSeconds - Duration of one synthetic block in seconds (default: 10)
+ * @returns Hedera timestamp range as a string
+ */
+export function getTimestampRangeFromBlockHeight(
+  blockHeight: number,
+  blockWindowSeconds = SYNTHETIC_BLOCK_WINDOW_SECONDS,
+) {
+  const startTimestamp = blockHeight * blockWindowSeconds;
+  const endTimestamp = (blockHeight + 1) * blockWindowSeconds;
+
+  return {
+    start: `${startTimestamp}.000000000`,
+    end: `${endTimestamp}.000000000`,
+  };
+}
+
 export const formatTransactionId = (transactionId: TransactionId): string => {
   const [accountId, timestamp] = transactionId.toString().split("@");
   const [secs, nanos] = timestamp.split(".");

package/src/network/api.test.ts

@@ -400,3 +400,124 @@ describe("estimateContractCallGas", () => {
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("getTransactionsByTimestampRange", () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("should include correct query params with timestamp range", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({ transactions: [], links: { next: null } }),
+    );
+
+    await apiClient.getTransactionsByTimestampRange("1000.000000000", "2000.000000000");
+
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+    expect(requestUrl).toContain("timestamp=gte%3A1000.000000000");
+    expect(requestUrl).toContain("timestamp=lt%3A2000.000000000");
+    expect(requestUrl).toContain("limit=100");
+    expect(requestUrl).toContain("order=desc");
+  });
+
+  it("should return empty array when no transactions found", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({ transactions: [], links: { next: null } }),
+    );
+
+    const result = await apiClient.getTransactionsByTimestampRange(
+      "1000.000000000",
+      "2000.000000000",
+    );
+
+    expect(result).toEqual([]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return all transactions when only one page is needed", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        transactions: [
+          { consensus_timestamp: "1500.123456789" },
+          { consensus_timestamp: "1750.987654321" },
+        ],
+        links: { next: null },
+      }),
+    );
+
+    const result = await apiClient.getTransactionsByTimestampRange(
+      "1000.000000000",
+      "2000.000000000",
+    );
+
+    expect(result).toHaveLength(2);
+    expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1500.123456789", "1750.987654321"]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should keep fetching all pages when links.next is present", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [{ consensus_timestamp: "1100.000000000" }],
+          links: { next: "/next-1" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [{ consensus_timestamp: "1200.000000000" }],
+          links: { next: "/next-2" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [{ consensus_timestamp: "1300.000000000" }],
+          links: { next: null },
+        }),
+      );
+
+    const result = await apiClient.getTransactionsByTimestampRange(
+      "1000.000000000",
+      "2000.000000000",
+    );
+
+    expect(result).toHaveLength(3);
+    expect(result.map(tx => tx.consensus_timestamp)).toEqual([
+      "1100.000000000",
+      "1200.000000000",
+      "1300.000000000",
+    ]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(3);
+  });
+
+  it("should handle empty pages and continue fetching", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [{ consensus_timestamp: "1100.000000000" }],
+          links: { next: "/next-1" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [],
+          links: { next: "/next-2" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          transactions: [{ consensus_timestamp: "1300.000000000" }],
+          links: { next: null },
+        }),
+      );
+
+    const result = await apiClient.getTransactionsByTimestampRange(
+      "1000.000000000",
+      "2000.000000000",
+    );
+
+    expect(result).toHaveLength(2);
+    expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1100.000000000", "1300.000000000"]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(3);
+  });
+});

package/src/network/api.ts

@@ -239,6 +239,34 @@ async function estimateContractCallGas(
   return new BigNumber(res.data.result);
 }
 
+async function getTransactionsByTimestampRange(
+  startTimestamp: string,
+  endTimestamp: string,
+): Promise<HederaMirrorTransaction[]> {
+  const transactions: HederaMirrorTransaction[] = [];
+  const params = new URLSearchParams({
+    limit: "100",
+    order: "desc",
+  });
+
+  params.append("timestamp", `gte:${startTimestamp}`);
+  params.append("timestamp", `lt:${endTimestamp}`);
+
+  let nextPath: string | null = `/api/v1/transactions?${params.toString()}`;
+
+  while (nextPath) {
+    const res: LiveNetworkResponse<HederaMirrorTransactionsResponse> = await network({
+      method: "GET",
+      url: `${API_URL}${nextPath}`,
+    });
+    const newTransactions = res.data.transactions;
+    transactions.push(...newTransactions);
+    nextPath = res.data.links.next;
+  }
+
+  return transactions;
+}
+
 export const apiClient = {
   getAccountsForPublicKey,
   getAccount,
@@ -250,4 +278,5 @@ export const apiClient = {
   findTransactionByContractCall,
   getERC20Balance,
   estimateContractCallGas,
+  getTransactionsByTimestampRange,
 };