sclaw-agent 1.0.0

package/server/lib/token-analysis.ts

@@ -0,0 +1,109 @@
+import { heliusRpc, getTokenMetadata } from './helius';
+import { HELIUS_RPC_URL } from '../config';
+
+export interface TokenSecurityReport {
+  mint: string;
+  name: string | null;
+  symbol: string | null;
+  supply: number | null;
+  decimals: number | null;
+  freezeAuthority: string | null;
+  mintAuthority: string | null;
+  isFreezable: boolean;
+  isMintable: boolean;
+  topHolders: { address: string; amount: number; percentage: number }[];
+  holderConcentration: number;
+  lpInfo: { locked: boolean; pool: string | null } | null;
+  metadata: unknown;
+  risks: string[];
+}
+
+export async function analyzeToken(mintAddress: string): Promise<TokenSecurityReport> {
+  const risks: string[] = [];
+
+  const mintInfo = await heliusRpc({
+    method: 'getAccountInfo',
+    params: [mintAddress, { encoding: 'jsonParsed' }],
+  }) as any;
+
+  const parsed = mintInfo?.value?.data?.parsed?.info;
+  const mintAuthority = parsed?.mintAuthority || null;
+  const freezeAuthority = parsed?.freezeAuthority || null;
+  const supply = parsed?.supply ? Number(parsed.supply) : null;
+  const decimals = parsed?.decimals ?? null;
+
+  const isMintable = mintAuthority !== null;
+  const isFreezable = freezeAuthority !== null;
+
+  if (isMintable) risks.push('MINT_AUTHORITY_ACTIVE — token supply can be increased');
+  if (isFreezable) risks.push('FREEZE_AUTHORITY_ACTIVE — accounts can be frozen');
+
+  let name: string | null = null;
+  let symbol: string | null = null;
+  let metadata: unknown = null;
+  try {
+    const metaResult = await getTokenMetadata(mintAddress) as any[];
+    if (metaResult?.[0]) {
+      metadata = metaResult[0];
+      name = metaResult[0]?.onChainMetadata?.metadata?.data?.name || 
+             metaResult[0]?.offChainMetadata?.metadata?.name || null;
+      symbol = metaResult[0]?.onChainMetadata?.metadata?.data?.symbol ||
+               metaResult[0]?.offChainMetadata?.metadata?.symbol || null;
+    }
+  } catch {
+    risks.push('METADATA_FETCH_FAILED — could not retrieve token metadata');
+  }
+
+  let topHolders: { address: string; amount: number; percentage: number }[] = [];
+  let holderConcentration = 0;
+  try {
+    const holders = await heliusRpc({
+      method: 'getTokenLargestAccounts',
+      params: [mintAddress],
+    }) as any;
+
+    const totalSupply = supply && decimals !== null ? supply / Math.pow(10, decimals) : 0;
+    topHolders = (holders?.value || []).slice(0, 10).map((h: any) => {
+      const amount = Number(h.amount) / Math.pow(10, decimals || 0);
+      const percentage = totalSupply > 0 ? (amount / totalSupply) * 100 : 0;
+      return {
+        address: h.address,
+        amount,
+        percentage: Math.round(percentage * 100) / 100,
+      };
+    });
+
+    holderConcentration = topHolders.reduce((sum, h) => sum + h.percentage, 0);
+    holderConcentration = Math.round(holderConcentration * 100) / 100;
+
+    if (holderConcentration > 80) {
+      risks.push(`HIGH_CONCENTRATION — top 10 holders own ${holderConcentration}% of supply`);
+    } else if (holderConcentration > 50) {
+      risks.push(`MODERATE_CONCENTRATION — top 10 holders own ${holderConcentration}% of supply`);
+    }
+
+    const bigWhale = topHolders.find(h => h.percentage > 20);
+    if (bigWhale) {
+      risks.push(`WHALE_ALERT — single holder owns ${bigWhale.percentage}% (${bigWhale.address.slice(0, 8)}...)`);
+    }
+  } catch {
+    risks.push('HOLDER_ANALYSIS_FAILED — could not fetch holder data');
+  }
+
+  return {
+    mint: mintAddress,
+    name,
+    symbol,
+    supply,
+    decimals,
+    freezeAuthority,
+    mintAuthority,
+    isFreezable,
+    isMintable,
+    topHolders,
+    holderConcentration,
+    lpInfo: null,
+    metadata,
+    risks,
+  };
+}

package/server/routes/risk.ts

