Automation, Without the Blow-Up.

1
# risk_gate.py — Pre-trade risk validation
2
# Rejects any trade that fails R:R, size, or daily-loss-limit checks
3
 
4
def pre_trade_risk_check(
5
    account_equity: float,
6
    entry_price: float,
7
    stop_price: float,
8
    target_price: float,
9
    proposed_size: float,
10
    daily_pnl: float,
11
    daily_loss_limit: float = -0.02,  # -2% account
12
    max_risk_per_trade: float = 0.02,  # 2% account
13
    min_rr_ratio: float = 2.0,
14
) -> tuple[bool, str]:
15
    """
16
    Returns (approved, reason). Raise before any order submission.
17
    """
18
    # 1. R:R check
19
    risk_per_unit = abs(entry_price - stop_price)
20
    reward_per_unit = abs(target_price - entry_price)
21
    if risk_per_unit == 0:
22
        return False, "Stop equals entry — invalid trade parameters"
23
 
24
    rr_ratio = reward_per_unit / risk_per_unit
25
    if rr_ratio < min_rr_ratio:
26
        return False, f"R:R {rr_ratio:.2f} below minimum {min_rr_ratio:.2f}"
27
 
28
    # 2. Position size check
29
    dollar_risk = proposed_size * risk_per_unit
30
    risk_pct = dollar_risk / account_equity
31
    if risk_pct > max_risk_per_trade:
32
        return False, f"Risk {risk_pct:.1%} exceeds max {max_risk_per_trade:.1%}"
33
 
34
    # 3. Daily loss limit check
35
    daily_pnl_pct = daily_pnl / account_equity
36
    if daily_pnl_pct <= daily_loss_limit:
37
        return False, f"Daily loss {daily_pnl_pct:.1%} hit limit — no new trades today"
38
 
39
    return True, "approved"
40
 
41
# Usage
42
approved, reason = pre_trade_risk_check(
43
    account_equity=50_000,
44
    entry_price=4_500.00,
45
    stop_price=4_493.50,
46
    target_price=4_517.00,
47
    proposed_size=2,
48
    daily_pnl=-450.00,
49
)
50
if not approved:
51
    raise RuntimeError(f"Trade rejected: {reason}")

1
// pine_alert.pine — Alert with structured JSON payload
2
// Run at bar close to avoid re-paints
3
 
4
//@version=5
5
strategy("Asymmetric Entry v1", overlay=true, calc_on_every_tick=false)
6
 
7
// — Inputs
8
rsi_len   = input.int(14, "RSI Length")
9
ema_fast  = input.int(9,  "Fast EMA")
10
ema_slow  = input.int(21, "Slow EMA")
11
risk_pct  = input.float(1.0, "Risk %", minval=0.1, maxval=5.0)
12
 
13
// — Indicators
14
rsi       = ta.rsi(close, rsi_len)
15
ema_f     = ta.ema(close, ema_fast)
16
ema_s     = ta.ema(close, ema_slow)
17
 
18
// — Entry conditions
19
long_cond  = ta.crossover(ema_f, ema_s) and rsi < 60
20
short_cond = ta.crossunder(ema_f, ema_s) and rsi > 40
21
 
22
// — Structured JSON payload for webhook receiver
23
if long_cond
24
    alert(
25
        str.format(
26
            "{"action":"buy","symbol":"{0}","price":{1}," +
27
            ""risk_pct":{2},"bar_time":"{3}"}",
28
            syminfo.ticker, close, risk_pct, str.tostring(time)
29
        ),
30
        alert.freq_once_per_bar_close  // no re-paints
31
    )
32
    strategy.entry("Long", strategy.long)
33
 
34
if short_cond
35
    alert(
36
        str.format(
37
            "{"action":"sell","symbol":"{0}","price":{1}," +
38
            ""risk_pct":{2},"bar_time":"{3}"}",
39
            syminfo.ticker, close, risk_pct, str.tostring(time)
40
        ),
41
        alert.freq_once_per_bar_close
42
    )
43
    strategy.entry("Short", strategy.short)

1
// webhook.js — Express webhook receiver with idempotency
2
// Deduplicates by client_order_id to prevent double-orders on retry
3
 
4
const express = require("express");
5
const crypto  = require("crypto");
6
const app     = express();
7
app.use(express.json());
8
 
9
// In-memory dedup cache (use Redis in production)
10
const processedIds = new Set();
11
 
