senofy/autofirmer-expanded
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add full Next.js autotrader app with SQLite persistence and live Tradovate data

Browse Source 
- SQLite DB (better-sqlite3) with firms, account_configs, firm_fees, instruments tables
- REST API routes: firms CRUD, account configs CRUD, state, accounts, instruments
- Live Tradovate WebSocket client: login, sync, positions, auto-liq thresholds
- Dashboard (app/page.tsx): per-firm account list with balance, day P&L, days traded,
  target progress, and Dead/Inactive/Flat status based on Tradovate auto-liq floors
- Account detail page: objectives progress, daily P&L chart, consistency tracking
- Per-firm settings page: account configs and instrument fee management
- Dead detection uses trailingMaxDrawdownLimit - trailingMaxDrawdown from
  userAccountAutoLiqs; filters Tradovate sentinel value (999999999 = no limit)
- FIFO P&L engine with commission accounting for daily P&L history
- Removed manual maxLoss fallback in favour of live Tradovate auto-liq data

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Senofy
2026-03-08 15:03:21 -05:00
co-authored by Claude Sonnet 4.6
parent a9b6acd479
commit dd18f91584
22 changed files with 2218 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/tradovate-class.ts
+231 -80
View File
@@ -27,6 +27,11 @@ export class TradovateClient {
} = {};
public daysTraded: { [accountId: number]: number } = {};
public dailyPnL: { [accountId: number]: { date: string; pnl: number }[] } = {};
/** Balance floor set by the prop firm — account is blown when amount <= this value (0 = not set) */
public autoLiqThresholds: { [accountId: number]: number } = {};
public products: { id: number; name: string }[] = [];
private ws: WebSocket;
private callbackOnSyncRequest: () => Promise<void>;
@@ -52,7 +57,12 @@ export class TradovateClient {
callback: (response: any) => void;
}[] = [];
constructor(name: string, password: string, callbackOnSyncRequest: () => Promise<void>) {
constructor(
name: string,
password: string,
callbackOnSyncRequest: () => Promise<void>
) {
this.name = name;
this.password = password;
this.callbackOnSyncRequest = callbackOnSyncRequest;
@@ -85,9 +95,8 @@ export class TradovateClient {
console.log('Connected to websocket');
this.ws.send('authorize\n2\n\n' + this.accessInfo.accessToken);
this.directEventCallbacks[2] = (response: any) => {
// Once authorize, start syncing every 60 seconds
this.requestAccountUpdates();
setInterval(() => this.requestAccountUpdates(), 60000);
this.requestSync();
setInterval(() => this.requestSync(), 60000);
// Every 2.5 seconds send a heartbeat
setInterval(() => {
@@ -156,79 +165,94 @@ export class TradovateClient {
});
}
private async requestAccountUpdates(): Promise<void> {
private requestSync(): void {
this.directEventCallbacks[3] = (response: any) => {
// Syncing DLL or MLL hit
const riskStatusById: { [id: number]: { liquidateOnly?: string } } = (
response.accountRiskStatuses || []
).reduce((acc: any, item: any) => {
acc[item.id] = item;
return acc;
}, {});
this.accountList = (response.accounts as AccountItem[]).map((account) => {
if (riskStatusById[account.id]?.liquidateOnly) {
return { ...account, active: false };
try {
if (!response) {
console.error('[requestSync] Received null/undefined response — auth may have failed');
return;
}
return account;
});
this.accountCashBalances = response.cashBalances.reduce(
(
acc: {
[accountId: number]: { amount: number; realizedPnL: number };
},
item: { accountId: number; amount: number; realizedPnL: number }
) => {
acc[item.accountId] = {
amount: item.amount,
realizedPnL: item.realizedPnL,
};
// liquidateOnly flag lives in accountRiskStatuses
const riskStatusById: { [accountId: number]: { liquidateOnly?: string } } = (
response.accountRiskStatuses || []
).reduce((acc: any, item: any) => {
const key = item.accountId ?? item.id;
acc[key] = item;
return acc;
},
{} as { [accountId: number]: { amount: number; realizedPnL: number } }
);
this.positions = response.positions
.filter((item) => item.netPos !== 0)
.reduce(
}, {});
// Auto-liquidation balance floor lives in userAccountAutoLiqs.
// item.id IS the account ID. The floor is: trailingMaxDrawdownLimit - trailingMaxDrawdown.
// Tradovate uses 999999999 as a sentinel for "no limit" — skip those.
for (const item of (response.userAccountAutoLiqs ?? [])) {
const accountId: number = item.id;
const limit: number = item.trailingMaxDrawdownLimit ?? 0;
const drawdown: number = item.trailingMaxDrawdown ?? 0;
const isSentinel = limit >= 999999999;
const floor = (!isSentinel && limit > 0 && drawdown > 0) ? limit - drawdown : 0;
this.autoLiqThresholds[accountId] = floor;
if (floor > 0) {
console.log(`[autoLiq] account ${accountId} → floor $${floor} (hwm=$${limit} drawdown=$${drawdown})`);
}
}
this.accountList = ((response.accounts ?? []) as AccountItem[]).map((account) => {
if (riskStatusById[account.id]?.liquidateOnly) {
return { ...account, active: false };
}
return account;
});
this.accountCashBalances = (response.cashBalances ?? []).reduce(
(
acc: {
[accountId: number]: {
contractId: number;
netPos: number;
netPrice: number;
timestamp: Date;
};
},
item: {
accountId: number;
contractId: number;
netPos: number;
netPrice: number;
timestamp: Date;
}
acc: { [accountId: number]: { amount: number; realizedPnL: number } },
item: { accountId: number; amount: number; realizedPnL: number }
) => {
acc[item.accountId] = {
contractId: item.contractId,
netPos: item.netPos,
netPrice: item.netPrice,
timestamp: new Date(item.timestamp),
};
acc[item.accountId] = { amount: item.amount, realizedPnL: item.realizedPnL };
return acc;
},
{} as {
[accountId: number]: {
contractId: number;
netPos: number;
netPrice: number;
timestamp: Date;
};
}
{} as { [accountId: number]: { amount: number; realizedPnL: number } }
);
this.callbackOnSyncRequest();
this.fetchDaysTraded();
this.positions = (response.positions ?? [])
.filter((item: any) => item.netPos !== 0)
.reduce(
(
acc: { [accountId: number]: { contractId: number; netPos: number; netPrice: number; timestamp: Date } },
item: { accountId: number; contractId: number; netPos: number; netPrice: number; timestamp: Date }
) => {
acc[item.accountId] = {
contractId: item.contractId,
netPos: item.netPos,
netPrice: item.netPrice,
timestamp: new Date(item.timestamp),
};
return acc;
},
{} as { [accountId: number]: { contractId: number; netPos: number; netPrice: number; timestamp: Date } }
);
console.log(`[requestSync] ${this.accountList.length} account(s), ${Object.keys(this.accountCashBalances).length} balance(s)`);
this.fetchDaysTraded();
if (this.products.length > 0) {
this.callbackOnSyncRequest();
return;
}
this.directEventCallbacks[30] = (products: any) => {
if (Array.isArray(products) && products.length > 0) {
this.products = products.map((p: any) => ({ id: p.id, name: p.name }));
console.log(`Loaded ${this.products.length} products`);
}
this.callbackOnSyncRequest();
};
this.ws.send('product/list\n30\n\n');
} catch (err) {
console.error('[requestSync] Error processing sync response:', err);
}
};
this.ws.send('user/syncrequest\n3\n\n{"splitResponses":false}');
@@ -237,25 +261,111 @@ export class TradovateClient {
private async fetchDaysTraded(): Promise<void> {
if (!this.accessInfo?.accessToken) return;
const cutoff = new Date();
cutoff.setDate(cutoff.getDate() - 28);
const now = new Date();
const start = new Date();
start.setDate(start.getDate() - 28);
const fmtDate = (d: Date) => {
const m = String(d.getMonth() + 1).padStart(2, '0');
const day = String(d.getDate()).padStart(2, '0');
return `${m}/${day}/${d.getFullYear()}`;
};
for (const account of this.accountList) {
try {
const res = await axios.get(
`https://demo.tradovateapi.com/v1/fill/ldeps?masterid=${account.id}`,
const res = await axios.post(
'https://rpt-demo.tradovateapi.com/v1/reports/requestreport',
{
name: 'Fills',
params: [
{ name: 'startDate', value: fmtDate(start) },
{ name: 'endDate', value: fmtDate(now) },
{ name: 'startTime', value: '00:00:00' },
{ name: 'endTime', value: '00:00:00' },
{ name: 'account', value: account.name },
],
representationType: 'json',
timezone: 0,
},
{ headers: { Authorization: `Bearer ${this.accessInfo.accessToken}` } }
);
const fills: { timestamp: string }[] = res.data ?? [];
const tradingDays = new Set(
fills
.filter((f) => new Date(f.timestamp) >= cutoff)
.map((f) => new Date(f.timestamp).toDateString())
);
this.daysTraded[account.id] = tradingDays.size;
// _tradeDate is unquoted in the response (invalid JSON), but the "Date" field
// ("M/D/YY") is a valid quoted string that already reflects CME trade date.
const raw: string = (res.data?.data ?? '[]')
.replace(/"_tradeDate":\s*(\d{4}-\d{2}-\d{2})/g, '"_tradeDate": "$1"');
type Fill = {
_tradeDate: string;
_timestamp: string;
_action: number; // 0 = Buy, 1 = Sell
_qty: number;
_price: number;
Product: string;
commission: number;
};
const fills: Fill[] = JSON.parse(raw);
const uniqueDays = new Set(fills.map(f => f._tradeDate));
this.daysTraded[account.id] = uniqueDays.size;
// Dollar-per-point map for common futures products
const POINT_VALUES: { [product: string]: number } = {
NQ: 20, MNQ: 2, ES: 50, MES: 5,
YM: 5, MYM: 0.5, RTY: 50, M2K: 10,
GC: 100, MGC: 10, SI: 50, CL: 1000,
MCL: 100, NG: 10000, ZB: 1000, ZN: 1000,
ZF: 1000, '6E': 125000, '6J': 12500000, '6B': 62500,
};
// FIFO P&L computation: match buy/sell fills into round-trips
// Both the opening and closing commissions are deducted on close.
const sorted = [...fills].sort((a, b) => a._timestamp.localeCompare(b._timestamp));
interface Lot { price: number; qty: number; commPerUnit: number }
const longBook: Lot[] = [];
const shortBook: Lot[] = [];
const dailyMap: { [date: string]: number } = {};
for (const fill of sorted) {
const pointValue = POINT_VALUES[fill.Product] ?? 1;
const isBuy = fill._action === 0;
let remaining = fill._qty;
const commPerUnit = fill._qty > 0 ? fill.commission / fill._qty : 0;
if (isBuy) {
// Close any short lots first (FIFO), then open long
while (remaining > 0 && shortBook.length > 0) {
const lot = shortBook[0];
const closed = Math.min(lot.qty, remaining);
const pnl = (lot.price - fill._price) * closed * pointValue
- (commPerUnit * closed) // closing fill commission
- (lot.commPerUnit * closed); // opening fill commission
dailyMap[fill._tradeDate] = (dailyMap[fill._tradeDate] ?? 0) + pnl;
lot.qty -= closed;
remaining -= closed;
if (lot.qty === 0) shortBook.shift();
}
if (remaining > 0) longBook.push({ price: fill._price, qty: remaining, commPerUnit });
} else {
// Close any long lots first (FIFO), then open short
while (remaining > 0 && longBook.length > 0) {
const lot = longBook[0];
const closed = Math.min(lot.qty, remaining);
const pnl = (fill._price - lot.price) * closed * pointValue
- (commPerUnit * closed) // closing fill commission
- (lot.commPerUnit * closed); // opening fill commission
dailyMap[fill._tradeDate] = (dailyMap[fill._tradeDate] ?? 0) + pnl;
lot.qty -= closed;
remaining -= closed;
if (lot.qty === 0) longBook.shift();
}
if (remaining > 0) shortBook.push({ price: fill._price, qty: remaining, commPerUnit });
}
}
this.dailyPnL[account.id] = Object.entries(dailyMap)
.map(([date, pnl]) => ({ date, pnl: Math.round(pnl * 100) / 100 }))
.sort((a, b) => a.date.localeCompare(b.date));
} catch (err) {
console.error(`[fetchDaysTraded] account ${account.id}`, err);
this.daysTraded[account.id] = 0;
console.error(`[fetchDaysTraded] ${account.name}`, err);
this.daysTraded[account.id] ??= 0;
}
}
}
@@ -321,6 +431,47 @@ export class TradovateClient {
return res.data;
}
async fetchInstrumentFees(symbols: string[]): Promise<{ [symbol: string]: number }> {
if (!this.accessInfo?.accessToken || this.products.length === 0) return {};
const productIds = symbols
.map((sym) => this.products.find((p) => p.name === sym)?.id)
.filter((id): id is number => id !== undefined);
const res = await axios.post(
'https://demo.tradovateapi.com/v1/contract/getproductfeeparams',
{ productIds },
{ headers: { Authorization: `Bearer ${this.accessInfo.accessToken}` } }
);
const result: { [symbol: string]: number } = {};
for (const param of (res.data?.params ?? [])) {
const product = this.products.find((p) => p.id === param.productId);
if (product && symbols.includes(product.name)) {
const raw =
(param.clearingFee ?? 0) +
(param.exchangeFee ?? 0) +
(param.nfaFee ?? 0) +
(param.brokerageFee ?? 0) +
(param.ipFee ?? 0) +
(param.commission ?? 0) +
(param.orderRoutingFee ?? 0);
result[product.name] = parseFloat(raw.toFixed(4));
console.log(
`[fees] ${product.name}: clearing=${param.clearingFee ?? 0}` +
` exchange=${param.exchangeFee ?? 0}` +
` nfa=${param.nfaFee ?? 0}` +
` brokerage=${param.brokerageFee ?? 0}` +
` ip=${param.ipFee ?? 0}` +
` commission=${param.commission ?? 0}` +
` routing=${param.orderRoutingFee ?? 0}` +
` → total=${result[product.name]}`
);
}
}
return result;
}
async requestContractsFromSocket(names: string[]): Promise<{
[name: string]: Contract;
}> {