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

package/src/api/index.integ.test.ts

@@ -0,0 +1,401 @@
+import invariant from "invariant";
+import {
+  AccountId,
+  Hbar,
+  HbarUnit,
+  TokenAssociateTransaction,
+  TransferTransaction,
+} from "@hashgraph/sdk";
+import type { FeeEstimation, Pagination } from "@ledgerhq/coin-framework/api/types";
+import { createApi } from "../api";
+import { HEDERA_TRANSACTION_MODES, TINYBAR_SCALE } from "../constants";
+import { getSyntheticBlock } from "../logic/utils";
+import { MAINNET_TEST_ACCOUNTS } from "../test/fixtures/account.fixture";
+
+describe("createApi", () => {
+  const api = createApi({});
+
+  describe("craftTransaction", () => {
+    it("returns serialized native coin TransferTransaction", async () => {
+      const { transaction: hex } = await api.craftTransaction({
+        intentType: "transaction",
+        asset: {
+          type: "native",
+        },
+        type: HEDERA_TRANSACTION_MODES.Send,
+        amount: BigInt(1 * 10 ** TINYBAR_SCALE),
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "native transfer",
+        },
+      });
+
+      const rawTx = TransferTransaction.fromBytes(Buffer.from(hex, "hex"));
+
+      expect(rawTx).toBeInstanceOf(TransferTransaction);
+      invariant(rawTx instanceof TransferTransaction, "TransferTransaction type guard");
+
+      const sendTransfer = rawTx.hbarTransfers.get(MAINNET_TEST_ACCOUNTS.withoutTokens.accountId);
+      const receiveTransfer = rawTx.hbarTransfers.get(MAINNET_TEST_ACCOUNTS.withTokens.accountId);
+
+      expect(rawTx.hbarTransfers.size).toBe(2);
+      expect(sendTransfer).toEqual(Hbar.from(-1, HbarUnit.Hbar));
+      expect(receiveTransfer).toEqual(Hbar.from(1, HbarUnit.Hbar));
+      expect(rawTx.transactionMemo).toBe("native transfer");
+    });
+
+    it("returns serialized HTS token TransferTransaction", async () => {
+      const { transaction: hex } = await api.craftTransaction({
+        intentType: "transaction",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.5022567",
+        },
+        type: HEDERA_TRANSACTION_MODES.Send,
+        amount: BigInt(1),
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "token transfer",
+        },
+      });
+
+      const rawTx = TransferTransaction.fromBytes(Buffer.from(hex, "hex"));
+
+      expect(rawTx).toBeInstanceOf(TransferTransaction);
+      invariant(rawTx instanceof TransferTransaction, "TransferTransaction type guard");
+
+      const tokenTransfers = rawTx.tokenTransfers.get("0.0.5022567");
+      const senderTransfer = tokenTransfers?.get(MAINNET_TEST_ACCOUNTS.withoutTokens.accountId);
+      const recipientTransfer = tokenTransfers?.get(MAINNET_TEST_ACCOUNTS.withTokens.accountId);
+
+      // .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("-1");
+      expect(recipientTransfer?.toString()).toEqual("1");
+      expect(tokenTransfers).not.toBeNull();
+      expect(rawTx.transactionMemo).toBe("token transfer");
+    });
+
+    it("returns serialized HTS token association transaction", async () => {
+      const { transaction: hex } = await api.craftTransaction({
+        intentType: "transaction",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.5022567",
+        },
+        amount: BigInt(0),
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        recipient: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "token association",
+        },
+      });
+
+      const rawTx = TokenAssociateTransaction.fromBytes(Buffer.from(hex, "hex"));
+
+      expect(rawTx).toBeInstanceOf(TokenAssociateTransaction);
+      invariant(rawTx instanceof TokenAssociateTransaction, "TokenAssociateTransaction type guard");
+      expect(rawTx.accountId).toEqual(
+        AccountId.fromString(MAINNET_TEST_ACCOUNTS.withoutTokens.accountId),
+      );
+      // .toString() is used because sdk.TokenId.fromString() sets `_checksum` to undefined,
+      // but tokenIds elements from TokenAssociateTransaction.fromBytes have it set to null
+      expect(rawTx.tokenIds?.[0]?.toString()).toEqual("0.0.5022567");
+      expect(rawTx.transactionMemo).toBe("token association");
+    });
+
+    it("applies customFees properly", async () => {
+      const customFees: FeeEstimation = {
+        value: BigInt(1000),
+      };
+
+      const { transaction: hex } = await api.craftTransaction(
+        {
+          intentType: "transaction",
+          asset: {
+            type: "native",
+          },
+          amount: BigInt(1 * 10 ** TINYBAR_SCALE),
+          sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+          senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+          recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+          type: HEDERA_TRANSACTION_MODES.Send,
+          memo: {
+            kind: "text",
+            type: "string",
+            value: "",
+          },
+        },
+        customFees,
+      );
+
+      const rawTx = TransferTransaction.fromBytes(Buffer.from(hex, "hex"));
+
+      expect(rawTx).toBeInstanceOf(TransferTransaction);
+      invariant(rawTx instanceof TransferTransaction, "TransferTransaction type guard");
+
+      expect(rawTx.maxTransactionFee).toEqual(Hbar.from(customFees.value, HbarUnit.Tinybar));
+    });
+  });
+
+  describe("estimateFees", () => {
+    it("returns fee for coin transfer transaction", async () => {
+      const fees = await api.estimateFees({
+        intentType: "transaction",
+        asset: {
+          type: "native",
+        },
+        type: HEDERA_TRANSACTION_MODES.Send,
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        amount: BigInt(100),
+        recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "",
+        },
+      });
+
+      expect(fees.value).toBeGreaterThanOrEqual(0n);
+    });
+
+    it("returns fee for token transfer transaction", async () => {
+      const fees = await api.estimateFees({
+        intentType: "transaction",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.5022567",
+        },
+        type: HEDERA_TRANSACTION_MODES.Send,
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        amount: BigInt(100),
+        recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "",
+        },
+      });
+
+      expect(fees.value).toBeGreaterThanOrEqual(0n);
+    });
+
+    it("returns fee for token association transaction", async () => {
+      const fees = await api.estimateFees({
+        intentType: "transaction",
+        asset: {
+          type: "hts",
+          assetReference: "0.0.5022567",
+        },
+        type: HEDERA_TRANSACTION_MODES.TokenAssociate,
+        sender: MAINNET_TEST_ACCOUNTS.withoutTokens.accountId,
+        senderPublicKey: MAINNET_TEST_ACCOUNTS.withoutTokens.publicKey,
+        amount: BigInt(100),
+        recipient: MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+        memo: {
+          kind: "text",
+          type: "string",
+          value: "",
+        },
+      });
+
+      expect(fees.value).toBeGreaterThanOrEqual(0n);
+    });
+  });
+
+  describe("getBalance", () => {
+    it("returns zero balance for pristine account", async () => {
+      const balances = await api.getBalance(MAINNET_TEST_ACCOUNTS.pristine.accountId);
+
+      expect(balances.length).toBe(1);
+      expect(balances[0].value).toBe(0n);
+    });
+
+    it("returns native asset for account without tokens", async () => {
+      const balances = await api.getBalance(MAINNET_TEST_ACCOUNTS.withoutTokens.accountId);
+      const nativeBalance = balances.filter(b => b.asset.type === "native");
+
+      expect(nativeBalance.length).toBe(1);
+      expect(nativeBalance[0].value).toBeGreaterThan(0n);
+    });
+
+    it("returns native and token assets for account with tokens", async () => {
+      const balances = await api.getBalance(MAINNET_TEST_ACCOUNTS.withTokens.accountId);
+      const tokenBalances = balances.filter(b => b.asset.type !== "native");
+
+      const associatedTokenWithBalance = balances.find(b => {
+        return (
+          "assetReference" in b.asset &&
+          b.asset.assetReference === MAINNET_TEST_ACCOUNTS.withTokens.associatedTokenWithBalance
+        );
+      });
+
+      const associatedTokenWithoutBalance = balances.find(b => {
+        return (
+          "assetReference" in b.asset &&
+          b.asset.assetReference === MAINNET_TEST_ACCOUNTS.withTokens.associatedTokenWithoutBalance
+        );
+      });
+
+      const notAssociatedToken = balances.find(b => {
+        return (
+          "assetReference" in b.asset &&
+          b.asset.assetReference === MAINNET_TEST_ACCOUNTS.withTokens.notAssociatedToken
+        );
+      });
+
+      expect(tokenBalances.length).toBeGreaterThan(0);
+      expect(associatedTokenWithBalance?.value).toBeGreaterThan(0n);
+      expect(associatedTokenWithoutBalance?.value).toBe(0n);
+      expect(notAssociatedToken?.value).toBe(undefined);
+    });
+  });
+
+  describe("lastBlock", () => {
+    it("returns the last block information", async () => {
+      const lastBlock = await api.lastBlock();
+
+      expect(lastBlock.height).toBeGreaterThan(0);
+      expect(lastBlock.hash?.length).toBe(64);
+      expect(lastBlock.time?.getTime()).toBeGreaterThan(0);
+    });
+  });
+
+  describe("listOperations", () => {
+    it("returns empty array for pristine account", async () => {
+      const block = await api.lastBlock();
+      const [operations] = await api.listOperations(MAINNET_TEST_ACCOUNTS.pristine.accountId, {
+        minHeight: block.height,
+        order: "desc",
+      });
+
+      expect(operations).toBeInstanceOf(Array);
+      expect(operations.length).toBe(0);
+    });
+
+    it("returns operations with valid synthetic block info", async () => {
+      const lastPagingToken = "1753099264.927988000";
+      const block = await api.lastBlock();
+      const [ops] = await api.listOperations(MAINNET_TEST_ACCOUNTS.withTokens.accountId, {
+        minHeight: block.height,
+        order: "asc",
+        limit: 4,
+        lastPagingToken,
+      });
+
+      const expectedSyntheticBlock = getSyntheticBlock(lastPagingToken);
+      const blockHeights = ops.map(o => o.tx.block.height);
+
+      expect(blockHeights).toHaveLength(4);
+      expect(blockHeights.every(h => h >= expectedSyntheticBlock.blockHeight)).toBe(true);
+    });
+
+    it("returns operations for real account with tokens", async () => {
+      const lastPagingToken = "1753099264.927988000";
+      const block = await api.lastBlock();
+      const [ops] = await api.listOperations(MAINNET_TEST_ACCOUNTS.withTokens.accountId, {
+        minHeight: block.height,
+        order: "desc",
+        limit: 100,
+        lastPagingToken,
+      });
+
+      const memoTxHash = "WvMcFERtxRsGJqxqGVDYa6JR5PqLgFeJxiSVoimayaWra/AMEJMzC09LhdRLTZ/M";
+      const operationWithMemo = ops.find(op => op.tx.hash === memoTxHash);
+      const firstTokenAssociateOperations = ops.find(op => op.type === "ASSOCIATE_TOKEN");
+      const firstSendTokenOperation = ops.find(o => o.type === "OUT" && o.asset.type !== "native");
+
+      const hasReceiveHbarOperations = ops.some(o => o.type === "IN" && o.asset.type === "native");
+      const hasSendHbarOperations = ops.some(op => op.type === "OUT" && op.asset.type === "native");
+      const hasReceiveTokenOperations = ops.some(o => o.type === "IN" && o.asset.type !== "native");
+      const hasSendTokenOperations = !!firstSendTokenOperation;
+      const hasTokenAssociateOperations = !!firstTokenAssociateOperations;
+      const hasFeesOperationForSendToken = ops.some(
+        o =>
+          o.type === "FEES" &&
+          o.asset.type === "native" &&
+          o.tx.hash === firstSendTokenOperation?.tx.hash,
+      );
+
+      expect(ops).toBeInstanceOf(Array);
+      expect(ops.length).toBeGreaterThanOrEqual(2);
+      expect(hasReceiveHbarOperations).toBe(true);
+      expect(hasSendHbarOperations).toBe(true);
+      expect(hasReceiveTokenOperations).toBe(true);
+      expect(hasSendTokenOperations).toBe(true);
+      expect(hasFeesOperationForSendToken).toBe(false);
+      expect(hasTokenAssociateOperations).toBe(true);
+      expect(operationWithMemo?.details).toMatchObject({
+        pagingToken: expect.any(String),
+        consensusTimestamp: expect.any(String),
+        ledgerOpType: expect.any(String),
+        memo: expect.any(String),
+      });
+      expect(firstTokenAssociateOperations?.details).toMatchObject({
+        pagingToken: expect.any(String),
+        consensusTimestamp: expect.any(String),
+        ledgerOpType: expect.any(String),
+        associatedTokenId: expect.any(String),
+      });
+    });
+
+    it.each(["desc", "asc"] as const)(
+      "returns paginated operations for account with high activity (%s)",
+      async order => {
+        const commonPagination = {
+          minHeight: 0,
+          limit: 10,
+          order,
+        } satisfies Pagination;
+
+        const [page1, pagingToken1] = await api.listOperations(
+          MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+          commonPagination,
+        );
+
+        const [page2, pagingToken2] = await api.listOperations(
+          MAINNET_TEST_ACCOUNTS.withTokens.accountId,
+          {
+            ...commonPagination,
+            lastPagingToken: pagingToken1,
+          },
+        );
+
+        const firstPage1Timestamp = page1[0]?.tx?.date;
+        const firstPage2Timestamp = page2[0]?.tx?.date;
+        const lastPage1Timestamp = page1[page1.length - 1]?.tx?.date;
+        const lastPage2Timestamp = page2[page2.length - 1]?.tx?.date;
+        const page1Hashes = new Set(page1.map(op => op.tx.hash));
+        const page2Hashes = new Set(page2.map(op => op.tx.hash));
+        const hasOverlap = [...page2Hashes].some(hash => page1Hashes.has(hash));
+
+        // NOTE: this won't be equal to limit, because single Hedera transaction can generate multiple operations
+        expect(page1.length).toBeGreaterThanOrEqual(commonPagination.limit);
+        expect(page2.length).toBeGreaterThanOrEqual(commonPagination.limit);
+        expect(pagingToken1).not.toBeNull();
+        expect(pagingToken2).not.toBeNull();
+        expect(hasOverlap).toBe(false);
+        expect(firstPage1Timestamp).toBeInstanceOf(Date);
+        expect(firstPage2Timestamp).toBeInstanceOf(Date);
+        expect(lastPage1Timestamp).toBeInstanceOf(Date);
+        expect(lastPage2Timestamp).toBeInstanceOf(Date);
+        expect(lastPage1Timestamp > firstPage2Timestamp).toBe(order === "desc");
+        expect(firstPage1Timestamp < lastPage2Timestamp).toBe(order === "asc");
+      },
+    );
+  });
+});

