380 lines
12 KiB
JavaScript
380 lines
12 KiB
JavaScript
import process from 'node:process';
|
|
import { setTimeout as sleep } from 'node:timers/promises';
|
|
|
|
function getIsoNow() {
|
|
return new Date().toISOString();
|
|
}
|
|
|
|
function clampInt(value, min, max, fallback) {
|
|
const n = Number.parseInt(String(value ?? ''), 10);
|
|
if (!Number.isInteger(n)) return fallback;
|
|
return Math.min(max, Math.max(min, n));
|
|
}
|
|
|
|
function envList(name, fallbackCsv) {
|
|
const raw = process.env[name] ?? fallbackCsv;
|
|
return String(raw)
|
|
.split(',')
|
|
.map((s) => s.trim())
|
|
.filter(Boolean);
|
|
}
|
|
|
|
function envIntList(name, fallbackCsv) {
|
|
const out = [];
|
|
for (const item of envList(name, fallbackCsv)) {
|
|
const n = Number.parseInt(item, 10);
|
|
if (!Number.isFinite(n)) continue;
|
|
out.push(n);
|
|
}
|
|
return out.length ? out : envList(name, fallbackCsv).map((v) => Number.parseInt(v, 10)).filter(Number.isFinite);
|
|
}
|
|
|
|
function toNumberOrNull(value) {
|
|
if (value == null) return null;
|
|
if (typeof value === 'number') return Number.isFinite(value) ? value : null;
|
|
if (typeof value === 'string') {
|
|
const s = value.trim();
|
|
if (!s) return null;
|
|
const n = Number(s);
|
|
return Number.isFinite(n) ? n : null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function numStr(value) {
|
|
if (value == null) return null;
|
|
if (typeof value === 'number') return Number.isFinite(value) ? String(value) : null;
|
|
if (typeof value === 'string') return value.trim() || null;
|
|
return null;
|
|
}
|
|
|
|
function jsonNormalize(value) {
|
|
if (typeof value !== 'string') return value;
|
|
const s = value.trim();
|
|
if (!s) return null;
|
|
try {
|
|
return JSON.parse(s);
|
|
} catch {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
function resolveConfig() {
|
|
const hasuraUrl = process.env.HASURA_GRAPHQL_URL || 'http://hasura:8080/v1/graphql';
|
|
const hasuraAdminSecret = process.env.HASURA_ADMIN_SECRET || process.env.HASURA_GRAPHQL_ADMIN_SECRET || undefined;
|
|
const hasuraAuthToken = process.env.HASURA_AUTH_TOKEN || process.env.HASURA_JWT || undefined;
|
|
|
|
const markets = envList('DLOB_MARKETS', 'PUMP-PERP,SOL-PERP,1MBONK-PERP,BTC-PERP,ETH-PERP');
|
|
const pollMs = clampInt(process.env.DLOB_POLL_MS, 250, 60_000, 1000);
|
|
const sizesUsd = envIntList('DLOB_SLIPPAGE_SIZES_USD', '100,500,1000,5000,10000,50000');
|
|
|
|
const pricePrecision = Number(process.env.PRICE_PRECISION || 1_000_000);
|
|
const basePrecision = Number(process.env.BASE_PRECISION || 1_000_000_000);
|
|
if (!Number.isFinite(pricePrecision) || pricePrecision <= 0)
|
|
throw new Error(`Invalid PRICE_PRECISION: ${process.env.PRICE_PRECISION}`);
|
|
if (!Number.isFinite(basePrecision) || basePrecision <= 0)
|
|
throw new Error(`Invalid BASE_PRECISION: ${process.env.BASE_PRECISION}`);
|
|
|
|
return {
|
|
hasuraUrl,
|
|
hasuraAdminSecret,
|
|
hasuraAuthToken,
|
|
markets,
|
|
pollMs,
|
|
sizesUsd,
|
|
pricePrecision,
|
|
basePrecision,
|
|
};
|
|
}
|
|
|
|
async function graphqlRequest(cfg, query, variables) {
|
|
const headers = { 'content-type': 'application/json' };
|
|
if (cfg.hasuraAuthToken) {
|
|
headers.authorization = `Bearer ${cfg.hasuraAuthToken}`;
|
|
} else if (cfg.hasuraAdminSecret) {
|
|
headers['x-hasura-admin-secret'] = cfg.hasuraAdminSecret;
|
|
} else {
|
|
throw new Error('Missing Hasura auth (set HASURA_AUTH_TOKEN or HASURA_ADMIN_SECRET)');
|
|
}
|
|
|
|
const res = await fetch(cfg.hasuraUrl, {
|
|
method: 'POST',
|
|
headers,
|
|
body: JSON.stringify({ query, variables }),
|
|
signal: AbortSignal.timeout(10_000),
|
|
});
|
|
const text = await res.text();
|
|
if (!res.ok) throw new Error(`Hasura HTTP ${res.status}: ${text}`);
|
|
const json = JSON.parse(text);
|
|
if (json.errors?.length) throw new Error(json.errors.map((e) => e.message).join(' | '));
|
|
return json.data;
|
|
}
|
|
|
|
function parseLevels(raw, pricePrecision, basePrecision, side) {
|
|
const v = jsonNormalize(raw);
|
|
if (!Array.isArray(v)) return [];
|
|
|
|
const out = [];
|
|
for (const item of v) {
|
|
const priceInt = toNumberOrNull(item?.price);
|
|
const sizeInt = toNumberOrNull(item?.size);
|
|
if (priceInt == null || sizeInt == null) continue;
|
|
const price = priceInt / pricePrecision;
|
|
const size = sizeInt / basePrecision;
|
|
if (!Number.isFinite(price) || !Number.isFinite(size)) continue;
|
|
out.push({ price, size });
|
|
}
|
|
|
|
if (side === 'bid') out.sort((a, b) => b.price - a.price);
|
|
if (side === 'ask') out.sort((a, b) => a.price - b.price);
|
|
return out;
|
|
}
|
|
|
|
function computeMid(bestBid, bestAsk, markPrice, oraclePrice) {
|
|
if (bestBid != null && bestAsk != null) return (bestBid + bestAsk) / 2;
|
|
if (markPrice != null) return markPrice;
|
|
if (oraclePrice != null) return oraclePrice;
|
|
return null;
|
|
}
|
|
|
|
function simulateBuy(asks, mid, sizeUsd) {
|
|
let remainingUsd = sizeUsd;
|
|
let filledUsd = 0;
|
|
let filledBase = 0;
|
|
let worstPrice = null;
|
|
let levelsConsumed = 0;
|
|
|
|
for (const lvl of asks) {
|
|
if (!(remainingUsd > 0)) break;
|
|
if (!(lvl.price > 0) || !(lvl.size > 0)) continue;
|
|
|
|
const maxBase = remainingUsd / lvl.price;
|
|
const takeBase = Math.min(lvl.size, maxBase);
|
|
if (!(takeBase > 0)) continue;
|
|
|
|
const cost = takeBase * lvl.price;
|
|
filledUsd += cost;
|
|
filledBase += takeBase;
|
|
remainingUsd -= cost;
|
|
worstPrice = lvl.price;
|
|
levelsConsumed += 1;
|
|
}
|
|
|
|
const vwap = filledBase > 0 ? filledUsd / filledBase : null;
|
|
const impactBps = vwap != null && mid != null && mid > 0 ? (vwap / mid - 1) * 10_000 : null;
|
|
const fillPct = sizeUsd > 0 ? filledUsd / sizeUsd : null;
|
|
|
|
return { vwap, worstPrice, filledUsd, filledBase, impactBps, levelsConsumed, fillPct };
|
|
}
|
|
|
|
function simulateSell(bids, mid, sizeUsd) {
|
|
if (mid == null || !(mid > 0)) {
|
|
return { vwap: null, worstPrice: null, filledUsd: 0, filledBase: 0, impactBps: null, levelsConsumed: 0, fillPct: null };
|
|
}
|
|
|
|
const baseTarget = sizeUsd / mid;
|
|
let remainingBase = baseTarget;
|
|
let proceedsUsd = 0;
|
|
let filledBase = 0;
|
|
let worstPrice = null;
|
|
let levelsConsumed = 0;
|
|
|
|
for (const lvl of bids) {
|
|
if (!(remainingBase > 0)) break;
|
|
if (!(lvl.price > 0) || !(lvl.size > 0)) continue;
|
|
|
|
const takeBase = Math.min(lvl.size, remainingBase);
|
|
if (!(takeBase > 0)) continue;
|
|
|
|
const proceeds = takeBase * lvl.price;
|
|
proceedsUsd += proceeds;
|
|
filledBase += takeBase;
|
|
remainingBase -= takeBase;
|
|
worstPrice = lvl.price;
|
|
levelsConsumed += 1;
|
|
}
|
|
|
|
const vwap = filledBase > 0 ? proceedsUsd / filledBase : null;
|
|
const impactBps = vwap != null && mid > 0 ? (1 - vwap / mid) * 10_000 : null;
|
|
const fillPct = baseTarget > 0 ? filledBase / baseTarget : null;
|
|
|
|
return { vwap, worstPrice, filledUsd: proceedsUsd, filledBase, impactBps, levelsConsumed, fillPct };
|
|
}
|
|
|
|
async function fetchL2Latest(cfg) {
|
|
const query = `
|
|
query DlobL2Latest($markets: [String!]!) {
|
|
dlob_l2_latest(where: {market_name: {_in: $markets}}) {
|
|
market_name
|
|
market_type
|
|
market_index
|
|
ts
|
|
slot
|
|
mark_price
|
|
oracle_price
|
|
best_bid_price
|
|
best_ask_price
|
|
bids
|
|
asks
|
|
updated_at
|
|
}
|
|
}
|
|
`;
|
|
const data = await graphqlRequest(cfg, query, { markets: cfg.markets });
|
|
return Array.isArray(data?.dlob_l2_latest) ? data.dlob_l2_latest : [];
|
|
}
|
|
|
|
async function upsertSlippage(cfg, rows) {
|
|
if (!rows.length) return;
|
|
const mutation = `
|
|
mutation UpsertDlobSlippage($rows: [dlob_slippage_latest_insert_input!]!) {
|
|
insert_dlob_slippage_latest(
|
|
objects: $rows
|
|
on_conflict: {
|
|
constraint: dlob_slippage_latest_pkey
|
|
update_columns: [
|
|
market_type
|
|
market_index
|
|
ts
|
|
slot
|
|
mid_price
|
|
best_bid_price
|
|
best_ask_price
|
|
vwap_price
|
|
worst_price
|
|
filled_usd
|
|
filled_base
|
|
impact_bps
|
|
levels_consumed
|
|
fill_pct
|
|
raw
|
|
updated_at
|
|
]
|
|
}
|
|
) { affected_rows }
|
|
}
|
|
`;
|
|
await graphqlRequest(cfg, mutation, { rows });
|
|
}
|
|
|
|
async function main() {
|
|
const cfg = resolveConfig();
|
|
const lastUpdatedAtByMarket = new Map();
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
service: 'dlob-slippage-worker',
|
|
startedAt: getIsoNow(),
|
|
hasuraUrl: cfg.hasuraUrl,
|
|
hasuraAuth: cfg.hasuraAuthToken ? 'bearer' : cfg.hasuraAdminSecret ? 'admin-secret' : 'none',
|
|
markets: cfg.markets,
|
|
pollMs: cfg.pollMs,
|
|
sizesUsd: cfg.sizesUsd,
|
|
pricePrecision: cfg.pricePrecision,
|
|
basePrecision: cfg.basePrecision,
|
|
},
|
|
null,
|
|
2
|
|
)
|
|
);
|
|
|
|
while (true) {
|
|
const rows = [];
|
|
|
|
try {
|
|
const l2Rows = await fetchL2Latest(cfg);
|
|
for (const l2 of l2Rows) {
|
|
const market = String(l2.market_name || '').trim();
|
|
if (!market) continue;
|
|
|
|
const updatedAt = l2.updated_at || null;
|
|
if (updatedAt && lastUpdatedAtByMarket.get(market) === updatedAt) continue;
|
|
if (updatedAt) lastUpdatedAtByMarket.set(market, updatedAt);
|
|
|
|
const bestBid = toNumberOrNull(l2.best_bid_price);
|
|
const bestAsk = toNumberOrNull(l2.best_ask_price);
|
|
const markPrice = toNumberOrNull(l2.mark_price);
|
|
const oraclePrice = toNumberOrNull(l2.oracle_price);
|
|
const mid = computeMid(bestBid, bestAsk, markPrice, oraclePrice);
|
|
|
|
const bids = parseLevels(l2.bids, cfg.pricePrecision, cfg.basePrecision, 'bid');
|
|
const asks = parseLevels(l2.asks, cfg.pricePrecision, cfg.basePrecision, 'ask');
|
|
|
|
for (const sizeUsd of cfg.sizesUsd) {
|
|
const buy = simulateBuy(asks, mid, sizeUsd);
|
|
rows.push({
|
|
market_name: market,
|
|
side: 'buy',
|
|
size_usd: sizeUsd,
|
|
market_type: l2.market_type ? String(l2.market_type) : 'perp',
|
|
market_index: typeof l2.market_index === 'number' ? l2.market_index : null,
|
|
ts: l2.ts == null ? null : String(l2.ts),
|
|
slot: l2.slot == null ? null : String(l2.slot),
|
|
mid_price: numStr(mid),
|
|
best_bid_price: numStr(bestBid),
|
|
best_ask_price: numStr(bestAsk),
|
|
vwap_price: numStr(buy.vwap),
|
|
worst_price: numStr(buy.worstPrice),
|
|
filled_usd: numStr(buy.filledUsd),
|
|
filled_base: numStr(buy.filledBase),
|
|
impact_bps: numStr(buy.impactBps),
|
|
levels_consumed: buy.levelsConsumed,
|
|
fill_pct: numStr(buy.fillPct),
|
|
raw: {
|
|
ref: 'mid',
|
|
units: 'usd',
|
|
pricePrecision: cfg.pricePrecision,
|
|
basePrecision: cfg.basePrecision,
|
|
},
|
|
updated_at: updatedAt,
|
|
});
|
|
|
|
const sell = simulateSell(bids, mid, sizeUsd);
|
|
rows.push({
|
|
market_name: market,
|
|
side: 'sell',
|
|
size_usd: sizeUsd,
|
|
market_type: l2.market_type ? String(l2.market_type) : 'perp',
|
|
market_index: typeof l2.market_index === 'number' ? l2.market_index : null,
|
|
ts: l2.ts == null ? null : String(l2.ts),
|
|
slot: l2.slot == null ? null : String(l2.slot),
|
|
mid_price: numStr(mid),
|
|
best_bid_price: numStr(bestBid),
|
|
best_ask_price: numStr(bestAsk),
|
|
vwap_price: numStr(sell.vwap),
|
|
worst_price: numStr(sell.worstPrice),
|
|
filled_usd: numStr(sell.filledUsd),
|
|
filled_base: numStr(sell.filledBase),
|
|
impact_bps: numStr(sell.impactBps),
|
|
levels_consumed: sell.levelsConsumed,
|
|
fill_pct: numStr(sell.fillPct),
|
|
raw: {
|
|
ref: 'mid',
|
|
units: 'usd',
|
|
pricePrecision: cfg.pricePrecision,
|
|
basePrecision: cfg.basePrecision,
|
|
},
|
|
updated_at: updatedAt,
|
|
});
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error(`[dlob-slippage-worker] fetch/compute: ${String(err?.message || err)}`);
|
|
}
|
|
|
|
try {
|
|
await upsertSlippage(cfg, rows);
|
|
} catch (err) {
|
|
console.error(`[dlob-slippage-worker] upsert: ${String(err?.message || err)}`);
|
|
}
|
|
|
|
await sleep(cfg.pollMs);
|
|
}
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error(String(err?.stack || err));
|
|
process.exitCode = 1;
|
|
});
|