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

package/src/bridge/utils.integration.test.ts

@@ -1,40 +1,26 @@
 import BigNumber from "bignumber.js";
-import { InvalidAddress } from "@ledgerhq/errors";
-import cvsApi from "@ledgerhq/live-countervalues/api/index";
 import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
+import { estimateFees } from "../logic/estimateFees";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
+import {
+  getMockedCurrency,
+  getMockedTokenCurrency,
+  getTokenCurrencyFromCAL,
+} from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import { getMockedOperation } from "../test/fixtures/operation.fixture";
+import { getMockedMirrorToken } from "../test/fixtures/mirror.fixture";
+import type { HederaOperationExtra } from "../types";
 import {
   applyPendingExtras,
   calculateAmount,
-  checkAccountTokenAssociationStatus,
-  getCurrencyToUSDRate,
-  getEstimatedFees,
   getSubAccounts,
   getSyncHash,
   mergeSubAccounts,
-  safeParseAccountId,
   patchOperationWithExtra,
   prepareOperations,
 } from "./utils";
-import {
-  getMockedCurrency,
-  getMockedTokenCurrency,
-  getTokenCurrencyFromCAL,
-} from "../test/fixtures/currency.fixture";
-import { getMockedOperation } from "../test/fixtures/operation.fixture";
-import { HederaOperationExtra } from "../types";
-import { getAccount } from "../api/mirror";
-import { HederaRecipientInvalidChecksum } from "../errors";
-import { isValidExtra } from "../logic";
-import { getMockedMirrorToken } from "../test/fixtures/mirror.fixture";
-import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_KINDS } from "../constants";
-
-jest.mock("../api/mirror");
-jest.mock("@ledgerhq/live-countervalues/api/index");
-
-const mockedFetchLatest = cvsApi.fetchLatest as jest.MockedFunction<typeof cvsApi.fetchLatest>;
-const mockedGetAccount = getAccount as jest.MockedFunction<typeof getAccount>;
 
 describe("utils", () => {
   describe("calculateAmount", () => {
@@ -43,8 +29,8 @@ describe("utils", () => {
     beforeAll(async () => {
       const mockedAccount = getMockedAccount();
       const [crypto, associate] = await Promise.all([
-        getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer),
-        getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.TokenAssociate),
+        estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.CryptoTransfer),
+        estimateFees(mockedAccount.currency, HEDERA_OPERATION_TYPES.TokenAssociate),
       ]);
 
       estimatedFees = { crypto, associate };
@@ -131,8 +117,8 @@ describe("utils", () => {
       const mockedTransaction = getMockedTransaction({
         useAllAmount: false,
         amount: new BigNumber(1),
+        mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
         properties: {
-          name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
           token: mockedTokenCurrency,
         },
       });
@@ -149,83 +135,6 @@ describe("utils", () => {
     });
   });
 
-  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 () => {
-      // 1 HBAR = 1 USD
-      const usdRate = 1;
-      mockedFetchLatest.mockResolvedValueOnce([usdRate]);
-
-      const result = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
-
-      const baseFeeTinybar = 0.0001 * 10 ** 8;
-      const expectedFee = new BigNumber(baseFeeTinybar)
-        .div(usdRate)
-        .integerValue(BigNumber.ROUND_CEIL)
-        .multipliedBy(2); // safety rate
-
-      expect(result.toFixed()).toBe(expectedFee.toFixed());
-    });
-
-    test("returns estimated fee based on USD rate for TokenTransfer", async () => {
-      // 1 HBAR = 0.5 USD
-      const usdRate = 0.5;
-      mockedFetchLatest.mockResolvedValueOnce([usdRate]);
-
-      const result = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.TokenTransfer);
-
-      const baseFeeTinybar = 0.001 * 10 ** 8;
-      const expectedFee = new BigNumber(baseFeeTinybar)
-        .div(usdRate)
-        .integerValue(BigNumber.ROUND_CEIL)
-        .multipliedBy(2);
-
-      expect(result.toFixed()).toBe(expectedFee.toFixed());
-    });
-
-    test("returns estimated fee based on USD rate for TokenAssociate", async () => {
-      // 1 HBAR = 2 USD
-      const usdRate = 2;
-      mockedFetchLatest.mockResolvedValueOnce([usdRate]);
-
-      const result = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.TokenAssociate);
-
-      const baseFeeTinybar = 0.05 * 10 ** 8;
-      const expectedFee = new BigNumber(baseFeeTinybar)
-        .div(usdRate)
-        .integerValue(BigNumber.ROUND_CEIL)
-        .multipliedBy(2);
-
-      expect(result.toFixed()).toBe(expectedFee.toFixed());
-    });
-
-    test("falls back to default estimate when cvs api returns null", async () => {
-      const usdRate = null;
-      mockedFetchLatest.mockResolvedValueOnce([usdRate]);
-
-      const result = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
-
-      const expected = new BigNumber("150200").multipliedBy(2);
-      expect(result.toFixed()).toBe(expected.toFixed());
-    });
-
-    test("falls back to default estimate on cvs api failure", async () => {
-      mockedFetchLatest.mockRejectedValueOnce(new Error("Network error"));
-
-      const result = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
-
-      const expected = new BigNumber("150200").multipliedBy(2);
-      expect(result.toFixed()).toBe(expected.toFixed());
-    });
-  });
-
   describe("getSyncHash", () => {
     const mockedCurrency = getMockedCurrency();
 
@@ -307,7 +216,7 @@ describe("utils", () => {
       expect(result).toHaveLength(1);
       expect(result[0].token).toEqual(tokenCurrencyFromCAL);
       expect(result[0].operations).toHaveLength(0);
-      expect(result[0].balance.toString()).toBe("42");
+      expect(result[0].balance).toEqual(new BigNumber(42));
     });
   });
 
