@nadohq/indexer-client 0.14.0 → 0.17.0

package/dist/IndexerBaseClient.js

@@ -1,787 +1,605 @@
-// src/IndexerBaseClient.ts
-import {
-  getDefaultRecvTime,
-  getNadoEIP712Values,
-  getSignedTransactionRequest,
-  getValidatedAddress,
-  getValidatedHex,
-  mapValues,
-  nowInSeconds,
-  removeDecimals,
-  subaccountFromHex,
-  subaccountToHex,
-  toBigInt,
-  toBigNumber,
-  toIntegerString,
-  WalletNotProvidedError
-} from "@nadohq/shared";
+import { mapIndexerCandlesticks, mapIndexerEvent, mapIndexerEventWithTx, mapIndexerFundingRate, mapIndexerLeaderboardContest, mapIndexerLeaderboardPosition, mapIndexerLeaderboardRegistration, mapIndexerMakerStatistics, mapIndexerMarketSnapshot, mapIndexerMatchEventBalances, mapIndexerNlpSnapshot, mapIndexerOrder, mapIndexerPerpPrices, mapIndexerProductPayment, mapIndexerServerProduct, mapIndexerV2Symbols, mapIndexerV2Ticker, mapSnapshotsIntervalToServerParams } from "./dataMappers.js";
+import { WalletNotProvidedError, getDefaultRecvTime, getNadoEIP712Values, getSignedTransactionRequest, getValidatedAddress, getValidatedHex, mapValues, nowInSeconds, removeDecimals, subaccountFromHex, subaccountToHex, toBigInt, toBigNumber, toIntegerString } from "@nadohq/shared";
 import axios from "axios";
