@t2000/sdk 0.10.4 → 0.11.1

package/dist/index.cjs

@@ -12,6 +12,7 @@ var path = require('path');
 var os = require('os');
 var bcs = require('@mysten/sui/bcs');
 var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
+var fs = require('fs');
 
 // src/t2000.ts
 
@@ -2496,7 +2497,10 @@ async function trySponsored(client, keypair, tx) {
     gasCostSui: gasCost
   };
 }
-async function executeWithGas(client, keypair, buildTx) {
+async function executeWithGas(client, keypair, buildTx, options) {
+  if (options?.enforcer && options?.metadata) {
+    options.enforcer.check(options.metadata);
+  }
   const errors = [];
   try {
     const tx = await buildTx();
@@ -2533,18 +2537,182 @@ async function executeWithGas(client, keypair, buildTx) {
   );
 }
 
-// src/t2000.ts
+// src/safeguards/types.ts
+var OUTBOUND_OPS = /* @__PURE__ */ new Set([
+  "send",
+  "pay",
+  "sentinel"
+]);
+var DEFAULT_SAFEGUARD_CONFIG = {
+  locked: false,
+  maxPerTx: 0,
+  maxDailySend: 0,
+  dailyUsed: 0,
+  dailyResetDate: ""
+};
+
+// src/safeguards/errors.ts
+var SafeguardError = class extends T2000Error {
+  rule;
+  details;
+  constructor(rule, details, message) {
+    const msg = message ?? buildMessage(rule, details);
+    super("SAFEGUARD_BLOCKED", msg, { rule, ...details });
+    this.name = "SafeguardError";
+    this.rule = rule;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      error: "SAFEGUARD_BLOCKED",
+      message: this.message,
+      retryable: this.retryable,
+      data: { rule: this.rule, ...this.details }
+    };
+  }
+};
+function buildMessage(rule, details) {
+  switch (rule) {
+    case "locked":
+      return "Agent is locked. All operations are frozen.";
+    case "maxPerTx":
+      return `Amount $${(details.attempted ?? 0).toFixed(2)} exceeds per-transaction limit ($${(details.limit ?? 0).toFixed(2)})`;
+    case "maxDailySend":
+      return `Daily send limit reached ($${(details.current ?? 0).toFixed(2)}/$${(details.limit ?? 0).toFixed(2)} used today)`;
+  }
+}
+
+// src/safeguards/enforcer.ts
+var SafeguardEnforcer = class {
+  config;
+  configPath;
+  constructor(configDir) {
+    this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
+    this.configPath = configDir ? path.join(configDir, "config.json") : null;
+  }
+  load() {
+    if (!this.configPath) return;
+    try {
+      const raw = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
+      this.config = {
+        ...DEFAULT_SAFEGUARD_CONFIG,
+        locked: raw.locked ?? false,
+        maxPerTx: raw.maxPerTx ?? 0,
+        maxDailySend: raw.maxDailySend ?? 0,
+        dailyUsed: raw.dailyUsed ?? 0,
+        dailyResetDate: raw.dailyResetDate ?? ""
+      };
+    } catch {
+      this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
+    }
+  }
+  assertNotLocked() {
+    this.load();
+    if (this.config.locked) {
+      throw new SafeguardError("locked", {});
+    }
+  }
+  check(metadata) {
+    this.load();
+    if (this.config.locked) {
+      throw new SafeguardError("locked", {});
+    }
+    if (!OUTBOUND_OPS.has(metadata.operation)) return;
+    const amount = metadata.amount ?? 0;
+    if (this.config.maxPerTx > 0 && amount > this.config.maxPerTx) {
+      throw new SafeguardError("maxPerTx", {
+        attempted: amount,
+        limit: this.config.maxPerTx
+      });
+    }
+    this.resetDailyIfNewDay();
+    if (this.config.maxDailySend > 0 && this.config.dailyUsed + amount > this.config.maxDailySend) {
+      throw new SafeguardError("maxDailySend", {
+        attempted: amount,
+        limit: this.config.maxDailySend,
+        current: this.config.dailyUsed
+      });
+    }
+  }
+  recordUsage(amount) {
+    this.resetDailyIfNewDay();
+    this.config.dailyUsed += amount;
+    this.save();
+  }
+  lock() {
+    this.config.locked = true;
+    this.save();
+  }
+  unlock() {
+    this.config.locked = false;
+    this.save();
+  }
+  set(key, value) {
+    if (key === "locked" && typeof value === "boolean") {
+      this.config.locked = value;
+    } else if (key === "maxPerTx" && typeof value === "number") {
+      this.config.maxPerTx = value;
+    } else if (key === "maxDailySend" && typeof value === "number") {
+      this.config.maxDailySend = value;
+    }
+    this.save();
+  }
+  getConfig() {
+    this.load();
+    this.resetDailyIfNewDay();
+    return { ...this.config };
+  }
+  isConfigured() {
+    return this.config.maxPerTx > 0 || this.config.maxDailySend > 0;
+  }
+  resetDailyIfNewDay() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (this.config.dailyResetDate !== today) {
+      this.config.dailyUsed = 0;
+      this.config.dailyResetDate = today;
+      this.save();
+    }
+  }
+  save() {
+    if (!this.configPath) return;
+    try {
+      let existing = {};
+      try {
+        existing = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
+      } catch {
+      }
+      const merged = {
+        ...existing,
+        locked: this.config.locked,
+        maxPerTx: this.config.maxPerTx,
+        maxDailySend: this.config.maxDailySend,
+        dailyUsed: this.config.dailyUsed,
+        dailyResetDate: this.config.dailyResetDate
+      };
+      const dir = this.configPath.replace(/[/\\][^/\\]+$/, "");
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(merged, null, 2) + "\n");
+    } catch {
+    }
+  }
+};
+var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
 var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   keypair;
   client;
   _address;
   registry;
