sclaw-agent 1.0.0

package/README.md

@@ -0,0 +1,228 @@
+<p align="center">
+  <h1 align="center">SCLAW</h1>
+  <p align="center">ShadowClawAI Pre-Execution Engine</p>
+  <p align="center">
+    <a href="#quick-start">Quick Start</a> ·
+    <a href="#cli">CLI</a> ·
+    <a href="#api">API</a> ·
+    <a href="#architecture">Architecture</a>
+  </p>
+</p>
+
+---
+
+Pre-execution engine that simulates Solana transactions, analyzes token security on-chain, and produces AI risk reports via CLAW agents — before you sign anything.
+
+All data sourced from **Helius RPC mainnet**. Zero mocks. Zero fakes.
+
+## What It Does
+
+**Transaction Simulation** — Dry-run any Solana transaction via Helius `simulateTransaction`. See program logs, compute units, balance changes, and errors without touching the chain.
+
+**Token Security Analysis** — Real-time on-chain checks: mint authority, freeze authority, holder concentration, whale detection, metadata verification. Every query hits mainnet.
+
+**CLAW Agent Intelligence** — AI-powered risk assessment via LLM (Claude through OpenRouter). Structured reports with risk score 0-100, threat level, specific flags, and detailed analysis. Any LLM can serve as a CLAW agent — swap the model in config.
+
+**Wallet Risk Profiling** — Analyze any Solana address: SOL balance, token holdings, transaction patterns, bot detection, counterparty analysis.
+
+## Quick Start
+
+```bash
+git clone https://github.com/alc0hol120/SHADOWCLAW.git
+cd SHADOWCLAW
+npm install
+```
+
+Set your API keys:
+
+```bash
+export HELIUS_API_KEY=your-helius-key
+export OPENROUTER_API_KEY=your-openrouter-key
+```
+
+Get a free Helius key at [helius.dev](https://helius.dev). Get an OpenRouter key at [openrouter.ai](https://openrouter.ai).
+
+Start the server:
+
+```bash
+npm run server
+```
+
+Verify:
+
+```bash
+curl http://localhost:3001/api/health
+# {"status":"CLAW Engine Online","version":"1.0.0"}
+
+curl http://localhost:3001/api/token/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
+# Returns USDC analysis + CLAW report
+```
+
+## npm
+
+```bash
+npm install sclaw-agent
+```
+
+## CLI
+
+Requires the server running (`npm run server`).
+
+```bash
+npx tsx cli/index.ts token EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
+
+npx tsx cli/index.ts wallet <solana-address>
+
+npx tsx cli/index.ts simulate <base64-transaction>
+
+npx tsx cli/index.ts --help
+```
+
+Example output:
+
+```
+SCLAW — Token Security Analysis
+Analyzing EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
+
+  USDC USD Coin
+  Mint: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
+  Supply: 8,680,309,682.51
+  Decimals: 6
+  Mintable: YES
+  Freezable: YES
+  Top 10 concentration: 0%
+
+CLAW Agent Report
+  Risk: 15/100 LOW
+  USDC is a legitimate stablecoin but has centralized controls
+```
+
+## API
+
+All endpoints return JSON. Server runs on port 3001 by default.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/api/health` | Server status check |
+| `POST` | `/api/simulate/transaction` | Simulate a base64-encoded transaction |
+| `POST` | `/api/simulate/preview` | Review executed transaction by signature |
+| `GET` | `/api/token/:mint` | Full token security analysis + CLAW report |
+| `GET` | `/api/token/:mint/history` | Recent token transactions via Helius |
+| `GET` | `/api/risk/wallet/:address` | Wallet risk profile + CLAW report |
+| `POST` | `/api/risk/analyze` | Free-form CLAW agent analysis |
+
+### Simulate Transaction
+
+```bash
+curl -X POST http://localhost:3001/api/simulate/transaction \
+  -H "Content-Type: application/json" \
+  -d '{"transaction": "<base64-encoded-tx>", "walletAddress": "<optional>"}'
+```
+
+Response:
+
+```json
+{
+  "simulation": {
+    "success": true,
+    "logs": ["Program 111... invoke [1]", "Program 111... success"],
+    "unitsConsumed": 150,
+    "error": null
+  },
+  "preBalance": 0.39,
+  "estimatedCostSOL": 0.00075,
+  "clawAnalysis": {
+    "riskScore": 15,
+    "riskLevel": "LOW",
+    "summary": "Standard system program transaction",
+    "flags": [],
+    "details": "..."
+  }
+}
+```
+
+### Token Analysis
+
+```bash
+curl http://localhost:3001/api/token/<mint-address>
+```
+
+Response includes: mint/freeze authority status, supply, decimals, top 10 holder distribution with whale alerts, and CLAW agent risk report.
+
+### Wallet Risk
+
+```bash
+curl http://localhost:3001/api/risk/wallet/<address>
+```
+
+Response includes: SOL balance, token accounts, recent transactions with native/token transfers, and CLAW agent analysis of wallet behavior patterns.
+
+## Architecture
+
+```
+server/
+  index.ts              Express API (port 3001)
+  config.ts             Helius + OpenRouter keys (env vars)
+  lib/
+    helius.ts           Solana mainnet RPC — simulateTransaction,
+                        getTokenMetadata, getAsset, getBalance,
+                        getTokenAccounts, getTransactionHistory
+    claw-agent.ts       AI risk analysis — structured prompts,
+                        JSON output parsing, fallback handling
+    token-analysis.ts   On-chain security — mint/freeze authority,
+                        holder concentration, whale detection
+  routes/
+    simulate.ts         POST /simulate/transaction, /simulate/preview
+    token.ts            GET /token/:mint, /token/:mint/history
+    risk.ts             GET /risk/wallet/:address, POST /risk/analyze
+cli/
+  index.ts              Terminal interface — token, wallet, simulate
+```
+
+### How It Works
+
+1. Request comes in (API call, CLI command)
+2. Server fetches real-time data from Solana via Helius RPC
+3. For transactions: `simulateTransaction` with `replaceRecentBlockhash`
+4. For tokens: mint account info, metadata, largest holders
+5. For wallets: balance, token accounts, transaction history
+6. All collected data is passed to CLAW agent (LLM)
+7. CLAW agent returns structured risk report (score, level, flags, details)
+8. Response sent back with raw data + AI analysis
+
+### CLAW Agent
+
+CLAW is the AI layer. It receives raw blockchain data and produces structured risk assessments. Under the hood it's an LLM (currently Claude via OpenRouter) with a specialized system prompt for blockchain risk analysis.
+
+Any LLM can be a CLAW agent — swap the model in `server/lib/claw-agent.ts`. The prompt and output format stay the same.
+
+Risk levels: `SAFE` (0-20) · `LOW` (21-40) · `MEDIUM` (41-60) · `HIGH` (61-80) · `CRITICAL` (81-100)
+
+## Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `HELIUS_API_KEY` | Helius RPC API key | Yes |
+| `OPENROUTER_API_KEY` | OpenRouter API key for CLAW agent | Yes |
+| `PORT` | Server port (default: 3001) | No |
+
+## Token Security Checks
+
+| Check | What It Detects |
+|-------|----------------|
+| Mint Authority | Can new tokens be minted? Supply inflation risk |
+| Freeze Authority | Can accounts be frozen? Honeypot risk |
+| Holder Concentration | Top 10 wallet % of supply. Rug pull risk |
+| Whale Detection | Single wallet >20% flagged |
+| Metadata | Name, symbol, off-chain data verified |
+
+## Stack
+
+- **Helius RPC** — Solana mainnet data
+- **Claude AI** via OpenRouter — CLAW agent intelligence
+- **Express.js** — Backend API
+- **TypeScript** — Everything
+
+## License
+
+MIT

package/cli/index.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+const API_BASE = process.env.SCLAW_API || 'http://localhost:3001/api';
+
+const COLORS = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+function c(color: keyof typeof COLORS, text: string) {
+  return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+
+async function request(path: string, options?: RequestInit) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { 'Content-Type': 'application/json' },
+    ...options,
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }));
+    throw new Error(err.error || 'Request failed');
+  }
+  return res.json();
+}
+
+function printRisk(analysis: any) {
+  if (!analysis) return;
+  const levelColor = analysis.riskLevel === 'SAFE' || analysis.riskLevel === 'LOW' ? 'green'
+    : analysis.riskLevel === 'MEDIUM' ? 'yellow' : 'red';
+
+  console.log(`\n${c('bold', 'CLAW Agent Report')}`);
+  console.log(`  Risk: ${c(levelColor, `${analysis.riskScore}/100 ${analysis.riskLevel}`)}`);
+  console.log(`  ${analysis.summary}`);
+  if (analysis.flags?.length) {
+    console.log(`\n  ${c('yellow', 'Flags:')}`);
+    analysis.flags.forEach((f: string) => console.log(`    ${c('yellow', '▸')} ${f}`));
+  }
+  if (analysis.details) {
+    console.log(`\n  ${c('dim', analysis.details)}`);
+  }
+}
+
+async function tokenCmd(mint: string) {
+  console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Token Security Analysis')}`);
+  console.log(`${c('dim', 'Analyzing')} ${mint}\n`);
+
+  const data = await request(`/token/${mint}`);
+  const t = data.token;
+
+  console.log(`  ${c('bold', t.symbol || 'Unknown')} ${c('dim', t.name || '')}`);
+  console.log(`  Mint: ${c('dim', t.mint)}`);
+  console.log(`  Supply: ${t.supply !== null && t.decimals !== null ? (t.supply / Math.pow(10, t.decimals)).toLocaleString() : 'N/A'}`);
+  console.log(`  Decimals: ${t.decimals ?? 'N/A'}`);
+  console.log(`  Mintable: ${t.isMintable ? c('red', 'YES') : c('green', 'NO')}`);
+  console.log(`  Freezable: ${t.isFreezable ? c('red', 'YES') : c('green', 'NO')}`);
+  console.log(`  Top 10 concentration: ${t.holderConcentration > 80 ? c('red', t.holderConcentration + '%') : t.holderConcentration > 50 ? c('yellow', t.holderConcentration + '%') : c('green', t.holderConcentration + '%')}`);
+
+  if (t.risks?.length) {
+    console.log(`\n  ${c('yellow', 'Risk Flags:')}`);
+    t.risks.forEach((r: string) => console.log(`    ${c('yellow', '▸')} ${r}`));
+  }
+
+  if (t.topHolders?.length) {
+    console.log(`\n  ${c('dim', 'Top Holders:')}`);
+    t.topHolders.slice(0, 5).forEach((h: any, i: number) => {
+      console.log(`    ${i + 1}. ${h.address.slice(0, 8)}...${h.address.slice(-6)}  ${h.amount.toLocaleString()}  ${h.percentage}%`);
+    });
+  }
+
+  printRisk(data.clawAnalysis);
+}
+
+async function walletCmd(address: string) {
+  console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Wallet Risk Analysis')}`);
+  console.log(`${c('dim', 'Analyzing')} ${address}\n`);
+
+  const data = await request(`/risk/wallet/${address}`);
+
+  console.log(`  Balance: ${data.balanceSOL} SOL`);
+  const txCount = data.recentTransactions?.length || 0;
+  console.log(`  Recent transactions: ${txCount}`);
+
+  if (data.recentTransactions?.length) {
+    console.log(`\n  ${c('dim', 'Recent Activity:')}`);
+    data.recentTransactions.slice(0, 5).forEach((tx: any) => {
+      console.log(`    ${c('dim', tx.type || '?')} via ${tx.source || '?'}`);
+    });
+  }
+
+  printRisk(data.clawAnalysis);
+}
+
+async function simulateCmd(tx: string) {
+  console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Transaction Simulation')}\n`);
+
+  const data = await request('/simulate/transaction', {
+    method: 'POST',
+    body: JSON.stringify({ transaction: tx }),
+  });
+
+  const sim = data.simulation;
+  console.log(`  Result: ${sim.success ? c('green', 'SUCCESS') : c('red', 'FAILED')}`);
+  console.log(`  Compute units: ${sim.unitsConsumed}`);
+  if (sim.error) console.log(`  Error: ${c('red', sim.error)}`);
+  if (data.estimatedCostSOL) console.log(`  Est. cost: ${data.estimatedCostSOL} SOL`);
+
+  if (sim.logs?.length) {
+    console.log(`\n  ${c('dim', 'Logs:')}`);
+    sim.logs.slice(0, 10).forEach((l: string) => console.log(`    ${c('dim', l)}`));
+  }
+
+  printRisk(data.clawAnalysis);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  const arg = args[1];
+
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    console.log(`
+${c('cyan', 'SCLAW')} ${c('dim', '— ShadowClawAI Pre-Execution Engine')}
+
+${c('bold', 'Usage:')}
+  sclaw token <mint-address>     Analyze token security
+  sclaw wallet <address>         Wallet risk profile
+  sclaw simulate <base64-tx>     Dry-run a transaction
+
+${c('bold', 'Options:')}
+  --api <url>                    Custom API endpoint (default: localhost:3001)
+
+${c('dim', 'All data sourced from Helius RPC mainnet. AI analysis by CLAW agents.')}
+`);
+    return;
+  }
+
+  try {
+    switch (cmd) {
+      case 'token': await tokenCmd(arg); break;
+      case 'wallet': await walletCmd(arg); break;
+      case 'simulate': await simulateCmd(arg); break;
+      default:
+        console.error(`Unknown command: ${cmd}. Run sclaw --help`);
+        process.exit(1);
+    }
+  } catch (err: any) {
+    console.error(`\n${c('red', 'Error:')} ${err.message}`);
+    process.exit(1);
+  }
+
+  console.log('');
+}
+
+main();