package/src/api/index.test.ts

@@ -0,0 +1,30 @@
+import { createApi } from "./index";
+import coinConfig from "../config";
+
+describe("createApi", () => {
+  it("should set the coin config value", () => {
+    const mockSetCoinConfig = jest.spyOn(coinConfig, "setCoinConfig");
+
+    createApi({});
+    const config = coinConfig.getCoinConfig();
+
+    expect(mockSetCoinConfig).toHaveBeenCalled();
+    expect(config).toMatchObject({
+      status: { type: "active" },
+    });
+  });
+
+  it("should return an API object with alpaca api methods", () => {
+    const api = createApi({});
+
+    expect(api.broadcast).toBeInstanceOf(Function);
+    expect(api.combine).toBeInstanceOf(Function);
+    expect(api.craftTransaction).toBeInstanceOf(Function);
+    expect(api.estimateFees).toBeInstanceOf(Function);
+    expect(api.getBalance).toBeInstanceOf(Function);
+    expect(api.lastBlock).toBeInstanceOf(Function);
+    expect(api.listOperations).toBeInstanceOf(Function);
+    expect(api.getAssetFromToken).toBeInstanceOf(Function);
+    expect(api.getTokenFromAsset).toBeInstanceOf(Function);
+  });
+});

package/src/api/index.ts

