@t2000/sdk 0.16.1 → 0.16.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 t2000
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -71,6 +71,22 @@ await agent.investUnearn({ asset: 'SUI' });
 
 // Sell position (auto-withdraws if earning first)
 await agent.investSell({ asset: 'SUI', usdAmount: 'all' });
+
+// Buy into a strategy (single atomic PTB)
+await agent.investStrategy({ strategy: 'bluechip', usdAmount: 200 });
+
+// Check strategy status
+const status = await agent.getStrategyStatus({ strategy: 'bluechip' });
+console.log(`Total value: $${status.totalValue}`);
+
+// Rebalance strategy to target weights
+await agent.rebalanceStrategy({ strategy: 'bluechip' });
+
+// Set up dollar-cost averaging
+await agent.setupAutoInvest({ amount: 50, frequency: 'weekly', strategy: 'bluechip' });
+
+// Run pending DCA purchases
+await agent.runAutoInvest();
 ```
 
 ## API Reference
@@ -179,7 +195,28 @@ const agent = T2000.fromPrivateKey('suiprivkey1q...');
 | `agent.investSell({ asset, usdAmount \| 'all', maxSlippage? })` | Sell crypto back to USDC (auto-withdraws if earning) | `InvestResult` |
 | `agent.investEarn({ asset })` | Deposit invested asset into best-rate lending for yield | `InvestEarnResult` |
 | `agent.investUnearn({ asset })` | Withdraw from lending, keep in portfolio | `InvestUnearnResult` |
-| `agent.getPortfolio()` | Investment positions + P&L | `PortfolioResult` |
+| `agent.getPortfolio()` | Investment positions + P&L (grouped by strategy) | `PortfolioResult` |
+
+### Strategy Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `agent.investStrategy({ strategy, usdAmount, maxSlippage?, dryRun? })` | Buy into a strategy (single atomic PTB) | `StrategyBuyResult` |
+| `agent.sellStrategy({ strategy, maxSlippage? })` | Sell all positions in a strategy | `StrategySellResult` |
+| `agent.rebalanceStrategy({ strategy, maxSlippage?, driftThreshold? })` | Rebalance to target weights | `StrategyRebalanceResult` |
+| `agent.getStrategyStatus({ strategy })` | Positions, weights, drift for a strategy | `StrategyStatusResult` |
+| `agent.getStrategies()` | List all available strategies | `StrategyDefinition[]` |
+| `agent.createStrategy({ name, allocations, description? })` | Create a custom strategy | `StrategyDefinition` |
+| `agent.deleteStrategy({ name })` | Delete a custom strategy (no active positions) | `void` |
+
+### Auto-Invest (DCA) Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `agent.setupAutoInvest({ amount, frequency, strategy?, asset? })` | Schedule recurring purchases | `AutoInvestSchedule` |
+| `agent.getAutoInvestStatus()` | View schedules and pending runs | `AutoInvestStatus` |
+| `agent.runAutoInvest()` | Execute all pending DCA purchases | `AutoInvestRunResult` |
+| `agent.stopAutoInvest({ id? })` | Stop one or all schedules | `void` |
 
 ### Key Management
 
@@ -383,7 +420,7 @@ Fees are collected by the t2000 protocol treasury on-chain.
 
 ## MCP Server
 
-The SDK powers the [`@t2000/mcp`](https://www.npmjs.com/package/@t2000/mcp) server — 19 tools and 6 prompts for Claude Desktop, Cursor, and any MCP-compatible AI platform. Run `t2000 mcp` to start.
+The SDK powers the [`@t2000/mcp`](https://www.npmjs.com/package/@t2000/mcp) server — 21 tools and 6 prompts for Claude Desktop, Cursor, and any MCP-compatible AI platform. Run `t2000 mcp` to start.
 
 ## License
 

package/dist/index.cjs

@@ -2388,13 +2388,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) {
@@ -2444,53 +2493,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;
@@ -2518,11 +2520,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,
@@ -2540,8 +2543,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({
@@ -2577,8 +2587,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) {
@@ -4340,20 +4349,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;
           }
@@ -4363,27 +4374,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 transactions.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();