Merge branch 'vest-fix-timing' into vest-fixes
# Conflicts: # lib/reporter.ts # lib/vest-class.ts # scripts/check-vest.mjs
This commit is contained in:
Brandon Li
+16
-10
@@ -11,9 +11,9 @@ import { getClients } from './clients';
|
||||
import { getCachedFirm, getTradableFirms } from './firm-catalog';
|
||||
import { ensureRulesEvidence, getAccountConfig } from './account-type-resolver';
|
||||
import {
|
||||
combineCmeSessions, computeDayPlan, groupLegFraction, pickLegAmount, resolveEffectiveConfig, currentTradeDateCT,
|
||||
combineCmeSessions, computeDayPlan, groupLegFraction, pickLegAmount, resolveEffectiveConfig, tradeDateFor,
|
||||
obfuscationStopDollars, takeProfitPlan, onTick, percentFee, dllRoom, dllStopDollars, dllViable, stopTicks,
|
||||
expectedSwapToWin, planLegSize, maxLossRoom, breachDistance,
|
||||
expectedSwapToWin, planLegSize, maxLossRoom, breachDistance, legCloseNote,
|
||||
isNoTradeTime, isPastSessionClose,
|
||||
BIG_DAY_THRESHOLD, LEG_COMPLETION_EPSILON, MAX_LEGS_PER_DAY,
|
||||
FALLBACK_COMMISSION_PER_CONTRACT, MAX_COMMISSION_PER_CONTRACT, DLL_MIN_STOP,
|
||||
@@ -1043,7 +1043,10 @@ async function runTradeLocked(
|
||||
// operator's pick; 'Auto' is drawn per batch from the batch firm's list.
|
||||
const explicit = futuresLane && symbol !== 'Auto' ? symbol : null;
|
||||
|
||||
const tradeDate = currentTradeDateCT();
|
||||
// The lane's own day (tradeDateFor): a notional lane is one firm — a
|
||||
// Vest lane's day turns at 20:00 ET, its rows and realized P&L with it —
|
||||
// and the futures lane's clients all keep the Central trade date.
|
||||
const tradeDate = tradeDateFor(open[0]?.client);
|
||||
const maxConcurrent = maxConcurrentAccounts();
|
||||
|
||||
// ── Phase 1: the eligible accounts across the lane's firms ──
|
||||
@@ -1488,6 +1491,10 @@ async function fireLeg(
|
||||
if (!plan.sizing) {
|
||||
throw new Error(`no position size for ${legContract.name} — its recent volatility is unknown`);
|
||||
}
|
||||
// The pick held the batch's lead leg to its market's close; this
|
||||
// account's leg can size longer (another stage, a leverage cap).
|
||||
const closeNote = legCloseNote(legContract.closesAt, plan.sizing.predictedHoldHours, Date.now());
|
||||
if (closeNote) throw new Error(`${legContract.name}: ${closeNote} — not entering`);
|
||||
contracts = Math.max(1, Math.round(plan.sizing.notional / stepNotional));
|
||||
if (plan.cap > 0) contracts = Math.min(contracts, Math.max(1, Math.floor(plan.cap / stepNotional)));
|
||||
if ((legContract.maxContracts ?? 0) > 0) contracts = Math.min(contracts, legContract.maxContracts!);
|
||||
@@ -1742,7 +1749,8 @@ async function copyTradeLocked(lease: number, lane: string): Promise<unknown[]>
|
||||
return [];
|
||||
}
|
||||
|
||||
const tradeDate = currentTradeDateCT();
|
||||
// The lane's own day, as in runTrade.
|
||||
const tradeDate = tradeDateFor(ready[0]?.client);
|
||||
|
||||
// Collect eligible accounts (same logic as Phase 1 of runTrade)
|
||||
const eligible: LegItem[] = [];
|
||||
@@ -1860,7 +1868,7 @@ export async function fireManualLeg(accountId: number, action: 'Buy' | 'Sell' |
|
||||
const lease = acquireTradeMutex('[manual-leg]', lane);
|
||||
if (lease === null) throw new Error('another batch is in flight in this lane');
|
||||
try {
|
||||
const tradeDate = currentTradeDateCT();
|
||||
const tradeDate = tradeDateFor(client);
|
||||
const ev = evaluateAccountForTrade(client, acc, tradeDate);
|
||||
if (!ev || !ev.plan) throw new Error(ev?.reason || 'account has no account type');
|
||||
if (!ev.eligible && !ev.reason.startsWith('already traded today')) throw new Error(ev.reason);
|
||||
@@ -1986,7 +1994,6 @@ async function runClaims(lane: string, ready: FirmClient[]): Promise<void> {
|
||||
const lease = acquireTradeMutex('[auto-claim]', lane);
|
||||
if (lease === null) return;
|
||||
try {
|
||||
const tradeDate = currentTradeDateCT();
|
||||
for (const { firm, client, acc } of due) {
|
||||
if (!holdsTradeMutex(lease, lane)) return;
|
||||
// Settled since, or a different amount now: claim what is due now.
|
||||
@@ -1996,7 +2003,7 @@ async function runClaims(lane: string, ready: FirmClient[]): Promise<void> {
|
||||
// In flight while it claims: a batch that takes over a wedged
|
||||
// lane, or a Claim now, leaves the account alone.
|
||||
const { claimed, received } = await withAccountInFlight(acc.id, () => client.claimProfit!(acc.id, amount));
|
||||
afterClaim('[auto-claim]', firm, client, acc, claimed, received, tradeDate);
|
||||
afterClaim('[auto-claim]', firm, client, acc, claimed, received, tradeDateFor(client));
|
||||
} catch (err) {
|
||||
(runtime().claimFailedAt ??= new Map()).set(acc.id, Date.now());
|
||||
console.error(`[auto-claim] ${firm.name} ${acc.name}: claim of $${Math.floor(amount * 100) / 100} failed — ${errorMessage(err)}; retrying in ${CLAIM_RETRY_MS / 60_000}m`);
|
||||
@@ -2130,7 +2137,7 @@ export async function claimAccountNow(accountId: number, amount: number): Promis
|
||||
if (!(amount >= 1)) throw new ClaimRefusedError(`$${amount} is below the $1 minimum claim`);
|
||||
if (amount > c.amount + 0.005) throw new ClaimRefusedError(`only $${c.amount.toFixed(2)} is claimable now`);
|
||||
const { claimed, received } = await withAccountInFlight(c.acc.id, () => c.client.claimProfit!(c.acc.id, amount));
|
||||
const stage = afterClaim('[claim-now]', c.firm, c.client, c.acc, claimed, received, currentTradeDateCT());
|
||||
const stage = afterClaim('[claim-now]', c.firm, c.client, c.acc, claimed, received, tradeDateFor(c.client));
|
||||
return { claimed, received, stage };
|
||||
} finally {
|
||||
releaseTradeMutex(lease, lane);
|
||||
@@ -2142,7 +2149,6 @@ export async function claimAccountNow(accountId: number, amount: number): Promis
|
||||
/** Returns true if any configured account could still trade today (eligible for a next leg / extra-day, or has an open position). */
|
||||
function hasRemainingConfiguredAccounts(): boolean {
|
||||
const { ready, unready } = firmClients();
|
||||
const tradeDate = currentTradeDateCT();
|
||||
|
||||
// A client that isn't ready can't say whether its accounts are done — its
|
||||
// snapshot is missing or stale — so while one might hold any of ours, the
|
||||
@@ -2175,7 +2181,7 @@ function hasRemainingConfiguredAccounts(): boolean {
|
||||
// Order being placed right now = still in play (evaluation calls it ineligible)
|
||||
if (runtime().accountsInFlight.has(acc.id)) return true;
|
||||
|
||||
const ev = evaluateAccountForTrade(client, acc, tradeDate);
|
||||
const ev = evaluateAccountForTrade(client, acc, tradeDateFor(client));
|
||||
if (ev?.eligible) return true;
|
||||
// Waiting on its history (or its day-start balance), not done: it may
|
||||
// still owe today's trade — during the session and before it opens
|
||||
|
||||
@@ -684,6 +684,15 @@ export function markTrade(
|
||||
`).run(t.positionId, t.accountId, t.accountName, t.symbol, t.side, t.quantity, t.openPrice, t.openedAt, Date.now());
|
||||
}
|
||||
|
||||
/** Which of these positions this instance's own order opened (markTrade). */
|
||||
export function botOpenedPositions(positionIds: string[]): Set<string> {
|
||||
if (positionIds.length === 0) return new Set();
|
||||
const rows = db.prepare(`SELECT position_id AS positionId FROM trades
|
||||
WHERE opened_by = 'bot' AND position_id IN (${positionIds.map(() => '?').join(', ')})`)
|
||||
.all(...positionIds) as { positionId: string }[];
|
||||
return new Set(rows.map((r) => r.positionId));
|
||||
}
|
||||
|
||||
/** Vest accounts with a trade the table still shows open (Vest's position
|
||||
* ids are bare numbers; the fill-built trades below carry a prefix). */
|
||||
export function openTradeAccounts(): { accountId: number; accountName: string }[] {
|
||||
|
||||
@@ -48,6 +48,11 @@ export interface PlatformContract {
|
||||
/** Margin posted per dollar of notional (0.2 = 5:1 leverage), where the
|
||||
* broker says — caps a position at available funds ÷ this. */
|
||||
marginRate?: number;
|
||||
/** When the instrument's market next closes for long (epoch ms; Vest: a
|
||||
* weekend or holiday, not the maintenance hour), where the platform
|
||||
* says: no leg starts that wouldn't be done by then (clearsClose), each
|
||||
* account's at its own size (fireLeg). */
|
||||
closesAt?: number;
|
||||
}
|
||||
|
||||
export interface PlatformClient {
|
||||
@@ -145,6 +150,11 @@ export interface PlatformClient {
|
||||
* before the platform's daily reset (resetClearStop).
|
||||
*/
|
||||
dayGainForRoom?(accountId: number, o: { leg: number; limit: number }): number;
|
||||
/** The trade date at `now` (epoch ms) that this platform's daily rows and
|
||||
* realized P&L follow, where its day turns at another hour than the
|
||||
* 5 PM CT roll (Vest: 20:00 ET). The engine plans the accounts and
|
||||
* counts their legs by it (tradeDateFor); absent = currentTradeDateCT. */
|
||||
tradeDate?(now: number): string;
|
||||
/** Payouts made since the firm's last daily reset — what picks the stage
|
||||
* of an account type whose stages reset each day. */
|
||||
sameDayClaims?(accountId: number): number;
|
||||
|
||||
+8
-4
@@ -20,7 +20,7 @@ import { getClients } from './clients';
|
||||
import { getAccountTypeById, getKeptRuleIdsForFirm, getTradableFirms } from './firm-catalog';
|
||||
import { getAccountConfig } from './account-type-resolver';
|
||||
import { getSchedulerStatus } from './auto-trade';
|
||||
import { botStopsActive, combineCmeSessions, computeDayPlan, currentTradeDateCT, completionPlace, cycleCompletion, endedCycleCompletion, LEG_COMPLETION_EPSILON, projectPerfectPath, resolveEffectiveConfig, stageInputsFor } from './trading-logic';
|
||||
import { botStopsActive, combineCmeSessions, computeDayPlan, completionPlace, cycleCompletion, endedCycleCompletion, LEG_COMPLETION_EPSILON, projectPerfectPath, resolveEffectiveConfig, stageInputsFor, tradeDateFor } from './trading-logic';
|
||||
import type { AccountTypeStats, FirmStats, InstrumentStats, SymbolStats } from './master-protocol';
|
||||
import { accountNextLeg, accountLegShape } from './leg-estimate';
|
||||
import { sizingHoldHours } from './person-size';
|
||||
@@ -33,9 +33,6 @@ function collectFirmStats() {
|
||||
// the master's table with rows for firms it does not run.
|
||||
const firms = getTradableFirms();
|
||||
const clients = getClients();
|
||||
// One raw trade date for the whole report: the combined views below roll
|
||||
// it forward, the completion check needs it as is.
|
||||
const rawToday = currentTradeDateCT();
|
||||
// projectPerfectPath's `loops` test: a type whose completed cycle keeps
|
||||
// going pays out (a funded account), one that stops just passes.
|
||||
const loops = (cfg: { payoutable?: boolean; withdrawalStages: unknown[] }): boolean =>
|
||||
@@ -49,6 +46,11 @@ function collectFirmStats() {
|
||||
const keptRuleIds = getKeptRuleIdsForFirm(f.id);
|
||||
// accounts: [] only once synced (see emptyFirmStats).
|
||||
if (!client || client.accountList.length === 0) return emptyFirmStats(f, client, keptRuleIds);
|
||||
// One raw trade date per firm, the one its accounts trade on
|
||||
// (tradeDateFor — Vest's turns at 20:00 ET, not 5 PM CT): the
|
||||
// combined views below roll it forward, the completion check needs
|
||||
// it as is.
|
||||
const rawToday = tradeDateFor(client);
|
||||
|
||||
let totalAccounts = 0;
|
||||
let accountsTraded = 0;
|
||||
@@ -282,6 +284,7 @@ function collectFirmStats() {
|
||||
const ended = endedCycleCompletion({
|
||||
accountId: acc.id,
|
||||
rawTradeDate: rawToday,
|
||||
client,
|
||||
fullDailyPnL: client.fullDailyPnL[acc.id] ?? [],
|
||||
cycleDailyPnL: client.dailyPnL[acc.id],
|
||||
fundTransactions: fundTxns,
|
||||
@@ -325,6 +328,7 @@ function collectFirmStats() {
|
||||
const completion = cycleCompletion({
|
||||
accountId: acc.id,
|
||||
rawTradeDate: rawToday,
|
||||
client,
|
||||
cycleDailyPnL: client.dailyPnL[acc.id],
|
||||
rawRealizedPnL: cash.realizedPnL,
|
||||
combineCmeHolidays: cfg.combineCmeHolidays,
|
||||
|
||||
+48
-11
@@ -165,6 +165,18 @@ export function currentTradeDateCT(now: Date = new Date()): string {
|
||||
return new Date(date).toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
/**
|
||||
* The trade date a client's accounts are planned on and count their legs by:
|
||||
* the platform's own day where its daily rows and realized P&L follow one
|
||||
* that turns at another hour (Vest: 20:00 ET, two hours after the 5 PM CT
|
||||
* roll), else the Central trade date. Between the two rolls the Central date
|
||||
* would count the platform's still-open day both as a prior day and as
|
||||
* today's realized P&L, and start the day's leg count over mid-day.
|
||||
*/
|
||||
export function tradeDateFor(client: { tradeDate?: (now: number) => string } | null | undefined, now: Date = new Date()): string {
|
||||
return typeof client?.tradeDate === 'function' ? client.tradeDate(now.getTime()) : currentTradeDateCT(now);
|
||||
}
|
||||
|
||||
/** Drain-day target grid: $4–$15 in $0.50 steps (23 values, MNQ's
|
||||
* per-contract tick), always traded on MNQ. Drain days qualify at ≥
|
||||
* DRAIN_DAY_MIN, so every draw counts. Seeded per (account, trade date) like
|
||||
@@ -672,8 +684,9 @@ export type CycleCompletion = 'none' | 'today' | 'before';
|
||||
|
||||
/** How long a new trade date waits before it can read 'today': the platforms
|
||||
* reset realizedPnL on their own clock (a Tradovate cashBalance event, the
|
||||
* TopstepX 60s sync), not at 5 PM sharp, and until then the last session's
|
||||
* number — already booked under its own date — would count as a second day. */
|
||||
* TopstepX 60s sync, Vest's next sync after 20:00 ET), not at the roll
|
||||
* sharp, and until then the last session's number — already booked under
|
||||
* its own date — would count as a second day. */
|
||||
const ROLL_SETTLE_MS = 5 * 60 * 1000;
|
||||
|
||||
/** How long after a fund transaction starts a new cycle the cycle it ended is
|
||||
@@ -704,13 +717,14 @@ function cycleOwesNothing(
|
||||
* weekend (it is the last session's stale number, already booked under its
|
||||
* own date), a Monday with a weekend-dated row — the live session filed under
|
||||
* a weekend date, which would count it twice — and the first minutes after
|
||||
* the 5 PM roll. An every-day firm's weekends are real sessions, so only the
|
||||
* roll window applies to it. */
|
||||
* the roll: the client's own (tradeDateFor), else 5 PM CT. An every-day
|
||||
* firm's weekends are real sessions, so only the roll window applies to it. */
|
||||
function sessionDoubtful(
|
||||
rawTradeDate: string,
|
||||
cycleDailyPnL: { date: string; pnl: number }[],
|
||||
now: Date,
|
||||
everyDay = false,
|
||||
client?: { tradeDate?: (now: number) => string },
|
||||
): boolean {
|
||||
const day = new Date(`${rawTradeDate}T00:00:00Z`);
|
||||
const dow = day.getUTCDay();
|
||||
@@ -721,7 +735,7 @@ function sessionDoubtful(
|
||||
if (cycleDailyPnL.some((d) => d.date === saturday || d.date === sunday)) return true;
|
||||
}
|
||||
// Settle window: a few minutes ago it was still an earlier trade date.
|
||||
return currentTradeDateCT(new Date(now.getTime() - ROLL_SETTLE_MS)) < rawTradeDate;
|
||||
return tradeDateFor(client, new Date(now.getTime() - ROLL_SETTLE_MS)) < rawTradeDate;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -734,14 +748,18 @@ function sessionDoubtful(
|
||||
* 'none' instead: a weekend (realizedPnL is the last session's stale number,
|
||||
* already booked under its own date), a Monday with a weekend-dated row — the
|
||||
* live session filed under a weekend date, which would count it twice — and
|
||||
* the first minutes after the 5 PM roll. 'before' skips those guards: it only
|
||||
* the first minutes after the roll. 'before' skips those guards: it only
|
||||
* keeps a locked, untraded pass out of the reporter's losses.
|
||||
*/
|
||||
export function cycleCompletion(opts: {
|
||||
accountId: number;
|
||||
/** currentTradeDateCT() — NOT the combined date, which rolls a weekend
|
||||
* forward to Monday. */
|
||||
/** tradeDateFor(client) — NOT the combined date, which rolls a weekend
|
||||
* forward to Monday. On a platform whose day turns later than 5 PM CT
|
||||
* (Vest), the Central date would count its open day twice. */
|
||||
rawTradeDate: string;
|
||||
/** The account's client: the settle window follows its day's roll
|
||||
* (tradeDateFor). */
|
||||
client?: { tradeDate?: (now: number) => string };
|
||||
/** Current-cycle daily P&L as the client holds it (client.dailyPnL). */
|
||||
cycleDailyPnL: { date: string; pnl: number }[];
|
||||
rawRealizedPnL: number;
|
||||
@@ -764,7 +782,7 @@ export function cycleCompletion(opts: {
|
||||
const prior = view.dailyPnL.filter((d) => d.date !== view.tradeDate);
|
||||
|
||||
if (cycleOwesNothing(accountId, eff, prior, view.tradeDate, equityProfit, view.realizedPnL, splitEnabled)) return 'before';
|
||||
if (sessionDoubtful(rawTradeDate, opts.cycleDailyPnL, opts.now ?? new Date(), everyDay)) return 'none';
|
||||
if (sessionDoubtful(rawTradeDate, opts.cycleDailyPnL, opts.now ?? new Date(), everyDay, opts.client)) return 'none';
|
||||
|
||||
const withToday = [...prior, { date: view.tradeDate, pnl: view.realizedPnL }];
|
||||
const probe = nextTradingDate(view.tradeDate, everyDay);
|
||||
@@ -825,8 +843,10 @@ export function completionPlace(o: {
|
||||
*/
|
||||
export function endedCycleCompletion(opts: {
|
||||
accountId: number;
|
||||
/** currentTradeDateCT(). */
|
||||
/** tradeDateFor(client). */
|
||||
rawTradeDate: string;
|
||||
/** As in cycleCompletion. */
|
||||
client?: { tradeDate?: (now: number) => string };
|
||||
/** Every cycle's daily P&L, raw (client.fullDailyPnL). */
|
||||
fullDailyPnL: { date: string; pnl: number }[];
|
||||
/** Current-cycle daily P&L, raw (client.dailyPnL). */
|
||||
@@ -855,7 +875,7 @@ export function endedCycleCompletion(opts: {
|
||||
if (lastFundDate === null || start === null) return null;
|
||||
const ageDays = (Date.parse(`${rawTradeDate}T00:00:00Z`) - Date.parse(`${lastFundDate}T00:00:00Z`)) / (24 * 60 * 60 * 1000);
|
||||
if (!(ageDays <= ENDED_CYCLE_WINDOW_DAYS)) return null; // NaN included: an unparseable date
|
||||
if (sessionDoubtful(rawTradeDate, opts.cycleDailyPnL, opts.now ?? new Date(), everyDay)) return null;
|
||||
if (sessionDoubtful(rawTradeDate, opts.cycleDailyPnL, opts.now ?? new Date(), everyDay, opts.client)) return null;
|
||||
|
||||
const latest = (a: string, b: string) => (b > a ? b : a);
|
||||
const earlierFunds = fundTransactions.filter((f) => f.date < lastFundDate);
|
||||
@@ -1413,6 +1433,23 @@ export function resetClearStop(o: { leg: number; resetInMs: number; holdHours: n
|
||||
return (o.leg * (c + Math.sqrt(c * c - 4))) / 2;
|
||||
}
|
||||
|
||||
/** Whether a leg of `holdHours` starting now is all but sure to be done
|
||||
* before its market closes `closeInMs` from now: the RESET_CLEAR_HOLDS
|
||||
* holds a daily reset is given (resetClearStop). A leg still open at the
|
||||
* close can't be exited until the market reopens, and meets the reopen's
|
||||
* gap with its stop. */
|
||||
export function clearsClose(o: { closeInMs: number; holdHours: number }): boolean {
|
||||
return o.closeInMs >= RESET_CLEAR_HOLDS * o.holdHours * 3_600_000;
|
||||
}
|
||||
|
||||
/** Why a leg of `holdHours` starting at `now` doesn't open: its market
|
||||
* closes at `closesAt` (epoch ms) before it clears (clearsClose). null when
|
||||
* it clears, or no close is known (a futures contract). */
|
||||
export function legCloseNote(closesAt: number | null | undefined, holdHours: number, now: number): string | null {
|
||||
if (closesAt === null || closesAt === undefined || clearsClose({ closeInMs: closesAt - now, holdHours })) return null;
|
||||
return `closes in ${((closesAt - now) / 3_600_000).toFixed(1)}h, under ${RESET_CLEAR_HOLDS} holds of ${holdHours.toFixed(1)}h`;
|
||||
}
|
||||
|
||||
/**
|
||||
* dllRoom where the platform states its daily-loss floor itself (Vest: the
|
||||
* equity the account may not fall below today, already moved by the day's
|
||||
|
||||
+179
-10
@@ -38,11 +38,11 @@
|
||||
|
||||
import { randomUUID } from 'crypto';
|
||||
import axios from './http-client';
|
||||
import { currentTradeDateCT, rankForTarget, dllReserve, resetClearStop } from './trading-logic';
|
||||
import { currentTradeDateCT, rankForTarget, dllReserve, resetClearStop, legCloseNote } from './trading-logic';
|
||||
import { sizingHoldHours } from './person-size';
|
||||
import {
|
||||
saveDailyPnL, loadDailyPnL, loadAccountMeta, saveAccountMeta, loadFundTransactions, saveFundTransactions,
|
||||
saveEndedCycleStart, dropFundTransaction, saveTrades, markTrade, getOrCreateSetting, TRADES_SINCE_SETTING, openTradeAccounts,
|
||||
saveEndedCycleStart, dropFundTransaction, saveTrades, markTrade, getOrCreateSetting, TRADES_SINCE_SETTING, openTradeAccounts, botOpenedPositions,
|
||||
} from './db';
|
||||
import { getCachedFirm } from './firm-catalog';
|
||||
import { firmInstruments } from './instruments';
|
||||
@@ -52,7 +52,7 @@ import { encodeContractName, decodeContractName, roundToStep, scoreCandidate } f
|
||||
import { vestSessionFor, dropVestSession, listVestSessions, refuseVestSession } from './vest-session';
|
||||
import {
|
||||
vestAccountId, vestAccountName, vestDayOf, lastVestResetMs, nextVestResetMs, parseCapitalAccount, parsePosition, parseOpenOrder,
|
||||
parseTxn, bookTxns, awaitingLegs, unrealizedPnl, hourlyVolatility, marketOpen, num, toMs, formatDecimal, resetSafeStop,
|
||||
parseTxn, bookTxns, awaitingLegs, unknownOpenFill, unrealizedPnl, hourlyVolatility, marketOpen, longClosure, num, toMs, formatDecimal, resetSafeStop,
|
||||
parseHistoryPosition, jwtClaimStrings, accountScopedToken, VEST_STATUS_ACTIVE, VEST_STOP_SLIPPAGE_FRACTION,
|
||||
VestApiError, VestNotSentError, nothingWentIn, tokenForRequest, settleClaims, readClaims, payoutDaysOf, payoutsSince,
|
||||
} from './vest-helpers';
|
||||
@@ -104,7 +104,8 @@ const NAKED_AFTER_MS = 2 * 60_000;
|
||||
* candidate is costed as crossing this many ticks. */
|
||||
const ASSUMED_SPREAD_TICKS = 1;
|
||||
/** How long before the daily reset open positions are fitted to the room
|
||||
* the reset will leave (guardReset). */
|
||||
* the reset will leave (guardReset) — and before a market closure that runs
|
||||
* past one, the bot's own legs are closed (guardClose). */
|
||||
const RESET_GUARD_MS = 5 * 60_000;
|
||||
/** No new position opens this close to the reset: the guard's window, and a
|
||||
* couple of minutes before it for an entry in flight to place its exits. */
|
||||
@@ -112,6 +113,9 @@ const RESET_ENTRY_BLOCK_MS = RESET_GUARD_MS + 2 * 60_000;
|
||||
/** How long a stop or close the guard just sent counts before a read of
|
||||
* open positions shows it. */
|
||||
const GUARD_ECHO_MS = 30_000;
|
||||
/** An open of unknown outcome is the position opened this close to its send
|
||||
* and its error — the gateway's clock and lag (unknownOpenFill). */
|
||||
const UNKNOWN_OPEN_SLACK_MS = 2 * 60_000;
|
||||
/** account_meta key of the profit claims this client made, per account. */
|
||||
const CLAIMS_META = 'vest_claims';
|
||||
|
||||
@@ -197,6 +201,17 @@ export class VestClient implements PlatformClient {
|
||||
noSessionLogged: false, unfittable: new Set<string>(),
|
||||
};
|
||||
private resetGuardInFlight = false;
|
||||
/** guardClose's closes just sent (position → when), the hand trades it
|
||||
* has named (position → the close they were named for), and when it
|
||||
* last said it couldn't read a symbol's hours or had no session. */
|
||||
private closeGuard = {
|
||||
closes: new Map<string, number>(), named: new Map<string, number>(), hoursWarnedAt: new Map<string, number>(), noSessionFor: 0,
|
||||
};
|
||||
private closeGuardInFlight = false;
|
||||
/** Opens whose outcome came back unknown, by account: the position one
|
||||
* made is the bot's once a read shows it (adoptUnknownOpen) — no exits
|
||||
* went on it, so it's the leg guardClose most needs to see. */
|
||||
private unknownOpens = new Map<number, { accountId: string; symbol: string; side: 'long' | 'short'; from: number; until: number }>();
|
||||
private capital = new Map<number, VestCapitalAccount>();
|
||||
private positionsDetail = new Map<number, VestPosition[]>();
|
||||
private openOrders = new Map<number, VestOpenOrder[]>();
|
||||
@@ -409,6 +424,7 @@ export class VestClient implements PlatformClient {
|
||||
const now = Date.now();
|
||||
if (this.syncInFlight && now - this.syncInFlightSince >= SYNC_WEDGED_MS) void this.requestSync();
|
||||
void this.guardReset().catch((err) => console.error(`${this.tag} reset guard failed: ${errorMessage(err)}`));
|
||||
void this.guardClose().catch((err) => console.error(`${this.tag} market-close guard failed: ${errorMessage(err)}`));
|
||||
}
|
||||
|
||||
// ── public market data ───────────────────────────────────────────────────
|
||||
@@ -579,6 +595,7 @@ export class VestClient implements PlatformClient {
|
||||
this.positionsDetail.set(id, mine);
|
||||
this.openOrders.set(id, orders.filter((o) => o.accountId === a.id));
|
||||
this.applyPosition(acc, mine);
|
||||
this.adoptUnknownOpen(id, mine, startedAt);
|
||||
|
||||
const amount = free.get(a.id);
|
||||
if (amount === undefined) { complete = false; continue; }
|
||||
@@ -718,6 +735,12 @@ export class VestClient implements PlatformClient {
|
||||
return this.dailyFloorOf(a, cash.amount, Date.now()) ?? null;
|
||||
}
|
||||
|
||||
/** See PlatformClient: Vest's own day (vestDayOf, 20:00 ET to 20:00 ET),
|
||||
* which its daily rows, realized P&L (realizedSince) and floors follow. */
|
||||
public tradeDate(now: number): string {
|
||||
return vestDayOf(now);
|
||||
}
|
||||
|
||||
/**
|
||||
* See PlatformClient: the gain since the day's base that is still in the
|
||||
* account — since this client's own claim today, else since the reset,
|
||||
@@ -728,7 +751,7 @@ export class VestClient implements PlatformClient {
|
||||
*/
|
||||
public dayGainForRoom(accountId: number, o: { leg: number; limit: number }): number {
|
||||
const now = Date.now();
|
||||
const hold = sizingHoldHours(getCachedFirm(this.cfg.firmId));
|
||||
const hold = sizingHoldHours(getCachedFirm(this.cfg.firmId), this.tradeDate(now));
|
||||
const allowed = resetClearStop({ leg: o.leg, resetInMs: nextVestResetMs(now) - now, holdHours: hold }) - o.limit;
|
||||
if (!(allowed > 0)) return 0;
|
||||
const a = this.capital.get(accountId);
|
||||
@@ -1066,6 +1089,124 @@ export class VestClient implements PlatformClient {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Before a long market closure — one that keeps a symbol's market shut
|
||||
* across an 8 PM ET reset: the weekend, a holiday (longClosure) — close
|
||||
* the bot's own legs in it still open in the last RESET_GUARD_MS, while
|
||||
* the market takes orders. Inside the closure nothing exits, the reset
|
||||
* guard's stops and closes are refused, and the reopen's gap jumps a
|
||||
* stop. No leg starts under RESET_CLEAR_HOLDS holds of a close
|
||||
* (pickCandidate), so this only meets one that outlived them.
|
||||
*
|
||||
* Only positions the bot's own order opened (markOwn, or an open of
|
||||
* unknown outcome that turned out filled: adoptUnknownOpen): one without
|
||||
* that mark — a hand trade, or one from before marking began — is left
|
||||
* as it is and named once in the log. The daily maintenance hour reopens
|
||||
* before the reset, and is ridden.
|
||||
*/
|
||||
private async guardClose(): Promise<void> {
|
||||
if (!this.syncComplete || this.intentionalDisconnect || this.closeGuardInFlight) return;
|
||||
const held = [...new Set([...this.positionsDetail.values()].flat().map((p) => p.symbol))];
|
||||
if (held.length === 0) return;
|
||||
this.closeGuardInFlight = true;
|
||||
try {
|
||||
const guard = this.closeGuard;
|
||||
const now = Date.now();
|
||||
for (const [id, at] of guard.closes) if (now - at >= GUARD_ECHO_MS) guard.closes.delete(id);
|
||||
for (const [id, closesAt] of guard.named) if (closesAt < now) guard.named.delete(id);
|
||||
// This runs all day while anything is open: hours it can't read
|
||||
// are said once in a while, not every tick.
|
||||
const unreadable = (what: string, err: unknown) => {
|
||||
if (now - (guard.hoursWarnedAt.get(what) ?? 0) < MARKET_HOURS_TTL_MS) return;
|
||||
guard.hoursWarnedAt.set(what, now);
|
||||
console.warn(`${this.tag} ${what}: market hours unreadable — can't tell whether its market is about to close (${errorMessage(err)})`);
|
||||
};
|
||||
let specs: Map<string, SymbolSpec>;
|
||||
try {
|
||||
specs = await this.symbolSpecs();
|
||||
} catch (err) {
|
||||
unreadable(held.join(', '), err);
|
||||
return;
|
||||
}
|
||||
// Each held symbol whose long closure is this near, and when.
|
||||
const closing = new Map<string, number>();
|
||||
for (const symbol of held) {
|
||||
const spec = specs.get(symbol);
|
||||
if (!spec) continue;
|
||||
let periods: unknown;
|
||||
try {
|
||||
periods = await this.marketHours(spec.assetId);
|
||||
} catch (err) {
|
||||
unreadable(symbol, err);
|
||||
continue;
|
||||
}
|
||||
const hours = marketOpen(periods, now);
|
||||
if (hours.open && hours.closesAt !== null && hours.closesAt - now <= RESET_GUARD_MS && longClosure(periods, hours.closesAt)) {
|
||||
closing.set(symbol, hours.closesAt);
|
||||
}
|
||||
}
|
||||
if (closing.size === 0) return;
|
||||
if (!vestSessionFor(this.wallet, now, USER_TOKEN_MIN_MS)) {
|
||||
const first = Math.min(...closing.values());
|
||||
if (guard.noSessionFor !== first) {
|
||||
guard.noSessionFor = first;
|
||||
console.error(`${this.tag} the market closes in ${Math.ceil((first - now) / 60_000)} min until past an 8 PM ET reset, and the bot's open legs can't be closed — no Vest session (open the Vest tab)`);
|
||||
}
|
||||
return;
|
||||
}
|
||||
const readAt = Date.now();
|
||||
const { data } = await this.request<{ positions?: unknown[] }>('trade', 'GET', '/v3/positions/opened');
|
||||
const all = (data?.positions ?? []).map(parsePosition).filter((p): p is VestPosition => p !== null);
|
||||
for (const id of [...this.unknownOpens.keys()]) this.adoptUnknownOpen(id, all, readAt);
|
||||
const open = all.filter((p) => closing.has(p.symbol));
|
||||
const mine = botOpenedPositions(open.map((p) => p.positionId));
|
||||
for (const acc of this.accountList) {
|
||||
const uuid = this.uuidById.get(acc.id);
|
||||
if (!uuid) continue;
|
||||
for (const pos of open.filter((p) => p.accountId === uuid)) {
|
||||
const closesAt = closing.get(pos.symbol)!;
|
||||
const inMin = Math.max(0, Math.ceil((closesAt - Date.now()) / 60_000));
|
||||
if (!mine.has(pos.positionId)) {
|
||||
if (guard.named.get(pos.positionId) !== closesAt) {
|
||||
guard.named.set(pos.positionId, closesAt);
|
||||
console.error(`${this.tag} ${acc.name}: ${pos.side} ${pos.symbol} isn't marked as the bot's (a hand trade, or a bot leg from before marking or a restart mid-entry) and stays open — its market closes in ${inMin} min until past an 8 PM ET reset; close it on Vest if it shouldn't carry the closure and the reopen's gap`);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// A close just sent counts until a read of open positions shows it.
|
||||
if (guard.closes.has(pos.positionId)) continue;
|
||||
try {
|
||||
await this.submit(uuid, '/v3/positions/close', { positionId: pos.positionId, symbol: pos.symbol, orderType: 'market' });
|
||||
guard.closes.set(pos.positionId, Date.now());
|
||||
this.markOwn('closed', acc.id, pos);
|
||||
console.error(`${this.tag} ${acc.name}: CLOSED the bot's ${pos.side} ${pos.quantity} ${pos.symbol} at market — its market closes in ${inMin} min until past an 8 PM ET reset, and nothing could exit it there`);
|
||||
} catch (err) {
|
||||
console.error(`${this.tag} ${acc.name}: couldn't close the bot's ${pos.symbol} before its market closes in ${inMin} min: ${errorMessage(err)}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
this.closeGuardInFlight = false;
|
||||
}
|
||||
}
|
||||
|
||||
/** An open of unknown outcome that a read (started at `readAt`) shows
|
||||
* filled after all: the position is the bot's (markOwn). One the read
|
||||
* doesn't show by then never filled — a market open is IOC. */
|
||||
private adoptUnknownOpen(accountId: number, positions: VestPosition[], readAt: number): void {
|
||||
const sent = this.unknownOpens.get(accountId);
|
||||
if (!sent) return;
|
||||
const pos = unknownOpenFill(sent, positions);
|
||||
if (pos) {
|
||||
this.unknownOpens.delete(accountId);
|
||||
this.markOwn('opened', accountId, pos);
|
||||
const name = this.accountList.find((a) => a.id === accountId)?.name ?? String(accountId);
|
||||
console.warn(`${this.tag} ${name}: the open of unknown outcome filled after all — ${pos.side} ${pos.quantity} ${pos.symbol} (${pos.positionId}) marked as the bot's`);
|
||||
} else if (readAt > sent.until) {
|
||||
this.unknownOpens.delete(accountId);
|
||||
}
|
||||
}
|
||||
|
||||
private settleSuspects(): void {
|
||||
const now = Date.now();
|
||||
for (const [id, since] of this.suspectAccounts) {
|
||||
@@ -1505,14 +1646,23 @@ export class VestClient implements PlatformClient {
|
||||
|
||||
private async pickCandidate(root: string, symbols: string[], sticky: boolean, ctx?: PickContext): Promise<PlatformContract | null> {
|
||||
const firm = getCachedFirm(this.cfg.firmId);
|
||||
const targetHold = sizingHoldHours(firm);
|
||||
const targetHold = sizingHoldHours(firm, this.tradeDate(Date.now()));
|
||||
const specs = await this.symbolSpecs();
|
||||
const known = symbols.filter((s) => specs.has(s));
|
||||
if (known.length > 0) await this.refreshMarks(known);
|
||||
const vols = await this.volatility(known);
|
||||
const now = Date.now();
|
||||
// A leg a long closure (a weekend, a holiday) catches open can't be
|
||||
// exited until the market reopens, and meets the reopen's gap with
|
||||
// its stop: none starts under RESET_CLEAR_HOLDS holds of one — the
|
||||
// daily reset's clearance. The daily maintenance hour reopens before
|
||||
// the reset and is ridden, as futures legs ride CME's daily break.
|
||||
// Such a symbol stays on the board (the dashboard's candidates) but
|
||||
// isn't picked (legCloseNote); fireLeg holds each account's own leg
|
||||
// to it too.
|
||||
const hold = ctx?.targetHoldHours ?? targetHold;
|
||||
|
||||
const board: { symbol: string; score: number | null; note: string; contract?: PlatformContract }[] = [];
|
||||
const board: { symbol: string; score: number | null; note: string; contract?: PlatformContract; closing?: boolean }[] = [];
|
||||
// No new position this close to the reset: nothing picked, and the
|
||||
// last survey's candidates stay up for the dashboard.
|
||||
const toReset = nextVestResetMs(now) - now;
|
||||
@@ -1526,8 +1676,11 @@ export class VestClient implements PlatformClient {
|
||||
const mark = this.marks.get(symbol);
|
||||
const vol = vols.get(symbol);
|
||||
let hours: { open: boolean; closesAt: number | null };
|
||||
let gateAt: number | null;
|
||||
try {
|
||||
hours = marketOpen(await this.marketHours(spec.assetId), now);
|
||||
const periods = await this.marketHours(spec.assetId);
|
||||
hours = marketOpen(periods, now);
|
||||
gateAt = hours.closesAt !== null && longClosure(periods, hours.closesAt) ? hours.closesAt : null;
|
||||
} catch (err) {
|
||||
board.push({ symbol, score: null, note: `market hours unknown (${errorMessage(err)})` });
|
||||
continue;
|
||||
@@ -1551,12 +1704,14 @@ export class VestClient implements PlatformClient {
|
||||
volatilityPerHour: vol?.vol ?? null,
|
||||
});
|
||||
if (score === null) { board.push({ symbol, score: null, note: 'no volatility' }); continue; }
|
||||
const closing = legCloseNote(gateAt, hold, now);
|
||||
board.push({
|
||||
symbol,
|
||||
score,
|
||||
note: `fee ${(pct * 100).toFixed(2)}bp${vol?.vol ? `, σ ${(vol.vol * Math.sqrt(24) * 100).toFixed(2)}%/day` : ''}`
|
||||
+ (spec.marginRate ? `, ${+(1 / spec.marginRate).toFixed(1)}:1` : '')
|
||||
+ (hours.closesAt ? `, open ${((hours.closesAt - now) / 3_600_000).toFixed(1)}h more` : ''),
|
||||
+ (closing ? `, ${closing}` : hours.closesAt ? `, open ${((hours.closesAt - now) / 3_600_000).toFixed(1)}h more` : ''),
|
||||
closing: closing !== null,
|
||||
contract: {
|
||||
id: symbol,
|
||||
name: encodeContractName(symbol, step),
|
||||
@@ -1568,16 +1723,21 @@ export class VestClient implements PlatformClient {
|
||||
spreadFraction: spread,
|
||||
minContracts: 1,
|
||||
marginRate: spec.marginRate || undefined,
|
||||
closesAt: gateAt ?? undefined,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
let ranked = board.filter((b) => b.contract).sort((a, b) => a.score! - b.score!);
|
||||
let ranked = board.filter((b) => b.contract && !b.closing).sort((a, b) => a.score! - b.score!);
|
||||
if (ctx) {
|
||||
const sized = ranked.flatMap((b) => {
|
||||
const ev = ctx.evaluate(b.contract!);
|
||||
if (!ev) { b.note += ', can\'t size'; return []; }
|
||||
b.note += `, $${Math.round(ev.notional / 1000)}k → ${ev.holdHours.toFixed(1)}h, ~$${Math.round(ev.cost)}`;
|
||||
// Held short of the target hold (a leverage cap), the leg
|
||||
// runs longer: it has to clear the close as well.
|
||||
const closing = legCloseNote(b.contract!.closesAt, ev.holdHours, now);
|
||||
if (closing) { b.note += `, ${closing}`; return []; }
|
||||
return [{ b, holdHours: ev.holdHours, cost: ev.cost }];
|
||||
});
|
||||
ranked = rankForTarget(sized, ctx.targetHoldHours).map((i) => sized[i].b);
|
||||
@@ -1755,6 +1915,15 @@ export class VestClient implements PlatformClient {
|
||||
for (const w of this.fillWaiters.filter((x) => x.orderId === orderNumber)) w.callback(result);
|
||||
this.fillWaiters = this.fillWaiters.filter((x) => x.orderId !== orderNumber);
|
||||
return result;
|
||||
} catch (err) {
|
||||
// An open that may have gone in: no exits will go on it, so the
|
||||
// position it made, once a read shows it, is marked the bot's.
|
||||
if (opening && !isOrderNotPlaced(err)) {
|
||||
this.unknownOpens.set(accountId, {
|
||||
accountId: uuid, symbol, side, from: sentAt - UNKNOWN_OPEN_SLACK_MS, until: Date.now() + UNKNOWN_OPEN_SLACK_MS,
|
||||
});
|
||||
}
|
||||
throw err;
|
||||
} finally {
|
||||
this.pendingFills--;
|
||||
if (opening) {
|
||||
|
||||
+43
-7
@@ -433,6 +433,20 @@ export function awaitingLegs(p: VestPosition): VestLeg[] {
|
||||
return [...p.stopLosses, ...p.takeProfits].filter((l) => l.status === 'awaiting');
|
||||
}
|
||||
|
||||
/**
|
||||
* The position an open of unknown outcome (a timeout, a reset, a 5xx after
|
||||
* the send) made, once a read shows it: on its account, in its symbol and
|
||||
* side, opened between `from` and `until` — the send and the error, widened
|
||||
* for the gateway's clock. A market open is IOC, so a later one isn't it.
|
||||
*/
|
||||
export function unknownOpenFill(
|
||||
sent: { accountId: string; symbol: string; side: 'long' | 'short'; from: number; until: number },
|
||||
positions: VestPosition[],
|
||||
): VestPosition | null {
|
||||
return positions.find((p) => p.accountId === sent.accountId && p.symbol === sent.symbol && p.side === sent.side
|
||||
&& p.openedAt >= sent.from && p.openedAt <= sent.until) ?? null;
|
||||
}
|
||||
|
||||
export interface VestOpenOrder {
|
||||
orderId: string;
|
||||
accountId: string;
|
||||
@@ -706,7 +720,19 @@ export function hourlyVolatility(klines: unknown[]): number | null {
|
||||
*/
|
||||
export function marketOpen(periods: unknown, now: number): { open: boolean; closesAt: number | null } {
|
||||
if (!Array.isArray(periods) || periods.length === 0) return { open: true, closesAt: null };
|
||||
const list = periods.flatMap((p) => {
|
||||
const list = hoursPeriods(periods);
|
||||
const i = list.findIndex((p) => p.from <= now && now < p.to);
|
||||
if (i < 0 || !list[i].open) return { open: false, closesAt: null };
|
||||
// Consecutive open periods (overnight → pre-market → regular …) are one stretch.
|
||||
let end = list[i].to;
|
||||
for (let j = i + 1; j < list.length && list[j].open && list[j].from <= end + 1; j++) end = list[j].to;
|
||||
return { open: true, closesAt: end };
|
||||
}
|
||||
|
||||
/** The market-hours periods, read and in order; open = trading, with no
|
||||
* closure (see marketOpen). */
|
||||
function hoursPeriods(periods: unknown[]): { from: number; to: number; open: boolean }[] {
|
||||
return periods.flatMap((p) => {
|
||||
const r = p as {
|
||||
fromMs?: unknown; toMs?: unknown;
|
||||
state?: { tradingStatus?: unknown; closure?: unknown; price?: { allow?: unknown } };
|
||||
@@ -719,10 +745,20 @@ export function marketOpen(periods: unknown, now: number): { open: boolean; clos
|
||||
&& (closure === undefined || closure === 'unspecified');
|
||||
return [{ from, to, open }];
|
||||
}).sort((a, b) => a.from - b.from);
|
||||
const i = list.findIndex((p) => p.from <= now && now < p.to);
|
||||
if (i < 0 || !list[i].open) return { open: false, closesAt: null };
|
||||
// Consecutive open periods (overnight → pre-market → regular …) are one stretch.
|
||||
let end = list[i].to;
|
||||
for (let j = i + 1; j < list.length && list[j].open && list[j].from <= end + 1; j++) end = list[j].to;
|
||||
return { open: true, closesAt: end };
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the closure that starts at `closesAt` (marketOpen's) keeps the
|
||||
* market shut across one of Vest's 8 PM ET resets — a weekend, a holiday —
|
||||
* or for as far as the periods go. A position held into it can't be exited
|
||||
* or fitted to that reset until the market reopens, and meets the reopen's
|
||||
* gap with its stop; the daily maintenance hour reopens before the reset.
|
||||
* A close the periods don't show (they just end there) isn't one.
|
||||
*/
|
||||
export function longClosure(periods: unknown, closesAt: number): boolean {
|
||||
if (!Array.isArray(periods)) return false;
|
||||
const list = hoursPeriods(periods);
|
||||
if (!list.some((p) => p.to > closesAt)) return false;
|
||||
const reopensAt = list.find((p) => p.open && p.from >= closesAt)?.from;
|
||||
return reopensAt === undefined || nextVestResetMs(closesAt) < reopensAt;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user