Corsaro Documentation

# Install via npm
npm install corsaro

# Or using yarn
yarn add corsaro

import { Corsaro, Networks } from 'corsaro';
import { Connection } from '@helius-labs/helius';

// Initialize Helius connection
const connection = new Connection(
  "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"
);

// Initialize Corsaro with Helius connection
const corsaro = new Corsaro({
  network: Networks.MAINNET,
  connection,
  walletPrivateKey: process.env.WALLET_PRIVATE_KEY,
});

// Create a simple trading strategy
const strategy = corsaro.createStrategy({
  name: 'SMA Crossover',
  params: {
    fastPeriod: 10,
    slowPeriod: 30,
  },
  execute: async (data) => {
    // Your strategy logic here
    const { fastMA, slowMA } = data;
    
    if (fastMA > slowMA) {
      return corsaro.signals.BUY;
    } else if (fastMA < slowMA) {
      return corsaro.signals.SELL;
    }
    
    return corsaro.signals.HOLD;
  }
});

// Start the trading agent
corsaro.start();

// Creating a custom trading strategy
import { Corsaro, Strategy } from 'corsaro';

class CustomStrategy extends Strategy {
  constructor(params) {
    super('Custom Strategy', params);
    this.requiredData = ['ohlcv', 'volume'];
  }
  
  async initialize() {
    // Set up indicators or load models
    this.rsi = this.indicators.rsi(this.params.rsiPeriod);
    this.ema = this.indicators.ema(this.params.emaPeriod);
    
    // Optional: Load ML model
    await this.loadModel('/path/to/model');
  }
  
  async execute(data) {
    // Your strategy logic here
    const { close, volume } = data;
    const rsiValue = this.rsi.calculate(close);
    const emaValue = this.ema.calculate(close);
    
    if (rsiValue < 30 && close > emaValue) {
      return this.signals.BUY;
    } else if (rsiValue > 70 && close < emaValue) {
      return this.signals.SELL;
    }
    
    return this.signals.HOLD;
  }
}

// Register your custom strategy
corsaro.registerStrategy(new CustomStrategy({
  rsiPeriod: 14,
  emaPeriod: 21,
}));

// Trading with Helius
import { Corsaro } from 'corsaro';
import { Connection, TransactionBuilder } from '@helius-labs/helius';
import { PublicKey } from '@solana/web3.js';

// Initialize with your Helius API key
const connection = new Connection(
  "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"
);

const corsaro = new Corsaro({
  network: 'mainnet',
  connection,
  walletPrivateKey: process.env.WALLET_PRIVATE_KEY,
});

// Example: Creating a trade order using Helius
async function placeTrade(tokenAddress, amount, side) {
  const tokenMint = new PublicKey(tokenAddress);
  
  const txBuilder = new TransactionBuilder(connection);
  
  if (side === 'buy') {
    // Create a buy order for the token
    await txBuilder.addInstruction({
      swapExactSOLForTokens: {
        amountIn: amount,
        tokenMint,
      }
    });
  } else {
    // Create a sell order for the token
    await txBuilder.addInstruction({
      swapExactTokensForSOL: {
        amountIn: amount,
        tokenMint,
      }
    });
  }
  
  // Sign and send the transaction
  const signature = await txBuilder.buildAndExecute();
  
  console.log(`Trade executed: ${signature}`);
  return signature;
}

// Use in your Corsaro strategy
corsaro.createStrategy({
  name: 'Helius Trading Strategy',
  params: {
    tokenAddress: 'So11111111111111111111111111111111111111112',
    tradeAmount: 0.1, // SOL
  },
  execute: async (data) => {
    const { signal, params } = data;
    
    if (signal === corsaro.signals.BUY) {
      await placeTrade(params.tokenAddress, params.tradeAmount, 'buy');
    } else if (signal === corsaro.signals.SELL) {
      await placeTrade(params.tokenAddress, params.tradeAmount, 'sell');
    }
  }
});

// Using Corsaro AI Assistant
import { Corsaro } from 'corsaro';

const corsaro = new Corsaro({
  // Your configuration here
});

// Enable AI Trading Assistant
corsaro.enableAI({
  // Customize AI behavior
  riskTolerance: 'medium',
  tradingStyle: 'momentum',
  maxDrawdown: 0.15, // 15%
  
  // Learn from your manual trades
  learnFromHistory: true,
  
  // Rules
  rules: [
    'Never trade more than 5% of portfolio value',
    'Avoid trading during high volatility',
    'Always use stop loss at 2% below entry'
  ]
});

// The AI assistant will analyze your trading patterns
// and provide suggestions or execute trades