package/dist/cli/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+declare const API_BASE: string;
+declare const COLORS: {
+    green: string;
+    red: string;
+    yellow: string;
+    cyan: string;
+    dim: string;
+    bold: string;
+    reset: string;
+};
+declare function c(color: keyof typeof COLORS, text: string): string;
+declare function request(path: string, options?: RequestInit): Promise<any>;
+declare function printRisk(analysis: any): void;
+declare function tokenCmd(mint: string): Promise<void>;
+declare function walletCmd(address: string): Promise<void>;
+declare function simulateCmd(tx: string): Promise<void>;
+declare function main(): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+const API_BASE = process.env.SCLAW_API || 'http://localhost:3001/api';
+const COLORS = {
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+};
+function c(color, text) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+async function request(path, options) {
+    const res = await fetch(`${API_BASE}${path}`, {
+        headers: { 'Content-Type': 'application/json' },
+        ...options,
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: res.statusText }));
+        throw new Error(err.error || 'Request failed');
+    }
+    return res.json();
+}
+function printRisk(analysis) {
+    if (!analysis)
+        return;
+    const levelColor = analysis.riskLevel === 'SAFE' || analysis.riskLevel === 'LOW' ? 'green'
+        : analysis.riskLevel === 'MEDIUM' ? 'yellow' : 'red';
+    console.log(`\n${c('bold', 'CLAW Agent Report')}`);
+    console.log(`  Risk: ${c(levelColor, `${analysis.riskScore}/100 ${analysis.riskLevel}`)}`);
+    console.log(`  ${analysis.summary}`);
+    if (analysis.flags?.length) {
+        console.log(`\n  ${c('yellow', 'Flags:')}`);
+        analysis.flags.forEach((f) => console.log(`    ${c('yellow', '▸')} ${f}`));
+    }
+    if (analysis.details) {
+        console.log(`\n  ${c('dim', analysis.details)}`);
+    }
+}
+async function tokenCmd(mint) {
+    console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Token Security Analysis')}`);
+    console.log(`${c('dim', 'Analyzing')} ${mint}\n`);
+    const data = await request(`/token/${mint}`);
+    const t = data.token;
+    console.log(`  ${c('bold', t.symbol || 'Unknown')} ${c('dim', t.name || '')}`);
+    console.log(`  Mint: ${c('dim', t.mint)}`);
+    console.log(`  Supply: ${t.supply !== null && t.decimals !== null ? (t.supply / Math.pow(10, t.decimals)).toLocaleString() : 'N/A'}`);
+    console.log(`  Decimals: ${t.decimals ?? 'N/A'}`);
+    console.log(`  Mintable: ${t.isMintable ? c('red', 'YES') : c('green', 'NO')}`);
+    console.log(`  Freezable: ${t.isFreezable ? c('red', 'YES') : c('green', 'NO')}`);
+    console.log(`  Top 10 concentration: ${t.holderConcentration > 80 ? c('red', t.holderConcentration + '%') : t.holderConcentration > 50 ? c('yellow', t.holderConcentration + '%') : c('green', t.holderConcentration + '%')}`);
+    if (t.risks?.length) {
+        console.log(`\n  ${c('yellow', 'Risk Flags:')}`);
+        t.risks.forEach((r) => console.log(`    ${c('yellow', '▸')} ${r}`));
+    }
+    if (t.topHolders?.length) {
+        console.log(`\n  ${c('dim', 'Top Holders:')}`);
+        t.topHolders.slice(0, 5).forEach((h, i) => {
+            console.log(`    ${i + 1}. ${h.address.slice(0, 8)}...${h.address.slice(-6)}  ${h.amount.toLocaleString()}  ${h.percentage}%`);
+        });
+    }
+    printRisk(data.clawAnalysis);
+}
+async function walletCmd(address) {
+    console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Wallet Risk Analysis')}`);
+    console.log(`${c('dim', 'Analyzing')} ${address}\n`);
+    const data = await request(`/risk/wallet/${address}`);
+    console.log(`  Balance: ${data.balanceSOL} SOL`);
+    const txCount = data.recentTransactions?.length || 0;
+    console.log(`  Recent transactions: ${txCount}`);
+    if (data.recentTransactions?.length) {
+        console.log(`\n  ${c('dim', 'Recent Activity:')}`);
+        data.recentTransactions.slice(0, 5).forEach((tx) => {
+            console.log(`    ${c('dim', tx.type || '?')} via ${tx.source || '?'}`);
+        });
+    }
+    printRisk(data.clawAnalysis);
+}
+async function simulateCmd(tx) {
+    console.log(`\n${c('cyan', 'SCLAW')} ${c('dim', '— Transaction Simulation')}\n`);
+    const data = await request('/simulate/transaction', {
+        method: 'POST',
+        body: JSON.stringify({ transaction: tx }),
+    });
+    const sim = data.simulation;
+    console.log(`  Result: ${sim.success ? c('green', 'SUCCESS') : c('red', 'FAILED')}`);
+    console.log(`  Compute units: ${sim.unitsConsumed}`);
+    if (sim.error)
+        console.log(`  Error: ${c('red', sim.error)}`);
+    if (data.estimatedCostSOL)
+        console.log(`  Est. cost: ${data.estimatedCostSOL} SOL`);
+    if (sim.logs?.length) {
+        console.log(`\n  ${c('dim', 'Logs:')}`);
+        sim.logs.slice(0, 10).forEach((l) => console.log(`    ${c('dim', l)}`));
+    }
+    printRisk(data.clawAnalysis);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+    const arg = args[1];
+    if (!cmd || cmd === '--help' || cmd === '-h') {
+        console.log(`
+${c('cyan', 'SCLAW')} ${c('dim', '— ShadowClawAI Pre-Execution Engine')}
+
+${c('bold', 'Usage:')}
+  sclaw token <mint-address>     Analyze token security
+  sclaw wallet <address>         Wallet risk profile
+  sclaw simulate <base64-tx>     Dry-run a transaction
+
+${c('bold', 'Options:')}
+  --api <url>                    Custom API endpoint (default: localhost:3001)
+
+${c('dim', 'All data sourced from Helius RPC mainnet. AI analysis by CLAW agents.')}
+`);
+        return;
+    }
+    try {
+        switch (cmd) {
+            case 'token':
+                await tokenCmd(arg);
+                break;
+            case 'wallet':
+                await walletCmd(arg);
+                break;
+            case 'simulate':
+                await simulateCmd(arg);
+                break;
+            default:
+                console.error(`Unknown command: ${cmd}. Run sclaw --help`);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`\n${c('red', 'Error:')} ${err.message}`);
+        process.exit(1);
+    }
+    console.log('');
+}
+main();

