@t2000/sdk 0.16.1 → 0.16.6

package/dist/index.d.cts

@@ -582,6 +582,13 @@ interface AutoTopUpResult {
     suiReceived: number;
 }
 declare function shouldAutoTopUp(client: SuiJsonRpcClient, address: string): Promise<boolean>;
+/**
+ * Self-fund a USDC→SUI swap to replenish gas.
+ *
+ * Uses the agent's remaining SUI to pay for the swap gas (~0.007 SUI).
+ * This avoids the chicken-and-egg problem of needing gas station sponsorship
+ * to get gas, and works even when the gas station is down.
+ */
 declare function executeAutoTopUp(client: SuiJsonRpcClient, keypair: Ed25519Keypair): Promise<AutoTopUpResult>;
 
 type GasRequestType = 'bootstrap' | 'auto-topup' | 'fallback';

package/dist/index.d.ts

@@ -582,6 +582,13 @@ interface AutoTopUpResult {
     suiReceived: number;
 }
 declare function shouldAutoTopUp(client: SuiJsonRpcClient, address: string): Promise<boolean>;
+/**
+ * Self-fund a USDC→SUI swap to replenish gas.
+ *
+ * Uses the agent's remaining SUI to pay for the swap gas (~0.007 SUI).
+ * This avoids the chicken-and-egg problem of needing gas station sponsorship
+ * to get gas, and works even when the gas station is down.
+ */
 declare function executeAutoTopUp(client: SuiJsonRpcClient, keypair: Ed25519Keypair): Promise<AutoTopUpResult>;
 
 type GasRequestType = 'bootstrap' | 'auto-topup' | 'fallback';

package/dist/index.js

@@ -2386,13 +2386,62 @@ function solveHashcash(challenge) {
   }
 }
 
+// src/gas/autoTopUp.ts
+var AUTO_TOPUP_MIN_SUI_FOR_GAS = 5000000n;
+async function shouldAutoTopUp(client, address) {
+  const [suiBalance, usdcBalance] = await Promise.all([
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type })
+  ]);
+  const suiRaw = BigInt(suiBalance.totalBalance);
+  const usdcRaw = BigInt(usdcBalance.totalBalance);
+  return suiRaw < AUTO_TOPUP_THRESHOLD && suiRaw >= AUTO_TOPUP_MIN_SUI_FOR_GAS && usdcRaw >= AUTO_TOPUP_MIN_USDC;
+}
+async function executeAutoTopUp(client, keypair) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const topupAmountHuman = Number(AUTO_TOPUP_AMOUNT) / 1e6;
+  const { tx } = await buildSwapTx({
+    client,
+    address,
+    fromAsset: "USDC",
+    toAsset: "SUI",
+    amount: topupAmountHuman
+  });
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true, showBalanceChanges: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  let suiReceived = 0;
+  if (result.balanceChanges) {
+    for (const change of result.balanceChanges) {
+      if (change.coinType === SUPPORTED_ASSETS.SUI.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === address) {
+        suiReceived += Number(change.amount) / Number(MIST_PER_SUI);
+      }
+    }
+  }
+  return {
+    success: true,
+    tx: result.digest,
+    usdcSpent: topupAmountHuman,
+    suiReceived: Math.abs(suiReceived)
+  };
+}
+
 // src/gas/gasStation.ts
