Vest: a stale sync keeps the bot's fill, a cut-off open is still the bot's, and the day turns with the numbers
A sync whose positions read went out before the bot's own open or close finished no longer writes that account's positions back (ownOrderSeq, as claimSeq guards balances): the record a flatten goes by stays, so a read lagging the fill still gives FLATTEN FAILED, not "nothing to flatten". An open is noted in account_meta before its POST and dropped once its outcome is known. After a restart the first sync takes the note up as an open of unknown outcome, so the position it made is marked the bot's and guardClose sees it. Such an open is matched by the position id its answer named, else only to a position with no exit legs opened between the send and a few seconds past the error (was two minutes): an outside copy-trader's open half a minute on isn't taken for the bot's, and several matches adopt none, loudly. VestClient.tradeDate follows the last sync's numbers: past 8 PM ET the day turns once a sync has worked out the fresh day's realized P&L, so the engine, reporter and dashboard never pair the new day with the ended day's numbers. A stalled sync holds the day back only while isClientReady still trades on it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Brandon Li
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
ab588adbac
commit
032ba1ca9c
+235
-10
@@ -1,6 +1,8 @@
|
||||
// Checks for the Vest client's own wiring (lib/vest-class.ts), past what its
|
||||
// pure helpers show: the market-close guard closing a leg whose open came back
|
||||
// unknown, and the candidate board keeping a symbol the close gate holds back.
|
||||
// unknown, and the candidate board keeping a symbol the close gate holds back;
|
||||
// a sync older than the bot's own fill, an open a restart cut off, an outside
|
||||
// trade beside an open of unknown outcome, and the client's day at 8 PM ET.
|
||||
//
|
||||
// npm run check
|
||||
//
|
||||
@@ -49,9 +51,11 @@ VestClient.prototype.request = async function (bucket, method, path, opts = {})
|
||||
return gateway(method, path, opts);
|
||||
};
|
||||
const { putVestSession } = await import('../lib/vest-session.ts');
|
||||
const { botOpenedPositions } = await import('../lib/db.ts');
|
||||
const { vestDayOf, VEST_STATUS_ACTIVE } = await import('../lib/vest-helpers.ts');
|
||||
const { botOpenedPositions, loadAccountMeta, saveAccountMeta } = await import('../lib/db.ts');
|
||||
const { vestDayOf, vestAccountId, VestApiError, VEST_STATUS_ACTIVE } = await import('../lib/vest-helpers.ts');
|
||||
const { encodeContractName } = await import('../lib/dxtrade-helpers.ts');
|
||||
const { tradeDateFor } = await import('../lib/trading-logic.ts');
|
||||
const { isClientReady } = await import('../lib/platform-client.ts');
|
||||
|
||||
const iso = (s) => Date.parse(s);
|
||||
const WALLET = '0x7ce10771819f80130e204ddb5ca1522e48a9b451';
|
||||
@@ -84,8 +88,9 @@ const spec = (symbol, assetId) => ({
|
||||
});
|
||||
const specs = new Map([['NDX-USD', spec('NDX-USD', 7)], ['BTC-PERP', spec('BTC-PERP', 9)]]);
|
||||
|
||||
/** A client with no sync running, its gateway answered by `answer`. */
|
||||
function testClient(answer) {
|
||||
/** A client with no sync running, its gateway answered by `answer`, holding
|
||||
* acc-1 and acc-2 under `ids` (the ids a sync gives them: A and B). */
|
||||
function testClient(answer, ids = [1, 2]) {
|
||||
gateway = null;
|
||||
const client = new VestClient({ firmId: 'vest-test', firmName: 'Vest test', wallet: WALLET }, async () => {});
|
||||
clearInterval(client.syncInterval);
|
||||
@@ -94,14 +99,58 @@ function testClient(answer) {
|
||||
client.specs = specs;
|
||||
client.symbolSpecs = async () => specs;
|
||||
client.marketHours = async (assetId) => (assetId === 7 ? week : []);
|
||||
client.accountList = [{ id: 1, name: 'V50K-F-D3-1', active: true }, { id: 2, name: 'V50K-F-D3-2', active: true }];
|
||||
client.uuidById.set(1, 'acc-1');
|
||||
client.uuidById.set(2, 'acc-2');
|
||||
client.capital.set(1, { status: VEST_STATUS_ACTIVE });
|
||||
client.capital.set(2, { status: VEST_STATUS_ACTIVE });
|
||||
client.accountList = ids.map((id, i) => ({ id, name: `V50K-F-D3-${i + 1}`, active: true }));
|
||||
ids.forEach((id, i) => {
|
||||
client.uuidById.set(id, `acc-${i + 1}`);
|
||||
client.capital.set(id, { status: VEST_STATUS_ACTIVE });
|
||||
});
|
||||
return client;
|
||||
}
|
||||
|
||||
const A = vestAccountId('acc-1');
|
||||
const B = vestAccountId('acc-2');
|
||||
const NDX = encodeContractName('NDX-USD', 0.001);
|
||||
const rawPosition = (positionId, accountId, openDate, extra = {}) => ({
|
||||
positionId, accountId, symbol: 'NDX-USD', side: 'LONG', quantity: '0.500', openPrice: '20000', collateral: '500', leverage: '20', openDate,
|
||||
stopLosses: [], takeProfits: [], ...extra,
|
||||
});
|
||||
|
||||
/** What a sync reads (acc-1 and acc-2 funded, $50k each, and the login's
|
||||
* main account; `positions` open), and the history reads after it. */
|
||||
function syncReads(method, path, positions) {
|
||||
if (method !== 'GET') return null;
|
||||
if (path === '/v3/capital/accounts/active') {
|
||||
return { data: { accounts: ['acc-1', 'acc-2'].map((id, i) => ({
|
||||
id, status: VEST_STATUS_ACTIVE, attempt_index: i + 1, initial_capital: '50000', max_daily_loss_pct: '0.03', stage: 1, stages: [{ ordinal: 1, kind: 'funded' }],
|
||||
})) } };
|
||||
}
|
||||
if (path === '/v3/accounts') {
|
||||
return { data: { accounts: [
|
||||
{ account_id: 'acc-1', amount: '50000', account_type: 2 }, { account_id: 'acc-2', amount: '50000', account_type: 2 }, { account_id: 'main', amount: '0', account_type: 1 },
|
||||
] } };
|
||||
}
|
||||
if (path === '/v3/positions/opened') return { data: { positions } };
|
||||
if (path === '/v3/positions/opened-orders') return { data: { orders: [] } };
|
||||
if (path === '/v3/ticker/latest') return { data: { tickers: [] } };
|
||||
if (path === '/v3/positions') return { data: { positions: [] } };
|
||||
return null;
|
||||
}
|
||||
|
||||
/** testClient on the ids a sync gives, once the constructor's own sync
|
||||
* (which reaches no gateway) is over, with its history taken as read — so
|
||||
* each requestSync here is one good sync, and starts nothing else. */
|
||||
async function syncingClient(answer) {
|
||||
const client = testClient(answer, [A, B]);
|
||||
await client.syncRunning;
|
||||
client.historyLoaded = true;
|
||||
client.historyLoadedIds = new Set([A, B]);
|
||||
client.lastDaysFetchStartedAt = Date.now();
|
||||
client.lastDaysFetchSucceededAt = Infinity;
|
||||
return client;
|
||||
}
|
||||
|
||||
const unanswered = (method, path) => { throw new Error(`no gateway in this test: ${method} ${path}`); };
|
||||
|
||||
test('the market-close guard closes a bot leg whose open came back unknown, not a hand trade', async () => {
|
||||
let positions = [];
|
||||
const closes = [];
|
||||
@@ -171,3 +220,179 @@ test('a symbol the close gate holds back stays on the board, and isn\'t picked;
|
||||
client.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
test("a sync whose positions read predates the bot's own fill leaves the fill's record alone", async () => {
|
||||
let positions = [];
|
||||
let holdRead = false;
|
||||
let releaseRead = null;
|
||||
clockAt('2026-10-28T14:00:00Z');
|
||||
const client = await syncingClient((method, path) => {
|
||||
if (method === 'GET' && path === '/v3/positions/opened' && holdRead) {
|
||||
// Read now, flat — answered once released.
|
||||
holdRead = false;
|
||||
const served = positions;
|
||||
return new Promise((resolve) => { releaseRead = () => resolve({ data: { positions: served } }); });
|
||||
}
|
||||
const read = syncReads(method, path, positions);
|
||||
if (read) return read;
|
||||
if (method === 'POST' && path === '/v3/positions/open') {
|
||||
positions = [rawPosition('9101', 'acc-1', Date.now() + 300)];
|
||||
return { data: { orderId: 'o-9101', positionId: '9101' } };
|
||||
}
|
||||
return unanswered(method, path);
|
||||
});
|
||||
try {
|
||||
await client.requestSync();
|
||||
// A sync reads acc-1 flat; the entry fills while it is still out.
|
||||
holdRead = true;
|
||||
const sync = client.requestSync();
|
||||
await client.sendOrder(A, NDX, 500, 'Buy', 'Market', undefined, 'open');
|
||||
// Filled: the note kept against a restart goes.
|
||||
assert.equal(loadAccountMeta(A, 'vest_pending_open'), 'null');
|
||||
releaseRead();
|
||||
await sync;
|
||||
assert.deepEqual(client.positionsDetail.get(A).map((p) => p.positionId), ['9101']);
|
||||
assert.equal(client.positions[A].netPos, 0.5);
|
||||
// A read lagging the fill: the leg's flatten is refused as a position
|
||||
// still out there (FLATTEN FAILED), not taken as nothing to flatten.
|
||||
positions = [];
|
||||
await assert.rejects(client.sendOrder(A, NDX, 500, 'Sell', 'Market', undefined, 'close'), /last saw a long one open/);
|
||||
// A sync that went out after the fill writes what it reads.
|
||||
await client.requestSync();
|
||||
assert.deepEqual(client.positionsDetail.get(A), []);
|
||||
assert.equal(client.positions[A], undefined);
|
||||
} finally {
|
||||
client.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
test("an open a restart cut off is marked the bot's once a read after the restart shows it", async () => {
|
||||
let positions = [];
|
||||
let posted;
|
||||
const postedAt = new Promise((resolve) => { posted = resolve; });
|
||||
clockAt('2026-10-28T15:00:00Z');
|
||||
const before = await syncingClient((method, path) => {
|
||||
const read = syncReads(method, path, positions);
|
||||
if (read) return read;
|
||||
// The app stops with the open out.
|
||||
if (method === 'POST' && path === '/v3/positions/open') { posted(Date.now()); return new Promise(() => {}); }
|
||||
return unanswered(method, path);
|
||||
});
|
||||
void before.sendOrder(A, NDX, 500, 'Buy', 'Market', undefined, 'open').catch(() => {});
|
||||
const sentAt = await postedAt;
|
||||
before.disconnect();
|
||||
|
||||
// Vest filled it, and an outside long opened on acc-2 with it. acc-2 has
|
||||
// an older note, of a short that never showed.
|
||||
positions = [rawPosition('9201', 'acc-1', sentAt + 400), rawPosition('9202', 'acc-2', sentAt + 400)];
|
||||
saveAccountMeta(B, 'vest_pending_open', JSON.stringify({ accountId: 'acc-2', symbol: 'NDX-USD', side: 'short', sentAt: sentAt - 10 * 60_000 }));
|
||||
clockAt('2026-10-28T15:02:00Z');
|
||||
let refuse = false;
|
||||
const after = await syncingClient((method, path) => {
|
||||
const read = syncReads(method, path, positions);
|
||||
if (read) return read;
|
||||
if (method === 'POST' && path === '/v3/positions/open' && refuse) throw new VestApiError('/v3/positions/open: refused (HTTP 400)', 400, 'REFUSED');
|
||||
return unanswered(method, path);
|
||||
});
|
||||
try {
|
||||
await after.requestSync();
|
||||
assert.deepEqual([...botOpenedPositions(['9201', '9202'])], ['9201']);
|
||||
assert.equal(loadAccountMeta(A, 'vest_pending_open'), 'null');
|
||||
assert.equal(loadAccountMeta(B, 'vest_pending_open'), 'null');
|
||||
// An open Vest refuses leaves no note behind.
|
||||
positions = [];
|
||||
refuse = true;
|
||||
await assert.rejects(after.sendOrder(A, NDX, 500, 'Buy', 'Market', undefined, 'open'), /refused/);
|
||||
assert.equal(loadAccountMeta(A, 'vest_pending_open'), 'null');
|
||||
} finally {
|
||||
after.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
test("an open of unknown outcome isn't matched to an outside trade after its error, nor to one of several", async () => {
|
||||
let positions = [];
|
||||
let open = null;
|
||||
let onRead = () => {};
|
||||
clockAt('2026-10-28T16:00:00Z');
|
||||
const client = await syncingClient((method, path) => {
|
||||
if (method === 'GET' && path === '/v3/positions/opened') onRead();
|
||||
const read = syncReads(method, path, positions);
|
||||
if (read) return read;
|
||||
if (method === 'POST' && path === '/v3/positions/open') return open();
|
||||
return unanswered(method, path);
|
||||
});
|
||||
try {
|
||||
await client.requestSync();
|
||||
// The entry's send fails in transit, and it never went in. Half a
|
||||
// minute on, an outside copy-trader opens NDX long on every account.
|
||||
open = () => { throw new Error('socket hang up'); };
|
||||
await assert.rejects(client.sendOrder(A, NDX, 500, 'Buy', 'Market', undefined, 'open'), /outcome unknown/);
|
||||
const errorAt = Date.now();
|
||||
positions = [rawPosition('9301', 'acc-1', errorAt + 30_000), rawPosition('9302', 'acc-2', errorAt + 30_000)];
|
||||
clockAt('2026-10-28T16:01:00Z');
|
||||
await client.requestSync();
|
||||
assert.deepEqual([...botOpenedPositions(['9301', '9302'])], []);
|
||||
assert.equal(loadAccountMeta(A, 'vest_pending_open'), 'null');
|
||||
|
||||
// Another on acc-2, and two positions show from that moment: either
|
||||
// could be the bot's, so neither is marked.
|
||||
positions = [];
|
||||
clockAt('2026-10-28T16:05:00Z');
|
||||
open = () => {
|
||||
positions = [rawPosition('9303', 'acc-2', Date.now() + 100), rawPosition('9304', 'acc-2', Date.now() + 150)];
|
||||
throw new Error('socket hang up');
|
||||
};
|
||||
await assert.rejects(client.sendOrder(B, NDX, 500, 'Buy', 'Market', undefined, 'open'), /outcome unknown/);
|
||||
await client.requestSync();
|
||||
assert.deepEqual([...botOpenedPositions(['9303', '9304'])], []);
|
||||
|
||||
// An open whose answer named its position, though no read showed it
|
||||
// within the wait: that position is the bot's, even with a stop a
|
||||
// hand has put on it since.
|
||||
positions = [];
|
||||
clockAt('2026-10-28T16:10:00Z');
|
||||
let answered = false;
|
||||
open = () => { answered = true; return { data: { orderId: 'o-9305', positionId: '9305' } }; };
|
||||
// The wait's first read comes back past its deadline.
|
||||
onRead = () => { if (answered) { answered = false; clockAt('2026-10-28T16:10:45Z'); } };
|
||||
await assert.rejects(client.sendOrder(A, NDX, 500, 'Buy', 'Market', undefined, 'open'), /not seen filled/);
|
||||
const stop = { id: 'sl-9305', triggerPrice: '19900', executionType: 'market', status: 'awaiting' };
|
||||
positions = [rawPosition('9305', 'acc-1', iso('2026-10-28T16:10:00Z') + 500, { stopLosses: [stop] })];
|
||||
await client.requestSync();
|
||||
assert.deepEqual([...botOpenedPositions(['9305'])], ['9305']);
|
||||
} finally {
|
||||
client.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
test("the client's Vest day turns with its numbers, and a sync that stalls stops the trading it holds back", async () => {
|
||||
clockAt('2026-10-27T23:58:00Z');
|
||||
const client = await syncingClient((method, path) => syncReads(method, path, []) ?? unanswered(method, path));
|
||||
// The day the engine plans the lane on, at this test's clock.
|
||||
const engineDay = () => tradeDateFor(client, new Date(Date.now()));
|
||||
try {
|
||||
// 7:58 PM ET, before any sync: the day now.
|
||||
assert.equal(engineDay(), '2026-10-27');
|
||||
await client.requestSync();
|
||||
// 8:00:20 PM ET: Vest's day has turned, but the numbers the last sync
|
||||
// worked out are still the ended day's — and so is the engine's day.
|
||||
clockAt('2026-10-28T00:00:20Z');
|
||||
assert.equal(vestDayOf(Date.now()), '2026-10-28');
|
||||
assert.equal(engineDay(), '2026-10-27');
|
||||
assert.equal(isClientReady(client), true);
|
||||
await client.requestSync();
|
||||
assert.equal(engineDay(), '2026-10-28');
|
||||
// No sync after the next reset: the day holds back only while the
|
||||
// scheduler still trades on the last sync's numbers.
|
||||
clockAt('2026-10-28T23:59:00Z');
|
||||
await client.requestSync();
|
||||
clockAt('2026-10-29T00:03:00Z');
|
||||
assert.equal(engineDay(), '2026-10-28');
|
||||
assert.equal(isClientReady(client), true);
|
||||
clockAt('2026-10-29T00:05:00Z');
|
||||
assert.equal(engineDay(), '2026-10-28');
|
||||
assert.equal(isClientReady(client), false);
|
||||
} finally {
|
||||
client.disconnect();
|
||||
}
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user