@@ -0,0 +1,149 @@
+import type {
+  Api,
+  Block,
+  BlockInfo,
+  CraftedTransaction,
+  Cursor,
+  Operation,
+  Page,
+  Reward,
+  Stake,
+  TransactionValidation,
+  Validator,
+} from "@ledgerhq/coin-framework/api/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import coinConfig from "../config";
+import {
+  broadcast as logicBroadcast,
+  combine,
+  craftTransaction,
+  estimateFees,
+  getBalance,
+  listOperations as logicListOperations,
+  getAssetFromToken,
+  getTokenFromAsset,
+  lastBlock,
+} from "../logic/index";
+import { mapIntentToSDKOperation, getOperationValue } from "../logic/utils";
+import { apiClient } from "../network/api";
+import type { HederaMemo } from "../types";
+
+export function createApi(config: Record<string, never>): Api<HederaMemo> {
+  coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
+  const currency = getCryptoCurrencyById("hedera");
+
+  return {
+    broadcast: async tx => {
+      const response = await logicBroadcast(tx);
+      return Buffer.from(response.transactionHash).toString("base64");
+    },
+    combine,
+    craftTransaction: async (txIntent, customFees) => {
+      const { serializedTx } = await craftTransaction(txIntent, customFees);
+
+      return {
+        transaction: serializedTx,
+      };
+    },
+    craftRawTransaction: (
+      _transaction: string,
+      _sender: string,
+      _publicKey: string,
+      _sequence: number,
+    ): Promise<CraftedTransaction> => {
+      throw new Error("craftRawTransaction is not supported");
+    },
+    estimateFees: async transactionIntent => {
+      const operationType = mapIntentToSDKOperation(transactionIntent);
+      const estimatedFee = await estimateFees(currency, operationType);
+
+      return {
+        value: BigInt(estimatedFee.toString()),
+      };
+    },
+    getBalance: address => getBalance(currency, address),
+    lastBlock,
+    listOperations: async (address, pagination) => {
+      const mirrorTokens = await apiClient.getAccountTokens(address);
+      const latestAccountOperations = await logicListOperations({
+        currency,
+        address,
+        pagination,
+        mirrorTokens,
+        fetchAllPages: false,
+        skipFeesForTokenOperations: true,
+        useEncodedHash: false,
+        useSyntheticBlocks: true,
+      });
+
+      const liveOperations = [
+        ...latestAccountOperations.coinOperations,
+        ...latestAccountOperations.tokenOperations,
+      ];
+
+      const sortedLiveOperations = [...liveOperations].sort((a, b) => {
+        const aTime = a.date.getTime();
+        const bTime = b.date.getTime();
+        return pagination.order === "desc" ? bTime - aTime : aTime - bTime;
+      });
+
+      const alpacaOperations = sortedLiveOperations.map(liveOp => {
+        const asset = liveOp.contract
+          ? {
+              type: liveOp.standard ?? "token",
+              assetReference: liveOp.contract,
+              assetOwner: address,
+            }
+          : { type: "native" };
+
+        return {
+          id: liveOp.id,
+          type: liveOp.type,
+          senders: liveOp.senders,
+          recipients: liveOp.recipients,
+          value: getOperationValue({ asset, operation: liveOp }),
+          asset,
+          details: {
+            ...liveOp.extra,
+            ledgerOpType: liveOp.type,
+            status: liveOp.hasFailed ? "failed" : "success",
+            ...(asset.type !== "native" && { assetAmount: liveOp.value.toFixed(0) }),
+          },
+          tx: {
+            hash: liveOp.hash,
+            fees: BigInt(liveOp.fee.toFixed(0)),
+            date: liveOp.date,
+            block: {
+              height: liveOp.blockHeight ?? 10,
+            },
+          },
+        } satisfies Operation;
+      });
+
+      return [alpacaOperations, latestAccountOperations.nextCursor ?? ""];
+    },
+    getTokenFromAsset: asset => getTokenFromAsset(currency, asset),
+    getAssetFromToken,
+    validateIntent: async (_transactionIntent, _customFees): Promise<TransactionValidation> => {
+      throw new Error("validateIntent is not supported");
+    },
+    getSequence: async (_address): Promise<number> => {
+      throw new Error("getSequence is not supported");
+    },
+    getBlock: async (_height): Promise<Block> => {
+      throw new Error("getBlock is not supported");
+    },
+    getBlockInfo: async (_height): Promise<BlockInfo> => {
+      throw new Error("getBlockInfo is not supported");
+    },
+    getStakes: async (_address, _cursor): Promise<Page<Stake>> => {
+      throw new Error("getStakes is not supported");
+    },
+    getRewards: async (_address, _cursor): Promise<Page<Reward>> => {
+      throw new Error("getRewards is not supported");
+    },
+    getValidators(_cursor?: Cursor): Promise<Page<Validator>> {
+      throw new Error("getValidators is not supported");
+    },
+  };
+}

