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

package/src/network/sdk.test.ts

@@ -1,50 +1,3 @@
-// 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";
 
@@ -215,6 +168,16 @@ 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: {
@@ -320,9 +283,9 @@ describe("SDK Functions", () => {
   });
 
   test("getOperationDate should return correct date", () => {
-    expect(sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse)).toEqual(
-      new Date("2025-03-18T10:40:54.878Z"),
-    );
+    const date = sdk.getOperationDate(mockTransaction as SuiTransactionBlockResponse);
+    expect(date).toBeDefined();
+    expect(date).toBeInstanceOf(Date);
   });
 
   test("getOperationCoinType should extract token coin type", () => {
@@ -534,33 +497,6 @@ 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 = {
@@ -1531,3 +1467,176 @@ 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,
-  SuiTransactionBlockResponse,
-  TransactionBlockData,
   SuiHTTPTransport,
-  TransactionEffects,
-  QueryTransactionBlocksParams,
-  BalanceChange,
+  SuiTransactionBlockResponse,
   SuiTransactionBlockResponseOptions,
   DelegatedStake,
   StakeObject,
+  TransactionBlockData,
+  TransactionEffects,
 } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 import { BigNumber } from "bignumber.js";
@@ -232,7 +232,7 @@ export function transactionToOperation(
       coinType,
     },
     fee: getOperationFee(transaction),
-    hasFailed: transaction.effects?.status.status != "success",
+    hasFailed: transaction.effects?.status.status !== "success",
     hash,
     recipients: getOperationRecipients(transaction.transaction?.data),
     senders: getOperationSenders(transaction.transaction?.data),
@@ -278,7 +278,7 @@ export function toBlockInfo(checkpoint: Checkpoint): BlockInfo {
     time: new Date(parseInt(checkpoint.timestampMs)),
   };
 
-  if (typeof checkpoint.previousDigest == "string")
+  if (typeof checkpoint.previousDigest === "string")
     return {
       ...info,
       parent: {
@@ -303,7 +303,7 @@ export function toBlockInfo(checkpoint: Checkpoint): BlockInfo {
 export function toBlockTransaction(transaction: SuiTransactionBlockResponse): BlockTransaction {
   return {
     hash: transaction.digest,
-    failed: transaction.effects?.status.status != "success",
+    failed: transaction.effects?.status.status !== "success",
     operations: transaction.balanceChanges?.flatMap(toBlockOperation) || [],
     fees: BigInt(getOperationFee(transaction).toString()),
     feesPayer: transaction.transaction?.data.sender || "",
@@ -316,7 +316,7 @@ export function toBlockTransaction(transaction: SuiTransactionBlockResponse): Bl
  * @param change balance change
  */
 export function toBlockOperation(change: BalanceChange): BlockOperation[] {
-  if (typeof change.owner == "string" || !("AddressOwner" in change.owner)) return [];
+  if (typeof change.owner === "string" || !("AddressOwner" in change.owner)) return [];
   return [
     {
       type: "transfer",
@@ -481,75 +481,79 @@ const getTotalGasUsed = (effects?: TransactionEffects | null): bigint => {
   );
 };
 
-const FALLBACK_GAS_BUDGET = {
-  SUI_TRANSFER: "3976000",
-  TOKEN_TRANSFER: "4461792",
-};
+/**
+ * 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,
+    });
 
-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),
-      };
+    // 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++;
     }
-  });
+    totalBalance = currentBalance;
 
-export const getCoinObjectIds = async (
-  address: string,
-  transaction: CreateExtrinsicArg | TransactionType,
-) =>
-  withApi(async api => {
-    const coinObjectId = null;
+    cursor = response.nextCursor;
+    hasNextPage = response.hasNextPage && totalBalance < requiredAmount;
+  }
 
-    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;
-  });
+  return coins;
+};
 
+/**
+ * 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));
 
-    const coinObjects = await getCoinObjectIds(address, transaction);
+    if (transaction.coinType !== DEFAULT_COIN_TYPE) {
+      const requiredAmount = transaction.amount.toNumber();
+
+      const coins = await getCoinsForAmount(api, address, transaction.coinType, requiredAmount);
 
-    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));
+      if (coins.length === 0) {
+        throw new Error(`No coins found for type ${transaction.coinType}`);
       }
-      const [coin] = tx.splitCoins(coins[0], [transaction.amount.toNumber()]);
+
+      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()]);
       tx.transferObjects([coin], transaction.recipient);
     } else {
       const [coin] = tx.splitCoins(tx.gas, [transaction.amount.toNumber()]);
@@ -559,6 +563,22 @@ 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);

package/tsconfig.json

@@ -8,7 +8,8 @@
     "rootDir": "./src",
     "exactOptionalPropertyTypes": true,
     "module": "ESNext",
-    "moduleResolution": "bundler"
+    "moduleResolution": "bundler",
+    "typeRoots": ["./node_modules/@types", "index.d.ts"]
   },
-  "include": ["src/**/*"]
-}
+  "include": ["src/**/*", "index.d.ts"]
+}