FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
#include "trading/PaperTradingSelftest.h"
#include "trading/PaperTrading.h"
#include "trading/TradingTypes.h"
#include <QString>
#include <cmath>
#include <cstdio>
#include <optional>
namespace fincept::trading {
namespace {
// Find an open position by exact symbol (selftest symbols are unambiguous).
std::optional<PtPosition> position_for(const QString& portfolio_id, const QString& symbol) {
for (const auto& p : pt_get_positions(portfolio_id))
if (p.symbol == symbol)
return p;
return std::nullopt;
}
bool approx(double a, double b, double eps = 0.01) {
return std::fabs(a - b) <= eps;
}
} // namespace
int run_paper_trading_selftest() {
int failures = 0;
auto check = [&](const char* label, bool ok) {
std::printf("[%s] %s\n", ok ? "PASS" : "FAIL", label);
if (!ok)
++failures;
};
// Throwaway portfolio. fee_rate = 0 so realized/unrealized P&L is exact and
// assertable; INR + NFO so the option-leverage and instrument-type paths run.
const QString name = QStringLiteral("__selftest_paper__");
const QString pf_exchange = QStringLiteral("NFO");
if (auto existing = pt_find_portfolio(name, pf_exchange))
pt_delete_portfolio(existing->id);
PtPortfolio pf = pt_create_portfolio(name, /*balance=*/1'000'000.0, /*currency=*/QStringLiteral("INR"),
/*leverage=*/1.0, /*margin_mode=*/QStringLiteral("cross"),
/*fee_rate=*/0.0, /*exchange=*/pf_exchange);
const QString pid = pf.id;
// Place a market order and fill it immediately at `px` (the path every screen
// uses for a market order: place -> fill).
auto open_market = [&](const QString& sym, const QString& side, double qty, double px, const QString& product,
const QString& exchange) {
auto o = pt_place_order(pid, sym, side, QStringLiteral("market"), qty, px, std::nullopt,
/*reduce_only=*/false, exchange, product);
pt_fill_order(o.id, px);
};
const QString NSE = QStringLiteral("NSE");
const QString NFO = QStringLiteral("NFO");
// ── 1. Long equity marks to market with the right sign + magnitude ──────
{
const QString sym = QStringLiteral("RELIANCE");
open_market(sym, QStringLiteral("buy"), 10, 100.0, QStringLiteral("MIS"), NSE);
pt_update_position_price(pid, sym, 110.0);
auto p = position_for(pid, sym);
check("long: position opened", p.has_value());
check("long: side == long", p && p->side.compare(QStringLiteral("long"), Qt::CaseInsensitive) == 0);
check("long: unrealized P&L = +100 at 110", p && approx(p->unrealized_pnl, 100.0));
open_market(sym, QStringLiteral("sell"), 10, 110.0, QStringLiteral("MIS"), NSE);
check("long: exits on opposite fill", !position_for(pid, sym).has_value());
}
// ── 2. Short option opens flat (P&L 0 at entry) ─────────────────────────
const QString opt = QStringLiteral("NIFTY24DEC2450000CE");
{
open_market(opt, QStringLiteral("sell"), 50, 200.0, QStringLiteral("NRML"), NFO);
auto p = position_for(pid, opt);
check("short: position opened as short",
p && p->side.compare(QStringLiteral("short"), Qt::CaseInsensitive) == 0);
check("short: unrealized P&L ~0 at entry", p && approx(p->unrealized_pnl, 0.0));
}
// ── 3. THE PHANTOM-PROFIT BUG: a zero/garbage tick on a short must NOT ───
// book the full premium (entry*qty) as profit. This is exactly what the
// user saw: "square up shows total trade value in profit". Pre-fix the
// engine writes unrealized = (200 - 0)*50 = +10000; post-fix the 0 tick
// is ignored and P&L holds at its last good value (~0 here).
{
pt_update_position_price(pid, opt, 0.0);
auto p = position_for(pid, opt);
check("zero-tick: P&L is NOT the full premium (+10000)", p && !approx(p->unrealized_pnl, 10000.0, 1.0));
check("zero-tick: P&L holds at last good value (~0)", p && approx(p->unrealized_pnl, 0.0));
// A real tick still marks correctly: short 50 @ 200, now 150 -> +2500.
pt_update_position_price(pid, opt, 150.0);
p = position_for(pid, opt);
check("short: unrealized P&L = +2500 at 150", p && approx(p->unrealized_pnl, 2500.0));
}
// ── 4. Square-off a short: it actually exits AND books the right realized ──
{
// Close the short (50 @ 200, marked 150) with a buy 50 @ 150.
open_market(opt, QStringLiteral("buy"), 50, 150.0, QStringLiteral("NRML"), NFO);
check("square-off: short position exited", !position_for(pid, opt).has_value());
bool booked = false;
for (const auto& t : pt_get_trades(pid))
if (t.symbol == opt && t.side.compare(QStringLiteral("buy"), Qt::CaseInsensitive) == 0 &&
approx(t.pnl, 2500.0))
booked = true;
check("square-off: realized P&L = +2500 recorded", booked);
}
// ── 5. Netting: an equal opposite fill closes out, never leaves a phantom ──
// reverse position (the failure mode behind "doesn't exit").
{
const QString sym = QStringLiteral("TCS");
open_market(sym, QStringLiteral("buy"), 5, 1000.0, QStringLiteral("MIS"), NSE);
open_market(sym, QStringLiteral("sell"), 5, 1100.0, QStringLiteral("MIS"), NSE);
check("netting: flat after equal opposite fill", !position_for(pid, sym).has_value());
}
// ── 6. Multi-leg (builder-style) strategy: every leg actually fills ─────
{
const QString pe = QStringLiteral("NIFTY24DEC2449000PE");
const QString ce = QStringLiteral("NIFTY24DEC2451000CE");
open_market(pe, QStringLiteral("buy"), 50, 120.0, QStringLiteral("NRML"), NFO);
open_market(ce, QStringLiteral("sell"), 50, 90.0, QStringLiteral("NRML"), NFO);
check("multi-leg: both legs opened as positions",
position_for(pid, pe).has_value() && position_for(pid, ce).has_value());
}
// ── 7. Margin lock on open, full release (+P&L) on close ────────────────
{
const QString sym = QStringLiteral("INFY");
const double bal0 = pt_get_portfolio(pid).balance;
open_market(sym, QStringLiteral("buy"), 10, 500.0, QStringLiteral("CNC"), NSE); // CNC 1x -> locks 5000
const double bal1 = pt_get_portfolio(pid).balance;
check("margin: balance drops by locked margin on open", bal1 < bal0 - 4999.0);
pt_update_position_price(pid, sym, 520.0);
open_market(sym, QStringLiteral("sell"), 10, 520.0, QStringLiteral("CNC"), NSE); // realize +200, release
const double bal2 = pt_get_portfolio(pid).balance;
check("margin: balance restored + realized P&L on close", approx(bal2, bal0 + 200.0, 1.0));
}
// Clean up the throwaway portfolio (positions/orders/trades/blocks cascade).
pt_delete_portfolio(pid);
std::printf("\npaper-trading selftest: %s (%d failure%s)\n", failures == 0 ? "OK" : "FAILED", failures,
failures == 1 ? "" : "s");
return failures == 0 ? 0 : 1;
}
} // namespace fincept::trading