@t2000/sdk 0.2.6 → 0.3.0

package/README.md

@@ -111,6 +111,14 @@ const agent = T2000.fromPrivateKey('suiprivkey1q...');
 | `agent.deposit()` | Wallet address + funding instructions | `DepositInfo` |
 | `agent.history({ limit? })` | Transaction history (default: all) | `TransactionRecord[]` |
 
+### Sentinel Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `agent.sentinelList()` | List active sentinels with prize pools | `SentinelAgent[]` |
+| `agent.sentinelInfo(id)` | Get sentinel details (from API or on-chain) | `SentinelAgent` |
+| `agent.sentinelAttack(id, prompt, fee?)` | Full attack flow: request → TEE → settle | `SentinelAttackResult` |
+
 ### Key Management
 
 ```typescript

package/dist/index.cjs

@@ -12,6 +12,7 @@ var os = require('os');
 var transactions = require('@mysten/sui/transactions');
 var lending = require('@naviprotocol/lending');
 var suiClmmSdk = require('@cetusprotocol/sui-clmm-sdk');
+var bcs = require('@mysten/sui/bcs');
 
 // src/t2000.ts
 
@@ -39,14 +40,26 @@ var SUPPORTED_ASSETS = {
     symbol: "SUI"
   }
 };
-process.env.T2000_PACKAGE_ID ?? "0x51c44bb2ad3ba608cf9adbc6e37ee67268ef9313a4ff70957d4c6e7955dc7eef";
-process.env.T2000_CONFIG_ID ?? "0xd30408960ac38eced670acc102df9e178b5b46b3a8c0e96a53ec2fd3f39b5936";
-process.env.T2000_TREASURY_ID ?? "0x2398c2759cfce40f1b0f2b3e524eeba9e8f6428fcb1d1e39235dd042d48defc8";
+var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
+var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
+var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
 var DEFAULT_NETWORK = "mainnet";
 var DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
 var DEFAULT_KEY_PATH = "~/.t2000/wallet.key";
 var API_BASE_URL = process.env.T2000_API_URL ?? "https://api.t2000.ai";
 var CETUS_USDC_SUI_POOL = "0x51e883ba7c0b566a26cbc8a94cd33eb0abd418a77cc1e60ad22fd9b1f29cd2ab";
+var SENTINEL = {
+  PACKAGE: "0x88b83f36dafcd5f6dcdcf1d2cb5889b03f61264ab3cee9cae35db7aa940a21b7",
+  AGENT_REGISTRY: "0xc47564f5f14c12b31e0dfa1a3dc99a6380a1edf8929c28cb0eaa3359c8db36ac",
+  ENCLAVE: "0xfb1261aeb9583514cb1341a548a5ec12d1231bd96af22215f1792617a93e1213",
+  PROTOCOL_CONFIG: "0x2fa4fa4a1dd0498612304635ff9334e1b922e78af325000e9d9c0e88adea459f",
+  TEE_API: "https://app.suisentinel.xyz/api/consume-prompt",
+  SENTINELS_API: "https://api.suisentinel.xyz/agents/mainnet",
+  RANDOM: "0x8",
+  MIN_FEE_MIST: 100000000n,
+  // 0.1 SUI
+  MAX_PROMPT_TOKENS: 600
+};
 
 // src/errors.ts
 var T2000Error = class extends Error {
@@ -89,7 +102,8 @@ function mapMoveAbortCode(code) {
     6: "Not authorized",
     7: "Package version mismatch \u2014 upgrade required",
     8: "Timelock is active \u2014 wait for expiry",
-    9: "No pending change to execute"
+    9: "No pending change to execute",
+    10: "Already at current version"
   };
   return abortMessages[code] ?? `Move abort code: ${code}`;
 }
@@ -360,6 +374,61 @@ function inferAction(txBlock) {
   if (kind === "ProgrammableTransaction") return "transaction";
   return kind ?? "unknown";
 }
+
+// src/protocols/protocolFee.ts
+var FEE_RATES = {
+  save: SAVE_FEE_BPS,
+  swap: SWAP_FEE_BPS,
+  borrow: BORROW_FEE_BPS
+};
+var OP_CODES = {
+  save: 0,
+  swap: 1,
+  borrow: 2
+};
+function calculateFee(operation, amount) {
+  const bps = FEE_RATES[operation];
+  const feeAmount = amount * Number(bps) / Number(BPS_DENOMINATOR);
+  const rawAmount = usdcToRaw(feeAmount);
+  return {
+    amount: feeAmount,
+    asset: "USDC",
+    rate: Number(bps) / Number(BPS_DENOMINATOR),
+    rawAmount
+  };
+}
+function addCollectFeeToTx(tx, paymentCoin, operation) {
+  const bps = FEE_RATES[operation];
+  if (bps <= 0n) return;
+  tx.moveCall({
+    target: `${T2000_PACKAGE_ID}::treasury::collect_fee`,
+    typeArguments: [SUPPORTED_ASSETS.USDC.type],
+    arguments: [
+      tx.object(T2000_TREASURY_ID),
+      tx.object(T2000_CONFIG_ID),
+      paymentCoin,
+      tx.pure.u8(OP_CODES[operation])
+    ]
+  });
+}
+async function reportFee(agentAddress, operation, feeAmount, feeRate, txDigest) {
+  try {
+    await fetch(`${API_BASE_URL}/api/fees`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        agentAddress,
+        operation,
+        feeAmount: feeAmount.toString(),
+        feeRate: feeRate.toString(),
+        txDigest
+      })
+    });
+  } catch {
+  }
+}
+
+// src/protocols/navi.ts
 var ENV = { env: "prod" };
 var USDC_TYPE = SUPPORTED_ASSETS.USDC.type;
 var RATE_DECIMALS = 27;
@@ -402,7 +471,7 @@ async function updateOracle(tx, client, address) {
   } catch {
   }
 }
-async function buildSaveTx(client, address, amount) {
+async function buildSaveTx(client, address, amount, options = {}) {
   const rawAmount = Number(usdcToRaw(amount));
   const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
   if (!coins || coins.length === 0) {
@@ -411,6 +480,9 @@ async function buildSaveTx(client, address, amount) {
   const tx = new transactions.Transaction();
   tx.setSender(address);
   const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, coinObj, "save");
+  }
   await lending.depositCoinPTB(tx, USDC_TYPE, coinObj, ENV);
   return tx;
 }
@@ -428,12 +500,15 @@ async function buildWithdrawTx(client, address, amount) {
   tx.transferObjects([withdrawnCoin], address);
   return { tx, effectiveAmount };
 }
-async function buildBorrowTx(client, address, amount) {
+async function buildBorrowTx(client, address, amount, options = {}) {
   const rawAmount = Number(usdcToRaw(amount));
   const tx = new transactions.Transaction();
   tx.setSender(address);
   await updateOracle(tx, client, address);
   const borrowedCoin = await lending.borrowCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, borrowedCoin, "borrow");
+  }
   tx.transferObjects([borrowedCoin], address);
   return tx;
 }
@@ -641,40 +716,6 @@ async function getSwapQuote(client, fromAsset, toAsset, amount) {
   }
 }
 
-// src/protocols/protocolFee.ts
-var FEE_RATES = {
-  save: SAVE_FEE_BPS,
-  swap: SWAP_FEE_BPS,
-  borrow: BORROW_FEE_BPS
-};
-function calculateFee(operation, amount) {
-  const bps = FEE_RATES[operation];
-  const feeAmount = amount * Number(bps) / Number(BPS_DENOMINATOR);
-  const rawAmount = usdcToRaw(feeAmount);
-  return {
-    amount: feeAmount,
-    asset: "USDC",
-    rate: Number(bps) / Number(BPS_DENOMINATOR),
-    rawAmount
-  };
-}
-async function reportFee(agentAddress, operation, feeAmount, feeRate, txDigest) {
-  try {
-    await fetch(`${API_BASE_URL}/api/fees`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        agentAddress,
-        operation,
-        feeAmount: feeAmount.toString(),
-        feeRate: feeRate.toString(),
-        txDigest
-      })
-    });
-  } catch {
-  }
-}
-
 // src/protocols/yieldTracker.ts
 async function getEarnings(client, keypair) {
   const hf = await getHealthFactor(client, keypair);
@@ -701,6 +742,190 @@ async function getFundStatus(client, keypair) {
     projectedMonthly: earnings.dailyEarning * 30
   };
 }
+function mapAgent(raw) {
+  return {
+    id: raw.agent_id,
+    objectId: raw.agent_object_id,
+    name: raw.agent_name,
+    model: raw.model ?? "unknown",
+    systemPrompt: raw.prompt,
+    attackFee: BigInt(raw.cost_per_message),
+    prizePool: BigInt(raw.total_balance),
+    totalAttacks: raw.total_attacks,
+    successfulBreaches: raw.successful_breaches ?? 0,
+    state: raw.state
+  };
+}
+async function listSentinels() {
+  const res = await fetch(SENTINEL.SENTINELS_API);
+  if (!res.ok) {
+    throw new T2000Error("SENTINEL_API_ERROR", `Sentinel API returned ${res.status}`);
+  }
+  const data = await res.json();
+  if (!Array.isArray(data.agents)) {
+    throw new T2000Error("SENTINEL_API_ERROR", "Unexpected API response shape");
+  }
+  return data.agents.filter((a) => a.state === "active").map(mapAgent);
+}
+async function getSentinelInfo(client, sentinelObjectId) {
+  const agents = await listSentinels();
+  const match = agents.find((a) => a.objectId === sentinelObjectId || a.id === sentinelObjectId);
+  if (match) return match;
+  const obj = await client.getObject({
+    id: sentinelObjectId,
+    options: { showContent: true, showType: true }
+  });
+  if (!obj.data) {
+    throw new T2000Error("SENTINEL_NOT_FOUND", `Sentinel ${sentinelObjectId} not found on-chain`);
+  }
+  const content = obj.data.content;
+  if (!content || content.dataType !== "moveObject") {
+    throw new T2000Error("SENTINEL_NOT_FOUND", `Object ${sentinelObjectId} is not a Move object`);
+  }
+  const fields = content.fields;
+  return {
+    id: fields.id?.id ?? sentinelObjectId,
+    objectId: sentinelObjectId,
+    name: fields.name ?? "Unknown",
+    model: fields.model ?? "unknown",
+    systemPrompt: fields.system_prompt ?? "",
+    attackFee: BigInt(fields.cost_per_message ?? "0"),
+    prizePool: BigInt(fields.balance ?? "0"),
+    totalAttacks: Number(fields.total_attacks ?? "0"),
+    successfulBreaches: Number(fields.successful_breaches ?? "0"),
+    state: fields.state ?? "unknown"
+  };
+}
+async function requestAttack(client, signer, sentinelObjectId, feeMist) {
+  if (feeMist < SENTINEL.MIN_FEE_MIST) {
+    throw new T2000Error("INVALID_AMOUNT", `Attack fee must be at least 0.1 SUI (${SENTINEL.MIN_FEE_MIST} MIST)`);
+  }
+  const tx = new transactions.Transaction();
+  const [coin] = tx.splitCoins(tx.gas, [Number(feeMist)]);
+  const [attack2] = tx.moveCall({
+    target: `${SENTINEL.PACKAGE}::sentinel::request_attack`,
+    arguments: [
+      tx.object(SENTINEL.AGENT_REGISTRY),
+      tx.object(sentinelObjectId),
+      tx.object(SENTINEL.PROTOCOL_CONFIG),
+      coin,
+      tx.object(SENTINEL.RANDOM),
+      tx.object(CLOCK_ID)
+    ]
+  });
+  const address = signer.toSuiAddress();
+  tx.transferObjects([attack2], address);
+  const result = await client.signAndExecuteTransaction({
+    signer,
+    transaction: tx,
+    options: { showObjectChanges: true, showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const attackObj = result.objectChanges?.find(
+    (c) => c.type === "created" && c.objectType?.includes("::sentinel::Attack")
+  );
+  const attackObjectId = attackObj && "objectId" in attackObj ? attackObj.objectId : void 0;
+  if (!attackObjectId) {
+    throw new T2000Error("SENTINEL_TX_FAILED", "Attack object was not created \u2014 transaction may have failed");
+  }
+  return { attackObjectId, digest: result.digest };
+}
+async function submitPrompt(agentId, attackObjectId, prompt) {
+  const res = await fetch(SENTINEL.TEE_API, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      agent_id: agentId,
+      attack_object_id: attackObjectId,
+      message: prompt
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new T2000Error("SENTINEL_TEE_ERROR", `TEE returned ${res.status}: ${body.slice(0, 200)}`);
+  }
+  const raw = await res.json();
+  const envelope = raw.response ?? raw;
+  const data = envelope.data ?? envelope;
+  const signature = raw.signature ?? data.signature;
+  const timestampMs = envelope.timestamp_ms ?? data.timestamp_ms;
+  if (typeof signature !== "string") {
+    throw new T2000Error("SENTINEL_TEE_ERROR", "TEE response missing signature");
+  }
+  return {
+    success: data.success ?? data.is_success,
+    score: data.score,
+    agentResponse: data.agent_response,
+    juryResponse: data.jury_response,
+    funResponse: data.fun_response ?? "",
+    signature,
+    timestampMs
+  };
+}
+async function settleAttack(client, signer, sentinelObjectId, attackObjectId, prompt, verdict) {
+  const sigBytes = Array.from(Buffer.from(verdict.signature.replace(/^0x/, ""), "hex"));
+  const tx = new transactions.Transaction();
+  tx.moveCall({
+    target: `${SENTINEL.PACKAGE}::sentinel::consume_prompt`,
+    arguments: [
+      tx.object(SENTINEL.AGENT_REGISTRY),
+      tx.object(SENTINEL.PROTOCOL_CONFIG),
+      tx.object(sentinelObjectId),
+      tx.pure.bool(verdict.success),
+      tx.pure.string(verdict.agentResponse),
+      tx.pure.string(verdict.juryResponse),
+      tx.pure.string(verdict.funResponse),
+      tx.pure.string(prompt),
+      tx.pure.u8(verdict.score),
+      tx.pure.u64(verdict.timestampMs),
+      tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(sigBytes)),
+      tx.object(SENTINEL.ENCLAVE),
+      tx.object(attackObjectId),
+      tx.object(CLOCK_ID)
+    ]
+  });
+  const result = await client.signAndExecuteTransaction({
+    signer,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const txSuccess = result.effects?.status?.status === "success";
+  return { digest: result.digest, success: txSuccess };
+}
+async function attack(client, signer, sentinelId, prompt, feeMist) {
+  const sentinel = await getSentinelInfo(client, sentinelId);
+  const fee = feeMist ?? sentinel.attackFee;
+  if (fee < SENTINEL.MIN_FEE_MIST) {
+    throw new T2000Error("INVALID_AMOUNT", `Attack fee must be at least 0.1 SUI`);
+  }
+  const { attackObjectId, digest: requestTx } = await requestAttack(
+    client,
+    signer,
+    sentinel.objectId,
+    fee
+  );
+  const verdict = await submitPrompt(sentinel.id, attackObjectId, prompt);
+  const { digest: settleTx } = await settleAttack(
+    client,
+    signer,
+    sentinel.objectId,
+    attackObjectId,
+    prompt,
+    verdict
+  );
+  const won = verdict.success && verdict.score >= 70;
+  return {
+    attackObjectId,
+    sentinelId: sentinel.id,
+    prompt,
+    verdict,
+    requestTx,
+    settleTx,
+    won,
+    feePaid: Number(fee) / Number(MIST_PER_SUI)
+  };
+}
 function hasLeadingZeroBits(hash, bits) {
   const fullBytes = Math.floor(bits / 8);
   const remainingBits = bits % 8;
@@ -1083,12 +1308,12 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const gasResult = await executeWithGas(
       this.client,
       this.keypair,
-      () => buildSaveTx(this.client, this._address, saveAmount)
+      () => buildSaveTx(this.client, this._address, saveAmount, { collectFee: true })
     );
     const rates = await getRates(this.client);
     reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
     this.emitBalanceChange("USDC", saveAmount, "save", gasResult.digest);
-    let savingsBalance = saveAmount - fee.amount;
+    let savingsBalance = saveAmount;
     try {
       const positions = await this.positions();
       savingsBalance = positions.positions.filter((p) => p.type === "save").reduce((sum, p) => sum + p.amount, 0);
@@ -1172,7 +1397,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const gasResult = await executeWithGas(
       this.client,
       this.keypair,
-      () => buildBorrowTx(this.client, this._address, borrowAmount)
+      () => buildBorrowTx(this.client, this._address, borrowAmount, { collectFee: true })
     );
     const hf = await getHealthFactor(this.client, this.keypair);
     reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
@@ -1318,6 +1543,16 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   async fundStatus() {
     return getFundStatus(this.client, this.keypair);
   }
+  // -- Sentinel --
+  async sentinelList() {
+    return listSentinels();
+  }
+  async sentinelInfo(id) {
+    return getSentinelInfo(this.client, id);
+  }
+  async sentinelAttack(id, prompt, fee) {
+    return attack(this.client, this.keypair, id, prompt, fee);
+  }
   // -- Helpers --
   emitBalanceChange(asset, amount, cause, tx) {
     this.emit("balanceChange", { asset, previous: 0, current: 0, cause, tx });
@@ -1421,11 +1656,13 @@ exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
 exports.MIST_PER_SUI = MIST_PER_SUI;
+exports.SENTINEL = SENTINEL;
 exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
 exports.T2000 = T2000;
 exports.T2000Error = T2000Error;
 exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.addCollectFeeToTx = addCollectFeeToTx;
 exports.calculateFee = calculateFee;
 exports.executeAutoTopUp = executeAutoTopUp;
 exports.executeWithGas = executeWithGas;
@@ -1437,17 +1674,23 @@ exports.getAddress = getAddress;
 exports.getGasStatus = getGasStatus;
 exports.getPoolPrice = getPoolPrice;
 exports.getRates = getRates;
+exports.getSentinelInfo = getSentinelInfo;
 exports.getSwapQuote = getSwapQuote;
 exports.keypairFromPrivateKey = keypairFromPrivateKey;
+exports.listSentinels = listSentinels;
 exports.loadKey = loadKey;
 exports.mapMoveAbortCode = mapMoveAbortCode;
 exports.mapWalletError = mapWalletError;
 exports.mistToSui = mistToSui;
 exports.rawToUsdc = rawToUsdc;
+exports.requestAttack = requestAttack;
 exports.saveKey = saveKey;
+exports.sentinelAttack = attack;
+exports.settleAttack = settleAttack;
 exports.shouldAutoTopUp = shouldAutoTopUp;
 exports.simulateTransaction = simulateTransaction;
 exports.solveHashcash = solveHashcash;
+exports.submitPrompt = submitPrompt;
 exports.suiToMist = suiToMist;
 exports.throwIfSimulationFailed = throwIfSimulationFailed;
 exports.truncateAddress = truncateAddress;