@msafe/sui3-sdk 1.0.24 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msafe/sui3-sdk",
-  "version": "1.0.24",
+  "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

@@ -14,6 +14,14 @@ 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 {
@@ -42,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.
@@ -57,6 +103,13 @@ export function computeGasBudget(
 
 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
@@ -68,16 +121,15 @@ export function pickGasPaymentCoins(coins: PaymentCoinRef[], cover: bigint): Pay
     return [];
   }
 
-  const sorted = [...coins]
-    .filter((coin) => coin.balance > 0n)
-    .sort((a, b) => (a.balance === b.balance ? 0 : a.balance < b.balance ? 1 : -1));
+  const sorted = [...coins].filter((coin) => coin.balance > 0n).sort(compareBalanceDescending);
 
   const selected: PaymentCoinRef[] = [];
   let sum = 0n;
-  for (const coin of sorted) {
+  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) {
@@ -87,6 +139,58 @@ export function pickGasPaymentCoins(coins: PaymentCoinRef[], cover: bigint): Pay
   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[];
   coinBalance: bigint;
@@ -317,6 +421,15 @@ 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.
@@ -419,7 +532,22 @@ export async function estimateGasBudget(input: {
   probe.setGasPrice(gasPrice);
 
   // Prefer a few large classic coins for the probe (never attach every owned coin).
-  if (funding.paymentCoins.length > 0) {
+  // 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)));
   }