@aiaiaichain/agent 0.1.4 → 0.1.6

package/dist/wallet/AgentWallet.js

@@ -8,10 +8,18 @@
  *   Signer:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (authority)
  */
 import { Type } from "@sinclair/typebox";
-export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
-export const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
+// Wallet architecture (verified on-chain):
+//   ACTION:  GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG  (executes buys + burns)
+//   HOT:     BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2  (temporary swap + burn)
+//   DEPOSIT: FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e  (user deposits)
+//   COLD:    A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J  (reserve — /wallet only)
+export const ACTION_WALLET = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export const HOT_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
 export const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
-export const SIGNER = "GmFrDZT2cdrqykgTikVdXbe8EtCgzUDM9VsDhQnwsUsG";
+export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export const SIGNER = ACTION_WALLET;
 export const AIAIAI_MINT = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export const AIAIAI_TOKEN = AIAIAI_MINT;
 const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
@@ -19,14 +27,21 @@ function getRpcUrl() {
     return process.env.SOLANA_RPC_URL || "https://api.mainnet-beta.solana.com";
 }
 async function rpcCall(method, params = []) {
-    const response = await fetch(getRpcUrl(), {
+    const response = await resilientFetch(getRpcUrl(), {
+        timeout: 15_000,
+        retries: 2,
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
     });
     const data = await response.json();
-    if (data.error)
-        throw new Error(data.error.message);
+    if (data.error) {
+        const msg = data.error.message || 'Unknown RPC error';
+        if (data.error.code === -32005 || msg.includes('rate limit')) {
+            logger.warn('AgentWallet', 'RPC rate limited', { method, code: data.error.code });
+        }
+        throw new Error(msg);
+    }
     return data.result;
 }
 async function getBalance(address) {
@@ -34,7 +49,8 @@ async function getBalance(address) {
         const result = await rpcCall("getBalance", [address]);
         return (result?.value ?? 0) / 1e9;
     }
-    catch {
+    catch (error) {
+        logger.warn('AgentWallet', 'getBalance failed', { address, error: error.message });
         return 0;
     }
 }
@@ -50,7 +66,8 @@ async function getTokenBalance(address, mint) {
             return 0;
         return parseFloat(accounts[0]?.account?.data?.parsed?.info?.tokenAmount?.uiAmount ?? "0");
     }
-    catch {
+    catch (error) {
+        logger.warn('AgentWallet', 'getTokenBalance failed', { address, mint, error: error.message });
         return 0;
     }
 }
@@ -62,20 +79,17 @@ export class AgentWallet {
         if (this.cachedWallets && Date.now() - this.lastFetch < this.cacheDuration) {
             return this.cachedWallets;
         }
-        const [coldSol, coldAiai, coldUsdc, actionSol, actionAiai, actionUsdc, depSol, depAiai, depUsdc] = await Promise.all([
-            getBalance(COLD_WALLET),
-            getTokenBalance(COLD_WALLET, AIAIAI_MINT),
-            getTokenBalance(COLD_WALLET, USDC_MINT),
-            getBalance(ACTION_WALLET),
-            getTokenBalance(ACTION_WALLET, AIAIAI_MINT),
-            getTokenBalance(ACTION_WALLET, USDC_MINT),
-            getBalance(DEPOSIT_WALLET),
-            getTokenBalance(DEPOSIT_WALLET, AIAIAI_MINT),
-            getTokenBalance(DEPOSIT_WALLET, USDC_MINT),
+        // 4 wallets × 3 tokens = 12 parallel queries
+        const [coldSol, coldAiai, coldUsdc, actionSol, actionAiai, actionUsdc, hotSol, hotAiai, hotUsdc, depSol, depAiai, depUsdc] = await Promise.all([
+            getBalance(COLD_WALLET), getTokenBalance(COLD_WALLET, AIAIAI_MINT), getTokenBalance(COLD_WALLET, USDC_MINT),
+            getBalance(ACTION_WALLET), getTokenBalance(ACTION_WALLET, AIAIAI_MINT), getTokenBalance(ACTION_WALLET, USDC_MINT),
+            getBalance(HOT_WALLET), getTokenBalance(HOT_WALLET, AIAIAI_MINT), getTokenBalance(HOT_WALLET, USDC_MINT),
+            getBalance(DEPOSIT_WALLET), getTokenBalance(DEPOSIT_WALLET, AIAIAI_MINT), getTokenBalance(DEPOSIT_WALLET, USDC_MINT),
         ]);
         this.cachedWallets = {
             cold: { address: COLD_WALLET, sol: coldSol, aiaiai: coldAiai, usdc: coldUsdc },
             action: { address: ACTION_WALLET, sol: actionSol, aiaiai: actionAiai, usdc: actionUsdc },
+            hot: { address: HOT_WALLET, sol: hotSol, aiaiai: hotAiai, usdc: hotUsdc },
             deposit: { address: DEPOSIT_WALLET, sol: depSol, aiaiai: depAiai, usdc: depUsdc },
         };
         this.lastFetch = Date.now();
@@ -90,23 +104,41 @@ export class AgentWallet {
     async getDepositWallet() {
         return (await this.getAll()).deposit;
     }
+    // Get live SOL price from PriceFeed
+    async getSolPrice() {
+        try {
+            const { priceFeed } = await import("../tools/PriceFeed.js");
+            const result = await priceFeed.fetchToken("So11111111111111111111111111111111111111112");
+            return parseFloat(result.priceUsd ?? "150");
+        }
+        catch {
+            return 150; // fallback
+        }
+    }
     // ── Tools ───────────────────────────────────────────────────────────────
+    async getHotWallet() {
+        return (await this.getAll()).hot;
+    }
     getAgentBalanceParams = Type.Object({});
     getDepositBalanceParams = Type.Object({});
     async getAgentBalanceTool() {
         const w = await this.getAll();
         const lines = [
-            `Agent Cold Wallet`,
-            `  Address:  ${COLD_WALLET.slice(0, 8)}…${COLD_WALLET.slice(-6)}`,
-            `  SOL:      ${w.cold.sol.toFixed(4)}`,
-            `  $AIAIAI:   ${w.cold.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
-            `  USDC:     ${w.cold.usdc.toFixed(2)}`,
-            ``,
-            `Agent Action Wallet`,
-            `  Address:  ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
+            `🤖 Action Wallet`,
+            `  ${ACTION_WALLET.slice(0, 8)}…${ACTION_WALLET.slice(-6)}`,
             `  SOL:      ${w.action.sol.toFixed(4)}`,
-            `  $AIAIAI:   ${w.action.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+            `  $AIAIAI:  ${w.action.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
             `  USDC:     ${w.action.usdc.toFixed(2)}`,
+            ``,
+            `⚡ Hot Wallet`,
+            `  ${HOT_WALLET.slice(0, 8)}…${HOT_WALLET.slice(-6)}`,
+            `  SOL:      ${w.hot.sol.toFixed(4)}`,
+            `  $AIAIAI:  ${w.hot.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 2 })}`,
+            `  USDC:     ${w.hot.usdc.toFixed(2)}`,
+            ``,
+            `❄️  Cold (reserve)`,
+            `  ${COLD_WALLET.slice(0, 8)}…${COLD_WALLET.slice(-6)}`,
+            `  SOL:      ${w.cold.sol.toFixed(4)}`,
         ];
         return { content: [{ type: "text", text: lines.join("\n") }] };
     }

package/dist/wallet/ProfitTracker.d.ts

@@ -0,0 +1,30 @@
+/**
+/ProfitTracker.ts - Track cost basis and P&L for agent wallet trades
+ */
+export interface Trade {
+    timestamp: number;
+    type: "buy" | "sell" | "burn";
+    tokenAmount: number;
+    solAmount: number;
+    pricePerToken: number;
+    txSignature?: string;
+}
+export interface ProfitState {
+    trades: Trade[];
+    totalSpent: number;
+    totalReceived: number;
+    avgCostBasis: number;
+}
+export interface PLSummary {
+    avgCostBasis: number;
+    totalSpent: number;
+    totalReceived: number;
+    realizedPL: number;
+    unrealizedPL: number;
+    roi: number;
+}
+export declare function recordTrade(type: "buy" | "sell" | "burn", tokenAmount: number, solAmount: number, txSignature?: string): void;
+export declare function getPLSummary(currentTokenPrice: number): PLSummary;
+export declare function getTradeHistory(): Trade[];
+export declare function exportCSV(): string;
+//# sourceMappingURL=ProfitTracker.d.ts.map

package/dist/wallet/ProfitTracker.js

@@ -0,0 +1,93 @@
+/**
+/ProfitTracker.ts - Track cost basis and P&L for agent wallet trades
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { logger } from "../util/logger.js";
+const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
+const TRACKER_DIR = join(AIAIAI_HOME, ".tracker");
+const TRACKER_FILE = join(TRACKER_DIR, "pl.json");
+function loadState() {
+    try {
+        const raw = readFileSync(TRACKER_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { trades: [], totalSpent: 0, totalReceived: 0, avgCostBasis: 0 };
+    }
+}
+function saveState(state) {
+    try {
+        if (!existsSync(TRACKER_DIR)) {
+            mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+        }
+        writeFileSync(TRACKER_FILE, JSON.stringify(state, null, 2), "utf-8");
+    }
+    catch (error) {
+        logger.warn("ProfitTracker", "Failed to save state", { error: error.message });
+    }
+}
+export function recordTrade(type, tokenAmount, solAmount, txSignature) {
+    const state = loadState();
+    const pricePerToken = tokenAmount > 0 ? solAmount / tokenAmount : 0;
+    const trade = {
+        timestamp: Date.now(),
+        type,
+        tokenAmount,
+        solAmount,
+        pricePerToken,
+        txSignature,
+    };
+    state.trades.push(trade);
+    if (type === "buy") {
+        state.totalSpent += solAmount;
+        const totalTokensInvested = state.trades
+            .filter(t => t.type === "buy")
+            .reduce((sum, t) => sum + t.tokenAmount, 0);
+        state.avgCostBasis = totalTokensInvested > 0 ? state.totalSpent / totalTokensInvested : 0;
+    }
+    else if (type === "sell") {
+        state.totalReceived += solAmount;
+    }
+    saveState(state);
+    logger.info("ProfitTracker", "Recorded " + type, { tokenAmount, solAmount, pricePerToken });
+}
+export function getPLSummary(currentTokenPrice) {
+    const state = loadState();
+    const buyTrades = state.trades.filter(t => t.type === "buy");
+    const totalBought = buyTrades.reduce((sum, t) => sum + t.tokenAmount, 0);
+    const totalSoldOrBurned = state.trades
+        .filter(t => t.type === "sell" || t.type === "burn")
+        .reduce((sum, t) => sum + t.tokenAmount, 0);
+    const remainingTokens = totalBought - totalSoldOrBurned;
+    const realizedPL = state.totalReceived - (state.totalSpent * (totalSoldOrBurned / Math.max(totalBought, 1)));
+    const unrealizedPL = remainingTokens * currentTokenPrice;
+    const totalPL = realizedPL + unrealizedPL;
+    const roi = state.totalSpent > 0 ? (totalPL / state.totalSpent) * 100 : 0;
+    return {
+        avgCostBasis: state.avgCostBasis,
+        totalSpent: state.totalSpent,
+        totalReceived: state.totalReceived,
+        realizedPL,
+        unrealizedPL,
+        roi,
+    };
+}
+export function getTradeHistory() {
+    return loadState().trades;
+}
+export function exportCSV() {
+    const state = loadState();
+    const header = "timestamp,type,tokenAmount,solAmount,pricePerToken,txSignature";
+    const rows = state.trades.map(t => t.timestamp + "," + t.type + "," + t.tokenAmount + "," + t.solAmount + "," + t.pricePerToken + "," + (t.txSignature ?? ""));
+    const csv = header + "\n" + rows.join("\n");
+    const csvPath = join(TRACKER_DIR, "pl-export.csv");
+    if (!existsSync(TRACKER_DIR)) {
+        mkdirSync(TRACKER_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(csvPath, csv, "utf-8");
+    logger.info("ProfitTracker", "Exported CSV", { path: csvPath });
+    return csvPath;
+}
+//# sourceMappingURL=ProfitTracker.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiaiaichain/agent",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "AIAIAI Chain Agent — Solana-native AI agent for decentralized AI governance. Ticker: $AIAIAI",
   "author": "AIAIAI Foundation",
   "license": "MIT",
@@ -64,4 +64,4 @@
     "docs",
     "!dist/**/*.map"
   ]
-}
+}