Introduction to Vexa

import { VexaClient } from '@vexa/sdk';
import { Keypair } from '@solana/web3.js';

// Initialize with your wallet
const wallet = Keypair.fromSecretKey(yourSecretKey);

const vexa = new VexaClient({
  wallet,
  rpcUrl: 'https://api.mainnet-beta.solana.com',
  // or use custom RPC
  // rpcUrl: process.env.HELIUS_RPC_URL,
});

// Authenticate
await vexa.connect();
console.log('Connected:', vexa.publicKey.toBase58());

import { VexaClient, RuleBuilder } from '@vexa/sdk';

const rule = new RuleBuilder()
  .name('LP Protection')
  .when('LIQUIDITY_OUT')
  .condition('percentage', '>', 30)
  .and('PRICE_CHANGE')
  .condition('percentage', '<', -5)
  .then('WITHDRAW_LP')
  .then('TRANSFER', { to: coldWalletAddress })
  .cooldown(300) // 5 minutes
  .build();

await vexa.rules.create(rule);
console.log('Rule created:', rule.id);

const complexRule = new RuleBuilder()
  .name('Smart Exit Strategy')
  .when('LIQUIDITY_OUT')
  .condition('percentage', '>', 25)
  .and('WHALE_MOVE')
  .condition('action', '=', 'sell')
  .and('RISK_SCORE_CHANGE')
  .condition('newScore', '<', 50)
  .then('WITHDRAW_LP', { percentage: 100 })
  .then('AUTO_SWAP', { from: 'TOKEN', to: 'USDC' })
  .then('TRANSFER', { to: safeWalletAddress })
  .build();

// Set your safe wallet address
await vexa.safety.setSafeWallet({
  address: 'YourColdWalletPublicKey...',
  label: 'Hardware Wallet',
  autoTransferThreshold: 40, // Risk score below this triggers transfer
});

// Configure what triggers a safe wallet transfer
await vexa.safety.setAutoDefense({
  enabled: true,
  actions: [
    { trigger: 'RISK_SCORE_BELOW', value: 40, action: 'TRANSFER_ALL' },
    { trigger: 'RUG_DETECTED', action: 'EMERGENCY_EXIT' },
    { trigger: 'HONEYPOT_DETECTED', action: 'PAUSE_RULES' },
  ]
});

const vexa = new VexaClient({
  wallet,
  rpcUrl: process.env.HELIUS_RPC_URL,
  rpcOptions: {
    // Backup RPCs for failover
    fallbackUrls: [
      process.env.QUICKNODE_RPC_URL,
      'https://api.mainnet-beta.solana.com',
    ],
    // Timeout before trying next RPC
    timeout: 5000,
    // Maximum retries per RPC
    maxRetries: 3,
    // Enable automatic health checks
    healthCheck: true,
    healthCheckInterval: 30000, // 30 seconds
  }
});

await vexa.config.setGasOptions({
  // Priority fee strategy
  strategy: 'dynamic', // 'fixed' | 'dynamic' | 'aggressive'
  
  // For 'fixed' strategy
  fixedPriorityFee: 10000, // microLamports
  
  // For 'dynamic' strategy
  dynamicOptions: {
    percentile: 75, // Use 75th percentile of recent fees
    minFee: 5000,
    maxFee: 100000,
  },
  
  // Compute unit settings
  computeUnits: {
    autoEstimate: true,
    buffer: 1.2, // 20% buffer
  }
});

await vexa.notifications.configure({
  telegram: {
    botToken: process.env.TELEGRAM_BOT_TOKEN,
    chatId: process.env.TELEGRAM_CHAT_ID,
  },
  webhook: {
    url: 'https://your-server.com/vexa-webhook',
    secret: process.env.WEBHOOK_SECRET,
  },
  alerts: {
    ruleExecuted: true,
    riskAlert: true,
    dailySummary: true,
    errorNotifications: true,
  }
});

const sniperRule = new RuleBuilder()
  .name('Fresh Liquidity Sniper')
  .when('NEW_POOL')
  .condition('initialLiquidity', '>', 30000) // Min $30k
  .and('RISK_SCORE_CHANGE')
  .condition('newScore', '>', 60) // Safe pools only
  .then('AUTO_SWAP', {
    from: 'USDC',
    to: 'NEW_TOKEN',
    amount: 100, // $100 per snipe
    slippage: 5,
  })
  .cooldown(60) // 1 min cooldown
  .maxExecutions(10, '24h') // Max 10 per day
  .build();