-  constructor(keypair, client, registry) {
+  enforcer;
+  constructor(keypair, client, registry, configDir) {
     super();
     this.keypair = keypair;
     this.client = client;
     this._address = getAddress(keypair);
     this.registry = registry ?? _T2000.createDefaultRegistry(client);
+    this.enforcer = new SafeguardEnforcer(configDir);
+    this.enforcer.load();
   }
   static createDefaultRegistry(client) {
     const registry = new ProtocolRegistry();
@@ -2568,7 +2736,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       if (secret) {
         await saveKey(keypair2, secret, keyPath);
       }
-      return new _T2000(keypair2, client);
+      return new _T2000(keypair2, client, void 0, DEFAULT_CONFIG_DIR);
     }
     const exists = await walletExists(keyPath);
     if (!exists) {
@@ -2581,7 +2749,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       throw new T2000Error("WALLET_LOCKED", "PIN required to unlock wallet");
     }
     const keypair = await loadKey(secret, keyPath);
-    return new _T2000(keypair, client);
+    return new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
   }
   static fromPrivateKey(privateKey, options = {}) {
     const keypair = keypairFromPrivateKey(privateKey);
@@ -2593,7 +2761,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const keypair = generateKeypair();
     await saveKey(keypair, secret, options.keyPath);
     const client = getSuiClient();
-    const agent = new _T2000(keypair, client);
+    const agent = new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
     const address = agent.address();
     let sponsored = false;
     if (options.sponsored !== false) {
@@ -2619,6 +2787,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return this._address;
   }
   async send(params) {
+    this.enforcer.assertNotLocked();
     const asset = params.asset ?? "USDC";
     if (!(asset in SUPPORTED_ASSETS)) {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
@@ -2628,8 +2797,10 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const gasResult = await executeWithGas(
       this.client,
       this.keypair,
-      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset })
+      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset }),
+      { metadata: { operation: "send", amount: sendAmount }, enforcer: this.enforcer }
     );
+    this.enforcer.recordUsage(sendAmount);
     const balance = await this.balance();
     this.emitBalanceChange(asset, sendAmount, "send", gasResult.digest);
     return {
@@ -2685,6 +2856,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Savings --
   async save(params) {
+    this.enforcer.assertNotLocked();
     const asset = "USDC";
     const bal = await queryBalance(this.client, this._address);
     const usdcBalance = bal.stables.USDC ?? 0;
@@ -2779,6 +2951,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async withdraw(params) {
+    this.enforcer.assertNotLocked();
     if (params.amount === "all" && !params.protocol) {
       return this.withdrawAllProtocols();
     }
@@ -3016,6 +3189,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Borrowing --
   async borrow(params) {
+    this.enforcer.assertNotLocked();
     const asset = "USDC";
     const adapter = await this.resolveLending(params.protocol, asset, "borrow");
     const maxResult = await adapter.maxBorrow(this._address, asset);
@@ -3048,6 +3222,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async repay(params) {
+    this.enforcer.assertNotLocked();
     const allPositions = await this.registry.allPositions(this._address);
     const borrows = [];
     for (const pos of allPositions) {
@@ -3201,6 +3376,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Exchange --
   async exchange(params) {
+    this.enforcer.assertNotLocked();
     const fromAsset = params.from;
     const toAsset = params.to;
     if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
@@ -3301,6 +3477,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return this.registry.allRatesAcrossAssets();
   }
   async rebalance(opts = {}) {
+    this.enforcer.assertNotLocked();
     const dryRun = opts.dryRun ?? false;
     const minYieldDiff = opts.minYieldDiff ?? 0.5;
     const maxBreakEven = opts.maxBreakEven ?? 30;
@@ -3582,6 +3759,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return getSentinelInfo(this.client, id);
   }
   async sentinelAttack(id, prompt, fee) {
+    this.enforcer.check({ operation: "sentinel", amount: fee ? Number(fee) / 1e9 : 0.1 });
     return attack(this.client, this.keypair, id, prompt, fee);
   }
   // -- Helpers --
@@ -3737,12 +3915,16 @@ exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
 exports.CetusAdapter = CetusAdapter;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
+exports.DEFAULT_SAFEGUARD_CONFIG = DEFAULT_SAFEGUARD_CONFIG;
 exports.MIST_PER_SUI = MIST_PER_SUI;
 exports.NaviAdapter = NaviAdapter;
+exports.OUTBOUND_OPS = OUTBOUND_OPS;
 exports.ProtocolRegistry = ProtocolRegistry;
 exports.SENTINEL = SENTINEL;
 exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
+exports.SafeguardEnforcer = SafeguardEnforcer;
+exports.SafeguardError = SafeguardError;
 exports.SuilendAdapter = SuilendAdapter;
 exports.T2000 = T2000;
 exports.T2000Error = T2000Error;