@ledgerhq/coin-hedera 1.13.0-nightly.2 → 1.13.0-nightly.3

package/src/logic/broadcast.test.ts

@@ -0,0 +1,58 @@
+import { broadcast } from "./broadcast";
+import { rpcClient } from "../network/rpc";
+import { deserializeTransaction } from "./utils";
+
+jest.mock("../network/rpc");
+jest.mock("./utils");
+
+describe("broadcast", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should deserialize and broadcast a transaction successfully", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const mockDeserializedTx = { someProperty: "mockTransaction" } as any;
+    const mockResponse = { transactionId: "mock-transaction-id" } as any;
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (rpcClient.broadcastTransaction as jest.Mock).mockResolvedValue(mockResponse);
+
+    const result = await broadcast(txWithSignature);
+
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledTimes(1);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+    expect(result).toBe(mockResponse);
+  });
+
+  it("should propagate errors from deserializeTransaction", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const error = new Error("Deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    await expect(broadcast(txWithSignature)).rejects.toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from broadcastTransaction", async () => {
+    const txWithSignature = "serialized-transaction-with-signature";
+    const mockDeserializedTx = { someProperty: "mockTransaction" } as any;
+    const error = new Error("Network error");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (rpcClient.broadcastTransaction as jest.Mock).mockRejectedValue(error);
+
+    await expect(broadcast(txWithSignature)).rejects.toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(txWithSignature);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledTimes(1);
+    expect(rpcClient.broadcastTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+  });
+});

package/src/logic/broadcast.ts

@@ -0,0 +1,8 @@
+import type { TransactionResponse } from "@hashgraph/sdk";
+import { rpcClient } from "../network/rpc";
+import { deserializeTransaction } from "./utils";
+
+export const broadcast = async (txWithSignature: string): Promise<TransactionResponse> => {
+  const hederaTransaction = deserializeTransaction(txWithSignature);
+  return await rpcClient.broadcastTransaction(hederaTransaction);
+};

package/src/logic/combine.test.ts

@@ -0,0 +1,119 @@
+import { PublicKey } from "@hashgraph/sdk";
+import { combine } from "./combine";
+import { deserializeSignature, deserializeTransaction, serializeTransaction } from "./utils";
+
+jest.mock("./utils");
+jest.mock("@hashgraph/sdk");
+
+describe("combine", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should combine transaction with signature successfully", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const mockBufferSignature = Buffer.from("mock-signature");
+    const mockBufferPublicKey = { key: "mock-public-key" } as any;
+    const mockSerializedTxWithSignature = "serialized-transaction-with-signature";
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockReturnValue(mockBufferSignature);
+    (PublicKey.fromString as jest.Mock).mockReturnValue(mockBufferPublicKey);
+    (serializeTransaction as jest.Mock).mockReturnValue(mockSerializedTxWithSignature);
+
+    const result = combine(tx, signature, publicKey);
+
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).toHaveBeenCalledTimes(1);
+    expect(PublicKey.fromString).toHaveBeenCalledWith(publicKey);
+    expect(mockDeserializedTx.addSignature).toHaveBeenCalledTimes(1);
+    expect(mockDeserializedTx.addSignature).toHaveBeenCalledWith(
+      mockBufferPublicKey,
+      mockBufferSignature,
+    );
+    expect(serializeTransaction).toHaveBeenCalledTimes(1);
+    expect(serializeTransaction).toHaveBeenCalledWith(mockDeserializedTx);
+    expect(result).toBe(mockSerializedTxWithSignature);
+  });
+
+  it("should throw an error when public key is not provided", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+
+    expect(() => combine(tx, signature, undefined)).toThrow();
+    expect(deserializeTransaction).not.toHaveBeenCalled();
+    expect(deserializeSignature).not.toHaveBeenCalled();
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from deserializeTransaction", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+    const error = new Error("Deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).not.toHaveBeenCalled();
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from deserializeSignature", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "public-key-string";
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const error = new Error("Signature deserialization error");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).not.toHaveBeenCalled();
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+
+  it("should propagate errors from PublicKey.fromString", () => {
+    const tx = "serialized-transaction";
+    const signature = "serialized-signature";
+    const publicKey = "invalid-public-key";
+    const mockDeserializedTx = { addSignature: jest.fn() } as any;
+    const mockBufferSignature = Buffer.from("mock-signature");
+    const error = new Error("Invalid public key");
+
+    (deserializeTransaction as jest.Mock).mockReturnValue(mockDeserializedTx);
+    (deserializeSignature as jest.Mock).mockReturnValue(mockBufferSignature);
+    (PublicKey.fromString as jest.Mock).mockImplementation(() => {
+      throw error;
+    });
+
+    expect(() => combine(tx, signature, publicKey)).toThrow(error);
+    expect(deserializeTransaction).toHaveBeenCalledTimes(1);
+    expect(deserializeTransaction).toHaveBeenCalledWith(tx);
+    expect(deserializeSignature).toHaveBeenCalledTimes(1);
+    expect(deserializeSignature).toHaveBeenCalledWith(signature);
+    expect(PublicKey.fromString).toHaveBeenCalledTimes(1);
+    expect(PublicKey.fromString).toHaveBeenCalledWith(publicKey);
+    expect(serializeTransaction).not.toHaveBeenCalled();
+  });
+});