// DCA into SOL every day
const dcaRule = new RuleBuilder()
  .name('Daily SOL DCA')
  .schedule('0 9 * * *') // Every day at 9 AM UTC
  .then('AUTO_SWAP', {
    from: 'USDC',
    to: 'SOL',
    amount: 50, // $50 per day
    slippage: 1,
  })
  .build();

// DCA on dips
const dipDcaRule = new RuleBuilder()
  .name('Buy the Dip')
  .when('PRICE_CHANGE')
  .condition('percentage', '<', -5) // 5% drop
  .condition('timeframe', '=', '1h')
  .then('AUTO_SWAP', {
    from: 'USDC',
    to: 'SOL',
    amount: 100,
  })
  .cooldown(3600) // 1 hour between buys
  .build();

import { 
  VexaClient, 
  RuleBuilder, 
  EventType,
  ActionType 
} from '@vexa/sdk';

// Initialize client
const vexa = new VexaClient({
  wallet: yourWallet,
  rpcUrl: process.env.RPC_URL,
  options: {
    gasOptimizer: true,
    rpcFailover: true,
    maxRetries: 3,
  }
});

// Connect and start monitoring
await vexa.connect();

// Subscribe to events
vexa.on('LIQUIDITY_OUT', (event) => {
  console.log('Liquidity removed:', event);
});

// Create and activate a rule
const rule = new RuleBuilder()
  .name('My Automation')
  .when(EventType.VOLUME_SPIKE)
  .condition('multiplier', '>', 2)
  .then(ActionType.REBALANCE, { 
    targets: { USDC: 20 } 
  })
  .build();

await vexa.rules.create(rule);
await vexa.rules.activate(rule.id);

interface VexaClientConfig {
  // Required
  wallet: Keypair | Wallet;
  rpcUrl: string;
  
  // Optional
  options?: {
    // Transaction settings
    gasOptimizer?: boolean;      // Auto-optimize priority fees
    computeUnitLimit?: number;   // Max compute units
    skipPreflight?: boolean;     // Skip simulation
    
    // RPC settings
    rpcFailover?: boolean;       // Enable failover
    fallbackUrls?: string[];     // Backup RPCs
    rpcTimeout?: number;         // Timeout in ms
    maxRetries?: number;         // Retry attempts
    
    // Monitoring settings
    pollInterval?: number;       // Event poll rate (ms)
    maxConcurrent?: number;      // Concurrent transactions
    
    // Safety settings
    safetyGuard?: boolean;       // Enable SSG
    autoDefense?: boolean;       // Auto-protect on risk
  };
}

// Subscribe to events
vexa.on('ruleExecuted', (event) => {
  console.log('Rule executed:', event.ruleId);
  console.log('Transaction:', event.txSignature);
});

vexa.on('riskAlert', (event) => {
  console.warn('Risk detected:', event.pool);
  console.warn('Score dropped:', event.oldScore, '->', event.newScore);
});

// Unsubscribe
const unsubscribe = vexa.on('liquidityEvent', handler);
unsubscribe(); // Stop listening

// Event types
enum EventType {
  LIQUIDITY_IN = 'LIQUIDITY_IN',
  LIQUIDITY_OUT = 'LIQUIDITY_OUT',
  VOLUME_SPIKE = 'VOLUME_SPIKE',
  WHALE_MOVE = 'WHALE_MOVE',
  NEW_POOL = 'NEW_POOL',
  PRICE_CHANGE = 'PRICE_CHANGE',
  RISK_SCORE_CHANGE = 'RISK_SCORE_CHANGE',
}

// Action types
enum ActionType {
  AUTO_SWAP = 'AUTO_SWAP',
  WITHDRAW_LP = 'WITHDRAW_LP',
  ADD_LP = 'ADD_LP',
  TRANSFER = 'TRANSFER',
  REBALANCE = 'REBALANCE',
  TAKE_PROFIT = 'TAKE_PROFIT',
  STOP_LOSS = 'STOP_LOSS',
  DCA = 'DCA',
}

// Rule interface
interface Rule {
  id: string;
  name: string;
  status: 'active' | 'paused' | 'error';
  trigger: EventType;
  conditions: Condition[];
  actions: Action[];
  cooldown: number;
  createdAt: Date;
  lastExecuted?: Date;
  executionCount: number;
}

// Pool interface
interface Pool {
  address: string;
  tokenA: Token;
  tokenB: Token;
  tvl: number;
  volume24h: number;
  apy: number;
  riskScore: number;
  dex: 'raydium' | 'orca' | 'phoenix' | 'meteora';
}