@scriptmasterlabs/mcp-x402 2.0.2 → 2.1.1

package/src/server/tools/echo.ts

@@ -1,58 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { PriceRegistry } from '../registry/pricing.js';
-import { EchoForgeAPI } from '../../lib/sml-api/echo.js';
-
-const PatternMatchSchema = z.object({
-  symbol: z.string().min(1).max(10).toUpperCase(),
-  lookback_days: z.number().int().min(1).max(3650),
-  top_n: z.number().int().min(1).max(20).default(5),
-  wallet_address: z.string().optional(),
-});
-
-export function registerEcho(server: McpServer): void {
-  const audit = AuditLogger.getInstance();
-
-  // ── PAID: echo_pattern_match (0.05 USDC — coming soon) ────────────────────
-  server.tool(
-    'echo_pattern_match',
-    {
-      symbol: z.string().describe('Ticker symbol to find historical analogs for (e.g. TSLA, GME).'),
-      lookback_days: z.number().describe('Days of price history to encode as the query pattern (1-3650).'),
-      top_n: z.number().describe('Number of closest historical matches to return (1-20, default 5).'),
-      wallet_address: z.string().describe('Agent wallet for x402 payment.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(PatternMatchSchema, rawArgs);
-
-      if (!RateLimiter.getInstance().checkTool('echo_pattern_match')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      // Service not yet deployed — skip payment and return informative stub
-      const data = await EchoForgeAPI.patternMatch({
-        symbol: args.symbol,
-        lookbackDays: args.lookback_days,
-        topN: args.top_n,
-        walletAddress: args.wallet_address ?? 'anonymous',
-      });
-
-      audit.info('echo_pattern_match_stub', { symbol: args.symbol });
-
-      // Still go through payment flow once the service is live — skeleton already wired:
-      // const price = await PriceRegistry.getInstance().getPrice('echo_pattern_match');
-      // payment = await executeX402Payment(...);
-      // Then call real API
-
-      // Suppress unused import warnings until service goes live
-      void executeX402Payment;
-      void PriceRegistry;
-
-      return { content: [{ type: 'text', text: JSON.stringify(data) }] };
-    },
-  );
-}

package/src/server/tools/forge.ts

@@ -1,87 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { PriceRegistry } from '../registry/pricing.js';
-import { ForgeGatewayAPI } from '../../lib/sml-api/forge.js';
-
-const LLMSchema = z.object({
-  model: z.string().min(1).max(64),
-  prompt: z.string().min(1).max(32768),
-  max_tokens: z.number().int().positive().max(8192).optional(),
-  wallet_address: z.string().optional(),
-});
-
-export function registerForge(server: McpServer): void {
-  const audit = AuditLogger.getInstance();
-
-  // ── FREE: forge_status ─────────────────────────────────────────────────────
-  server.tool(
-    'forge_status',
-    {},
-    async () => {
-      try {
-        const data = await ForgeGatewayAPI.status();
-        return { content: [{ type: 'text', text: JSON.stringify(data) }] };
-      } catch (err) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-
-  // ── PAID: forge_llm (0.02 USDC) ───────────────────────────────────────────
-  server.tool(
-    'forge_llm',
-    {
-      model: z.string().describe('Model identifier (e.g. "claude-3-5-haiku-20241022", "gpt-4o-mini").'),
-      prompt: z.string().describe('Prompt to send to the LLM (max 32768 chars).'),
-      max_tokens: z.number().describe('Maximum tokens in the response (default: model max). Max: 8192.'),
-      wallet_address: z.string().describe('Agent wallet for x402 pay-per-token billing.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(LLMSchema, rawArgs);
-
-      if (!RateLimiter.getInstance().checkTool('forge_llm')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('forge_llm');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({ price, currency: 'USDC', toolName: 'forge_llm', walletAddress: args.wallet_address });
-      } catch (err) {
-        audit.warn('forge_llm_payment_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      try {
-        const data = await ForgeGatewayAPI.llm({
-          model: args.model,
-          prompt: args.prompt,
-          maxTokens: args.max_tokens,
-          walletAddress: args.wallet_address ?? payment.walletAddress ?? 'anonymous',
-        });
-        audit.info('forge_llm_success', { model: args.model, receiptId: payment.receiptId });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              data,
-              _meta: { receipt_id: payment.receiptId, tx_hash: payment.txHash, chain: payment.chain, amount_paid: `${payment.amountPaid} ${payment.currency}`, timestamp: payment.timestamp },
-            }),
-          }],
-        };
-      } catch (err) {
-        audit.error('forge_llm_api_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-}

package/src/server/tools/ftd.ts

@@ -1,88 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { FtdClient } from '../../lib/sml-api/ftd.js';
-import { PriceRegistry } from '../registry/pricing.js';
-
-const CACHE_TTL_MS = 15 * 60 * 1000; // 15-min cache per spec
-
-interface CacheEntry {
-  data: unknown;
-  ts: number;
-}
-
-const alertCache = new Map<string, CacheEntry>();
-const fullCache = new Map<string, CacheEntry>();
-
-const InputSchema = z.object({
-  scan_type: z.enum(['alerts', 'full', 'spike_history']),
-  ticker: z.string().regex(/^[A-Z]{1,5}$/).optional(),
-  min_spike_multiplier: z.number().min(1).default(2),
-  wallet_address: z.string().optional(),
-});
-
-export function registerFtd(server: McpServer): void {
-  server.tool(
-    'ftd_threshold_scan',
-    {
-      scan_type: z.enum(['alerts', 'full', 'spike_history']).describe('"alerts" is free. "full" and "spike_history" require 0.05 USDC.'),
-      ticker: z.string().describe('Filter by ticker. Optional.'),
-      min_spike_multiplier: z.number().describe('Minimum FTD spike multiplier vs baseline. Default: 2x.'),
-      wallet_address: z.string().describe('Agent wallet for paid scans.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(InputSchema, rawArgs);
-      const audit = AuditLogger.getInstance();
-
-      if (!RateLimiter.getInstance().checkTool('ftd_threshold_scan')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded' }) }], isError: true };
-      }
-
-      const cacheKey = `${args.scan_type}:${args.ticker ?? 'all'}:${args.min_spike_multiplier}`;
-      const now = Date.now();
-
-      // Free tier: alerts only
-      if (args.scan_type === 'alerts') {
-        const cached = alertCache.get(cacheKey);
-        if (cached && now - cached.ts < CACHE_TTL_MS) {
-          return { content: [{ type: 'text', text: JSON.stringify({ data: cached.data, cached: true, tier: 'free' }) }] };
-        }
-
-        const client = FtdClient.getInstance();
-        const data = await client.getAlerts({ ticker: args.ticker, minSpikeMultiplier: args.min_spike_multiplier ?? 2 });
-        alertCache.set(cacheKey, { data, ts: now });
-        audit.info('ftd_alert_success', { ticker: args.ticker ?? 'all' });
-        return { content: [{ type: 'text', text: JSON.stringify({ data, tier: 'free' }) }] };
-      }
-
-      // Paid tier: full data
-      const cached = fullCache.get(cacheKey);
-      if (cached && now - cached.ts < CACHE_TTL_MS) {
-        return { content: [{ type: 'text', text: JSON.stringify({ data: cached.data, cached: true, tier: 'paid' }) }] };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('ftd_threshold_scan');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({ price, currency: 'USDC', toolName: 'ftd_threshold_scan', walletAddress: args.wallet_address });
-      } catch (err) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      const client = FtdClient.getInstance();
-      const data = await client.getFullScan({ ticker: args.ticker, scanType: args.scan_type, minSpikeMultiplier: args.min_spike_multiplier ?? 2 });
-      fullCache.set(cacheKey, { data, ts: now });
-
-      audit.info('ftd_paid_success', { ticker: args.ticker ?? 'all', receiptId: payment.receiptId });
-      return { content: [{ type: 'text', text: JSON.stringify({ data, tier: 'paid', _meta: { receipt_id: payment.receiptId, tx_hash: payment.txHash, chain: payment.chain, amount_paid: `${payment.amountPaid} ${payment.currency}` } }) }] };
-    },
-  );
-}

package/src/server/tools/ghost.ts

@@ -1,93 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { PriceRegistry } from '../registry/pricing.js';
-import { GhostLayerAPI } from '../../lib/sml-api/ghost.js';
-
-const RouteSchema = z.object({
-  from_chain: z.enum(['xrpl', 'base']),
-  to_chain: z.enum(['xrpl', 'base']),
-  amount: z.string().min(1),
-  currency: z.string().min(1).max(10),
-  destination_address: z.string().min(10),
-  wallet_address: z.string().optional(),
-});
-
-export function registerGhost(server: McpServer): void {
-  const audit = AuditLogger.getInstance();
-
-  // ── FREE: ghost_status ────────────────────────────────────────────────────
-  server.tool(
-    'ghost_status',
-    {},
-    async () => {
-      try {
-        const data = await GhostLayerAPI.status();
-        return { content: [{ type: 'text', text: JSON.stringify(data) }] };
-      } catch (err) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-
-  // ── PAID: ghost_route (0.01 USDC) ─────────────────────────────────────────
-  server.tool(
-    'ghost_route',
-    {
-      from_chain: z.enum(['xrpl', 'base']).describe('Source chain.'),
-      to_chain: z.enum(['xrpl', 'base']).describe('Destination chain.'),
-      amount: z.string().describe('Amount to route (as string to preserve precision).'),
-      currency: z.string().describe('Token/currency symbol (e.g. RLUSD, XRP, ETH).'),
-      destination_address: z.string().describe('Recipient address on the destination chain.'),
-      wallet_address: z.string().describe('Agent wallet for x402 payment.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(RouteSchema, rawArgs);
-
-      if (!RateLimiter.getInstance().checkTool('ghost_route')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('ghost_route');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({ price, currency: 'USDC', toolName: 'ghost_route', walletAddress: args.wallet_address });
-      } catch (err) {
-        audit.warn('ghost_route_payment_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      try {
-        const data = await GhostLayerAPI.route({
-          fromChain: args.from_chain,
-          toChain: args.to_chain,
-          amount: args.amount,
-          currency: args.currency,
-          destinationAddress: args.destination_address,
-          walletAddress: args.wallet_address ?? payment.walletAddress ?? 'anonymous',
-        });
-        audit.info('ghost_route_success', { receiptId: payment.receiptId });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              data,
-              _meta: { receipt_id: payment.receiptId, tx_hash: payment.txHash, chain: payment.chain, amount_paid: `${payment.amountPaid} ${payment.currency}`, timestamp: payment.timestamp },
-            }),
-          }],
-        };
-      } catch (err) {
-        audit.error('ghost_route_api_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-}

package/src/server/tools/index.ts

@@ -1,42 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { registerAgentCard } from './agentcard.js';
-import { registerBacktest } from './backtest.js';
-import { registerBrokers } from './brokers.js';
-import { registerCopyTrader } from './copytrader.js';
-import { registerCrawl } from './crawl.js';
-import { registerDiscovery } from './discovery.js';
-import { registerEcho } from './echo.js';
-import { registerForge } from './forge.js';
-import { registerFtd } from './ftd.js';
-import { registerGhost } from './ghost.js';
-import { registerLaunchpad } from './launchpad.js';
-import { registerLeviathan } from './leviathan.js';
-import { registerNexus } from './nexus.js';
-import { registerProof402 } from './proof402.js';
-import { registerRails } from './rails.js';
-import { registerShadow } from './shadow.js';
-import { registerSqueezeOS } from './squeezeos.js';
-import { registerXdeo } from './xdeo.js';
-import { registerXmit } from './xmit.js';
-
-export async function registerTools(server: McpServer): Promise<void> {
-  registerDiscovery(server);
-  registerAgentCard(server);
-  registerBacktest(server);
-  registerBrokers(server);
-  registerCopyTrader(server);
-  registerCrawl(server);
-  registerEcho(server);
-  registerForge(server);
-  registerFtd(server);
-  registerGhost(server);
-  registerLaunchpad(server);
-  await registerLeviathan(server);
-  registerNexus(server);
-  registerProof402(server);
-  registerRails(server);
-  registerShadow(server);
-  registerSqueezeOS(server);
-  registerXdeo(server);
-  await registerXmit(server);
-}

package/src/server/tools/launchpad.ts

@@ -1,173 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { PriceRegistry } from '../registry/pricing.js';
-import { LaunchpadAPI } from '../../lib/sml-api/launchpad.js';
-
-const CreateSchema = z.object({
-  name: z.string().min(1).max(64),
-  symbol: z.string().min(1).max(10).toUpperCase(),
-  description: z.string().max(512),
-  creator_address: z.string().min(10),
-  initial_supply: z.number().int().positive(),
-  target_liquidity_xrp: z.number().positive(),
-  wallet_address: z.string().optional(),
-});
-
-const BuySchema = z.object({
-  token_address: z.string().min(10),
-  buyer_address: z.string().min(10),
-  xrp_amount: z.number().positive(),
-  wallet_address: z.string().optional(),
-});
-
-export function registerLaunchpad(server: McpServer): void {
-  const audit = AuditLogger.getInstance();
-
-  // ── FREE: launchpad_status ─────────────────────────────────────────────────
-  server.tool(
-    'launchpad_status',
-    {},
-    async () => {
-      try {
-        const data = await LaunchpadAPI.status();
-        return { content: [{ type: 'text', text: JSON.stringify(data) }] };
-      } catch (err) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-
-  // ── FREE: launchpad_list ───────────────────────────────────────────────────
-  server.tool(
-    'launchpad_list',
-    {},
-    async () => {
-      if (!RateLimiter.getInstance().checkTool('launchpad_list')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-      try {
-        const data = await LaunchpadAPI.list();
-        audit.info('launchpad_list', {});
-        return { content: [{ type: 'text', text: JSON.stringify(data) }] };
-      } catch (err) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-
-  // ── PAID: launchpad_create (0.10 USDC) ────────────────────────────────────
-  server.tool(
-    'launchpad_create',
-    {
-      name: z.string().describe('Token name (e.g. "Moon Rocket").'),
-      symbol: z.string().describe('Ticker symbol (e.g. MNRKT, max 10 chars).'),
-      description: z.string().describe('Token description (max 512 chars).'),
-      creator_address: z.string().describe('XRPL address of the token creator.'),
-      initial_supply: z.number().describe('Total token supply (integer).'),
-      target_liquidity_xrp: z.number().describe('XRP target to graduate from bonding curve to DEX.'),
-      wallet_address: z.string().describe('Agent wallet for x402 payment.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(CreateSchema, rawArgs);
-
-      if (!RateLimiter.getInstance().checkTool('launchpad_create')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('launchpad_create');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({ price, currency: 'USDC', toolName: 'launchpad_create', walletAddress: args.wallet_address });
-      } catch (err) {
-        audit.warn('launchpad_create_payment_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      try {
-        const data = await LaunchpadAPI.create({
-          name: args.name,
-          symbol: args.symbol,
-          description: args.description,
-          creatorAddress: args.creator_address,
-          initialSupply: args.initial_supply,
-          targetLiquidityXrp: args.target_liquidity_xrp,
-        });
-        audit.info('launchpad_create_success', { symbol: args.symbol, receiptId: payment.receiptId });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              data,
-              _meta: { receipt_id: payment.receiptId, tx_hash: payment.txHash, chain: payment.chain, amount_paid: `${payment.amountPaid} ${payment.currency}`, timestamp: payment.timestamp },
-            }),
-          }],
-        };
-      } catch (err) {
-        audit.error('launchpad_create_api_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-
-  // ── PAID: launchpad_buy (0.01 USDC) ───────────────────────────────────────
-  server.tool(
-    'launchpad_buy',
-    {
-      token_address: z.string().describe('Token contract/address on XRPL.'),
-      buyer_address: z.string().describe('XRPL address of the buyer.'),
-      xrp_amount: z.number().describe('Amount of XRP to spend on the bonding curve.'),
-      wallet_address: z.string().describe('Agent wallet for x402 payment.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(BuySchema, rawArgs);
-
-      if (!RateLimiter.getInstance().checkTool('launchpad_buy')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('launchpad_buy');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({ price, currency: 'USDC', toolName: 'launchpad_buy', walletAddress: args.wallet_address });
-      } catch (err) {
-        audit.warn('launchpad_buy_payment_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      try {
-        const data = await LaunchpadAPI.buy({
-          tokenAddress: args.token_address,
-          buyerAddress: args.buyer_address,
-          xrpAmount: args.xrp_amount,
-        });
-        audit.info('launchpad_buy_success', { receiptId: payment.receiptId });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              data,
-              _meta: { receipt_id: payment.receiptId, tx_hash: payment.txHash, chain: payment.chain, amount_paid: `${payment.amountPaid} ${payment.currency}`, timestamp: payment.timestamp },
-            }),
-          }],
-        };
-      } catch (err) {
-        audit.error('launchpad_buy_api_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'api_error', message: String(err) }) }], isError: true };
-      }
-    },
-  );
-}

package/src/server/tools/leviathan.ts

@@ -1,81 +0,0 @@
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { executeX402Payment } from '../payments/x402.js';
-import { RateLimiter } from '../security/rate-limit.js';
-import { Sandbox } from '../security/sandbox.js';
-import { AuditLogger } from '../security/audit.js';
-import { LeviathanClient } from '../../lib/sml-api/leviathan.js';
-import { PriceRegistry } from '../registry/pricing.js';
-
-const InputSchema = z.object({
-  ticker: z.string().regex(/^[A-Z]{1,5}$/).optional(),
-  signal_type: z.enum(['squeeze', 'momentum', 'dark_pool', 'all']),
-  min_confidence: z.number().min(0).max(100).default(60),
-  wallet_address: z.string().optional(),
-});
-
-export function registerLeviathan(server: McpServer): void {
-  server.tool(
-    'leviathan_signal',
-    {
-      ticker: z.string().describe('Ticker symbol (e.g. TSLA, MSTR). Optional — omit for top signals.'),
-      signal_type: z.enum(['squeeze', 'momentum', 'dark_pool', 'all']).describe('Signal category.'),
-      min_confidence: z.number().describe('Minimum confidence score 0-100. Default: 60.'),
-      wallet_address: z.string().describe('Agent wallet address for payment. Auto-provisioned if omitted.'),
-    },
-    async (rawArgs) => {
-      const args = Sandbox.validate(InputSchema, rawArgs);
-      const audit = AuditLogger.getInstance();
-
-      if (!RateLimiter.getInstance().checkTool('leviathan_signal')) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'rate_limit_exceeded', retry_after: 60 }) }], isError: true };
-      }
-
-      await PriceRegistry.getInstance().seedDefaults();
-      const price = await PriceRegistry.getInstance().getPrice('leviathan_signal');
-      if (!price) {
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'price_unavailable', message: 'Cannot determine price. Try again shortly.' }) }], isError: true };
-      }
-
-      let payment;
-      try {
-        payment = await executeX402Payment({
-          price,
-          currency: 'USDC',
-          toolName: 'leviathan_signal',
-          walletAddress: args.wallet_address,
-        });
-      } catch (err) {
-        audit.warn('leviathan_payment_fail', { error: String(err) });
-        return { content: [{ type: 'text', text: JSON.stringify({ error: 'payment_failed', message: String(err) }) }], isError: true };
-      }
-
-      const client = LeviathanClient.getInstance();
-      const data = await client.getSignal({
-        ticker: args.ticker,
-        signalType: args.signal_type,
-        minConfidence: args.min_confidence ?? 60,
-      });
-
-      audit.info('leviathan_success', { ticker: args.ticker ?? 'all', receiptId: payment.receiptId });
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              data,
-              _meta: {
-                receipt_id: payment.receiptId,
-                tx_hash: payment.txHash,
-                chain: payment.chain,
-                amount_paid: `${payment.amountPaid} ${payment.currency}`,
-                timestamp: payment.timestamp,
-              },
-            }),
-          },
-        ],
-      };
-    },
-  );
-}