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

package/src/logic/estimateFees.ts

@@ -0,0 +1,28 @@
+import BigNumber from "bignumber.js";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  BASE_USD_FEE_BY_OPERATION_TYPE,
+  DEFAULT_TINYBAR_FEE,
+  ESTIMATED_FEE_SAFETY_RATE,
+  HEDERA_OPERATION_TYPES,
+} from "../constants";
+import { getCurrencyToUSDRate } from "./utils";
+
+export const estimateFees = async (
+  currency: CryptoCurrency,
+  operationType: HEDERA_OPERATION_TYPES,
+): Promise<BigNumber> => {
+  let fee: BigNumber | undefined;
+  const usdRate = await getCurrencyToUSDRate(currency).catch(() => null);
+
+  if (usdRate) {
+    fee = new BigNumber(BASE_USD_FEE_BY_OPERATION_TYPE[operationType])
+      .dividedBy(new BigNumber(usdRate))
+      .integerValue(BigNumber.ROUND_CEIL)
+      .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+  } else {
+    fee = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+  }
+
+  return fee;
+};

package/src/logic/getAssetFromToken.test.ts

@@ -0,0 +1,27 @@
+import { getAssetFromToken } from "./getAssetFromToken";
+import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+
+describe("getAssetFromToken", () => {
+  it("returns asset from TEST token", () => {
+    const owner = "owner";
+    const token = getMockedTokenCurrency({
+      contractAddress: "0.0.1234567",
+      name: "TEST",
+      units: [
+        {
+          name: "Test",
+          code: "TEST",
+          magnitude: 8,
+        },
+      ],
+    });
+
+    expect(getAssetFromToken(token, owner)).toEqual({
+      assetReference: token.contractAddress,
+      assetOwner: owner,
+      name: token.name,
+      type: token.tokenType,
+      unit: token.units[0],
+    });
+  });
+});

package/src/logic/getAssetFromToken.ts

@@ -0,0 +1,12 @@
+import type { AssetInfo } from "@ledgerhq/coin-framework/api/types";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+export function getAssetFromToken(token: TokenCurrency, owner: string): AssetInfo {
+  return {
+    type: token.tokenType,
+    assetReference: token.contractAddress,
+    assetOwner: owner,
+    name: token.name,
+    unit: token.units[0],
+  };
+}

package/src/logic/getBalance.test.ts

