ZenFlow.Core 1.0.0

ZenFlow - Forex Quantitative Trading Engine

<div align="center">

A modern, high-performance forex quantitative trading engine built with .NET 10

Features • Quick Start • Documentation • Examples

</div>

Overview

ZenFlow is a comprehensive quantitative trading engine designed for forex markets. Inspired by QuantConnect/Lean architecture, it provides a complete framework for developing, backtesting, and deploying algorithmic trading strategies.

Key Highlights

• .NET 10 - Built on the latest .NET platform
• 143 Tests - Comprehensive test coverage ensuring reliability
• Modular Architecture - Clean separation of concerns
• QuantConnect Compatible API - Familiar interface for algorithm development
• Multiple Data Sources - Support for CSV, JSON, API, and real-time feeds
• Rich Indicator Library - SMA, EMA, RSI, MACD, Bollinger Bands, and more

Features

Core Components

Technical Indicators

• SimpleMovingAverage (SMA) - Simple moving average
• ExponentialMovingAverage (EMA) - Exponential moving average
• RelativeStrengthIndex (RSI) - Relative strength index
• MovingAverageConvergenceDivergence (MACD) - MACD indicator
• BollingerBands (BB) - Bollinger Bands volatility indicator

Order Types

Project Structure

ZenFlow/
├── src/
│   └── ZenFlow.Core/
│       ├── Algorithm/          # Strategy framework
│       │   ├── Framework/      # Alpha, Portfolio, Execution models
│       │   └── Strategies/     # Example strategies
│       ├── Brokerage/          # Brokerage implementations
│       ├── Data/               # Market data handling
│       ├── Engine/             # Trading engine core
│       ├── Indicators/         # Technical indicators
│       ├── Trading/            # Orders, Portfolio, Securities
│       └── Examples/           # Usage examples
├── tests/
│   └── ZenFlow.Core.Tests/    # Unit tests (143 tests)
└── samples/                    # Sample applications

Quick Start

Prerequisites

• .NET 10 SDK
• Visual Studio 2022 or VS Code with C# extension

Build and Test

# Clone or navigate to the project
cd ZenFlow

# Build the solution
dotnet build

# Run all tests
dotnet test

Create Your First Strategy

using ZenFlow.Algorithm;
using ZenFlow.Data.Market;
using ZenFlow.Indicators;

public class MyFirstStrategy : QCAlgorithm
{
    private SimpleMovingAverage _sma;
    private Symbol _eurusd;

    public override void Initialize()
    {
        SetCash(100000);
        SetStartDate(2023, 1, 1);
        SetEndDate(2023, 12, 31);

        _eurusd = AddForex("EURUSD", Resolution.Hour);
        _sma = SMA(_eurusd, 20);
    }

    public override void OnData(Slice data)
    {
        if (!_sma.IsReady) return;

        if (data[_eurusd].Price > _sma.Current)
        {
            SetHoldings(_eurusd, 0.1);  // Buy 10%
        }
        else
        {
            Liquidate(_eurusd);  // Close position
        }
    }
}

Examples

Moving Average Cross Strategy

public class MovingAverageCrossStrategy : QCAlgorithm
{
    private ExponentialMovingAverage _fastEma;
    private ExponentialMovingAverage _slowEma;
    private Symbol _symbol;

    public override void Initialize()
    {
        SetCash(100000);
        _symbol = AddForex("EURUSD", Resolution.Hour);

        _fastEma = EMA(_symbol, 10);
        _slowEma = EMA(_symbol, 30);
    }

    public override void OnData(Slice data)
    {
        if (!_fastEma.IsReady || !_slowEma.IsReady) return;

        var holding = Portfolio[_symbol];
        var fastAboveSlow = _fastEma.Current > _slowEma.Current;

        if (fastAboveSlow && holding.Quantity <= 0)
        {
            MarketOrder(_symbol, 10000);
        }
        else if (!fastAboveSlow && holding.Quantity > 0)
        {
            Liquidate(_symbol);
        }
    }
}

RSI Mean Reversion Strategy

public class RsiStrategy : QCAlgorithm
{
    private RelativeStrengthIndex _rsi;
    private Symbol _symbol;

    public override void Initialize()
    {
        SetCash(100000);
        _symbol = AddForex("GBPUSD", Resolution.Hour);
        _rsi = RSI(_symbol, 14);
    }

    public override void OnData(Slice data)
    {
        if (!_rsi.IsReady) return;

        if (_rsi.Current < 30)  // Oversold
        {
            MarketOrder(_symbol, 10000);
        }
        else if (_rsi.Current > 70)  // Overbought
        {
            Liquidate(_symbol);
        }
    }
}

Documentation

Core Concepts

Algorithm Lifecycle

1. Initialize() - Set up strategy parameters, indicators, and subscriptions
2. OnData(Slice) - Process incoming market data and make trading decisions
3. OnOrderEvent(OrderEvent) - Handle order fills, cancellations, etc.
4. OnEndOfAlgorithm() - Final cleanup and reporting

Portfolio Management

// Access portfolio properties
var cash = Portfolio.Cash;
var equity = Portfolio.TotalPortfolioValue;
var holdings = Portfolio[_symbol];

// Position information
var quantity = holdings.Quantity;
var avgPrice = holdings.AveragePrice;
var unrealizedPnL = holdings.UnrealizedProfit;

Order Management

// Market order
var ticket = MarketOrder(_symbol, 10000);

// Limit order
var ticket = LimitOrder(_symbol, 10000, limitPrice: 1.0850);

// Stop order
var ticket = StopMarketOrder(_symbol, -10000, stopPrice: 1.0800);

// Check order status
if (ticket.Status == OrderStatus.Filled)
{
    Log($"Order filled at {ticket.AverageFillPrice}");
}

Performance Metrics

The backtest engine calculates comprehensive performance metrics:

Testing

ZenFlow has comprehensive test coverage:

# Run all tests
dotnet test

# Run specific test category
dotnet test --filter "FullyQualifiedName~Indicators"

# Run with coverage
dotnet test --collect:"XPlat Code Coverage"

Test Categories

• Indicator Tests - SMA, EMA, RSI, MACD, Bollinger Bands
• Order Tests - Order creation, validation, lifecycle
• Engine Tests - Matching engine, brokerage simulation
• Data Tests - Data loading, parsing, historical data

Roadmap

Phase 1-5 (Completed)

• Core project structure
• Order system implementation
• Data sources and market data
• Trading engine core
• Indicator library
• Comprehensive test suite (143 tests)

Phase 6 (In Progress)

• Example strategies
• Documentation
• API reference generation
• Advanced examples

Future Phases

• Live trading support
• Multiple broker integrations
• Web-based dashboard
• Machine learning indicators

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting PRs.

1. Fork the repository
2. Create a feature branch
3. Write tests for new features
4. Ensure all tests pass
5. Submit a pull request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• Inspired by QuantConnect/Lean
• Built with .NET 10 and modern C# practices
• Testing powered by xUnit and FluentAssertions

<div align="center">

ZenFlow - Empowering algorithmic forex trading

</div>