High-throughput systematic quantitative trading SaaS with sub-100ms Redis Streams execution, vectorized backtesting studio, and bank-grade AES-256 Demat key vault.
🌐 Live Production Application: https://sirus-opal.vercel.app
SIRUS is an institutional-grade, multi-tenant quantitative trading platform and algorithmic backtesting engine built for systematic hedge funds, proprietary desks, and quantitative traders. Traditional retail setups rely on brittle webhook bots or monolithic desktop programs that lack pre-trade risk controls, multi-broker connectivity, and hardware-grade credential security. SIRUS unifies equities Direct Market Access (Zerodha Kite Connect, Alpaca Markets, Interactive Brokers, Upstox, AngelOne) and cryptocurrency derivatives (KuCoin, Binance) into a single asynchronous event-driven architecture. Powered by sub-100ms Redis Streams messaging, a 540,000 ticks/sec vectorized NumPy/Pandas simulation engine, automated circuit breakers, and AES-256-GCM envelope-encrypted Demat credential storage, SIRUS delivers institutional execution speed and rigorous risk management within a dark-mode Paddle-inspired visual interface.
| Feature | Description |
|---|---|
| Direct Market Access (DMA) Routing | Sub-millisecond order dispatch with smart order routing (SOR) across Equities (NSE/BSE, US markets) and Crypto spot/perpetuals. |
| Vectorized Backtesting Studio | Executes multi-year backtests over historical OHLCV hypertables at 540,000 ticks/sec with Sharpe ratio, Sortino, and maximum drawdown metrics. |
| Monte Carlo Walk-Forward Simulator | Validates strategy resilience with 10,000+ iteration stochastic equity curve projections, parameter stress testing, and out-of-sample decay analysis. |
| Pre-Trade Risk Engine & Guards | Enforces atomic margin verification, dynamic ATR trailing stops, position concentration caps, and tenant-isolated risk envelopes before order dispatch. |
| Hardware-Grade Demat Credential Vault | AES-256-GCM envelope encryption protecting broker API keys, Kite Demat tokens, and exchange secrets with tenant key derivation. |
| Sub-100ms Redis Streams Event Bus | Low-latency asynchronous messaging pipeline distributing tick data, signal triggers, order execution events, and position updates. |
| TimescaleDB Financial Hypertables | High-throughput time-series persistence partitioning millions of order fills, candles, and real-time tick telemetry. |
| Idempotent OMS/EMS Executor | Guarantees exactly-once execution semantics with unique client idempotency keys, eliminating duplicate order dispatches during network retries. |
| Real-Time WebSocket Ticker Pipeline | Streams live bid/ask quotes, order book depth, and strategy performance updates directly to client web dashboards. |
| Paddle-Themed Dark Mode UI | High-contrast dark dashboard (#0f1515) with Inter typography, Three.js 3D depth, ambient glassmorphism, and responsive financial charts. |
- Execute Across Multi-Broker Adapters: Dispatches orders simultaneously to Alpaca (US Equities), Zerodha Kite Connect (NSE/BSE), and KuCoin (Crypto Spot/Perps).
- Run Sub-100ms Historical Backtests: Evaluates Moving Average Crossover, RSI Mean Reversion, and Donchian Breakout strategies across years of 1m tick data.
- Enforce Automated Circuit Breakers: Halts trading and liquidates risky positions when daily drawdown breaches the 5% threshold or volatility spikes.
- Secure Broker Demat API Keys: Stores and derives exchange credentials through AES-256-GCM envelope encryption with master key derivation.
- Stream Live Market Tickers: Ingests real-time WebSocket feeds from brokerages and broadcasts normalised tick events over
/ws/v1/market-data. - Guarantee Exactly-Once Order Execution: Employs distributed Redis locks and client-side idempotency keys to eliminate double-spend order placement.
- Render Real-Time Equity Curves: Displays live mark-to-market portfolio value, win rates, and profit factors with sub-second dashboard refreshes.
| Dimension | Retail Webhook Bots (TradingView, MetaTrader) | Institutional Desks (Bloomberg, Fidessa) | Custom Python Scripts | SIRUS (This Platform) |
|---|---|---|---|---|
| Execution Latency | 500ms – 3000ms over HTTP webhooks; severe slippage during volatility. | Ultra-low latency, but locked to proprietary hardware and private lines. | Unpredictable; bottlenecked by Python GIL and synchronous HTTP requests. | Sub-100ms asynchronous order routing via Redis Streams and non-blocking FastAPI. |
| Credential Security | Plaintext API keys stored in local config files or vulnerable databases. | Proprietary smartcards and internal network security appliances. | Hardcoded .env secrets committed to private repositories. |
Bank-grade AES-256-GCM envelope encryption with isolated Demat key vault. |
| Pre-Trade Risk Controls | Post-trade notifications; no atomic balance or concentration checks before order. | Sophisticated, but requires dedicated risk compliance staff to configure. | None; scripts execute blind orders until brokerage rejects margin. | Automated pre-trade risk engine with drawdown circuit breakers and concentration caps. |
| Cross-Asset Flexibility | Locked to specific asset classes (Forex only or Crypto only). | Segmented into separate expensive terminals for equities, FX, and derivatives. | Requires bespoke adapter scripts for each exchange API. | Unified multi-broker execution across Indian Demat (NSE/BSE), US Equities, and Crypto. |
| Simulation & Validation | Simple bar backtesting with lookahead bias and unrealistic fills. | Enterprise Monte Carlo tools costing $25k+/year per terminal license. | Slow loops iterating bar-by-bar over Pandas DataFrames. | 540,000 ticks/sec vectorized backtester with 10,000+ iteration Monte Carlo simulator. |
- Node.js: 18.x or 20.x LTS & npm
- Python: 3.11+
- Docker Engine: v24.0+ & Docker Compose: v2.20+
- PostgreSQL: 16 with TimescaleDB extension
- Redis: 7+ with Streams support
git clone https://github.com/arnnnnaaavvvvv/SIRUS.git
cd SIRUS
# Configure environment variables
cp .env.example .env
# Create Python virtual environment
python -m venv venv
# On Windows:
.\venv\Scripts\activate
# On Linux/macOS:
source venv/bin/activate
# Install dependencies across packages
pip install -r requirements.txtcd apps/web-frontend
npm install
npm run devOpen http://localhost:3000 in your browser.
Launch the entire containerized microservices stack (PostgreSQL + TimescaleDB, Redis Streams, API Gateway, Order Executor, Market Data Ingestor) with Docker Compose:
# Build and spin up all microservices
docker compose up --build -d
# Verify system health
curl -s http://localhost:8000/health | jq .{
"status": "healthy",
"service": "SIRUS — High-Throughput Quantitative Trading Core",
"version": "1.0.0",
"components": {
"api_gateway": "ONLINE",
"order_executor": "ONLINE",
"market_data_service": "ONLINE",
"redis_streams": "CONNECTED",
"timescaledb": "CONNECTED"
},
"supported_brokers": ["ALPACA", "ZERODHA_KITE", "KUCOIN", "INTERACTIVE_BROKERS"],
"active_circuit_breakers": 0
}{
"strategy_type": "MA_CROSSOVER",
"symbol": "BTC-USDT",
"timeframe": "1m",
"start_date": "2026-08-01T00:00:00Z",
"end_date": "2026-08-07T00:00:00Z",
"initial_capital": 10000,
"parameters": {
"short_window": 9,
"long_window": 21
}
}{
"total_trades": 14,
"winning_trades": 9,
"losing_trades": 5,
"win_rate": 64.29,
"total_pnl": 1420.50,
"return_pct": 14.21,
"max_drawdown_pct": 3.82,
"sharpe_ratio": 2.15,
"profit_factor": 1.84,
"trades": [
{
"entry_time": "2026-08-01T04:12:00Z",
"exit_time": "2026-08-01T07:45:00Z",
"side": "BUY",
"entry_price": 64200.00,
"exit_price": 64850.00,
"pnl": 650.00,
"return_pct": 1.01
}
],
"equity_curve": [
{"timestamp": "2026-08-01T00:00:00Z", "equity": 10000.00},
{"timestamp": "2026-08-07T00:00:00Z", "equity": 11420.50}
]
}curl -X POST "http://localhost:8000/api/v1/credentials" \
-H "Authorization: Bearer <Firebase_Token>" \
-H "Content-Type: application/json" \
-d '{
"broker_name": "alpaca",
"environment": "paper",
"api_key": "PK_TEST_KEY_12345",
"api_secret": "SECRET_TEST_98765",
"passphrase": null
}'curl -X POST "http://localhost:8000/api/v1/strategies" \
-H "Authorization: Bearer <Firebase_Token>" \
-H "Content-Type: application/json" \
-d '{
"name": "BTC Momentum Breakout",
"strategy_type": "MOMENTUM_BREAKOUT",
"symbol": "BTC-USDT",
"timeframe": "1m",
"broker_name": "kucoin",
"parameters": {
"lookback_period": 20
},
"risk_profile": {
"max_position_size": 5000,
"stop_loss_pct": 0.02,
"take_profit_pct": 0.05,
"max_daily_drawdown_pct": 0.05,
"max_user_exposure": 25000
}
}'curl -X POST "http://localhost:8000/api/v1/orders" \
-H "Authorization: Bearer <Firebase_Token>" \
-H "Content-Type: application/json" \
-d '{
"symbol": "AAPL",
"side": "buy",
"order_type": "limit",
"quantity": 50,
"limit_price": 180.50,
"time_in_force": "gtc",
"broker_name": "alpaca",
"idempotency_key": "ord_client_uuid_12345"
}'wscat -c "wss://localhost:8000/ws/v1/market-data?token=<Firebase_Token>"All system parameters can be set via environment variables or a root .env file:
| Variable | Default | Description |
|---|---|---|
DATABASE_URL |
postgresql+asyncpg://sirus:sirus@localhost:5432/sirus_db |
Async connection string for PostgreSQL and TimescaleDB. |
REDIS_URL |
redis://localhost:6379/0 |
Low-latency Redis instance for Streams and distributed locks. |
VAULT_MASTER_KEY_HEX |
None |
256-bit hexadecimal master key for AES-256-GCM Demat credential encryption. |
FIREBASE_PROJECT_ID |
sirus-auth-prod |
Firebase project identifier for JWT ID token verification. |
MAX_DAILY_DRAWDOWN_PCT |
0.05 |
System-wide maximum daily portfolio drawdown threshold (5%). |
DEFAULT_ORDER_TIMEOUT_MS |
5000 |
Gateway execution timeout for broker DMA order acknowledgement. |
RATE_LIMIT_PER_MINUTE |
120 |
Per-tenant rate limit ceiling on REST API calls. |
TICK_BUFFER_CAPACITY |
100000 |
In-memory Redis stream ring-buffer capacity for market ticks. |
The following diagram illustrates SIRUS's end-to-end architecture across client dashboards, edge authentication, broker DMA adapters, the Redis Streams execution backbone, and TimescaleDB hypertables.
Figure 1: High-level architectural flowchart of the SIRUS quantitative trading platform.
flowchart TD
classDef highlight fill:#DC382D,stroke:#991B1B,stroke-width:2px,color:#ffffff;
classDef standard fill:#1e293b,stroke:#475569,stroke-width:1px,color:#f8fafc;
CLIENT[Client Tier<br/>Next.js 14 Dark Dashboard / Three.js]:::standard
EDGE[Edge Gateway & Auth<br/>FastAPI Orchestrator / Firebase Auth]:::standard
subgraph BrokerAdapters["Direct Market Access (DMA) Adapters"]
ALPACA[Alpaca Markets Adapter<br/>US Equities DMA]:::standard
ZERODHA[Zerodha Kite Adapter<br/>NSE / BSE Demat]:::standard
KUCOIN[KuCoin Exchange Adapter<br/>Crypto Spot & Perps]:::standard
IBKR[Interactive Brokers Adapter<br/>Global Equities & Options]:::standard
end
subgraph ExecutionCore["Execution & Risk Backbone"]
REDIS_BUS[("Redis Streams Event Bus<br/>Low-Latency Tick & Order Buffer")]:::highlight
MARKET_INGEST[Market Data Ingestor<br/>WebSocket Stream Consumer]:::standard
STRATEGY_AST[Strategy Studio & AST Engine<br/>Vectorized Signal Generator]:::standard
RISK_ENGINE[Pre-Trade Risk Engine<br/>Drawdown & Concentration Guard]:::highlight
ORDER_EXEC[Idempotent OMS Executor<br/>Sub-100ms Broker Dispatcher]:::highlight
end
subgraph Persistence["High-Frequency Persistence Tier"]
PG[(PostgreSQL 16<br/>Tenants, Vault Keys, Accounts)]:::standard
TIMESCALE[(TimescaleDB Hypertables<br/>Ticks, Candles & Order Fills)]:::standard
end
CLIENT -->|HTTPS / WSS| EDGE
EDGE --> PG
ALPACA & ZERODHA & KUCOIN & IBKR -->|Live Tickers| MARKET_INGEST
MARKET_INGEST --> REDIS_BUS
MARKET_INGEST --> TIMESCALE
REDIS_BUS --> STRATEGY_AST
STRATEGY_AST --> RISK_ENGINE
RISK_ENGINE --> ORDER_EXEC
ORDER_EXEC -->|Idempotent Order Fill| ALPACA & ZERODHA & KUCOIN & IBKR
ORDER_EXEC --> PG
ORDER_EXEC --> TIMESCALE
ORDER_EXEC -.->|Execution Event| REDIS_BUS
REDIS_BUS -.->|Fill Telemetry| CLIENT
The following sequence diagram outlines the end-to-end order lifecycle: from algorithmic signal generation, atomic pre-trade risk verification, to DMA broker routing, state persistence, and client broadcast.
Figure 2: Primary end-to-end order execution lifecycle and fill event telemetry sequence.
sequenceDiagram
autonumber
actor Trader as Algorithmic Trader / Web UI
participant GW as FastAPI Gateway
participant Bus as Redis Streams Bus
participant Risk as Pre-Trade Risk Engine
participant Vault as AES-256 Demat Vault
participant OMS as Order Executor (OMS)
participant Broker as Broker DMA (Zerodha / Alpaca)
participant DB as TimescaleDB / Postgres
Trader->>GW: POST /api/v1/orders (Symbol, Side, Qty, IdempotencyKey)
GW->>GW: Verify Firebase JWT & Check Idempotency Key
GW->>Bus: Publish ORDER_REQUEST to Redis Stream
Bus->>Risk: Consume ORDER_REQUEST
Risk->>Risk: Check Margin, Max Exposure & Daily Drawdown (< 5%)
alt Risk Limits Breached
Risk-->>Bus: Publish ORDER_REJECTED (Reason: MARGIN_EXCEEDED)
Bus-->>Trader: WebSocket Broadcast: Order Rejected
else Risk Checks Passed
Risk->>OMS: Dispatch Validated Order Payload
OMS->>Vault: Retrieve & Decrypt Demat Broker Token (AES-256)
Vault-->>OMS: Ephemeral Decrypted API Secret
OMS->>Broker: Submit DMA Order Payload (REST / FIX)
Broker-->>OMS: 200 OK (Broker Order ID: ord_98765)
OMS->>DB: Persist Execution Record in TimescaleDB
OMS->>Bus: Publish ORDER_FILLED Event
Bus-->>Trader: WebSocket Broadcast: Order Executed
end
The following Raptor-style decision flowchart illustrates how SIRUS screens incoming orders, evaluates account health against risk limits, and trips automated circuit breakers during volatile market swings.
Figure 3: Raptor-style deterministic decision flowchart for pre-trade risk gating and circuit breakers.
flowchart TD
classDef highlight fill:#DC382D,stroke:#991B1B,stroke-width:2px,color:#ffffff;
classDef standard fill:#1e293b,stroke:#475569,stroke-width:1px,color:#f8fafc;
classDef terminal fill:#f43f5e,stroke:#e11d48,stroke-width:2px,color:#ffffff;
classDef pass fill:#10b981,stroke:#059669,stroke-width:2px,color:#ffffff;
START([Order Execution Signal Ingested]):::standard
BROKER_CHECK{Broker Adapter<br/>Online & Active?}:::standard
REJECT_OFFLINE[Reject: Broker Gateway Offline]:::terminal
AUTH_CHECK{Demat HSM Key<br/>Signature Valid?}:::standard
REJECT_AUTH[Reject: Invalid Broker Credentials]:::terminal
MARGIN_CHECK{Tenant Margin Balance<br/>>= Required Margin?}:::standard
REJECT_MARGIN[Reject: Margin Limit Exceeded]:::terminal
EXPOSURE_CHECK{Total Symbol Exposure<br/><= Risk Profile Cap?}:::standard
REJECT_EXPOSURE[Reject: Position Concentration Exceeded]:::terminal
DRAWDOWN_CHECK{Tenant Daily Drawdown<br/>>= Max Drawdown Limit 5%?}:::standard
TRIP_BREAKER[TRIP CIRCUIT BREAKER<br/>Halt All Trading & Flatten Positions]:::highlight
VOLATILITY_CHECK{Market Volatility Spike<br/>ATR > 3.0 Standard Deviations?}:::standard
REJECT_VOLATILITY[Reject: Volatility Circuit Active]:::terminal
DISPATCH_ORDER[Dispatch to Direct Market Access API<br/>Execute Idempotent Order Placement]:::highlight
PERSIST_FILL[Record Order Execution in TimescaleDB<br/>Broadcast Real-Time Fill Event]:::pass
START --> BROKER_CHECK
BROKER_CHECK -- No --> REJECT_OFFLINE
BROKER_CHECK -- Yes --> AUTH_CHECK
AUTH_CHECK -- No --> REJECT_AUTH
AUTH_CHECK -- Yes --> MARGIN_CHECK
MARGIN_CHECK -- No --> REJECT_MARGIN
MARGIN_CHECK -- Yes --> EXPOSURE_CHECK
EXPOSURE_CHECK -- No --> REJECT_EXPOSURE
EXPOSURE_CHECK -- Yes --> DRAWDOWN_CHECK
DRAWDOWN_CHECK -- Yes --> TRIP_BREAKER
DRAWDOWN_CHECK -- No --> VOLATILITY_CHECK
VOLATILITY_CHECK -- Yes --> REJECT_VOLATILITY
VOLATILITY_CHECK -- No --> DISPATCH_ORDER
DISPATCH_ORDER --> PERSIST_FILL
The relational and time-series schema manages multi-tenant users, encrypted Demat credentials, strategies, risk envelopes, orders, and market tick hypertables.
Figure 4: Entity-Relationship diagram illustrating core database models and hypertables.
erDiagram
TENANT_USERS ||--o{ BROKER_CREDENTIALS : configures
TENANT_USERS ||--o{ STRATEGIES : deploys
STRATEGIES ||--o{ ORDERS : triggers
ORDERS ||--o{ EXECUTIONS : generates
TENANT_USERS ||--o{ RISK_PROFILES : defines
STRATEGIES ||--o{ BACKTEST_RUNS : evaluates
BROKER_CREDENTIALS ||--o{ ORDERS : executes_through
TENANT_USERS {
uuid id PK
string firebase_uid
string email
string role
string status
timestamp created_at
}
BROKER_CREDENTIALS {
uuid id PK
uuid user_id FK
string broker_name
string environment
text encrypted_api_key
text encrypted_api_secret
int key_version
boolean is_active
}
RISK_PROFILES {
uuid id PK
uuid user_id FK
decimal max_position_size
decimal stop_loss_pct
decimal take_profit_pct
decimal max_daily_drawdown_pct
decimal max_user_exposure
}
STRATEGIES {
uuid id PK
uuid user_id FK
string name
string strategy_type
string symbol
string timeframe
jsonb parameters
boolean is_running
}
ORDERS {
uuid id PK
uuid strategy_id FK
uuid credential_id FK
string symbol
string side
string order_type
decimal quantity
decimal limit_price
string idempotency_key
string status
timestamp submitted_at
}
EXECUTIONS {
uuid id PK
uuid order_id FK
string broker_order_id
decimal executed_price
decimal executed_quantity
decimal fee_amount
timestamp executed_at
}
BACKTEST_RUNS {
uuid id PK
uuid strategy_id FK
decimal initial_capital
decimal total_pnl
decimal return_pct
decimal max_drawdown_pct
decimal sharpe_ratio
int total_trades
timestamp completed_at
}
SIRUS separates quantitative signal processing into three high-performance stages:
- Vectorized Array Operations: Backtesting and indicator synthesis (Moving Average Crossovers, RSI, Bollinger Bands) are implemented using contiguous memory buffers in NumPy/Pandas, evaluating over 540,000 candles per second without Python row-loop overhead.
-
Dynamic Volatility & ATR Stops: Position stop-losses adapt dynamically to market volatility using Average True Range (ATR):
$$\text{Stop Loss} = \text{Entry Price} \pm (k \times \text{ATR}_{14})$$ where$k$ dynamically scales based on intraday market regime classification. - Stochastic Monte Carlo Projection: Strategy robustness is validated by sampling 10,000 synthetic return trajectories using randomized order reshuffling and historical volatility bootstrapping to calculate 99% Value at Risk (VaR).
Figure 5: Input signals converging into the pre-trade execution and risk decision.
flowchart LR
classDef highlight fill:#DC382D,stroke:#991B1B,stroke-width:2px,color:#ffffff;
classDef standard fill:#1e293b,stroke:#475569,stroke-width:1px,color:#f8fafc;
TICKS[Market Tick Stream<br/>Bid/Ask Quotes]:::standard
AST[Strategy Signal Generator<br/>Vectorized Indicators]:::standard
RISK[Pre-Trade Risk Envelope<br/>Margin & Drawdown Limit]:::standard
VAULT[AES-256 Demat Key Vault<br/>Encrypted Credentials]:::standard
CORE[OMS Execution Engine<br/>FastAPI & Redis Streams]:::highlight
OUTPUT[Direct Market Access Order<br/>Alpaca / Zerodha / KuCoin Fill]:::standard
TICKS --> CORE
AST --> CORE
RISK --> CORE
VAULT --> CORE
CORE --> OUTPUT
| Error Code | HTTP Status | Description | Remediation |
|---|---|---|---|
UNAUTHORIZED |
401 Unauthorized |
Invalid, expired, or revoked Firebase Bearer ID token. | Re-authenticate client and acquire fresh Firebase token. |
USER_DISABLED |
403 Forbidden |
Tenant account administratively locked due to risk limit violations. | Contact platform administrator or risk desk to unlock account. |
IDEMPOTENCY_CONFLICT |
409 Conflict |
Order placement request with identical idempotency key is already in flight. | Wait for existing order confirmation or submit with new unique UUID. |
MARGIN_LIMIT_EXCEEDED |
400 Bad Request |
Required margin for order size exceeds available account purchasing power. | Reduce order quantity or allocate additional margin capital. |
CIRCUIT_BREAKER_ACTIVE |
423 Locked |
Trading halted because tenant breached the 5% daily drawdown threshold. | Wait for next trading day reset or manually re-authorize via risk desk. |
RATE_LIMIT_EXCEEDED |
429 Too Many Requests |
Exceeded tenant quota of 120 requests per minute. | Implement client-side exponential backoff before retrying. |
BROKER_API_TIMEOUT |
504 Gateway Timeout |
Brokerage DMA gateway did not acknowledge order within 5000ms. | Order state enters reconciliation loop; inspect /api/v1/orders/{id}. |
Run unit, integration, and quantitative strategy validation test suites:
# Run comprehensive test suite
pytest tests/ -v
# Run Pre-Trade Risk Engine & Drawdown Guard Tests
pytest tests/test_risk_core.py -v
# Run AES-256 Demat Vault Encryption Tests
pytest tests/test_vault_security.py -v
# Run Vectorized Backtest Accuracy Tests
pytest tests/test_backtest_studio.py -v
# Run Web Frontend Type-Check & Build
cd apps/web-frontend && npm run build- Sub-Millisecond Execution: In high-frequency and quantitative trading, execution latency directly drives alpha decay. Asynchronous event routing and non-blocking I/O minimize slippage.
- Deterministic Risk Guardrails: An algorithmic error must never wipe out an account. Pre-trade margin validation, position caps, and automated drawdown circuit breakers are non-bypassable.
- Envelope Demat Credential Security: User exchange keys are treated with bank-grade security. Secrets are stored using AES-256-GCM envelope encryption and never logged in plaintext.
- Zero-Dependency Dashboards: Financial analytics and 3D dashboards render natively in modern browsers with crisp WebGL visualizations and responsive dark mode themes.
- Multi-Leg Options Greeks Engine: Real-time Delta, Gamma, Theta, and Vega risk calculation for options strategies.
- FIX Protocol Adapter: Direct connectivity to institutional brokerages and prime desks via Financial Information eXchange protocol.
- Machine Learning Alpha Factor Studio: Automated factor selection and rolling feature importance optimization.
- Multi-Broker Smart Order Routing (SOR): Split-fill order execution optimizing across multiple exchange order books.
- Arnav Singh (@arnnnnaaavvvvv) — Lead Architect & Maintainer
- SIRUS Quantitative Engineering Team
This project is licensed under the MIT License — see the LICENSE file for details.