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

package/src/bridge/buildTransaction.ts

@@ -1,6 +1,7 @@
+import { findSubAccountById } from "@ledgerhq/coin-framework/account/helpers";
 import type { SuiAccount, Transaction } from "../types";
 import { craftTransaction } from "../logic";
-import { toSuiAsset } from "../network/sdk";
+import { DEFAULT_COIN_TYPE, toSuiAsset } from "../network/sdk";
 
 /**
  * @param {Account} account
@@ -8,13 +9,17 @@ import { toSuiAsset } from "../network/sdk";
  */
 export const buildTransaction = async (
   account: SuiAccount,
-  { recipient, mode, amount, coinType }: Transaction,
+  { amount, mode, recipient, subAccountId }: Transaction,
 ) => {
+  const { freshAddress } = account;
+  const subAccount = findSubAccountById(account, subAccountId ?? "");
+  const asset = toSuiAsset(subAccount?.token.contractAddress ?? DEFAULT_COIN_TYPE);
+
   return craftTransaction({
-    sender: account.freshAddress,
+    amount: BigInt(amount.toString()),
+    asset,
     recipient,
+    sender: freshAddress,
     type: mode,
-    amount: BigInt(amount.toString()),
-    asset: toSuiAsset(coinType),
   });
 };

package/src/bridge/getFeesForTransaction.ts

@@ -4,6 +4,7 @@ import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
 import type { SuiAccount, Transaction } from "../types";
 import { calculateAmount } from "./utils";
 import { estimateFees } from "../logic";
+import { DEFAULT_COIN_TYPE, toSuiAsset } from "../network/sdk";
 
 /**
  * Fetch the transaction fees for a transaction
@@ -34,9 +35,7 @@ export default async function getEstimatedFees({
   };
 
   const subAccount = findSubAccountById(account, transaction.subAccountId ?? "");
-  const asset = subAccount
-    ? { type: "token" as const, coinType: subAccount?.token.contractAddress }
-    : { type: "native" as const };
+  const asset = toSuiAsset(subAccount?.token.contractAddress ?? DEFAULT_COIN_TYPE);
 
   const fees = await estimateFees({
     recipient: getAbandonSeedAddress(account.currency.id),

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

@@ -2,7 +2,7 @@ import buildSignOperation from "./signOperation";
 import { createFixtureAccount, createFixtureTransaction } from "../types/bridge.fixture";
 import { SuiSigner } from "../types";
 import coinConfig from "../config";
-import { getFullnodeUrl } from "@mysten/sui/client";
+import { getEnv } from "@ledgerhq/live-env";
 
 describe("signOperation", () => {
   beforeAll(() => {
@@ -11,7 +11,7 @@ describe("signOperation", () => {
         type: "active",
       },
       node: {
-        url: getFullnodeUrl("mainnet"),
+        url: getEnv("API_SUI_NODE_PROXY"),
       },
     }));
   });

package/src/logic/craftTransaction.ts

@@ -25,9 +25,9 @@ export async function craftTransaction({
   }
   const unsigned = await suiAPI.createTransaction(sender, {
     amount: BigNumber(amount.toString()),
-    recipient,
     coinType,
     mode: type as SuiTransactionMode,
+    recipient,
   });
 
   return { unsigned };

package/src/network/sdk.integration.test.ts

@@ -12,7 +12,7 @@ import {
   getBlockInfo,
   getStakes,
 } from "./sdk";
-import { getFullnodeUrl } from "@mysten/sui/client";
+import { getEnv } from "@ledgerhq/live-env";
 
 describe("SUI SDK Integration tests", () => {
   beforeAll(() => {
@@ -21,7 +21,7 @@ describe("SUI SDK Integration tests", () => {
         type: "active",
       },
       node: {
-        url: getFullnodeUrl("mainnet"),
+        url: getEnv("API_SUI_NODE_PROXY"),
       },
     }));
   });

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";
@@ -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"]
+}