@ledgerhq/coin-hedera 1.15.0-nightly.20251126023856 → 1.15.0-nightly.20251126160702

package/src/logic/getTokenFromAsset.test.ts

@@ -1,12 +1,12 @@
 import { getTokenFromAsset } from "./getTokenFromAsset";
-import { getMockedCurrency, getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import { getMockedCurrency, getMockedHTSTokenCurrency } from "../test/fixtures/currency.fixture";
 import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
 setupMockCryptoAssetsStore();
 
 describe("getTokenFromAsset", () => {
   const mockCurrency = getMockedCurrency();
-  const mockToken = getMockedTokenCurrency();
+  const mockToken = getMockedHTSTokenCurrency();
 
   beforeEach(() => {
     jest.clearAllMocks();

package/src/logic/listOperations.ts

@@ -1,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import type { Operation } from "@ledgerhq/types-live";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Pagination } from "@ledgerhq/coin-framework/api/types";
 import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
@@ -10,6 +10,11 @@ import { parseTransfers } from "../network/utils";
 import type { HederaMirrorToken, HederaMirrorTransaction, HederaOperationExtra } from "../types";
 import { base64ToUrlSafeBase64, getMemoFromBase64, getSyntheticBlock } from "./utils";
 
+const txNameToCustomOperationType: Record<string, OperationType> = {
+  TOKENASSOCIATE: "ASSOCIATE_TOKEN",
+  CONTRACTCALL: "CONTRACT_CALL",
+};
+
 function getCommonOperationData(
   rawTx: HederaMirrorTransaction,
   useEncodedHash: boolean,
@@ -26,6 +31,7 @@ function getCommonOperationData(
   const extra: HederaOperationExtra = {
     pagingToken: rawTx.consensus_timestamp,
     consensusTimestamp: rawTx.consensus_timestamp,
+    transactionId: rawTx.transaction_id,
     ...(memo && { memo }),
   };
 
@@ -134,14 +140,12 @@ function processTransfers({
   const { type, value, senders, recipients } = parseTransfers(transfers, address);
   const { hash, fee, timestamp, blockHeight, blockHash, hasFailed } = commonData;
   const extra = { ...commonData.extra };
-  let operationType = type;
+  const operationType = txNameToCustomOperationType[rawTx.name] ?? 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";
-
+  if (operationType === "ASSOCIATE_TOKEN") {
     const relatedMirrorToken = mirrorTokens.find(t => {
       return t.created_timestamp === rawTx.consensus_timestamp;
     });

package/src/logic/utils.test.ts

@@ -1,13 +1,18 @@
 import BigNumber from "bignumber.js";
 import { createHash } from "crypto";
-import { Transaction } from "@hashgraph/sdk";
+import { Transaction, TransactionId } from "@hashgraph/sdk";
 import type { AssetInfo } from "@ledgerhq/coin-framework/api/types";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { InvalidAddress } from "@ledgerhq/errors";
 import { HEDERA_TRANSACTION_MODES, SYNTHETIC_BLOCK_WINDOW_SECONDS } from "../constants";
+import { HederaRecipientInvalidChecksum } from "../errors";
 import { apiClient } from "../network/api";
+import { rpcClient } from "../network/rpc";
 import { getMockedOperation } from "../test/fixtures/operation.fixture";
-import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
+import {
+  getMockedERC20TokenCurrency,
+  getMockedHTSTokenCurrency,
+} from "../test/fixtures/currency.fixture";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import {
   serializeSignature,
@@ -25,16 +30,22 @@ import {
   checkAccountTokenAssociationStatus,
   safeParseAccountId,
   getSyntheticBlock,
+  fromEVMAddress,
+  toEVMAddress,
+  formatTransactionId,
 } from "./utils";
-import { HederaRecipientInvalidChecksum } from "../errors";
 
 jest.mock("../network/api");
 
-describe("utils", () => {
+describe("logic utils", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
+  afterAll(() => {
+    rpcClient._resetInstance();
+  });
+
   describe("signature serialization", () => {
     it("should serialize a signature to base64", () => {
       const signature = new Uint8Array([1, 2, 3, 4, 5]);
@@ -84,49 +95,49 @@ describe("utils", () => {
       expect(deserialized).toBe(mockTransaction);
     });
   });
-});
 
-describe("getOperationValue", () => {
-  const nativeAsset: AssetInfo = { type: "native" };
-  const tokenAsset: AssetInfo = { type: "hts", assetReference: "0.0.1234" };
+  describe("getOperationValue", () => {
+    const nativeAsset: AssetInfo = { type: "native" };
+    const tokenAsset: AssetInfo = { type: "hts", assetReference: "0.0.1234" };
 
-  it("should return 0 for FEES operations", () => {
-    const operation = getMockedOperation({
-      type: "FEES",
-      value: BigNumber(0),
-      fee: BigNumber(100),
+    it("should return 0 for FEES operations", () => {
+      const operation = getMockedOperation({
+        type: "FEES",
+        value: BigNumber(0),
+        fee: BigNumber(100),
+      });
+
+      expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(0));
+      expect(getOperationValue({ asset: tokenAsset, operation })).toBe(BigInt(0));
     });
 
-    expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(0));
-    expect(getOperationValue({ asset: tokenAsset, operation })).toBe(BigInt(0));
-  });
+    it("should substract fee from value for native OUT operations", () => {
+      const operation = getMockedOperation({
+        type: "OUT",
+        value: BigNumber(1000),
+        fee: BigNumber(100),
+      });
 
-  it("should substract fee from value for native OUT operations", () => {
-    const operation = getMockedOperation({
-      type: "OUT",
-      value: BigNumber(1000),
-      fee: BigNumber(100),
+      expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(900));
     });
 
-    expect(getOperationValue({ asset: nativeAsset, operation })).toBe(BigInt(900));
-  });
+    it("should return value for other operations", () => {
+      const operationOut = getMockedOperation({
+        type: "OUT",
+        value: BigNumber(500),
+        fee: BigNumber(20),
+      });
 
-  it("should return value for other operations", () => {
-    const operationOut = getMockedOperation({
-      type: "OUT",
-      value: BigNumber(500),
-      fee: BigNumber(20),
-    });
+      const operationIn = getMockedOperation({
+        type: "IN",
+        value: BigNumber(800),
+        fee: BigNumber(30),
+      });
 
-    const operationIn = getMockedOperation({
-      type: "IN",
-      value: BigNumber(800),
-      fee: BigNumber(30),
+      expect(getOperationValue({ asset: tokenAsset, operation: operationOut })).toBe(BigInt(500));
+      expect(getOperationValue({ asset: tokenAsset, operation: operationIn })).toBe(BigInt(800));
+      expect(getOperationValue({ asset: nativeAsset, operation: operationIn })).toBe(BigInt(800));
     });
-
-    expect(getOperationValue({ asset: tokenAsset, operation: operationOut })).toBe(BigInt(500));
-    expect(getOperationValue({ asset: tokenAsset, operation: operationIn })).toBe(BigInt(800));
-    expect(getOperationValue({ asset: nativeAsset, operation: operationIn })).toBe(BigInt(800));
   });
 
   describe("getMemoFromBase64", () => {
@@ -157,7 +168,7 @@ describe("getOperationValue", () => {
   });
 
   describe("getTransactionExplorer", () => {
-    test("Tx explorer URL is converted from hash to consensus timestamp", async () => {
+    it("Tx explorer URL is converted from hash to consensus timestamp", async () => {
       const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
       expect(explorerView).toEqual({
         tx: expect.any(String),
@@ -172,7 +183,7 @@ describe("getOperationValue", () => {
       expect(newUrl).toBe("https://hashscan.io/mainnet/transaction/1.2.3.4");
     });
 
-    test("Tx explorer URL is based on transaction id if consensus timestamp is not available", async () => {
+    it("Tx explorer URL is based on transaction id if consensus timestamp is not available", async () => {
       const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
       expect(explorerView).toEqual({
         tx: expect.any(String),
@@ -189,7 +200,7 @@ describe("getOperationValue", () => {
   });
 
   describe("isTokenAssociateTransaction", () => {
-    test("returns correct value based on tx.properties", () => {
+    it("returns correct value based on tx.properties", () => {
       expect(
         isTokenAssociateTransaction({ mode: HEDERA_TRANSACTION_MODES.TokenAssociate } as any),
       ).toBe(true);
@@ -201,7 +212,7 @@ describe("getOperationValue", () => {
   });
 
   describe("isAutoTokenAssociationEnabled", () => {
-    test("returns value based on isAutoTokenAssociationEnabled flag", () => {
+    it("returns value based on isAutoTokenAssociationEnabled flag", () => {
       expect(
         isAutoTokenAssociationEnabled({
           hederaResources: { isAutoTokenAssociationEnabled: true },
@@ -219,16 +230,16 @@ describe("getOperationValue", () => {
   });
 
   describe("isTokenAssociationRequired", () => {
-    test("should return false if token is already associated (token account exists)", () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("should return false if token is already associated (token account exists)", () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
       const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
 
       expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(false);
     });
 
-    test("should return false if auto token associations are enabled", () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("should return false if auto token associations are enabled", () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedAccount = getMockedAccount({
         subAccounts: [],
         hederaResources: {
@@ -240,21 +251,28 @@ describe("getOperationValue", () => {
       expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(false);
     });
 
-    test("should return true if token is not associated and auto associations are disabled", () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("should return true if token is not associated and auto associations are disabled", () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedAccount = getMockedAccount({ subAccounts: [] });
 
       expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(true);
     });
 
-    test("should return false if token is undefined", () => {
+    it("should return false for erc20 token", () => {
+      const mockedTokenCurrency = getMockedERC20TokenCurrency();
+      const mockedAccount = getMockedAccount({ subAccounts: [] });
+
+      expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(false);
+    });
+
+    it("should return false if token is undefined", () => {
       const mockedAccount = getMockedAccount({ subAccounts: [] });
 
       expect(isTokenAssociationRequired(mockedAccount, undefined)).toBe(false);
     });
 
-    test("should return false for legacy accounts without subAccounts or hederaResources", () => {
-      const mockedTokenCurrency = getMockedTokenCurrency();
+    it("should return false for legacy accounts without subAccounts or hederaResources", () => {
+      const mockedTokenCurrency = getMockedHTSTokenCurrency();
       const mockedAccount = getMockedAccount();
 
       delete mockedAccount.subAccounts;
@@ -265,7 +283,7 @@ describe("getOperationValue", () => {
   });
 
   describe("isValidExtra", () => {
-    test("returns true for object and false for invalid types", () => {
+    it("returns true for object and false for invalid types", () => {
       expect(isValidExtra({ some: "value" })).toBe(true);
       expect(isValidExtra(null)).toBe(false);
       expect(isValidExtra(undefined)).toBe(false);
@@ -276,7 +294,7 @@ describe("getOperationValue", () => {
   });
 
   describe("sendRecipientCanNext", () => {
-    test("handles association warnings", () => {
+    it("handles association warnings", () => {
       expect(sendRecipientCanNext({ warnings: {} } as any)).toBe(true);
       expect(sendRecipientCanNext({ warnings: { missingAssociation: new Error() } } as any)).toBe(
         false,
@@ -289,15 +307,19 @@ describe("getOperationValue", () => {
 
   describe("checkAccountTokenAssociationStatus", () => {
     const accountId = "0.0.1234";
-    const tokenId = "0.0.5678";
+    const htsToken = getMockedHTSTokenCurrency({ contractAddress: "0.0.1234", tokenType: "hts" });
+    const erc20Token = getMockedHTSTokenCurrency({
+      contractAddress: "0.0.4321",
+      tokenType: "erc20",
+    });
 
     beforeEach(() => {
       jest.clearAllMocks();
       // reset LRU cache to make sure all tests receive correct mocks from mockedGetAccount
-      checkAccountTokenAssociationStatus.clear(`${accountId}-${tokenId}`);
+      checkAccountTokenAssociationStatus.clear(`${accountId}-${htsToken.contractAddress}`);
     });
 
-    test("returns true if max_automatic_token_associations === -1", async () => {
+    it("returns true if max_automatic_token_associations === -1", async () => {
       (apiClient.getAccount as jest.Mock).mockResolvedValueOnce({
         account: accountId,
         max_automatic_token_associations: -1,
@@ -308,41 +330,47 @@ describe("getOperationValue", () => {
         },
       });
 
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
+      const result = await checkAccountTokenAssociationStatus(accountId, htsToken);
       expect(result).toBe(true);
     });
 
-    test("returns true if token is already associated", async () => {
+    it("returns true if token is already associated", async () => {
       (apiClient.getAccount as jest.Mock).mockResolvedValueOnce({
         account: accountId,
         max_automatic_token_associations: 0,
         balance: {
           balance: 1,
           timestamp: "",
-          tokens: [{ token_id: tokenId, balance: 1 }],
+          tokens: [{ token_id: htsToken.contractAddress, balance: 1 }],
         },
       });
 
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
+      const result = await checkAccountTokenAssociationStatus(accountId, htsToken);
       expect(result).toBe(true);
     });
 
-    test("returns false if token is not associated", async () => {
+    it("returns false if token is not associated", async () => {
       (apiClient.getAccount as jest.Mock).mockResolvedValueOnce({
         account: accountId,
         max_automatic_token_associations: 0,
         balance: {
           balance: 1,
           timestamp: "",
-          tokens: [{ token_id: "0.0.9999", balance: 1 }],
+          tokens: [{ token_id: "0.1234", balance: 1 }],
         },
       });
 
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
+      const result = await checkAccountTokenAssociationStatus(accountId, htsToken);
       expect(result).toBe(false);
     });
 
-    test("supports addresses with checksum", async () => {
+    it("returns true for erc20 tokens", async () => {
+      const result = await checkAccountTokenAssociationStatus(accountId, erc20Token);
+      expect(apiClient.getAccount as jest.Mock).not.toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it("supports addresses with checksum", async () => {
       const addressWithChecksum = "0.0.9124531-xrxlv";
 
       (apiClient.getAccount as jest.Mock).mockResolvedValueOnce({
@@ -351,18 +379,18 @@ describe("getOperationValue", () => {
         balance: {
           balance: 1,
           timestamp: "",
-          tokens: [{ token_id: "0.0.9999", balance: 1 }],
+          tokens: [{ token_id: htsToken.contractAddress, balance: 1 }],
         },
       });
 
-      await checkAccountTokenAssociationStatus(addressWithChecksum, tokenId);
+      await checkAccountTokenAssociationStatus(addressWithChecksum, htsToken);
       expect(apiClient.getAccount).toHaveBeenCalledTimes(1);
       expect(apiClient.getAccount).toHaveBeenCalledWith("0.0.9124531");
     });
   });
 
   describe("safeParseAccountId", () => {
-    test("returns account id and no checksum for valid address without checksum", () => {
+    it("returns account id and no checksum for valid address without checksum", () => {
       const [error, result] = safeParseAccountId("0.0.9124531");
 
       expect(error).toBeNull();
@@ -370,7 +398,7 @@ describe("getOperationValue", () => {
       expect(result?.checksum).toBeNull();
     });
 
-    test("returns account id and checksum for valid address with correct checksum", () => {
+    it("returns account id and checksum for valid address with correct checksum", () => {
       const [error, result] = safeParseAccountId("0.0.9124531-xrxlv");
 
       expect(error).toBeNull();
@@ -378,14 +406,14 @@ describe("getOperationValue", () => {
       expect(result?.checksum).toBe("xrxlv");
     });
 
-    test("returns error for valid address with incorrect checksum", () => {
+    it("returns error for valid address with incorrect checksum", () => {
       const [error, accountId] = safeParseAccountId("0.0.9124531-invld");
 
       expect(error).toBeInstanceOf(HederaRecipientInvalidChecksum);
       expect(accountId).toBeNull();
     });
 
-    test("returns error for invalid address format", () => {
+    it("returns error for invalid address format", () => {
       const [error, accountId] = safeParseAccountId("not-a-valid-address");
 
       expect(error).toBeInstanceOf(InvalidAddress);
@@ -429,4 +457,64 @@ describe("getOperationValue", () => {
       expect(() => getSyntheticBlock("")).toThrow();
     });
   });
+
+  describe("formatTransactionId", () => {
+    it("converts SDK TransactionId format to mirror node format", () => {
+      const mockTransactionId = {
+        toString: () => "0.0.8835924@1759825731.231952875",
+      } as TransactionId;
+
+      const result = formatTransactionId(mockTransactionId);
+      expect(result).toBe("0.0.8835924-1759825731-231952875");
+    });
+
+    it("handles different account ID formats", () => {
+      const mockTransactionId = {
+        toString: () => "0.0.1@1234567890.987654321",
+      } as TransactionId;
+
+      const result = formatTransactionId(mockTransactionId);
+      expect(result).toBe("0.0.1-1234567890-987654321");
+    });
+  });
+
+  describe("toEVMAddress", () => {
+    it("returns correct EVM address for valid Hedera account ID", () => {
+      const evmAddress = toEVMAddress("0.0.12345");
+      expect(evmAddress).toBe("0x0000000000000000000000000000000000003039");
+    });
+
+    it("returns null for invalid Hedera account ID", () => {
+      const evmAddress = toEVMAddress("invalid_account_id");
+      expect(evmAddress).toBeNull();
+    });
+  });
+
+  describe("fromEVMAddress", () => {
+    it("should convert a long-zero EVM address to Hedera account ID", () => {
+      const evmAddress = "0x00000000000000000000000000000000008b3ab3";
+      const result = fromEVMAddress(evmAddress);
+      expect(result).toBe("0.0.9124531");
+    });
+
+    it("should return null for non-long-zero EVM address", () => {
+      const evmAddress = "0xae2e616828973ec543bbce40cf640c012c5a3805";
+      const result = fromEVMAddress(evmAddress, 0, 0);
+      expect(result).toBeNull();
+    });
+
+    it("should handle custom shard and realm values", () => {
+      const evmAddress = "0x0000000000000000000000000000000000000064";
+      const result = fromEVMAddress(evmAddress, 1, 2);
+      expect(result).toBe("1.2.100");
+    });
+
+    it("should return null for invalid EVM addresses", () => {
+      expect(fromEVMAddress("not-an-address")).toBeNull();
+      expect(fromEVMAddress("0xInvalid")).toBeNull();
+      expect(fromEVMAddress("")).toBeNull();
+      expect(fromEVMAddress("1234567890")).toBeNull();
+      expect(fromEVMAddress(undefined as unknown as string)).toBeNull();
+    });
+  });
 });

package/src/logic/utils.ts

@@ -1,7 +1,12 @@
 import BigNumber from "bignumber.js";
 import { createHash } from "crypto";
 import invariant from "invariant";
-import { AccountId, Transaction as HederaSDKTransaction } from "@hashgraph/sdk";
+import {
+  AccountId,
+  EntityIdHelper,
+  Transaction as HederaSDKTransaction,
+  TransactionId,
+} from "@hashgraph/sdk";
 import { AssetInfo, TransactionIntent } from "@ledgerhq/coin-framework/api/types";
 import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
 import { getFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/fiats";
@@ -75,10 +80,14 @@ export const mapIntentToSDKOperation = (txIntent: TransactionIntent) => {
     return HEDERA_OPERATION_TYPES.TokenAssociate;
   }
 
-  if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type !== "native") {
+  if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "hts") {
     return HEDERA_OPERATION_TYPES.TokenTransfer;
   }
 
+  if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "erc20") {
+    return HEDERA_OPERATION_TYPES.ContractCall;
+  }
+
   return HEDERA_OPERATION_TYPES.CryptoTransfer;
 };
 
@@ -127,6 +136,10 @@ export const isTokenAssociationRequired = (
   account: AccountLike,
   token: TokenCurrency | null | undefined,
 ) => {
+  if (token?.tokenType !== "hts") {
+    return false;
+  }
+
   const subAccounts = !!account && "subAccounts" in account ? account.subAccounts ?? [] : [];
   const isTokenAssociated = subAccounts.some(item => item.token.id === token?.id);
 
@@ -170,7 +183,11 @@ export const getCurrencyToUSDRate = makeLRUCache(
 );
 
 export const checkAccountTokenAssociationStatus = makeLRUCache(
-  async (address: string, tokenId: string) => {
+  async (address: string, token: TokenCurrency) => {
+    if (token.tokenType !== "hts") {
+      return true;
+    }
+
     const [parsingError, parsingResult] = safeParseAccountId(address);
 
     if (parsingError) {
@@ -185,13 +202,13 @@ export const checkAccountTokenAssociationStatus = makeLRUCache(
       return true;
     }
 
-    const isTokenAssociated = mirrorAccount.balance.tokens.some(token => {
-      return token.token_id === tokenId;
+    const isTokenAssociated = mirrorAccount.balance.tokens.some(t => {
+      return t.token_id === token.contractAddress;
     });
 
     return isTokenAssociated;
   },
-  (accountId, tokenId) => `${accountId}-${tokenId}`,
+  (accountId, token) => `${accountId}-${token.contractAddress}`,
   seconds(30),
 );
 
@@ -203,16 +220,11 @@ export const safeParseAccountId = (
 
   try {
     const accountId = AccountId.fromString(address);
+    const checksum = EntityIdHelper.fromString(address).checksum ?? null;
 
-    // verify checksum if present
-    // FIXME: migrate to EntityIdHelper methods once SDK is upgraded:
-    // https://github.com/hiero-ledger/hiero-sdk-js/blob/main/src/EntityIdHelper.js#L197
-    // https://github.com/hiero-ledger/hiero-sdk-js/blob/main/src/EntityIdHelper.js#L446
-    const checksum: string | null = address.split("-")[1] ?? null;
     if (checksum) {
       const client = rpcClient.getInstance();
-      const recipientWithChecksum = accountId.toStringWithChecksum(client);
-      const expectedChecksum = recipientWithChecksum.split("-")[1];
+      const expectedChecksum = accountId.toStringWithChecksum(client).split("-")[1];
 
       if (checksum !== expectedChecksum) {
         return [new HederaRecipientInvalidChecksum(), null];
@@ -253,3 +265,53 @@ export function getSyntheticBlock(
 
   return { blockHeight, blockHash, blockTime };
 }
+
+export const formatTransactionId = (transactionId: TransactionId): string => {
+  const [accountId, timestamp] = transactionId.toString().split("@");
+  const [secs, nanos] = timestamp.split(".");
+
+  return `${accountId}-${secs}-${nanos}`;
+};
+
+/**
+ * Converts a Hedera account ID (e.g. "0.0.1234") into its corresponding EVM address in hexadecimal format.
+ * If the conversion fails, it returns null.
+ *
+ * @param address - Hedera account ID in the format `shard.realm.num`
+ * @returns the long-zero EVM address (`0x...`) or null if conversion fails
+ */
+export const toEVMAddress = (accountId: string) => {
+  try {
+    const evmAddress = "0x" + AccountId.fromString(accountId).toEvmAddress();
+    return evmAddress;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Converts EVM address in hexadecimal format to its corresponding Hedera account ID.
+ * Only long-zero addresses can be mathematically converted back to account IDs.
+ * Non-long-zero addresses support would require mirror node call and is not needed for now
+ * Uses shard 0 and realm 0 by default for the conversion.
+ * If the conversion fails, it returns null.
+ *
+ * @param evmAddress - EVM address in hexadecimal format (should start with '0x')
+ * @param shard - Optional shard ID (defaults to 0)
+ * @param realm - Optional realm ID (defaults to 0)
+ * @returns Hedera account ID in the format `shard.realm.num` or null if conversion fails
+ */
+export const fromEVMAddress = (evmAddress: string, shard = 0, realm = 0): string | null => {
+  try {
+    const isLongZeroAddress = evmAddress.includes("0".repeat(20));
+
+    if (!isLongZeroAddress) {
+      return null;
+    }
+
+    const accountId = AccountId.fromEvmAddress(shard, realm, evmAddress).toString();
+    return accountId;
+  } catch {
+    return null;
+  }
+};