@ledgerhq/coin-sui 0.10.0-nightly.1 → 0.10.0

package/src/network/sdk.test.ts

@@ -1,3 +1,50 @@
+// Move all jest.mock calls to the very top
+jest.mock("../config", () => ({
+  __esModule: true,
+  default: {
+    getCoinConfig: jest.fn(() => ({ node: { url: "http://test.com" } })),
+    setCoinConfig: jest.fn(),
+  },
+}));
+
+jest.mock("../utils", () => ({
+  ensureAddressFormat: jest.fn((addr: string) => addr),
+}));
+
+jest.mock("@ledgerhq/live-network/cache", () => ({
+  makeLRUCache: jest.fn(() => jest.fn()),
+  minutes: jest.fn(() => 60000),
+}));
+
+jest.mock("@ledgerhq/logs", () => ({
+  log: jest.fn(),
+}));
+
+jest.mock("@mysten/sui/client", () => {
+  const mockClient = {
+    queryTransactionBlocks: jest.fn(),
+    getBalance: jest.fn(),
+    getLatestCheckpointSequenceNumber: jest.fn(),
+    getCheckpoint: jest.fn(),
+    dryRunTransactionBlock: jest.fn(),
+    executeTransactionBlock: jest.fn(),
+  };
+  return {
+    SuiClient: jest.fn().mockImplementation(() => mockClient),
+  };
+});
+
+jest.mock("@mysten/sui/transactions", () => ({
+  Transaction: jest.fn().mockImplementation(() => ({
+    setSender: jest.fn().mockReturnThis(),
+    splitCoins: jest.fn().mockReturnValue([{ id: "coin1" }]),
+    transferObjects: jest.fn().mockReturnThis(),
+    gas: { id: "gas" },
+    build: jest.fn().mockResolvedValue(new Uint8Array([1, 2, 3])),
+  })),
+}));
+
+// Now import after mocks
 import * as sdk from "./sdk";
 import coinConfig from "../config";
 