12
app.post("/webhook/signal", async (req, res) => {
13
  const payload = req.body;
14
 
15
  // 1. Validate payload shape
16
  const { action, symbol, price, risk_pct } = payload;
17
  if (!action || !symbol || !price) {
18
    return res.status(400).json({ error: "invalid_payload" });
19
  }
20
 
21
  // 2. Generate deterministic idempotency key
22
  const raw = `${action}:${symbol}:${payload.bar_time}`;
23
  const client_order_id = crypto
24
    .createHash("sha256")
25
    .update(raw)
26
    .digest("hex")
27
    .slice(0, 24);
28
 
29
  // 3. Check for duplicate
30
  if (processedIds.has(client_order_id)) {
31
    console.log(`[dedup] Skipping duplicate signal: ${client_order_id}`);
32
    return res.json({ status: "duplicate", client_order_id });
33
  }
34
 
35
  processedIds.add(client_order_id);
36
 
37
  try {
38
    // 4. Submit order to broker (Alpaca example)
39
    const order = await submitOrder({
40
      symbol,
41
      side: action === "buy" ? "buy" : "sell",
42
      type: "limit",
43
      limit_price: price,
44
      qty: computeQty(risk_pct, price),
45
      client_order_id,
46
      time_in_force: "day",
47
    });
48
 
49
    console.log(`[order] Submitted ${action} ${symbol} → ${order.id}`);
50
    res.json({ status: "submitted", order_id: order.id, client_order_id });
51
  } catch (err) {
52
    // Remove from dedup cache on failure so retry can proceed
53
    processedIds.delete(client_order_id);
54
    console.error(`[error] Order submission failed: ${err.message}`);
55
    res.status(500).json({ error: "submission_failed", message: err.message });
56
  }
57
});
58
 
59
app.listen(3001, () => console.log("Webhook receiver listening on :3001"));

1
// CircuitBreaker.cs — NinjaScript kill switch + circuit breaker
2
// Stops new entries when daily P&L hits limit or kill switch is active
3
 
4
#region Using declarations
5
using System;
6
using NinjaTrader.Cbi;
7
using NinjaTrader.NinjaScript;
8
#endregion
9
 
10
namespace NinjaTrader.NinjaScript.Strategies
11
{
12
    public class AsymmetricStrategy : Strategy
13
    {
14
        private double dailyLossLimit = -500; // dollars
15
        private bool killSwitchActive = false;
16
 
17
        protected override void OnStateChange()
18
        {
19
            if (State == State.SetDefaults)
20
            {
21
                Name = "AsymmetricStrategy";
22
                Calculate = Calculate.OnBarClose;
23
            }
24
        }
25
 
26
        protected override void OnBarUpdate()
27
        {
28
            // Gate 1: Kill switch — set via UI or external trigger
29
            if (killSwitchActive)
30
            {
31
                Print("[KILL] Kill switch active — no new orders");
32
                return;
33
            }
34
 
35
            // Gate 2: Daily loss circuit breaker
36
            double todayPnL = GetDailyPnL();
37
            if (todayPnL <= dailyLossLimit)
38
            {
39
                Print($"[CIRCUIT] Daily P&L {todayPnL:F2} hit limit {dailyLossLimit:F2}");
40
                FlattenAll();
41
                killSwitchActive = true;
42
                return;
43
            }
44
 
45
            // Gate 3: Only trade in defined session hours
46
            if (Time[0].Hour < 9 || Time[0].Hour >= 16)
47
                return;
48
 
49
            // — Signal logic (simplified)
50
            double rsi = RSI(14, 3)[0];
51
            double ema9  = EMA(9)[0];
52
            double ema21 = EMA(21)[0];
53
 
54
            if (rsi < 40 && ema9 > ema21 && Position.MarketPosition == MarketPosition.Flat)
55
                EnterLongLimit(0, true, 1, Close[0] - 0.25, "LongEntry");
56
 
57
            if (rsi > 60 && ema9 < ema21 && Position.MarketPosition == MarketPosition.Flat)
58
                EnterShortLimit(0, true, 1, Close[0] + 0.25, "ShortEntry");
59
        }
60
 
61
        private double GetDailyPnL()
62
        {
63
            return Performance.AllTrades.TradesPerformance.GrossProfit
64
                 - Performance.AllTrades.TradesPerformance.GrossLoss;
65
        }
66
 
67
        private void FlattenAll()
68
        {
69
            if (Position.MarketPosition != MarketPosition.Flat)
70
            {
71
                Print("[FLATTEN] Closing all positions");
72
                ExitLong();
73
                ExitShort();
74
            }
75
        }
76
    }
77
}

1
# deadman.py — Flat-all if heartbeat absent > N seconds
2
# Run as a separate process alongside your main strategy
3
 
4
import time
5
import signal
6
import threading
7
from datetime import datetime
8
 
9
HEARTBEAT_FILE = "/tmp/strategy_heartbeat"
10
MAX_SILENCE_SECONDS = 60  # flat all if no heartbeat for 60s
11
CHECK_INTERVAL = 5        # poll every 5 seconds
12
 
