@nadohq/indexer-client 0.15.0 → 0.17.0

package/dist/IndexerClient.js

@@ -1,366 +1,277 @@
-// src/IndexerClient.ts
-import {
-  NLP_PRODUCT_ID,
-  ProductEngineType,
-  QUOTE_PRODUCT_ID,
-  subaccountFromHex,
-  toBigNumber,
-  toIntegerString
-} from "@nadohq/shared";
 import { IndexerBaseClient } from "./IndexerBaseClient.js";
+import { NLP_PRODUCT_ID, ProductEngineType, QUOTE_PRODUCT_ID, subaccountFromHex, toBigNumber, toIntegerString } from "@nadohq/shared";
+//#region src/IndexerClient.ts
+/**
+* Indexer client providing paginated queries for historical data from the Nado indexer service
+*/
 var IndexerClient = class extends IndexerBaseClient {
-  async getPaginatedSubaccountMatchEvents(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner,
-      isolated,
-      productIds
-    } = params;
-    const limit = requestedLimit + 1;
-    const events = await this.getMatchEvents({
-      startCursor,
-      maxTimestampInclusive,
-      limit,
-      subaccounts: [{ subaccountName, subaccountOwner }],
-      productIds,
-      isolated
-    });
-    return this.getPaginationEventsResponse(events, requestedLimit);
-  }
-  async getPaginatedSubaccountNlpEvents(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner
-    } = params;
-    const limit = requestedLimit + 1;
-    const baseResponse = await this.getEvents({
-      startCursor,
-      maxTimestampInclusive,
-      eventTypes: ["mint_nlp", "burn_nlp"],
-      limit: {
-        type: "txs",
-        value: limit
-      },
-      subaccounts: [{ subaccountName, subaccountOwner }]
-    });
-    const eventsBySubmissionIdx = /* @__PURE__ */ new Map();
-    baseResponse.forEach((event) => {
-      const mappedEvent = (() => {
-        const existingEvent = eventsBySubmissionIdx.get(event.submissionIndex);
-        if (existingEvent) {
-          return existingEvent;
-        }
-        const newEvent = {
-          nlpDelta: toBigNumber(0),
-          primaryQuoteDelta: toBigNumber(0),
-          timestamp: event.timestamp,
-          submissionIndex: event.submissionIndex,
-          tx: event.tx,
-          ...subaccountFromHex(event.subaccount)
-        };
-        eventsBySubmissionIdx.set(event.submissionIndex, newEvent);
-        return newEvent;
-      })();
-      const balanceDelta = event.state.postBalance.amount.minus(
-        event.state.preBalance.amount
-      );
-      const productId = event.state.market.productId;
-      if (productId === QUOTE_PRODUCT_ID) {
-        mappedEvent.primaryQuoteDelta = balanceDelta;
-      } else if (productId === NLP_PRODUCT_ID) {
-        mappedEvent.nlpDelta = balanceDelta;
-      } else {
-        throw Error(`Invalid product ID for NLP event ${productId}`);
-      }
-    });
-    const events = Array.from(eventsBySubmissionIdx.values());
-    return this.getPaginationEventsResponse(events, requestedLimit);
-  }
-  async getPaginatedSubaccountCollateralEvents(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner,
-      eventTypes,
-      isolated
-    } = params;
-    const limit = requestedLimit + 1;
-    const baseResponse = await this.getEvents({
-      startCursor,
-      maxTimestampInclusive,
-      eventTypes: eventTypes ?? [
-        "deposit_collateral",
-        "withdraw_collateral",
-        "transfer_quote"
-      ],
-      limit: {
-        type: "txs",
-        value: limit
-      },
-      subaccounts: [{ subaccountName, subaccountOwner }],
-      isolated
-    });
-    const events = baseResponse.map((event) => {
-      if (event.state.type !== ProductEngineType.SPOT) {
-        throw Error("Incorrect event state for collateral event");
-      }
-      return {
-        timestamp: event.timestamp,
-        // This cast is safe as the query param restricts to collateral events
-        eventType: event.eventType,
-        submissionIndex: event.submissionIndex,
-        snapshot: event.state,
-        amount: event.state.postBalance.amount.minus(
-          event.state.preBalance.amount
-        ),
-        newAmount: event.state.postBalance.amount,
-        tx: event.tx,
-        ...subaccountFromHex(event.subaccount)
-      };
-    });
-    return this.getPaginationEventsResponse(events, requestedLimit);
-  }
-  async getPaginatedSubaccountOrders(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner,
-      productIds,
-      triggerTypes,
-      isolated
-    } = params;
-    const limit = requestedLimit + 1;
-    const baseResponse = await this.getOrders({
-      startCursor,
-      maxTimestampInclusive,
-      subaccounts: [{ subaccountName, subaccountOwner }],
-      limit,
-      productIds,
-      triggerTypes,
-      isolated
-    });
-    const truncatedOrders = baseResponse.slice(0, requestedLimit);
-    const hasMore = baseResponse.length > truncatedOrders.length;
-    return {
-      meta: {
-        hasMore,
-        nextCursor: baseResponse[truncatedOrders.length]?.submissionIndex
-      },
-      orders: truncatedOrders
-    };
-  }
-  async getPaginatedSubaccountSettlementEvents(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner
-    } = params;
-    const limit = requestedLimit + 1;
-    const baseResponse = await this.getEvents({
-      startCursor,
-      maxTimestampInclusive,
-      eventTypes: ["settle_pnl"],
-      limit: {
-        type: "txs",
-        value: limit
-      },
-      subaccounts: [{ subaccountName, subaccountOwner }]
-    });
-    const events = baseResponse.map((event) => {
-      if (event.state.market.productId === QUOTE_PRODUCT_ID) {
-        return;
-      }
-      if (event.state.type !== ProductEngineType.PERP) {
-        throw Error("Incorrect event state for settlement event");
-      }
-      return {
-        timestamp: event.timestamp,
-        submissionIndex: event.submissionIndex,
-        snapshot: event.state,
-        // Spot quote delta = -vQuote delta
-        quoteDelta: event.state.preBalance.vQuoteBalance.minus(
-          event.state.postBalance.vQuoteBalance
-        ),
-        isolated: event.isolated,
-        tx: event.tx,
-        ...subaccountFromHex(event.subaccount)
-      };
-    }).filter((event) => !!event);
-    return this.getPaginationEventsResponse(events, requestedLimit);
-  }
-  async getPaginatedSubaccountLiquidationEvents(params) {
-    const {
-      startCursor,
-      maxTimestampInclusive,
-      limit: requestedLimit,
-      subaccountName,
-      subaccountOwner,
-      productIds
-    } = params;
-    const limit = requestedLimit + 1;
-    const baseResponse = await this.getEvents({
-      startCursor,
-      maxTimestampInclusive,
-      eventTypes: ["liquidate_subaccount"],
-      limit: {
-        type: "txs",
-        value: limit
-      },
-      subaccounts: [{ subaccountName, subaccountOwner }],
-      productIds
-    });
-    const eventsBySubmissionIdx = /* @__PURE__ */ new Map();
-    const productIdsSet = productIds ? new Set(productIds) : void 0;
-    baseResponse.forEach((event) => {
-      if (productIdsSet && !productIdsSet.has(
-        // product_id can also encode a health group for spread liquidation, but we ignore
-        // this case for now
-        event.tx.liquidate_subaccount.product_id
-      )) {
-        return;
-      }
-      const mappedEvent = (() => {
-        const existingEvent = eventsBySubmissionIdx.get(event.submissionIndex);
-        if (existingEvent) {
-          return existingEvent;
-        }
-        const newEvent = {
-          perp: void 0,
-          spot: void 0,
-          quote: void 0,
-          timestamp: event.timestamp,
-          submissionIndex: event.submissionIndex
-        };
-        return newEvent;
-      })();
-      const balanceDelta = event.state.postBalance.amount.minus(
-        event.state.preBalance.amount
-      );
-      if (balanceDelta.isZero() && event.state.market.productId !== QUOTE_PRODUCT_ID) {
-        return;
-      }
-      if (event.state.type === ProductEngineType.PERP) {
-        mappedEvent.perp = {
-          amountLiquidated: balanceDelta.negated(),
-          // This cast is safe because we're checking for event.state.type
-          indexerEvent: event
-        };
-      } else if (event.state.market.productId === QUOTE_PRODUCT_ID) {
-        mappedEvent.quote = {
-          balanceDelta,
-          indexerEvent: event
-        };
-      } else {
-        mappedEvent.spot = {
-          amountLiquidated: balanceDelta.negated(),
-          indexerEvent: event
-        };
-      }
-      eventsBySubmissionIdx.set(event.submissionIndex, mappedEvent);
-    });
-    const events = Array.from(
-      eventsBySubmissionIdx.values()
-    );
-    return this.getPaginationEventsResponse(events, requestedLimit);
-  }
-  /**
-   * Get all interest funding payments for a given subaccount with the standard pagination response
-   * This is a simple wrapper over the underlying `getInterestFundingPayments` function. Very little
-   * additional processing is needed because the endpoint is well structured for pagination
-   *
-   * @param params
-   */
-  async getPaginatedSubaccountInterestFundingPayments(params) {
-    const {
-      limit,
-      productIds,
-      startCursor,
-      maxTimestampInclusive,
-      subaccountName,
-      subaccountOwner
-    } = params;
-    const baseResponse = await this.getInterestFundingPayments({
-      limit,
-      productIds,
-      startCursor,
-      maxTimestampInclusive,
-      subaccount: {
-        subaccountName,
-        subaccountOwner
-      }
-    });
-    return {
-      ...baseResponse,
-      meta: {
-        hasMore: baseResponse.nextCursor != null,
-        nextCursor: baseResponse.nextCursor ?? void 0
-      }
-    };
-  }
-  /**
-   * Paginated leaderboard query that paginates on rank number.
-   *
-   * @param params
-   */
-  async getPaginatedLeaderboard(params) {
-    const requestedLimit = params.limit;
-    const baseResponse = await this.getLeaderboard({
-      contestId: params.contestId,
-      rankType: params.rankType,
-      // Query for 1 more result for proper pagination
-      limit: requestedLimit + 1,
-      // Start cursor is the next rank number
-      startCursor: params.startCursor
-    });
-    const overflowParticipant = baseResponse.participants[requestedLimit];
-    let nextCursor;
-    if (overflowParticipant) {
-      const trackData = params.rankType ? overflowParticipant.tracks[params.rankType] : Object.values(overflowParticipant.tracks)[0];
-      nextCursor = trackData.rank;
-    }
-    return {
-      ...baseResponse,
-      // Truncate the response to the requested limit
-      participants: baseResponse.participants.slice(0, requestedLimit),
-      meta: {
-        hasMore: baseResponse.participants.length > requestedLimit,
-        nextCursor: nextCursor !== void 0 ? toIntegerString(nextCursor) : void 0
-      }
-    };
-  }
-  /**
-   * A util function to generate the standard pagination response for events
-   * @param events
-   * @param requestedLimit given by consumers of the SDK
-   * @private
-   */
-  getPaginationEventsResponse(events, requestedLimit) {
-    const truncatedEvents = events.slice(0, requestedLimit);
-    const hasMore = events.length > truncatedEvents.length;
-    return {
-      events: truncatedEvents,
-      meta: {
-        hasMore,
-        // We want the NEXT available cursor, so we use the first event after the truncation cutoff
-        // If len(events) === len(truncatedEvents), there are no more entries and this is undefined
-        nextCursor: events[truncatedEvents.length]?.submissionIndex
-      }
-    };
-  }
-};
-export {
-  IndexerClient
+	async getPaginatedSubaccountMatchEvents(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner, isolated, productIds } = params;
+		const limit = requestedLimit + 1;
+		const events = await this.getMatchEvents({
+			startCursor,
+			maxTimestampInclusive,
+			limit,
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}],
+			productIds,
+			isolated
+		});
+		return this.getPaginationEventsResponse(events, requestedLimit);
+	}
+	async getPaginatedSubaccountNlpEvents(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner } = params;
+		const limit = requestedLimit + 1;
+		const baseResponse = await this.getEvents({
+			startCursor,
+			maxTimestampInclusive,
+			eventTypes: ["mint_nlp", "burn_nlp"],
+			limit: {
+				type: "txs",
+				value: limit
+			},
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}]
+		});
+		const eventsBySubmissionIdx = /* @__PURE__ */ new Map();
+		baseResponse.forEach((event) => {
+			const mappedEvent = (() => {
+				const existingEvent = eventsBySubmissionIdx.get(event.submissionIndex);
+				if (existingEvent) return existingEvent;
+				const newEvent = {
+					nlpDelta: toBigNumber(0),
+					primaryQuoteDelta: toBigNumber(0),
+					timestamp: event.timestamp,
+					submissionIndex: event.submissionIndex,
+					tx: event.tx,
+					...subaccountFromHex(event.subaccount)
+				};
+				eventsBySubmissionIdx.set(event.submissionIndex, newEvent);
+				return newEvent;
+			})();
+			const balanceDelta = event.state.postBalance.amount.minus(event.state.preBalance.amount);
+			const productId = event.state.market.productId;
+			if (productId === QUOTE_PRODUCT_ID) mappedEvent.primaryQuoteDelta = balanceDelta;
+			else if (productId === NLP_PRODUCT_ID) mappedEvent.nlpDelta = balanceDelta;
+			else throw Error(`Invalid product ID for NLP event ${productId}`);
+		});
+		const events = Array.from(eventsBySubmissionIdx.values());
+		return this.getPaginationEventsResponse(events, requestedLimit);
+	}
+	async getPaginatedSubaccountCollateralEvents(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner, eventTypes, isolated } = params;
+		const limit = requestedLimit + 1;
+		const events = (await this.getEvents({
+			startCursor,
+			maxTimestampInclusive,
+			eventTypes: eventTypes ?? [
+				"deposit_collateral",
+				"withdraw_collateral",
+				"transfer_quote"
+			],
+			limit: {
+				type: "txs",
+				value: limit
+			},
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}],
+			isolated
+		})).map((event) => {
+			if (event.state.type !== ProductEngineType.SPOT) throw Error("Incorrect event state for collateral event");
+			return {
+				timestamp: event.timestamp,
+				eventType: event.eventType,
+				submissionIndex: event.submissionIndex,
+				snapshot: event.state,
+				amount: event.state.postBalance.amount.minus(event.state.preBalance.amount),
+				newAmount: event.state.postBalance.amount,
+				tx: event.tx,
+				...subaccountFromHex(event.subaccount)
+			};
+		});
+		return this.getPaginationEventsResponse(events, requestedLimit);
+	}
+	async getPaginatedSubaccountOrders(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner, productIds, triggerTypes, isolated } = params;
+		const limit = requestedLimit + 1;
+		const baseResponse = await this.getOrders({
+			startCursor,
+			maxTimestampInclusive,
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}],
+			limit,
+			productIds,
+			triggerTypes,
+			isolated
+		});
+		const truncatedOrders = baseResponse.slice(0, requestedLimit);
+		return {
+			meta: {
+				hasMore: baseResponse.length > truncatedOrders.length,
+				nextCursor: baseResponse[truncatedOrders.length]?.submissionIndex
+			},
+			orders: truncatedOrders
+		};
+	}
+	async getPaginatedSubaccountSettlementEvents(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner } = params;
+		const limit = requestedLimit + 1;
+		const events = (await this.getEvents({
+			startCursor,
+			maxTimestampInclusive,
+			eventTypes: ["settle_pnl"],
+			limit: {
+				type: "txs",
+				value: limit
+			},
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}]
+		})).map((event) => {
+			if (event.state.market.productId === QUOTE_PRODUCT_ID) return;
+			if (event.state.type !== ProductEngineType.PERP) throw Error("Incorrect event state for settlement event");
+			return {
+				timestamp: event.timestamp,
+				submissionIndex: event.submissionIndex,
+				snapshot: event.state,
+				quoteDelta: event.state.preBalance.vQuoteBalance.minus(event.state.postBalance.vQuoteBalance),
+				isolated: event.isolated,
+				tx: event.tx,
+				...subaccountFromHex(event.subaccount)
+			};
+		}).filter((event) => !!event);
+		return this.getPaginationEventsResponse(events, requestedLimit);
+	}
+	async getPaginatedSubaccountLiquidationEvents(params) {
+		const { startCursor, maxTimestampInclusive, limit: requestedLimit, subaccountName, subaccountOwner, productIds } = params;
+		const limit = requestedLimit + 1;
+		const baseResponse = await this.getEvents({
+			startCursor,
+			maxTimestampInclusive,
+			eventTypes: ["liquidate_subaccount"],
+			limit: {
+				type: "txs",
+				value: limit
+			},
+			subaccounts: [{
+				subaccountName,
+				subaccountOwner
+			}],
+			productIds
+		});
+		const eventsBySubmissionIdx = /* @__PURE__ */ new Map();
+		const productIdsSet = productIds ? new Set(productIds) : void 0;
+		baseResponse.forEach((event) => {
+			if (productIdsSet && !productIdsSet.has(event.tx.liquidate_subaccount.product_id)) return;
+			const mappedEvent = (() => {
+				const existingEvent = eventsBySubmissionIdx.get(event.submissionIndex);
+				if (existingEvent) return existingEvent;
+				return {
+					perp: void 0,
+					spot: void 0,
+					quote: void 0,
+					timestamp: event.timestamp,
+					submissionIndex: event.submissionIndex
+				};
+			})();
+			const balanceDelta = event.state.postBalance.amount.minus(event.state.preBalance.amount);
+			if (balanceDelta.isZero() && event.state.market.productId !== QUOTE_PRODUCT_ID) return;
+			if (event.state.type === ProductEngineType.PERP) mappedEvent.perp = {
+				amountLiquidated: balanceDelta.negated(),
+				indexerEvent: event
+			};
+			else if (event.state.market.productId === QUOTE_PRODUCT_ID) mappedEvent.quote = {
+				balanceDelta,
+				indexerEvent: event
+			};
+			else mappedEvent.spot = {
+				amountLiquidated: balanceDelta.negated(),
+				indexerEvent: event
+			};
+			eventsBySubmissionIdx.set(event.submissionIndex, mappedEvent);
+		});
+		const events = Array.from(eventsBySubmissionIdx.values());
+		return this.getPaginationEventsResponse(events, requestedLimit);
+	}
+	/**
+	* Get all interest funding payments for a given subaccount with the standard pagination response
+	* This is a simple wrapper over the underlying `getInterestFundingPayments` function. Very little
+	* additional processing is needed because the endpoint is well structured for pagination
+	*
+	* @param params
+	*/
+	async getPaginatedSubaccountInterestFundingPayments(params) {
+		const { limit, productIds, startCursor, maxTimestampInclusive, subaccountName, subaccountOwner } = params;
+		const baseResponse = await this.getInterestFundingPayments({
+			limit,
+			productIds,
+			startCursor,
+			maxTimestampInclusive,
+			subaccount: {
+				subaccountName,
+				subaccountOwner
+			}
+		});
+		return {
+			...baseResponse,
+			meta: {
+				hasMore: baseResponse.nextCursor != null,
+				nextCursor: baseResponse.nextCursor ?? void 0
+			}
+		};
+	}
+	/**
+	* Paginated leaderboard query that paginates on rank number.
+	*
+	* @param params
+	*/
+	async getPaginatedLeaderboard(params) {
+		const requestedLimit = params.limit;
+		const baseResponse = await this.getLeaderboard({
+			contestId: params.contestId,
+			rankType: params.rankType,
+			limit: requestedLimit + 1,
+			startCursor: params.startCursor
+		});
+		const overflowParticipant = baseResponse.participants[requestedLimit];
+		let nextCursor;
+		if (overflowParticipant) nextCursor = (params.rankType ? overflowParticipant.tracks[params.rankType] : Object.values(overflowParticipant.tracks)[0]).rank;
+		return {
+			...baseResponse,
+			participants: baseResponse.participants.slice(0, requestedLimit),
+			meta: {
+				hasMore: baseResponse.participants.length > requestedLimit,
+				nextCursor: nextCursor !== void 0 ? toIntegerString(nextCursor) : void 0
+			}
+		};
+	}
+	/**
+	* A util function to generate the standard pagination response for events
+	* @param events
+	* @param requestedLimit given by consumers of the SDK
+	* @private
+	*/
+	getPaginationEventsResponse(events, requestedLimit) {
+		const truncatedEvents = events.slice(0, requestedLimit);
+		return {
+			events: truncatedEvents,
+			meta: {
+				hasMore: events.length > truncatedEvents.length,
+				nextCursor: events[truncatedEvents.length]?.submissionIndex
+			}
+		};
+	}
 };
+//#endregion
+export { IndexerClient };
+
 //# sourceMappingURL=IndexerClient.js.map