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

package/src/network/sdk.ts

@@ -1,16 +1,18 @@
 import {
+  BalanceChange,
   Checkpoint,
   ExecuteTransactionBlockParams,
   PaginatedTransactionResponse,
+  QueryTransactionBlocksParams,
   SuiCallArg,
   SuiClient,
+  SuiHTTPTransport,
   SuiTransactionBlockResponse,
+  SuiTransactionBlockResponseOptions,
+  DelegatedStake,
+  StakeObject,
   TransactionBlockData,
-  SuiHTTPTransport,
   TransactionEffects,
-  QueryTransactionBlocksParams,
-  BalanceChange,
-  SuiTransactionBlockResponseOptions,
 } from "@mysten/sui/client";
 import { Transaction } from "@mysten/sui/transactions";
 import { BigNumber } from "bignumber.js";
@@ -20,6 +22,8 @@ import type {
   BlockTransaction,
   BlockOperation,
   Operation as Op,
+  Stake,
+  StakeState,
   AssetInfo,
 } from "@ledgerhq/coin-framework/api/index";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
@@ -81,45 +85,29 @@ export async function withApi<T>(execute: AsyncApiFunction<T>) {
   return result;
 }
 
-export const getBalanceCached = makeLRUCache(
-  ({ api, owner }: { api: SuiClient; owner: string }) => api.getBalance({ owner }),
-  (params: { api: SuiClient; owner: string }) => params.owner,
-  minutes(1),
-);
-
 export const getAllBalancesCached = makeLRUCache(
-  ({ api, owner }: { api: SuiClient; owner: string }) =>
-    api.getAllBalances({
-      owner,
-    }),
-  (params: { api: SuiClient; owner: string }) => params.owner,
+  async (owner: string) =>
+    withApi(
+      async api =>
+        await api.getAllBalances({
+          owner,
+        }),
+    ),
+  (owner: string) => owner,
   minutes(1),
 );
 
-/**
- * Get account balance
- */
-export const getAccount = async (addr: string) =>
-  withApi(async api => {
-    const balance = await getBalanceCached({ api, owner: addr });
-    return {
-      blockHeight: BLOCK_HEIGHT * 2,
-      balance: BigNumber(balance.totalBalance),
-    };
-  });
-
 /**
  * Get account balance (native and tokens)
  */
-export const getAccountBalances = async (addr: string) =>
-  withApi(async api => {
-    const balances = await getAllBalancesCached({ api, owner: addr });
-    return balances.map(({ coinType, totalBalance }) => ({
-      coinType,
-      blockHeight: BLOCK_HEIGHT * 2,
-      balance: BigNumber(totalBalance),
-    }));
-  });
+export const getAccountBalances = async (addr: string) => {
+  const balances = await getAllBalancesCached(addr);
+  return balances.map(({ coinType, totalBalance }) => ({
+    coinType,
+    blockHeight: BLOCK_HEIGHT * 2,
+    balance: BigNumber(totalBalance),
+  }));
+};
 
 /**
  * Returns true if account is the signer
@@ -493,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();
 
-    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 coins = await getCoinsForAmount(api, address, transaction.coinType, requiredAmount);
+
+      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()]);
@@ -571,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);
@@ -670,3 +678,51 @@ export const queryTransactionsByDigest = async (params: {
 
   return responses;
 };
+
+export const getStakes = (address: string): Promise<Stake[]> =>
+  withApi(async api =>
+    api
+      .getStakes({ owner: address })
+      .then(delegations => delegations.flatMap(delegation => toStakes(address, delegation))),
+  );
+
+export const toStakes = (address: string, delegation: DelegatedStake): Stake[] =>
+  delegation.stakes.map(stake => {
+    const { deposited, rewarded } = toStakeAmounts(stake);
+    return {
+      uid: stake.stakedSuiId,
+      address: address,
+      delegate: delegation.validatorAddress,
+      state: toStakeState(stake.status),
+      asset: { type: "native" },
+      amount: deposited + rewarded,
+      amountDeposited: deposited,
+      amountRewarded: rewarded,
+      details: {
+        activeEpoch: Number(stake.stakeActiveEpoch),
+        requestEpoch: Number(stake.stakeRequestEpoch),
+      },
+    };
+  });
+
+export const toStakeState = (status: "Pending" | "Active" | "Unstaked"): StakeState => {
+  switch (status) {
+    case "Pending":
+      return "activating";
+    case "Active":
+      return "active";
+    case "Unstaked":
+      return "inactive";
+  }
+};
+
+export const toStakeAmounts = (stake: StakeObject): { deposited: bigint; rewarded: bigint } => {
+  switch (stake.status) {
+    case "Pending":
+      return { deposited: BigInt(stake.principal), rewarded: 0n };
+    case "Active":
+      return { deposited: BigInt(stake.principal), rewarded: BigInt(stake.estimatedReward) };
+    case "Unstaked":
+      return { deposited: BigInt(stake.principal), rewarded: 0n }; // note: we lose reward information in unstaked state here
+  }
+};

package/src/test/testUtils.ts

@@ -0,0 +1,38 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SuiClient, getFullnodeUrl } from "@mysten/sui/client";
+
+export async function extractCoinTypeFromUnsignedTx(
+  unsignedTxBytes: Uint8Array,
+): Promise<string[] | null> {
+  const tx = Transaction.from(unsignedTxBytes);
+  const data = tx.getData();
+
+  const gasObjectIds = data.gasData.payment?.map(object => object.objectId) ?? [];
+  const inputObjectIds = data.inputs
+    .map(input => {
+      return input.$kind === "Object" && input.Object.$kind === "ImmOrOwnedObject"
+        ? input.Object.ImmOrOwnedObject.objectId
+        : null;
+    })
+    .filter((objectId): objectId is string => !!objectId);
+
+  const suiClient = new SuiClient({ url: getFullnodeUrl("mainnet") });
+  const objects = await suiClient.multiGetObjects({
+    ids: [...gasObjectIds, ...inputObjectIds],
+    options: {
+      showBcs: true,
+      showPreviousTransaction: true,
+      showStorageRebate: true,
+      showOwner: true,
+    },
+  });
+
+  const coinObjects = objects.filter(obj => {
+    const bcsData = obj.data?.bcs as any;
+    return bcsData.type.includes("coin");
+  });
+
+  const coinTypes: string[] = coinObjects.map(obj => (obj.data?.bcs as any).type);
+
+  return coinTypes;
+}