886 lines
25 KiB
TypeScript
886 lines
25 KiB
TypeScript
import { program, Option } from "commander";
|
|
|
|
import responseTime = require("response-time");
|
|
import express from "express";
|
|
import rateLimit from "express-rate-limit";
|
|
import compression from "compression";
|
|
import morgan from "morgan";
|
|
import cors from "cors";
|
|
|
|
import { Connection, Commitment, PublicKey } from "@solana/web3.js";
|
|
|
|
import {
|
|
getVariant,
|
|
BulkAccountLoader,
|
|
DriftClient,
|
|
initialize,
|
|
DriftEnv,
|
|
SlotSubscriber,
|
|
UserMap,
|
|
DLOBOrder,
|
|
DLOBOrders,
|
|
DLOBOrdersCoder,
|
|
SpotMarkets,
|
|
PerpMarkets,
|
|
DLOBSubscriber,
|
|
MarketType,
|
|
SpotMarketConfig,
|
|
PhoenixSubscriber,
|
|
SerumSubscriber,
|
|
} from "@drift-labs/sdk";
|
|
|
|
import { Mutex } from "async-mutex";
|
|
|
|
import { getWallet } from "./utils";
|
|
import { logger, setLogLevel } from "./logger";
|
|
|
|
import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
|
|
import {
|
|
ExplicitBucketHistogramAggregation,
|
|
InstrumentType,
|
|
MeterProvider,
|
|
View,
|
|
} from "@opentelemetry/sdk-metrics-base";
|
|
import { ObservableResult } from "@opentelemetry/api";
|
|
|
|
require("dotenv").config();
|
|
const driftEnv = (process.env.ENV || "devnet") as DriftEnv;
|
|
const commitHash = process.env.COMMIT;
|
|
//@ts-ignore
|
|
const sdkConfig = initialize({ env: process.env.ENV });
|
|
|
|
const stateCommitment: Commitment = "confirmed";
|
|
const serverPort = process.env.PORT || 6969;
|
|
|
|
const bulkAccountLoaderPollingInterval = process.env
|
|
.BULK_ACCOUNT_LOADER_POLLING_INTERVAL
|
|
? parseInt(process.env.BULK_ACCOUNT_LOADER_POLLING_INTERVAL)
|
|
: 5000;
|
|
const healthCheckInterval = bulkAccountLoaderPollingInterval * 2;
|
|
|
|
const rateLimitCallsPerSecond = process.env.RATE_LIMIT_CALLS_PER_SECOND
|
|
? parseInt(process.env.RATE_LIMIT_CALLS_PER_SECOND)
|
|
: 10;
|
|
|
|
const logFormat =
|
|
':remote-addr - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent" :req[x-forwarded-for]';
|
|
const logHttp = morgan(logFormat, {
|
|
skip: (_req, res) => res.statusCode < 400,
|
|
});
|
|
|
|
function errorHandler(err, _req, res, _next) {
|
|
logger.error(err.stack);
|
|
res.status(500).send("Internal error");
|
|
}
|
|
|
|
const app = express();
|
|
app.use(cors({ origin: "*" }));
|
|
app.use(compression());
|
|
app.set("trust proxy", 1);
|
|
app.use(logHttp);
|
|
|
|
app.use(
|
|
rateLimit({
|
|
windowMs: 1000, // 1 second
|
|
max: rateLimitCallsPerSecond,
|
|
standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
|
|
legacyHeaders: false, // Disable the `X-RateLimit-*` headers
|
|
})
|
|
);
|
|
|
|
// strip off /dlob, if the request comes from exchange history server LB
|
|
app.use((req, _res, next) => {
|
|
if (req.url.startsWith("/dlob")) {
|
|
req.url = req.url.replace("/dlob", "");
|
|
if (req.url === "") {
|
|
req.url = "/";
|
|
}
|
|
}
|
|
next();
|
|
});
|
|
|
|
program
|
|
.option("-d, --dry-run", "Dry run, do not send transactions on chain")
|
|
.option("--test-liveness", "Purposefully fail liveness test after 1 minute")
|
|
.addOption(
|
|
new Option(
|
|
"-p, --private-key <string>",
|
|
"private key, supports path to id.json, or list of comma separate numbers"
|
|
).env("ANCHOR_PRIVATE_KEY")
|
|
)
|
|
.option("--debug", "Enable debug logging")
|
|
.parse();
|
|
|
|
const opts = program.opts();
|
|
setLogLevel(opts.debug ? "debug" : "info");
|
|
|
|
const endpoint = process.env.ENDPOINT;
|
|
const wsEndpoint = process.env.WS_ENDPOINT;
|
|
logger.info(`RPC endpoint: ${endpoint}`);
|
|
logger.info(`WS endpoint: ${wsEndpoint}`);
|
|
logger.info(`DriftEnv: ${driftEnv}`);
|
|
logger.info(`Commit: ${commitHash}`);
|
|
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
/**
|
|
* Creates {count} buckets of size {increment} starting from {start}. Each bucket stores the count of values within its "size".
|
|
* @param start
|
|
* @param increment
|
|
* @param count
|
|
* @returns
|
|
*/
|
|
const createHistogramBuckets = (
|
|
start: number,
|
|
increment: number,
|
|
count: number
|
|
) => {
|
|
return new ExplicitBucketHistogramAggregation(
|
|
Array.from(new Array(count), (_, i) => start + i * increment)
|
|
);
|
|
};
|
|
|
|
enum METRIC_TYPES {
|
|
runtime_specs = "runtime_specs",
|
|
endpoint_response_times_histogram = "endpoint_response_times_histogram",
|
|
health_status = "health_status",
|
|
}
|
|
|
|
export enum HEALTH_STATUS {
|
|
Ok = 0,
|
|
StaleBulkAccountLoader,
|
|
UnhealthySlotSubscriber,
|
|
LivenessTesting,
|
|
}
|
|
|
|
const metricsPort =
|
|
parseInt(process.env.METRICS_PORT) || PrometheusExporter.DEFAULT_OPTIONS.port;
|
|
const { endpoint: defaultEndpoint } = PrometheusExporter.DEFAULT_OPTIONS;
|
|
const exporter = new PrometheusExporter(
|
|
{
|
|
port: metricsPort,
|
|
endpoint: defaultEndpoint,
|
|
},
|
|
() => {
|
|
logger.info(
|
|
`prometheus scrape endpoint started: http://localhost:${metricsPort}${defaultEndpoint}`
|
|
);
|
|
}
|
|
);
|
|
const meterName = "dlob-meter";
|
|
const meterProvider = new MeterProvider({
|
|
views: [
|
|
new View({
|
|
instrumentName: METRIC_TYPES.endpoint_response_times_histogram,
|
|
instrumentType: InstrumentType.HISTOGRAM,
|
|
meterName,
|
|
aggregation: createHistogramBuckets(0, 50, 30),
|
|
}),
|
|
],
|
|
});
|
|
meterProvider.addMetricReader(exporter);
|
|
const meter = meterProvider.getMeter(meterName);
|
|
|
|
const runtimeSpecsGauge = meter.createObservableGauge(
|
|
METRIC_TYPES.runtime_specs,
|
|
{
|
|
description: "Runtime sepcification of this program",
|
|
}
|
|
);
|
|
const bootTimeMs = Date.now();
|
|
runtimeSpecsGauge.addCallback((obs) => {
|
|
obs.observe(bootTimeMs, {
|
|
commit: commitHash,
|
|
driftEnv,
|
|
rpcEndpoint: endpoint,
|
|
wsEndpoint: wsEndpoint,
|
|
});
|
|
});
|
|
|
|
let healthStatus: HEALTH_STATUS = HEALTH_STATUS.Ok;
|
|
const healthStatusGauge = meter.createObservableGauge(
|
|
METRIC_TYPES.health_status,
|
|
{
|
|
description: "Health status of this program",
|
|
}
|
|
);
|
|
healthStatusGauge.addCallback((obs: ObservableResult) => {
|
|
obs.observe(healthStatus, {});
|
|
});
|
|
|
|
const endpointResponseTimeHistogram = meter.createHistogram(
|
|
METRIC_TYPES.endpoint_response_times_histogram,
|
|
{
|
|
description: "Duration of endpoint responses",
|
|
unit: "ms",
|
|
}
|
|
);
|
|
|
|
const getPhoenixSubscriber = (
|
|
driftClient: DriftClient,
|
|
marketConfig: SpotMarketConfig,
|
|
accountLoader: BulkAccountLoader
|
|
) => {
|
|
return new PhoenixSubscriber({
|
|
connection: driftClient.connection,
|
|
programId: new PublicKey(sdkConfig.PHOENIX),
|
|
marketAddress: marketConfig.phoenixMarket,
|
|
accountSubscription: {
|
|
type: "polling",
|
|
accountLoader,
|
|
},
|
|
});
|
|
};
|
|
|
|
const getSerumSubscriber = (
|
|
driftClient: DriftClient,
|
|
marketConfig: SpotMarketConfig,
|
|
accountLoader: BulkAccountLoader
|
|
) => {
|
|
return new SerumSubscriber({
|
|
connection: driftClient.connection,
|
|
programId: new PublicKey(sdkConfig.SERUM_V3),
|
|
marketAddress: marketConfig.serumMarket,
|
|
accountSubscription: {
|
|
type: "polling",
|
|
accountLoader,
|
|
},
|
|
});
|
|
};
|
|
|
|
type SubscriberLookup = {
|
|
[marketIndex: number]: {
|
|
phoenix?: PhoenixSubscriber;
|
|
serum?: SerumSubscriber;
|
|
};
|
|
};
|
|
|
|
let MARKET_SUBSCRIBERS: SubscriberLookup = {};
|
|
|
|
const initializeAllMarketSubscribers = async (
|
|
driftClient: DriftClient,
|
|
bulkAccountLoader: BulkAccountLoader
|
|
) => {
|
|
const markets: SubscriberLookup = {};
|
|
|
|
for (const market of sdkConfig.SPOT_MARKETS) {
|
|
markets[market.marketIndex] = {
|
|
phoenix: undefined,
|
|
serum: undefined,
|
|
};
|
|
|
|
if (market.phoenixMarket) {
|
|
const phoenixSubscriber = getPhoenixSubscriber(
|
|
driftClient,
|
|
market,
|
|
bulkAccountLoader
|
|
);
|
|
await phoenixSubscriber.subscribe();
|
|
markets[market.marketIndex].phoenix = phoenixSubscriber;
|
|
}
|
|
|
|
if (market.serumMarket) {
|
|
const serumSubscriber = getSerumSubscriber(
|
|
driftClient,
|
|
market,
|
|
bulkAccountLoader
|
|
);
|
|
await serumSubscriber.subscribe();
|
|
markets[market.marketIndex].serum = serumSubscriber;
|
|
}
|
|
}
|
|
|
|
return markets;
|
|
};
|
|
|
|
const main = async () => {
|
|
const wallet = getWallet();
|
|
const clearingHousePublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
|
|
|
|
const connection = new Connection(endpoint, {
|
|
wsEndpoint: wsEndpoint,
|
|
commitment: stateCommitment,
|
|
});
|
|
|
|
const bulkAccountLoader = new BulkAccountLoader(
|
|
connection,
|
|
stateCommitment,
|
|
bulkAccountLoaderPollingInterval
|
|
);
|
|
const lastBulkAccountLoaderSlotMutex = new Mutex();
|
|
let lastBulkAccountLoaderSlot = bulkAccountLoader.mostRecentSlot;
|
|
let lastBulkAccountLoaderSlotUpdated = Date.now();
|
|
const driftClient = new DriftClient({
|
|
connection,
|
|
wallet,
|
|
programID: clearingHousePublicKey,
|
|
perpMarketIndexes: PerpMarkets[driftEnv].map((mkt) => mkt.marketIndex),
|
|
spotMarketIndexes: SpotMarkets[driftEnv].map((mkt) => mkt.marketIndex),
|
|
oracleInfos: PerpMarkets[driftEnv].map((mkt) => {
|
|
return { publicKey: mkt.oracle, source: mkt.oracleSource };
|
|
}),
|
|
accountSubscription: {
|
|
type: "polling",
|
|
accountLoader: bulkAccountLoader,
|
|
},
|
|
env: driftEnv,
|
|
userStats: true,
|
|
});
|
|
|
|
const dlobCoder = DLOBOrdersCoder.create();
|
|
const slotSubscriber = new SlotSubscriber(connection, {});
|
|
const lastSlotReceivedMutex = new Mutex();
|
|
let lastSlotReceived: number;
|
|
let lastHealthCheckSlot = -1;
|
|
let lastHealthCheckSlotUpdated = Date.now();
|
|
const startupTime = Date.now();
|
|
|
|
const lamportsBalance = await connection.getBalance(wallet.publicKey);
|
|
logger.info(
|
|
`DriftClient ProgramId: ${driftClient.program.programId.toBase58()}`
|
|
);
|
|
logger.info(`Wallet pubkey: ${wallet.publicKey.toBase58()}`);
|
|
logger.info(` . SOL balance: ${lamportsBalance / 10 ** 9}`);
|
|
|
|
await driftClient.subscribe();
|
|
driftClient.eventEmitter.on("error", (e) => {
|
|
logger.info("clearing house error");
|
|
logger.error(e);
|
|
});
|
|
|
|
await slotSubscriber.subscribe();
|
|
slotSubscriber.eventEmitter.on("newSlot", async (slot: number) => {
|
|
await lastSlotReceivedMutex.runExclusive(async () => {
|
|
lastSlotReceived = slot;
|
|
});
|
|
});
|
|
|
|
if (!(await driftClient.getUser().exists())) {
|
|
logger.error(`User for ${wallet.publicKey} does not exist`);
|
|
if (opts.initUser) {
|
|
logger.info(`Creating User for ${wallet.publicKey}`);
|
|
const [txSig] = await driftClient.initializeUserAccount();
|
|
logger.info(`Initialized user account in transaction: ${txSig}`);
|
|
} else {
|
|
throw new Error("Run with '--init-user' flag to initialize a User");
|
|
}
|
|
}
|
|
|
|
const userMap = new UserMap(
|
|
driftClient,
|
|
driftClient.userAccountSubscriptionConfig,
|
|
false
|
|
);
|
|
await userMap.subscribe();
|
|
|
|
const dlobSubscriber = new DLOBSubscriber({
|
|
driftClient,
|
|
dlobSource: userMap,
|
|
slotSource: slotSubscriber,
|
|
updateFrequency: bulkAccountLoaderPollingInterval,
|
|
});
|
|
await dlobSubscriber.subscribe();
|
|
|
|
const handleResponseTime = responseTime((req: Request, _res, time) => {
|
|
const endpoint = req.url;
|
|
|
|
const responseTimeMs = time;
|
|
endpointResponseTimeHistogram.record(responseTimeMs, {
|
|
endpoint,
|
|
});
|
|
});
|
|
|
|
MARKET_SUBSCRIBERS = await initializeAllMarketSubscribers(
|
|
driftClient,
|
|
bulkAccountLoader
|
|
);
|
|
|
|
// start http server listening to /health endpoint using http package
|
|
app.get("/health", handleResponseTime, async (req, res, next) => {
|
|
try {
|
|
if (req.url === "/health") {
|
|
if (opts.testLiveness) {
|
|
if (Date.now() > startupTime + 60 * 1000) {
|
|
healthStatus = HEALTH_STATUS.LivenessTesting;
|
|
|
|
res.writeHead(500);
|
|
res.end("Testing liveness test fail");
|
|
return;
|
|
}
|
|
}
|
|
// check if a slot was received recently
|
|
let healthySlotSubscriber = false;
|
|
await lastSlotReceivedMutex.runExclusive(async () => {
|
|
const slotChanged = lastSlotReceived > lastHealthCheckSlot;
|
|
const slotChangedRecently =
|
|
Date.now() - lastHealthCheckSlotUpdated < healthCheckInterval;
|
|
healthySlotSubscriber = slotChanged || slotChangedRecently;
|
|
logger.debug(
|
|
`Slotsubscriber health check: lastSlotReceived: ${lastSlotReceived}, lastHealthCheckSlot: ${lastHealthCheckSlot}, slotChanged: ${slotChanged}, slotChangedRecently: ${slotChangedRecently}`
|
|
);
|
|
if (slotChanged) {
|
|
lastHealthCheckSlot = lastSlotReceived;
|
|
lastHealthCheckSlotUpdated = Date.now();
|
|
}
|
|
});
|
|
if (!healthySlotSubscriber) {
|
|
healthStatus = HEALTH_STATUS.UnhealthySlotSubscriber;
|
|
logger.error(`SlotSubscriber is not healthy`);
|
|
|
|
res.writeHead(500);
|
|
res.end(`SlotSubscriber is not healthy`);
|
|
return;
|
|
}
|
|
|
|
if (bulkAccountLoader) {
|
|
let healthyBulkAccountLoader = false;
|
|
await lastBulkAccountLoaderSlotMutex.runExclusive(async () => {
|
|
const slotChanged =
|
|
bulkAccountLoader.mostRecentSlot > lastBulkAccountLoaderSlot;
|
|
const slotChangedRecently =
|
|
Date.now() - lastBulkAccountLoaderSlotUpdated <
|
|
healthCheckInterval;
|
|
healthyBulkAccountLoader = slotChanged || slotChangedRecently;
|
|
logger.debug(
|
|
`BulkAccountLoader health check: bulkAccountLoader.mostRecentSlot: ${bulkAccountLoader.mostRecentSlot}, lastBulkAccountLoaderSlot: ${lastBulkAccountLoaderSlot}, slotChanged: ${slotChanged}, slotChangedRecently: ${slotChangedRecently}`
|
|
);
|
|
if (slotChanged) {
|
|
lastBulkAccountLoaderSlot = bulkAccountLoader.mostRecentSlot;
|
|
lastBulkAccountLoaderSlotUpdated = Date.now();
|
|
}
|
|
});
|
|
if (!healthyBulkAccountLoader) {
|
|
healthStatus = HEALTH_STATUS.StaleBulkAccountLoader;
|
|
logger.error(
|
|
`Health check failed due to stale bulkAccountLoader.mostRecentSlot`
|
|
);
|
|
|
|
res.writeHead(501);
|
|
res.end(`bulkAccountLoader.mostRecentSlot is not healthy`);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// liveness check passed
|
|
healthStatus = HEALTH_STATUS.Ok;
|
|
res.writeHead(200);
|
|
res.end("OK");
|
|
} else {
|
|
res.writeHead(404);
|
|
res.end("Not found");
|
|
}
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
});
|
|
|
|
app.get("/orders/json/raw", handleResponseTime, async (_req, res, next) => {
|
|
try {
|
|
// object with userAccount key and orders object serialized
|
|
const orders: Array<any> = [];
|
|
const oracles: Array<any> = [];
|
|
const slot = bulkAccountLoader.mostRecentSlot;
|
|
|
|
for (const market of driftClient.getPerpMarketAccounts()) {
|
|
const oracle = driftClient.getOracleDataForPerpMarket(
|
|
market.marketIndex
|
|
);
|
|
oracles.push({
|
|
marketIndex: market.marketIndex,
|
|
...oracle,
|
|
});
|
|
}
|
|
|
|
for (const user of userMap.values()) {
|
|
const userAccount = user.getUserAccount();
|
|
|
|
for (const order of userAccount.orders) {
|
|
if (getVariant(order.status) === "init") {
|
|
continue;
|
|
}
|
|
|
|
orders.push({
|
|
user: user.getUserAccountPublicKey().toBase58(),
|
|
order: order,
|
|
});
|
|
}
|
|
}
|
|
|
|
// respond with orders
|
|
res.writeHead(200);
|
|
res.end(
|
|
JSON.stringify({
|
|
slot,
|
|
oracles,
|
|
orders,
|
|
})
|
|
);
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
});
|
|
|
|
app.get("/orders/json", handleResponseTime, async (_req, res, next) => {
|
|
try {
|
|
// object with userAccount key and orders object serialized
|
|
const slot = bulkAccountLoader.mostRecentSlot;
|
|
const orders: Array<any> = [];
|
|
const oracles: Array<any> = [];
|
|
for (const market of driftClient.getPerpMarketAccounts()) {
|
|
const oracle = driftClient.getOracleDataForPerpMarket(
|
|
market.marketIndex
|
|
);
|
|
const oracleHuman = {
|
|
marketIndex: market.marketIndex,
|
|
price: oracle.price.toString(),
|
|
slot: oracle.slot.toString(),
|
|
confidence: oracle.confidence.toString(),
|
|
hasSufficientNumberOfDataPoints:
|
|
oracle.hasSufficientNumberOfDataPoints,
|
|
};
|
|
if (oracle.twap) {
|
|
oracleHuman["twap"] = oracle.twap.toString();
|
|
}
|
|
if (oracle.twapConfidence) {
|
|
oracleHuman["twapConfidence"] = oracle.twapConfidence.toString();
|
|
}
|
|
oracles.push(oracleHuman);
|
|
}
|
|
for (const user of userMap.values()) {
|
|
const userAccount = user.getUserAccount();
|
|
|
|
for (const order of userAccount.orders) {
|
|
if (getVariant(order.status) === "init") {
|
|
continue;
|
|
}
|
|
|
|
const orderHuman = {
|
|
status: getVariant(order.status),
|
|
orderType: getVariant(order.orderType),
|
|
marketType: getVariant(order.marketType),
|
|
slot: order.slot.toString(),
|
|
orderId: order.orderId,
|
|
userOrderId: order.userOrderId,
|
|
marketIndex: order.marketIndex,
|
|
price: order.price.toString(),
|
|
baseAssetAmount: order.baseAssetAmount.toString(),
|
|
baseAssetAmountFilled: order.baseAssetAmountFilled.toString(),
|
|
quoteAssetAmountFilled: order.quoteAssetAmountFilled.toString(),
|
|
direction: getVariant(order.direction),
|
|
reduceOnly: order.reduceOnly,
|
|
triggerPrice: order.triggerPrice.toString(),
|
|
triggerCondition: getVariant(order.triggerCondition),
|
|
existingPositionDirection: getVariant(
|
|
order.existingPositionDirection
|
|
),
|
|
postOnly: order.postOnly,
|
|
immediateOrCancel: order.immediateOrCancel,
|
|
oraclePriceOffset: order.oraclePriceOffset,
|
|
auctionDuration: order.auctionDuration,
|
|
auctionStartPrice: order.auctionStartPrice.toString(),
|
|
auctionEndPrice: order.auctionEndPrice.toString(),
|
|
maxTs: order.maxTs.toString(),
|
|
};
|
|
if (order.quoteAssetAmount) {
|
|
orderHuman["quoteAssetAmount"] = order.quoteAssetAmount.toString();
|
|
}
|
|
|
|
orders.push({
|
|
user: user.getUserAccountPublicKey().toBase58(),
|
|
order: orderHuman,
|
|
});
|
|
}
|
|
}
|
|
|
|
// respond with orders
|
|
res.writeHead(200);
|
|
res.end(
|
|
JSON.stringify({
|
|
slot,
|
|
oracles,
|
|
orders,
|
|
})
|
|
);
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
});
|
|
|
|
app.get("/orders/idl", handleResponseTime, async (_req, res, next) => {
|
|
try {
|
|
const dlobOrders: DLOBOrders = [];
|
|
|
|
for (const user of userMap.values()) {
|
|
const userAccount = user.getUserAccount();
|
|
|
|
for (const order of userAccount.orders) {
|
|
if (getVariant(order.status) === "init") {
|
|
continue;
|
|
}
|
|
|
|
dlobOrders.push({
|
|
user: user.getUserAccountPublicKey(),
|
|
order,
|
|
} as DLOBOrder);
|
|
}
|
|
}
|
|
|
|
res.writeHead(200);
|
|
res.end(dlobCoder.encode(dlobOrders));
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
});
|
|
|
|
app.get("/orders/idlWithSlot", handleResponseTime, async (req, res, next) => {
|
|
try {
|
|
const { marketName, marketIndex, marketType } = req.query;
|
|
const { normedMarketType, normedMarketIndex, error } = validateDlobQuery(
|
|
marketType as string,
|
|
marketIndex as string,
|
|
marketName as string
|
|
);
|
|
const useFilter =
|
|
marketName !== undefined ||
|
|
marketIndex !== undefined ||
|
|
marketType !== undefined;
|
|
|
|
if (useFilter) {
|
|
if (
|
|
error ||
|
|
normedMarketType === undefined ||
|
|
normedMarketIndex === undefined
|
|
) {
|
|
res.status(400).send(error);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const dlobOrders: DLOBOrders = [];
|
|
|
|
for (const user of userMap.values()) {
|
|
const userAccount = user.getUserAccount();
|
|
|
|
for (const order of userAccount.orders) {
|
|
if (getVariant(order.status) === "init") {
|
|
continue;
|
|
}
|
|
|
|
if (useFilter) {
|
|
if (
|
|
getVariant(order.marketType) !== getVariant(normedMarketType) ||
|
|
order.marketIndex !== normedMarketIndex
|
|
) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
dlobOrders.push({
|
|
user: user.getUserAccountPublicKey(),
|
|
order,
|
|
} as DLOBOrder);
|
|
}
|
|
}
|
|
|
|
res.end(
|
|
JSON.stringify({
|
|
slot: bulkAccountLoader.mostRecentSlot,
|
|
data: dlobCoder.encode(dlobOrders).toString("base64"),
|
|
})
|
|
);
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
});
|
|
|
|
const validateDlobQuery = (
|
|
marketType?: string,
|
|
marketIndex?: string,
|
|
marketName?: string
|
|
): {
|
|
normedMarketType?: MarketType;
|
|
normedMarketIndex?: number;
|
|
error?: string;
|
|
} => {
|
|
let normedMarketType: MarketType = undefined;
|
|
let normedMarketIndex: number = undefined;
|
|
let normedMarketName: string = undefined;
|
|
if (marketName === undefined) {
|
|
if (marketIndex === undefined || marketType === undefined) {
|
|
return {
|
|
error:
|
|
"Bad Request: (marketName) or (marketIndex and marketType) must be supplied",
|
|
};
|
|
}
|
|
|
|
// validate marketType
|
|
switch ((marketType as string).toLowerCase()) {
|
|
case "spot": {
|
|
normedMarketType = MarketType.SPOT;
|
|
normedMarketIndex = parseInt(marketIndex as string);
|
|
const spotMarketIndicies = SpotMarkets[driftEnv].map(
|
|
(mkt) => mkt.marketIndex
|
|
);
|
|
if (!spotMarketIndicies.includes(normedMarketIndex)) {
|
|
return {
|
|
error: "Bad Request: invalid marketIndex",
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
case "perp": {
|
|
normedMarketType = MarketType.PERP;
|
|
normedMarketIndex = parseInt(marketIndex as string);
|
|
const perpMarketIndicies = PerpMarkets[driftEnv].map(
|
|
(mkt) => mkt.marketIndex
|
|
);
|
|
if (!perpMarketIndicies.includes(normedMarketIndex)) {
|
|
return {
|
|
error: "Bad Request: invalid marketIndex",
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
return {
|
|
error: 'Bad Request: marketType must be either "spot" or "perp"',
|
|
};
|
|
}
|
|
} else {
|
|
// validate marketName
|
|
normedMarketName = (marketName as string).toUpperCase();
|
|
const derivedMarketInfo =
|
|
driftClient.getMarketIndexAndType(normedMarketName);
|
|
if (!derivedMarketInfo) {
|
|
return {
|
|
error: "Bad Request: unrecognized marketName",
|
|
};
|
|
}
|
|
normedMarketType = derivedMarketInfo.marketType;
|
|
normedMarketIndex = derivedMarketInfo.marketIndex;
|
|
}
|
|
|
|
return {
|
|
normedMarketType,
|
|
normedMarketIndex,
|
|
};
|
|
};
|
|
|
|
app.get("/l2", handleResponseTime, async (req, res, next) => {
|
|
try {
|
|
const {
|
|
marketName,
|
|
marketIndex,
|
|
marketType,
|
|
depth,
|
|
includeVamm,
|
|
includePhoenix,
|
|
includeSerum,
|
|
} = req.query;
|
|
|
|
const { normedMarketType, normedMarketIndex, error } = validateDlobQuery(
|
|
marketType as string,
|
|
marketIndex as string,
|
|
marketName as string
|
|
);
|
|
if (error) {
|
|
res.status(400).send(error);
|
|
return;
|
|
}
|
|
|
|
const isSpot = getVariant(normedMarketType);
|
|
|
|
const l2 = await dlobSubscriber.getL2({
|
|
marketIndex: normedMarketIndex,
|
|
marketType: normedMarketType,
|
|
depth: depth ? parseInt(depth as string) : 10,
|
|
includeVamm: `${includeVamm}`.toLowerCase() === "true",
|
|
fallbackL2Generators: isSpot
|
|
? [
|
|
`${includePhoenix}`.toLowerCase() === "true" &&
|
|
MARKET_SUBSCRIBERS[normedMarketIndex].phoenix,
|
|
`${includeSerum}`.toLowerCase() === "true" &&
|
|
MARKET_SUBSCRIBERS[normedMarketIndex].serum,
|
|
].filter((a) => !!a)
|
|
: [],
|
|
});
|
|
|
|
for (const key of Object.keys(l2)) {
|
|
for (const idx in l2[key]) {
|
|
const level = l2[key][idx];
|
|
const sources = level["sources"];
|
|
for (const sourceKey of Object.keys(sources)) {
|
|
sources[sourceKey] = sources[sourceKey].toString();
|
|
}
|
|
l2[key][idx] = {
|
|
price: level.price.toString(),
|
|
size: level.size.toString(),
|
|
sources,
|
|
};
|
|
}
|
|
}
|
|
|
|
res.writeHead(200);
|
|
res.end(JSON.stringify(l2));
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
});
|
|
|
|
app.get("/l3", handleResponseTime, async (req, res, next) => {
|
|
try {
|
|
const { marketName, marketIndex, marketType } = req.query;
|
|
|
|
const { normedMarketType, normedMarketIndex, error } = validateDlobQuery(
|
|
marketType as string,
|
|
marketIndex as string,
|
|
marketName as string
|
|
);
|
|
if (error) {
|
|
res.status(400).send(error);
|
|
return;
|
|
}
|
|
|
|
const l3 = dlobSubscriber.getL3({
|
|
marketIndex: normedMarketIndex,
|
|
marketType: normedMarketType,
|
|
});
|
|
|
|
for (const key of Object.keys(l3)) {
|
|
for (const idx in l3[key]) {
|
|
const level = l3[key][idx];
|
|
l3[key][idx] = {
|
|
...level,
|
|
price: level.price.toString(),
|
|
size: level.size.toString(),
|
|
};
|
|
}
|
|
}
|
|
|
|
res.writeHead(200);
|
|
res.end(JSON.stringify(l3));
|
|
} catch (err) {
|
|
next(err);
|
|
}
|
|
});
|
|
|
|
app.use(errorHandler);
|
|
app.listen(serverPort, () => {
|
|
logger.info(`DLOB server listening on port http://localhost:${serverPort}`);
|
|
});
|
|
};
|
|
|
|
async function recursiveTryCatch(f: () => void) {
|
|
try {
|
|
await f();
|
|
} catch (e) {
|
|
console.error(e);
|
|
await sleep(15000);
|
|
await recursiveTryCatch(f);
|
|
}
|
|
}
|
|
|
|
recursiveTryCatch(() => main());
|