@nadohq/indexer-client 0.1.0-alpha.1

package/README.md

@@ -0,0 +1,2 @@
+# `@nadohq/indexer-client`
+

package/dist/IndexerBaseClient.cjs

@@ -0,0 +1,608 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/IndexerBaseClient.ts
+var IndexerBaseClient_exports = {};
+__export(IndexerBaseClient_exports, {
+  IndexerBaseClient: () => IndexerBaseClient
+});
+module.exports = __toCommonJS(IndexerBaseClient_exports);
+var import_contracts = require("@nadohq/contracts");
+var import_utils = require("@nadohq/utils");
+var import_axios = __toESM(require("axios"), 1);
+var import_dataMappers = require("./dataMappers.cjs");
+var IndexerBaseClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.axiosInstance = import_axios.default.create({
+      withCredentials: true
+    });
+    this.v2Url = opts.v2Url ? opts.v2Url : opts.url.replace("v1", "v2");
+  }
+  /**
+   * List all subaccounts
+   *
+   * @param params
+   */
+  async listSubaccounts(params) {
+    const baseResponse = await this.query("subaccounts", params);
+    return baseResponse.subaccounts.map((item) => {
+      const subaccount = (0, import_contracts.subaccountFromHex)(item.subaccount);
+      return {
+        hexId: item.subaccount,
+        ...subaccount
+      };
+    });
+  }
+  /**
+   * Retrieve snapshots of multiple subaccounts at multiple points in time.
+   * Each snapshot is a view of the subaccount's balances at this point in time, with tracked variables for interest, funding, etc.
+   *
+   * @param params
+   */
+  async getMultiSubaccountSnapshots(params) {
+    const subaccountHexIds = params.subaccounts.map(
+      ({ subaccountOwner, subaccountName }) => (0, import_contracts.subaccountToHex)({
+        subaccountOwner,
+        subaccountName
+      })
+    );
+    const baseResponse = await this.query("account_snapshots", {
+      subaccounts: subaccountHexIds,
+      timestamps: params.timestamps,
+      isolated: params.isolated
+    });
+    const snapshotsBySubaccount = (0, import_utils.mapValues)(
+      baseResponse.snapshots,
+      (balanceSnapshots) => {
+        const snapshotByTimestamp = {};
+        Object.entries(balanceSnapshots).forEach(([timestamp, events]) => {
+          const balances = events.map(import_dataMappers.mapIndexerEvent);
+          snapshotByTimestamp[timestamp] = {
+            timestamp: (0, import_utils.toBigDecimal)(timestamp),
+            balances
+          };
+        });
+        return snapshotByTimestamp;
+      }
+    );
+    return {
+      subaccountHexIds,
+      snapshots: snapshotsBySubaccount
+    };
+  }
+  /**
+   * Retrieves referral code for an address
+   *
+   * @param params
+   */
+  async getReferralCode(params) {
+    const baseResponse = await this.query("referral_code", {
+      subaccount: (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccount.subaccountOwner,
+        subaccountName: params.subaccount.subaccountName
+      })
+    });
+    return {
+      referralCode: baseResponse.referral_code
+    };
+  }
+  /**
+   * Retrieves funding rate for a product, where 1 = 100%
+   * @param params
+   */
+  async getFundingRate(params) {
+    const baseResponse = await this.query("funding_rate", {
+      product_id: params.productId
+    });
+    return (0, import_dataMappers.mapIndexerFundingRate)(baseResponse);
+  }
+  /**
+   * Retrieves funding rate for multiple products, where 1 = 100%
+   * @param params
+   */
+  async getMultiProductFundingRates(params) {
+    const baseResponse = await this.query("funding_rates", {
+      product_ids: params.productIds
+    });
+    return (0, import_utils.mapValues)(baseResponse, import_dataMappers.mapIndexerFundingRate);
+  }
+  /**
+   * Retrieves latest mark/index price for a perp product
+   * @param params
+   */
+  async getPerpPrices(params) {
+    const baseResponse = await this.query("price", {
+      product_id: params.productId
+    });
+    return (0, import_dataMappers.mapIndexerPerpPrices)(baseResponse);
+  }
+  /**
+   * Retrieves latest mark/index price for multiple perp products
+   * @param params
+   */
+  async getMultiProductPerpPrices(params) {
+    const baseResponse = await this.query("perp_prices", {
+      product_ids: params.productIds
+    });
+    return (0, import_utils.mapValues)(baseResponse, import_dataMappers.mapIndexerPerpPrices);
+  }
+  /**
+   * Retrieves latest oracle prices for provided products
+   * @param params
+   */
+  async getOraclePrices(params) {
+    const baseResponse = await this.query("oracle_price", {
+      product_ids: params.productIds
+    });
+    return baseResponse.prices.map((price) => {
+      return {
+        oraclePrice: (0, import_utils.removeDecimals)(price.oracle_price_x18),
+        updateTime: (0, import_utils.toBigDecimal)(price.update_time),
+        productId: price.product_id
+      };
+    });
+  }
+  /**
+   * Retrieves candlesticks for a product
+   * @param params
+   */
+  async getCandlesticks(params) {
+    const baseResponse = await this.query("candlesticks", {
+      product_id: params.productId,
+      max_time: params.maxTimeInclusive,
+      limit: params.limit,
+      granularity: params.period
+    });
+    return baseResponse.candlesticks.map(import_dataMappers.mapIndexerCandlesticks);
+  }
+  /**
+   * Retrieves candlesticks for a product from Edge
+   * @param params
+   */
+  async getEdgeCandlesticks(params) {
+    const baseResponse = await this.query("edge_candlesticks", {
+      product_id: params.productId,
+      max_time: params.maxTimeInclusive,
+      limit: params.limit,
+      granularity: params.period
+    });
+    return baseResponse.candlesticks.map(import_dataMappers.mapIndexerCandlesticks);
+  }
+  /**
+   * Retrieves historical snapshots for a product
+   * @param params
+   */
+  async getProductSnapshots(params) {
+    const baseResponse = await this.query("products", {
+      product_id: params.productId,
+      max_time: params.maxTimestampInclusive,
+      limit: params.limit,
+      idx: params.startCursor
+    });
+    return baseResponse.products.map((product) => {
+      return {
+        ...(0, import_dataMappers.mapIndexerServerProduct)(product.product),
+        submissionIndex: product.submission_idx
+      };
+    });
+  }
+  /**
+   * Retrieves historical snapshots for multiple products
+   * @param params
+   */
+  async getMultiProductSnapshots(params) {
+    const timestampToProductsMap = await this.query("product_snapshots", {
+      product_ids: params.productIds,
+      max_time: params.maxTimestampInclusive ?? [(0, import_utils.nowInSeconds)()]
+    });
+    return (0, import_utils.mapValues)(timestampToProductsMap, (productIdToProduct) => {
+      return (0, import_utils.mapValues)(productIdToProduct, (indexerProduct) => {
+        return {
+          ...(0, import_dataMappers.mapIndexerServerProduct)(indexerProduct.product),
+          submissionIndex: indexerProduct.submission_idx
+        };
+      });
+    });
+  }
+  /**
+   * Retrieves historical events
+   *
+   * @param params
+   */
+  async getEvents(params) {
+    const serverLimit = (() => {
+      if (!params.limit) {
+        return;
+      }
+      if (params.limit.type === "events") {
+        return {
+          raw: params.limit.value
+        };
+      }
+      return {
+        txs: params.limit.value
+      };
+    })();
+    const baseResponse = await this.query("events", {
+      subaccount: params.subaccount ? (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccount.subaccountOwner,
+        subaccountName: params.subaccount.subaccountName
+      }) : void 0,
+      product_ids: params.productIds,
+      isolated: params.isolated,
+      event_types: params.eventTypes,
+      max_time: params.maxTimestampInclusive,
+      desc: params.desc,
+      limit: serverLimit,
+      idx: params.startCursor
+    });
+    let lastTxIdx = 0;
+    return baseResponse.events.map((event) => {
+      if (baseResponse.txs[lastTxIdx].submission_idx !== event.submission_idx) {
+        lastTxIdx += 1;
+      }
+      const tx = baseResponse.txs[lastTxIdx];
+      return (0, import_dataMappers.mapIndexerEventWithTx)(event, tx);
+    });
+  }
+  /**
+   * Retrieves historical orders
+   * @param params
+   */
+  async getOrders(params) {
+    const baseResponse = await this.query("orders", {
+      subaccount: params.subaccount ? (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccount.subaccountOwner,
+        subaccountName: params.subaccount.subaccountName
+      }) : void 0,
+      product_ids: params.productIds,
+      isolated: params.isolated,
+      digests: params.digests,
+      max_time: params.maxTimestampInclusive,
+      limit: params.limit,
+      idx: params.startCursor
+    });
+    return baseResponse.orders.map(import_dataMappers.mapIndexerOrder);
+  }
+  /**
+   * Gets match order events, this will return the same events as the events query, but with additional information
+   * to identify the order that was matched
+   *
+   * @param params
+   */
+  async getMatchEvents(params) {
+    const baseResponse = await this.query("matches", {
+      subaccount: params.subaccount ? (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccount.subaccountOwner,
+        subaccountName: params.subaccount.subaccountName
+      }) : void 0,
+      product_ids: params.productIds,
+      isolated: params.isolated,
+      max_time: params.maxTimestampInclusive,
+      limit: params.limit,
+      idx: params.startCursor
+    });
+    let lastTxIdx = 0;
+    return baseResponse.matches.map((matchEvent) => {
+      if (baseResponse.txs[lastTxIdx].submission_idx !== matchEvent.submission_idx) {
+        lastTxIdx += 1;
+      }
+      const { tx, timestamp } = baseResponse.txs[lastTxIdx];
+      const postBalances = (0, import_dataMappers.mapIndexerMatchEventBalances)(
+        matchEvent.post_balance
+      );
+      return {
+        productId: postBalances.base.productId,
+        isolated: matchEvent.isolated,
+        totalFee: (0, import_utils.toBigDecimal)(matchEvent.fee),
+        sequencerFee: (0, import_utils.toBigDecimal)(matchEvent.sequencer_fee),
+        baseFilled: (0, import_utils.toBigDecimal)(matchEvent.base_filled),
+        quoteFilled: (0, import_utils.toBigDecimal)(matchEvent.quote_filled),
+        cumulativeFee: (0, import_utils.toBigDecimal)(matchEvent.cumulative_fee),
+        cumulativeBaseFilled: (0, import_utils.toBigDecimal)(matchEvent.cumulative_base_filled),
+        cumulativeQuoteFilled: (0, import_utils.toBigDecimal)(matchEvent.cumulative_quote_filled),
+        digest: matchEvent.digest,
+        order: matchEvent.order,
+        submissionIndex: matchEvent.submission_idx,
+        timestamp: (0, import_utils.toBigDecimal)(timestamp),
+        preEventTrackedVars: {
+          netEntryUnrealized: (0, import_utils.toBigDecimal)(matchEvent.net_entry_unrealized),
+          netEntryCumulative: (0, import_utils.toBigDecimal)(matchEvent.net_entry_cumulative)
+        },
+        preBalances: (0, import_dataMappers.mapIndexerMatchEventBalances)(matchEvent.pre_balance),
+        postBalances,
+        tx,
+        ...(0, import_contracts.subaccountFromHex)(matchEvent.order.sender)
+      };
+    });
+  }
+  /**
+   * Retrieves historical funding & interest payments.
+   * NOTE: `limit` is an upperbound. If a user changes position size such that his position is 0 during each funding/interest tick,
+   *        then the indexer will return fewer than `limit` results per page. However, more events can be present. This means that
+   *        there isn't a reliable way to determine whether there is a next page. We just need to keep paginating until the next cursor is null.
+   *
+   * @param params
+   */
+  async getInterestFundingPayments(params) {
+    const baseResponse = await this.query("interest_and_funding", {
+      subaccount: (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccount.subaccountOwner,
+        subaccountName: params.subaccount.subaccountName
+      }),
+      product_ids: params.productIds,
+      max_time: params.maxTimestampInclusive,
+      limit: params.limit,
+      max_idx: params.startCursor
+    });
+    return {
+      fundingPayments: baseResponse.funding_payments.map(
+        import_dataMappers.mapIndexerProductPayment
+      ),
+      interestPayments: baseResponse.interest_payments.map(
+        import_dataMappers.mapIndexerProductPayment
+      ),
+      nextCursor: baseResponse.next_idx
+    };
+  }
+  /**
+   * Gets quote (USDC) price in terms of USD
+   */
+  async getQuotePrice() {
+    const baseResponse = await this.query("usdc_price", {});
+    return {
+      price: (0, import_utils.removeDecimals)(baseResponse.price_x18)
+    };
+  }
+  /**
+   * Fetches currently registered linked signer with the remaining txs allowed for the subaccount
+   */
+  async getLinkedSignerWithRateLimit(params) {
+    const baseResponse = await this.query("linked_signer_rate_limit", {
+      subaccount: (0, import_contracts.subaccountToHex)(params.subaccount)
+    });
+    return {
+      totalTxLimit: (0, import_utils.toBigDecimal)(baseResponse.total_tx_limit),
+      remainingTxs: (0, import_utils.toBigDecimal)(baseResponse.remaining_tx),
+      signer: baseResponse.signer,
+      waitTimeUntilNextTx: (0, import_utils.toBigDecimal)(baseResponse.wait_time)
+    };
+  }
+  /**
+   * Retrieve historical market snapshots
+   * @param params
+   */
+  async getMarketSnapshots(params) {
+    const baseResponse = await this.query("market_snapshots", {
+      interval: (0, import_dataMappers.mapSnapshotsIntervalToServerParams)(params),
+      product_ids: params.productIds
+    });
+    return baseResponse.snapshots.map(import_dataMappers.mapIndexerMarketSnapshot);
+  }
+  /**
+   * Retrieve historical market snapshots from Edge
+   * @param params
+   */
+  async getEdgeMarketSnapshots(params) {
+    const baseResponse = await this.query("edge_market_snapshots", {
+      interval: (0, import_dataMappers.mapSnapshotsIntervalToServerParams)(params)
+    });
+    return (0, import_utils.mapValues)(
+      baseResponse.snapshots,
+      (snapshots) => snapshots.map(import_dataMappers.mapIndexerMarketSnapshot)
+    );
+  }
+  /**
+   * Retrieve maker statistics for a given epoch
+   *
+   * @param params
+   */
+  async getMakerStatistics(params) {
+    const baseResponse = await this.query("maker_statistics", {
+      product_id: params.productId,
+      epoch: params.epoch,
+      interval: params.interval
+    });
+    return {
+      rewardCoefficient: (0, import_utils.toBigDecimal)(baseResponse.reward_coefficient),
+      makers: baseResponse.makers.map(import_dataMappers.mapIndexerMakerStatistics)
+    };
+  }
+  /**
+   * Retrieve leaderboard stats for a given contest
+   *
+   * @param params
+   */
+  async getLeaderboard(params) {
+    const baseResponse = await this.query("leaderboard", {
+      contest_id: params.contestId,
+      rank_type: params.rankType,
+      start: params.startCursor,
+      limit: params.limit
+    });
+    return {
+      participants: baseResponse.positions.map(import_dataMappers.mapIndexerLeaderboardPosition)
+    };
+  }
+  /**
+   * Retrieve leaderboard ranking of a subaccount on a given contest
+   *
+   * @param params
+   */
+  async getLeaderboardParticipant(params) {
+    const baseResponse = await this.query("leaderboard_rank", {
+      subaccount: (0, import_contracts.subaccountToHex)(params.subaccount),
+      contest_ids: params.contestIds
+    });
+    return {
+      participant: (0, import_utils.mapValues)(
+        baseResponse.positions,
+        (position) => (0, import_dataMappers.mapIndexerLeaderboardPosition)(position)
+      )
+    };
+  }
+  /**
+   * Attempts to update a user's registration to the provided `contestId`. This requires signing.
+   * @param params
+   */
+  async updateLeaderboardRegistration(params) {
+    const signatureParams = {
+      // Default to 90 seconds from now if no recvTime is provided
+      expiration: (0, import_utils.toIntegerString)(params.recvTime ?? (0, import_contracts.getDefaultRecvTime)()),
+      subaccountName: params.subaccountName,
+      subaccountOwner: params.subaccountOwner
+    };
+    const tx = (0, import_contracts.getNadoEIP712Values)(
+      "leaderboard_authentication",
+      signatureParams
+    );
+    const signature = await this.sign(
+      "leaderboard_authentication",
+      params.updateRegistration.verifyingAddr,
+      params.updateRegistration.chainId,
+      signatureParams
+    );
+    const updateRegistrationTx = {
+      tx,
+      signature
+    };
+    const baseResponse = await this.query("leaderboard_registration", {
+      subaccount: (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccountOwner,
+        subaccountName: params.subaccountName
+      }),
+      contest_id: params.contestId,
+      update_registration: updateRegistrationTx
+    });
+    return {
+      registration: baseResponse.registration ? (0, import_dataMappers.mapIndexerLeaderboardRegistration)(baseResponse.registration) : null
+    };
+  }
+  /**
+   * Retrieves the registration status for a leaderboard participant for provided `contestId`.
+   * @param params
+   */
+  async getLeaderboardRegistration(params) {
+    const baseResponse = await this.query("leaderboard_registration", {
+      subaccount: (0, import_contracts.subaccountToHex)({
+        subaccountOwner: params.subaccountOwner,
+        subaccountName: params.subaccountName
+      }),
+      contest_id: params.contestId,
+      update_registration: null
+    });
+    return {
+      registration: baseResponse.registration ? (0, import_dataMappers.mapIndexerLeaderboardRegistration)(baseResponse.registration) : null
+    };
+  }
+  /**
+   * Retrieve metadata of provided leaderboard contests
+   *
+   * @param params
+   */
+  async getLeaderboardContests(params) {
+    const baseResponse = await this.query("leaderboard_contests", {
+      contest_ids: params.contestIds
+    });
+    return {
+      contests: baseResponse.contests.map(import_dataMappers.mapIndexerLeaderboardContest)
+    };
+  }
+  /**
+   * Retrieve signature and tx to submit a fast withdrawal
+   *
+   * @param params
+   */
+  async getFastWithdrawalSignature(params) {
+    const baseResponse = await this.query("fast_withdrawal_signature", params);
+    return {
+      idx: (0, import_utils.toBigInt)(baseResponse.idx),
+      tx: baseResponse.tx,
+      txBytes: (0, import_utils.getValidatedHex)(baseResponse.tx_bytes),
+      signatures: baseResponse.signatures.map(import_utils.getValidatedHex)
+    };
+  }
+  async getVlpSnapshots(params) {
+    const baseResponse = await this.query("vlp_snapshots", {
+      interval: {
+        count: params.limit,
+        max_time: params.maxTimeInclusive ? (0, import_utils.toIntegerString)(params.maxTimeInclusive) : void 0,
+        granularity: params.granularity
+      }
+    });
+    return {
+      snapshots: baseResponse.snapshots.map(import_dataMappers.mapIndexerVlpSnapshot)
+    };
+  }
+  async getSequencerBacklog() {
+    const baseResponse = await this.query("backlog", {});
+    return {
+      totalTxs: (0, import_utils.toBigDecimal)(baseResponse.total_txs),
+      totalSubmissions: (0, import_utils.toBigDecimal)(baseResponse.total_submissions),
+      backlogSize: (0, import_utils.toBigDecimal)(baseResponse.backlog_size),
+      updatedAt: (0, import_utils.toBigDecimal)(baseResponse.updated_at),
+      backlogEtaInSeconds: baseResponse.backlog_eta_in_seconds ? (0, import_utils.toBigDecimal)(baseResponse.backlog_eta_in_seconds) : null,
+      txsPerSecond: baseResponse.txs_per_second ? (0, import_utils.toBigDecimal)(baseResponse.txs_per_second) : null
+    };
+  }
+  async query(requestType, params) {
+    const reqBody = {
+      [requestType]: params
+    };
+    const response = await this.axiosInstance.post(this.opts.url, reqBody);
+    this.checkResponseStatus(response);
+    return response.data;
+  }
+  async sign(requestType, verifyingContract, chainId, params) {
+    const walletClient = this.opts.walletClient;
+    if (!walletClient) {
+      throw new import_utils.WalletNotProvidedError();
+    }
+    return (0, import_contracts.getSignedTransactionRequest)({
+      chainId,
+      requestParams: params,
+      requestType,
+      walletClient,
+      verifyingContract
+    });
+  }
+  checkResponseStatus(response) {
+    if (response.status !== 200 || !response.data) {
+      throw Error(
+        `Unexpected response from server: ${response.status} ${response.statusText}`
+      );
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexerBaseClient
+});
+//# sourceMappingURL=IndexerBaseClient.cjs.map