13
def flat_all_positions(broker_client):
14
    """Close every open position. Implement for your broker."""
15
    print(f"[DEADMAN] {datetime.now().isoformat()} — Flattening all positions")
16
    positions = broker_client.get_all_positions()
17
    for position in positions:
18
        symbol = position.symbol
19
        qty    = abs(int(position.qty))
20
        side   = "sell" if float(position.qty) > 0 else "buy"
21
        broker_client.submit_order(
22
            symbol=symbol,
23
            qty=qty,
24
            side=side,
25
            type="market",
26
            time_in_force="day",
27
        )
28
        print(f"[DEADMAN] Closed {qty} {symbol} ({side})")
29
 
30
def deadman_monitor(broker_client):
31
    """Watch heartbeat file. If stale > MAX_SILENCE_SECONDS, flatten."""
32
    print(f"[DEADMAN] Monitor started — max silence: {MAX_SILENCE_SECONDS}s")
33
    while True:
34
        time.sleep(CHECK_INTERVAL)
35
        try:
36
            mtime = os.path.getmtime(HEARTBEAT_FILE)
37
            age   = time.time() - mtime
38
            if age > MAX_SILENCE_SECONDS:
39
                print(f"[DEADMAN] Heartbeat age {age:.0f}s — triggering flat-all")
40
                flat_all_positions(broker_client)
41
                # Keep monitoring — may need to re-flatten if positions reopen
42
        except FileNotFoundError:
43
            print("[DEADMAN] Heartbeat file missing — creating baseline")
44
            with open(HEARTBEAT_FILE, "w") as f:
45
                f.write(str(time.time()))
46
 
47
# In your main strategy loop, touch the heartbeat file each bar:
48
# with open(HEARTBEAT_FILE, "w") as f:
49
#     f.write(str(time.time()))

1
// RsiBracketBot.cs — cTrader cAlgo example
2
// Trade RSI extremes with bracketed stop / take-profit (in pips).
3
using cAlgo.API;
4
using cAlgo.API.Indicators;
5
 
6
namespace cAlgo.Robots
7
{
8
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
9
    public class RsiBracketBot : Robot
10
    {
11
        [Parameter("RSI Periods", DefaultValue = 14, MinValue = 2)]
12
        public int RsiPeriods { get; set; }
13
 
14
        [Parameter("Lots", DefaultValue = 0.10, MinValue = 0.01, Step = 0.01)]
15
        public double Lots { get; set; }
16
 
17
        [Parameter("Stop Loss (pips)", DefaultValue = 25)]
18
        public double StopLossPips { get; set; }
19
 
20
        [Parameter("Take Profit (pips)", DefaultValue = 50)]
21
        public double TakeProfitPips { get; set; }
22
 
23
        private RelativeStrengthIndex _rsi;
24
        private const string Label = "RsiBracketBot";
25
 
26
        protected override void OnStart()
27
        {
28
            _rsi = Indicators.RelativeStrengthIndex(Bars.ClosePrices, RsiPeriods);
29
        }
30
 
31
        protected override void OnBar()
32
        {
33
            // Skip if we already have a position with this label
34
            var open = Positions.FindAll(Label, SymbolName);
35
            if (open.Length > 0) return;
36
 
37
            var volume = Symbol.QuantityToVolumeInUnits(Lots);
38
            var prev   = _rsi.Result.Last(1);
39
 
40
            if (prev < 30)
41
                ExecuteMarketOrder(TradeType.Buy,  SymbolName, volume, Label,
42
                                   StopLossPips, TakeProfitPips);
43
            else if (prev > 70)
44
                ExecuteMarketOrder(TradeType.Sell, SymbolName, volume, Label,
45
                                   StopLossPips, TakeProfitPips);
46
        }
47
 
48
        protected override void OnStop()
49
        {
50
            // Optional: flatten on shutdown for safety
51
            foreach (var p in Positions.FindAll(Label, SymbolName))
52
                ClosePosition(p);
53
        }
54
    }
55
}

1
# ccxt_order.py — Spot + perp market order with proper error handling
2
# pip install ccxt
3
import os
4
import ccxt
5
 
6
VENUE       = os.environ["VENUE"]          # e.g. "bybit", "okx", "binance"
7
API_KEY     = os.environ["API_KEY"]
8
API_SECRET  = os.environ["API_SECRET"]
9
PASSPHRASE  = os.environ.get("API_PASSPHRASE")  # required for OKX, Coinbase
10
 
11
exchange_cls = getattr(ccxt, VENUE)
12
exchange = exchange_cls({
13
    "apiKey":   API_KEY,
14
    "secret":   API_SECRET,
15
    "password": PASSPHRASE,
16
    "enableRateLimit": True,        # CCXT will sleep to respect venue limits
17
    "options": {"defaultType": "spot"},
18
})
19
 