package/dist/server/config.d.ts

@@ -0,0 +1,5 @@
+export declare const HELIUS_API_KEY: string;
+export declare const HELIUS_RPC_URL: string;
+export declare const HELIUS_API_URL = "https://api.helius.xyz/v0";
+export declare const OPENROUTER_API_KEY: string;
+export declare const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";

package/dist/server/config.js

@@ -0,0 +1,5 @@
+export const HELIUS_API_KEY = process.env.HELIUS_API_KEY || '';
+export const HELIUS_RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;
+export const HELIUS_API_URL = `https://api.helius.xyz/v0`;
+export const OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY || '';
+export const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions';

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/index.js

@@ -0,0 +1,18 @@
+import express from 'express';
+import cors from 'cors';
+import { simulateRoute } from './routes/simulate';
+import { tokenRoute } from './routes/token';
+import { riskRoute } from './routes/risk';
+const app = express();
+const PORT = process.env.PORT || 3001;
+app.use(cors());
+app.use(express.json());
+app.use('/api/simulate', simulateRoute);
+app.use('/api/token', tokenRoute);
+app.use('/api/risk', riskRoute);
+app.get('/api/health', (_req, res) => {
+    res.json({ status: 'CLAW Engine Online', version: '1.0.0' });
+});
+app.listen(PORT, () => {
+    console.log(`[CLAW] ShadowClaw engine running on port ${PORT}`);
+});

