@nadohq/indexer-client 0.15.0 → 0.17.0

package/dist/IndexerBaseClient.cjs

@@ -1,788 +1,3 @@
-"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_shared = require("@nadohq/shared");
-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,
-      // 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 = (0, import_shared.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 }) => (0, import_shared.subaccountToHex)({
-        subaccountOwner,
-        subaccountName
-      })
-    );
-    const baseResponse = await this.query("account_snapshots", {
-      subaccounts: subaccountHexIds,
-      timestamps: params.timestamps,
-      isolated: params.isolated
-    });
-    const snapshotsBySubaccount = (0, import_shared.mapValues)(
-      baseResponse.snapshots,
-      (balanceSnapshots) => {
-        const snapshotByTimestamp = {};
-        Object.entries(balanceSnapshots).forEach(([timestamp, events]) => {
-          const balances = events.map(import_dataMappers.mapIndexerEvent);
-          snapshotByTimestamp[timestamp] = {
-            timestamp: (0, import_shared.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: (0, import_shared.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_shared.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_shared.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_shared.removeDecimals)(price.oracle_price_x18),
-        updateTime: (0, import_shared.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(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_shared.nowInSeconds)()]
-    });
-    return (0, import_shared.mapValues)(timestampToProductsMap, (productIdToProduct) => {
-      return (0, import_shared.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", {
-      subaccounts: params.subaccounts?.map(
-        (subaccount) => (0, import_shared.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 (0, import_dataMappers.mapIndexerEventWithTx)(event, tx);
-    });
-  }
-  /**
-   * Retrieves historical orders
-   * @param params
-   */
-  async getOrders(params) {
-    const baseResponse = await this.query("orders", {
-      subaccounts: params?.subaccounts?.map(
-        (subaccount) => (0, import_shared.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(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", {
-      subaccounts: params?.subaccounts?.map(
-        (subaccount) => (0, import_shared.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 = (0, import_dataMappers.mapIndexerMatchEventBalances)(
-        matchEvent.post_balance
-      );
-      return {
-        productId: postBalances.base.productId,
-        isolated: matchEvent.isolated,
-        totalFee: (0, import_shared.toBigNumber)(matchEvent.fee),
-        sequencerFee: (0, import_shared.toBigNumber)(matchEvent.sequencer_fee),
-        builderFee: (0, import_shared.toBigNumber)(matchEvent.builder_fee),
-        baseFilled: (0, import_shared.toBigNumber)(matchEvent.base_filled),
-        quoteFilled: (0, import_shared.toBigNumber)(matchEvent.quote_filled),
-        cumulativeFee: (0, import_shared.toBigNumber)(matchEvent.cumulative_fee),
-        cumulativeBaseFilled: (0, import_shared.toBigNumber)(matchEvent.cumulative_base_filled),
-        cumulativeQuoteFilled: (0, import_shared.toBigNumber)(matchEvent.cumulative_quote_filled),
-        digest: matchEvent.digest,
-        order: matchEvent.order,
-        submissionIndex: matchEvent.submission_idx,
-        timestamp: (0, import_shared.toBigNumber)(timestamp),
-        preEventTrackedVars: {
-          netEntryUnrealized: (0, import_shared.toBigNumber)(matchEvent.net_entry_unrealized),
-          netEntryCumulative: (0, import_shared.toBigNumber)(matchEvent.net_entry_cumulative)
-        },
-        preBalances: (0, import_dataMappers.mapIndexerMatchEventBalances)(matchEvent.pre_balance),
-        postBalances,
-        tx,
-        isTaker: matchEvent.is_taker,
-        realizedPnl: (0, import_shared.toBigNumber)(matchEvent.realized_pnl),
-        closedAmount: (0, import_shared.toBigNumber)(matchEvent.closed_amount),
-        closedNetEntry: (0, import_shared.toBigNumber)(matchEvent.closed_net_entry),
-        margin: matchEvent.margin ? (0, import_shared.toBigNumber)(matchEvent.margin) : null,
-        ...(0, import_shared.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_shared.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 (USDT) price in terms of USD
-   */
-  async getQuotePrice() {
-    const baseResponse = await this.query("quote_price", {});
-    return {
-      price: (0, import_shared.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_shared.subaccountToHex)(params.subaccount)
-    });
-    return {
-      totalTxLimit: (0, import_shared.toBigNumber)(baseResponse.total_tx_limit),
-      remainingTxs: (0, import_shared.toBigNumber)(baseResponse.remaining_tx),
-      signer: baseResponse.signer,
-      waitTimeUntilNextTx: (0, import_shared.toBigNumber)(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_shared.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_shared.toBigNumber)(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,
-      order: params.order
-    });
-    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_shared.subaccountToHex)(params.subaccount),
-      contest_ids: params.contestIds
-    });
-    return {
-      participant: (0, import_shared.mapValues)(
-        baseResponse.positions,
-        (position) => (0, import_dataMappers.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: (0, import_shared.toIntegerString)(params.recvTime ?? (0, import_shared.getDefaultRecvTime)()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      contestIds: params.contestIds
-    };
-    const tx = (0, import_shared.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(
-        import_dataMappers.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: (0, import_shared.subaccountToHex)(params.subaccount),
-      contest_ids: params.contestIds,
-      active: params.active
-    });
-    return {
-      registrations: baseResponse.registrations.map(
-        import_dataMappers.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(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_shared.toBigInt)(baseResponse.idx),
-      tx: baseResponse.tx,
-      txBytes: (0, import_shared.getValidatedHex)(baseResponse.tx_bytes),
-      signatures: baseResponse.signatures.map(import_shared.getValidatedHex)
-    };
-  }
-  async getNlpSnapshots(params) {
-    const baseResponse = await this.query("nlp_snapshots", {
-      interval: {
-        count: params.limit,
-        max_time: params.maxTimeInclusive ? (0, import_shared.toIntegerString)(params.maxTimeInclusive) : void 0,
-        granularity: params.granularity
-      }
-    });
-    return {
-      snapshots: baseResponse.snapshots.map(import_dataMappers.mapIndexerNlpSnapshot)
-    };
-  }
-  /**
-   * Retrieves the subaccount's DDA (Direct Deposit Address)
-   * @param params
-   */
-  async getSubaccountDDA(params) {
-    const baseResponse = await this.query("direct_deposit_address", {
-      subaccount: (0, import_shared.subaccountToHex)(params.subaccount)
-    });
-    return {
-      address: (0, import_shared.getValidatedAddress)(baseResponse.v1_address)
-    };
-  }
-  async getSequencerBacklog() {
-    const baseResponse = await this.query("backlog", {});
-    return {
-      totalTxs: (0, import_shared.toBigNumber)(baseResponse.total_txs),
-      totalSubmissions: (0, import_shared.toBigNumber)(baseResponse.total_submissions),
-      backlogSize: (0, import_shared.toBigNumber)(baseResponse.backlog_size),
-      updatedAt: (0, import_shared.toBigNumber)(baseResponse.updated_at),
-      backlogEtaInSeconds: baseResponse.backlog_eta_in_seconds ? (0, import_shared.toBigNumber)(baseResponse.backlog_eta_in_seconds) : null,
-      txsPerSecond: baseResponse.txs_per_second ? (0, import_shared.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: (0, import_shared.toBigNumber)(baseResponse.points),
-      feeRefund: (0, import_shared.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: (0, import_shared.toBigNumber)(epoch.start_time),
-        endTime: (0, import_shared.toBigNumber)(epoch.end_time),
-        totalPoints: (0, import_shared.toBigNumber)(epoch.total_points),
-        points: (0, import_shared.toBigNumber)(epoch.points),
-        rank: epoch.rank,
-        tier: epoch.tier
-      })),
-      allTimePoints: {
-        points: (0, import_shared.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: (0, import_shared.toIntegerString)(params.recvTime ?? (0, import_shared.getDefaultRecvTime)()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      provider: params.provider
-    };
-    const tx = (0, import_shared.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: (0, import_shared.toIntegerString)(params.recvTime ?? (0, import_shared.getDefaultRecvTime)()),
-      subaccountName: params.subaccountName,
-      subaccountOwner: params.subaccountOwner,
-      provider: params.provider
-    };
-    const tx = (0, import_shared.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 (0, import_shared.mapValues)(response.data, import_dataMappers.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 (0, import_shared.mapValues)(response.data, import_dataMappers.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 import_shared.WalletNotProvidedError();
-    }
-    return (0, import_shared.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
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_IndexerBaseClient = require("./IndexerBaseClient-3KfzA2ph.cjs");
+exports.IndexerBaseClient = require_IndexerBaseClient.IndexerBaseClient;