-import {
-  mapIndexerCandlesticks,
-  mapIndexerEvent,
-  mapIndexerEventWithTx,
-  mapIndexerFundingRate,
-  mapIndexerLeaderboardContest,
-  mapIndexerLeaderboardPosition,
-  mapIndexerLeaderboardRegistration,
-  mapIndexerMakerStatistics,
-  mapIndexerMarketSnapshot,
-  mapIndexerMatchEventBalances,
-  mapIndexerNlpSnapshot,
-  mapIndexerOrder,
-  mapIndexerPerpPrices,
-  mapIndexerProductPayment,
-  mapIndexerServerProduct,
-  mapIndexerV2Symbols,
-  mapIndexerV2Ticker,
-  mapSnapshotsIntervalToServerParams
-} from "./dataMappers.js";
+//#region src/IndexerBaseClient.ts
+/**
+* Base client for all indexer requests
+*/
 var IndexerBaseClient = class {
-  constructor(opts) {
-    this.opts = opts;
-    this.axiosInstance = axios.create({
-      withCredentials: true,
-      // We have custom logic to validate response status and create an appropriate error
-      validateStatus: () => true
-    });
-    this.v2Url = opts.v2Url ? opts.v2Url : opts.url.replace("v1", "v2");
-  }
-  /**
-   * Sets the linked signer for execute requests
-   *
-   * @param linkedSignerWalletClient The linkedSigner to use for all signatures. Set to null to revert to the chain signer
-   */
-  setLinkedSigner(linkedSignerWalletClient) {
-    this.opts.linkedSignerWalletClient = linkedSignerWalletClient ?? void 0;
-  }
-  /**
-   * List all subaccounts
-   *
-   * @param params
-   */
-  async listSubaccounts(params) {
-    const baseResponse = await this.query("subaccounts", params);
-    return baseResponse.subaccounts.map((item) => {
-      const subaccount = subaccountFromHex(item.subaccount);
-      return {
-        hexId: item.subaccount,
-        createdAt: Number(item.created_at),
-        isolated: item.isolated,
-        ...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 }) => subaccountToHex({
-        subaccountOwner,
-        subaccountName
-      })
-    );
-    const baseResponse = await this.query("account_snapshots", {
-      subaccounts: subaccountHexIds,
-      timestamps: params.timestamps,
-      isolated: params.isolated
-    });
-    const snapshotsBySubaccount = mapValues(
-      baseResponse.snapshots,
-      (balanceSnapshots) => {
-        const snapshotByTimestamp = {};
-        Object.entries(balanceSnapshots).forEach(([timestamp, events]) => {
-          const balances = events.map(mapIndexerEvent);
-          snapshotByTimestamp[timestamp] = {
-            timestamp: toBigNumber(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: 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 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 mapValues(baseResponse, 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 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 mapValues(baseResponse, 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: removeDecimals(price.oracle_price_x18),
-        updateTime: toBigNumber(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(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(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 {
-        ...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 ?? [nowInSeconds()]
-    });
-    return mapValues(timestampToProductsMap, (productIdToProduct) => {
-      return mapValues(productIdToProduct, (indexerProduct) => {
-        return {
-          ...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", {
-      subaccounts: params.subaccounts?.map(
-        (subaccount) => subaccountToHex({
-          subaccountOwner: subaccount.subaccountOwner,
-          subaccountName: subaccount.subaccountName
-        })
-      ),
-      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 mapIndexerEventWithTx(event, tx);
-    });
-  }
-  /**
-   * Retrieves historical orders
-   * @param params
-   */
-  async getOrders(params) {
-    const baseResponse = await this.query("orders", {
-      subaccounts: params?.subaccounts?.map(
-        (subaccount) => subaccountToHex({
-          subaccountOwner: subaccount.subaccountOwner,
-          subaccountName: subaccount.subaccountName
-        })
-      ),
-      product_ids: params.productIds,
-      trigger_types: params.triggerTypes,
-      isolated: params.isolated,
-      digests: params.digests,
-      max_time: params.maxTimestampInclusive,
-      limit: params.limit,
-      idx: params.startCursor
-    });
-    return baseResponse.orders.map(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", {
-      subaccounts: params?.subaccounts?.map(
-        (subaccount) => subaccountToHex({
-          subaccountOwner: subaccount.subaccountOwner,
-          subaccountName: subaccount.subaccountName
-        })
-      ),
-      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 = mapIndexerMatchEventBalances(
-        matchEvent.post_balance
-      );
-      return {
-        productId: postBalances.base.productId,
-        isolated: matchEvent.isolated,
-        totalFee: toBigNumber(matchEvent.fee),
-        sequencerFee: toBigNumber(matchEvent.sequencer_fee),
-        builderFee: toBigNumber(matchEvent.builder_fee),
-        baseFilled: toBigNumber(matchEvent.base_filled),
-        quoteFilled: toBigNumber(matchEvent.quote_filled),
-        cumulativeFee: toBigNumber(matchEvent.cumulative_fee),
-        cumulativeBaseFilled: toBigNumber(matchEvent.cumulative_base_filled),
-        cumulativeQuoteFilled: toBigNumber(matchEvent.cumulative_quote_filled),
-        digest: matchEvent.digest,
-        order: matchEvent.order,
-        submissionIndex: matchEvent.submission_idx,
-        timestamp: toBigNumber(timestamp),
-        preEventTrackedVars: {
-          netEntryUnrealized: toBigNumber(matchEvent.net_entry_unrealized),
-          netEntryCumulative: toBigNumber(matchEvent.net_entry_cumulative)
-        },
-        preBalances: mapIndexerMatchEventBalances(matchEvent.pre_balance),
-        postBalances,
-        tx,
-        isTaker: matchEvent.is_taker,
-        realizedPnl: toBigNumber(matchEvent.realized_pnl),
-        closedAmount: toBigNumber(matchEvent.closed_amount),
-        closedNetEntry: toBigNumber(matchEvent.closed_net_entry),
-        margin: matchEvent.margin ? toBigNumber(matchEvent.margin) : null,
-        ...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: 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(
-        mapIndexerProductPayment
-      ),
-      interestPayments: baseResponse.interest_payments.map(
-        mapIndexerProductPayment
-      ),
-      nextCursor: baseResponse.next_idx
-    };
-  }
-  /**
-   * Gets quote (USDT) price in terms of USD
-   */
-  async getQuotePrice() {
-    const baseResponse = await this.query("quote_price", {});
-    return {
-      price: 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: subaccountToHex(params.subaccount)
-    });
-    return {
-      totalTxLimit: toBigNumber(baseResponse.total_tx_limit),
-      remainingTxs: toBigNumber(baseResponse.remaining_tx),
-      signer: baseResponse.signer,
-      waitTimeUntilNextTx: toBigNumber(baseResponse.wait_time)
-    };
-  }
-  /**
-   * Retrieve historical market snapshots
-   * @param params
-   */
-  async getMarketSnapshots(params) {
-    const baseResponse = await this.query("market_snapshots", {
-      interval: mapSnapshotsIntervalToServerParams(params),
-      product_ids: params.productIds
-    });
-    return baseResponse.snapshots.map(mapIndexerMarketSnapshot);
-  }
-  /**
-   * Retrieve historical market snapshots from Edge
-   * @param params
-   */
-  async getEdgeMarketSnapshots(params) {
-    const baseResponse = await this.query("edge_market_snapshots", {
-      interval: mapSnapshotsIntervalToServerParams(params)
-    });
-    return mapValues(
-      baseResponse.snapshots,
-      (snapshots) => snapshots.map(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: toBigNumber(baseResponse.reward_coefficient),
-      makers: baseResponse.makers.map(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,
-      order: params.order
-    });
-    return {
-      participants: baseResponse.positions.map(mapIndexerLeaderboardPosition)
-    };
-  }
-  /**
-   * Retrieve leaderboard ranking of a subaccount on a given contest
-   *
-   * @param params
-   */
-  async getLeaderboardParticipant(params) {
-    const baseResponse = await this.query("leaderboard_rank", {
-      subaccount: subaccountToHex(params.subaccount),
-      contest_ids: params.contestIds
-    });
-    return {
-      participant: mapValues(
-        baseResponse.positions,
-        (position) => mapIndexerLeaderboardPosition(position)
-      )
-    };
-  }
-  /**
-   * Registers a subaccount for one or more contests. Requires EIP-712 signing.
-   *
-   * @param params - Registration parameters including contest IDs and signing config.
-   */
-  async registerLeaderboard(params) {
-    const signatureParams = {
-      expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      contestIds: params.contestIds
-    };
-    const tx = getNadoEIP712Values(
-      "leaderboard_authentication",
-      signatureParams
-    );
-    const signature = await this.sign(
-      "leaderboard_authentication",
-      params.verifyingAddr,
-      params.chainId,
-      signatureParams
-    );
-    const updateRegistrationTx = {
-      tx,
-      signature
-    };
-    const baseResponse = await this.query("leaderboard_register", {
-      update_registration: updateRegistrationTx
-    });
-    return {
-      registrations: baseResponse.registrations.map(
-        mapIndexerLeaderboardRegistration
-      )
-    };
-  }
-  /**
-   * Retrieves contest registrations for a subaccount. Supports batch lookup
-   * across multiple contests with an optional active filter.
-   *
-   * @param params - Query parameters including subaccount and contest IDs.
-   */
-  async getLeaderboardRegistrations(params) {
-    const baseResponse = await this.query("leaderboard_registrations", {
-      subaccount: subaccountToHex(params.subaccount),
-      contest_ids: params.contestIds,
-      active: params.active
-    });
-    return {
-      registrations: baseResponse.registrations.map(
-        mapIndexerLeaderboardRegistration
-      )
-    };
-  }
-  /**
-   * Retrieve metadata of provided leaderboard contests
-   *
-   * @param params
-   */
-  async getLeaderboardContests(params) {
-    const baseResponse = await this.query("leaderboard_contests", {
-      contest_ids: params.contestIds,
-      active: params.active
-    });
-    return {
-      contests: baseResponse.contests.map(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: toBigInt(baseResponse.idx),
-      tx: baseResponse.tx,
-      txBytes: getValidatedHex(baseResponse.tx_bytes),
-      signatures: baseResponse.signatures.map(getValidatedHex)
-    };
-  }
-  async getNlpSnapshots(params) {
-    const baseResponse = await this.query("nlp_snapshots", {
-      interval: {
-        count: params.limit,
-        max_time: params.maxTimeInclusive ? toIntegerString(params.maxTimeInclusive) : void 0,
-        granularity: params.granularity
-      }
-    });
-    return {
-      snapshots: baseResponse.snapshots.map(mapIndexerNlpSnapshot)
-    };
-  }
-  /**
-   * Retrieves the subaccount's DDA (Direct Deposit Address)
-   * @param params
-   */
-  async getSubaccountDDA(params) {
-    const baseResponse = await this.query("direct_deposit_address", {
-      subaccount: subaccountToHex(params.subaccount)
-    });
-    return {
-      address: getValidatedAddress(baseResponse.v1_address)
-    };
-  }
-  async getSequencerBacklog() {
-    const baseResponse = await this.query("backlog", {});
-    return {
-      totalTxs: toBigNumber(baseResponse.total_txs),
-      totalSubmissions: toBigNumber(baseResponse.total_submissions),
-      backlogSize: toBigNumber(baseResponse.backlog_size),
-      updatedAt: toBigNumber(baseResponse.updated_at),
-      backlogEtaInSeconds: baseResponse.backlog_eta_in_seconds ? toBigNumber(baseResponse.backlog_eta_in_seconds) : null,
-      txsPerSecond: baseResponse.txs_per_second ? toBigNumber(baseResponse.txs_per_second) : null
-    };
-  }
-  /**
-   * Retrieves private alpha choice information for a given address
-   * @param params
-   */
-  async getPrivateAlphaChoice(params) {
-    const baseResponse = await this.query("private_alpha_choice", {
-      address: params.address
-    });
-    return {
-      points: toBigNumber(baseResponse.points),
-      feeRefund: toBigNumber(baseResponse.fee_refund),
-      nftEligibility: baseResponse.nft_eligibility
-    };
-  }
-  /**
-   * Retrieves points information for a given address, including points per epoch and all-time points
-   * @param params
-   */
-  async getPoints(params) {
-    const baseResponse = await this.query("nado_points", {
-      address: params.address
-    });
-    return {
-      pointsPerEpoch: baseResponse.points_per_epoch.map((epoch) => ({
-        epoch: epoch.epoch,
-        description: epoch.description,
-        startTime: toBigNumber(epoch.start_time),
-        endTime: toBigNumber(epoch.end_time),
-        totalPoints: toBigNumber(epoch.total_points),
-        points: toBigNumber(epoch.points),
-        rank: epoch.rank,
-        tier: epoch.tier
-      })),
-      allTimePoints: {
-        points: toBigNumber(baseResponse.all_time_points.points),
-        rank: baseResponse.all_time_points.rank,
-        tier: baseResponse.all_time_points.tier
-      }
-    };
-  }
-  /**
-   * Initiates a social account connection flow. Returns a URL the user must visit to complete the OAuth flow.
-   * Requires EIP-712 signing.
-   *
-   * @param params - Connection parameters including provider and signing config.
-   */
-  async connectSocialAccount(params) {
-    const signatureParams = {
-      expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      provider: params.provider
-    };
-    const tx = getNadoEIP712Values("social_authentication", signatureParams);
-    const signature = await this.sign(
-      "social_authentication",
-      params.verifyingAddr,
-      params.chainId,
-      signatureParams
-    );
-    const baseResponse = await this.query("social_connect", {
-      update_social_account: { tx, signature }
-    });
-    return { url: baseResponse.url };
-  }
-  /**
-   * Lists linked social accounts for a given address.
-   *
-   * @param params - Query parameters including the wallet address.
-   */
-  async listSocialAccounts(params) {
-    const baseResponse = await this.query("list_social_accounts", {
-      address: params.address
-    });
-    return {
-      accounts: baseResponse.accounts.map((a) => ({
-        provider: a.provider,
-        username: a.username,
-        displayName: a.display_name,
-        profileImageUrl: a.profile_image_url
-      }))
-    };
-  }
-  /**
-   * Revokes a linked social account. Requires EIP-712 signing.
-   *
-   * @param params - Revocation parameters including provider and signing config.
-   */
-  async revokeSocialAccount(params) {
-    const signatureParams = {
-      expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      provider: params.provider
-    };
-    const tx = getNadoEIP712Values("social_authentication", signatureParams);
-    const signature = await this.sign(
-      "social_authentication",
-      params.verifyingAddr,
-      params.chainId,
-      signatureParams
-    );
-    const baseResponse = await this.query("revoke_social_account", {
-      update_social_account: { tx, signature }
-    });
-    return {
-      accounts: baseResponse.accounts.map((a) => ({
-        provider: a.provider,
-        username: a.username,
-        displayName: a.display_name,
-        profileImageUrl: a.profile_image_url
-      }))
-    };
-  }
-  /**
-   * Get tickers from the v2 indexer endpoint
-   * @param params
-   */
-  async getV2Tickers(params) {
-    const response = await this.axiosInstance.get(
-      `${this.v2Url}/tickers`,
-      { params }
-    );
-    this.checkResponseStatus(response);
-    return mapValues(response.data, mapIndexerV2Ticker);
-  }
-  /**
-   * Get symbols with market hours from the v2 indexer endpoint
-   * @param params
-   */
-  async getV2Symbols(params) {
-    const response = await this.axiosInstance.get(
-      `${this.v2Url}/symbols`,
-      {
-        params: {
-          product_type: params?.productType,
-          product_ids: params?.productIds
-        }
-      }
-    );
-    this.checkResponseStatus(response);
-    return mapValues(response.data, mapIndexerV2Symbols);
-  }
-  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.linkedSignerWalletClient ?? this.opts.walletClient;
-    if (!walletClient) {
-      throw new WalletNotProvidedError();
-    }
-    return 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}`
-      );
-    }
-  }
-};
-export {
-  IndexerBaseClient
+	constructor(opts) {
+		this.opts = opts;
+		this.axiosInstance = axios.create({
+			withCredentials: true,
+			validateStatus: () => true
+		});
+		this.v2Url = opts.v2Url ? opts.v2Url : opts.url.replace("v1", "v2");
+	}
+	/**
+	* Sets the linked signer for execute requests
+	*
+	* @param linkedSignerWalletClient The linkedSigner to use for all signatures. Set to null to revert to the chain signer
+	*/
+	setLinkedSigner(linkedSignerWalletClient) {
+		this.opts.linkedSignerWalletClient = linkedSignerWalletClient ?? void 0;
+	}
+	/**
+	* List all subaccounts
+	*
+	* @param params
+	*/
+	async listSubaccounts(params) {
+		return (await this.query("subaccounts", params)).subaccounts.map((item) => {
+			const subaccount = subaccountFromHex(item.subaccount);
+			return {
+				hexId: item.subaccount,
+				createdAt: Number(item.created_at),
+				isolated: item.isolated,
+				...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 }) => subaccountToHex({
+			subaccountOwner,
+			subaccountName
+		}));
+		return {
+			subaccountHexIds,
+			snapshots: mapValues((await this.query("account_snapshots", {
+				subaccounts: subaccountHexIds,
+				timestamps: params.timestamps,
+				isolated: params.isolated
+			})).snapshots, (balanceSnapshots) => {
+				const snapshotByTimestamp = {};
+				Object.entries(balanceSnapshots).forEach(([timestamp, events]) => {
+					const balances = events.map(mapIndexerEvent);
+					snapshotByTimestamp[timestamp] = {
+						timestamp: toBigNumber(timestamp),
+						balances
+					};
+				});
+				return snapshotByTimestamp;
+			})
+		};
+	}
+	/**
+	* Retrieves referral code for an address
+	*
+	* @param params
+	*/
+	async getReferralCode(params) {
+		return { referralCode: (await this.query("referral_code", { subaccount: subaccountToHex({
+			subaccountOwner: params.subaccount.subaccountOwner,
+			subaccountName: params.subaccount.subaccountName
+		}) })).referral_code };
+	}
+	/**
+	* Retrieves funding rate for a product, where 1 = 100%
+	* @param params
+	*/
+	async getFundingRate(params) {
+		return mapIndexerFundingRate(await this.query("funding_rate", { product_id: params.productId }));
+	}
+	/**
+	* Retrieves funding rate for multiple products, where 1 = 100%
+	* @param params
+	*/
+	async getMultiProductFundingRates(params) {
+		return mapValues(await this.query("funding_rates", { product_ids: params.productIds }), mapIndexerFundingRate);
+	}
+	/**
+	* Retrieves latest mark/index price for a perp product
+	* @param params
+	*/
+	async getPerpPrices(params) {
+		return mapIndexerPerpPrices(await this.query("price", { product_id: params.productId }));
+	}
+	/**
+	* Retrieves latest mark/index price for multiple perp products
+	* @param params
+	*/
+	async getMultiProductPerpPrices(params) {
+		return mapValues(await this.query("perp_prices", { product_ids: params.productIds }), mapIndexerPerpPrices);
+	}
+	/**
+	* Retrieves latest oracle prices for provided products
+	* @param params
+	*/
+	async getOraclePrices(params) {
+		return (await this.query("oracle_price", { product_ids: params.productIds })).prices.map((price) => {
+			return {
+				oraclePrice: removeDecimals(price.oracle_price_x18),
+				updateTime: toBigNumber(price.update_time),
+				productId: price.product_id
+			};
+		});
+	}
+	/**
+	* Retrieves candlesticks for a product
+	* @param params
+	*/
+	async getCandlesticks(params) {
+		return (await this.query("candlesticks", {
+			product_id: params.productId,
+			max_time: params.maxTimeInclusive,
+			limit: params.limit,
+			granularity: params.period
+		})).candlesticks.map(mapIndexerCandlesticks);
+	}
+	/**
+	* Retrieves candlesticks for a product from Edge
+	* @param params
+	*/
+	async getEdgeCandlesticks(params) {
+		return (await this.query("edge_candlesticks", {
+			product_id: params.productId,
+			max_time: params.maxTimeInclusive,
+			limit: params.limit,
+			granularity: params.period
+		})).candlesticks.map(mapIndexerCandlesticks);
+	}
+	/**
+	* Retrieves historical snapshots for a product
+	* @param params
+	*/
+	async getProductSnapshots(params) {
+		return (await this.query("products", {
+			product_id: params.productId,
+			max_time: params.maxTimestampInclusive,
+			limit: params.limit,
+			idx: params.startCursor
+		})).products.map((product) => {
+			return {
+				...mapIndexerServerProduct(product.product),
+				submissionIndex: product.submission_idx
+			};
+		});
+	}
+	/**
+	* Retrieves historical snapshots for multiple products
+	* @param params
+	*/
+	async getMultiProductSnapshots(params) {
+		return mapValues(await this.query("product_snapshots", {
+			product_ids: params.productIds,
+			max_time: params.maxTimestampInclusive ?? [nowInSeconds()]
+		}), (productIdToProduct) => {
+			return mapValues(productIdToProduct, (indexerProduct) => {
+				return {
+					...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", {
+			subaccounts: params.subaccounts?.map((subaccount) => subaccountToHex({
+				subaccountOwner: subaccount.subaccountOwner,
+				subaccountName: subaccount.subaccountName
+			})),
+			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 mapIndexerEventWithTx(event, tx);
+		});
+	}
+	/**
+	* Retrieves historical orders
+	* @param params
+	*/
+	async getOrders(params) {
+		return (await this.query("orders", {
+			subaccounts: params?.subaccounts?.map((subaccount) => subaccountToHex({
+				subaccountOwner: subaccount.subaccountOwner,
+				subaccountName: subaccount.subaccountName
+			})),
+			product_ids: params.productIds,
+			trigger_types: params.triggerTypes,
+			isolated: params.isolated,
+			digests: params.digests,
+			max_time: params.maxTimestampInclusive,
+			limit: params.limit,
+			idx: params.startCursor
+		})).orders.map(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", {
+			subaccounts: params?.subaccounts?.map((subaccount) => subaccountToHex({
+				subaccountOwner: subaccount.subaccountOwner,
+				subaccountName: subaccount.subaccountName
+			})),
+			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 = mapIndexerMatchEventBalances(matchEvent.post_balance);
+			return {
+				productId: postBalances.base.productId,
+				isolated: matchEvent.isolated,
+				totalFee: toBigNumber(matchEvent.fee),
+				sequencerFee: toBigNumber(matchEvent.sequencer_fee),
+				builderFee: toBigNumber(matchEvent.builder_fee),
+				baseFilled: toBigNumber(matchEvent.base_filled),
+				quoteFilled: toBigNumber(matchEvent.quote_filled),
+				cumulativeFee: toBigNumber(matchEvent.cumulative_fee),
+				cumulativeBaseFilled: toBigNumber(matchEvent.cumulative_base_filled),
+				cumulativeQuoteFilled: toBigNumber(matchEvent.cumulative_quote_filled),
+				digest: matchEvent.digest,
+				order: matchEvent.order,
+				submissionIndex: matchEvent.submission_idx,
+				timestamp: toBigNumber(timestamp),
+				preEventTrackedVars: {
+					netEntryUnrealized: toBigNumber(matchEvent.net_entry_unrealized),
+					netEntryCumulative: toBigNumber(matchEvent.net_entry_cumulative)
+				},
+				preBalances: mapIndexerMatchEventBalances(matchEvent.pre_balance),
+				postBalances,
+				tx,
+				isTaker: matchEvent.is_taker,
+				realizedPnl: toBigNumber(matchEvent.realized_pnl),
+				closedAmount: toBigNumber(matchEvent.closed_amount),
+				closedNetEntry: toBigNumber(matchEvent.closed_net_entry),
+				margin: matchEvent.margin ? toBigNumber(matchEvent.margin) : null,
+				...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: 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(mapIndexerProductPayment),
+			interestPayments: baseResponse.interest_payments.map(mapIndexerProductPayment),
+			nextCursor: baseResponse.next_idx
+		};
+	}
+	/**
+	* Gets quote (USDT) price in terms of USD
+	*/
+	async getQuotePrice() {
+		return { price: removeDecimals((await this.query("quote_price", {})).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: subaccountToHex(params.subaccount) });
+		return {
+			totalTxLimit: toBigNumber(baseResponse.total_tx_limit),
+			remainingTxs: toBigNumber(baseResponse.remaining_tx),
+			signer: baseResponse.signer,
+			waitTimeUntilNextTx: toBigNumber(baseResponse.wait_time)
+		};
+	}
+	/**
+	* Retrieve historical market snapshots
+	* @param params
+	*/
+	async getMarketSnapshots(params) {
+		return (await this.query("market_snapshots", {
+			interval: mapSnapshotsIntervalToServerParams(params),
+			product_ids: params.productIds
+		})).snapshots.map(mapIndexerMarketSnapshot);
+	}
+	/**
+	* Retrieve historical market snapshots from Edge
+	* @param params
+	*/
+	async getEdgeMarketSnapshots(params) {
+		return mapValues((await this.query("edge_market_snapshots", { interval: mapSnapshotsIntervalToServerParams(params) })).snapshots, (snapshots) => snapshots.map(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: toBigNumber(baseResponse.reward_coefficient),
+			makers: baseResponse.makers.map(mapIndexerMakerStatistics)
+		};
+	}
+	/**
+	* Retrieve leaderboard stats for a given contest
+	*
+	* @param params
+	*/
+	async getLeaderboard(params) {
+		return { participants: (await this.query("leaderboard", {
+			contest_id: params.contestId,
+			rank_type: params.rankType,
+			start: params.startCursor,
+			limit: params.limit,
+			order: params.order
+		})).positions.map(mapIndexerLeaderboardPosition) };
+	}
+	/**
+	* Retrieve leaderboard ranking of a subaccount on a given contest
+	*
+	* @param params
+	*/
+	async getLeaderboardParticipant(params) {
+		return { participant: mapValues((await this.query("leaderboard_rank", {
+			subaccount: subaccountToHex(params.subaccount),
+			contest_ids: params.contestIds
+		})).positions, (position) => mapIndexerLeaderboardPosition(position)) };
+	}
+	/**
+	* Registers a subaccount for one or more contests. Requires EIP-712 signing.
+	*
+	* @param params - Registration parameters including contest IDs and signing config.
+	*/
+	async registerLeaderboard(params) {
+		const signatureParams = {
+			expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			contestIds: params.contestIds
+		};
+		const updateRegistrationTx = {
+			tx: getNadoEIP712Values("leaderboard_authentication", signatureParams),
+			signature: await this.sign("leaderboard_authentication", params.verifyingAddr, params.chainId, signatureParams)
+		};
+		return { registrations: (await this.query("leaderboard_register", { update_registration: updateRegistrationTx })).registrations.map(mapIndexerLeaderboardRegistration) };
+	}
+	/**
+	* Retrieves contest registrations for a subaccount. Supports batch lookup
+	* across multiple contests with an optional active filter.
+	*
+	* @param params - Query parameters including subaccount and contest IDs.
+	*/
+	async getLeaderboardRegistrations(params) {
+		return { registrations: (await this.query("leaderboard_registrations", {
+			subaccount: subaccountToHex(params.subaccount),
+			contest_ids: params.contestIds,
+			active: params.active
+		})).registrations.map(mapIndexerLeaderboardRegistration) };
+	}
+	/**
+	* Retrieve metadata of provided leaderboard contests
+	*
+	* @param params
+	*/
+	async getLeaderboardContests(params) {
+		return { contests: (await this.query("leaderboard_contests", {
+			contest_ids: params.contestIds,
+			active: params.active
+		})).contests.map(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: toBigInt(baseResponse.idx),
+			tx: baseResponse.tx,
+			txBytes: getValidatedHex(baseResponse.tx_bytes),
+			signatures: baseResponse.signatures.map(getValidatedHex)
+		};
+	}
+	async getNlpSnapshots(params) {
+		return { snapshots: (await this.query("nlp_snapshots", { interval: {
+			count: params.limit,
+			max_time: params.maxTimeInclusive ? toIntegerString(params.maxTimeInclusive) : void 0,
+			granularity: params.granularity
+		} })).snapshots.map(mapIndexerNlpSnapshot) };
+	}
+	/**
+	* Retrieves the subaccount's DDA (Direct Deposit Address)
+	* @param params
+	*/
+	async getSubaccountDDA(params) {
+		return { address: getValidatedAddress((await this.query("direct_deposit_address", { subaccount: subaccountToHex(params.subaccount) })).v1_address) };
+	}
+	async getSequencerBacklog() {
+		const baseResponse = await this.query("backlog", {});
+		return {
+			totalTxs: toBigNumber(baseResponse.total_txs),
+			totalSubmissions: toBigNumber(baseResponse.total_submissions),
+			backlogSize: toBigNumber(baseResponse.backlog_size),
+			updatedAt: toBigNumber(baseResponse.updated_at),
+			backlogEtaInSeconds: baseResponse.backlog_eta_in_seconds ? toBigNumber(baseResponse.backlog_eta_in_seconds) : null,
+			txsPerSecond: baseResponse.txs_per_second ? toBigNumber(baseResponse.txs_per_second) : null
+		};
+	}
+	/**
+	* Retrieves private alpha choice information for a given address
+	* @param params
+	*/
+	async getPrivateAlphaChoice(params) {
+		const baseResponse = await this.query("private_alpha_choice", { address: params.address });
+		return {
+			points: toBigNumber(baseResponse.points),
+			feeRefund: toBigNumber(baseResponse.fee_refund),
+			nftEligibility: baseResponse.nft_eligibility
+		};
+	}
+	/**
+	* Retrieves points information for a given address, including points per epoch and all-time points
+	* @param params
+	*/
+	async getPoints(params) {
+		const baseResponse = await this.query("nado_points", { address: params.address });
+		return {
+			pointsPerEpoch: baseResponse.points_per_epoch.map((epoch) => ({
+				epoch: epoch.epoch,
+				description: epoch.description,
+				startTime: toBigNumber(epoch.start_time),
+				endTime: toBigNumber(epoch.end_time),
+				totalPoints: toBigNumber(epoch.total_points),
+				points: toBigNumber(epoch.points),
+				rank: epoch.rank,
+				tier: epoch.tier
+			})),
+			allTimePoints: {
+				points: toBigNumber(baseResponse.all_time_points.points),
+				rank: baseResponse.all_time_points.rank,
+				tier: baseResponse.all_time_points.tier
+			}
+		};
+	}
+	/**
+	* Initiates a social account connection flow. Returns a URL the user must visit to complete the OAuth flow.
+	* Requires EIP-712 signing.
+	*
+	* @param params - Connection parameters including provider and signing config.
+	*/
+	async connectSocialAccount(params) {
+		const signatureParams = {
+			expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			provider: params.provider
+		};
+		const tx = getNadoEIP712Values("social_authentication", signatureParams);
+		const signature = await this.sign("social_authentication", params.verifyingAddr, params.chainId, signatureParams);
+		return { url: (await this.query("social_connect", { update_social_account: {
+			tx,
+			signature
+		} })).url };
+	}
+	/**
+	* Lists linked social accounts for a given address.
+	*
+	* @param params - Query parameters including the wallet address.
+	*/
+	async listSocialAccounts(params) {
+		return { accounts: (await this.query("list_social_accounts", { address: params.address })).accounts.map((a) => ({
+			provider: a.provider,
+			username: a.username,
+			displayName: a.display_name,
+			profileImageUrl: a.profile_image_url
+		})) };
+	}
+	/**
+	* Revokes a linked social account. Requires EIP-712 signing.
+	*
+	* @param params - Revocation parameters including provider and signing config.
+	*/
+	async revokeSocialAccount(params) {
+		const signatureParams = {
+			expiration: toIntegerString(params.recvTime ?? getDefaultRecvTime()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			provider: params.provider
+		};
+		const tx = getNadoEIP712Values("social_authentication", signatureParams);
+		const signature = await this.sign("social_authentication", params.verifyingAddr, params.chainId, signatureParams);
+		return { accounts: (await this.query("revoke_social_account", { update_social_account: {
+			tx,
+			signature
+		} })).accounts.map((a) => ({
+			provider: a.provider,
+			username: a.username,
+			displayName: a.display_name,
+			profileImageUrl: a.profile_image_url
+		})) };
+	}
+	/**
+	* Get tickers from the v2 indexer endpoint
+	* @param params
+	*/
+	async getV2Tickers(params) {
+		const response = await this.axiosInstance.get(`${this.v2Url}/tickers`, { params });
+		this.checkResponseStatus(response);
+		return mapValues(response.data, mapIndexerV2Ticker);
+	}
+	/**
+	* Get symbols with market hours from the v2 indexer endpoint
+	* @param params
+	*/
+	async getV2Symbols(params) {
+		const response = await this.axiosInstance.get(`${this.v2Url}/symbols`, { params: {
+			product_type: params?.productType,
+			product_ids: params?.productIds
+		} });
+		this.checkResponseStatus(response);
+		return mapValues(response.data, mapIndexerV2Symbols);
+	}
+	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.linkedSignerWalletClient ?? this.opts.walletClient;
+		if (!walletClient) throw new WalletNotProvidedError();
+		return 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}`);
+	}
 };
+//#endregion
+export { IndexerBaseClient };
+
 //# sourceMappingURL=IndexerBaseClient.js.map