20
def place_spot_buy(symbol: str, quote_amount: float):
21
    """Market-buy 'quote_amount' of the quote currency (e.g. 100 USDT of BTC)."""
22
    try:
23
        bal = exchange.fetch_balance()
24
        free_quote = bal["free"].get(symbol.split("/")[1], 0)
25
        if free_quote < quote_amount:
26
            raise RuntimeError(f"Insufficient quote balance: {free_quote}")
27
 
28
        # 'createMarketBuyOrderRequiresPrice' is False on most venues when
29
        # passing cost via params; check venue docs.
30
        order = exchange.create_market_buy_order(
31
            symbol, amount=None,
32
            params={"cost": quote_amount},
33
        )
34
        return order
35
    except ccxt.RateLimitExceeded as e:
36
        # Back off and retry from caller
37
        raise
38
    except ccxt.InsufficientFunds as e:
39
        raise RuntimeError(f"Exchange rejected order: {e}")
40
 
41
def place_perp_long(symbol: str, contracts: float, leverage: int = 3):
42
    """Open a long perpetual position with isolated margin."""
43
    perp = exchange_cls({
44
        "apiKey": API_KEY, "secret": API_SECRET, "password": PASSPHRASE,
45
        "enableRateLimit": True,
46
        "options": {"defaultType": "swap"},   # perpetual futures
47
    })
48
    perp.set_leverage(leverage, symbol, params={"marginMode": "isolated"})
49
    return perp.create_market_buy_order(symbol, contracts)
50
 
51
if __name__ == "__main__":
52
    print(place_spot_buy("BTC/USDT", 100.0))
53
    # print(place_perp_long("BTC/USDT:USDT", 0.001, leverage=3))

1
# tradovate_order.py — Auth + place market order on Tradovate REST
2
# Tradovate uses an access-token flow. Tokens expire — refresh on 401.
3
import os
4
import time
5
import requests
6
from websocket import WebSocketApp  # pip install websocket-client
7
 
8
BASE = "https://demo.tradovateapi.com/v1"   # live: https://live.tradovateapi.com/v1
9
WS   = "wss://demo.tradovateapi.com/v1/websocket"
10
 
11
def get_access_token() -> str:
12
    payload = {
13
        "name":       os.environ["TRADOVATE_USERNAME"],
14
        "password":   os.environ["TRADOVATE_PASSWORD"],
15
        "appId":      os.environ["TRADOVATE_APP_ID"],
16
        "appVersion": "1.0",
17
        "cid":        os.environ["TRADOVATE_CID"],
18
        "sec":        os.environ["TRADOVATE_SECRET"],
19
    }
20
    r = requests.post(f"{BASE}/auth/accesstokenrequest", json=payload, timeout=10)
21
    r.raise_for_status()
22
    body = r.json()
23
    if "accessToken" not in body:
24
        raise RuntimeError(f"Auth failed: {body}")
25
    return body["accessToken"]
26
 
27
def place_market_order(token: str, account_id: int, symbol: str, qty: int, action: str = "Buy"):
28
    """action: 'Buy' or 'Sell'. symbol e.g. 'MESM5' (Micro E-mini June '25)."""
29
    headers = {"Authorization": f"Bearer {token}"}
30
    body = {
31
        "accountSpec": os.environ["TRADOVATE_USERNAME"],
32
        "accountId":   account_id,
33
        "action":      action,
34
        "symbol":      symbol,
35
        "orderQty":    qty,
36
        "orderType":   "Market",
37
        "isAutomated": True,
38
    }
39
    r = requests.post(f"{BASE}/order/placeorder", json=body, headers=headers, timeout=10)
40
    if r.status_code == 401:
41
        raise PermissionError("Token expired — re-auth and retry")
42
    r.raise_for_status()
43
    return r.json()
44
 
45
def stream_fills(token: str, on_fill):
46
    """Reconnect-on-drop fill stream. Caller passes a callback(message_dict)."""
47
    def _on_open(ws):
48
        ws.send(f"authorize\n1\n\n{token}")
49
    def _on_message(ws, msg):
50
        on_fill(msg)
51
    def _on_close(ws, code, reason):
52
        print(f"[WS] closed {code} {reason} — reconnecting in 3s")
53
        time.sleep(3)
54
        stream_fills(token, on_fill)   # tail-call reconnect
55
    WebSocketApp(WS, on_open=_on_open, on_message=_on_message, on_close=_on_close).run_forever()
56
 
57
if __name__ == "__main__":
58
    tok = get_access_token()
59
    print(place_market_order(tok, account_id=int(os.environ["TRADOVATE_ACCOUNT_ID"]),
60
                             symbol="MESM5", qty=1, action="Buy"))