@@ -0,0 +1,200 @@
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { getBalance } from "./getBalance";
+import { apiClient } from "../network/api";
+import { getMockedCurrency } from "../test/fixtures/currency.fixture";
+
+jest.mock("../network/api");
+jest.mock("@ledgerhq/cryptoassets/tokens");
+
+describe("getBalance", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return native balance when only HBAR is present", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const mockMirrorAccount = {
+      balance: {
+        balance: "1000000000",
+      },
+    };
+
+    (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
+    (apiClient.getAccountTokens as jest.Mock).mockResolvedValue([]);
+
+    const result = await getBalance(mockCurrency, address);
+
+    expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccount).toHaveBeenCalledWith(address);
+    expect(apiClient.getAccountTokens).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
+    expect(result).toHaveLength(1);
+    expect(result).toEqual([
+      {
+        asset: { type: "native" },
+        value: BigInt("1000000000"),
+      },
+    ]);
+  });
+
+  it("should return native balance and token balances", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const mockMirrorAccount = {
+      balance: {
+        balance: "1000000000",
+      },
+    };
+    const mockMirrorTokens = [
+      {
+        token_id: "0.0.7890",
+        balance: "5000",
+      },
+      {
+        token_id: "0.0.9876",
+        balance: "10000",
+      },
+    ];
+    const mockToken1 = {
+      id: "token1",
+      contractAddress: "0.0.7890",
+      tokenType: "hts",
+      name: "Test Token 1",
+      units: [{ name: "TT1", code: "tt1", magnitude: 6 }],
+    };
+    const mockToken2 = {
+      id: "token2",
+      contractAddress: "0.0.9876",
+      tokenType: "hts",
+      name: "Test Token 2",
+      units: [{ name: "TT2", code: "tt2", magnitude: 8 }],
+    };
+
+    (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
+    (apiClient.getAccountTokens as jest.Mock).mockResolvedValue(mockMirrorTokens);
+    (findTokenByAddressInCurrency as jest.Mock).mockImplementation(tokenId => {
+      if (tokenId === "0.0.7890") return mockToken1;
+      if (tokenId === "0.0.9876") return mockToken2;
+      return null;
+    });
+
+    const result = await getBalance(mockCurrency, address);
+
+    expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccount).toHaveBeenCalledWith(address);
+    expect(apiClient.getAccountTokens).toHaveBeenCalledTimes(1);
+    expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
+    expect(findTokenByAddressInCurrency).toHaveBeenCalledTimes(2);
+    expect(findTokenByAddressInCurrency).toHaveBeenCalledWith("0.0.7890", "hedera");
+    expect(findTokenByAddressInCurrency).toHaveBeenCalledWith("0.0.9876", "hedera");
+    expect(result).toHaveLength(3);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        {
+          asset: { type: "native" },
+          value: BigInt("1000000000"),
+        },
+        {
+          value: BigInt("5000"),
+          asset: {
+            type: mockToken1.tokenType,
+            assetReference: mockToken1.contractAddress,
+            assetOwner: address,
+            name: mockToken1.name,
+            unit: mockToken1.units[0],
+          },
+        },
+        {
+          value: BigInt("10000"),
+          asset: {
+            type: mockToken2.tokenType,
+            assetReference: mockToken2.contractAddress,
+            assetOwner: address,
+            name: mockToken2.name,
+            unit: mockToken2.units[0],
+          },
+        },
+      ]),
+    );
+  });
+
+  it("should skip tokens not found in CAL", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const mockMirrorAccount = {
+      balance: {
+        balance: "1000000000",
+      },
+    };
+    const mockMirrorTokens = [
+      {
+        token_id: "0.0.7890",
+        balance: "5000",
+      },
+      {
+        token_id: "0.0.9876",
+        balance: "10000",
+      },
+    ];
+    const mockToken1 = {
+      id: "token1",
+      contractAddress: "0.0.7890",
+      tokenType: "hts",
+      name: "Test Token 1",
+      units: [{ name: "TT1", code: "tt1", magnitude: 6 }],
+    };
+
+    (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
+    (apiClient.getAccountTokens as jest.Mock).mockResolvedValue(mockMirrorTokens);
+    (findTokenByAddressInCurrency as jest.Mock).mockImplementation(tokenId => {
+      if (tokenId === "0.0.7890") return mockToken1;
+      return null;
+    });
+
+    const result = await getBalance(mockCurrency, address);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({
+      asset: { type: "native" },
+      value: BigInt("1000000000"),
+    });
+    expect(result[1]).toEqual({
+      value: BigInt("5000"),
+      asset: {
+        type: mockToken1.tokenType,
+        assetReference: mockToken1.contractAddress,
+        assetOwner: address,
+        name: mockToken1.name,
+        unit: mockToken1.units[0],
+      },
+    });
+  });
+
+  it("should throw when failing to getAccount data", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const error = new Error("Network error");
+
+    (apiClient.getAccount as jest.Mock).mockRejectedValue(error);
+    (apiClient.getAccountTokens as jest.Mock).mockResolvedValue([]);
+
+    await expect(getBalance(mockCurrency, address)).rejects.toThrow(error);
+  });
+
+  it("should throw when failing to getAccountTokens data", async () => {
+    const address = "0.0.12345";
+    const mockCurrency = getMockedCurrency();
+    const error = new Error("Network error");
+    const mockMirrorAccount = {
+      balance: {
+        balance: "1000000000",
+      },
+    };
+
+    (apiClient.getAccount as jest.Mock).mockResolvedValue(mockMirrorAccount);
+    (apiClient.getAccountTokens as jest.Mock).mockRejectedValue(error);
+
+    await expect(getBalance(mockCurrency, address)).rejects.toThrow(error);
+  });
+});

package/src/logic/getBalance.ts

@@ -0,0 +1,39 @@
+import type { Balance } from "@ledgerhq/coin-framework/api/types";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+import { apiClient } from "../network/api";
+
+export async function getBalance(currency: CryptoCurrency, address: string): Promise<Balance[]> {
+  const [mirrorAccount, mirrorTokens] = await Promise.all([
+    apiClient.getAccount(address),
+    apiClient.getAccountTokens(address),
+  ]);
+
+  const balance: Balance[] = [
+    {
+      asset: { type: "native" },
+      value: BigInt(mirrorAccount.balance.balance),
+    },
+  ];
+
+  for (const mirrorToken of mirrorTokens) {
+    const calToken = findTokenByAddressInCurrency(mirrorToken.token_id, currency.id);
+
+    if (!calToken) {
+      continue;
+    }
+
+    balance.push({
+      value: BigInt(mirrorToken.balance),
+      asset: {
+        type: calToken.tokenType,
+        assetReference: calToken.contractAddress,
+        assetOwner: address,
+        name: calToken.name,
+        unit: calToken.units[0],
+      },
+    });
+  }
+
+  return balance;
+}