package/src/bridge/broadcast.ts

@@ -1,18 +1,13 @@
-import { Transaction as HederaSDKTransaction } from "@hashgraph/sdk";
 import { AccountBridge, Operation } from "@ledgerhq/types-live";
 import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
-import { base64ToUrlSafeBase64, patchOperationWithExtra } from "./utils";
-import { HederaOperationExtra, Transaction } from "../types";
-import { broadcastTransaction } from "../api/network";
-import { isValidExtra } from "../logic";
+import { broadcast as logicBroadcast } from "../logic/broadcast";
+import { base64ToUrlSafeBase64, isValidExtra } from "../logic/utils";
+import type { HederaOperationExtra, Transaction } from "../types";
+import { patchOperationWithExtra } from "./utils";
 
 export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({ signedOperation }) => {
   const { signature, operation } = signedOperation;
-
-  // NOTE: expecting a serialized transaction to be signedOperation.signature (in hex)
-  const hederaTransaction = HederaSDKTransaction.fromBytes(Buffer.from(signature, "base64"));
-
-  const response = await broadcastTransaction(hederaTransaction);
+  const response = await logicBroadcast(signature);
 
   const base64Hash = Buffer.from(response.transactionHash).toString("base64");
   const base64HashUrlSafe = base64ToUrlSafeBase64(base64Hash);

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

@@ -1,10 +1,10 @@
 import BigNumber from "bignumber.js";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_MODES } from "../constants";
