Monad Swarm Agent

#!/usr/bin/env npx ts-node
/**
 * 🔗 Log Swarm Decision to Monad Chain
 * 
 * Creates an immutable record of swarm decisions on Monad
 * Each decision includes: asset, signals, consensus, timestamp
 */

import { ethers } from 'ethers';

// Decision log contract ABI (simple storage)
const DECISION_LOG_ABI = [
  'function logDecision(string asset, uint8 direction, uint8 confidence, uint8 agentCount, bytes32 signalHash) external',
  'function getDecision(uint256 id) external view returns (string asset, uint8 direction, uint8 confidence, uint256 timestamp)',
  'function decisionCount() external view returns (uint256)',
  'event DecisionLogged(uint256 indexed id, string asset, uint8 direction, uint8 confidence, uint256 timestamp)'
];

// Direction enum matching contract
enum Direction {
  STRONG_BUY = 0,
  BUY = 1,
  NEUTRAL = 2,
  SELL = 3,
  STRONG_SELL = 4
}

interface SwarmDecision {
  asset: string;
  direction: string;
  confidence: number;
  signals: {
    agent: string;
    type: string;
    strength: number;
    reasoning: string;
  }[];
}

async function logToMonad(decision: SwarmDecision): Promise<string> {
  const rpcUrl = process.env.MONAD_RPC_URL || 'https://testnet.monad.xyz/rpc';
  const privateKey = process.env.MONAD_PRIVATE_KEY;
  const contractAddress = process.env.DECISION_LOG_CONTRACT;
  
  if (!privateKey || !contractAddress) {
    console.log('⚠️  Monad logging not configured (missing MONAD_PRIVATE_KEY or DECISION_LOG_CONTRACT)');
    console.log('   Generating decision hash for reference...\n');
    
    // Generate hash even without on-chain logging
    const hash = ethers.keccak256(
      ethers.toUtf8Bytes(JSON.stringify(decision))
    );
    
    console.log(`📝 Decision Hash: ${hash}`);
    console.log(`   Asset: ${decision.asset}`);
    console.log(`   Direction: ${decision.direction}`);
    console.log(`   Confidence: ${decision.confidence}%`);
    console.log(`   Agents: ${decision.signals.length}`);
    
    return hash;
  }
  
  console.log('🔗 Logging decision to Monad...\n');
  
  const provider = new ethers.JsonRpcProvider(rpcUrl);
  const wallet = new ethers.Wallet(privateKey, provider);
  const contract = new ethers.Contract(contractAddress, DECISION_LOG_ABI, wallet);
  
  // Map direction string to enum
  const directionMap: Record<string, Direction> = {
    'STRONG BUY': Direction.STRONG_BUY,
    'BUY': Direction.BUY,
    'NEUTRAL': Direction.NEUTRAL,
    'SELL': Direction.SELL,
    'STRONG SELL': Direction.STRONG_SELL
  };
  
  const direction = directionMap[decision.direction] ?? Direction.NEUTRAL;
  
  // Hash the signals for compact storage
  const signalHash = ethers.keccak256(
    ethers.toUtf8Bytes(JSON.stringify(decision.signals))
  );
  
  try {
    const tx = await contract.logDecision(
      decision.asset,
      direction,
      decision.confidence,
      decision.signals.length,
      signalHash
    );
    
    console.log(`📤 Transaction submitted: ${tx.hash}`);
    console.log('⏳ Waiting for confirmation...');
    
    const receipt = await tx.wait();
    
    console.log(`✅ Decision logged on Monad!`);
    console.log(`   Block: ${receipt.blockNumber}`);
    console.log(`   Gas used: ${receipt.gasUsed.toString()}`);
    
    // Find the event
    const event = receipt.logs.find(
      (log: any) => log.fragment?.name === 'DecisionLogged'
    );
    
    if (event) {
      console.log(`   Decision ID: ${event.args.id.toString()}`);
    }
    
    return tx.hash;
    
  } catch (error: any) {
    console.error('❌ Failed to log decision:', error.message);
    throw error;
  }
}

// Example usage / test
async function main() {
  const testDecision: SwarmDecision = {
    asset: 'MONAD',
    direction: 'STRONG BUY',
    confidence: 78,
    signals: [
      { agent: 'Trading', type: 'bullish', strength: 72, reasoning: 'RSI oversold' },
      { agent: 'Sentiment', type: 'bullish', strength: 85, reasoning: 'Positive Twitter' },
      { agent: 'OnChain', type: 'bullish', strength: 68, reasoning: 'Whale accumulation' }
    ]
  };
  
  await logToMonad(testDecision);
}

