DXtrade platform for Tradeify247: percent fees, hard daily-loss stops, volatility sizing, every-day lanes

- DXtrade client (lib/dxtrade-class.ts): REST session login with lockout-safe
  backoff, 60s sync of accounts/metrics/positions/orders/transfers, history and
  fund transactions from cash transactions, day-start balance at the 22:00 UTC
  reset, CLOSE-by-positionCode exits (native OCO group, else a stop-first
  emulated pair), a cross-account hedge guard, stray-order reaper.
- Instrument selector: the firm's symbol map lists candidate symbols per CME
  root; the cheapest tradable one per unit of recent hourly volatility wins
  (spread + 2x commission [+ financing] / sigma).
- Fees: a firm's commission % of notional prices every fee off the fill; the
  take-profit is solved in closed form so the leg nets its target.
- Hard daily loss limit per account type: every leg carries a stop keeping the
  firm's day inside the limit less a 10% reserve and both fees (rounded in);
  a green day never widens it; no room or a refused bracket flattens.
- Notional sizing where the platform prices positions: target-hold volatility
  sizing or the symbol map's fixed notional, under a per-type notional cap.
- Every-day firms trade weekends/holidays; the scheduler runs lanes (futures,
  one per DXtrade firm) with their own hours, flat gate, mutex and batches.
- The catalog sync skips platforms this build doesn't know instead of treating
  them as Tradovate. One shared fireLeg replaces the duplicated batch/copy code.
- npm run check: fee/stop/sizing/hours/selector checks; scripts/dxtrade-smoke.mjs
  confirms the API against a real login before trading.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

lib/platform-client.ts

@@ -4,11 +4,14 @@
  * reporter, state route and resolver can drive either platform without caring
  * which is behind the map entry.
  *
- * Contract ids are `number` on Tradovate and `string` (e.g.
- * "CON.F.US.ENQ.Z25") on TopstepX — everything that compares them only ever
- * compares within one client, so the union is safe.
+ * Contract ids are `number` on Tradovate and `string` on TopstepX (e.g.
+ * "CON.F.US.ENQ.Z25") and DXTrade (the symbol, e.g. "BTC/USD") — everything
+ * that compares them only ever compares within one client, so the union is
+ * safe.
  */
 
+import type { FirmPlatform } from './master-protocol';
+
 export interface PlatformAccount {
     id: number;
     name: string;
@@ -19,14 +22,33 @@ export interface PlatformContract {
     id: number | string;
     name: string;
     tickSize: number;
+    /** Dollars per 1.0 of price per engine contract. Absent = the CME
+     *  product's POINT_VALUES entry (futures). */
+    pointValue?: number;
+    /** Commission as % of notional per side, where the firm charges that way. */
+    commissionPct?: number;
+    /** Notional of one engine contract at the current mid — present where the
+     *  platform prices positions, which is what enables notional sizing. */
+    stepNotional?: number;
+    /** Fixed sizing: notional per $1,000 of leg (the symbol map's setting). */
+    fixedNotional?: number;
+    /** σ of log returns per √hour, from recent candles. */
+    volatilityPerHour?: number;
+    /** (ask − bid) / mid when the contract was picked. */
+    spreadFraction?: number;
+    /** Largest order the broker takes, in engine contracts. */
+    maxContracts?: number;
+    /** Smallest order the broker takes, in engine contracts. */
+    minContracts?: number;
 }
 
 export interface PlatformClient {
     accountList: PlatformAccount[];
     /** realizedPnL is today's. pendingRoll (Tradovate): the broker still shows
      *  the ended day's record and today's share of it can't be told apart —
-     *  the account waits for the broker to roll it. */
-    accountCashBalances: { [accountId: number]: { amount: number; realizedPnL: number; pendingRoll?: boolean } };
+     *  the account waits for the broker to roll it. equity: balance plus open
+     *  P&L, where the platform reports it. */
+    accountCashBalances: { [accountId: number]: { amount: number; realizedPnL: number; pendingRoll?: boolean; equity?: number } };
     positions: {
         [accountId: number]: {
             contractId: number | string;
@@ -69,6 +91,15 @@ export interface PlatformClient {
      * read as a fresh stage-1 cycle, so such an account must not trade.
      */
     historyReady(accountId: number): boolean;
+    /**
+     * The account's closed balance at the firm's last daily reset — what a
+     * hard daily loss limit is measured from. Only platforms that know the
+     * firm's own day implement it (DXTrade: 22:00 UTC); the rest leave it out
+     * and the engine falls back to the session's realized P&L. null = the
+     * platform knows it but can't tell yet (history not fetched): hold the
+     * account rather than size a stop on a guess.
+     */
+    dayStartBalance?(accountId: number): number | null;
     /** Drop the account's history from memory (the wipe routes), so it reads
      *  unloaded until the next fetch rebuilds it. */
     forgetHistory(accountId: number, accountName: string): void;
@@ -113,10 +144,11 @@ export interface PlatformClient {
  * Timestamps are epoch ms, 0 = never. Never carries tokens or credentials.
  */
 export interface ClientHealth {
-    platform: 'tradovate' | 'topstepx';
+    platform: FirmPlatform;
     /** Holding a session token right now. */
     authenticated: boolean;
-    /** Tradovate: socket readyState name; TopstepX: hub state. 'none' = no transport. */
+    /** Tradovate: socket readyState name; TopstepX: hub state; DXTrade: 'rest'
+     *  or its push socket's state. 'none' = no transport. */
     transport: string;
     syncComplete: boolean;
     lastSyncAt: number;