@aiaiaichain/agent 0.1.3 → 0.1.5

package/dist/tools/CrossTools.js

@@ -0,0 +1,190 @@
+/**
+ * CrossTools — automation tools that combine multiple data sources.
+ * Watch tokens, compare, portfolio tracking, price alerts.
+ */
+import { Type } from "@sinclair/typebox";
+import { priceFeed } from "../tools/PriceFeed.js";
+import { AIAIAI_TOKEN, agentWallet } from "../wallet/AgentWallet.js";
+import { logger } from "../util/logger.js";
+const alerts = [];
+export function addAlert(token, type, price) {
+    const alert = {
+        id: `alert-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
+        token,
+        type,
+        price,
+        active: true,
+        createdAt: Date.now(),
+    };
+    alerts.push(alert);
+    return alert;
+}
+export function checkAlerts(currentPrice, token) {
+    const triggered = [];
+    for (const alert of alerts) {
+        if (!alert.active || alert.token !== token)
+            continue;
+        if (alert.type === 'above' && currentPrice >= alert.price) {
+            alert.active = false;
+            alert.triggeredAt = Date.now();
+            triggered.push(alert);
+        }
+        else if (alert.type === 'below' && currentPrice <= alert.price) {
+            alert.active = false;
+            alert.triggeredAt = Date.now();
+            triggered.push(alert);
+        }
+    }
+    return triggered;
+}
+export function getActiveAlerts() {
+    return alerts.filter(a => a.active);
+}
+// ── Watch List ───────────────────────────────────────────────────────────────
+const watchList = new Set();
+export function addToWatchList(tokenAddress) {
+    watchList.add(tokenAddress);
+}
+export function removeFromWatchList(tokenAddress) {
+    watchList.delete(tokenAddress);
+}
+export function getWatchList() {
+    return [...watchList];
+}
+// ── Agent Tools ──────────────────────────────────────────────────────────────
+export const watchTokenParams = Type.Object({
+    address: Type.String({ description: "Token contract address to watch" }),
+});
+export const removeWatchParams = Type.Object({
+    address: Type.String({ description: "Token contract address to remove" }),
+});
+export const listWatchParams = Type.Object({});
+export const addAlertParams = Type.Object({
+    token: Type.String({ description: "Token address or 'AIAIAI'" }),
+    type: Type.String({ description: "Alert type: above or below" }),
+    price: Type.Number({ description: "Price threshold in USD" }),
+});
+export const checkAlertsParams = Type.Object({});
+export const compareTokensParams = Type.Object({
+    address1: Type.String({ description: "First token address" }),
+    address2: Type.String({ description: "Second token address" }),
+});
+export async function watchTokenTool(_id, params) {
+    const addr = params.address;
+    addToWatchList(addr);
+    return { content: [{ type: "text", text: `👁️ Watching ${addr.slice(0, 8)}…${addr.slice(-6)}. You'll get alerts on significant moves.` }] };
+}
+export async function removeWatchTool(_id, params) {
+    const addr = params.address;
+    removeFromWatchList(addr);
+    return { content: [{ type: "text", text: `Removed ${addr.slice(0, 8)}… from watch list.` }] };
+}
+export async function listWatchTool() {
+    const list = getWatchList();
+    if (list.length === 0)
+        return { content: [{ type: "text", text: "Watch list is empty." }] };
+    const lines = list.map((addr, i) => `  ${i + 1}. ${addr.slice(0, 8)}…${addr.slice(-6)}`);
+    return { content: [{ type: "text", text: `Watch List (${list.length}):\n${lines.join("\n")}` }] };
+}
+export async function addAlertTool(_id, params) {
+    const token = params.token;
+    const type = params.type;
+    const price = params.price;
+    const alert = addAlert(token, type, price);
+    return { content: [{ type: "text", text: `🔔 Alert set: ${type} $${price} for ${token.slice(0, 8)}… (${alert.id})` }] };
+}
+export async function checkAlertsTool() {
+    const active = getActiveAlerts();
+    if (active.length === 0)
+        return { content: [{ type: "text", text: "No active alerts." }] };
+    const lines = active.map(a => `  ${a.id} — ${a.type} $${a.price} (${a.token.slice(0, 8)}…)`);
+    return { content: [{ type: "text", text: `Active Alerts (${active.length}):\n${lines.join("\n")}` }] };
+}
+export async function compareTokensTool(_id, params) {
+    const addr1 = params.address1;
+    const addr2 = params.address2;
+    let price1 = null, price2 = null;
+    try {
+        if (addr1 === AIAIAI_TOKEN || addr1.toLowerCase() === 'aiaiai') {
+            price1 = await priceFeed.getAiaiaiPrice();
+        }
+        else {
+            price1 = await priceFeed.fetchToken(addr1);
+        }
+    }
+    catch (error) {
+        logger.warn('CrossTools', 'compareTokens: failed to fetch price1', { address: addr1, error: error.message });
+        price1 = null;
+    }
+    try {
+        if (addr2 === AIAIAI_TOKEN || addr2.toLowerCase() === 'aiaiai') {
+            price2 = await priceFeed.getAiaiaiPrice();
+        }
+        else {
+            price2 = await priceFeed.fetchToken(addr2);
+        }
+    }
+    catch (error) {
+        logger.warn('CrossTools', 'compareTokens: failed to fetch price2', { address: addr2, error: error.message });
+        price2 = null;
+    }
+    const lines = [
+        '── Token Comparison ──────────────────────────',
+        '',
+        `Token 1: ${addr1.slice(0, 8)}…`,
+        price1 ? `  Price: $${price1.priceUsd ?? 'N/A'}` : '  Price: N/A',
+        price1 ? `  24h: ${price1.priceChange24h > 0 ? '+' : ''}${price1.priceChange24h.toFixed(2)}%` : '  24h: N/A',
+        price1 ? `  Liq: $${(price1.liquidityUsd / 1000).toFixed(1)}k` : '  Liq: N/A',
+        price1 ? `  MCap: $${price1.marketCap ? (price1.marketCap / 1000).toFixed(1) + 'k' : 'N/A'}` : '  MCap: N/A',
+        '',
+        `Token 2: ${addr2.slice(0, 8)}…`,
+        price2 ? `  Price: $${price2.priceUsd ?? 'N/A'}` : '  Price: N/A',
+        price2 ? `  24h: ${price2.priceChange24h > 0 ? '+' : ''}${price2.priceChange24h.toFixed(2)}%` : '  24h: N/A',
+        price2 ? `  Liq: $${(price2.liquidityUsd / 1000).toFixed(1)}k` : '  Liq: N/A',
+        price2 ? `  MCap: $${price2.marketCap ? (price2.marketCap / 1000).toFixed(1) + 'k' : 'N/A'}` : '  MCap: N/A',
+    ];
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+}
+// ── Portfolio tracking ─────────────────────────────────────────────────────────────
+export const portfolioParams = Type.Object({
+    address: Type.String({ description: "Wallet address to analyze" }),
+});
+export async function portfolioTool(_id, params) {
+    const address = params.address;
+    // Use agentWallet's cached balances if it's one of our wallets
+    let result = null;
+    try {
+        const all = await agentWallet.getAll();
+        if (address === COLD_WALLET)
+            result = all.cold;
+        else if (address === ACTION_WALLET)
+            result = all.action;
+        else if (address === DEPOSIT_WALLET)
+            result = all.deposit;
+    }
+    catch (error) {
+        logger.warn('CrossTools', 'portfolioTool: wallet lookup failed', { address, error: error.message });
+    }
+    if (result) {
+        let solPrice = await new Promise(res => {
+            agentWallet.getSolPrice().then(res).catch(() => res(150));
+        });
+        const lines = [
+            `📊 Portfolio: ${address.slice(0, 8)}…${address.slice(-6)}`,
+            '',
+            `  SOL:   ${result.sol.toFixed(4)} ($${(result.sol * solPrice).toFixed(2)} est)`,
+            `  $AIAIAI: ${result.aiaiai.toLocaleString(undefined, { maximumFractionDigits: 0 })}`,
+            `  USDC:  ${result.usdc.toFixed(2)}`,
+            '',
+            `  Total value (est): $${(result.sol * solPrice + result.usdc).toFixed(2)} + $AIAIAI`,
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    return {
+        content: [{ type: "text", text: `📊 Analyzed: ${address.slice(0, 8)}…${address.slice(-6)}\nUse /wallet or /deposit for tracked wallet balances.` }],
+    };
+}
+export const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+//# sourceMappingURL=CrossTools.js.map

package/dist/tools/MarketSentiment.js

@@ -3,11 +3,13 @@
  * Fear & Greed Index, Binance Funding Rates, BTC Mempool, DeFi TVL, Solana Stats.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 // ── Fear & Greed Index ──────────────────────────────────────────────────────
 export const fearGreedParams = Type.Object({});
 export async function getFearGreedTool() {
     try {
-        const response = await fetch("https://api.alternative.me/fng/?limit=7");
+        const response = await resilientFetch("https://api.alternative.me/fng/?limit=7", { timeout: 10_000, retries: 1 });
         if (!response.ok)
             return fallbackFearGreed();
         const data = await response.json();
@@ -28,7 +30,8 @@ export async function getFearGreedTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Fear & Greed fetch failed', { error: error.message });
         return fallbackFearGreed();
     }
 }
@@ -47,7 +50,7 @@ export const fundingRatesParams = Type.Object({
 export async function getFundingRatesTool(_id, params) {
     const limit = params.limit || 10;
     try {
-        const response = await fetch("https://fapi.binance.com/fapi/v1/premiumIndex");
+        const response = await resilientFetch("https://fapi.binance.com/fapi/v1/premiumIndex", { timeout: 10_000, retries: 1 });
         if (!response.ok)
             return fallbackFundingRates();
         const data = await response.json();
@@ -67,7 +70,8 @@ export async function getFundingRatesTool(_id, params) {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Funding rates fetch failed', { error: error.message });
         return fallbackFundingRates();
     }
 }
@@ -84,8 +88,8 @@ export const btcMempoolParams = Type.Object({});
 export async function getBtcMempoolTool() {
     try {
         const [feeResp, mempoolResp] = await Promise.all([
-            fetch("https://mempool.space/api/v1/fees/recommended"),
-            fetch("https://mempool.space/api/mempool"),
+            resilientFetch("https://mempool.space/api/v1/fees/recommended", { timeout: 10_000 }),
+            resilientFetch("https://mempool.space/api/mempool", { timeout: 10_000 }),
         ]);
         const fees = await feeResp.json();
         const mempool = await mempoolResp.json();
@@ -107,7 +111,8 @@ export async function getBtcMempoolTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'BTC mempool fetch failed', { error: error.message });
         return {
             content: [{ type: "text", text: "BTC Mempool: Data temporarily unavailable." }],
         };
@@ -121,7 +126,7 @@ export async function getDefiTvlTool(_id, params) {
     const chain = params.chain?.toLowerCase();
     try {
         if (chain) {
-            const response = await fetch(`https://api.llama.fi/v2/historicalChainTvl/${chain}`);
+            const response = await resilientFetch(`https://api.llama.fi/v2/historicalChainTvl/${chain}`, { timeout: 10_000 });
             if (!response.ok)
                 return fallbackTvl(chain);
             const data = await response.json();
@@ -134,7 +139,7 @@ export async function getDefiTvlTool(_id, params) {
             };
         }
         else {
-            const response = await fetch("https://api.llama.fi/v2/chains");
+            const response = await resilientFetch("https://api.llama.fi/v2/chains", { timeout: 10_000 });
             if (!response.ok)
                 return fallbackTvl("all");
             const data = await response.json();
@@ -148,7 +153,8 @@ export async function getDefiTvlTool(_id, params) {
             };
         }
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'DeFi TVL fetch failed', { chain, error: error.message });
         return fallbackTvl(chain ?? "all");
     }
 }
@@ -168,7 +174,9 @@ export async function getSolanaStatsTool() {
             method: "getEpochInfo",
             params: [],
         });
-        const response = await fetch(rpcUrl, {
+        const response = await resilientFetch(rpcUrl, {
+            timeout: 10_000,
+            retries: 1,
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body,
@@ -179,7 +187,7 @@ export async function getSolanaStatsTool() {
         const epoch = data.result;
         const epochProgress = ((epoch.slotIndex / epoch.slotsInEpoch) * 100).toFixed(1);
         // Also get SOL price
-        const priceResp = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd&include_24hr_change=true");
+        const priceResp = await resilientFetch("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd&include_24hr_change=true", { timeout: 8_000 });
         let solPrice = "";
         if (priceResp.ok) {
             const priceData = await priceResp.json();
@@ -199,7 +207,8 @@ export async function getSolanaStatsTool() {
                 }],
         };
     }
-    catch {
+    catch (error) {
+        logger.warn('MarketSentiment', 'Solana stats fetch failed', { error: error.message });
         return fallbackSolanaStats();
     }
 }

package/dist/tools/NewsSentiment.js

@@ -3,6 +3,8 @@
  * Uses public RSS feeds and a basic lexicon-based sentiment analyzer.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 const POSITIVE_WORDS = new Set([
     "bullish", "surge", "rally", "gain", "green", "high", "breakthrough", "adoption",
     "partnership", "launch", "upgrade", "growth", "profit", "positive", "optimistic",
@@ -51,7 +53,9 @@ export class NewsFeed {
             const url = apiKey
                 ? `https://cryptopanic.com/api/v1/posts/?auth_token=${apiKey}&kind=news&public=true`
                 : "https://cryptopanic.com/api/v1/posts/?public=true";
-            const response = await fetch(url, {
+            const response = await resilientFetch(url, {
+                timeout: 10_000,
+                retries: 1,
                 headers: { "Accept": "application/json" },
             });
             if (response.ok) {
@@ -71,7 +75,8 @@ export class NewsFeed {
                 items.push(...this.getFallbackNews());
             }
         }
-        catch {
+        catch (error) {
+            logger.warn('NewsSentiment', 'Failed to fetch news', { error: error.message });
             items.push(...this.getFallbackNews());
         }
         this.cachedItems = items;
@@ -109,7 +114,8 @@ export class NewsFeed {
             const emoji = report.averageSentiment > 0.2 ? "📈" : report.averageSentiment < -0.2 ? "📉" : "📊";
             return `${emoji} ${(report.averageSentiment * 100).toFixed(0)}%`;
         }
-        catch {
+        catch (error) {
+            logger.debug('NewsSentiment', 'statusBadge failed', { error: error.message });
             return "";
         }
     }

package/dist/tools/PriceFeed.js

@@ -4,6 +4,8 @@
  * Secondary: query any token by address.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
 const AIAIAI_TOKEN = "AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump";
 export class PriceFeed {
     cachedAiaiPrice = null;
@@ -18,7 +20,7 @@ export class PriceFeed {
     async fetchToken(tokenAddress) {
         const url = `https://api.dexscreener.com/tokens/v1/solana/${tokenAddress}`;
         try {
-            const response = await fetch(url);
+            const response = await resilientFetch(url, { timeout: 10_000, retries: 1 });
             if (!response.ok) {
                 return this.fallbackPrice(tokenAddress);
             }
@@ -48,7 +50,8 @@ export class PriceFeed {
             }
             return result;
         }
-        catch {
+        catch (error) {
+            logger.warn('PriceFeed', 'fetchToken failed', { tokenAddress, error: error.message });
             return this.fallbackPrice(tokenAddress);
         }
     }
@@ -71,7 +74,7 @@ export class PriceFeed {
     }
     tickerLine(maxLength = 6) {
         try {
-            const p = this.cachedAiaiPrice ?? this.getAiaiaiPriceSync();
+            const p = this.cachedAiaiPrice;
             if (!p || !p.priceUsd)
                 return "";
             const price = parseFloat(p.priceUsd).toFixed(6);
@@ -79,7 +82,9 @@ export class PriceFeed {
             const arrow = change > 0 ? "▲" : change < 0 ? "▼" : "─";
             return `$AIAIAI $${price} ${arrow}${Math.abs(change).toFixed(2)}%`.slice(0, 40);
         }
-        catch {
+        catch (error) {
+            // Log error in case of debug needed
+            console.error('Error in tickerLine:', error);
             return "";
         }
     }
@@ -131,4 +136,6 @@ export class PriceFeed {
     }
 }
 export const priceFeed = new PriceFeed();
+// Eagerly initialize the price cache so sidebar shows price immediately
+priceFeed.getAiaiaiPrice().catch(() => { });
 //# sourceMappingURL=PriceFeed.js.map

package/dist/tools/TechnicalAnalysis.js

@@ -3,6 +3,7 @@
  * Works with OHLCV candle data. Tools for the agent to query.
  */
 import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
 // ── SMA ──────────────────────────────────────────────────────────────────────
 export function sma(data, period) {
     const result = [];
@@ -197,7 +198,7 @@ export async function getCandlesTool(_id, params) {
     const interval = params.interval || "1d";
     const limit = params.limit || 50;
     try {
-        const response = await fetch(`https://api.binance.com/api/v3/klines?symbol=${symbol}&interval=${interval}&limit=${limit}`);
+        const response = await resilientFetch(`https://api.binance.com/api/v3/klines?symbol=${symbol}&interval=${interval}&limit=${limit}`, { timeout: 10_000, retries: 1 });
         if (!response.ok) {
             return { content: [{ type: "text", text: `Failed to fetch candles for ${symbol}: ${response.status}` }] };
         }

package/dist/tools/TokenCalendar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * src/tools/TokenCalendar.ts — Token launch calendar tracker.
+ * Uses DexScreener's latest tokens endpoint to find recent launches.
+ * Caches results for 5 minutes.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface LaunchEvent {
+    address: string;
+    symbol: string;
+    name: string;
+    priceUsd: string | null;
+    volume24h: number;
+    liquidityUsd: number;
+    age: string;
+    chain: string;
+}
+export declare const launchCalendarParams: import("@sinclair/typebox").TObject<{
+    chain: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare function launchCalendarTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+/** Get sidebar-ready summary */
+export declare function getLaunchSummary(): string;
+//# sourceMappingURL=TokenCalendar.d.ts.map

package/dist/tools/TokenCalendar.js

@@ -0,0 +1,81 @@
+/**
+ * src/tools/TokenCalendar.ts — Token launch calendar tracker.
+ * Uses DexScreener's latest tokens endpoint to find recent launches.
+ * Caches results for 5 minutes.
+ */
+import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
+export const launchCalendarParams = Type.Object({
+    chain: Type.Optional(Type.String({ description: "Chain: solana, ethereum, bsc, base", default: "solana" })),
+    limit: Type.Optional(Type.Number({ description: "Max entries", default: 10 })),
+});
+let cachedLaunches = [];
+let lastFetch = 0;
+const CACHE_DURATION = 300_000; // 5 min
+export async function launchCalendarTool(_id, params) {
+    const chain = params.chain || "solana";
+    const limit = params.limit || 10;
+    if (Date.now() - lastFetch < CACHE_DURATION && cachedLaunches.length > 0) {
+        const filtered = cachedLaunches.filter(l => l.chain === chain).slice(0, limit);
+        return formatResult(filtered, chain);
+    }
+    try {
+        // DexScreener "latest" endpoint per chain
+        const url = `https://api.dexscreener.com/latest/dex/tokens/${chain}`;
+        const response = await resilientFetch(url, { timeout: 10_000, retries: 1 });
+        if (!response.ok) {
+            return { content: [{ type: "text", text: `Token launch calendar unavailable for ${chain}.` }] };
+        }
+        const data = await response.json();
+        const pairs = data?.pairs ?? [];
+        cachedLaunches = pairs.map((p) => {
+            const createdAt = p.pairCreatedAt ? new Date(p.pairCreatedAt) : null;
+            const now = Date.now();
+            const diffMs = createdAt ? now - createdAt.getTime() : Infinity;
+            const age = createdAt
+                ? diffMs < 3600000 ? `${Math.floor(diffMs / 60000)}m ago`
+                    : diffMs < 86400000 ? `${Math.floor(diffMs / 3600000)}h ago`
+                        : `${Math.floor(diffMs / 86400000)}d ago`
+                : "unknown";
+            return {
+                address: p.baseToken?.address ?? "",
+                symbol: p.baseToken?.symbol ?? "???",
+                name: p.baseToken?.name ?? "Unknown",
+                priceUsd: p.priceUsd ?? null,
+                volume24h: p.volume?.h24 ?? 0,
+                liquidityUsd: p.liquidity?.usd ?? 0,
+                age,
+                chain,
+            };
+        });
+        lastFetch = Date.now();
+        const filtered = cachedLaunches.slice(0, limit);
+        return formatResult(filtered, chain);
+    }
+    catch (error) {
+        logger.warn("TokenCalendar", "Failed to fetch launches", { chain, error: error.message });
+        return { content: [{ type: "text", text: `Token launch calendar: Data temporarily unavailable.` }] };
+    }
+}
+function formatResult(launches, chain) {
+    if (launches.length === 0) {
+        return { content: [{ type: "text", text: `No recent launches found on ${chain}.` }] };
+    }
+    const lines = [`🚀 Recent Token Launches — ${chain.toUpperCase()}`, ""];
+    for (const l of launches.slice(0, 10)) {
+        const price = l.priceUsd ? `$${parseFloat(l.priceUsd).toFixed(8)}` : "N/A";
+        const vol = l.volume24h > 0 ? `$${(l.volume24h / 1000).toFixed(1)}k` : "no vol";
+        const liq = l.liquidityUsd > 0 ? `$${(l.liquidityUsd / 1000).toFixed(1)}k` : "no liq";
+        lines.push(`  ${l.symbol.padEnd(10)} ${price.padEnd(16)} ${vol.padEnd(10)} ${l.age.padEnd(10)} ${l.address.slice(0, 6)}…`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }], details: { launches } };
+}
+/** Get sidebar-ready summary */
+export function getLaunchSummary() {
+    if (cachedLaunches.length === 0)
+        return "Loading…";
+    const recent = cachedLaunches.slice(0, 3);
+    return recent.map(l => l.symbol).join(" · ");
+}
+//# sourceMappingURL=TokenCalendar.js.map

package/dist/tools/TokenSecurityScanner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * src/tools/TokenSecurityScanner.ts - honeypot/rugpull detection for Solana tokens
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface TokenSecurityResult {
+    address: string;
+    symbol: string;
+    name: string;
+    isHoneypot: boolean;
+    isRugRisk: boolean;
+    mintAuthorityRenounced: boolean;
+    freezeAuthorityRenounced: boolean;
+    liquidityLocked: boolean;
+    top10HolderPct: number;
+    warnings: string[];
+    score: number;
+}
+export declare const tokenSecurityParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare function scanTokenSecurityTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+//# sourceMappingURL=TokenSecurityScanner.d.ts.map

package/dist/tools/TokenSecurityScanner.js

@@ -0,0 +1,102 @@
+/**
+ * src/tools/TokenSecurityScanner.ts - honeypot/rugpull detection for Solana tokens
+ */
+import { Type } from "@sinclair/typebox";
+import { resilientFetch } from "../util/resilientFetch.js";
+import { logger } from "../util/logger.js";
+export const tokenSecurityParams = Type.Object({
+    address: Type.String({ description: "Token mint address on Solana" }),
+});
+export async function scanTokenSecurityTool(_id, params) {
+    const address = params.address;
+    if (!address || address.length < 32 || address.length > 44) {
+        return {
+            content: [{ type: "text", text: "Invalid token address format." }],
+            isError: true,
+        };
+    }
+    const warnings = [];
+    let score = 100;
+    let isHoneypot = false;
+    let isRugRisk = false;
+    let dexData = null;
+    try {
+        const resp = await resilientFetch(`https://api.dexscreener.com/tokens/v1/solana/${address}`, {
+            timeout: 10_000,
+            retries: 1,
+        });
+        if (resp.ok) {
+            const data = await resp.json();
+            if (data && data.length > 0)
+                dexData = data[0];
+        }
+    }
+    catch (error) {
+        logger.warn("TokenSecurity", "DexScreener lookup failed", { address, error: error.message });
+    }
+    if (!dexData) {
+        warnings.push("No DEX liquidity found - token may be dead or not traded");
+        score -= 50;
+        isRugRisk = true;
+    }
+    else {
+        const liquidity = dexData.liquidity?.usd ?? 0;
+        if (liquidity < 1000) {
+            warnings.push(`Low liquidity: $${liquidity.toFixed(0)}`);
+            score -= 30;
+            isRugRisk = true;
+        }
+        else if (liquidity < 10000) {
+            warnings.push(`Moderate liquidity: $${liquidity.toFixed(0)}`);
+            score -= 10;
+        }
+        const volume = dexData.volume?.h24 ?? 0;
+        if (volume < 100) {
+            warnings.push(`Very low 24h volume: $${volume.toFixed(0)}`);
+            score -= 20;
+        }
+    }
+    try {
+        const rugResp = await resilientFetch(`https://api.rugcheck.xyz/v1/tokens/${address}/report`, {
+            timeout: 8_000,
+            retries: 0,
+        });
+        if (rugResp.ok) {
+            const report = await rugResp.json();
+            if (report.status === "WARNING" || report.status === "BLOCKED") {
+                warnings.push(`RugCheck status: ${report.status}`);
+                score -= 40;
+                isRugRisk = true;
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('TokenSecurity', 'RugCheck lookup failed (optional)', { address, error: error.message });
+    }
+    const symbol = dexData?.baseToken?.symbol ?? "???";
+    const name = dexData?.baseToken?.name ?? "Unknown";
+    const scoreLabel = score >= 70 ? "SAFE" : score >= 40 ? "CAUTION" : "DANGEROUS";
+    const lines = [
+        "Token Security Scan",
+        "",
+        `Token: ${name} ($${symbol})`,
+        `Address: ${address.slice(0, 8)}...${address.slice(-6)}`,
+        `Score: ${scoreLabel} (${score}/100)`,
+        "",
+    ];
+    if (warnings.length > 0) {
+        lines.push("Warnings:");
+        for (const w of warnings)
+            lines.push("  - " + w);
+    }
+    else {
+        lines.push("No immediate risks detected.");
+    }
+    lines.push("");
+    lines.push("This is not financial advice. Always verify before trading.");
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: { address, symbol, name, score, isHoneypot, isRugRisk, warnings },
+    };
+}
+//# sourceMappingURL=TokenSecurityScanner.js.map

package/dist/tools/TransactionSim.d.ts

@@ -0,0 +1,17 @@
+/**
+ * src/tools/TransactionSim.ts — Simulate Solana transactions before execution.
+ * Uses public RPC simulateTransaction for pre-flight checks.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface SimResult {
+    ok: boolean;
+    logs: string[];
+    unitsConsumed: number;
+    fee: number;
+    error?: string;
+}
+export declare const simulateTxParams: import("@sinclair/typebox").TObject<{
+    transaction: import("@sinclair/typebox").TString;
+}>;
+export declare function simulateTxTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+//# sourceMappingURL=TransactionSim.d.ts.map