// Export for use in other scripts
export { logToMonad, SwarmDecision };

// Run if called directly
if (require.main === module) {
  main().catch(console.error);
}

#!/usr/bin/env npx ts-node
/**
 * 🐝 Monad Swarm Intelligence - Analysis Script
 * 
 * Runs a multi-agent swarm analysis on a given asset
 * Each agent provides its signal, then consensus is reached
 * 
 * Usage: npx ts-node swarm-analyze.ts MONAD
 */

// Types
interface Signal {
  agent: string;
  emoji: string;
  type: 'bullish' | 'bearish' | 'neutral';
  strength: number; // 0-100
  reasoning: string;
}

interface ConsensusResult {
  direction: 'STRONG BUY' | 'BUY' | 'NEUTRAL' | 'SELL' | 'STRONG SELL';
  confidence: number;
  agreementCount: number;
  totalAgents: number;
}

// ═══════════════════════════════════════════════════════════════
//                     TRADING AGENT
// ═══════════════════════════════════════════════════════════════

async function tradingAgent(asset: string): Promise<Signal> {
  // Simulate technical analysis
  // In production: fetch real price data from CoinGecko/Binance
  
  const rsi = Math.random() * 100;
  const macdHistogram = Math.random() * 2 - 1;
  const priceVsSMA = Math.random() * 0.2 - 0.1;
  
  let type: Signal['type'] = 'neutral';
  let strength = 50;
  const reasons: string[] = [];
  
  // RSI analysis
  if (rsi < 30) {
    type = 'bullish';
    strength += 20;
    reasons.push(`RSI oversold at ${rsi.toFixed(0)}`);
  } else if (rsi > 70) {
    type = 'bearish';
    strength += 20;
    reasons.push(`RSI overbought at ${rsi.toFixed(0)}`);
  }
  
  // MACD analysis
  if (macdHistogram > 0.3) {
    if (type !== 'bearish') type = 'bullish';
    strength += 15;
    reasons.push('MACD bullish crossover');
  } else if (macdHistogram < -0.3) {
    if (type !== 'bullish') type = 'bearish';
    strength += 15;
    reasons.push('MACD bearish crossover');
  }
  
  // Price vs SMA
  if (priceVsSMA > 0.05) {
    reasons.push('Price above 50-day SMA');
    strength += 10;
  } else if (priceVsSMA < -0.05) {
    reasons.push('Price below 50-day SMA');
  }
  
  return {
    agent: 'Trading Agent',
    emoji: '📈',
    type,
    strength: Math.min(100, strength),
    reasoning: reasons.join(', ') || 'No clear signals'
  };
}

// ═══════════════════════════════════════════════════════════════
//                     SENTIMENT AGENT
// ═══════════════════════════════════════════════════════════════

async function sentimentAgent(asset: string): Promise<Signal> {
  // Simulate social sentiment analysis
  // In production: use Twitter API, Discord bots, etc.
  
  const twitterVolume = Math.random() * 500 - 100; // % change
  const sentimentScore = Math.random() * 2 - 1; // -1 to 1
  const influencerMentions = Math.floor(Math.random() * 10);
  
  let type: Signal['type'] = 'neutral';
  let strength = 50;
  const reasons: string[] = [];
  
  // Volume surge
  if (twitterVolume > 100) {
    strength += 20;
    reasons.push(`Twitter volume +${twitterVolume.toFixed(0)}%`);
  }
  
  // Sentiment direction
  if (sentimentScore > 0.3) {
    type = 'bullish';
    strength += Math.floor(sentimentScore * 30);
    reasons.push('positive keywords dominating');
  } else if (sentimentScore < -0.3) {
    type = 'bearish';
    strength += Math.floor(Math.abs(sentimentScore) * 30);
    reasons.push('negative sentiment detected');
  }
  
  // Influencer activity
  if (influencerMentions > 5) {
    strength += 15;
    reasons.push(`${influencerMentions} influencer mentions`);
  }
  
  return {
    agent: 'Sentiment Agent',
    emoji: '🐦',
    type,
    strength: Math.min(100, strength),
    reasoning: reasons.join(', ') || 'Low social activity'
  };
}

// ═══════════════════════════════════════════════════════════════
//                     ONCHAIN AGENT
// ═══════════════════════════════════════════════════════════════

