@ledgerhq/coin-hedera 1.12.1-nightly.1 → 1.13.0-nightly.3

package/src/logic/listOperations.test.ts

@@ -0,0 +1,388 @@
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account/accountId";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import type { Pagination } from "@ledgerhq/coin-framework/api/types";
+import { listOperations } from "./listOperations";
+import { apiClient } from "../network/api";
+import { getMockedCurrency } from "../test/fixtures/currency.fixture";
+import * as utils from "./utils";
+
+jest.mock("@ledgerhq/cryptoassets/tokens");
+jest.mock("@ledgerhq/coin-framework/account/accountId");
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("../network/api");
+jest.mock("./utils");
+
+describe("listOperations", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (utils.getMemoFromBase64 as jest.Mock).mockImplementation(memo =>
+      memo ? `decoded-${memo}` : null,
+    );
+    (encodeOperationId as jest.Mock).mockImplementation(
+      (accountId, hash, type) => `${accountId}-${hash}-${type}`,
+    );
+    (encodeTokenAccountId as jest.Mock).mockImplementation(
+      (accountId, token) => `${accountId}-${token.id}`,
+    );
+  });
+
+  it("should return empty arrays when no transactions are found", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "asc",
+    };
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: [],
+      nextCursor: null,
+    });
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(apiClient.getAccountTransactions).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccountTransactions).toHaveBeenCalledWith({
+      address,
+      fetchAllPages: true,
+      pagingToken: null,
+      order: "asc",
+      limit: 10,
+    });
+    expect(result.coinOperations).toEqual([]);
+    expect(result.tokenOperations).toEqual([]);
+  });
+
+  it("should parse HBAR transfer transactions correctly", async () => {
+    const address = "0.0.1234567";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+
+    const mockTransactions = [
+      {
+        consensus_timestamp: "1625097600.000000000",
+        transaction_hash: "hash1",
+        charged_tx_fee: 500000,
+        result: "SUCCESS",
+        memo_base64: "test-memo",
+        token_transfers: [],
+        transfers: [
+          { account: address, amount: "-1000000" },
+          { account: "0.0.67890", amount: "1000000" },
+        ],
+        name: "CRYPTOTRANSFER",
+      },
+    ];
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: mockTransactions,
+      nextCursor: null,
+    });
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(result.coinOperations).toHaveLength(1);
+    expect(result.tokenOperations).toEqual([]);
+
+    expect(result.coinOperations).toMatchObject([
+      {
+        type: "OUT",
+        value: expect.any(Object),
+        hash: "hash1",
+        fee: expect.any(Object),
+        date: expect.any(Date),
+        senders: [address],
+        recipients: ["0.0.67890"],
+        extra: {
+          pagingToken: "1625097600.000000000",
+          consensusTimestamp: "1625097600.000000000",
+          memo: "decoded-test-memo",
+        },
+      },
+    ]);
+  });
+
+  it("should parse token transfer transactions correctly", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const tokenId = "0.0.7890";
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+
+    const mockToken = {
+      id: "token1",
+      contractAddress: tokenId,
+      standard: "hts",
+      name: "Test Token",
+      units: [{ name: "TT", code: "tt", magnitude: 6 }],
+    };
+
+    const mockTransactions = [
+      {
+        consensus_timestamp: "1625097600.000000000",
+        transaction_hash: "hash1",
+        charged_tx_fee: 500000,
+        result: "SUCCESS",
+        token_transfers: [
+          { token_id: tokenId, account: address, amount: "-1000" },
+          { token_id: tokenId, account: "0.0.67890", amount: "1000" },
+        ],
+        transfers: [],
+        name: "CRYPTOTRANSFER",
+      },
+    ];
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: mockTransactions,
+      nextCursor: null,
+    });
+    (findTokenByAddressInCurrency as jest.Mock).mockReturnValue(mockToken);
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(result.coinOperations).toHaveLength(1);
+    expect(result.tokenOperations).toHaveLength(1);
+
+    expect(result.coinOperations).toMatchObject([
+      {
+        type: "FEES",
+        fee: expect.any(Object),
+      },
+    ]);
+
+    expect(result.tokenOperations).toMatchObject([
+      {
+        type: "OUT",
+        value: expect.any(Object),
+        hash: "hash1",
+        contract: tokenId,
+        standard: "hts",
+        senders: [address],
+        recipients: ["0.0.67890"],
+        extra: {
+          pagingToken: "1625097600.000000000",
+          consensusTimestamp: "1625097600.000000000",
+        },
+      },
+    ]);
+  });
+
+  it("should parse token associate transactions correctly", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+
+    const mockTransactions = [
+      {
+        consensus_timestamp: "1625097600.000000000",
+        transaction_hash: "hash1",
+        charged_tx_fee: 500000,
+        result: "SUCCESS",
+        token_transfers: [],
+        transfers: [{ account: address, amount: "-500000" }],
+        name: "TOKENASSOCIATE",
+      },
+    ];
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: mockTransactions,
+      nextCursor: null,
+    });
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(result.coinOperations).toHaveLength(1);
+    expect(result.tokenOperations).toHaveLength(0);
+
+    expect(result.coinOperations).toMatchObject([
+      {
+        type: "ASSOCIATE_TOKEN",
+        value: expect.any(Object),
+        hash: "hash1",
+        fee: expect.any(Object),
+        senders: [address],
+        recipients: [],
+        extra: {
+          pagingToken: "1625097600.000000000",
+          consensusTimestamp: "1625097600.000000000",
+        },
+      },
+    ]);
+  });
+
+  it("should skip token operations when token is not found in cryptoassets", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const tokenId = "0.0.7890";
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+
+    const mockTransactions = [
+      {
+        consensus_timestamp: "1625097600.000000000",
+        transaction_hash: "hash1",
+        charged_tx_fee: 500000,
+        result: "SUCCESS",
+        token_transfers: [
+          { token_id: tokenId, account: address, amount: "-1000" },
+          { token_id: tokenId, account: "0.0.67890", amount: "1000" },
+        ],
+        transfers: [],
+        name: "CRYPTOTRANSFER",
+      },
+    ];
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: mockTransactions,
+      nextCursor: null,
+    });
+    (findTokenByAddressInCurrency as jest.Mock).mockReturnValue(null);
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(result.coinOperations).toHaveLength(0);
+    expect(result.tokenOperations).toHaveLength(0);
+  });
+
+  it("should use pagination parameters correctly", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 20,
+      order: "asc",
+      lastPagingToken: "1625097500.000000000",
+    };
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: [],
+      nextCursor: null,
+    });
+
+    await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(apiClient.getAccountTransactions).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccountTransactions).toHaveBeenCalledWith({
+      address,
+      fetchAllPages: true,
+      pagingToken: "1625097500.000000000",
+      order: "asc",
+      limit: 20,
+    });
+  });
+
+  it("should handle failed transactions", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+
+    const mockTransactions = [
+      {
+        consensus_timestamp: "1625097600.000000000",
+        transaction_hash: "hash1",
+        charged_tx_fee: 500000,
+        result: "INVALID_SIGNATURE",
+        memo_base64: null,
+        token_transfers: [],
+        transfers: [
+          { account: address, amount: "-1000000" },
+          { account: "0.0.67890", amount: "1000000" },
+        ],
+        name: "CRYPTOTRANSFER",
+      },
+    ];
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: mockTransactions,
+      nextCursor: null,
+    });
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    expect(result.coinOperations).toHaveLength(1);
+    expect(result.coinOperations[0].hasFailed).toBe(true);
+  });
+});

