@ledgerhq/coin-aptos 2.0.0 → 2.1.0-next.1

package/src/__tests__/api/craftTransaction.unit.test.ts

@@ -0,0 +1,243 @@
+import { Hex, RawTransaction, Deserializer } from "@aptos-labs/ts-sdk";
+import type { TransactionIntent } from "@ledgerhq/coin-framework/lib/api/types";
+import { createApi } from "../../api";
+import type { AptosAsset, AptosExtra, AptosSender } from "../../types/assets";
+import { AptosAPI } from "../../network";
+import { APTOS_ASSET_ID } from "../../constants";
+
+jest.mock("../../network");
+let mockedAptosApi: jest.Mocked<any>;
+
+jest.mock("../../config", () => ({
+  setCoinConfig: jest.fn(),
+}));
+
+describe("craftTransaction", () => {
+  beforeEach(() => {
+    mockedAptosApi = jest.mocked(AptosAPI);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  const SENDER_ADDR = "APTOS_1_ADDRESS";
+  const RECIPIENT_ADDR = "APTOS_2_ADDRESS";
+
+  const hexRawTx =
+    "0xfdde1012c0fac1f9a121eb3c8481c90d473df1c4180c070bd4f2549a6d06180400000000000000000200000000000000000000000000000000000000000000000000000000000000010d6170746f735f6163636f756e74087472616e736665720002203f5f0fcc8a909f23806e5efbdc1757e653fcd744de516a7de12b99b8417925c1080a00000000000000400d03000000000064000000000000002c721b6800000000b7";
+
+  const rawTxn = RawTransaction.deserialize(
+    new Deserializer(Hex.fromHexString(hexRawTx).toUint8Array()),
+  );
+
+  it("creates a coin transaction", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: APTOS_ASSET_ID, amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 10n,
+      asset: { type: "native" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: [APTOS_ASSET_ID],
+        functionArguments: [RECIPIENT_ADDR, txArg.amount.toString()],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("creates a native coin transaction using all amount available", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: APTOS_ASSET_ID, amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 0n,
+      asset: { type: "native" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(1);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: [APTOS_ASSET_ID],
+        functionArguments: [RECIPIENT_ADDR, "12345"],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("creates a coin token transaction", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42::token::Token", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 10n,
+      asset: { type: "token", standard: "coin", contractAddress: "0x42::token::Token" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::aptos_account::transfer_coins",
+        typeArguments: ["0x42::token::Token"],
+        functionArguments: [RECIPIENT_ADDR, txArg.amount.toString()],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("creates a fungible_asset token transaction using all amount available", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 0n,
+      asset: { type: "token", standard: "fungible_asset", contractAddress: "0x42" },
+    };
+
+    const tx = await api.craftTransaction(txArg);
+
+    expect(tx).not.toEqual("");
+    expect(Hex.isValid(tx).valid).toBeTruthy();
+    expect(mockGetBalances).toHaveBeenCalledTimes(1);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(1);
+
+    expect(mockGenerateTransaction).toHaveBeenCalledWith(
+      SENDER.freshAddress,
+      expect.objectContaining({
+        function: "0x1::primary_fungible_store::transfer",
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: ["0x42", RECIPIENT_ADDR, "12345"],
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("throws an exception for invalid tokenType", async () => {
+    const mockGenerateTransaction = jest.fn().mockResolvedValue(rawTxn);
+    const mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ contractAddress: "0x42::token::Token", amount: 12345 }]);
+    mockedAptosApi.mockImplementation(() => ({
+      generateTransaction: mockGenerateTransaction,
+      getBalances: mockGetBalances,
+    }));
+
+    const SENDER: AptosSender = {
+      xpub: "public-key",
+      freshAddress: SENDER_ADDR,
+    };
+    const api = createApi({
+      aptosSettings: {},
+    });
+
+    const txArg: TransactionIntent<AptosAsset, AptosExtra, AptosSender> = {
+      type: "send",
+      sender: SENDER,
+      recipient: RECIPIENT_ADDR,
+      amount: 10n,
+      asset: { type: "token", standard: "asset", contractAddress: "0x42::token::Token" },
+    };
+
+    expect(async () => await api.craftTransaction(txArg)).rejects.toThrow(
+      "Token type asset not supported",
+    );
+
+    expect(mockGetBalances).toHaveBeenCalledTimes(0);
+    expect(mockGenerateTransaction).toHaveBeenCalledTimes(0);
+  });
+});

package/src/__tests__/api/getBalance.unit.test.ts

@@ -0,0 +1,44 @@
+import { AptosAPI } from "../../network";
+import { getBalance } from "../../logic/getBalance";
+import { APTOS_ASSET_ID } from "../../constants";
+import BigNumber from "bignumber.js";
+
+jest.mock("../../network", () => {
+  return {
+    AptosAPI: jest.fn().mockImplementation(() => ({
+      getBalances: jest.fn(),
+    })),
+  };
+});
+
+describe("getBalance", () => {
+  let mockGetBalances: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockGetBalances = jest
+      .fn()
+      .mockResolvedValue([{ asset_type: APTOS_ASSET_ID, amount: BigNumber(10) }]);
+
+    (AptosAPI as jest.Mock).mockImplementation(() => ({
+      getBalances: mockGetBalances,
+    }));
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should returns balance with value 10", async () => {
+    mockGetBalances.mockResolvedValue([{ asset_type: APTOS_ASSET_ID, amount: new BigNumber(10) }]);
+
+    const accountAddress = "0x4be47904b31063d60ac0dfde06e5dc203e647edbe853bae0e666ae5a763c3906";
+    const client = new AptosAPI("aptos");
+    const balance = await getBalance(client, accountAddress);
+
+    expect(balance).toBeDefined();
+    expect(balance).toMatchObject([{ value: BigInt(10), asset: { type: "native" } }]);
+    expect(mockGetBalances).toHaveBeenCalledWith(accountAddress);
+  });
+});

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

@@ -1,7 +1,8 @@
-import { Hex, Network } from "@aptos-labs/ts-sdk";
+import { Deserializer, Hex, Network, RawTransaction } from "@aptos-labs/ts-sdk";
 import { createApi } from "../../api";
 import { getEnv } from "@ledgerhq/live-env";
-import { AptosSender } from "../../types/assets";
+import type { AptosSender } from "../../types/assets";
+import { DEFAULT_GAS, DEFAULT_GAS_PRICE } from "../../constants";
 
 describe("createApi", () => {
   const api = createApi({
@@ -11,35 +12,43 @@ describe("createApi", () => {
       indexer: getEnv("APTOS_INDEXER_ENDPOINT"),
     },
   });
+
   const sender: AptosSender = {
-    xpub: "0x474dd8fad13de7ebc82e1cb7ec4e5320887a58010fc484ed5bc8c5ed73fcd8b0",
-    freshAddress: "0xa0d8abc262e3321f87d745bd5d687e8f3fb14c87d48f840b6b56867df0026ec8",
+    xpub: "0x934887885b27a0407bf8a5e0bbc6b6371254bea94de5510e948bcc92dc0a519b",
+    freshAddress: "0x0ef3b40f6ecd5583218d1985e0d54b54e8785ad2ec2d27ed1720ec16bb11686f",
   };
+
   const recipient: AptosSender = {
-    xpub: "0x64159425ccc6e755b91dc801b93d182af978c4624d9064facaa9b147544db87f",
-    freshAddress: "0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb",
+    xpub: "0x7fd6bfaac17c2c763f624b1f95cd4911e3646a5b777b03cc24f93ed0ac3f3e2b",
+    freshAddress: "0x4859a161dfe13081cf5a5eac409cd38f707c06176a21ddc875260c2ce63f3a28",
+  };
+
+  const tokenAccount: AptosSender = {
+    xpub: "0xeacada8192f15185637e475d7783e14486e232d8b9978ffa127383847ffc5318",
+    freshAddress: "0xb8922507317d85197d70c2bc1afc949c759fd0a62c8841a4300d1e2b63649bf6",
   };
 
   describe("lastBlock", () => {
     it("returns the last block information", async () => {
       const lastBlock = await api.lastBlock();
-
       expect(lastBlock).toHaveProperty("hash");
       expect(Hex.isValid(lastBlock.hash ?? "").valid).toBeTruthy();
 
       expect(lastBlock).toHaveProperty("height");
       expect(lastBlock.height).toBeGreaterThan(0);
 
+      const time = lastBlock.time as Date;
+
       expect(lastBlock).toHaveProperty("time");
-      expect(lastBlock.time).not.toBeUndefined();
-      expect(lastBlock.time?.getFullYear()).toBeGreaterThan(0);
-      expect(lastBlock.time?.getMonth()).toBeGreaterThan(0);
-      expect(lastBlock.time?.getDay()).toBeGreaterThan(0);
+      expect(lastBlock.time).toBeDefined();
+      expect(time.getFullYear()).toBeGreaterThan(0);
+      expect(time.getMonth() + 1).toBeGreaterThan(0);
+      expect(time.getDay() + 1).toBeGreaterThan(0);
     });
   });
 
   describe("estimateFees", () => {
-    it("returns a default value", async () => {
+    it("returns fee for a native asset", async () => {
       const amount = BigInt(100);
 
       const fees = await api.estimateFees({
@@ -54,5 +63,339 @@ describe("createApi", () => {
 
       expect(fees.value).toBeGreaterThanOrEqual(0);
     });
+
+    it("returns fee for a token coin", async () => {
+      const amount = BigInt(100);
+
+      const fees = await api.estimateFees({
+        asset: {
+          type: "token",
+          standard: "coin",
+          contractAddress:
+            "0x50788befc1107c0cc4473848a92e5c783c635866ce3c98de71d2eeb7d2a34f85::usdc_coin::USDCoin",
+        },
+        type: "send",
+        sender,
+        amount,
+        recipient: recipient.freshAddress,
+      });
+
+      expect(fees.value).toBeGreaterThanOrEqual(0);
+    });
+
+    it("returns fee for a token FA", async () => {
+      const amount = BigInt(100);
+
+      const fees = await api.estimateFees({
+        asset: {
+          type: "token",
+          standard: "fungible_asset",
+          contractAddress: "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b",
+        },
+        type: "send",
+        sender,
+        amount,
+        recipient: recipient.freshAddress,
+      });
+
+      expect(fees.value).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("craftTransaction", () => {
+    it("returns a native coin RawTransaction serialized into an hexadecimal string", async () => {
+      const hex = await api.craftTransaction(
+        {
+          amount: 1n,
+          sender: sender,
+          recipient: recipient.freshAddress,
+          type: "send",
+          asset: { type: "native" },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(sender.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+
+    it("returns a coin token RawTransaction serialized into an hexadecimal string", async () => {
+      const hex = await api.craftTransaction(
+        {
+          amount: 1n,
+          sender: sender,
+          recipient: recipient.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "coin",
+            contractAddress:
+              "0x50788befc1107c0cc4473848a92e5c783c635866ce3c98de71d2eeb7d2a34f85::aptos_coin::AptosCoin",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(sender.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+
+    it("returns a use-all-amount coin token RawTransaction serialized into an hexadecimal string", async () => {
+      const hex = await api.craftTransaction(
+        {
+          amount: 0n,
+          sender: sender,
+          recipient: recipient.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "coin",
+            contractAddress:
+              "0x50788befc1107c0cc4473848a92e5c783c635866ce3c98de71d2eeb7d2a34f85::aptos_coin::AptosCoin",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(sender.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+
+    it("returns a use-all-amount fungible_asset token RawTransaction serialized into an hexadecimal string", async () => {
+      const r = sender;
+      const s = recipient; // recipient contains fungible_assets balances
+      const hex = await api.craftTransaction(
+        {
+          amount: 0n,
+          sender: s,
+          recipient: r.freshAddress,
+          type: "send",
+          asset: {
+            type: "token",
+            standard: "fungible_asset",
+            contractAddress: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+          },
+        },
+        0n,
+      );
+
+      const rawTx = RawTransaction.deserialize(
+        new Deserializer(Hex.fromHexString(hex).toUint8Array()),
+      );
+
+      expect(rawTx.sender.toString()).toBe(s.freshAddress);
+      expect(rawTx.gas_unit_price.toString()).toBe(DEFAULT_GAS_PRICE.toString());
+      expect(rawTx.max_gas_amount.toString()).toBe(DEFAULT_GAS.toString());
+    });
+  });
+
+  describe("getBalance", () => {
+    it("return balances from account", async () => {
+      const balances = await api.getBalance(sender.freshAddress);
+
+      expect(balances.length).toBeGreaterThan(0);
+      expect(balances[0].value).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("listOperations", () => {
+    it("returns operations from account", async () => {
+      const block = await api.lastBlock();
+
+      const [operations] = await api.listOperations(sender.freshAddress, {
+        minHeight: block.height,
+      });
+
+      expect(operations).toBeInstanceOf(Array);
+      expect(operations.length).toBeGreaterThanOrEqual(2);
+
+      const txINHash = "0xe1987b67878faff326a179d59ab0f5df89cc10cdcbccab1147b52735579832a5";
+      const txOUTHash = "0xee3866ab35797a39102aeff6bdeb70d3d4df65adedf9efedfddad88f27dc6fa4";
+
+      const operationIN = operations.find(operation => operation.id === txINHash);
+      const operationOUT = operations.find(operation => operation.id === txOUTHash);
+
+      expect(operationIN).toMatchObject({
+        type: "IN",
+        value: 11000000n,
+        recipients: [sender.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xe1987b67878faff326a179d59ab0f5df89cc10cdcbccab1147b52735579832a5",
+          block: { height: 0 },
+          fees: 99900n,
+          date: new Date("2025-05-29T13:16:30.763Z"),
+        },
+      });
+
+      expect(operationOUT).toMatchObject({
+        type: "OUT",
+        value: 2000000n,
+        recipients: ["0x4859a161dfe13081cf5a5eac409cd38f707c06176a21ddc875260c2ce63f3a28"],
+        senders: [sender.freshAddress],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xee3866ab35797a39102aeff6bdeb70d3d4df65adedf9efedfddad88f27dc6fa4",
+          block: { height: 0 },
+          fees: 1100n,
+          date: new Date("2025-05-29T13:39:28.702Z"),
+        },
+      });
+    });
+  });
+
+  describe("listOperationsTokens", () => {
+    it("returns operations from account", async () => {
+      const block = await api.lastBlock();
+
+      const [operations] = await api.listOperations(tokenAccount.freshAddress, {
+        minHeight: block.height,
+      });
+
+      expect(operations).toBeInstanceOf(Array);
+      expect(operations.length).toBeGreaterThanOrEqual(1);
+
+      const txINNativeHash = "0xd841b502ce333e5b9ac394db81e6597d9bbbe475e5b12966b98b843d91cc0a09";
+      const txOUTNativeHash = "0xb1114396c5b6f2f5ba955fa8e4102d0e3983d5ccdb0717ff792f6e4848e72366";
+
+      const txINLegacyCoinHash =
+        "0x6869c933396d976af85b273a825fe264a910d0064fe28ce97285073b9e5306bb";
+      const txOUTLegacyCoinHash =
+        "0xa720db7fe6327b1db23e778df5856ab1d8785d7e8edae98941a3f6e05fa58ddd";
+
+      const txINFungibleAssetHash =
+        "0x88856968603dee4f08579036bc30322b9a5f329561656888e3467ce27cc11ea7";
+      const txOUTFungibleAssetHash =
+        "0x8aa9e980760fe8aeb6804f387350b3019a2471aa61a5506a260c32cd5d6db32c";
+
+      const operationIN = operations.find(operation => operation.id === txINNativeHash);
+      const operationOUT = operations.find(operation => operation.id === txOUTNativeHash);
+
+      expect(operationIN).toMatchObject({
+        type: "IN",
+        value: 1000000n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xd841b502ce333e5b9ac394db81e6597d9bbbe475e5b12966b98b843d91cc0a09",
+          block: { height: 0 },
+          fees: 99900n,
+          date: new Date("2025-05-29T18:32:11.515Z"),
+        },
+      });
+
+      expect(operationOUT).toMatchObject({
+        type: "OUT",
+        value: 951100n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: { type: "native" },
+        tx: {
+          hash: "0xb1114396c5b6f2f5ba955fa8e4102d0e3983d5ccdb0717ff792f6e4848e72366",
+          block: { height: 0 },
+          fees: 1100n,
+          date: new Date("2025-05-29T18:39:57.864Z"),
+        },
+      });
+
+      const coinIN = operations.find(operation => operation.id === txINLegacyCoinHash);
+      const coinOUT = operations.find(operation => operation.id === txOUTLegacyCoinHash);
+
+      expect(coinIN).toMatchObject({
+        type: "IN",
+        value: 2000000n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: {
+          type: "token",
+          standard: "coin",
+          contractAddress:
+            "0xd11107bdf0d6d7040c6c0bfbdecb6545191fdf13e8d8d259952f53e1713f61b5::staked_coin::StakedAptos",
+        },
+        tx: {
+          hash: "0x6869c933396d976af85b273a825fe264a910d0064fe28ce97285073b9e5306bb",
+          block: { height: 0 },
+          fees: 51100n,
+          date: new Date("2025-05-29T18:32:58.804Z"),
+        },
+      });
+
+      expect(coinOUT).toMatchObject({
+        type: "OUT",
+        value: 1000000n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: {
+          type: "token",
+          standard: "coin",
+          contractAddress:
+            "0xd11107bdf0d6d7040c6c0bfbdecb6545191fdf13e8d8d259952f53e1713f61b5::staked_coin::StakedAptos",
+        },
+        tx: {
+          hash: "0xa720db7fe6327b1db23e778df5856ab1d8785d7e8edae98941a3f6e05fa58ddd",
+          block: { height: 0 },
+          fees: 1200n,
+          date: new Date("2025-05-29T18:38:08.283Z"),
+        },
+      });
+
+      const fungibleAssetIN = operations.find(operation => operation.id === txINFungibleAssetHash);
+      const fungibleAssetOUT = operations.find(
+        operation => operation.id === txOUTFungibleAssetHash,
+      );
+
+      expect(fungibleAssetIN).toMatchObject({
+        type: "IN",
+        value: 1750n,
+        recipients: [tokenAccount.freshAddress],
+        senders: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        asset: {
+          type: "token",
+          standard: "fungible_asset",
+          contractAddress: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+        },
+        tx: {
+          hash: "0x88856968603dee4f08579036bc30322b9a5f329561656888e3467ce27cc11ea7",
+          block: { height: 0 },
+          fees: 54300n,
+          date: new Date("2025-05-29T18:33:58.097Z"),
+        },
+      });
+
+      expect(fungibleAssetOUT).toMatchObject({
+        type: "OUT",
+        value: 1000n,
+        recipients: ["0x24dbf71ba20209753035505c51d4607ed67aa0c81b930d9ef4483ec84b349fcb"],
+        senders: [tokenAccount.freshAddress],
+        asset: {
+          type: "token",
+          standard: "fungible_asset",
+          contractAddress: "0x2ebb2ccac5e027a87fa0e2e5f656a3a4238d6a48d93ec9b610d570fc0aa0df12",
+        },
+        tx: {
+          hash: "0x8aa9e980760fe8aeb6804f387350b3019a2471aa61a5506a260c32cd5d6db32c",
+          block: { height: 0 },
+          fees: 1000n,
+          date: new Date("2025-05-29T18:38:56.897Z"),
+        },
+      });
+    });
   });
 });

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

@@ -76,7 +76,7 @@ describe("lastBlock", () => {
     expect(await api.lastBlock()).toStrictEqual({
       height: 123,
       hash: "123hash",
-      time: new Date(1746021098623892),
+      time: new Date(1746021098623892 / 1_000),
     });
   });
 });