skayn-trading-sdk/index.js

Professional Bitcoin trading strategy backtesting framework with institutional-grade architecture

/**
 * Skayn Trading SDK
 * The easiest way to build Bitcoin trading strategies
 * Focused on Bitcoin perpetuals and spot trading
 * 
 * @example
 * const { SDK } = require('skayn-trading-sdk');
 * 
 * class MyStrategy extends SDK.Strategy {
 *   async analyze(data, portfolio) {
 *     return { action: 'BUY', confidence: 0.8 };
 *   }
 * }
 * 
 * const bot = SDK.create()
 *   .strategy(new MyStrategy())
 *   .dataProvider(myDataProvider)
 *   .backtest();
 */

// Core Interfaces - The building blocks
const IStrategy = require('./src/interfaces/IStrategy');
const IDataProvider = require('./src/interfaces/IDataProvider');
const IBacktestEngine = require('./src/interfaces/IBacktestEngine');
const IExchangeProvider = require('./src/interfaces/IExchangeProvider');
const IRiskManager = require('./src/interfaces/IRiskManager');
const IPositionManager = require('./src/interfaces/IPositionManager');
const IExecutionEngine = require('./src/interfaces/IExecutionEngine');
const INotificationProvider = require('./src/interfaces/INotificationProvider');
const IStorageProvider = require('./src/interfaces/IStorageProvider');

// Framework Components
const TradingFramework = require('./src/core/trading-framework');
const PluginRegistry = require('./src/core/plugin-registry');

// Utilities
const ErrorHandler = require('./src/utils/error-handler');

/**
 * Main SDK Class - Your entry point to algorithmic trading
 */
class SkaynTradingSDK {
  constructor(config = {}) {
    this.framework = new TradingFramework(config);
    this.registry = new PluginRegistry();
    this.config = config;
  }

  /**
   * Register a strategy plugin
   * @param {IStrategy} strategy - Strategy implementation
   * @returns {SkaynTradingSDK} Chainable
   */
  strategy(strategy) {
    this.framework.use('strategy', strategy);
    return this;
  }

  /**
   * Register a data provider plugin
   * @param {IDataProvider} provider - Data provider implementation
   * @returns {SkaynTradingSDK} Chainable
   */
  dataProvider(provider) {
    this.framework.use('dataProvider', provider);
    return this;
  }

  /**
   * Register an exchange provider plugin
   * @param {IExchangeProvider} exchange - Exchange implementation
   * @returns {SkaynTradingSDK} Chainable
   */
  exchange(exchange) {
    this.framework.use('executionEngine', exchange);
    return this;
  }

  /**
   * Register a backtest engine - use ours or plug in your own
   * @param {IBacktestEngine} engine - Backtest engine implementation
   * @returns {SkaynTradingSDK} Chainable
   */
  backtestEngine(engine) {
    this.framework.use('backtestEngine', engine);
    return this;
  }

  /**
   * Run backtest with current configuration
   * @param {Object} config - Backtest configuration
   * @returns {Promise<Object>} Backtest results
   */
  async backtest(config = {}) {
    // Set up required components if not provided
    if (!this.framework.activeComponents.has('backtestEngine')) {
      const SimpleBacktestEngine = require('./src/backtesting/engines/simple-backtest-engine');
      this.framework.use('backtestEngine', new SimpleBacktestEngine(config));
    }
    
    if (!this.framework.activeComponents.has('positionManager')) {
      const SimplePositionManager = require('./src/backtesting/managers/simple-position-manager');
      this.framework.use('positionManager', new SimplePositionManager(config));
    }
    
    if (!this.framework.activeComponents.has('executionEngine')) {
      // Mock execution engine for backtesting
      const mockExecutionEngine = {
        async execute(signal) {
          return { success: true, executedPrice: 45000 };
        }
      };
      this.framework.use('executionEngine', mockExecutionEngine);
    }
    
    return await this.framework.runBacktest(config);
  }

  /**
   * Start live trading
   * @param {Object} config - Live trading configuration
   * @returns {Promise<void>}
   */
  async live(config = {}) {
    return await this.framework.startLiveTrading(config);
  }
}

/**
 * Quick start factory functions
 */
const SDK = {
  /**
   * Create a new SDK instance
   * @param {Object} config - Initial configuration
   * @returns {SkaynTradingSDK} SDK instance
   */
  create(config = {}) {
    return new SkaynTradingSDK(config);
  },

  // Base interfaces for extending
  Strategy: IStrategy,
  DataProvider: IDataProvider,
  BacktestEngine: IBacktestEngine,

  /**
   * Create a strategy from a simple function
   * @param {Function} analyzeFunction - Strategy logic
   * @param {Object} metadata - Strategy metadata
   * @returns {IStrategy} Strategy instance
   */
  strategy(analyzeFunction, metadata = {}) {
    return new (class extends IStrategy {
      async analyze(data, portfolio) {
        return await analyzeFunction(data, portfolio);
      }
      
      getRequiredWarmupPeriods() {
        return metadata.warmupPeriods || 20; // Default 20 periods
      }
      
      getStrategyMetadata() {
        return {
          name: metadata.name || 'Custom Strategy',
          version: metadata.version || '1.0.0',
          description: metadata.description || 'User-defined strategy',
          ...metadata
        };
      }
    })();
  },

  /**
   * Create a data provider from a simple function
   * @param {Function} getDataFunction - Data fetching logic
   * @param {Object} metadata - Provider metadata
   * @returns {IDataProvider} Data provider instance
   */
  dataProvider(getDataFunction, metadata = {}) {
    return new (class extends IDataProvider {
      async getData(startDate, endDate, interval, symbol) {
        return await getDataFunction(startDate, endDate, interval, symbol);
      }
    })();
  },

  /**
   * Create a backtest engine from custom logic
   * @param {Function} runBacktestFunction - Backtest execution logic
   * @param {Object} metadata - Engine metadata
   * @returns {IBacktestEngine} Backtest engine instance
   */
  backtestEngine(runBacktestFunction, metadata = {}) {
    return new (class extends IBacktestEngine {
      async runBacktest(config) {
        return await runBacktestFunction(config);
      }
      
      getBacktestEngineMetadata() {
        return {
          name: metadata.name || 'Custom Engine',
          version: metadata.version || '1.0.0',
          description: metadata.description || 'User-defined backtest engine',
          ...metadata
        };
      }
    })();
  }
};

// Export everything
module.exports = {
  // Main SDK class
  SDK,
  SkaynTradingSDK,

  // Base interfaces - Extend these to create plugins
  Strategy: IStrategy,
  DataProvider: IDataProvider,
  BacktestEngine: IBacktestEngine,
  ExchangeProvider: IExchangeProvider,
  RiskManager: IRiskManager,
  PositionManager: IPositionManager,
  ExecutionEngine: IExecutionEngine,
  NotificationProvider: INotificationProvider,
  StorageProvider: IStorageProvider,

  // Framework components
  TradingFramework,
  PluginRegistry,

  // Utilities
  ErrorHandler,

  // Version info
  version: '1.0.0'
};