@@ -322,7 +231,7 @@ describe("utils", () => {
         accountId: encodeTokenAccountId(mockedTokenAccount.parentId, tokenCurrencyFromCAL),
       });
 
-      const result = prepareOperations([mockedCoinOperation], [mockedTokenOperation], []);
+      const result = prepareOperations([mockedCoinOperation], [mockedTokenOperation]);
 
       expect(result).toHaveLength(1);
       expect(result[0].subOperations).toEqual([mockedTokenOperation]);
@@ -335,7 +244,7 @@ describe("utils", () => {
         accountId: encodeTokenAccountId(mockedTokenAccount.parentId, tokenCurrencyFromCAL),
       });
 
-      const result = prepareOperations([], [mockedOrphanTokenOperation], []);
+      const result = prepareOperations([], [mockedOrphanTokenOperation]);
       const noneOp = result.find(op => op.type === "NONE");
 
       expect(typeof noneOp).toBe("object");
@@ -343,42 +252,6 @@ describe("utils", () => {
       expect(noneOp?.subOperations?.[0]).toEqual(mockedOrphanTokenOperation);
       expect(noneOp?.hash).toBe("unknown-hash");
     });
-
-    test("adds associatedTokenId to ASSOCIATE_TOKEN coin operation based on consensusTimestamp", () => {
-      const mockedCoinOperation = getMockedOperation({
-        type: "ASSOCIATE_TOKEN",
-        extra: { consensusTimestamp: "123" },
-      });
-      const mockedMirrorToken = getMockedMirrorToken({
-        token_id: "0.0.1001",
-        created_timestamp: "123",
-      });
-
-      const result = prepareOperations([mockedCoinOperation], [], [mockedMirrorToken]);
-      const extra = isValidExtra(result[0].extra) ? result[0].extra : null;
-
-      expect(typeof extra).toBe("object");
-      expect(extra).not.toBeNull();
-      expect(extra?.associatedTokenId).toBe("0.0.1001");
-    });
-
-    test("ignores enrichment of ASSOCIATE_TOKEN operation if consensusTimestamp mismatches", () => {
-      const mockedCoinOperation = getMockedOperation({
-        type: "ASSOCIATE_TOKEN",
-        extra: { consensusTimestamp: "123" },
-      });
-      const mockedMirrorToken = getMockedMirrorToken({
-        token_id: "0.0.1001",
-        created_timestamp: "999",
-      });
-
-      const result = prepareOperations([mockedCoinOperation], [], [mockedMirrorToken]);
-      const extra = isValidExtra(result[0].extra) ? result[0].extra : null;
-
-      expect(typeof extra).toBe("object");
-      expect(extra).not.toBeNull();
-      expect(extra?.associatedTokenId).toBeUndefined();
-    });
   });
 
   describe("mergeSubAccounts", () => {
@@ -450,6 +323,7 @@ describe("utils", () => {
 
       const result = applyPendingExtras([mockedOperation1], [mockedPendingOperation1]);
 
+      expect(result).toHaveLength(1);
       expect(result[0].extra).toEqual({
         ...mockedOperation1.extra,
         ...mockedPendingOperation1.extra,
@@ -464,6 +338,7 @@ describe("utils", () => {
       const mockedPendingOperation = getMockedOperation({ hash: "op1", extra: pendingExtra });
 
       const result = applyPendingExtras([mockedOperation], [mockedPendingOperation]);
+      expect(result).toHaveLength(1);
       expect(result[0].extra).toEqual(mockedOperation.extra);
     });
   });
@@ -484,112 +359,8 @@ describe("utils", () => {
       const patched = patchOperationWithExtra(mockedOperation, extra);
 
       expect(patched.extra).toEqual(extra);
+      expect(patched.subOperations).toHaveLength(1);
       expect(patched.subOperations?.[0].extra).toEqual(extra);
     });
   });
-
-  describe("checkAccountTokenAssociationStatus", () => {
-    const accountId = "0.0.1234";
-    const tokenId = "0.0.5678";
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-      // reset LRU cache to make sure all tests receive correct mocks from mockedGetAccount
-      checkAccountTokenAssociationStatus.clear(`${accountId}-${tokenId}`);
-    });
-
-    test("returns true if max_automatic_token_associations === -1", async () => {
-      mockedGetAccount.mockResolvedValueOnce({
-        account: accountId,
-        max_automatic_token_associations: -1,
-        balance: {
-          balance: 0,
-          timestamp: "",
-          tokens: [],
-        },
-      });
-
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
-      expect(result).toBe(true);
-    });
-
-    test("returns true if token is already associated", async () => {
-      mockedGetAccount.mockResolvedValueOnce({
-        account: accountId,
-        max_automatic_token_associations: 0,
-        balance: {
-          balance: 1,
-          timestamp: "",
-          tokens: [{ token_id: tokenId, balance: 1 }],
-        },
-      });
-
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
-      expect(result).toBe(true);
-    });
-
-    test("returns false if token is not associated", async () => {
-      mockedGetAccount.mockResolvedValueOnce({
-        account: accountId,
-        max_automatic_token_associations: 0,
-        balance: {
-          balance: 1,
-          timestamp: "",
-          tokens: [{ token_id: "0.0.9999", balance: 1 }],
-        },
-      });
-
-      const result = await checkAccountTokenAssociationStatus(accountId, tokenId);
-      expect(result).toBe(false);
-    });
-
-    test("supports addresses with checksum", async () => {
-      const addressWithChecksum = "0.0.9124531-xrxlv";
-
-      mockedGetAccount.mockResolvedValueOnce({
-        account: accountId,
-        max_automatic_token_associations: 0,
-        balance: {
-          balance: 1,
-          timestamp: "",
-          tokens: [{ token_id: "0.0.9999", balance: 1 }],
-        },
-      });
-
-      await checkAccountTokenAssociationStatus(addressWithChecksum, tokenId);
-      expect(mockedGetAccount).toHaveBeenCalledWith("0.0.9124531");
-    });
-  });
-
-  describe("safeParseAccountId", () => {
-    test("returns account id and no checksum for valid address without checksum", () => {
-      const [error, result] = safeParseAccountId("0.0.9124531");
-
-      expect(error).toBeNull();
-      expect(result?.accountId).toBe("0.0.9124531");
-      expect(result?.checksum).toBeNull();
-    });
-
-    test("returns account id and checksum for valid address with correct checksum", () => {
-      const [error, result] = safeParseAccountId("0.0.9124531-xrxlv");
-
-      expect(error).toBeNull();
-      expect(result?.accountId).toBe("0.0.9124531");
-      expect(result?.checksum).toBe("xrxlv");
-    });
-
-    test("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", () => {
-      const [error, accountId] = safeParseAccountId("not-a-valid-address");
-
-      expect(error).toBeInstanceOf(InvalidAddress);
-      expect(accountId).toBeNull();
-    });
-  });
 });

