clawvif 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1538 @@
+import { a as readJsonl, i as readJsonOr, n as ensureDir, o as readJsonlTail, s as writeJson, t as appendJsonl } from "./file-store-Cp6U-dO6.mjs";
+import { Type } from "@sinclair/typebox";
+import { join } from "node:path";
+import { Bot } from "grammy";
+//#region src/lib/audit-logger.ts
+/**
+* Audit logger for Clawvif.
+*
+* Records all sensitive operations to a JSONL audit trail.
+* Every vault sign, trade execution, risk check, and configuration
+* change is logged with timestamp, source skill, and relevant data.
+*/
+let logDir = join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "logs");
+/**
+* Get the path to the audit log file.
+*/
+function getAuditLogPath() {
+	return join(logDir, "audit.jsonl");
+}
+/**
+* Write an audit log entry.
+*
+* @param skill - Name of the skill/tool performing the action
+* @param action - Action being performed (e.g., "sign_transaction", "import_key")
+* @param data - Relevant data (NEVER include private keys or passwords)
+*/
+function auditLog(skill, action, data = {}) {
+	const entry = {
+		ts: (/* @__PURE__ */ new Date()).toISOString(),
+		skill,
+		action,
+		data
+	};
+	appendJsonl(getAuditLogPath(), entry);
+}
+/**
+* Query recent audit log entries.
+*
+* @param count - Number of recent entries to return
+* @returns Most recent entries (newest first)
+*/
+function queryAuditLog(count = 50) {
+	return readJsonlTail(getAuditLogPath(), count);
+}
+/**
+* Query audit log entries filtered by skill and/or action.
+*
+* @param filters - Optional filters
+* @param count - Maximum entries to return
+*/
+function queryAuditLogFiltered(filters, count = 50) {
+	return queryAuditLog(count * 3).filter((entry) => {
+		if (filters.skill && entry.skill !== filters.skill) return false;
+		if (filters.action && entry.action !== filters.action) return false;
+		return true;
+	}).slice(0, count);
+}
+//#endregion
+//#region src/tools/audit.ts
+/**
+* Audit Tool — Query and manage the Clawvif audit trail.
+*
+* All sensitive operations across all skills are recorded in audit.jsonl.
+* This tool provides read access to the audit log for review and analysis.
+*/
+function textResult$6(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerAuditTools(api) {
+	api.registerTool({
+		name: "audit_log",
+		description: "Write an entry to the audit log. Use this to record important agent actions that should be tracked for security review.",
+		parameters: Type.Object({
+			skill: Type.String({ description: "Name of the skill performing the action" }),
+			action: Type.String({ description: "Action description (e.g., \"strategy_enabled\", \"config_changed\")" }),
+			data: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Additional structured data (NEVER include private keys or passwords)" }))
+		}),
+		async execute(_id, params) {
+			const { skill, action, data } = params;
+			auditLog(skill, action, data || {});
+			return textResult$6(`📝 Audit entry recorded: [${skill}] ${action}`);
+		}
+	});
+	api.registerTool({
+		name: "audit_query",
+		description: "Query the audit log to review past operations. Returns recent entries optionally filtered by skill name and/or action type.",
+		parameters: Type.Object({
+			skill: Type.Optional(Type.String({ description: "Filter by skill name (e.g., \"vault\", \"dex-swap-executor\")" })),
+			action: Type.Optional(Type.String({ description: "Filter by action type (e.g., \"sign_transaction\", \"trade_executed\")" })),
+			count: Type.Optional(Type.Number({
+				description: "Number of recent entries to return (default: 20, max: 100)",
+				minimum: 1,
+				maximum: 100
+			}))
+		}),
+		async execute(_id, params) {
+			const { skill, action, count = 20 } = params;
+			const clampedCount = Math.min(Math.max(count, 1), 100);
+			let entries;
+			if (skill || action) entries = queryAuditLogFiltered({
+				skill,
+				action
+			}, clampedCount);
+			else entries = queryAuditLog(clampedCount);
+			if (entries.length === 0) return textResult$6("📭 No audit entries found matching your criteria.");
+			const formatted = entries.map((e) => {
+				const dataStr = Object.keys(e.data).length > 0 ? `\n   Data: ${JSON.stringify(e.data)}` : "";
+				return `• [${e.ts}] **${e.skill}** → ${e.action}${dataStr}`;
+			});
+			return textResult$6(`${skill || action ? `🔍 Audit Log (filtered: ${[skill && `skill=${skill}`, action && `action=${action}`].filter(Boolean).join(", ")})` : "📋 Recent Audit Log"}\n\n${formatted.join("\n\n")}\n\nShowing ${entries.length} entries.`);
+		}
+	});
+}
+//#endregion
+//#region src/tools/alert.ts
+/**
+* Alert Dispatcher Tool — Unified alert management for Clawvif.
+*
+* All skills route alerts through this dispatcher, which handles:
+* - Alert level classification (CRITICAL / HIGH / MEDIUM / LOW)
+* - Deduplication (same event within cooldown = suppressed)
+* - Message formatting for Telegram delivery
+* - Alert history tracking
+*/
+/** In-memory dedup cache: dedupKey → last sent timestamp */
+const dedupCache = /* @__PURE__ */ new Map();
+/** Default cooldown in seconds */
+const DEFAULT_COOLDOWN_SECONDS = 300;
+/** Alert level emoji mapping */
+const LEVEL_EMOJI = {
+	critical: "🔴",
+	high: "🟠",
+	medium: "🟡",
+	low: "🟢"
+};
+function getWorkspacePath$4() {
+	return process.env["CLAWVIF_WORKSPACE_PATH"] || join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "workspace");
+}
+function getAlertLogPath() {
+	return join(getWorkspacePath$4(), "logs", "alerts.jsonl");
+}
+function getAlertRulesPath() {
+	return join(getWorkspacePath$4(), "config", "alert-rules.json");
+}
+function loadAlertRules() {
+	return readJsonOr(getAlertRulesPath(), {
+		rules: [],
+		defaultCooldownSeconds: DEFAULT_COOLDOWN_SECONDS
+	});
+}
+function isDuplicate(dedupKey, cooldownSeconds) {
+	const lastSent = dedupCache.get(dedupKey);
+	if (!lastSent) return false;
+	return (Date.now() - lastSent) / 1e3 < cooldownSeconds;
+}
+function formatAlert(alert) {
+	let message = `${LEVEL_EMOJI[alert.level]} **${alert.level.toUpperCase()}** — ${alert.title}\n\n${alert.body}`;
+	if (alert.data && Object.keys(alert.data).length > 0) {
+		const dataLines = Object.entries(alert.data).map(([k, v]) => `  • ${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`).join("\n");
+		message += `\n\n📎 Details:\n${dataLines}`;
+	}
+	message += `\n\n🕐 ${alert.timestamp}`;
+	return message;
+}
+function textResult$5(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerAlertTools(api) {
+	api.registerTool({
+		name: "alert_send",
+		description: "Send an alert through the Clawvif alert dispatcher. Handles deduplication, level-based formatting, and history tracking. The formatted alert message should be forwarded to the user via the active messaging channel.",
+		parameters: Type.Object({
+			level: Type.Union([
+				Type.Literal("critical"),
+				Type.Literal("high"),
+				Type.Literal("medium"),
+				Type.Literal("low")
+			], { description: "Alert level: critical (fund safety), high (actionable signal), medium (threshold trigger), low (informational)" }),
+			title: Type.String({ description: "Short alert title" }),
+			body: Type.String({ description: "Detailed alert body text" }),
+			source: Type.String({ description: "Source skill name (e.g., \"onchain-monitor\", \"risk-guardian\")" }),
+			dedupKey: Type.Optional(Type.String({ description: "Deduplication key — same key within cooldown period will be suppressed" })),
+			data: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Additional structured data to include in the alert" }))
+		}),
+		async execute(_id, params) {
+			const { level, title, body, source, dedupKey, data } = params;
+			const cooldown = loadAlertRules().defaultCooldownSeconds || DEFAULT_COOLDOWN_SECONDS;
+			if (dedupKey && isDuplicate(dedupKey, cooldown)) return textResult$5(`⏭️ Alert suppressed (duplicate within ${cooldown}s cooldown): ${title}`);
+			const alert = {
+				id: `alert_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+				level,
+				title,
+				body,
+				data,
+				source,
+				dedupKey,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			if (dedupKey) dedupCache.set(dedupKey, Date.now());
+			ensureDir(join(getWorkspacePath$4(), "logs"));
+			appendJsonl(getAlertLogPath(), alert);
+			auditLog("alert-dispatcher", "alert_sent", {
+				alertId: alert.id,
+				level,
+				title,
+				source
+			});
+			return textResult$5(formatAlert(alert));
+		}
+	});
+	api.registerTool({
+		name: "alert_configure",
+		description: "View or modify alert dispatcher configuration, including cooldown periods and alert rules.",
+		parameters: Type.Object({
+			action: Type.Union([Type.Literal("get"), Type.Literal("set_cooldown")], { description: "Action: \"get\" to view config, \"set_cooldown\" to change default cooldown" }),
+			cooldownSeconds: Type.Optional(Type.Number({
+				description: "New default cooldown in seconds (for set_cooldown action)",
+				minimum: 0,
+				maximum: 3600
+			}))
+		}),
+		async execute(_id, params) {
+			const { action, cooldownSeconds } = params;
+			const rules = loadAlertRules();
+			if (action === "get") return textResult$5(`🔔 Alert Configuration\n\nDefault cooldown: ${rules.defaultCooldownSeconds}s\nActive rules: ${rules.rules.length}\nDedup cache entries: ${dedupCache.size}`);
+			if (action === "set_cooldown" && cooldownSeconds !== void 0) {
+				rules.defaultCooldownSeconds = cooldownSeconds;
+				const rulesPath = getAlertRulesPath();
+				ensureDir(join(getWorkspacePath$4(), "config"));
+				const { writeJson } = await import("./file-store-Cp6U-dO6.mjs").then((n) => n.r);
+				writeJson(rulesPath, rules);
+				auditLog("alert-dispatcher", "config_changed", { cooldownSeconds });
+				return textResult$5(`✅ Default cooldown updated to ${cooldownSeconds}s`);
+			}
+			return textResult$5("❌ Invalid action or missing parameters.");
+		}
+	});
+}
+//#endregion
+//#region src/lib/chains.ts
+/**
+* Build an Alchemy HTTP/WSS URL for a given network.
+*/
+function alchemyUrl(network, protocol = "https") {
+	return `${protocol}://${network}.g.alchemy.com/v2/${process.env["ALCHEMY_API_KEY"] || ""}`;
+}
+/**
+* Build a Helius URL for Solana.
+*/
+function heliusUrl(protocol = "https") {
+	const key = process.env["HELIUS_API_KEY"] || "";
+	if (protocol === "wss") return `wss://mainnet.helius-rpc.com/?api-key=${key}`;
+	return `https://mainnet.helius-rpc.com/?api-key=${key}`;
+}
+/**
+* All supported chain configurations.
+*/
+const CHAIN_CONFIGS = {
+	ethereum: {
+		chain: "ethereum",
+		family: "evm",
+		name: "Ethereum",
+		nativeToken: "ETH",
+		rpc: {
+			http: process.env["ETH_RPC_HTTP"] || alchemyUrl("eth-mainnet"),
+			wss: process.env["ETH_RPC_WSS"] || alchemyUrl("eth-mainnet", "wss"),
+			chainId: 1
+		},
+		explorerUrl: "https://etherscan.io",
+		contracts: {
+			uniswapV3Router: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+			uniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+			uniswapV2Factory: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+			weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	base: {
+		chain: "base",
+		family: "evm",
+		name: "Base",
+		nativeToken: "ETH",
+		rpc: {
+			http: process.env["BASE_RPC_HTTP"] || alchemyUrl("base-mainnet"),
+			wss: process.env["BASE_RPC_WSS"] || alchemyUrl("base-mainnet", "wss"),
+			chainId: 8453
+		},
+		explorerUrl: "https://basescan.org",
+		contracts: {
+			uniswapV3Router: "0x2626664c2603336E57B271c5C0b26F421741e481",
+			uniswapV3Factory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+			weth: "0x4200000000000000000000000000000000000006",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	arbitrum: {
+		chain: "arbitrum",
+		family: "evm",
+		name: "Arbitrum One",
+		nativeToken: "ETH",
+		rpc: {
+			http: process.env["ARB_RPC_HTTP"] || alchemyUrl("arb-mainnet"),
+			wss: process.env["ARB_RPC_WSS"] || alchemyUrl("arb-mainnet", "wss"),
+			chainId: 42161
+		},
+		explorerUrl: "https://arbiscan.io",
+		contracts: {
+			uniswapV3Router: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+			uniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+			weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	polygon: {
+		chain: "polygon",
+		family: "evm",
+		name: "Polygon",
+		nativeToken: "MATIC",
+		rpc: {
+			http: process.env["POLYGON_RPC_HTTP"] || alchemyUrl("polygon-mainnet"),
+			wss: process.env["POLYGON_RPC_WSS"] || alchemyUrl("polygon-mainnet", "wss"),
+			chainId: 137
+		},
+		explorerUrl: "https://polygonscan.com",
+		contracts: {
+			uniswapV3Router: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+			uniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+			wmatic: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	bsc: {
+		chain: "bsc",
+		family: "evm",
+		name: "BNB Smart Chain",
+		nativeToken: "BNB",
+		rpc: {
+			http: process.env["BSC_RPC_HTTP"] || "https://bsc-dataseed.binance.org",
+			wss: process.env["BSC_RPC_WSS"] || "wss://bsc-ws-node.nariox.org",
+			chainId: 56
+		},
+		explorerUrl: "https://bscscan.com",
+		contracts: {
+			pancakeFactory: "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73",
+			pancakeRouter: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
+			wbnb: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	optimism: {
+		chain: "optimism",
+		family: "evm",
+		name: "Optimism",
+		nativeToken: "ETH",
+		rpc: {
+			http: process.env["OP_RPC_HTTP"] || alchemyUrl("opt-mainnet"),
+			wss: process.env["OP_RPC_WSS"] || alchemyUrl("opt-mainnet", "wss"),
+			chainId: 10
+		},
+		explorerUrl: "https://optimistic.etherscan.io",
+		contracts: {
+			uniswapV3Router: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+			uniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+			weth: "0x4200000000000000000000000000000000000006",
+			oneInchRouter: "0x1111111254EEB25477B68fb85Ed929f73A960582"
+		}
+	},
+	solana: {
+		chain: "solana",
+		family: "solana",
+		name: "Solana",
+		nativeToken: "SOL",
+		rpc: {
+			http: process.env["SOLANA_RPC_HTTP"] || heliusUrl("https"),
+			wss: process.env["SOLANA_RPC_WSS"] || heliusUrl("wss")
+		},
+		explorerUrl: "https://solscan.io",
+		contracts: {
+			jupiterAggregator: "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
+			raydiumAmm: "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8",
+			pumpFun: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P",
+			wsol: "So11111111111111111111111111111111111111112"
+		}
+	}
+};
+/**
+* Get chain config by chain name.
+*/
+function getChainConfig(chain) {
+	const config = CHAIN_CONFIGS[chain];
+	if (!config) throw new Error(`Unsupported chain: ${chain}`);
+	return config;
+}
+/**
+* Get explorer URL for a transaction.
+*/
+function getExplorerTxUrl(chain, txHash) {
+	const config = getChainConfig(chain);
+	if (chain === "solana") return `${config.explorerUrl}/tx/${txHash}`;
+	return `${config.explorerUrl}/tx/${txHash}`;
+}
+//#endregion
+//#region src/tools/chain-monitor.ts
+/**
+* Chain Monitor Tool — On-chain event monitoring and query.
+*
+* Provides tools for:
+* - Managing chain monitoring subscriptions (watchlist, event types)
+* - Querying transaction details
+* - Retrieving recent on-chain events
+*/
+function getWorkspacePath$3() {
+	return process.env["CLAWVIF_WORKSPACE_PATH"] || join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "workspace");
+}
+function getWatchlistPath() {
+	return join(getWorkspacePath$3(), "config", "watchlist.json");
+}
+function getEventsDir() {
+	return join(getWorkspacePath$3(), "memory", "market-intel", "onchain-events");
+}
+function loadWatchlist() {
+	return readJsonOr(getWatchlistPath(), { addresses: [] });
+}
+function saveWatchlist(watchlist) {
+	ensureDir(join(getWorkspacePath$3(), "config"));
+	writeJson(getWatchlistPath(), watchlist);
+}
+function loadRecentEvents(limit = 50, chain, type) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const yesterday = (/* @__PURE__ */ new Date(Date.now() - 864e5)).toISOString().split("T")[0];
+	const events = [];
+	for (const dateStr of [today, yesterday]) {
+		const filePath = join(getEventsDir(), `${dateStr}.jsonl`);
+		try {
+			const dayEvents = readJsonl(filePath);
+			events.push(...dayEvents);
+		} catch {}
+	}
+	let filtered = events;
+	if (chain) filtered = filtered.filter((e) => e.chain === chain);
+	if (type) filtered = filtered.filter((e) => e.type === type);
+	return filtered.slice(-limit).reverse();
+}
+function textResult$4(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerChainMonitorTools(api) {
+	api.registerTool({
+		name: "chain_subscribe",
+		description: "Manage on-chain monitoring subscriptions. Add or remove addresses from the watchlist, or list currently monitored addresses.",
+		parameters: Type.Object({
+			action: Type.Union([
+				Type.Literal("add"),
+				Type.Literal("remove"),
+				Type.Literal("list")
+			], { description: "Action to perform on the watchlist" }),
+			address: Type.Optional(Type.String({ description: "Address to add or remove" })),
+			chain: Type.Optional(Type.Union([
+				Type.Literal("ethereum"),
+				Type.Literal("base"),
+				Type.Literal("arbitrum"),
+				Type.Literal("solana"),
+				Type.Literal("polygon"),
+				Type.Literal("bsc")
+			], { description: "Chain for the address" })),
+			label: Type.Optional(Type.String({ description: "Label for the address (e.g., \"Jump Trading\")" })),
+			tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for categorization (e.g., [\"vc\", \"market-maker\"])" }))
+		}),
+		async execute(_id, params) {
+			const { action, address, chain, label, tags } = params;
+			const watchlist = loadWatchlist();
+			if (action === "list") {
+				if (watchlist.addresses.length === 0) return textResult$4("📭 Watchlist is empty. Use action \"add\" to monitor addresses.");
+				const lines = watchlist.addresses.map((a, i) => `${i + 1}. **${a.label}** [${a.chain}]\n   \`${a.address}\`\n   Tags: ${a.tags.join(", ") || "none"}`);
+				return textResult$4(`👁️ Monitored Addresses (${watchlist.addresses.length}):\n\n${lines.join("\n\n")}`);
+			}
+			if (action === "add") {
+				if (!address || !chain) return textResult$4("❌ Address and chain are required for adding to watchlist.");
+				if (watchlist.addresses.some((a) => a.address.toLowerCase() === address.toLowerCase())) return textResult$4(`⚠️ Address ${address} is already in the watchlist.`);
+				const entry = {
+					address,
+					chain,
+					label: label || address.slice(0, 8) + "...",
+					tags: tags || [],
+					addedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				watchlist.addresses.push(entry);
+				saveWatchlist(watchlist);
+				auditLog("onchain-monitor", "watchlist_add", {
+					address,
+					chain,
+					label: entry.label
+				});
+				return textResult$4(`✅ Added to watchlist:\n  Address: \`${address}\`\n  Chain: ${chain}\n  Label: ${entry.label}`);
+			}
+			if (action === "remove") {
+				if (!address) return textResult$4("❌ Address is required for removal.");
+				const idx = watchlist.addresses.findIndex((a) => a.address.toLowerCase() === address.toLowerCase());
+				if (idx === -1) return textResult$4(`⚠️ Address ${address} not found in watchlist.`);
+				const removed = watchlist.addresses.splice(idx, 1)[0];
+				saveWatchlist(watchlist);
+				auditLog("onchain-monitor", "watchlist_remove", {
+					address,
+					label: removed.label
+				});
+				return textResult$4(`✅ Removed from watchlist: ${removed.label} (${address})`);
+			}
+			return textResult$4("❌ Invalid action.");
+		}
+	});
+	api.registerTool({
+		name: "chain_query_tx",
+		description: "Query details of a specific transaction by hash. Returns decoded information including method, parameters, and value.",
+		parameters: Type.Object({
+			chain: Type.Union([
+				Type.Literal("ethereum"),
+				Type.Literal("base"),
+				Type.Literal("arbitrum"),
+				Type.Literal("solana"),
+				Type.Literal("polygon"),
+				Type.Literal("bsc")
+			], { description: "Chain to query" }),
+			txHash: Type.String({ description: "Transaction hash to look up" })
+		}),
+		async execute(_id, params) {
+			const { chain, txHash } = params;
+			return textResult$4(`🔍 Transaction Details\n\nChain: ${chain}\nHash: \`${txHash}\`\nExplorer: ${getExplorerTxUrl(chain, txHash)}\n\n_Full transaction decoding requires active RPC connection._`);
+		}
+	});
+	api.registerTool({
+		name: "chain_get_events",
+		description: "Retrieve recent on-chain events detected by the monitoring system. Can filter by chain and event type.",
+		parameters: Type.Object({
+			chain: Type.Optional(Type.Union([
+				Type.Literal("ethereum"),
+				Type.Literal("base"),
+				Type.Literal("arbitrum"),
+				Type.Literal("solana"),
+				Type.Literal("polygon"),
+				Type.Literal("bsc")
+			], { description: "Filter by chain (optional)" })),
+			type: Type.Optional(Type.Union([
+				Type.Literal("large_transfer"),
+				Type.Literal("new_pool"),
+				Type.Literal("smart_money_move"),
+				Type.Literal("contract_deploy")
+			], { description: "Filter by event type (optional)" })),
+			limit: Type.Optional(Type.Number({
+				description: "Number of events to return (default: 20, max: 100)",
+				minimum: 1,
+				maximum: 100
+			}))
+		}),
+		async execute(_id, params) {
+			const { chain, type, limit = 20 } = params;
+			const events = loadRecentEvents(Math.min(limit, 100), chain, type);
+			if (events.length === 0) return textResult$4("📭 No on-chain events found matching your criteria.");
+			const formatted = events.map((e) => {
+				const label = e.fromLabel ? ` (${e.fromLabel})` : "";
+				return `• **${e.type}** [${e.chain}] — ${e.confidence} confidence\n  ${e.action}\n  From: \`${e.from}\`${label}\n  TX: \`${e.txHash.slice(0, 16)}...\`\n  ${e.timestamp}`;
+			});
+			const filterDesc = [chain && `chain=${chain}`, type && `type=${type}`].filter(Boolean).join(", ");
+			return textResult$4(`${filterDesc ? `🔗 On-Chain Events (${filterDesc})` : "🔗 Recent On-Chain Events"}\n\n${formatted.join("\n\n")}\n\nShowing ${events.length} events.`);
+		}
+	});
+}
+//#endregion
+//#region src/tools/sentiment.ts
+/**
+* Sentiment Analysis Tool — Multi-source social media sentiment tracking.
+*
+* Aggregates sentiment data from:
+* - X/Twitter (KOL mentions, volume spikes)
+* - Telegram groups (alpha calls, CA extraction)
+* - Discord (community sentiment)
+*
+* Uses LLM for sentiment classification and produces
+* standardized sentiment scores per token.
+*/
+function getWorkspacePath$2() {
+	return process.env["CLAWVIF_WORKSPACE_PATH"] || join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "workspace");
+}
+function getSentimentDir() {
+	return join(getWorkspacePath$2(), "memory", "market-intel", "sentiment");
+}
+function loadRecentSentiment(token, limit = 50) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const filePath = join(getSentimentDir(), `${today}.jsonl`);
+	try {
+		let entries = readJsonl(filePath);
+		if (token) entries = entries.filter((e) => e.token.toLowerCase() === token.toLowerCase());
+		return entries.slice(-limit).reverse();
+	} catch {
+		return [];
+	}
+}
+function saveSentimentScore(score) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	ensureDir(getSentimentDir());
+	appendJsonl(join(getSentimentDir(), `${today}.jsonl`), score);
+}
+function formatSentimentScore(s) {
+	const emoji = s.sentimentScore > .3 ? "🟢" : s.sentimentScore < -.3 ? "🔴" : "🟡";
+	const deltaEmoji = s.sentimentDelta1h > 0 ? "↑" : s.sentimentDelta1h < 0 ? "↓" : "→";
+	const spikeFlag = s.mentionSpike ? "🔥 SPIKE" : "";
+	let text = `${emoji} **${s.token}** — Sentiment: ${s.sentimentScore.toFixed(2)} ${spikeFlag}\n  Score delta (1h): ${deltaEmoji}${s.sentimentDelta1h.toFixed(2)}\n  Mentions (1h): ${s.mentionCount1h}\n  TG Alpha hits: ${s.telegramAlphaHits}`;
+	if (s.topKolSignals.length > 0) {
+		const kolLines = s.topKolSignals.map((k) => `    • ${k.handle}: ${k.stance} (reach: ${k.reach.toLocaleString()})`);
+		text += `\n  KOL Signals:\n${kolLines.join("\n")}`;
+	}
+	if (s.extractedCa) text += `\n  CA: \`${s.extractedCa}\``;
+	text += `\n  Updated: ${s.timestamp}`;
+	return text;
+}
+function textResult$3(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerSentimentTools(api) {
+	api.registerTool({
+		name: "sentiment_query",
+		description: "Query the current sentiment score for a specific token. Returns the latest sentiment data including score (-1.0 to 1.0), delta, mention count, KOL signals, and Telegram alpha group hits.",
+		parameters: Type.Object({
+			token: Type.String({ description: "Token symbol (e.g., \"BTC\", \"ETH\", \"BONK\") or contract address" }),
+			chain: Type.Optional(Type.String({ description: "Chain to filter by (optional)" }))
+		}),
+		async execute(_id, params) {
+			const { token } = params;
+			const scores = loadRecentSentiment(token, 5);
+			if (scores.length === 0) return textResult$3(`📊 No sentiment data available for **${token}**.\n\nUse \`sentiment_scan\` to trigger a fresh scan, or wait for the next scheduled scan.`);
+			const latest = scores[0];
+			const formatted = formatSentimentScore(latest);
+			let trend = "";
+			if (scores.length > 1) {
+				const oldest = scores[scores.length - 1];
+				const change = latest.sentimentScore - oldest.sentimentScore;
+				trend = `\n\n📈 Trend (last ${scores.length} readings): ${change > 0 ? "↑" : "↓"} ${change.toFixed(2)}`;
+			}
+			return textResult$3(`📊 Sentiment Analysis — ${token}\n\n${formatted}${trend}`);
+		}
+	});
+	api.registerTool({
+		name: "sentiment_scan",
+		description: "Trigger a comprehensive sentiment scan across all data sources. Scans X/Twitter, Telegram groups, and Discord for market sentiment. Results are stored in market-intel/sentiment/ for later query. Returns a summary of the scan results.",
+		parameters: Type.Object({ tokens: Type.Optional(Type.Array(Type.String(), { description: "Specific tokens to scan (default: scan trending tokens)" })) }),
+		async execute(_id, params) {
+			const { tokens } = params;
+			const scanTargets = tokens || [
+				"BTC",
+				"ETH",
+				"SOL"
+			];
+			const results = [];
+			for (const token of scanTargets) {
+				const score = {
+					token,
+					sentimentScore: 0,
+					sentimentDelta1h: 0,
+					mentionCount1h: 0,
+					mentionSpike: false,
+					topKolSignals: [],
+					telegramAlphaHits: 0,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				saveSentimentScore(score);
+				results.push(score);
+			}
+			auditLog("sentiment-radar", "scan_completed", {
+				tokens: scanTargets,
+				resultCount: results.length
+			});
+			const summary = results.map((r) => formatSentimentScore(r)).join("\n\n");
+			return textResult$3(`📊 Sentiment Scan Complete\n\nScanned ${scanTargets.length} tokens.\n\n${summary}\n\n_Note: For real-time data, ensure X API and Telegram API credentials are configured._`);
+		}
+	});
+}
+//#endregion
+//#region src/tools/whale.ts
+/**
+* Whale Tracker Tool — High-level whale behavior analysis.
+*
+* Built on top of the on-chain monitor output, provides:
+* - Recent whale movement summaries
+* - Address behavior profiling (preferred chains, DEXes, win rate)
+* - Accumulation/distribution pattern detection
+* - Cross-correlation signals (multiple whales buying same token)
+*/
+function getWorkspacePath$1() {
+	return process.env["CLAWVIF_WORKSPACE_PATH"] || join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "workspace");
+}
+function getWhaleDir() {
+	return join(getWorkspacePath$1(), "memory", "market-intel", "whale-movements");
+}
+function getProfilesDir() {
+	return join(getWorkspacePath$1(), "memory", "knowledge", "wallet-profiles");
+}
+function loadRecentWhaleAlerts(limit = 50, chain) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const yesterday = (/* @__PURE__ */ new Date(Date.now() - 864e5)).toISOString().split("T")[0];
+	const alerts = [];
+	for (const dateStr of [today, yesterday]) {
+		const filePath = join(getWhaleDir(), `${dateStr}.jsonl`);
+		try {
+			alerts.push(...readJsonl(filePath));
+		} catch {}
+	}
+	let filtered = alerts;
+	if (chain) filtered = filtered.filter((a) => a.chain === chain);
+	return filtered.slice(-limit).reverse();
+}
+function loadWhaleProfile(address) {
+	const safeName = address.replace(/[^a-zA-Z0-9]/g, "_");
+	return readJsonOr(join(getProfilesDir(), `${safeName}.json`), null);
+}
+function saveWhaleProfile(profile) {
+	const safeName = profile.address.replace(/[^a-zA-Z0-9]/g, "_");
+	ensureDir(getProfilesDir());
+	writeJson(join(getProfilesDir(), `${safeName}.json`), profile);
+}
+function formatWhaleAlert(alert) {
+	const labelStr = alert.addressLabel ? ` (${alert.addressLabel})` : "";
+	const patternStr = alert.pattern && alert.pattern !== "unknown" ? `\n  Pattern: ${alert.pattern}` : "";
+	return `• 🐋 **${alert.action}**\n  Address: \`${alert.address}\`${labelStr}\n  Token: ${alert.token.symbol} — ${alert.token.amount}\n  Value: $${alert.valueUsd.toLocaleString()}\n  Chain: ${alert.chain} | TX: \`${alert.txHash.slice(0, 16)}...\`${patternStr}\n  ${alert.timestamp}`;
+}
+function formatWhaleProfile(profile) {
+	const labelStr = profile.label ? ` (${profile.label})` : "";
+	let text = `🐋 Whale Profile: \`${profile.address}\`${labelStr}\n\n📊 Statistics:\n  Active chains: ${profile.activeChains.join(", ")}\n  Preferred DEXes: ${profile.preferredDexes.join(", ") || "Unknown"}\n  Avg holding period: ${profile.avgHoldingPeriodHours.toFixed(1)}h\n  Win rate: ${(profile.winRate * 100).toFixed(1)}%\n  Total trades tracked: ${profile.totalTrades}\n  Last updated: ${profile.lastUpdated}`;
+	if (profile.recentActivity.length > 0) {
+		const activities = profile.recentActivity.slice(0, 5).map((a) => `    • ${a.action} ${a.token} — $${a.valueUsd.toLocaleString()} (${a.timestamp})`);
+		text += `\n\n📋 Recent Activity:\n${activities.join("\n")}`;
+	}
+	return text;
+}
+function textResult$2(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerWhaleTools(api) {
+	api.registerTool({
+		name: "whale_query",
+		description: "Query recent whale movements. Returns large transactions from tracked wallets with pattern analysis (accumulation/distribution detection).",
+		parameters: Type.Object({
+			chain: Type.Optional(Type.Union([
+				Type.Literal("ethereum"),
+				Type.Literal("base"),
+				Type.Literal("arbitrum"),
+				Type.Literal("solana"),
+				Type.Literal("polygon"),
+				Type.Literal("bsc")
+			], { description: "Filter by chain (optional)" })),
+			timeframe: Type.Optional(Type.Union([
+				Type.Literal("1h"),
+				Type.Literal("24h"),
+				Type.Literal("7d")
+			], { description: "Time window for query (default: 24h)" })),
+			limit: Type.Optional(Type.Number({
+				description: "Number of results (default: 20, max: 100)",
+				minimum: 1,
+				maximum: 100
+			}))
+		}),
+		async execute(_id, params) {
+			const { chain, limit = 20 } = params;
+			const alerts = loadRecentWhaleAlerts(Math.min(limit, 100), chain);
+			if (alerts.length === 0) return textResult$2("🐋 No whale movements detected in the selected timeframe.\n\nEnsure on-chain monitoring is active and addresses are in the watchlist.");
+			const formatted = alerts.map(formatWhaleAlert);
+			return textResult$2(`🐋 Whale Movements (${chain || "all chains"})\n\n${formatted.join("\n\n")}\n\nShowing ${alerts.length} movements.`);
+		}
+	});
+	api.registerTool({
+		name: "whale_profile",
+		description: "Get or build a behavior profile for a specific address. Shows preferred chains, DEXes, average holding period, historical win rate, and recent activity.",
+		parameters: Type.Object({ address: Type.String({ description: "Wallet address to profile" }) }),
+		async execute(_id, params) {
+			const { address } = params;
+			let profile = loadWhaleProfile(address);
+			if (!profile) {
+				profile = {
+					address,
+					activeChains: [],
+					preferredDexes: [],
+					avgHoldingPeriodHours: 0,
+					winRate: 0,
+					totalTrades: 0,
+					recentActivity: [],
+					lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				saveWhaleProfile(profile);
+				return textResult$2(`🐋 New Profile Created for \`${address}\`\n\nNo historical data yet. The profile will be enriched as on-chain activity is monitored.\n\nTo build a profile faster, add this address to the watchlist:\n\`chain_subscribe add ${address}\``);
+			}
+			return textResult$2(formatWhaleProfile(profile));
+		}
+	});
+}
+//#endregion
+//#region src/services/telegram-scanner.ts
+/**
+* Telegram Group Scanner Service — Deep scanning of Telegram groups
+* for alpha calls, contract addresses, and bot signals.
+*
+* Uses Telegram MTProto API via session string authentication.
+* Falls back to HTTPS Bot API when MTProto is unavailable.
+*
+* Architecture:
+* - Subscriptions stored in memory + persisted to tg-scanner-state.json
+* - Messages processed through CA extraction pipeline
+* - First-call detection via JSONL history
+* - Call performance tracked with entry price snapshots
+*/
+const EVM_CA_REGEX = /\b(0x[a-fA-F0-9]{40})\b/g;
+const SOLANA_CA_REGEX = /\b([1-9A-HJ-NP-Za-km-z]{32,44})\b/g;
+const TICKER_REGEX = /\$([A-Z]{2,10})\b/g;
+const URL_REGEX = /https?:\/\/[^\s<>)"]+/g;
+const KNOWN_BOT_PATTERNS = [
+	{
+		name: "Maestro",
+		pattern: /maestro|🤖.*sniper|auto.?buy/i
+	},
+	{
+		name: "BananaGun",
+		pattern: /banana\s?gun|🍌.*snipe/i
+	},
+	{
+		name: "Unibot",
+		pattern: /unibot|📈.*limit.*order/i
+	},
+	{
+		name: "BONKbot",
+		pattern: /bonkbot|🐶.*swap/i
+	},
+	{
+		name: "Trojan",
+		pattern: /trojan.*bot|🏛️.*swap/i
+	},
+	{
+		name: "SolTradingBot",
+		pattern: /sol.*trading.*bot/i
+	},
+	{
+		name: "BullX",
+		pattern: /bullx|🐂.*trade/i
+	},
+	{
+		name: "Photon",
+		pattern: /photon.*bot|⚡.*swap/i
+	}
+];
+const SOLANA_ADDR_EXCLUDED = new Set([
+	"So11111111111111111111111111111111111111112",
+	"11111111111111111111111111111111",
+	"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+	"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+	"SysvarRent111111111111111111111111111111111",
+	"SysvarC1ock11111111111111111111111111111111"
+]);
+function getWorkspacePath() {
+	return process.env["CLAWVIF_WORKSPACE_PATH"] || join(process.env["HOME"] || process.env["USERPROFILE"] || "/tmp", ".clawvif", "workspace");
+}
+function getScannerDir() {
+	return join(getWorkspacePath(), "memory", "market-intel", "tg-scanner");
+}
+function getStatePath() {
+	return join(getScannerDir(), "scanner-state.json");
+}
+function getCaRegistryPath() {
+	return join(getScannerDir(), "ca-registry.json");
+}
+function getMessagesLogPath() {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	return join(getScannerDir(), "messages", `${today}.jsonl`);
+}
+function getFirstCallsLogPath() {
+	return join(getScannerDir(), "first-calls.jsonl");
+}
+function loadScannerState() {
+	return readJsonOr(getStatePath(), {
+		subscriptions: [],
+		totalMessagesProcessed: 0,
+		totalCaExtracted: 0,
+		lastScanAt: null
+	});
+}
+function saveScannerState(state) {
+	ensureDir(getScannerDir());
+	writeJson(getStatePath(), state);
+}
+function loadCaRegistry() {
+	return readJsonOr(getCaRegistryPath(), {});
+}
+function saveCaRegistry(registry) {
+	ensureDir(getScannerDir());
+	writeJson(getCaRegistryPath(), registry);
+}
+/**
+* Extract contract addresses from a message text.
+*/
+function extractContractAddresses(text) {
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(EVM_CA_REGEX)) {
+		const addr = match[1];
+		if (!seen.has(addr.toLowerCase())) {
+			seen.add(addr.toLowerCase());
+			results.push({
+				address: addr,
+				chain: "evm"
+			});
+		}
+	}
+	for (const match of text.matchAll(SOLANA_CA_REGEX)) {
+		const addr = match[1];
+		if (!seen.has(addr) && !SOLANA_ADDR_EXCLUDED.has(addr) && /[A-Z]/.test(addr) && /[a-z]/.test(addr) && /\d/.test(addr) && addr.length >= 32) {
+			seen.add(addr);
+			results.push({
+				address: addr,
+				chain: "solana"
+			});
+		}
+	}
+	return results;
+}
+/**
+* Extract ticker symbols ($XXX) from message text.
+*/
+function extractTickers(text) {
+	const tickers = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(TICKER_REGEX)) {
+		const ticker = match[1].toUpperCase();
+		if (!seen.has(ticker)) {
+			seen.add(ticker);
+			tickers.push(ticker);
+		}
+	}
+	return tickers;
+}
+/**
+* Extract URLs from message text.
+*/
+function extractUrls(text) {
+	const urls = [];
+	for (const match of text.matchAll(URL_REGEX)) urls.push(match[0]);
+	return urls;
+}
+/**
+* Detect if a message is from a known trading bot.
+*/
+function detectBotSignal(text) {
+	for (const { name, pattern } of KNOWN_BOT_PATTERNS) if (pattern.test(text)) return {
+		isBot: true,
+		botName: name,
+		confidence: .85
+	};
+	const botIndicators = [
+		/\b(buy|sell)\s+\d+(\.\d+)?\s+(SOL|ETH|BNB)\b/i,
+		/tx:\s*[A-Za-z0-9]{40,}/i,
+		/slippage:\s*\d+%/i,
+		/gas:\s*\d+\s*gwei/i
+	];
+	let indicatorCount = 0;
+	for (const indicator of botIndicators) if (indicator.test(text)) indicatorCount++;
+	if (indicatorCount >= 2) return {
+		isBot: true,
+		botName: "unknown",
+		confidence: .6
+	};
+	return {
+		isBot: false,
+		botName: null,
+		confidence: 0
+	};
+}
+/**
+* Process a message: extract CAs, tickers, detect bots, and update state.
+*/
+function processMessage(groupId, groupName, senderId, senderName, text, timestamp) {
+	const ts = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+	const cas = extractContractAddresses(text);
+	const tickers = extractTickers(text);
+	const urls = extractUrls(text);
+	const botDetection = detectBotSignal(text);
+	const message = {
+		groupId,
+		groupName,
+		senderId,
+		senderName,
+		contractAddresses: cas.map((c) => c.address),
+		tickers,
+		urls,
+		isBot: botDetection.isBot,
+		text,
+		timestamp: ts
+	};
+	ensureDir(join(getScannerDir(), "messages"));
+	appendJsonl(getMessagesLogPath(), message);
+	const registry = loadCaRegistry();
+	const newCas = [];
+	for (const ca of cas) {
+		const key = ca.address.toLowerCase();
+		const existing = registry[key];
+		if (!existing) {
+			registry[key] = {
+				contractAddress: ca.address,
+				chain: ca.chain,
+				firstSeenAt: ts,
+				firstSeenGroupId: groupId,
+				firstSeenGroupName: groupName,
+				firstSeenBy: senderName,
+				mentionCount: 1,
+				groups: [groupId],
+				entryPriceUsd: null,
+				currentPriceUsd: null,
+				performancePct: null,
+				lastUpdated: ts
+			};
+			appendJsonl(getFirstCallsLogPath(), {
+				contractAddress: ca.address,
+				chain: ca.chain,
+				groupId,
+				groupName,
+				callerName: senderName,
+				timestamp: ts
+			});
+			newCas.push({
+				...ca,
+				isFirstCall: true
+			});
+		} else {
+			existing.mentionCount++;
+			if (!existing.groups.includes(groupId)) existing.groups.push(groupId);
+			existing.lastUpdated = ts;
+			newCas.push({
+				...ca,
+				isFirstCall: false
+			});
+		}
+	}
+	saveCaRegistry(registry);
+	const state = loadScannerState();
+	state.totalMessagesProcessed++;
+	state.totalCaExtracted += cas.length;
+	state.lastScanAt = ts;
+	const sub = state.subscriptions.find((s) => s.groupId === groupId);
+	if (sub) {
+		sub.lastMessageAt = ts;
+		sub.messageCount++;
+	}
+	saveScannerState(state);
+	return {
+		message,
+		newCas,
+		botDetection
+	};
+}
+/**
+* Subscribe to a Telegram group for scanning.
+*/
+function subscribeGroup(groupId, groupName, type) {
+	const state = loadScannerState();
+	const existing = state.subscriptions.find((s) => s.groupId === groupId);
+	if (existing) {
+		existing.type = type;
+		existing.enabled = true;
+		saveScannerState(state);
+		auditLog("tg-scanner", "group_updated", {
+			groupId,
+			groupName,
+			type
+		});
+		return existing;
+	}
+	const sub = {
+		groupId,
+		groupName,
+		type,
+		enabled: true,
+		subscribedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		lastMessageAt: null,
+		messageCount: 0
+	};
+	state.subscriptions.push(sub);
+	saveScannerState(state);
+	auditLog("tg-scanner", "group_subscribed", {
+		groupId,
+		groupName,
+		type
+	});
+	return sub;
+}
+/**
+* Check if a CA is a first call in the registry.
+*/
+function checkFirstCall(contractAddress) {
+	const record = loadCaRegistry()[contractAddress.toLowerCase()] || null;
+	if (!record) return {
+		isFirstCall: true,
+		record: null
+	};
+	return {
+		isFirstCall: record.mentionCount <= 1,
+		record
+	};
+}
+/**
+* Get call performance data for a contract address.
+*/
+function getCallPerformance(contractAddress) {
+	const firstCalls = readJsonl(getFirstCallsLogPath());
+	const registry = loadCaRegistry();
+	const key = contractAddress.toLowerCase();
+	const caRecord = registry[key];
+	return firstCalls.filter((fc) => fc.contractAddress.toLowerCase() === key).map((fc) => ({
+		contractAddress: fc.contractAddress,
+		chain: fc.chain || "solana",
+		callerName: fc.callerName,
+		groupId: fc.groupId,
+		groupName: fc.groupName,
+		callTimestamp: fc.timestamp,
+		entryPriceUsd: caRecord?.entryPriceUsd ?? null,
+		peakPriceUsd: null,
+		currentPriceUsd: caRecord?.currentPriceUsd ?? null,
+		returnPct: caRecord?.performancePct ?? null,
+		peakReturnPct: null
+	}));
+}
+/**
+* Get caller stats for a group or specific sender.
+*/
+function getCallerStats(groupId) {
+	const firstCalls = readJsonl(getFirstCallsLogPath());
+	const filtered = groupId ? firstCalls.filter((fc) => fc.groupId === groupId) : firstCalls;
+	const statsMap = /* @__PURE__ */ new Map();
+	for (const fc of filtered) {
+		const key = `${fc.callerName}:${fc.groupId}`;
+		const existing = statsMap.get(key);
+		if (existing) existing.totalCalls++;
+		else statsMap.set(key, {
+			callerName: fc.callerName,
+			totalCalls: 1,
+			groupId: fc.groupId
+		});
+	}
+	return Array.from(statsMap.values()).sort((a, b) => b.totalCalls - a.totalCalls);
+}
+//#endregion
+//#region src/tools/tg-scanner.ts
+/**
+* Telegram Group Scanner Tool — Deep scanning of Telegram groups
+* for alpha calls, contract addresses, and bot signal detection.
+*
+* Registers 5 tools as specified in tg-group-scanner SKILL.md:
+* - tg_scanner_subscribe
+* - tg_scanner_extract_ca
+* - tg_scanner_first_call_check
+* - tg_scanner_call_performance
+* - tg_scanner_detect_bot_signal
+*/
+function textResult$1(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerTgScannerTools(api) {
+	api.registerTool({
+		name: "tg_scanner_subscribe",
+		description: "Subscribe to a Telegram group for deep scanning. Monitors messages for contract addresses, alpha calls, and bot signals. Supports group types: alpha, dev, community, signal.",
+		parameters: Type.Object({
+			groupId: Type.String({ description: "Telegram group/channel ID or @username" }),
+			groupName: Type.String({ description: "Display name for the group" }),
+			type: Type.Union([
+				Type.Literal("alpha"),
+				Type.Literal("dev"),
+				Type.Literal("community"),
+				Type.Literal("signal")
+			], { description: "Group type classification" })
+		}),
+		async execute(_id, params) {
+			const { groupId, groupName, type } = params;
+			const sub = subscribeGroup(groupId, groupName, type);
+			const totalSubs = loadScannerState().subscriptions.filter((s) => s.enabled).length;
+			const hasCreds = !!process.env["TG_API_ID"] && !!process.env["TG_API_HASH"] && !!process.env["TG_SESSION_STRING"];
+			let text = `✅ Subscribed to Telegram group\n\nGroup: **${groupName}**\nID: \`${groupId}\`\nType: ${type}\nSubscribed at: ${sub.subscribedAt}\nTotal active subscriptions: ${totalSubs}\n`;
+			if (!hasCreds) text += "\n⚠️ MTProto credentials not configured.\nSet TG_API_ID, TG_API_HASH, and TG_SESSION_STRING in .env for live scanning.\nManual message processing via tg_scanner_extract_ca is still available.";
+			else text += `\n🟢 MTProto credentials detected — live scanning available.`;
+			return textResult$1(text);
+		}
+	});
+	api.registerTool({
+		name: "tg_scanner_extract_ca",
+		description: "Extract contract addresses from a Telegram message text. Detects EVM (0x...) and Solana addresses, extracts ticker symbols ($XXX), URLs, and detects bot signals. Automatically checks if any CA is a first call.",
+		parameters: Type.Object({
+			text: Type.String({ description: "Message text to analyze" }),
+			groupId: Type.Optional(Type.String({ description: "Group ID the message is from (for tracking)" })),
+			groupName: Type.Optional(Type.String({ description: "Group display name" })),
+			senderId: Type.Optional(Type.String({ description: "Sender user ID" })),
+			senderName: Type.Optional(Type.String({ description: "Sender display name" }))
+		}),
+		async execute(_id, params) {
+			const { text: msgText, groupId = "manual", groupName = "Manual Input", senderId = "unknown", senderName = "Unknown" } = params;
+			const { message, newCas, botDetection } = processMessage(groupId, groupName, senderId, senderName, msgText);
+			let resultText = `🔍 CA Extraction Results\n\n`;
+			if (newCas.length === 0) resultText += `No contract addresses found in the message.\n`;
+			else {
+				resultText += `Found ${newCas.length} contract address(es):\n\n`;
+				for (const ca of newCas) {
+					const firstCallTag = ca.isFirstCall ? " 🆕 FIRST CALL" : "";
+					resultText += `  • \`${ca.address}\` [${ca.chain.toUpperCase()}]${firstCallTag}\n`;
+				}
+			}
+			if (message.tickers.length > 0) resultText += `\nTickers: ${message.tickers.map((t) => `$${t}`).join(", ")}\n`;
+			if (botDetection.isBot) resultText += `\n🤖 Bot signal detected: **${botDetection.botName}** (confidence: ${(botDetection.confidence * 100).toFixed(0)}%)\n`;
+			if (message.urls.length > 0) resultText += `\nURLs: ${message.urls.length} link(s) found\n`;
+			auditLog("tg-scanner", "ca_extracted", {
+				groupId,
+				casFound: newCas.length,
+				firstCalls: newCas.filter((c) => c.isFirstCall).length,
+				isBot: botDetection.isBot
+			});
+			return textResult$1(resultText);
+		}
+	});
+	api.registerTool({
+		name: "tg_scanner_first_call_check",
+		description: "Check if a contract address is a first call (never seen before in any alpha group). Returns first-call status and historical data if the CA has been seen before.",
+		parameters: Type.Object({ contractAddress: Type.String({ description: "Contract address to check (EVM 0x... or Solana base58)" }) }),
+		async execute(_id, params) {
+			const { contractAddress } = params;
+			const { isFirstCall, record } = checkFirstCall(contractAddress);
+			if (isFirstCall && !record) return textResult$1(`🆕 **FIRST CALL** — This CA has never been seen before!\n\nCA: \`${contractAddress}\`\nStatus: Never mentioned in any tracked group\n\n⚡ Consider running risk_check_contract to verify safety before any action.`);
+			if (isFirstCall && record) return textResult$1(`🆕 **FIRST CALL** — Only 1 mention so far\n\nCA: \`${record.contractAddress}\`\nChain: ${record.chain}\nFirst seen: ${record.firstSeenAt}\nFirst seen in: ${record.firstSeenGroupName}\nFirst called by: ${record.firstSeenBy}\nTotal mentions: ${record.mentionCount}\nGroups: ${record.groups.length}`);
+			if (record) {
+				const perfText = record.performancePct !== null ? `${record.performancePct >= 0 ? "+" : ""}${record.performancePct.toFixed(1)}%` : "N/A";
+				return textResult$1(`📋 CA already tracked — Not a first call\n\nCA: \`${record.contractAddress}\`\nChain: ${record.chain}\nFirst seen: ${record.firstSeenAt}\nFirst seen in: ${record.firstSeenGroupName}\nFirst called by: ${record.firstSeenBy}\nTotal mentions: ${record.mentionCount}\nGroups mentioning: ${record.groups.length}\nEntry price: ${record.entryPriceUsd !== null ? `$${record.entryPriceUsd}` : "N/A"}\nPerformance: ${perfText}`);
+			}
+			return textResult$1(`🆕 **FIRST CALL** — CA not in registry\n\nCA: \`${contractAddress}\``);
+		}
+	});
+	api.registerTool({
+		name: "tg_scanner_call_performance",
+		description: "Query call performance for a contract address or a group. Shows price change since first call, caller stats, and historical performance data.",
+		parameters: Type.Object({
+			contractAddress: Type.Optional(Type.String({ description: "Specific CA to check performance for" })),
+			groupId: Type.Optional(Type.String({ description: "Group ID to get caller stats for" }))
+		}),
+		async execute(_id, params) {
+			const { contractAddress, groupId } = params;
+			if (contractAddress) {
+				const performances = getCallPerformance(contractAddress);
+				if (performances.length === 0) return textResult$1(`📊 No call performance data for \`${contractAddress}\`\n\nThis CA has not been tracked through the scanner yet.`);
+				let text = `📊 Call Performance: \`${contractAddress}\`\n\n`;
+				for (const perf of performances) {
+					const returnText = perf.returnPct !== null ? `${perf.returnPct >= 0 ? "🟢 +" : "🔴 "}${perf.returnPct.toFixed(1)}%` : "⏳ Pending";
+					text += `Caller: **${perf.callerName}** in ${perf.groupName}\nCalled at: ${perf.callTimestamp}\nEntry: ${perf.entryPriceUsd !== null ? `$${perf.entryPriceUsd}` : "N/A"}\nCurrent: ${perf.currentPriceUsd !== null ? `$${perf.currentPriceUsd}` : "N/A"}\nReturn: ${returnText}\n\n`;
+				}
+				return textResult$1(text);
+			}
+			const stats = getCallerStats(groupId);
+			if (stats.length === 0) return textResult$1(`📊 No caller stats available${groupId ? ` for group ${groupId}` : ""}.\n\nProcess some messages with tg_scanner_extract_ca first.`);
+			let text = `📊 Caller Stats${groupId ? ` — Group ${groupId}` : ""}\n\n`;
+			text += `Top callers by first-call count:\n\n`;
+			for (const stat of stats.slice(0, 20)) text += `  • **${stat.callerName}**: ${stat.totalCalls} first calls (${stat.groupId})\n`;
+			return textResult$1(text);
+		}
+	});
+	api.registerTool({
+		name: "tg_scanner_detect_bot_signal",
+		description: "Detect if a message is from a known trading bot (Maestro, BananaGun, Unibot, etc.). Also extracts any contract addresses found in the bot message.",
+		parameters: Type.Object({ text: Type.String({ description: "Message text to analyze for bot patterns" }) }),
+		async execute(_id, params) {
+			const { text: msgText } = params;
+			const detection = detectBotSignal(msgText);
+			const cas = extractContractAddresses(msgText);
+			const tickers = extractTickers(msgText);
+			let resultText = `🤖 Bot Signal Detection\n\n`;
+			if (detection.isBot) resultText += `**Bot detected: ${detection.botName}**\nConfidence: ${(detection.confidence * 100).toFixed(0)}%\n\n`;
+			else resultText += `No bot pattern detected — likely a human message.\n\n`;
+			if (cas.length > 0) {
+				resultText += `Contract addresses in message:\n`;
+				for (const ca of cas) resultText += `  • \`${ca.address}\` [${ca.chain.toUpperCase()}]\n`;
+			}
+			if (tickers.length > 0) resultText += `\nTickers: ${tickers.map((t) => `$${t}`).join(", ")}\n`;
+			resultText += "\n💡 Bot signals can indicate trending tokens but may have higher risk due to front-running and sandwich attacks.";
+			return textResult$1(resultText);
+		}
+	});
+}
+//#endregion
+//#region src/services/telegram-listener.ts
+/**
+* Telegram Listener Service — Bot API based message listener.
+*
+* Connects to Telegram using a Bot Token (from @BotFather) and receives
+* messages via long polling. The bot must be added to groups/channels
+* as an admin to receive messages.
+*
+* Forwards incoming messages from subscribed groups/channels to the
+* existing telegram-scanner pipeline for CA extraction, bot detection, etc.
+*/
+let bot = null;
+let stats = {
+	running: false,
+	connectedAt: null,
+	messagesReceived: 0,
+	messagesProcessed: 0,
+	errors: 0,
+	subscribedGroupIds: []
+};
+let externalHandlers = [];
+function getSubscribedGroupIds() {
+	const state = loadScannerState();
+	return new Set(state.subscriptions.filter((s) => s.enabled).map((s) => s.groupId));
+}
+function isSubscribed(chatId) {
+	const subscribed = getSubscribedGroupIds();
+	if (subscribed.size === 0) return true;
+	return subscribed.has(chatId) || subscribed.has(`-${chatId}`) || subscribed.has(`-100${chatId}`);
+}
+function handleMessage(ctx) {
+	stats.messagesReceived++;
+	try {
+		const msg = ctx.message ?? ctx.channelPost;
+		if (!msg) return;
+		const text = msg.text ?? msg.caption ?? "";
+		if (!text.trim()) return;
+		const chatId = String(msg.chat.id);
+		if (!isSubscribed(chatId.replace(/^-100/, "")) && !isSubscribed(chatId)) return;
+		const groupName = "title" in msg.chat && msg.chat.title ? msg.chat.title : `chat:${chatId}`;
+		let senderId = "unknown";
+		let senderName = "Unknown";
+		if (msg.from) {
+			senderId = String(msg.from.id);
+			senderName = [msg.from.first_name, msg.from.last_name].filter(Boolean).join(" ");
+		}
+		const timestamp = (/* @__PURE__ */ new Date(msg.date * 1e3)).toISOString();
+		processMessage(chatId, groupName, senderId, senderName, text, timestamp);
+		stats.messagesProcessed++;
+		for (const handler of externalHandlers) try {
+			handler({
+				groupId: chatId,
+				groupName,
+				senderId,
+				senderName,
+				text,
+				timestamp
+			});
+		} catch {}
+	} catch (err) {
+		stats.errors++;
+		auditLog("tg-listener", "message_error", { error: err instanceof Error ? err.message : String(err) });
+	}
+}
+async function startTgListener(config) {
+	if (bot && stats.running) {
+		auditLog("tg-listener", "start_skipped", { reason: "already_running" });
+		return;
+	}
+	bot = new Bot(config.botToken);
+	bot.on("message:text", handleMessage);
+	bot.on("message:caption", handleMessage);
+	bot.on("channel_post:text", handleMessage);
+	bot.on("channel_post:caption", handleMessage);
+	bot.catch((err) => {
+		stats.errors++;
+		auditLog("tg-listener", "bot_error", { error: err.message || String(err) });
+	});
+	bot.start({ onStart: () => {
+		auditLog("tg-listener", "polling_started", {});
+	} });
+	stats = {
+		running: true,
+		connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		messagesReceived: 0,
+		messagesProcessed: 0,
+		errors: 0,
+		subscribedGroupIds: Array.from(getSubscribedGroupIds())
+	};
+	auditLog("tg-listener", "started", { subscribedGroups: stats.subscribedGroupIds.length });
+}
+async function stopTgListener() {
+	if (bot) {
+		try {
+			await bot.stop();
+		} catch {}
+		bot = null;
+	}
+	stats.running = false;
+	auditLog("tg-listener", "stopped", {
+		totalReceived: stats.messagesReceived,
+		totalProcessed: stats.messagesProcessed,
+		totalErrors: stats.errors
+	});
+}
+function getTgListenerStats() {
+	if (stats.running) stats.subscribedGroupIds = Array.from(getSubscribedGroupIds());
+	return { ...stats };
+}
+function isTgListenerRunning() {
+	return stats.running;
+}
+//#endregion
+//#region src/tools/tg-listener.ts
+/**
+* Telegram Listener Tool — Registers tools for controlling the Bot API
+* message listener via the OpenClaw plugin API.
+*
+* Tools:
+* - tg_listener_start: Start listening for messages
+* - tg_listener_stop: Stop the listener
+* - tg_listener_status: Get current listener status and stats
+*/
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function registerTgListenerTools(api) {
+	api.registerTool({
+		name: "tg_listener_start",
+		description: "Start the Telegram Bot listener to receive real-time messages from groups and channels. The bot must be added as an admin to target groups. Messages are automatically processed through the tg-scanner pipeline.",
+		parameters: Type.Object({ botToken: Type.Optional(Type.String({ description: "Bot token from @BotFather (defaults to TG_BOT_TOKEN env var)" })) }),
+		async execute(_id, params) {
+			if (isTgListenerRunning()) {
+				const stats = getTgListenerStats();
+				return textResult(`⚠️ Telegram listener is already running.\n\nConnected since: ${stats.connectedAt}\nMessages received: ${stats.messagesReceived}\nMessages processed: ${stats.messagesProcessed}\nSubscribed groups: ${stats.subscribedGroupIds.length}`);
+			}
+			const botToken = params.botToken ?? process.env["TG_BOT_TOKEN"];
+			if (!botToken) return textResult("❌ Missing Bot Token.\n\nSet TG_BOT_TOKEN in .env or pass it as a parameter.\n\nTo create a bot:\n  1. Open Telegram and find @BotFather\n  2. Send /newbot and follow the instructions\n  3. Copy the token to .env as TG_BOT_TOKEN");
+			try {
+				await startTgListener({ botToken });
+				const stats = getTgListenerStats();
+				return textResult(`✅ Telegram Bot listener started.\n\nConnected at: ${stats.connectedAt}\nSubscribed groups: ${stats.subscribedGroupIds.length}\n\nThe bot will receive messages from groups/channels where it's been added as an admin.\n\n💡 Use tg_scanner_subscribe to filter specific groups, or leave the subscription list empty to process messages from ALL groups.`);
+			} catch (err) {
+				return textResult(`❌ Failed to start Telegram listener.\n\nError: ${err instanceof Error ? err.message : String(err)}\n\nCommon causes:\n  • Invalid bot token\n  • Network connectivity issues\n  • Bot was revoked via @BotFather`);
+			}
+		}
+	});
+	api.registerTool({
+		name: "tg_listener_stop",
+		description: "Stop the Telegram Bot listener gracefully.",
+		parameters: Type.Object({}),
+		async execute() {
+			if (!isTgListenerRunning()) return textResult("ℹ️ Telegram listener is not running.");
+			const statsBefore = getTgListenerStats();
+			await stopTgListener();
+			return textResult(`✅ Telegram listener stopped.
+
+Session summary:
+  • Connected since: ${statsBefore.connectedAt}\n  • Messages received: ${statsBefore.messagesReceived}\n  • Messages processed: ${statsBefore.messagesProcessed}\n  • Errors: ${statsBefore.errors}`);
+		}
+	});
+	api.registerTool({
+		name: "tg_listener_status",
+		description: "Get the current status of the Telegram Bot listener, including connection state, message counts, and subscribed groups.",
+		parameters: Type.Object({}),
+		async execute() {
+			const stats = getTgListenerStats();
+			if (!stats.running) {
+				const hasToken = !!process.env["TG_BOT_TOKEN"];
+				return textResult(`⏹️ Telegram listener is **not running**.\n\nBot token configured: ${hasToken ? "✅ Yes" : "❌ No"}\n\n` + (hasToken ? `Use tg_listener_start to begin listening.` : `Set TG_BOT_TOKEN in .env first (get it from @BotFather).`));
+			}
+			const uptimeStr = formatUptime(stats.connectedAt ? Math.round((Date.now() - new Date(stats.connectedAt).getTime()) / 1e3) : 0);
+			let text = `🟢 Telegram listener is **running**\n\nConnected since: ${stats.connectedAt}\nUptime: ${uptimeStr}\nMessages received: ${stats.messagesReceived}\nMessages processed: ${stats.messagesProcessed}\nErrors: ${stats.errors}\n`;
+			if (stats.subscribedGroupIds.length > 0) {
+				text += `\nSubscribed groups (${stats.subscribedGroupIds.length}):\n`;
+				for (const gid of stats.subscribedGroupIds) text += `  • ${gid}\n`;
+			} else {
+				text += `\n📡 Processing messages from ALL groups where bot is admin.\n`;
+				text += `Use tg_scanner_subscribe to filter specific groups.`;
+			}
+			return textResult(text);
+		}
+	});
+}
+function formatUptime(seconds) {
+	const d = Math.floor(seconds / 86400);
+	const h = Math.floor(seconds % 86400 / 3600);
+	const m = Math.floor(seconds % 3600 / 60);
+	const s = seconds % 60;
+	const parts = [];
+	if (d > 0) parts.push(`${d}d`);
+	if (h > 0) parts.push(`${h}h`);
+	if (m > 0) parts.push(`${m}m`);
+	parts.push(`${s}s`);
+	return parts.join(" ");
+}
+//#endregion
+//#region src/index.ts
+/**
+* Clawvif — OpenClaw Plugin Entry Point
+*
+* This is the main entry point loaded by OpenClaw's plugin system via jiti.
+* It registers all Clawvif tools that the agent can invoke.
+*
+* IMPORTANT: This default export function must be SYNCHRONOUS.
+* OpenClaw's plugin loader ignores async activate functions.
+*/
+/**
+* Plugin entry — called synchronously by OpenClaw at load time.
+*/
+function clawvifPlugin(api) {
+	registerAuditTools(api);
+	registerAlertTools(api);
+	registerChainMonitorTools(api);
+	registerSentimentTools(api);
+	registerWhaleTools(api);
+	registerTgScannerTools(api);
+	registerTgListenerTools(api);
+	const pluginConfig = api.pluginConfig ?? {};
+	const botToken = pluginConfig.tgBotToken || process.env["TG_BOT_TOKEN"];
+	const autoStart = pluginConfig.tgAutoStart !== false;
+	if (botToken && autoStart) startTgListener({ botToken }).catch((err) => {
+		auditLog("tg-listener", "auto_start_failed", { error: err instanceof Error ? err.message : String(err) });
+	});
+	else if (!botToken) auditLog("tg-listener", "auto_start_skipped", {
+		reason: "no_bot_token",
+		hint: "Set tgBotToken in plugin config or TG_BOT_TOKEN in .env"
+	});
+	else auditLog("tg-listener", "auto_start_skipped", { reason: "tgAutoStart_disabled" });
+}
+//#endregion
+export { clawvifPlugin as default };
+
+//# sourceMappingURL=index.mjs.map