@@ -0,0 +1,65 @@
+import { Router } from 'express';
+import { getBalance, getTokenAccounts, getTransactionHistory } from '../lib/helius';
+import { clawAnalyze } from '../lib/claw-agent';
+
+export const riskRoute = Router();
+
+riskRoute.get('/wallet/:address', async (req, res) => {
+  try {
+    const { address } = req.params;
+
+    const results = await Promise.allSettled([
+      getBalance(address),
+      getTokenAccounts(address),
+      getTransactionHistory(address, 5),
+    ]);
+
+    const balance = results[0].status === 'fulfilled' ? results[0].value as number : 0;
+    const tokenAccounts = results[1].status === 'fulfilled' ? results[1].value : { value: [] };
+    const recentTxs = results[2].status === 'fulfilled' ? results[2].value : [];
+
+    const txSummary = (recentTxs as any[])?.map((tx: any) => ({
+      type: tx.type,
+      source: tx.source,
+      fee: tx.fee,
+      description: tx.description?.slice(0, 200),
+      timestamp: tx.timestamp,
+    })) || [];
+
+    const clawReport = await clawAnalyze(JSON.stringify({
+      type: 'WALLET_RISK_ANALYSIS',
+      address,
+      balanceSOL: balance / 1e9,
+      tokenAccountCount: (tokenAccounts as any)?.value?.length || 0,
+      recentTransactionSummary: txSummary,
+    }));
+
+    res.json({
+      address,
+      balanceSOL: balance / 1e9,
+      tokenAccounts,
+      recentTransactions: recentTxs,
+      clawAnalysis: clawReport,
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message || 'Wallet analysis failed' });
+  }
+});
+
+riskRoute.post('/analyze', async (req, res) => {
+  try {
+    const { data, context } = req.body;
+    if (!data) {
+      return res.status(400).json({ error: 'Missing data for analysis' });
+    }
+
+    const clawReport = await clawAnalyze(JSON.stringify({
+      type: context || 'CUSTOM_ANALYSIS',
+      data,
+    }));
+
+    res.json({ clawAnalysis: clawReport });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});

package/server/routes/simulate.ts

@@ -0,0 +1,68 @@
+import { Router } from 'express';
+import { simulateTransaction, getBalance, getParsedTransaction } from '../lib/helius';
+import { clawAnalyze } from '../lib/claw-agent';
+
+export const simulateRoute = Router();
+
+simulateRoute.post('/transaction', async (req, res) => {
+  try {
+    const { transaction, walletAddress } = req.body;
+    if (!transaction) {
+      return res.status(400).json({ error: 'Missing transaction (base64 encoded)' });
+    }
+
+    let preBalance: number | null = null;
+    if (walletAddress) {
+      preBalance = await getBalance(walletAddress);
+    }
+
+    const simResult = await simulateTransaction(transaction);
+
+    let estimatedCost: number | null = null;
+    if (preBalance !== null && simResult.unitsConsumed > 0) {
+      estimatedCost = simResult.unitsConsumed * 0.000005;
+    }
+
+    const clawReport = await clawAnalyze(JSON.stringify({
+      type: 'TRANSACTION_SIMULATION',
+      success: simResult.success,
+      logs: simResult.logs,
+      unitsConsumed: simResult.unitsConsumed,
+      error: simResult.error,
+      walletAddress,
+      preBalance: preBalance ? preBalance / 1e9 : null,
+      estimatedCostSOL: estimatedCost,
+    }));
+
+    res.json({
+      simulation: simResult,
+      preBalance: preBalance ? preBalance / 1e9 : null,
+      estimatedCostSOL: estimatedCost,
+      clawAnalysis: clawReport,
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+simulateRoute.post('/preview', async (req, res) => {
+  try {
+    const { signature } = req.body;
+    if (!signature) {
+      return res.status(400).json({ error: 'Missing transaction signature' });
+    }
+
+    const txData = await getParsedTransaction(signature);
+    const clawReport = await clawAnalyze(JSON.stringify({
+      type: 'TRANSACTION_REVIEW',
+      transaction: txData,
+    }));
+
+    res.json({
+      transaction: txData,
+      clawAnalysis: clawReport,
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});

package/server/routes/token.ts

@@ -0,0 +1,41 @@
+import { Router } from 'express';
+import { analyzeToken } from '../lib/token-analysis';
+import { getTransactionHistory } from '../lib/helius';
+import { clawAnalyze } from '../lib/claw-agent';
+
+export const tokenRoute = Router();
+
+tokenRoute.get('/:mint', async (req, res) => {
+  try {
+    const { mint } = req.params;
+    if (!mint || mint.length < 32) {
+      return res.status(400).json({ error: 'Invalid mint address' });
+    }
+
+    const report = await analyzeToken(mint);
+
+    const clawReport = await clawAnalyze(JSON.stringify({
+      type: 'TOKEN_SECURITY_ANALYSIS',
+      ...report,
+    }));
+
+    res.json({
+      token: report,
+      clawAnalysis: clawReport,
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+tokenRoute.get('/:mint/history', async (req, res) => {
+  try {
+    const { mint } = req.params;
+    const limit = parseInt(req.query.limit as string) || 10;
+
+    const history = await getTransactionHistory(mint, limit);
+    res.json({ history });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});