@0xarchive/sdk 0.3.0 → 0.3.2

package/dist/index.js

@@ -20,9 +20,50 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ApiMetaSchema: () => ApiMetaSchema,
+  ApiResponseSchema: () => ApiResponseSchema,
+  DataSourceSchema: () => DataSourceSchema,
+  FundingRateArrayResponseSchema: () => FundingRateArrayResponseSchema,
+  FundingRateResponseSchema: () => FundingRateResponseSchema,
+  FundingRateSchema: () => FundingRateSchema,
+  InstrumentArrayResponseSchema: () => InstrumentArrayResponseSchema,
+  InstrumentResponseSchema: () => InstrumentResponseSchema,
+  InstrumentSchema: () => InstrumentSchema,
+  InstrumentTypeSchema: () => InstrumentTypeSchema,
+  OpenInterestArrayResponseSchema: () => OpenInterestArrayResponseSchema,
+  OpenInterestResponseSchema: () => OpenInterestResponseSchema,
+  OpenInterestSchema: () => OpenInterestSchema,
+  OrderBookArrayResponseSchema: () => OrderBookArrayResponseSchema,
+  OrderBookResponseSchema: () => OrderBookResponseSchema,
+  OrderBookSchema: () => OrderBookSchema,
   OxArchive: () => OxArchive,
   OxArchiveError: () => OxArchiveError,
   OxArchiveWs: () => OxArchiveWs,
+  PriceLevelSchema: () => PriceLevelSchema,
+  TimestampedRecordSchema: () => TimestampedRecordSchema,
+  TradeArrayResponseSchema: () => TradeArrayResponseSchema,
+  TradeDirectionSchema: () => TradeDirectionSchema,
+  TradeSchema: () => TradeSchema,
+  TradeSideSchema: () => TradeSideSchema,
+  WsChannelSchema: () => WsChannelSchema,
+  WsConnectionStateSchema: () => WsConnectionStateSchema,
+  WsDataSchema: () => WsDataSchema,
+  WsErrorSchema: () => WsErrorSchema,
+  WsHistoricalBatchSchema: () => WsHistoricalBatchSchema,
+  WsHistoricalDataSchema: () => WsHistoricalDataSchema,
+  WsPongSchema: () => WsPongSchema,
+  WsReplayCompletedSchema: () => WsReplayCompletedSchema,
+  WsReplayPausedSchema: () => WsReplayPausedSchema,
+  WsReplayResumedSchema: () => WsReplayResumedSchema,
+  WsReplayStartedSchema: () => WsReplayStartedSchema,
+  WsReplayStoppedSchema: () => WsReplayStoppedSchema,
+  WsServerMessageSchema: () => WsServerMessageSchema,
+  WsStreamCompletedSchema: () => WsStreamCompletedSchema,
+  WsStreamProgressSchema: () => WsStreamProgressSchema,
+  WsStreamStartedSchema: () => WsStreamStartedSchema,
+  WsStreamStoppedSchema: () => WsStreamStoppedSchema,
+  WsSubscribedSchema: () => WsSubscribedSchema,
+  WsUnsubscribedSchema: () => WsUnsubscribedSchema,
   default: () => OxArchive
 });
 module.exports = __toCommonJS(index_exports);
@@ -44,15 +85,25 @@ var HttpClient = class {
   baseUrl;
   apiKey;
   timeout;
+  validate;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.apiKey = options.apiKey;
     this.timeout = options.timeout;
+    this.validate = options.validate ?? false;
+  }
+  /** Whether validation is enabled */
+  get validationEnabled() {
+    return this.validate;
   }
   /**
    * Make a GET request to the API
+   *
+   * @param path - API endpoint path
+   * @param params - Query parameters
+   * @param schema - Optional Zod schema for validation (used when validation is enabled)
    */