package/dist/server/lib/claw-agent.d.ts

@@ -0,0 +1,8 @@
+export interface ClawAnalysis {
+    riskScore: number;
+    riskLevel: 'SAFE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+    summary: string;
+    flags: string[];
+    details: string;
+}
+export declare function clawAnalyze(context: string): Promise<ClawAnalysis>;

package/dist/server/lib/claw-agent.js

@@ -0,0 +1,66 @@
+import { OPENROUTER_API_KEY, OPENROUTER_URL } from '../config';
+const CLAW_SYSTEM_PROMPT = `You are CLAW (ShadowClawAI), a specialized AI agent for blockchain transaction analysis and risk assessment.
+
+Your role:
+- Analyze transaction simulation results and identify risks
+- Detect potential rug pulls, honeypots, and scam patterns
+- Assess smart contract risks based on on-chain data
+- Provide clear, actionable risk reports
+
+Rules:
+- Be direct and precise. No fluff.
+- Always provide a risk score from 0-100 (0 = safe, 100 = extreme danger)
+- Categorize risks: SAFE, LOW, MEDIUM, HIGH, CRITICAL
+- Flag specific red flags with evidence
+- Never give financial advice, only technical risk analysis
+- Use real data only, never fabricate information`;
+export async function clawAnalyze(context) {
+    const res = await fetch(OPENROUTER_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${OPENROUTER_API_KEY}`,
+            'HTTP-Referer': 'https://sclaw.ai',
+            'X-Title': 'SCLAW - ShadowClawAI',
+        },
+        body: JSON.stringify({
+            model: 'anthropic/claude-sonnet-4',
+            messages: [
+                { role: 'system', content: CLAW_SYSTEM_PROMPT },
+                {
+                    role: 'user',
+                    content: `Analyze the following blockchain data and provide a risk assessment. Respond ONLY with valid JSON matching this schema:
+{
+  "riskScore": number (0-100),
+  "riskLevel": "SAFE" | "LOW" | "MEDIUM" | "HIGH" | "CRITICAL",
+  "summary": "one-line summary",
+  "flags": ["array of specific red flags"],
+  "details": "detailed analysis"
+}
+
+Data to analyze:
+${context}`,
+                },
+            ],
+            temperature: 0.1,
+            max_tokens: 2000,
+        }),
+    });
+    const data = await res.json();
+    const content = data.choices?.[0]?.message?.content || '';
+    try {
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[0]);
+        }
+    }
+    catch {
+    }
+    return {
+        riskScore: -1,
+        riskLevel: 'MEDIUM',
+        summary: 'CLAW agent could not complete analysis',
+        flags: ['Analysis incomplete — review manually'],
+        details: content,
+    };
+}

package/dist/server/lib/helius.d.ts

@@ -0,0 +1,19 @@
+interface HeliusRpcRequest {
+    method: string;
+    params: unknown[];
+}
+export declare function heliusRpc(request: HeliusRpcRequest): Promise<unknown>;
+export declare function simulateTransaction(encodedTx: string): Promise<{
+    success: boolean;
+    logs: string[];
+    unitsConsumed: number;
+    error: string | null;
+    accounts: unknown[];
+}>;
+export declare function getTokenMetadata(mintAddress: string): Promise<unknown>;
+export declare function getAsset(assetId: string): Promise<unknown>;
+export declare function getBalance(address: string): Promise<number>;
+export declare function getTokenAccounts(ownerAddress: string): Promise<unknown>;
+export declare function getTransactionHistory(address: string, limit?: number): Promise<unknown>;
+export declare function getParsedTransaction(signature: string): Promise<unknown>;
+export {};