-async function requestGasSponsorship(txJson, sender, type) {
-  const txBytes = Buffer.from(txJson).toString("base64");
+async function requestGasSponsorship(txJson, sender, type, txBcsBytes) {
+  const payload = { sender, type };
+  if (txBcsBytes) {
+    payload.txBcsBytes = txBcsBytes;
+  } else {
+    payload.txJson = txJson;
+    payload.txBytes = Buffer.from(txJson).toString("base64");
+  }
   const res = await fetch(`${API_BASE_URL}/api/gas`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ txJson, txBytes, sender, type })
+    body: JSON.stringify(payload)
   });
   const data = await res.json();
   if (!res.ok) {
@@ -2442,53 +2491,6 @@ async function getGasStatus(address) {
   return await res.json();
 }
 
-// src/gas/autoTopUp.ts
-async function shouldAutoTopUp(client, address) {
-  const [suiBalance, usdcBalance] = await Promise.all([
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type })
-  ]);
-  const suiRaw = BigInt(suiBalance.totalBalance);
-  const usdcRaw = BigInt(usdcBalance.totalBalance);
-  return suiRaw < AUTO_TOPUP_THRESHOLD && usdcRaw >= AUTO_TOPUP_MIN_USDC;
-}
-async function executeAutoTopUp(client, keypair) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const topupAmountHuman = Number(AUTO_TOPUP_AMOUNT) / 1e6;
-  const { tx } = await buildSwapTx({
-    client,
-    address,
-    fromAsset: "USDC",
-    toAsset: "SUI",
-    amount: topupAmountHuman
-  });
-  const txJson = tx.serialize();
-  const sponsoredResult = await requestGasSponsorship(txJson, address, "auto-topup");
-  const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
-  const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
-  const result = await client.executeTransactionBlock({
-    transactionBlock: sponsoredResult.txBytes,
-    signature: [agentSig, sponsoredResult.sponsorSignature],
-    options: { showEffects: true, showBalanceChanges: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  let suiReceived = 0;
-  if (result.balanceChanges) {
-    for (const change of result.balanceChanges) {
-      if (change.coinType === SUPPORTED_ASSETS.SUI.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === address) {
-        suiReceived += Number(change.amount) / Number(MIST_PER_SUI);
-      }
-    }
-  }
-  reportGasUsage(address, result.digest, 0, 0, "auto-topup");
-  return {
-    success: true,
-    tx: result.digest,
-    usdcSpent: topupAmountHuman,
-    suiReceived: Math.abs(suiReceived)
-  };
-}
-
 // src/gas/manager.ts
 function extractGasCost(effects) {
   if (!effects?.gasUsed) return 0;
@@ -2516,11 +2518,12 @@ async function trySelfFunded(client, keypair, tx) {
     gasCostSui: extractGasCost(result.effects)
   };
 }
-async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
+async function tryAutoTopUpThenSelfFund(client, keypair, buildTx) {
   const address = keypair.getPublicKey().toSuiAddress();
   const canTopUp = await shouldAutoTopUp(client, address);
   if (!canTopUp) return null;
   await executeAutoTopUp(client, keypair);
+  const tx = await buildTx();
   tx.setSender(address);
   const result = await client.signAndExecuteTransaction({
     signer: keypair,
@@ -2538,8 +2541,15 @@ async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
 async function trySponsored(client, keypair, tx) {
   const address = keypair.getPublicKey().toSuiAddress();
   tx.setSender(address);
-  const txJson = tx.serialize();
-  const sponsoredResult = await requestGasSponsorship(txJson, address);
+  let txJson;
+  let txBcsBase64;
+  try {
+    txJson = tx.serialize();
+  } catch {
+    const bcsBytes = await tx.build({ client });
+    txBcsBase64 = Buffer.from(bcsBytes).toString("base64");
+  }
+  const sponsoredResult = await requestGasSponsorship(txJson ?? "", address, void 0, txBcsBase64);
   const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
   const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
   const result = await client.executeTransactionBlock({
@@ -2575,8 +2585,7 @@ async function executeWithGas(client, keypair, buildTx, options) {
     errors.push(`self-funded: ${msg}`);
   }
   try {
-    const tx = await buildTx();
-    const result = await tryAutoTopUpThenSelfFund(client, keypair, tx);
+    const result = await tryAutoTopUpThenSelfFund(client, keypair, buildTx);
     if (result) return result;
     errors.push("auto-topup: not eligible (low USDC or sufficient SUI)");
   } catch (err) {
@@ -4338,20 +4347,22 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
     if (!params.usdAmount || params.usdAmount <= 0) {
       throw new T2000Error("INVALID_AMOUNT", "Strategy investment must be > $0");
     }
+    this.enforcer.check({ operation: "invest", amount: params.usdAmount });
     const bal = await queryBalance(this.client, this._address);
     if (bal.available < params.usdAmount) {
       throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance. Available: $${bal.available.toFixed(2)}, requested: $${params.usdAmount.toFixed(2)}`);
     }
     const buys = [];
+    const allocEntries = Object.entries(definition.allocations);
     if (params.dryRun) {
-      const swapAdapter = this.registry.listSwap()[0];
-      for (const [asset, pct] of Object.entries(definition.allocations)) {
+      const swapAdapter2 = this.registry.listSwap()[0];
+      for (const [asset, pct] of allocEntries) {
         const assetUsd = params.usdAmount * (pct / 100);
         let estAmount = 0;
         let estPrice = 0;
         try {
-          if (swapAdapter) {
-            const quote = await swapAdapter.getQuote("USDC", asset, assetUsd);
+          if (swapAdapter2) {
+            const quote = await swapAdapter2.getQuote("USDC", asset, assetUsd);
             estAmount = quote.expectedOutput;
             estPrice = assetUsd / estAmount;
           }
@@ -4361,27 +4372,76 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       }
       return { success: true, strategy: params.strategy, totalInvested: params.usdAmount, buys, gasCost: 0, gasMethod: "self-funded" };
     }
-    let totalGas = 0;
-    let gasMethod = "self-funded";
-    for (const [asset, pct] of Object.entries(definition.allocations)) {
-      const assetUsd = params.usdAmount * (pct / 100);
-      const result = await this.investBuy({ asset, usdAmount: assetUsd });
+    const swapAdapter = this.registry.listSwap()[0];
+    if (!swapAdapter?.addSwapToTx) {
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
+    }
+    const swapMetas = [];
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const tx = new Transaction();
+      tx.setSender(this._address);
+      const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+      if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+      const mergedUsdc = this._mergeCoinsInTx(tx, usdcCoins);
+      const splitAmounts = allocEntries.map(
+        ([, pct]) => BigInt(Math.floor(params.usdAmount * (pct / 100) * 10 ** SUPPORTED_ASSETS.USDC.decimals))
+      );
+      const splitCoins = tx.splitCoins(mergedUsdc, splitAmounts);
+      const outputCoins = [];
+      for (let i = 0; i < allocEntries.length; i++) {
+        const [asset] = allocEntries[i];
+        const assetUsd = params.usdAmount * (allocEntries[i][1] / 100);
+        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+          tx,
+          this._address,
+          splitCoins[i],
+          "USDC",
+          asset,
+          assetUsd
+        );
+        outputCoins.push(outputCoin);
+        swapMetas.push({ asset, usdAmount: assetUsd, estimatedOut, toDecimals });
+      }
+      tx.transferObjects(outputCoins, this._address);
+      return tx;
+    });
+    const digest = gasResult.digest;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const meta of swapMetas) {
+      const amount = meta.estimatedOut / 10 ** meta.toDecimals;
+      const price = meta.usdAmount / amount;
+      this.portfolio.recordBuy({
+        id: `inv_${Date.now()}_${meta.asset}`,
+        type: "buy",
+        asset: meta.asset,
+        amount,
+        price,
+        usdValue: meta.usdAmount,
+        fee: 0,
+        tx: digest,
+        timestamp: now
+      });
       this.portfolio.recordStrategyBuy(params.strategy, {
-        id: `strat_${Date.now()}_${asset}`,
+        id: `strat_${Date.now()}_${meta.asset}`,
         type: "buy",
-        asset,
-        amount: result.amount,
-        price: result.price,
-        usdValue: assetUsd,
-        fee: result.fee,
-        tx: result.tx,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        asset: meta.asset,
+        amount,
+        price,
+        usdValue: meta.usdAmount,
+        fee: 0,
+        tx: digest,
+        timestamp: now
       });
-      buys.push({ asset, usdAmount: assetUsd, amount: result.amount, price: result.price, tx: result.tx });
-      totalGas += result.gasCost;
-      gasMethod = result.gasMethod;
+      buys.push({ asset: meta.asset, usdAmount: meta.usdAmount, amount, price, tx: digest });
     }
-    return { success: true, strategy: params.strategy, totalInvested: params.usdAmount, buys, gasCost: totalGas, gasMethod };
+    return {
+      success: true,
+      strategy: params.strategy,
+      totalInvested: params.usdAmount,
+      buys,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async sellStrategy(params) {
     this.enforcer.assertNotLocked();