@t2000/engine 0.5.6 → 0.5.7

package/dist/index.d.ts

@@ -798,10 +798,19 @@ declare const healthCheckTool: Tool<{}, {
 
 declare const ratesInfoTool: Tool<{}, _t2000_sdk.RatesResult>;
 
+interface TxRecord {
+    digest: string;
+    action: string;
+    amount?: number;
+    asset?: string;
+    recipient?: string;
+    timestamp: number;
+    gasCost?: number;
+}
 declare const transactionHistoryTool: Tool<{
     limit?: number | undefined;
 }, {
-    transactions: _t2000_sdk.TransactionRecord[];
+    transactions: TxRecord[];
     count: number;
 }>;
 

package/dist/index.js

@@ -866,6 +866,97 @@ var ratesInfoTool = buildTool({
     };
   }
 });
+var SUI_TYPE = "0x2::sui::SUI";
+var KNOWN_TARGETS = [
+  [/::suilend|::obligation/, "lending"],
+  [/::navi|::incentive_v\d+|::oracle_pro/, "lending"],
+  [/::cetus|::pool/, "swap"],
+  [/::deepbook/, "swap"],
+  [/::transfer::public_transfer/, "send"]
+];
+function resolveOwner(owner) {
+  if (typeof owner === "object" && owner.AddressOwner) return owner.AddressOwner;
+  if (typeof owner === "string") return owner;
+  return null;
+}
+function classifyAction(targets, commandTypes) {
+  for (const target of targets) {
+    for (const [pattern, label] of KNOWN_TARGETS) {
+      if (pattern.test(target)) return label;
+    }
+  }
+  if (commandTypes.includes("TransferObjects") && !commandTypes.includes("MoveCall")) return "send";
+  return "transaction";
+}
+function parseRpcTx(tx, address) {
+  const gasUsed = tx.effects?.gasUsed;
+  const gasCost = gasUsed ? (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9 : void 0;
+  const moveCallTargets = [];
+  const commandTypes = [];
+  try {
+    const data = tx.transaction?.data;
+    const inner = data?.transaction;
+    const commands = inner?.commands;
+    if (commands) {
+      for (const cmd of commands) {
+        if (cmd.MoveCall) {
+          const mc = cmd.MoveCall;
+          moveCallTargets.push(`${mc.package}::${mc.module}::${mc.function}`);
+          commandTypes.push("MoveCall");
+        } else if (cmd.TransferObjects) {
+          commandTypes.push("TransferObjects");
+        }
+      }
+    }
+  } catch {
+  }
+  const changes = tx.balanceChanges ?? [];
+  const outflows = changes.filter((c) => resolveOwner(c.owner) === address && BigInt(c.amount) < 0n);
+  const inflows = changes.filter((c) => resolveOwner(c.owner) !== address && BigInt(c.amount) > 0n);
+  const primaryOutflow = outflows.filter((c) => c.coinType !== SUI_TYPE).sort((a, b) => Number(BigInt(a.amount) - BigInt(b.amount)))[0] ?? outflows[0];
+  let amount;
+  let asset;
+  let recipient;
+  if (primaryOutflow) {
+    const coinType = primaryOutflow.coinType;
+    const decimals = coinType.includes("::usdc::") ? 6 : 9;
+    amount = Math.abs(Number(BigInt(primaryOutflow.amount))) / 10 ** decimals;
+    asset = coinType === SUI_TYPE ? "SUI" : coinType.includes("::usdc::") ? "USDC" : coinType.split("::").pop() ?? "unknown";
+    const recipientChange = inflows.find((c) => c.coinType === coinType);
+    recipient = recipientChange ? resolveOwner(recipientChange.owner) ?? void 0 : void 0;
+  }
+  return {
+    digest: tx.digest,
+    action: classifyAction(moveCallTargets, commandTypes),
+    amount,
+    asset,
+    recipient,
+    timestamp: Number(tx.timestampMs ?? 0),
+    gasCost
+  };
+}
+async function queryHistoryRpc(rpcUrl, address, limit) {
+  const res = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "suix_queryTransactionBlocks",
+      params: [
+        { filter: { FromAddress: address }, options: { showEffects: true, showInput: true, showBalanceChanges: true } },
+        null,
+        limit,
+        true
+      ]
+    }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`Sui RPC error: ${res.status}`);
+  const json = await res.json();
+  if (json.error) throw new Error(`RPC error: ${json.error.message}`);
+  return (json.result?.data ?? []).map((tx) => parseRpcTx(tx, address));
+}
 var transactionHistoryTool = buildTool({
   name: "transaction_history",
   description: "Retrieve recent transaction history: past sends, saves, withdrawals, borrows, repayments, and rewards claims. Optionally limit the number of results.",
@@ -883,13 +974,21 @@ var transactionHistoryTool = buildTool({
   },
   isReadOnly: true,
   async call(input, context) {
-    const agent = requireAgent(context);
-    const records = await agent.history({ limit: input.limit ?? 10 });
+    const limit = input.limit ?? 10;
+    if (context.agent) {
+      const agent = requireAgent(context);
+      const records2 = await agent.history({ limit });
+      return {
+        data: { transactions: records2, count: records2.length },
+        displayText: `${records2.length} recent transaction(s)`
+      };
+    }
+    if (!context.walletAddress || !context.suiRpcUrl) {
+      throw new Error("Transaction history requires a wallet address");
+    }
+    const records = await queryHistoryRpc(context.suiRpcUrl, context.walletAddress, limit);
     return {
-      data: {
-        transactions: records,
-        count: records.length
-      },
+      data: { transactions: records, count: records.length },
       displayText: `${records.length} recent transaction(s)`
     };
   }