@nadohq/indexer-client 0.14.0 → 0.17.0

package/dist/CandlestickPeriod-1DtcEiOb.d.ts

@@ -0,0 +1,15 @@
+//#region src/types/CandlestickPeriod.d.ts
+declare enum CandlestickPeriod {
+  MIN = 60,
+  FIVE_MIN = 300,
+  FIFTEEN_MIN = 900,
+  HOUR = 3600,
+  TWO_HOUR = 7200,
+  FOUR_HOUR = 14400,
+  DAY = 86400,
+  WEEK = 604800,
+  MONTH = 2419200
+}
+//#endregion
+export { CandlestickPeriod as t };
+//# sourceMappingURL=CandlestickPeriod-1DtcEiOb.d.ts.map

package/dist/CandlestickPeriod-1DtcEiOb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CandlestickPeriod-1DtcEiOb.d.ts","names":[],"sources":["../src/types/src/types/CandlestickPeriod.ts"],"mappings":";aAAY,iBAAA;EACV,GAAA;EACA,QAAA;EACA,WAAA;EACA,IAAA;EACA,QAAA;EACA,SAAA;EACA,GAAA;EACA,IAAA;EACA,KAAA;AAAA"}

package/dist/CandlestickPeriod-D3_IoSev.d.cts

@@ -0,0 +1,15 @@
+//#region src/types/CandlestickPeriod.d.ts
+declare enum CandlestickPeriod {
+  MIN = 60,
+  FIVE_MIN = 300,
+  FIFTEEN_MIN = 900,
+  HOUR = 3600,
+  TWO_HOUR = 7200,
+  FOUR_HOUR = 14400,
+  DAY = 86400,
+  WEEK = 604800,
+  MONTH = 2419200
+}
+//#endregion
+export { CandlestickPeriod as t };
+//# sourceMappingURL=CandlestickPeriod-D3_IoSev.d.cts.map

package/dist/CandlestickPeriod-D3_IoSev.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CandlestickPeriod-D3_IoSev.d.cts","names":[],"sources":["../src/types/src/types/CandlestickPeriod.ts"],"mappings":";aAAY,iBAAA;EACV,GAAA;EACA,QAAA;EACA,WAAA;EACA,IAAA;EACA,QAAA;EACA,SAAA;EACA,GAAA;EACA,IAAA;EACA,KAAA;AAAA"}

package/dist/IndexerBaseClient-3KfzA2ph.cjs