package/src/logic/combine.ts

@@ -0,0 +1,14 @@
+import invariant from "invariant";
+import { PublicKey } from "@hashgraph/sdk";
+import { deserializeSignature, deserializeTransaction, serializeTransaction } from "./utils";
+
+export function combine(tx: string, signature: string, publicKey?: string): string {
+  invariant(publicKey, "hedera: public key is required to combine the transaction");
+
+  const hederaTransaction = deserializeTransaction(tx);
+  const bufferSignature = deserializeSignature(signature);
+  const bufferPublicKey = PublicKey.fromString(publicKey);
+  hederaTransaction.addSignature(bufferPublicKey, bufferSignature);
+
+  return serializeTransaction(hederaTransaction);
+}

package/src/logic/craftTransaction.test.ts

@@ -0,0 +1,215 @@
+import invariant from "invariant";
+import * as sdk from "@hashgraph/sdk";
+import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
+import { HEDERA_TRANSACTION_MODES, TINYBAR_SCALE } from "../constants";
+import { craftTransaction } from "./craftTransaction";
+import type { HederaMemo } from "../types";
+import { serializeTransaction } from "./utils";
+
+jest.mock("./utils");
+
+describe("craftTransaction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (serializeTransaction as jest.Mock).mockReturnValue("serialized-transaction");
+  });
+
+  it("should craft a native HBAR transfer transaction", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.Send,
+      amount: BigInt(1 * 10 ** TINYBAR_SCALE),
+      recipient: "0.0.12345",
+      sender: "0.0.54321",
+      asset: {
+        type: "native",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Hbar transfer",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    const result = await craftTransaction(txIntent);
+
+    expect(result.tx).toBeInstanceOf(sdk.TransferTransaction);
+    invariant(result.tx instanceof sdk.TransferTransaction, "TransferTransaction type guard");
+
+    const senderTransfer = result.tx.hbarTransfers?.get(txIntent.sender);
+    const recipientTransfer = result.tx.hbarTransfers?.get(txIntent.recipient);
+
+    expect(senderTransfer).toEqual(sdk.Hbar.fromTinybars(-txIntent.amount));
+    expect(recipientTransfer).toEqual(sdk.Hbar.fromTinybars(txIntent.amount));
+    expect(result.tx.transactionMemo).toBe(txIntent.memo.value);
+    expect(serializeTransaction).toHaveBeenCalled();
+    expect(result).toEqual({
+      tx: expect.any(Object),
+      serializedTx: "serialized-transaction",
+    });
+  });
+
+  it("should craft a token transfer transaction", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.Send,
+      amount: BigInt(1000),
+      recipient: "0.0.12345",
+      sender: "0.0.54321",
+      asset: {
+        type: "hts",
+        assetReference: "0.0.7890",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Token transfer",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    const result = await craftTransaction(txIntent);
+
+    expect(result.tx).toBeInstanceOf(sdk.TransferTransaction);
+    invariant(result.tx instanceof sdk.TransferTransaction, "TransferTransaction type guard");
+
+    const tokenTransfers = result.tx.tokenTransfers.get(txIntent.asset.assetReference);
+    const senderTransfer = tokenTransfers?.get(txIntent.sender);
+    const recipientTransfer = tokenTransfers?.get(txIntent.recipient);
+
+    // .toString() is used because tokenTransfers values are Long objects
+    // this is internal dependency of @hashgraph/sdk, re-exported in newer version
+    expect(senderTransfer?.toString()).toEqual((-txIntent.amount).toString());
+    expect(recipientTransfer?.toString()).toEqual(txIntent.amount.toString());
+    expect(result.tx.transactionMemo).toBe("Token transfer");
+    expect(serializeTransaction).toHaveBeenCalled();
+    expect(result).toEqual({
+      tx: expect.any(Object),
+      serializedTx: "serialized-transaction",
+    });
+  });
+
+  it("should craft a token associate transaction", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+      amount: BigInt(0),
+      recipient: "",
+      sender: "0.0.54321",
+      asset: {
+        type: "hts",
+        assetReference: "0.0.7890",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Token association",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    const result = await craftTransaction(txIntent);
+
+    expect(result.tx).toBeInstanceOf(sdk.TokenAssociateTransaction);
+    invariant(
+      result.tx instanceof sdk.TokenAssociateTransaction,
+      "TokenAssociateTransaction type guard",
+    );
+
+    expect(result.tx.accountId).toEqual(sdk.AccountId.fromString(txIntent.sender));
+    expect(result.tx.tokenIds).toEqual([sdk.TokenId.fromString(txIntent.asset.assetReference)]);
+    expect(result.tx.transactionMemo).toBe("Token association");
+    expect(serializeTransaction).toHaveBeenCalled();
+    expect(result).toEqual({
+      tx: expect.any(Object),
+      serializedTx: "serialized-transaction",
+    });
+  });
+
+  it("should apply custom fees when provided", async () => {
+    const customFees: FeeEstimation = {
+      value: BigInt(50000),
+    };
+
+    const result = await craftTransaction(
+      {
+        intentType: "transaction",
+        type: HEDERA_TRANSACTION_MODES.Send,
+        amount: BigInt(1000000),
+        recipient: "0.0.12345",
+        sender: "0.0.54321",
+        asset: {
+          type: "native",
+        },
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "Test memo with custom fee",
+        },
+      },
+      customFees,
+    );
+
+    expect(result.tx).toBeInstanceOf(sdk.TransferTransaction);
+    invariant(result.tx instanceof sdk.TransferTransaction, "TransferTransaction type guard");
+    expect(result.tx.maxTransactionFee).toEqual(sdk.Hbar.fromTinybars(customFees.value));
+  });
+
+  it("should throw error when token associate transaction has invalid asset type", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+      amount: BigInt(0),
+      recipient: "",
+      sender: "0.0.54321",
+      asset: {
+        type: "native",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Invalid token association",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    await expect(craftTransaction(txIntent)).rejects.toThrow();
+  });
+
+  it("should throw error when token associate transaction has missing assetReference", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+      amount: BigInt(0),
+      recipient: "",
+      sender: "0.0.54321",
+      asset: {
+        type: "hts",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Missing asset reference",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    await expect(craftTransaction(txIntent)).rejects.toThrow();
+  });
+
+  it("should throw error when token transfer transaction has missing assetReference", async () => {
+    const txIntent = {
+      intentType: "transaction",
+      type: HEDERA_TRANSACTION_MODES.Send,
+      amount: BigInt(1000),
+      recipient: "0.0.12345",
+      sender: "0.0.54321",
+      asset: {
+        type: "hts",
+      },
+      memo: {
+        kind: "text",
+        type: "string",
+        value: "Missing token reference",
+      },
+    } satisfies TransactionIntent<HederaMemo>;
+
+    await expect(craftTransaction(txIntent)).rejects.toThrow();
+  });
+});

