@t2000/sdk 1.12.0 → 1.13.1

package/dist/index.cjs

@@ -7482,21 +7482,26 @@ var WRITE_APPENDER_REGISTRY = {
       throw new exports.T2000Error("INVALID_AMOUNT", "Save amount must be greater than zero");
     }
     const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
-    const { coin, effectiveAmount } = await selectAndSplitCoin(
-      tx,
-      ctx.client,
-      ctx.sender,
-      assetInfo.type,
-      rawAmount
-    );
+    let coin;
+    let effectiveAmount;
+    if (ctx.chainedCoin) {
+      coin = ctx.chainedCoin;
+      effectiveAmount = rawAmount;
+    } else {
+      const r = await selectAndSplitCoin(tx, ctx.client, ctx.sender, assetInfo.type, rawAmount);
+      coin = r.coin;
+      effectiveAmount = r.effectiveAmount;
+    }
     if (ctx.feeHooks?.save_deposit) {
       await ctx.feeHooks.save_deposit({ tx, coin, input, sender: ctx.sender });
     }
     await addSaveToTx(tx, ctx.client, ctx.sender, coin, { asset });
     return {
-      toolName: "save_deposit",
-      effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
-      asset
+      preview: {
+        toolName: "save_deposit",
+        effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
+        asset
+      }
     };
   },
   withdraw: async (tx, input, ctx) => {
@@ -7511,8 +7516,13 @@ var WRITE_APPENDER_REGISTRY = {
       input.amount,
       { asset, skipPythUpdate: ctx.sponsoredContext }
     );
-    tx.transferObjects([coin], ctx.sender);
-    return { toolName: "withdraw", effectiveAmount, asset };
+    if (!ctx.isOutputConsumed) {
+      tx.transferObjects([coin], ctx.sender);
+    }
+    return {
+      preview: { toolName: "withdraw", effectiveAmount, asset },
+      outputCoin: coin
+    };
   },
   borrow: async (tx, input, ctx) => {
     const asset = resolveSaveableAsset(input.asset);
@@ -7529,8 +7539,13 @@ var WRITE_APPENDER_REGISTRY = {
     if (ctx.feeHooks?.borrow) {
       await ctx.feeHooks.borrow({ tx, coin, input, sender: ctx.sender });
     }
-    tx.transferObjects([coin], ctx.sender);
-    return { toolName: "borrow", effectiveAmount: input.amount, asset };
+    if (!ctx.isOutputConsumed) {
+      tx.transferObjects([coin], ctx.sender);
+    }
+    return {
+      preview: { toolName: "borrow", effectiveAmount: input.amount, asset },
+      outputCoin: coin
+    };
   },
   repay_debt: async (tx, input, ctx) => {
     const asset = resolveSaveableAsset(input.asset);
@@ -7539,21 +7554,26 @@ var WRITE_APPENDER_REGISTRY = {
       throw new exports.T2000Error("INVALID_AMOUNT", "Repay amount must be greater than zero");
     }
     const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
-    const { coin, effectiveAmount } = await selectAndSplitCoin(
-      tx,
-      ctx.client,
-      ctx.sender,
-      assetInfo.type,
-      rawAmount
-    );
+    let coin;
+    let effectiveAmount;
+    if (ctx.chainedCoin) {
+      coin = ctx.chainedCoin;
+      effectiveAmount = rawAmount;
+    } else {
+      const r = await selectAndSplitCoin(tx, ctx.client, ctx.sender, assetInfo.type, rawAmount);
+      coin = r.coin;
+      effectiveAmount = r.effectiveAmount;
+    }
     await addRepayToTx(tx, ctx.client, ctx.sender, coin, {
       asset,
       skipOracle: ctx.sponsoredContext
     });
     return {
-      toolName: "repay_debt",
-      effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
-      asset
+      preview: {
+        toolName: "repay_debt",
+        effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
+        asset
+      }
     };
   },
   send_transfer: async (tx, input, ctx) => {
@@ -7569,7 +7589,10 @@ var WRITE_APPENDER_REGISTRY = {
     const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
     let coin;
     let effectiveRaw;
-    if (asset === "SUI") {
+    if (ctx.chainedCoin) {
+      coin = ctx.chainedCoin;
+      effectiveRaw = rawAmount;
+    } else if (asset === "SUI") {
       const result = await selectSuiCoin(tx, ctx.client, ctx.sender, rawAmount, ctx.sponsoredContext);
       coin = result.coin;
       effectiveRaw = result.effectiveAmount;
@@ -7580,10 +7603,12 @@ var WRITE_APPENDER_REGISTRY = {
     }
     addSendToTx(tx, coin, recipient);
     return {
-      toolName: "send_transfer",
-      effectiveAmount: Number(effectiveRaw) / 10 ** assetInfo.decimals,
-      recipient,
-      asset
+      preview: {
+        toolName: "send_transfer",
+        effectiveAmount: Number(effectiveRaw) / 10 ** assetInfo.decimals,
+        recipient,
+        asset
+      }
     };
   },
   swap_execute: async (tx, input, ctx) => {
@@ -7603,37 +7628,59 @@ var WRITE_APPENDER_REGISTRY = {
       slippage: input.slippage,
       byAmountIn: input.byAmountIn,
       overlayFee: ctx.overlayFee,
-      providers
+      providers,
+      inputCoin: ctx.chainedCoin
     });
-    tx.transferObjects([result.coin], ctx.sender);
+    if (!ctx.isOutputConsumed) {
+      tx.transferObjects([result.coin], ctx.sender);
+    }
     return {
-      toolName: "swap_execute",
-      effectiveAmountIn: result.effectiveAmountIn,
-      expectedAmountOut: result.expectedAmountOut,
-      route: result.route
+      preview: {
+        toolName: "swap_execute",
+        effectiveAmountIn: result.effectiveAmountIn,
+        expectedAmountOut: result.expectedAmountOut,
+        route: result.route
+      },
+      outputCoin: result.coin
     };
   },
   claim_rewards: async (tx, _input, ctx) => {
     const rewards = await addClaimRewardsToTx(tx, ctx.client, ctx.sender);
-    return { toolName: "claim_rewards", rewards };
+    return { preview: { toolName: "claim_rewards", rewards } };
   },
   volo_stake: async (tx, input, ctx) => {
     if (input.amountSui <= 0) {
       throw new exports.T2000Error("INVALID_AMOUNT", "Stake amount must be greater than zero");
     }
     const amountMist = BigInt(Math.floor(input.amountSui * 1e9));
-    const result = await addStakeVSuiToTx(tx, ctx.client, ctx.sender, { amountMist });
-    tx.transferObjects([result.coin], ctx.sender);
-    return { toolName: "volo_stake", effectiveAmountMist: result.effectiveAmountMist };
+    const result = await addStakeVSuiToTx(tx, ctx.client, ctx.sender, {
+      amountMist,
+      inputCoin: ctx.chainedCoin
+    });
+    if (!ctx.isOutputConsumed) {
+      tx.transferObjects([result.coin], ctx.sender);
+    }
+    return {
+      preview: { toolName: "volo_stake", effectiveAmountMist: result.effectiveAmountMist },
+      outputCoin: result.coin
+    };
   },
   volo_unstake: async (tx, input, ctx) => {
     const amountMist = input.amountVSui === "all" ? "all" : BigInt(Math.floor(input.amountVSui * 1e9));
     if (amountMist !== "all" && amountMist <= 0n) {
       throw new exports.T2000Error("INVALID_AMOUNT", "Unstake amount must be greater than zero");
     }
-    const result = await addUnstakeVSuiToTx(tx, ctx.client, ctx.sender, { amountMist });
-    tx.transferObjects([result.coin], ctx.sender);
-    return { toolName: "volo_unstake", effectiveAmountMist: result.effectiveAmountMist };
+    const result = await addUnstakeVSuiToTx(tx, ctx.client, ctx.sender, {
+      amountMist,
+      inputCoin: ctx.chainedCoin
+    });
+    if (!ctx.isOutputConsumed) {
+      tx.transferObjects([result.coin], ctx.sender);
+    }
+    return {
+      preview: { toolName: "volo_unstake", effectiveAmountMist: result.effectiveAmountMist },
+      outputCoin: result.coin
+    };
   }
 };
 function deriveAllowedAddressesFromPtb(tx) {
@@ -7672,15 +7719,38 @@ function base64ToBytes(b64) {
 async function composeTx(opts) {
   const tx = new transactions.Transaction();
   tx.setSender(opts.sender);
-  const ctx = {
+  const baseCtx = {
     client: opts.client,
     sender: opts.sender,
     sponsoredContext: opts.sponsoredContext ?? false,
     overlayFee: opts.overlayFee,
     feeHooks: opts.feeHooks
   };
+  const consumedSteps = /* @__PURE__ */ new Set();
+  for (let i = 0; i < opts.steps.length; i++) {
+    const step = opts.steps[i];
+    const stepWithChain = step;
+    const idx = stepWithChain.inputCoinFromStep;
+    if (idx === void 0) continue;
+    if (!Number.isInteger(idx) || idx < 0 || idx >= i) {
+      throw new exports.T2000Error(
+        "CHAIN_MODE_INVALID",
+        `Step ${i} (${step.toolName}) has inputCoinFromStep=${idx}, which must be a non-negative integer < ${i} (forward-only references).`
+      );
+    }
+    const producer = opts.steps[idx];
+    if (producer.toolName === "save_deposit" || producer.toolName === "repay_debt" || producer.toolName === "send_transfer" || producer.toolName === "claim_rewards") {
+      throw new exports.T2000Error(
+        "CHAIN_MODE_INVALID",
+        `Step ${i} (${step.toolName}) references step ${idx} (${producer.toolName}) as producer, but '${producer.toolName}' is a terminal consumer that does not produce a chainable coin handle. Allowed producers: withdraw, borrow, swap_execute, volo_stake, volo_unstake.`
+      );
+    }
+    consumedSteps.add(idx);
+  }
+  const priorOutputs = [];
   const previews = [];
-  for (const step of opts.steps) {
+  for (let i = 0; i < opts.steps.length; i++) {
+    const step = opts.steps[i];
     const appender = WRITE_APPENDER_REGISTRY[step.toolName];
     if (!appender) {
       throw new exports.T2000Error(
@@ -7688,8 +7758,26 @@ async function composeTx(opts) {
         `No fragment appender registered for tool '${step.toolName}'. Allowed: ${Object.keys(WRITE_APPENDER_REGISTRY).join(", ")}`
       );
     }
-    const preview = await appender(tx, step.input, ctx);
-    previews.push(preview);
+    const stepWithChain = step;
+    let chainedCoin;
+    if (stepWithChain.inputCoinFromStep !== void 0) {
+      const upstream = priorOutputs[stepWithChain.inputCoinFromStep];
+      if (!upstream) {
+        throw new exports.T2000Error(
+          "CHAIN_MODE_INVALID",
+          `Step ${i} (${step.toolName}) expected a coin handle from step ${stepWithChain.inputCoinFromStep}, but the producer did not return one.`
+        );
+      }
+      chainedCoin = upstream;
+    }
+    const stepCtx = {
+      ...baseCtx,
+      chainedCoin,
+      isOutputConsumed: consumedSteps.has(i)
+    };
+    const result = await appender(tx, step.input, stepCtx);
+    priorOutputs.push(result.outputCoin ?? null);
+    previews.push(result.preview);
   }
   const txKindBytes = await tx.build({ client: opts.client, onlyTransactionKind: true });
   const derivedAllowedAddresses = deriveAllowedAddressesFromPtb(tx);