package/src/bridge/utils.ts

@@ -1,16 +1,7 @@
 import BigNumber from "bignumber.js";
 import murmurhash from "imurmurhash";
-import invariant from "invariant";
-import { AccountId } from "@hashgraph/sdk";
-import { InvalidAddress } from "@ledgerhq/errors";
 import type { Account, Operation, TokenAccount } from "@ledgerhq/types-live";
-import cvsApi from "@ledgerhq/live-countervalues/api/index";
-import {
-  findCryptoCurrencyById,
-  findTokenByAddressInCurrency,
-  getFiatCurrencyByTicker,
-  listTokensForCryptoCurrency,
-} from "@ledgerhq/cryptoassets";
+import { findTokenByAddressInCurrency, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import {
   decodeTokenAccountId,
   emptyHistoryCache,
@@ -19,63 +10,13 @@ import {
   isTokenAccount,
 } from "@ledgerhq/coin-framework/account";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import type { CryptoCurrency, Currency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { makeLRUCache, seconds } from "@ledgerhq/live-network/cache";
+import { HEDERA_OPERATION_TYPES } from "../constants";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
-import type { HederaOperationExtra, Transaction } from "../types";
-import { getAccount } from "../api/mirror";
-import { getHederaClient } from "../api/network";
-import type { HederaMirrorToken } from "../api/types";
-import { HederaRecipientInvalidChecksum } from "../errors";
-import { isTokenAssociateTransaction, isValidExtra } from "../logic";
-import { BASE_USD_FEE_BY_OPERATION_TYPE, HEDERA_OPERATION_TYPES } from "../constants";
-
-const ESTIMATED_FEE_SAFETY_RATE = 2;
-
-// note: this is currently called frequently by getTransactionStatus; LRU cache prevents duplicated requests
-export const getCurrencyToUSDRate = makeLRUCache(
-  async (currency: Currency) => {
-    try {
-      const [rate] = await cvsApi.fetchLatest([
-        {
-          from: currency,
-          to: getFiatCurrencyByTicker("USD"),
-          startDate: new Date(),
-        },
-      ]);
-
-      invariant(rate, "no value returned from cvs api");
-
-      return new BigNumber(rate);
-    } catch {
-      return null;
-    }
-  },
-  currency => currency.ticker,
-  seconds(3),
-);
-
-export const getEstimatedFees = async (
-  account: Account,
-  operationType: HEDERA_OPERATION_TYPES,
-): Promise<BigNumber> => {
-  try {
-    const usdRate = await getCurrencyToUSDRate(account.currency);
-
-    if (usdRate) {
-      return new BigNumber(BASE_USD_FEE_BY_OPERATION_TYPE[operationType])
-        .dividedBy(new BigNumber(usdRate))
-        .integerValue(BigNumber.ROUND_CEIL)
-        .multipliedBy(ESTIMATED_FEE_SAFETY_RATE);
-    }
-    // eslint-disable-next-line no-empty
-  } catch {}
-
-  // as fees are based on a currency conversion, we stay
-  // on the safe side here and double the estimate for "max spendable"
-  return new BigNumber("150200").multipliedBy(ESTIMATED_FEE_SAFETY_RATE); // 0.001502 ℏ (as of 2023-03-14)
-};
+import { estimateFees } from "../logic/estimateFees";
+import { isTokenAssociateTransaction, isValidExtra } from "../logic/utils";
+import type { HederaOperationExtra, Transaction, HederaMirrorToken } from "../types";
 
 interface CalculateAmountResult {
   amount: BigNumber;
@@ -91,7 +32,7 @@ const calculateCoinAmount = async ({
   transaction: Transaction;
   operationType: HEDERA_OPERATION_TYPES;
 }): Promise<CalculateAmountResult> => {
-  const estimatedFees = await getEstimatedFees(account, operationType);
+  const estimatedFees = await estimateFees(account.currency, operationType);
   const amount = transaction.useAllAmount
     ? await estimateMaxSpendable({ account, transaction })
     : transaction.amount;
@@ -142,15 +83,6 @@ export const calculateAmount = ({
   return calculateCoinAmount({ account, transaction, operationType });
 };
 
-// NOTE: convert from the non-url-safe version of base64 to the url-safe version (that the explorer uses)
-export function base64ToUrlSafeBase64(data: string): string {
-  // Might be nice to use this alternative if .nvmrc changes to >= Node v14.18.0
-  // base64url encoding option isn't supported until then
-  // Buffer.from(data, "base64").toString("base64url");
-
-  return data.replace(/\//g, "_").replace(/\+/g, "-");
-}
-
 const simpleSyncHashMemoize: Record<string, string> = {};
 
 export const getSyncHash = (
@@ -265,11 +197,12 @@ export const getSubAccounts = async (
   return subAccounts;
 };
 
-type CoinOperationForOrphanChildOperation = Operation & Required<Pick<Operation, "subOperations">>;
+type CoinOperationForOrphanChildOperation = Operation<HederaOperationExtra> &
+  Required<Pick<Operation, "subOperations">>;
 
 // create NONE coin operation that will be a parent of an orphan child operation
 const makeCoinOperationForOrphanChildOperation = (
-  childOperation: Operation,
+  childOperation: Operation<HederaOperationExtra>,
 ): CoinOperationForOrphanChildOperation => {
   const type = "NONE";
   const { accountId } = decodeTokenAccountId(childOperation.accountId);
@@ -299,33 +232,15 @@ const makeCoinOperationForOrphanChildOperation = (
 // - linking sub operations with coin operations, e.g. token transfer with fee payment
 // - if possible, assigning `extra.associatedTokenId = mirrorToken.tokenId` based on operation's consensus timestamp
 export const prepareOperations = (
-  coinOperations: Operation[],
-  tokenOperations: Operation[],
-  mirrorTokens: HederaMirrorToken[],
-): Operation[] => {
+  coinOperations: Operation<HederaOperationExtra>[],
+  tokenOperations: Operation<HederaOperationExtra>[],
+): Operation<HederaOperationExtra>[] => {
   const preparedCoinOperations = coinOperations.map(op => ({ ...op }));
   const preparedTokenOperations = tokenOperations.map(op => ({ ...op }));
 
-  // loop through coin operations to:
-  // - enrich ASSOCIATE_TOKEN operations with extra.associatedTokenId
-  // - prepare a map of hash => operations
+  // loop through coin operations to prepare a map of hash => operations
   const coinOperationsByHash: Record<string, CoinOperationForOrphanChildOperation[]> = {};
   preparedCoinOperations.forEach(op => {
-    const extra = isValidExtra(op.extra) ? op.extra : null;
-
-    if (op.type === "ASSOCIATE_TOKEN" && extra?.consensusTimestamp) {
-      const relatedMirrorToken = mirrorTokens.find(t => {
-        return t.created_timestamp === extra.consensusTimestamp;
-      });
-
-      if (relatedMirrorToken) {
-        op.extra = {
-          ...extra,
-          associatedTokenId: relatedMirrorToken.token_id,
-        } satisfies HederaOperationExtra;
-      }
-    }
-
     if (!coinOperationsByHash[op.hash]) {
       coinOperationsByHash[op.hash] = [];
     }
@@ -456,64 +371,3 @@ export function patchOperationWithExtra(
     nftOperations: (operation.nftOperations ?? []).map(op => ({ ...op, extra })),
   };
 }
-
-export const checkAccountTokenAssociationStatus = makeLRUCache(
-  async (address: string, tokenId: string) => {
-    const [parsingError, parsingResult] = safeParseAccountId(address);
-
-    if (parsingError) {
-      throw parsingError;
-    }
-
-    const addressWithoutChecksum = parsingResult.accountId;
-    const mirrorAccount = await getAccount(addressWithoutChecksum);
-
-    // auto association is enabled
-    if (mirrorAccount.max_automatic_token_associations === -1) {
-      return true;
-    }
-
-    const isTokenAssociated = mirrorAccount.balance.tokens.some(token => {
-      return token.token_id === tokenId;
-    });
-
-    return isTokenAssociated;
-  },
-  (accountId, tokenId) => `${accountId}-${tokenId}`,
-  seconds(30),
-);
-
-export const safeParseAccountId = (
-  address: string,
-): [Error, null] | [null, { accountId: string; checksum: string | null }] => {
-  const currency = findCryptoCurrencyById("hedera");
-  const currencyName = currency?.name ?? "Hedera";
-
-  try {
-    const accountId = AccountId.fromString(address);
-
-    // 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 = getHederaClient();
-      const recipientWithChecksum = accountId.toStringWithChecksum(client);
-      const expectedChecksum = recipientWithChecksum.split("-")[1];
-
-      if (checksum !== expectedChecksum) {
-        return [new HederaRecipientInvalidChecksum(), null];
-      }
-    }
-
-    const result = {
-      accountId: accountId.toString(),
-      checksum,
-    };
-
-    return [null, result];
-  } catch (err) {
-    return [new InvalidAddress("", { currencyName }), null];
-  }
-};

package/src/config.ts

@@ -0,0 +1,7 @@
+import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type HederaCoinConfig = CurrencyConfig;
+
+const coinConfig = buildCoinConfig<HederaCoinConfig>();
+
+export default coinConfig;

package/src/constants.ts

@@ -1,12 +1,11 @@
 /**
- * Internal types used to distinguish custom Hedera transaction behaviors.
- * These can be stored in transaction.properties.name and used to route specific preparation logic.
+ * Internal types to distinguish custom Hedera transaction behaviors.
+ * These can be used in transaction.mode and used to route specific preparation logic.
  */
-export const HEDERA_TRANSACTION_KINDS = {
-  TokenAssociate: {
-    name: "tokenAssociate",
-  },
-} as const satisfies Record<string, Record<string, unknown> & { name: string }>;
+export enum HEDERA_TRANSACTION_MODES {
+  Send = "send",
+  TokenAssociate = "token-associate",
+}
 
 /**
  * Enum representing the supported Hedera operation types for fee estimation
@@ -17,7 +16,14 @@ export enum HEDERA_OPERATION_TYPES {
   TokenAssociate = "TokenAssociate",
 }
 
-const TINYBAR_SCALE = 8;
+export const TINYBAR_SCALE = 8;
+
+export const ESTIMATED_FEE_SAFETY_RATE = 2;
+
+// old value moved from https://github.com/LedgerHQ/ledger-live/blob/8447b68b7c6f1e7ccd4aa9db4da0e6c8de36a88e/libs/coin-modules/coin-hedera/src/bridge/utils.ts#L77
+export const DEFAULT_TINYBAR_FEE = 150200;
+
+export const SYNTHETIC_BLOCK_WINDOW_SECONDS = 10;
 
 /**
  * https://docs.hedera.com/hedera/networks/mainnet/fees
@@ -25,7 +31,7 @@ const TINYBAR_SCALE = 8;
  * These are Hedera's estimated fee costs in USD, scaled to tinybars (1 HBAR = 10^8 tinybars),
  * so they can be converted into actual HBAR amounts based on current USD/crypto rates.
  *
- * Used in fee estimation logic (getEstimatedFees function) to determine whether an account
+ * Used in fee estimation logic (estimateFees function) to determine whether an account
  * has sufficient balance to cover the cost of a transaction (e.g. token association).
  */
 export const BASE_USD_FEE_BY_OPERATION_TYPE = {

package/src/deviceTransactionConfig.ts

@@ -1,7 +1,7 @@
 import type { AccountLike, Account } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus } from "./types";
 import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
-import { isTokenAssociateTransaction } from "./logic";
+import { isTokenAssociateTransaction } from "./logic/utils";
+import type { Transaction, TransactionStatus } from "./types";
 
 async function getDeviceTransactionConfig({
   transaction,