@@ -168,16 +215,6 @@ const mockTransaction = {
 
 const mockApi = new SuiClient({ url: "mock" }) as jest.Mocked<SuiClient>;
 
-// Helper function to generate mock coins from an array of balances
-const createMockCoins = (balances: string[]): any[] => {
-  return balances.map((balance, index) => ({
-    coinObjectId: `0xcoin${index + 1}`,
-    balance,
-    digest: `0xdigest${index + 1}`,
-    version: "1",
-  }));
-};
-
 beforeAll(() => {
   coinConfig.setCoinConfig(() => ({
     status: {
@@ -283,9 +320,9 @@ describe("SDK Functions", () => {
   });
 
   test("getOperationDate should return correct date", () => {
-    const date = sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse);
-    expect(date).toBeDefined();
-    expect(date).toBeInstanceOf(Date);
+    expect(sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse)).toEqual(
+      new Date("2025-03-18T10:40:54.878Z"),
+    );
   });
 
   test("getOperationCoinType should extract token coin type", () => {
@@ -497,6 +534,33 @@ describe("SDK Functions", () => {
     expect(info).toHaveProperty("fees");
   });
 
+  test("getCoinObjectIds should return array of object IDs for token transactions", async () => {
+    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+    const transaction = {
+      mode: "token.send" as const,
+      coinType: "0x123::test::TOKEN",
+      amount: new BigNumber(100),
+      recipient: "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164",
+    };
+
+    const coinObjectIds = await sdk.getCoinObjectIds(address, transaction);
+    expect(Array.isArray(coinObjectIds)).toBe(true);
+    expect(coinObjectIds).toContain("0xtest_coin_object_id");
+  });
+
+  test("getCoinObjectIds should return null for SUI transactions", async () => {
+    const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
+    const transaction = {
+      mode: "send" as const,
+      coinType: sdk.DEFAULT_COIN_TYPE,
+      amount: new BigNumber(100),
+      recipient: "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164",
+    };
+
+    const coinObjectIds = await sdk.getCoinObjectIds(address, transaction);
+    expect(coinObjectIds).toBeNull();
+  });
+
   test("createTransaction should build a transaction", async () => {
     const address = "0x6e143fe0a8ca010a86580dafac44298e5b1b7d73efc345356a59a15f0d7824f0";
     const transaction = {
@@ -1467,176 +1531,3 @@ describe("filterOperations", () => {
     });
   });
 });
-
-describe("getCoinsForAmount", () => {
-  const mockAddress = "0x33444cf803c690db96527cec67e3c9ab512596f4ba2d4eace43f0b4f716e0164";
-  const mockCoinType = "0x2::sui::SUI";
-
-  beforeEach(() => {
-    mockApi.getCoins.mockReset();
-  });
-
-  describe("basic functionality", () => {
-    test("handles single coin scenarios", async () => {
-      const sufficientCoins = createMockCoins(["1000"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: sufficientCoins, hasNextPage: false });
-
-      let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(1);
-      expect(result[0].balance).toBe("1000");
-
-      const insufficientCoins = createMockCoins(["500"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: insufficientCoins, hasNextPage: false });
-
-      result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(1);
-      expect(result[0].balance).toBe("500");
-    });
-
-    test("selects minimum coins needed", async () => {
-      const exactMatchCoins = createMockCoins(["600", "400", "300"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: exactMatchCoins, hasNextPage: false });
-
-      let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(2);
-      expect(result[0].balance).toBe("600");
-      expect(result[1].balance).toBe("400");
-
-      const exceedCoins = createMockCoins(["800", "400", "200"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: exceedCoins, hasNextPage: false });
-
-      result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(2);
-      expect(result[0].balance).toBe("800");
-      expect(result[1].balance).toBe("400");
-    });
-
-    test("handles edge cases", async () => {
-      mockApi.getCoins.mockResolvedValueOnce({ data: [], hasNextPage: false });
-
-      let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(0);
-
-      const coins = createMockCoins(["1000"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: coins, hasNextPage: false });
-
-      result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 0);
-      expect(result).toHaveLength(0);
-    });
-  });
-
-  describe("sorting and filtering", () => {
-    test("filters zero balance coins", async () => {
-      const mockCoins = createMockCoins(["1000", "500"]);
-      mockCoins.splice(1, 0, createMockCoins(["0"])[0]);
-      mockCoins.push({ coinObjectId: "0xcoin4", balance: "0", digest: "0xdigest4", version: "1" });
-
-      mockApi.getCoins.mockResolvedValueOnce({ data: mockCoins, hasNextPage: false });
-
-      const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].balance).toBe("1000");
-      expect(result.every(coin => parseInt(coin.balance) > 0)).toBe(true);
-    });
-
-    test("sorts and optimizes coin selection", async () => {
-      const unsortedCoins = createMockCoins(["100", "800", "300", "500"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: unsortedCoins, hasNextPage: false });
-
-      let result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(2);
-      expect(result[0].balance).toBe("800");
-      expect(result[1].balance).toBe("500");
-
-      const mixedCoins = createMockCoins(["200", "800", "400"]);
-      mixedCoins.unshift(createMockCoins(["0"])[0]);
-      mixedCoins.splice(2, 0, createMockCoins(["0"])[0]);
-
-      mockApi.getCoins.mockResolvedValueOnce({ data: mixedCoins, hasNextPage: false });
-
-      result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-      expect(result).toHaveLength(2);
-      expect(result[0].balance).toBe("800");
-      expect(result[1].balance).toBe("400");
-      expect(result.every(coin => parseInt(coin.balance) > 0)).toBe(true);
-    });
-
-    test("handles all zero balance coins", async () => {
-      const mockCoins = createMockCoins(["0", "0", "0"]);
-      mockApi.getCoins.mockResolvedValueOnce({ data: mockCoins, hasNextPage: false });
-
-      const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-
-      expect(result).toHaveLength(0);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("pagination", () => {
-    test("handles single page scenarios", async () => {
-      const mockCoins = createMockCoins(["800", "400", "300"]);
-      mockApi.getCoins.mockResolvedValueOnce({
-        data: mockCoins,
-        hasNextPage: true,
-        nextCursor: "cursor1",
-      });
-
-      const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-
-      expect(result).toHaveLength(2);
-      expect(result[0].balance).toBe("800");
-      expect(result[1].balance).toBe("400");
-      expect(mockApi.getCoins).toHaveBeenCalledTimes(1);
-    });
-
-    test("handles multi-page scenarios", async () => {
-      const firstPageCoins = createMockCoins(["300", "200"]);
-      const secondPageCoins = createMockCoins(["600", "400", "100"]);
-
-      mockApi.getCoins
-        .mockResolvedValueOnce({
-          data: firstPageCoins,
-          hasNextPage: true,
-          nextCursor: "cursor1",
-        })
-        .mockResolvedValueOnce({
-          data: secondPageCoins,
-          hasNextPage: false,
-        });
-
-      const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-
-      expect(result).toHaveLength(3);
-      expect(result[0].balance).toBe("300");
-      expect(result[1].balance).toBe("200");
-      expect(result[2].balance).toBe("600");
-      expect(mockApi.getCoins).toHaveBeenCalledTimes(2);
-    });
-
-    test("handles insufficient funds across pages", async () => {
-      const firstPageCoins = createMockCoins(["300", "200"]);
-      const secondPageCoins = createMockCoins(["200", "100"]);
-
-      mockApi.getCoins
-        .mockResolvedValueOnce({
-          data: firstPageCoins,
-          hasNextPage: true,
-          nextCursor: "cursor1",
-        })
-        .mockResolvedValueOnce({
-          data: secondPageCoins,
-          hasNextPage: false,
-        });
-
-      const result = await sdk.getCoinsForAmount(mockApi, mockAddress, mockCoinType, 1000);
-
-      expect(result).toHaveLength(4);
-      expect(result[0].balance).toBe("300");
-      expect(result[1].balance).toBe("200");
-      expect(result[2].balance).toBe("200");
-      expect(result[3].balance).toBe("100");
-      expect(mockApi.getCoins).toHaveBeenCalledTimes(2);
-    });
-  });
-});

package/src/network/sdk.ts

@@ -1,18 +1,18 @@
 import {
-  BalanceChange,
   Checkpoint,
   ExecuteTransactionBlockParams,
   PaginatedTransactionResponse,
-  QueryTransactionBlocksParams,
   SuiCallArg,
   SuiClient,
-  SuiHTTPTransport,
   SuiTransactionBlockResponse,
+  TransactionBlockData,
+  SuiHTTPTransport,
+  TransactionEffects,
+  QueryTransactionBlocksParams,
+  BalanceChange,
   SuiTransactionBlockResponseOptions,
   DelegatedStake,
   StakeObject,
-  TransactionBlockData,
-  TransactionEffects,
 } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 import { BigNumber } from "bignumber.js";
@@ -481,79 +481,75 @@ const getTotalGasUsed = (effects?: TransactionEffects | null): bigint => {
   );
 };
 
-/**
- * Get coins for a given address and coin type, stopping when we have enough to cover the amount.
- * Returns the minimum coins needed to cover the required amount.
- */
-export const getCoinsForAmount = async (
-  api: SuiClient,
-  address: string,
-  coinType: string,
-  requiredAmount: number,
-) => {
-  const coins = [];
-  let cursor = null;
-  let hasNextPage = true;
-  let totalBalance = 0;
-
-  while (hasNextPage && totalBalance < requiredAmount) {
-    const response = await api.getCoins({
-      owner: address,
-      coinType,
-      cursor,
-    });
+const FALLBACK_GAS_BUDGET = {
+  SUI_TRANSFER: "3976000",
+  TOKEN_TRANSFER: "4461792",
+};
 
-    // Filter out zero-balance coins and sort by balance (largest first)
-    const validCoins = response.data
-      .filter(coin => parseInt(coin.balance) > 0)
-      .sort((a, b) => parseInt(b.balance) - parseInt(a.balance));
-
-    let currentBalance = totalBalance;
-    let i = 0;
-    while (i < validCoins.length && currentBalance < requiredAmount) {
-      const coin = validCoins[i];
-      coins.push(coin);
-      currentBalance += parseInt(coin.balance);
-      i++;
+export const paymentInfo = async (sender: string, fakeTransaction: TransactionType) =>
+  withApi(async api => {
+    const tx = new Transaction();
+    tx.setSender(ensureAddressFormat(sender));
+    const coinObjects = await getCoinObjectIds(sender, fakeTransaction);
+
+    const [coin] = tx.splitCoins(Array.isArray(coinObjects) ? coinObjects[0] : tx.gas, [
+      fakeTransaction.amount.toNumber(),
+    ]);
+    tx.transferObjects([coin], fakeTransaction.recipient);
+
+    try {
+      const txb = await tx.build({ client: api });
+      const dryRunTxResponse = await api.dryRunTransactionBlock({ transactionBlock: txb });
+      const fees = getTotalGasUsed(dryRunTxResponse.effects);
+
+      return {
+        gasBudget: dryRunTxResponse.input.gasData.budget,
+        totalGasUsed: fees,
+        fees,
+      };
+    } catch (error) {
+      console.warn("Fee estimation failed:", error);
+      // If dry run fails return a reasonable default gas budget as fallback
+      return {
+        gasBudget: Array.isArray(coinObjects)
+          ? FALLBACK_GAS_BUDGET.TOKEN_TRANSFER
+          : FALLBACK_GAS_BUDGET.SUI_TRANSFER,
+        totalGasUsed: BigInt(1000000),
+        fees: BigInt(1000000),
+      };
     }
-    totalBalance = currentBalance;
+  });
 
-    cursor = response.nextCursor;
-    hasNextPage = response.hasNextPage && totalBalance < requiredAmount;
-  }
+export const getCoinObjectIds = async (
+  address: string,
+  transaction: CreateExtrinsicArg | TransactionType,
+) =>
+  withApi(async api => {
+    const coinObjectId = null;
 
-  return coins;
-};
+    if (transaction.coinType !== DEFAULT_COIN_TYPE) {
+      const tokenInfo = await api.getCoins({
+        owner: address,
+        coinType: transaction.coinType,
+      });
+      return tokenInfo.data.map(coin => coin.coinObjectId);
+    }
+    return coinObjectId;
+  });
 
-/**
- * Creates a Sui transaction block for transferring coins.
- *
- * @param address - The sender's address
- * @param transaction - The transaction details including recipient, amount, and coin type
- * @returns Promise<TransactionBlock> - A built transaction block ready for execution
- *
- */
 export const createTransaction = async (address: string, transaction: CreateExtrinsicArg) =>
   withApi(async api => {
     const tx = new Transaction();
     tx.setSender(ensureAddressFormat(address));
 
-    if (transaction.coinType !== DEFAULT_COIN_TYPE) {
-      const requiredAmount = transaction.amount.toNumber();
-
-      const coins = await getCoinsForAmount(api, address, transaction.coinType, requiredAmount);
+    const coinObjects = await getCoinObjectIds(address, transaction);
 
-      if (coins.length === 0) {
-        throw new Error(`No coins found for type ${transaction.coinType}`);
+    if (Array.isArray(coinObjects) && transaction.coinType !== DEFAULT_COIN_TYPE) {
+      const coins = coinObjects.map(coinId => tx.object(coinId));
+      if (coins.length > 1) {
+        tx.mergeCoins(coins[0], coins.slice(1));
       }
-
-      const coinObjects = coins.map(coin => tx.object(coin.coinObjectId));
-
-      if (coinObjects.length > 1) {
-        tx.mergeCoins(coinObjects[0], coinObjects.slice(1));
-      }
-
-      const [coin] = tx.splitCoins(coinObjects[0], [transaction.amount.toNumber()]);
+      const [coin] = tx.splitCoins(coins[0], [transaction.amount.toNumber()]);
       tx.transferObjects([coin], transaction.recipient);
     } else {
       const [coin] = tx.splitCoins(tx.gas, [transaction.amount.toNumber()]);
@@ -563,22 +559,6 @@ export const createTransaction = async (address: string, transaction: CreateExtr
     return tx.build({ client: api });
   });
 
-/**
- * Performs a dry run of a transaction to estimate gas costs and fees
- */
-export const paymentInfo = async (sender: string, fakeTransaction: TransactionType) =>
-  withApi(async api => {
-    const txb = await createTransaction(sender, fakeTransaction);
-    const dryRunTxResponse = await api.dryRunTransactionBlock({ transactionBlock: txb });
-    const fees = getTotalGasUsed(dryRunTxResponse.effects);
-
-    return {
-      gasBudget: dryRunTxResponse.input.gasData.budget,
-      totalGasUsed: fees,
-      fees,
-    };
-  });
-
 export const executeTransactionBlock = async (params: ExecuteTransactionBlockParams) =>
   withApi(async api => {
     return api.executeTransactionBlock(params);