package/src/logic/craftTransaction.ts

@@ -0,0 +1,175 @@
+import BigNumber from "bignumber.js";
+import invariant from "invariant";
+import {
+  AccountId,
+  Hbar,
+  TokenAssociateTransaction,
+  TransactionId,
+  TransferTransaction,
+} from "@hashgraph/sdk";
+import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
+import { HEDERA_TRANSACTION_MODES } from "../constants";
+import type { HederaMemo } from "../types";
+import { serializeTransaction } from "./utils";
+
+// avoid "sign" prompt loop by having only one node (one transaction)
+// https://github.com/LedgerHQ/ledger-live/pull/72/commits/1e942687d4301660e43e0c4b5419fcfa2733b290
+// changing this will break `getHederaTransactionBodyBytes` from logic/utils.ts
+const nodeAccountIds: AccountId[] = [new AccountId(3)];
+
+interface BuilderOperator {
+  accountId: string;
+}
+
+interface BuilderCommonTransactionFields {
+  maxFee: BigNumber | undefined;
+  memo: string;
+}
+
+interface BuilderCoinTransferTransaction extends BuilderCommonTransactionFields {
+  type: HEDERA_TRANSACTION_MODES.Send;
+  amount: BigNumber;
+  recipient: string;
+}
+
+interface BuilderTokenTransferTransaction extends BuilderCommonTransactionFields {
+  type: HEDERA_TRANSACTION_MODES.Send;
+  tokenId: string;
+  amount: BigNumber;
+  recipient: string;
+}
+
+interface BuilderTokenAssociateTransaction extends BuilderCommonTransactionFields {
+  type: HEDERA_TRANSACTION_MODES.TokenAssociate;
+  tokenId: string;
+}
+
+async function buildUnsignedCoinTransaction({
+  account,
+  transaction,
+}: {
+  account: BuilderOperator;
+  transaction: BuilderCoinTransferTransaction;
+}): Promise<TransferTransaction> {
+  const accountId = account.accountId;
+  const hbarAmount = Hbar.fromTinybars(transaction.amount);
+
+  const tx = new TransferTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo)
+    .addHbarTransfer(accountId, hbarAmount.negated())
+    .addHbarTransfer(transaction.recipient, hbarAmount);
+
+  if (transaction.maxFee) {
+    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
+  }
+
+  return tx.freeze();
+}
+
+async function buildUnsignedTokenTransaction({
+  account,
+  transaction,
+}: {
+  account: BuilderOperator;
+  transaction: BuilderTokenTransferTransaction;
+}): Promise<TransferTransaction> {
+  const accountId = account.accountId;
+  const tokenId = transaction.tokenId;
+
+  const tx = new TransferTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo)
+    .addTokenTransfer(tokenId, accountId, transaction.amount.negated().toNumber())
+    .addTokenTransfer(tokenId, transaction.recipient, transaction.amount.toNumber());
+
+  if (transaction.maxFee) {
+    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
+  }
+
+  return tx.freeze();
+}
+
+async function buildTokenAssociateTransaction({
+  account,
+  transaction,
+}: {
+  account: BuilderOperator;
+  transaction: BuilderTokenAssociateTransaction;
+}): Promise<TokenAssociateTransaction> {
+  const accountId = account.accountId;
+
+  const tx = new TokenAssociateTransaction()
+    .setNodeAccountIds(nodeAccountIds)
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo)
+    .setAccountId(accountId)
+    .setTokenIds([transaction.tokenId]);
+
+  if (transaction.maxFee) {
+    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
+  }
+
+  return tx.freeze();
+}
+
+export async function craftTransaction(
+  txIntent: TransactionIntent<HederaMemo>,
+  customFees?: FeeEstimation,
+) {
+  const account = {
+    accountId: txIntent.sender,
+  };
+
+  let tx;
+
+  if (txIntent.type === HEDERA_TRANSACTION_MODES.TokenAssociate) {
+    invariant(txIntent.asset.type !== "native", "hedera: invalid asset type");
+    invariant("assetReference" in txIntent.asset, "hedera: assetReference is missing");
+
+    tx = await buildTokenAssociateTransaction({
+      account,
+      transaction: {
+        type: txIntent.type,
+        tokenId: txIntent.asset.assetReference,
+        memo: txIntent.memo.value,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+      },
+    });
+  } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type !== "native") {
+    invariant("assetReference" in txIntent.asset, "hedera: no assetReference in token transfer");
+
+    const amount = new BigNumber(txIntent.amount.toString());
+
+    tx = await buildUnsignedTokenTransaction({
+      account,
+      transaction: {
+        type: txIntent.type,
+        tokenId: txIntent.asset.assetReference,
+        amount,
+        recipient: txIntent.recipient,
+        memo: txIntent.memo.value,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+      },
+    });
+  } else {
+    const amount = new BigNumber(txIntent.amount.toString());
+
+    tx = await buildUnsignedCoinTransaction({
+      account,
+      transaction: {
+        type: HEDERA_TRANSACTION_MODES.Send,
+        amount,
+        recipient: txIntent.recipient,
+        memo: txIntent.memo.value,
+        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+      },
+    });
+  }
+
+  const serializedTx = serializeTransaction(tx);
+
+  return { tx, serializedTx };
+}