@@ -0,0 +1,639 @@
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_dataMappers = require("./dataMappers.cjs");
+let _nadohq_shared = require("@nadohq/shared");
+let axios = require("axios");
+axios = __toESM(axios, 1);
+//#region src/IndexerBaseClient.ts
+/**
+* Base client for all indexer requests
+*/
+var IndexerBaseClient = class {
+	constructor(opts) {
+		this.opts = opts;
+		this.axiosInstance = axios.default.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 = (0, _nadohq_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, _nadohq_shared.subaccountToHex)({
+			subaccountOwner,
+			subaccountName
+		}));
+		return {
+			subaccountHexIds,
+			snapshots: (0, _nadohq_shared.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(require_dataMappers.mapIndexerEvent);
+					snapshotByTimestamp[timestamp] = {
+						timestamp: (0, _nadohq_shared.toBigNumber)(timestamp),
+						balances
+					};
+				});
+				return snapshotByTimestamp;
+			})
+		};
+	}
+	/**
+	* Retrieves referral code for an address
+	*
+	* @param params
+	*/
+	async getReferralCode(params) {
+		return { referralCode: (await this.query("referral_code", { subaccount: (0, _nadohq_shared.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 require_dataMappers.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 (0, _nadohq_shared.mapValues)(await this.query("funding_rates", { product_ids: params.productIds }), require_dataMappers.mapIndexerFundingRate);
+	}
+	/**
+	* Retrieves latest mark/index price for a perp product
+	* @param params
+	*/
+	async getPerpPrices(params) {
+		return require_dataMappers.mapIndexerPerpPrices(await this.query("price", { product_id: params.productId }));
+	}
+	/**
+	* Retrieves latest mark/index price for multiple perp products
+	* @param params
+	*/
+	async getMultiProductPerpPrices(params) {
+		return (0, _nadohq_shared.mapValues)(await this.query("perp_prices", { product_ids: params.productIds }), require_dataMappers.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: (0, _nadohq_shared.removeDecimals)(price.oracle_price_x18),
+				updateTime: (0, _nadohq_shared.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(require_dataMappers.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(require_dataMappers.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 {
+				...require_dataMappers.mapIndexerServerProduct(product.product),
+				submissionIndex: product.submission_idx
+			};
+		});
+	}
+	/**
+	* Retrieves historical snapshots for multiple products
+	* @param params
+	*/
+	async getMultiProductSnapshots(params) {
+		return (0, _nadohq_shared.mapValues)(await this.query("product_snapshots", {
+			product_ids: params.productIds,
+			max_time: params.maxTimestampInclusive ?? [(0, _nadohq_shared.nowInSeconds)()]
+		}), (productIdToProduct) => {
+			return (0, _nadohq_shared.mapValues)(productIdToProduct, (indexerProduct) => {
+				return {
+					...require_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, _nadohq_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 require_dataMappers.mapIndexerEventWithTx(event, tx);
+		});
+	}
+	/**
+	* Retrieves historical orders
+	* @param params
+	*/
+	async getOrders(params) {
+		return (await this.query("orders", {
+			subaccounts: params?.subaccounts?.map((subaccount) => (0, _nadohq_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
+		})).orders.map(require_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, _nadohq_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 = require_dataMappers.mapIndexerMatchEventBalances(matchEvent.post_balance);
+			return {
+				productId: postBalances.base.productId,
+				isolated: matchEvent.isolated,
+				totalFee: (0, _nadohq_shared.toBigNumber)(matchEvent.fee),
+				sequencerFee: (0, _nadohq_shared.toBigNumber)(matchEvent.sequencer_fee),
+				builderFee: (0, _nadohq_shared.toBigNumber)(matchEvent.builder_fee),
+				baseFilled: (0, _nadohq_shared.toBigNumber)(matchEvent.base_filled),
+				quoteFilled: (0, _nadohq_shared.toBigNumber)(matchEvent.quote_filled),
+				cumulativeFee: (0, _nadohq_shared.toBigNumber)(matchEvent.cumulative_fee),
+				cumulativeBaseFilled: (0, _nadohq_shared.toBigNumber)(matchEvent.cumulative_base_filled),
+				cumulativeQuoteFilled: (0, _nadohq_shared.toBigNumber)(matchEvent.cumulative_quote_filled),
+				digest: matchEvent.digest,
+				order: matchEvent.order,
+				submissionIndex: matchEvent.submission_idx,
+				timestamp: (0, _nadohq_shared.toBigNumber)(timestamp),
+				preEventTrackedVars: {
+					netEntryUnrealized: (0, _nadohq_shared.toBigNumber)(matchEvent.net_entry_unrealized),
+					netEntryCumulative: (0, _nadohq_shared.toBigNumber)(matchEvent.net_entry_cumulative)
+				},
+				preBalances: require_dataMappers.mapIndexerMatchEventBalances(matchEvent.pre_balance),
+				postBalances,
+				tx,
+				isTaker: matchEvent.is_taker,
+				realizedPnl: (0, _nadohq_shared.toBigNumber)(matchEvent.realized_pnl),
+				closedAmount: (0, _nadohq_shared.toBigNumber)(matchEvent.closed_amount),
+				closedNetEntry: (0, _nadohq_shared.toBigNumber)(matchEvent.closed_net_entry),
+				margin: matchEvent.margin ? (0, _nadohq_shared.toBigNumber)(matchEvent.margin) : null,
+				...(0, _nadohq_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, _nadohq_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(require_dataMappers.mapIndexerProductPayment),
+			interestPayments: baseResponse.interest_payments.map(require_dataMappers.mapIndexerProductPayment),
+			nextCursor: baseResponse.next_idx
+		};
+	}
+	/**
+	* Gets quote (USDT) price in terms of USD
+	*/
+	async getQuotePrice() {
+		return { price: (0, _nadohq_shared.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: (0, _nadohq_shared.subaccountToHex)(params.subaccount) });
+		return {
+			totalTxLimit: (0, _nadohq_shared.toBigNumber)(baseResponse.total_tx_limit),
+			remainingTxs: (0, _nadohq_shared.toBigNumber)(baseResponse.remaining_tx),
+			signer: baseResponse.signer,
+			waitTimeUntilNextTx: (0, _nadohq_shared.toBigNumber)(baseResponse.wait_time)
+		};
+	}
+	/**
+	* Retrieve historical market snapshots
+	* @param params
+	*/
+	async getMarketSnapshots(params) {
+		return (await this.query("market_snapshots", {
+			interval: require_dataMappers.mapSnapshotsIntervalToServerParams(params),
+			product_ids: params.productIds
+		})).snapshots.map(require_dataMappers.mapIndexerMarketSnapshot);
+	}
+	/**
+	* Retrieve historical market snapshots from Edge
+	* @param params
+	*/
+	async getEdgeMarketSnapshots(params) {
+		return (0, _nadohq_shared.mapValues)((await this.query("edge_market_snapshots", { interval: require_dataMappers.mapSnapshotsIntervalToServerParams(params) })).snapshots, (snapshots) => snapshots.map(require_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, _nadohq_shared.toBigNumber)(baseResponse.reward_coefficient),
+			makers: baseResponse.makers.map(require_dataMappers.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(require_dataMappers.mapIndexerLeaderboardPosition) };
+	}
+	/**
+	* Retrieve leaderboard ranking of a subaccount on a given contest
+	*
+	* @param params
+	*/
+	async getLeaderboardParticipant(params) {
+		return { participant: (0, _nadohq_shared.mapValues)((await this.query("leaderboard_rank", {
+			subaccount: (0, _nadohq_shared.subaccountToHex)(params.subaccount),
+			contest_ids: params.contestIds
+		})).positions, (position) => require_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, _nadohq_shared.toIntegerString)(params.recvTime ?? (0, _nadohq_shared.getDefaultRecvTime)()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			contestIds: params.contestIds
+		};
+		const updateRegistrationTx = {
+			tx: (0, _nadohq_shared.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(require_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) {
+		return { registrations: (await this.query("leaderboard_registrations", {
+			subaccount: (0, _nadohq_shared.subaccountToHex)(params.subaccount),
+			contest_ids: params.contestIds,
+			active: params.active
+		})).registrations.map(require_dataMappers.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(require_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, _nadohq_shared.toBigInt)(baseResponse.idx),
+			tx: baseResponse.tx,
+			txBytes: (0, _nadohq_shared.getValidatedHex)(baseResponse.tx_bytes),
+			signatures: baseResponse.signatures.map(_nadohq_shared.getValidatedHex)
+		};
+	}
+	async getNlpSnapshots(params) {
+		return { snapshots: (await this.query("nlp_snapshots", { interval: {
+			count: params.limit,
+			max_time: params.maxTimeInclusive ? (0, _nadohq_shared.toIntegerString)(params.maxTimeInclusive) : void 0,
+			granularity: params.granularity
+		} })).snapshots.map(require_dataMappers.mapIndexerNlpSnapshot) };
+	}
+	/**
+	* Retrieves the subaccount's DDA (Direct Deposit Address)
+	* @param params
+	*/
+	async getSubaccountDDA(params) {
+		return { address: (0, _nadohq_shared.getValidatedAddress)((await this.query("direct_deposit_address", { subaccount: (0, _nadohq_shared.subaccountToHex)(params.subaccount) })).v1_address) };
+	}
+	async getSequencerBacklog() {
+		const baseResponse = await this.query("backlog", {});
+		return {
+			totalTxs: (0, _nadohq_shared.toBigNumber)(baseResponse.total_txs),
+			totalSubmissions: (0, _nadohq_shared.toBigNumber)(baseResponse.total_submissions),
+			backlogSize: (0, _nadohq_shared.toBigNumber)(baseResponse.backlog_size),
+			updatedAt: (0, _nadohq_shared.toBigNumber)(baseResponse.updated_at),
+			backlogEtaInSeconds: baseResponse.backlog_eta_in_seconds ? (0, _nadohq_shared.toBigNumber)(baseResponse.backlog_eta_in_seconds) : null,
+			txsPerSecond: baseResponse.txs_per_second ? (0, _nadohq_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, _nadohq_shared.toBigNumber)(baseResponse.points),
+			feeRefund: (0, _nadohq_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, _nadohq_shared.toBigNumber)(epoch.start_time),
+				endTime: (0, _nadohq_shared.toBigNumber)(epoch.end_time),
+				totalPoints: (0, _nadohq_shared.toBigNumber)(epoch.total_points),
+				points: (0, _nadohq_shared.toBigNumber)(epoch.points),
+				rank: epoch.rank,
+				tier: epoch.tier
+			})),
+			allTimePoints: {
+				points: (0, _nadohq_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, _nadohq_shared.toIntegerString)(params.recvTime ?? (0, _nadohq_shared.getDefaultRecvTime)()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			provider: params.provider
+		};
+		const tx = (0, _nadohq_shared.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: (0, _nadohq_shared.toIntegerString)(params.recvTime ?? (0, _nadohq_shared.getDefaultRecvTime)()),
+			subaccountName: params.subaccountName,
+			subaccountOwner: params.subaccountOwner,
+			provider: params.provider
+		};
+		const tx = (0, _nadohq_shared.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 (0, _nadohq_shared.mapValues)(response.data, require_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, _nadohq_shared.mapValues)(response.data, require_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 _nadohq_shared.WalletNotProvidedError();
+		return (0, _nadohq_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}`);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "IndexerBaseClient", {
+	enumerable: true,
+	get: function() {
+		return IndexerBaseClient;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+
+//# sourceMappingURL=IndexerBaseClient-3KfzA2ph.cjs.map