+import { estimateFees } from "../logic/estimateFees";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
-import { buildOptimisticOperation } from "./buildOptimisticOperation";
-import { getEstimatedFees } from "./utils";
-import { HEDERA_OPERATION_TYPES, HEDERA_TRANSACTION_KINDS } from "../constants";
 
 describe("buildOptimisticOperation", () => {
   let estimatedFees: Record<"crypto" | "associate", BigNumber>;
@@ -12,8 +12,8 @@ describe("buildOptimisticOperation", () => {
   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 };
@@ -23,10 +23,10 @@ describe("buildOptimisticOperation", () => {
     const mockedAccount = getMockedAccount();
     const mockedToken = getMockedTokenCurrency();
     const mockedTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
       amount: new BigNumber(0),
       recipient: "0.0.1234",
       properties: {
-        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
         token: mockedToken,
       },
     });
@@ -39,7 +39,7 @@ describe("buildOptimisticOperation", () => {
     expect(op.type).toBe("ASSOCIATE_TOKEN");
     expect(op.extra).toEqual({ associatedTokenId: mockedToken.contractAddress });
     expect(op.fee).toEqual(estimatedFees.associate);
-    expect(op.senders).toContain(mockedAccount.freshAddress.toString());
+    expect(op.senders).toContain(mockedAccount.freshAddress);
     expect(op.recipients).toContain("0.0.1234");
   });
 
@@ -58,7 +58,7 @@ describe("buildOptimisticOperation", () => {
     expect(op.type).toBe("OUT");
     expect(op.fee).toEqual(estimatedFees.crypto);
     expect(op.value).toEqual(new BigNumber(123));
-    expect(op.senders).toContain(mockedAccount.freshAddress.toString());
+    expect(op.senders).toContain(mockedAccount.freshAddress);
     expect(op.recipients).toContain("0.0.5678");
   });