@msafe/sui3-sdk 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msafe/sui3-sdk",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "SDK for MSafe SUI V3",
   "type": "module",
   "module": "./dist/index.js",
@@ -51,6 +51,7 @@
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-unused-imports": "^3.0.0",
     "exponential-backoff": "^3.1.1",
+    "husky": "^9.1.7",
     "jest": "^30.0.0",
     "prettier": "^3.0.3",
     "semver": "7.6.3",
@@ -73,7 +74,8 @@
     "build-yalc": "bun run build && yalc publish --private",
     "changeset": "changeset",
     "version-packages": "changeset version",
-    "release": "bun run build && changeset publish"
+    "release": "bun run build && changeset publish",
+    "prepare": "husky"
   },
   "peerDependencies": {
     "@msafe/sui-app-store": ">0.0.100",

package/src/utils/gasFunding.ts

@@ -8,6 +8,20 @@ import { getAllCoins, SUI_COIN } from '@/utils/sui';
 
 const GAS_SAFE_OVERHEAD = 1000n;
 
+/** Protocol cap: a transaction may smash at most this many gas payment objects. */
+export const MAX_GAS_PAYMENT_OBJECTS = 256;
+
+/** Cover target for estimate probes (1 SUI is enough for a normal dry-run). */
+const ESTIMATE_GAS_COVER = 1_000_000_000n;
+
+/**
+ * Cap for the estimate probe budget. High enough for a dry-run, and well below
+ * a large gas coin so the probe does not reserve the balance a GasCoin split needs.
+ */
+const MAX_PROBE_GAS_BUDGET = 50_000_000_000n;
+
+const COIN_WITH_BALANCE_INTENT = 'CoinWithBalance';
+
 export type GasFundingMode = 'classic' | 'addressBalance' | 'mixedTopUp';
 
 export interface GasFundingResult {
@@ -36,6 +50,44 @@ export class InsufficientGasFundsError extends Error {
   }
 }
 
+/**
+ * Gas coins cannot cover a SUI amount that is split from the gas coin.
+ * Happens when the largest 256 coins are still short of amount + gas budget.
+ */
+export class GasPaymentLimitError extends Error {
+  readonly required: bigint;
+
+  readonly covered: bigint;
+
+  readonly coinCount: number;
+
+  constructor(required: bigint, covered: bigint, coinCount: number) {
+    super(gasPaymentLimitMessage(required, covered, coinCount));
+    this.name = 'GasPaymentLimitError';
+    this.required = required;
+    this.covered = covered;
+    this.coinCount = coinCount;
+  }
+}
+
+function formatSui(mist: bigint): string {
+  const negative = mist < 0n;
+  const value = negative ? -mist : mist;
+  const whole = value / 1_000_000_000n;
+  const fraction = (value % 1_000_000_000n).toString().padStart(9, '0').replace(/0+$/, '');
+  const text = fraction.length > 0 ? `${whole}.${fraction}` : `${whole}`;
+  return negative ? `-${text}` : text;
+}
+
+function gasPaymentLimitMessage(required: bigint, covered: bigint, coinCount: number): string {
+  const requiredSui = formatSui(required);
+  const coveredSui = formatSui(covered);
+  if (coinCount >= MAX_GAS_PAYMENT_OBJECTS) {
+    return `This transfer needs ${requiredSui} SUI from gas coins, but the largest ${MAX_GAS_PAYMENT_OBJECTS} coins only cover ${coveredSui} SUI. Send a smaller amount, or consolidate coins into fewer objects first.`;
+  }
+  return `This transfer needs ${requiredSui} SUI from gas coins, but the available SUI coin objects only cover ${coveredSui} SUI.`;
+}
+
 /**
  * Gas budget must cover pre-rebate costs (computation + storage + overhead).
  * storageRebate is refunded after execution and must not reduce the budget.
@@ -49,7 +101,95 @@ export function computeGasBudget(
   return BigInt(computationCost) + BigInt(storageCost) + safeOverhead;
 }
 
-type PaymentCoinRef = { objectId: string; version: string; digest: string; balance: bigint };
+export type PaymentCoinRef = { objectId: string; version: string; digest: string; balance: bigint };
+
+function compareBalanceDescending(a: PaymentCoinRef, b: PaymentCoinRef): number {
+  if (a.balance === b.balance) {
+    return 0;
+  }
+  return a.balance < b.balance ? 1 : -1;
+}
+
+/**
+ * Pick the fewest large SUI coins that cover `cover`, capped at 256.
+ * Never attach every owned coin — accounts with hundreds of SUI objects
+ * exceed max_gas_payment_objects and trip gasless estimate
+ * ("gas_budget must be 0 for gasless transactions").
+ */
+export function pickGasPaymentCoins(coins: PaymentCoinRef[], cover: bigint): PaymentCoinRef[] {
+  if (cover <= 0n) {
+    return [];
+  }
+
+  const sorted = [...coins].filter((coin) => coin.balance > 0n).sort(compareBalanceDescending);
+
+  const selected: PaymentCoinRef[] = [];
+  let sum = 0n;
+  for (let index = 0; index < sorted.length; index += 1) {
+    if (selected.length >= MAX_GAS_PAYMENT_OBJECTS) {
+      break;
+    }
+    const coin = sorted[index];
+    selected.push(coin);
+    sum += coin.balance;
+    if (sum >= cover) {
+      break;
+    }
+  }
+  return selected;
+}
+
+function readBigInt(value: unknown): bigint {
+  if (typeof value === 'bigint') {
+    return value;
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return BigInt(Math.trunc(value));
+  }
+  if (typeof value === 'string' && /^-?\d+$/.test(value)) {
+    return BigInt(value);
+  }
+  return 0n;
+}
+
+/** SUI that CoinWithBalance intents will split out of the gas coin. */
+export function gasCoinWithdrawal(tx: Transaction): bigint {
+  return tx.getData().commands.reduce((sum, command) => {
+    if (command.$kind !== '$Intent' || command.$Intent.name !== COIN_WITH_BALANCE_INTENT) {
+      return sum;
+    }
+    const data = command.$Intent.data as { type?: unknown; balance?: unknown } | undefined;
+    if (data?.type !== 'gas') {
+      return sum;
+    }
+    return sum + readBigInt(data.balance);
+  }, 0n);
+}
+
+/**
+ * Balance gas payment coins must hold.
+ * A SUI withdrawal is taken from the gas coin only when address balance cannot
+ * cover that withdrawal by itself. Mysten redeems address balance for the whole
+ * amount in that case, and gas payment only has to pay the gas budget.
+ */
+export function gasPaymentCover(tx: Transaction, addressBalance: bigint, gasBudget: bigint): bigint {
+  const withdrawal = gasCoinWithdrawal(tx);
+  const fromGasCoin = withdrawal > addressBalance ? withdrawal : 0n;
+  return gasBudget + fromGasCoin;
+}
+
+function sumBalances(coins: PaymentCoinRef[]): bigint {
+  return coins.reduce((sum, coin) => sum + coin.balance, 0n);
+}
+
+function pickGasPaymentCoinsForCover(coins: PaymentCoinRef[], cover: bigint): PaymentCoinRef[] {
+  const picked = pickGasPaymentCoins(coins, cover);
+  const covered = sumBalances(picked);
+  if (cover > 0n && covered < cover) {
+    throw new GasPaymentLimitError(cover, covered, picked.length);
+  }
+  return picked;
+}
 
 interface SuiGasFunding {
   paymentCoins: PaymentCoinRef[];
@@ -281,21 +421,31 @@ export async function selectGasFunding(input: {
     throw new InsufficientGasFundsError(gasBudget, coinBalance, addressBalance);
   }
 
+  // SUI sent via the gas coin must be in the payment set, not only the gas budget.
+  // Otherwise a single large coin is selected and any bigger transfer fails.
+  const cover = gasPaymentCover(tx, addressBalance, gasBudget);
+  if (cover > gasBudget) {
+    const picked = pickGasPaymentCoinsForCover(paymentCoins, cover);
+    tx.setGasPayment(toObjectRefs(picked));
+    return { mode: 'classic', gasBudget, coinBalance, addressBalance };
+  }
+
   // Prefer classic / mixed whenever owned SUI coins exist. Pure address-balance
   // gas (payment: []) is stricter on budget and is what Mysten auto-picks when
   // addressBalance > 0 — avoid it unless there is no usable gas coin.
   if (paymentCoins.length > 0 && coinBalance >= gasBudget) {
-    tx.setGasPayment(toObjectRefs(paymentCoins));
+    tx.setGasPayment(toObjectRefs(pickGasPaymentCoins(paymentCoins, gasBudget)));
     return { mode: 'classic', gasBudget, coinBalance, addressBalance };
   }
 
   if (paymentCoins.length > 0 && total >= gasBudget) {
     const topUpAmount = gasBudget - coinBalance; // > 0 and <= addressBalance
+    // One real coin is enough — reservation smashes into it.
     await applyMixedTopUp({
       tx,
       suiClient,
       owner,
-      paymentCoins,
+      paymentCoins: pickGasPaymentCoins(paymentCoins, 1n),
       topUpAmount,
     });
     return { mode: 'mixedTopUp', gasBudget, coinBalance, addressBalance };
@@ -381,9 +531,24 @@ export async function estimateGasBudget(input: {
   probe.setSender(owner);
   probe.setGasPrice(gasPrice);
 
-  // Prefer classic coins for the probe when available (cheaper than address-balance gas).
-  if (funding.paymentCoins.length > 0) {
-    probe.setGasPayment(toObjectRefs(funding.paymentCoins));
+  // Prefer a few large classic coins for the probe (never attach every owned coin).
+  // When the PTB splits SUI from the gas coin, the probe must hold that amount too,
+  // and the budget must be set so the node does not run its own gas selection.
+  const fromGasCoin = gasPaymentCover(tx, funding.addressBalance, 0n);
+  if (fromGasCoin > 0n) {
+    const picked = pickGasPaymentCoins(funding.paymentCoins, fromGasCoin + ESTIMATE_GAS_COVER);
+    const covered = sumBalances(picked);
+    // The 1 SUI probe cushion is not part of the transfer. Reject only when the
+    // coins cannot hold the withdrawal itself and leave something for gas.
+    if (covered <= fromGasCoin) {
+      throw new GasPaymentLimitError(fromGasCoin, covered, picked.length);
+    }
+    probe.setGasPayment(toObjectRefs(picked));
+    const remainder = covered - fromGasCoin;
+    const probeBudget = remainder > MAX_PROBE_GAS_BUDGET ? MAX_PROBE_GAS_BUDGET : remainder;
+    probe.setGasBudget(probeBudget);
+  } else if (funding.paymentCoins.length > 0) {
+    probe.setGasPayment(toObjectRefs(pickGasPaymentCoins(funding.paymentCoins, ESTIMATE_GAS_COVER)));
   }
 
   let built: Uint8Array;
@@ -500,6 +665,6 @@ export async function preferClassicGasPayment(input: {
   if (funding.paymentCoins.length === 0) {
     return false;
   }
-  tx.setGasPayment(toObjectRefs(funding.paymentCoins));
+  tx.setGasPayment(toObjectRefs(pickGasPaymentCoins(funding.paymentCoins, ESTIMATE_GAS_COVER)));
   return true;
 }