package/src/logic/estimateFees.test.ts

@@ -0,0 +1,99 @@
+import BigNumber from "bignumber.js";
+import cvsApi from "@ledgerhq/live-countervalues/api/index";
+import {
+  DEFAULT_TINYBAR_FEE,
+  ESTIMATED_FEE_SAFETY_RATE,
+  HEDERA_OPERATION_TYPES,
+  TINYBAR_SCALE,
+} from "../constants";
+import { estimateFees } from "./estimateFees";
+import { getMockedAccount } from "../test/fixtures/account.fixture";
+import { getCurrencyToUSDRate } from "./utils";
+
+jest.mock("@ledgerhq/live-countervalues/api/index");
+
+describe("getEstimatedFees", () => {
+  const mockedAccount = getMockedAccount();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // reset LRU cache to make sure all tests receive correct mocks from mockedFetchLatest
+    getCurrencyToUSDRate.clear(mockedAccount.currency.ticker);
+  });
+
+  test("returns estimated fee based on USD rate for CryptoTransfer", async () => {
+    const usdRate = 1; // 1 HBAR = 1 USD
+    (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
+
+    const result = await estimateFees(
+      mockedAccount.currency,
+      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    );
+
+    const baseFeeTinybar = 0.0001 * 10 ** TINYBAR_SCALE;
+    const expectedFee = new BigNumber(baseFeeTinybar)
+      .div(usdRate)
+      .integerValue(BigNumber.ROUND_CEIL)
+      .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+
+    expect(result).toEqual(expectedFee);
+  });
+
+  test("returns estimated fee based on USD rate for TokenTransfer", async () => {
+    const usdRate = 0.5; // 1 HBAR = 0.5 USD
+    (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
+
+    const result = await estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.TokenTransfer);
+
+    const baseFeeTinybar = 0.001 * 10 ** TINYBAR_SCALE;
+    const expectedFee = new BigNumber(baseFeeTinybar)
+      .div(usdRate)
+      .integerValue(BigNumber.ROUND_CEIL)
+      .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+
+    expect(result).toEqual(expectedFee);
+  });
+
+  test("returns estimated fee based on USD rate for TokenAssociate", async () => {
+    const usdRate = 2; // 1 HBAR = 2 USD
+    (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
+
+    const result = await estimateFees(
+      mockedAccount.currency,
+      HEDERA_OPERATION_TYPES.TokenAssociate,
+    );
+
+    const baseFeeTinybar = 0.05 * 10 ** TINYBAR_SCALE;
+    const expectedFee = new BigNumber(baseFeeTinybar)
+      .div(usdRate)
+      .integerValue(BigNumber.ROUND_CEIL)
+      .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+
+    expect(result).toEqual(expectedFee);
+  });
+
+  test("falls back to default estimate when cvs api returns null", async () => {
+    const usdRate = null;
+    (cvsApi.fetchLatest as jest.Mock).mockResolvedValueOnce([usdRate]);
+
+    const result = await estimateFees(
+      mockedAccount.currency,
+      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    );
+
+    const expected = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+    expect(result).toEqual(expected);
+  });
+
+  test("falls back to default estimate on cvs api failure", async () => {
+    (cvsApi.fetchLatest as jest.Mock).mockRejectedValueOnce(new Error("Network error"));
+
+    const result = await estimateFees(
+      mockedAccount.currency,
+      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    );
+
+    const expected = new BigNumber(DEFAULT_TINYBAR_FEE).multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
+    expect(result).toEqual(expected);
+  });
+});