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/replication/PortfolioReplicationService.h"
#include "trading/PaperTrading.h"
#include "trading/instruments/InstrumentService.h"
#include <QSet>
#include <cmath>
namespace fincept::trading::replication {
namespace {
bool is_delivery_product(const QString& product) {
// CNC = equity delivery. (NRML/MIS stay on the Positions side.)
return product.compare(QStringLiteral("CNC"), Qt::CaseInsensitive) == 0;
}
bool is_short_side(const QString& side) {
return side.compare(QStringLiteral("short"), Qt::CaseInsensitive) == 0 ||
side.compare(QStringLiteral("sell"), Qt::CaseInsensitive) == 0;
}
} // namespace
QVector<SourceItem> to_source_items(const QVector<BrokerHolding>& holdings, const QVector<BrokerPosition>& positions) {
QVector<SourceItem> out;
out.reserve(holdings.size() + positions.size());
for (const auto& h : holdings) {
SourceItem s;
s.kind = ItemKind::Holding;
s.src_symbol = h.symbol;
s.exchange = h.exchange;
s.quantity = h.quantity;
s.avg_price = h.avg_price;
s.ltp = h.ltp > 0 ? h.ltp : h.avg_price;
out.push_back(s);
}
for (const auto& p : positions) {
if (p.quantity == 0)
continue; // closed/net-flat intraday legs
SourceItem s;
s.kind = ItemKind::Position;
s.src_symbol = p.symbol;
s.exchange = p.exchange;
s.product = p.product_type.isEmpty() ? QStringLiteral("MIS") : p.product_type;
s.side = p.side;
s.quantity = std::fabs(p.quantity);
s.avg_price = p.avg_price;
s.ltp = p.ltp > 0 ? p.ltp : p.avg_price;
out.push_back(s);
}
return out;
}
QVector<SourceItem> paper_source_items(const QString& portfolio_id) {
QVector<SourceItem> out;
for (const auto& p : pt_get_positions(portfolio_id)) {
if (p.quantity == 0)
continue;
SourceItem s;
s.src_symbol = p.symbol;
s.exchange = QStringLiteral("NSE"); // paper positions carry no exchange column
s.quantity = std::fabs(p.quantity);
s.avg_price = p.entry_price;
s.ltp = p.current_price > 0 ? p.current_price : p.entry_price;
if (is_delivery_product(p.product)) {
s.kind = ItemKind::Holding;
} else {
s.kind = ItemKind::Position;
s.product = p.product.isEmpty() ? QStringLiteral("MIS") : p.product;
s.side = p.side;
}
out.push_back(s);
}
return out;
}
ReplicationPlan build_plan(const QVector<SourceItem>& items, const ReplicationOptions& opts, double target_available,
const QString& source_account_id, const QString& target_account_id,
const QString& target_paper_portfolio_id, const SymbolResolver& resolve) {
ReplicationPlan plan;
plan.source_account_id = source_account_id;
plan.target_account_id = target_account_id;
plan.target_paper_portfolio_id = target_paper_portfolio_id;
plan.target_available = target_available;
for (const auto& item : items) {
if (item.kind == ItemKind::Holding && !opts.include_holdings)
continue;
if (item.kind == ItemKind::Position && !opts.include_positions)
continue;
PlannedOrder po;
po.kind = item.kind;
po.src_symbol = item.src_symbol;
po.exchange = item.exchange.isEmpty() ? QStringLiteral("NSE") : item.exchange;
po.quantity = std::floor(item.quantity); // whole shares
po.est_price = item.ltp > 0 ? item.ltp : item.avg_price;
po.est_value = po.quantity * po.est_price;
if (item.kind == ItemKind::Holding) {
po.side = QStringLiteral("buy");
po.product = QStringLiteral("CNC");
} else {
po.side = is_short_side(item.side) ? QStringLiteral("sell") : QStringLiteral("buy");
po.product = item.product.isEmpty() ? QStringLiteral("MIS") : item.product;
}
ResolveResult r = resolve ? resolve(item.src_symbol, po.exchange) : ResolveResult{true, item.src_symbol};
po.norm_symbol = r.norm_symbol.isEmpty() ? item.src_symbol : r.norm_symbol;
po.mapped = r.tradable_on_target;
if (!po.mapped) {
po.warning = QStringLiteral("not tradable on target broker");
po.included = false;
} else if (po.quantity <= 0) {
po.warning = QStringLiteral("zero quantity after rounding");
po.included = false;
} else if (po.est_price <= 0) {
po.warning = QStringLiteral("no price available");
po.included = false;
} else {
po.included = true;
}
if (po.included)
plan.required_capital += po.est_value;
plan.orders.push_back(po);
}
return plan;
}
SymbolResolver make_instrument_resolver(const QString& source_broker_id, const QString& target_broker_id) {
return [source_broker_id, target_broker_id](const QString& src_symbol, const QString& exchange) -> ResolveResult {
auto& svc = InstrumentService::instance();
// 1) source brsymbol → canonical normalized symbol (fallback: as-is)
QString norm = src_symbol;
if (auto n = svc.from_brsymbol(src_symbol, exchange, source_broker_id))
norm = *n;
// 2) tradable on the target broker? (also rules out cross-broker symbol gaps)
bool tradable = svc.find(norm, exchange, target_broker_id).has_value();
return ResolveResult{tradable, norm};
};
}
ReplicationResult execute_plan(const ReplicationPlan& plan) {
ReplicationResult res;
// Idempotency + no-close guard. Replication must ESTABLISH positions in the
// target — it must never trade AGAINST an existing one. Routing a sell (or a
// re-imported symbol) through the normal fill engine takes its close-netting
// leg and books phantom REALIZED P&L (e.g. a source short selling into a just-
// bought long), and re-running would double exposure. So we skip any symbol the
// target already holds. To intentionally re-replicate, clear the paper account
// first. (Matched on the broker-native/normalised symbol the order will use.)
QSet<QString> already_held;
for (const auto& p : pt_get_positions(plan.target_paper_portfolio_id))
already_held.insert(p.symbol.toUpper());
for (const auto& po : plan.orders) {
if (!po.included) {
++res.skipped;
res.rows.push_back({po.norm_symbol, false, po.warning.isEmpty() ? QStringLiteral("skipped") : po.warning});
continue;
}
if (already_held.contains(po.norm_symbol.toUpper())) {
++res.skipped;
res.rows.push_back({po.norm_symbol, false,
QStringLiteral("already in target — skipped (clear paper account to re-replicate)")});
continue;
}
try {
std::optional<double> price_opt;
if (po.est_price > 0)
price_opt = po.est_price; // market reference price for margin calc
auto ord = pt_place_order(plan.target_paper_portfolio_id, po.norm_symbol, po.side, QStringLiteral("market"),
po.quantity, price_opt, std::nullopt,
/*reduce_only=*/false, po.exchange, po.product);
pt_fill_order(ord.id, po.est_price);
already_held.insert(po.norm_symbol.toUpper()); // a later same-symbol leg must not net against this
++res.placed;
res.rows.push_back({po.norm_symbol, true, QString()});
} catch (const std::exception& e) {
++res.failed;
res.rows.push_back({po.norm_symbol, false, QString::fromUtf8(e.what())});
}
}
return res;
}
} // namespace fincept::trading::replication