async function onchainAgent(asset: string): Promise<Signal> {
  // Simulate on-chain analysis
  // In production: use Etherscan, The Graph, Nansen
  
  const whaleNetFlow = (Math.random() * 10 - 5) * 1000000; // $M
  const smartMoneyBuying = Math.random() > 0.4;
  const dexBuyRatio = Math.random(); // 0-1, higher = more buying
  
  let type: Signal['type'] = 'neutral';
  let strength = 50;
  const reasons: string[] = [];
  
  // Whale flow
  if (whaleNetFlow > 1000000) {
    type = 'bullish';
    strength += 25;
    reasons.push(`whale wallets +$${(whaleNetFlow/1000000).toFixed(1)}M net`);
  } else if (whaleNetFlow < -1000000) {
    type = 'bearish';
    strength += 25;
    reasons.push(`whale wallets -$${(Math.abs(whaleNetFlow)/1000000).toFixed(1)}M net`);
  }
  
  // Smart money
  if (smartMoneyBuying) {
    if (type !== 'bearish') type = 'bullish';
    strength += 20;
    reasons.push('Smart money accumulating');
  } else {
    reasons.push('Smart money neutral');
  }
  
  // DEX flows
  if (dexBuyRatio > 0.6) {
    strength += 10;
    reasons.push(`DEX buy pressure ${(dexBuyRatio * 100).toFixed(0)}%`);
  } else if (dexBuyRatio < 0.4) {
    reasons.push(`DEX sell pressure ${((1 - dexBuyRatio) * 100).toFixed(0)}%`);
  }
  
  return {
    agent: 'OnChain Agent',
    emoji: '🔗',
    type,
    strength: Math.min(100, strength),
    reasoning: reasons.join(', ') || 'No significant on-chain signals'
  };
}

// ═══════════════════════════════════════════════════════════════
//                     CONSENSUS ENGINE
// ═══════════════════════════════════════════════════════════════

function buildConsensus(signals: Signal[]): ConsensusResult {
  const bullishCount = signals.filter(s => s.type === 'bullish').length;
  const bearishCount = signals.filter(s => s.type === 'bearish').length;
  const totalAgents = signals.length;
  
  const avgStrength = signals.reduce((sum, s) => sum + s.strength, 0) / totalAgents;
  
  let direction: ConsensusResult['direction'];
  let agreementCount: number;
  
  if (bullishCount > bearishCount) {
    agreementCount = bullishCount;
    direction = avgStrength > 70 ? 'STRONG BUY' : 'BUY';
  } else if (bearishCount > bullishCount) {
    agreementCount = bearishCount;
    direction = avgStrength > 70 ? 'STRONG SELL' : 'SELL';
  } else {
    agreementCount = signals.filter(s => s.type === 'neutral').length;
    direction = 'NEUTRAL';
  }
  
  const confidence = Math.round((agreementCount / totalAgents) * avgStrength);
  
  return {
    direction,
    confidence,
    agreementCount,
    totalAgents
  };
}

// ═══════════════════════════════════════════════════════════════
//                        MAIN
// ═══════════════════════════════════════════════════════════════

async function runSwarmAnalysis(asset: string): Promise<void> {
  console.log(`\n🐝 SWARM INTELLIGENCE REPORT`);
  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
  console.log(`Asset: ${asset.toUpperCase()}`);
  console.log(`Timestamp: ${new Date().toISOString()}\n`);
  
  // Run all agents in parallel
  const [trading, sentiment, onchain] = await Promise.all([
    tradingAgent(asset),
    sentimentAgent(asset),
    onchainAgent(asset)
  ]);
  
  const signals = [trading, sentiment, onchain];
  
  // Display each agent's signal
  for (const signal of signals) {
    const typeEmoji = signal.type === 'bullish' ? '🟢' : signal.type === 'bearish' ? '🔴' : '⚪';
    console.log(`${signal.emoji} ${signal.agent}: ${typeEmoji} ${signal.type.toUpperCase()} (strength: ${signal.strength}/100)`);
    console.log(`   └─ ${signal.reasoning}\n`);
  }
  
  // Build consensus
  const consensus = buildConsensus(signals);
  
  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
  console.log(`🎯 CONSENSUS: ${consensus.direction}`);
  console.log(`   Confidence: ${consensus.confidence}%`);
  console.log(`   Agents agreeing: ${consensus.agreementCount}/${consensus.totalAgents}`);
  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
  
  // TODO: Log to Monad chain when available
  // await logToMonad(asset, signals, consensus);
}

// Run if called directly
const asset = process.argv[2] || 'MONAD';
runSwarmAnalysis(asset).catch(console.error);