package/src/logic/listOperations.ts

@@ -0,0 +1,247 @@
+import BigNumber from "bignumber.js";
+import type { Operation } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Pagination } from "@ledgerhq/coin-framework/api/types";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { encodeAccountId, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/accountId";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { apiClient } from "../network/api";
+import { parseTransfers } from "../network/utils";
+import type { HederaMirrorToken, HederaMirrorTransaction, HederaOperationExtra } from "../types";
+import { base64ToUrlSafeBase64, getMemoFromBase64, getSyntheticBlock } from "./utils";
+
+function getCommonOperationData(
+  rawTx: HederaMirrorTransaction,
+  useEncodedHash: boolean,
+  useSyntheticBlocks: boolean,
+) {
+  const timestamp = new Date(Number.parseInt(rawTx.consensus_timestamp.split(".")[0], 10) * 1000);
+  const hash = useEncodedHash
+    ? base64ToUrlSafeBase64(rawTx.transaction_hash)
+    : rawTx.transaction_hash;
+  const fee = new BigNumber(rawTx.charged_tx_fee);
+  const hasFailed = rawTx.result !== "SUCCESS";
+  const syntheticBlock = getSyntheticBlock(rawTx.consensus_timestamp);
+  const memo = getMemoFromBase64(rawTx.memo_base64);
+  const extra: HederaOperationExtra = {
+    pagingToken: rawTx.consensus_timestamp,
+    consensusTimestamp: rawTx.consensus_timestamp,
+    ...(memo && { memo }),
+  };
+
+  return {
+    timestamp,
+    hash,
+    fee,
+    hasFailed,
+    blockHeight: useSyntheticBlocks ? syntheticBlock.blockHeight : 10,
+    blockHash: useSyntheticBlocks ? syntheticBlock.blockHash : null,
+    extra,
+  };
+}
+
+function processTokenTransfers({
+  rawTx,
+  address,
+  currency,
+  ledgerAccountId,
+  commonData,
+  skipFeesForTokenOperations,
+}: {
+  rawTx: HederaMirrorTransaction;
+  address: string;
+  currency: CryptoCurrency;
+  ledgerAccountId: string;
+  commonData: ReturnType<typeof getCommonOperationData>;
+  skipFeesForTokenOperations: boolean;
+}): {
+  coinOperation: Operation<HederaOperationExtra> | undefined;
+  tokenOperation: Operation<HederaOperationExtra>;
+} | null {
+  const tokenTransfers = rawTx.token_transfers ?? [];
+  if (tokenTransfers.length === 0) return null;
+
+  const tokenId = tokenTransfers[0].token_id;
+  const token = findTokenByAddressInCurrency(tokenId, currency.id);
+  if (!token) return null;
+
+  const encodedTokenId = encodeTokenAccountId(ledgerAccountId, token);
+  const { type, value, senders, recipients } = parseTransfers(tokenTransfers, address);
+  const { hash, fee, timestamp, blockHeight, blockHash, hasFailed } = commonData;
+  const extra = { ...commonData.extra };
+
+  let coinOperation: Operation<HederaOperationExtra> | undefined;
+
+  // Add main FEES coin operation for send token transfer
+  if (type === "OUT" && !skipFeesForTokenOperations) {
+    coinOperation = {
+      id: encodeOperationId(ledgerAccountId, hash, "FEES"),
+      accountId: ledgerAccountId,
+      type: "FEES",
+      value: fee,
+      recipients,
+      senders,
+      hash,
+      fee,
+      date: timestamp,
+      blockHeight,
+      blockHash,
+      hasFailed,
+      extra,
+    };
+  }
+
+  const tokenOperation = {
+    id: encodeOperationId(encodedTokenId, hash, type),
+    accountId: encodedTokenId,
+    contract: token.contractAddress,
+    standard: "hts",
+    type,
+    value,
+    recipients,
+    senders,
+    hash,
+    fee,
+    date: timestamp,
+    blockHeight,
+    blockHash,
+    hasFailed,
+    extra,
+  } satisfies Operation<HederaOperationExtra>;
+
+  return {
+    coinOperation,
+    tokenOperation,
+  };
+}
+
+function processTransfers({
+  rawTx,
+  address,
+  ledgerAccountId,
+  commonData,
+  mirrorTokens,
+}: {
+  rawTx: HederaMirrorTransaction;
+  address: string;
+  ledgerAccountId: string;
+  commonData: ReturnType<typeof getCommonOperationData>;
+  mirrorTokens: HederaMirrorToken[];
+}): Operation<HederaOperationExtra> | null {
+  const transfers = rawTx.transfers ?? [];
+  if (transfers.length === 0) return null;
+
+  const { type, value, senders, recipients } = parseTransfers(transfers, address);
+  const { hash, fee, timestamp, blockHeight, blockHash, hasFailed } = commonData;
+  const extra = { ...commonData.extra };
+  let operationType = type;
+
+  // try to enrich ASSOCIATE_TOKEN operation with extra.associatedTokenId
+  // this value is used by custom OperationDetails components in Hedera family
+  // accounts or contracts must first associate with an HTS token before they can receive or send that token; without association, token transfers fail
+  if (rawTx.name === "TOKENASSOCIATE") {
+    operationType = "ASSOCIATE_TOKEN";
+
+    const relatedMirrorToken = mirrorTokens.find(t => {
+      return t.created_timestamp === rawTx.consensus_timestamp;
+    });
+
+    if (relatedMirrorToken) {
+      extra.associatedTokenId = relatedMirrorToken.token_id;
+    }
+  }
+
+  return {
+    id: encodeOperationId(ledgerAccountId, hash, operationType),
+    accountId: ledgerAccountId,
+    type: operationType,
+    value,
+    recipients,
+    senders,
+    hash,
+    fee,
+    date: timestamp,
+    blockHeight,
+    blockHash,
+    hasFailed,
+    extra,
+  };
+}
+
+export async function listOperations({
+  currency,
+  address,
+  mirrorTokens,
+  pagination,
+  fetchAllPages,
+  skipFeesForTokenOperations,
+  useEncodedHash,
+  useSyntheticBlocks,
+}: {
+  currency: CryptoCurrency;
+  address: string;
+  mirrorTokens: HederaMirrorToken[];
+  pagination: Pagination;
+  // options for compatibility with old bridge
+  fetchAllPages: boolean;
+  skipFeesForTokenOperations: boolean;
+  useEncodedHash: boolean;
+  useSyntheticBlocks: boolean;
+}): Promise<{
+  coinOperations: Operation<HederaOperationExtra>[];
+  tokenOperations: Operation<HederaOperationExtra>[];
+  nextCursor: string | null;
+}> {
+  const coinOperations: Operation<HederaOperationExtra>[] = [];
+  const tokenOperations: Operation<HederaOperationExtra>[] = [];
+  const mirrorResult = await apiClient.getAccountTransactions({
+    address,
+    pagingToken: pagination.lastPagingToken ?? null,
+    order: pagination.order,
+    limit: pagination.limit,
+    fetchAllPages,
+  });
+  const ledgerAccountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode: "hederaBip44",
+  });
+
+  for (const rawTx of mirrorResult.transactions) {
+    const commonData = getCommonOperationData(rawTx, useEncodedHash, useSyntheticBlocks);
+
+    // process token transfers
+    const tokenResult = processTokenTransfers({
+      rawTx,
+      address,
+      currency,
+      ledgerAccountId,
+      commonData,
+      skipFeesForTokenOperations,
+    });
+
+    if (tokenResult?.coinOperation) coinOperations.push(tokenResult.coinOperation);
+    if (tokenResult?.tokenOperation) tokenOperations.push(tokenResult.tokenOperation);
+
+    // process regular transfers only if there were no token transfers
+    if (!tokenResult) {
+      const coinOperation = processTransfers({
+        rawTx,
+        address,
+        ledgerAccountId,
+        commonData,
+        mirrorTokens,
+      });
+
+      if (coinOperation) coinOperations.push(coinOperation);
+    }
+  }
+
+  return {
+    coinOperations,
+    tokenOperations,
+    nextCursor: mirrorResult.nextCursor,
+  };
+}