package/src/logic/getTokenFromAsset.test.ts

@@ -0,0 +1,22 @@
+import { getTokenFromAsset } from "./getTokenFromAsset";
+import { getMockedCurrency } from "../test/fixtures/currency.fixture";
+
+describe("getTokenFromAsset", () => {
+  const mockCurrency = getMockedCurrency();
+
+  it("returns token from USDC asset", async () => {
+    const asset1 = { type: "hts", assetReference: "0.0.5022567" };
+
+    expect(await getTokenFromAsset(mockCurrency, asset1)).toMatchObject({
+      id: "hedera/hts/hbark_0.0.5022567",
+      contractAddress: "0.0.5022567",
+      name: "hBARK",
+    });
+  });
+
+  it("returns undefined for native asset", async () => {
+    const nativeAsset = { type: "native" };
+
+    expect(await getTokenFromAsset(mockCurrency, nativeAsset)).toBeUndefined();
+  });
+});

package/src/logic/getTokenFromAsset.ts

@@ -0,0 +1,17 @@
+import type { AssetInfo } from "@ledgerhq/coin-framework/api/types";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets/tokens";
+
+export async function getTokenFromAsset(
+  currency: CryptoCurrency,
+  asset: AssetInfo,
+): Promise<TokenCurrency | undefined> {
+  const tokenId =
+    asset.type !== "native" && "assetReference" in asset ? asset.assetReference : undefined;
+
+  if (!tokenId) {
+    return;
+  }
+
+  return findTokenByAddressInCurrency(tokenId, currency.id);
+}

package/src/logic/index.ts

@@ -0,0 +1,9 @@
+export { broadcast } from "./broadcast";
+export { combine } from "./combine";
+export { craftTransaction } from "./craftTransaction";
+export { estimateFees } from "./estimateFees";
+export { getBalance } from "./getBalance";
+export { lastBlock } from "./lastBlock";
+export { listOperations } from "./listOperations";
+export { getAssetFromToken } from "./getAssetFromToken";
+export { getTokenFromAsset } from "./getTokenFromAsset";

package/src/logic/lastBlock.test.ts

@@ -0,0 +1,23 @@
+import { lastBlock } from "./lastBlock";
+import { apiClient } from "../network/api";
+import { getSyntheticBlock } from "./utils";
+
+jest.mock("../network/api");
+
+describe("lastBlock", () => {
+  it("should return the last block info", async () => {
+    const mockTransaction = {
+      consensus_timestamp: "1625097600.000000000",
+    };
+
+    (apiClient.getLatestTransaction as jest.Mock).mockResolvedValue(mockTransaction);
+
+    const result = await lastBlock();
+    const expectedSyntheticBlock = getSyntheticBlock(mockTransaction.consensus_timestamp);
+
+    expect(apiClient.getLatestTransaction).toHaveBeenCalledTimes(1);
+    expect(result.height).toEqual(expectedSyntheticBlock.blockHeight);
+    expect(result.hash).toEqual(expectedSyntheticBlock.blockHash);
+    expect(result.time).toEqual(expectedSyntheticBlock.blockTime);
+  });
+});

package/src/logic/lastBlock.ts

@@ -0,0 +1,23 @@
+import type { BlockInfo } from "@ledgerhq/coin-framework/api/index";
+import { apiClient } from "../network/api";
+import { getSyntheticBlock } from "./utils";
+
+/**
+ * Gets the latest "block" information for Hedera.
+ *
+ * Hedera doesn't have actual blocks - it uses a timestamp-based consensus model.
+ * To make Hedera compatible with block-based architecture:
+ * 1. We fetch the most recent transaction from the mirror node
+ * 2. Extract its consensus timestamp
+ * 3. Convert this timestamp into a synthetic block using a hardcoded time window (10 seconds by default)
+ */
+export async function lastBlock(): Promise<BlockInfo> {
+  const latestTransaction = await apiClient.getLatestTransaction();
+  const syntheticBlock = getSyntheticBlock(latestTransaction.consensus_timestamp);
+
+  return {
+    height: syntheticBlock.blockHeight,
+    hash: syntheticBlock.blockHash,
+    time: syntheticBlock.blockTime,
+  };
+}