-  async get(path, params) {
+  async get(path, params, schema) {
     const url = new URL(`${this.baseUrl}${path}`);
     if (params) {
       for (const [key, value] of Object.entries(params)) {
@@ -82,6 +133,17 @@ var HttpClient = class {
           data.meta?.request_id
         );
       }
+      if (this.validate && schema) {
+        const result = schema.safeParse(data);
+        if (!result.success) {
+          throw new OxArchiveError(
+            `Response validation failed: ${result.error.message}`,
+            422,
+            data.meta?.request_id
+          );
+        }
+        return result.data;
+      }
       return data;
     } catch (error) {
       clearTimeout(timeoutId);
@@ -99,6 +161,203 @@ var HttpClient = class {
   }
 };
 
+// src/schemas.ts
+var import_zod = require("zod");
+var ApiMetaSchema = import_zod.z.object({
+  count: import_zod.z.number(),
+  next_cursor: import_zod.z.string().optional(),
+  request_id: import_zod.z.string()
+});
+var ApiResponseSchema = (dataSchema) => import_zod.z.object({
+  success: import_zod.z.boolean(),
+  data: dataSchema,
+  meta: ApiMetaSchema
+});
+var PriceLevelSchema = import_zod.z.object({
+  px: import_zod.z.string(),
+  sz: import_zod.z.string(),
+  n: import_zod.z.number()
+});
+var OrderBookSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  timestamp: import_zod.z.string(),
+  bids: import_zod.z.array(PriceLevelSchema),
+  asks: import_zod.z.array(PriceLevelSchema),
+  mid_price: import_zod.z.string().optional(),
+  spread: import_zod.z.string().optional(),
+  spread_bps: import_zod.z.string().optional()
+});
+var TradeSideSchema = import_zod.z.enum(["A", "B"]);
+var TradeDirectionSchema = import_zod.z.enum([
+  "Open Long",
+  "Open Short",
+  "Close Long",
+  "Close Short"
+]);
+var DataSourceSchema = import_zod.z.enum(["s3", "ws", "api", "live"]);
+var TradeSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  side: TradeSideSchema,
+  price: import_zod.z.string(),
+  size: import_zod.z.string(),
+  timestamp: import_zod.z.string(),
+  tx_hash: import_zod.z.string().optional(),
+  trade_id: import_zod.z.number().optional(),
+  order_id: import_zod.z.number().optional(),
+  crossed: import_zod.z.boolean().optional(),
+  fee: import_zod.z.string().optional(),
+  fee_token: import_zod.z.string().optional(),
+  closed_pnl: import_zod.z.string().optional(),
+  direction: TradeDirectionSchema.optional(),
+  start_position: import_zod.z.string().optional(),
+  source: DataSourceSchema.optional(),
+  user_address: import_zod.z.string().optional(),
+  maker_address: import_zod.z.string().optional(),
+  taker_address: import_zod.z.string().optional()
+});
+var InstrumentTypeSchema = import_zod.z.enum(["perp", "spot"]);
+var InstrumentSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  szDecimals: import_zod.z.number(),
+  maxLeverage: import_zod.z.number().optional(),
+  onlyIsolated: import_zod.z.boolean().optional(),
+  instrumentType: InstrumentTypeSchema.optional(),
+  isActive: import_zod.z.boolean()
+});
+var FundingRateSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  timestamp: import_zod.z.string(),
+  funding_rate: import_zod.z.string(),
+  premium: import_zod.z.string().optional()
+});
+var OpenInterestSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  timestamp: import_zod.z.string(),
+  open_interest: import_zod.z.string(),
+  mark_price: import_zod.z.string().optional(),
+  oracle_price: import_zod.z.string().optional(),
+  day_ntl_volume: import_zod.z.string().optional(),
+  prev_day_price: import_zod.z.string().optional(),
+  mid_price: import_zod.z.string().optional(),
+  impact_bid_price: import_zod.z.string().optional(),
+  impact_ask_price: import_zod.z.string().optional()
+});
+var WsChannelSchema = import_zod.z.enum(["orderbook", "trades", "ticker", "all_tickers"]);
+var WsConnectionStateSchema = import_zod.z.enum(["connecting", "connected", "disconnected", "reconnecting"]);
+var WsSubscribedSchema = import_zod.z.object({
+  type: import_zod.z.literal("subscribed"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string().optional()
+});
+var WsUnsubscribedSchema = import_zod.z.object({
+  type: import_zod.z.literal("unsubscribed"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string().optional()
+});
+var WsPongSchema = import_zod.z.object({
+  type: import_zod.z.literal("pong")
+});
+var WsErrorSchema = import_zod.z.object({
+  type: import_zod.z.literal("error"),
+  message: import_zod.z.string()
+});
+var WsDataSchema = import_zod.z.object({
+  type: import_zod.z.literal("data"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  data: import_zod.z.unknown()
+});
+var WsReplayStartedSchema = import_zod.z.object({
+  type: import_zod.z.literal("replay_started"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  start: import_zod.z.number(),
+  end: import_zod.z.number(),
+  speed: import_zod.z.number()
+});
+var WsReplayPausedSchema = import_zod.z.object({
+  type: import_zod.z.literal("replay_paused"),
+  current_timestamp: import_zod.z.number()
+});
+var WsReplayResumedSchema = import_zod.z.object({
+  type: import_zod.z.literal("replay_resumed"),
+  current_timestamp: import_zod.z.number()
+});
+var WsReplayCompletedSchema = import_zod.z.object({
+  type: import_zod.z.literal("replay_completed"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  snapshots_sent: import_zod.z.number()
+});
+var WsReplayStoppedSchema = import_zod.z.object({
+  type: import_zod.z.literal("replay_stopped")
+});
+var WsHistoricalDataSchema = import_zod.z.object({
+  type: import_zod.z.literal("historical_data"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.unknown()
+});
+var WsStreamStartedSchema = import_zod.z.object({
+  type: import_zod.z.literal("stream_started"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  start: import_zod.z.number(),
+  end: import_zod.z.number()
+});
+var WsStreamProgressSchema = import_zod.z.object({
+  type: import_zod.z.literal("stream_progress"),
+  snapshots_sent: import_zod.z.number()
+});
+var TimestampedRecordSchema = import_zod.z.object({
+  timestamp: import_zod.z.number(),
+  data: import_zod.z.unknown()
+});
+var WsHistoricalBatchSchema = import_zod.z.object({
+  type: import_zod.z.literal("historical_batch"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  data: import_zod.z.array(TimestampedRecordSchema)
+});
+var WsStreamCompletedSchema = import_zod.z.object({
+  type: import_zod.z.literal("stream_completed"),
+  channel: WsChannelSchema,
+  coin: import_zod.z.string(),
+  snapshots_sent: import_zod.z.number()
+});
+var WsStreamStoppedSchema = import_zod.z.object({
+  type: import_zod.z.literal("stream_stopped"),
+  snapshots_sent: import_zod.z.number()
+});
+var WsServerMessageSchema = import_zod.z.discriminatedUnion("type", [
+  WsSubscribedSchema,
+  WsUnsubscribedSchema,
+  WsPongSchema,
+  WsErrorSchema,
+  WsDataSchema,
+  WsReplayStartedSchema,
+  WsReplayPausedSchema,
+  WsReplayResumedSchema,
+  WsReplayCompletedSchema,
+  WsReplayStoppedSchema,
+  WsHistoricalDataSchema,
+  WsStreamStartedSchema,
+  WsStreamProgressSchema,
+  WsHistoricalBatchSchema,
+  WsStreamCompletedSchema,
+  WsStreamStoppedSchema
+]);
+var OrderBookResponseSchema = ApiResponseSchema(OrderBookSchema);
+var OrderBookArrayResponseSchema = ApiResponseSchema(import_zod.z.array(OrderBookSchema));
+var TradeArrayResponseSchema = ApiResponseSchema(import_zod.z.array(TradeSchema));
+var InstrumentResponseSchema = ApiResponseSchema(InstrumentSchema);
+var InstrumentArrayResponseSchema = ApiResponseSchema(import_zod.z.array(InstrumentSchema));
+var FundingRateResponseSchema = ApiResponseSchema(FundingRateSchema);
+var FundingRateArrayResponseSchema = ApiResponseSchema(import_zod.z.array(FundingRateSchema));
+var OpenInterestResponseSchema = ApiResponseSchema(OpenInterestSchema);
+var OpenInterestArrayResponseSchema = ApiResponseSchema(import_zod.z.array(OpenInterestSchema));
+
 // src/resources/orderbook.ts
 var OrderBookResource = class {
   constructor(http) {
@@ -114,7 +373,8 @@ var OrderBookResource = class {
   async get(coin, params) {
     const response = await this.http.get(
       `/v1/orderbook/${coin.toUpperCase()}`,
-      params
+      params,
+      this.http.validationEnabled ? OrderBookResponseSchema : void 0
     );
     return response.data;
   }
@@ -128,7 +388,8 @@ var OrderBookResource = class {
   async history(coin, params) {
     const response = await this.http.get(
       `/v1/orderbook/${coin.toUpperCase()}/history`,
-      params
+      params,
+      this.http.validationEnabled ? OrderBookArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -172,7 +433,8 @@ var TradesResource = class {
   async list(coin, params) {
     const response = await this.http.get(
       `/v1/trades/${coin.toUpperCase()}`,
-      params
+      params,
+      this.http.validationEnabled ? TradeArrayResponseSchema : void 0
     );
     return {
       data: response.data,
@@ -189,7 +451,8 @@ var TradesResource = class {
   async recent(coin, limit) {
     const response = await this.http.get(
       `/v1/trades/${coin.toUpperCase()}/recent`,
-      { limit }
+      { limit },
+      this.http.validationEnabled ? TradeArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -217,7 +480,8 @@ var TradesResource = class {
   async listWithOffset(coin, params) {
     const response = await this.http.get(
       `/v1/trades/${coin.toUpperCase()}`,
-      params
+      params,
+      this.http.validationEnabled ? TradeArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -235,7 +499,9 @@ var InstrumentsResource = class {
    */
   async list() {
     const response = await this.http.get(
-      "/v1/instruments"
+      "/v1/instruments",
+      void 0,
+      this.http.validationEnabled ? InstrumentArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -247,7 +513,9 @@ var InstrumentsResource = class {
    */
   async get(coin) {
     const response = await this.http.get(
-      `/v1/instruments/${coin.toUpperCase()}`
+      `/v1/instruments/${coin.toUpperCase()}`,
+      void 0,
+      this.http.validationEnabled ? InstrumentResponseSchema : void 0
     );
     return response.data;
   }
@@ -268,7 +536,8 @@ var FundingResource = class {
   async history(coin, params) {
     const response = await this.http.get(
       `/v1/funding/${coin.toUpperCase()}`,
-      params
+      params,
+      this.http.validationEnabled ? FundingRateArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -280,7 +549,9 @@ var FundingResource = class {
    */
   async current(coin) {
     const response = await this.http.get(
-      `/v1/funding/${coin.toUpperCase()}/current`
+      `/v1/funding/${coin.toUpperCase()}/current`,
+      void 0,
+      this.http.validationEnabled ? FundingRateResponseSchema : void 0
     );
     return response.data;
   }
@@ -301,7 +572,8 @@ var OpenInterestResource = class {
   async history(coin, params) {
     const response = await this.http.get(
       `/v1/openinterest/${coin.toUpperCase()}`,
-      params
+      params,
+      this.http.validationEnabled ? OpenInterestArrayResponseSchema : void 0
     );
     return response.data;
   }
@@ -313,7 +585,9 @@ var OpenInterestResource = class {
    */
   async current(coin) {
     const response = await this.http.get(
-      `/v1/openinterest/${coin.toUpperCase()}/current`
+      `/v1/openinterest/${coin.toUpperCase()}/current`,
+      void 0,
+      this.http.validationEnabled ? OpenInterestResponseSchema : void 0
     );
     return response.data;
   }
@@ -356,7 +630,8 @@ var OxArchive = class {
     this.http = new HttpClient({
       baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
       apiKey: options.apiKey,
-      timeout: options.timeout ?? DEFAULT_TIMEOUT
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      validate: options.validate ?? false
     });
     this.orderbook = new OrderBookResource(this.http);
     this.trades = new TradesResource(this.http);
@@ -371,6 +646,39 @@ var DEFAULT_WS_URL = "wss://api.0xarchive.io/ws";
 var DEFAULT_PING_INTERVAL = 3e4;
 var DEFAULT_RECONNECT_DELAY = 1e3;
 var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+function transformTrade(coin, raw) {
+  if ("price" in raw && "size" in raw) {
+    return raw;
+  }
+  const px = raw.px;
+  const sz = raw.sz;
+  const side = raw.side;
+  const time = raw.time;
+  const hash = raw.hash;
+  const tid = raw.tid;
+  const users = raw.users;
+  const maker_address = users && users.length > 0 ? users[0] : void 0;
+  const taker_address = users && users.length > 1 ? users[1] : void 0;
+  const user_address = raw.userAddress ?? raw.user_address;
+  return {
+    coin,
+    side: side === "A" || side === "B" ? side : "B",
+    price: px ?? "0",
+    size: sz ?? "0",
+    timestamp: time ? new Date(time).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    tx_hash: hash,
+    trade_id: tid,
+    maker_address,
+    taker_address,
+    user_address
+  };
+}
+function transformTrades(coin, rawTrades) {
+  if (!Array.isArray(rawTrades)) {
+    return [transformTrade(coin, rawTrades)];
+  }
+  return rawTrades.map((raw) => transformTrade(coin, raw));
+}
 function transformOrderbook(coin, raw) {
   if ("bids" in raw && "asks" in raw) {
     return raw;
@@ -826,8 +1134,9 @@ var OxArchiveWs = class {
             handler(message.coin, orderbook);
           }
         } else if (message.channel === "trades") {
+          const trades = transformTrades(message.coin, message.data);
           for (const handler of this.tradesHandlers) {
-            handler(message.coin, message.data);
+            handler(message.coin, trades);
           }
         }
         break;
@@ -837,8 +1146,49 @@ var OxArchiveWs = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ApiMetaSchema,
+  ApiResponseSchema,
+  DataSourceSchema,
+  FundingRateArrayResponseSchema,
+  FundingRateResponseSchema,
+  FundingRateSchema,
+  InstrumentArrayResponseSchema,
+  InstrumentResponseSchema,
+  InstrumentSchema,
+  InstrumentTypeSchema,
+  OpenInterestArrayResponseSchema,
+  OpenInterestResponseSchema,
+  OpenInterestSchema,
+  OrderBookArrayResponseSchema,
+  OrderBookResponseSchema,
+  OrderBookSchema,
   OxArchive,
   OxArchiveError,
-  OxArchiveWs
+  OxArchiveWs,
+  PriceLevelSchema,
+  TimestampedRecordSchema,
+  TradeArrayResponseSchema,
+  TradeDirectionSchema,
+  TradeSchema,
+  TradeSideSchema,
+  WsChannelSchema,
+  WsConnectionStateSchema,
+  WsDataSchema,
+  WsErrorSchema,
+  WsHistoricalBatchSchema,
+  WsHistoricalDataSchema,
+  WsPongSchema,
+  WsReplayCompletedSchema,
+  WsReplayPausedSchema,
+  WsReplayResumedSchema,
+  WsReplayStartedSchema,
+  WsReplayStoppedSchema,
+  WsServerMessageSchema,
+  WsStreamCompletedSchema,
+  WsStreamProgressSchema,
+  WsStreamStartedSchema,
+  WsStreamStoppedSchema,
+  WsSubscribedSchema,
+  WsUnsubscribedSchema
 });
 //# sourceMappingURL=index.js.map