@nadohq/nuanze-client 0.41.0

package/README.md

@@ -0,0 +1,72 @@
+# `@nadohq/nuanze-client`
+
+HTTP client for the Nuanze public analytics API. Serves markets, wallets, trades, candles, collateral flows,
+positioning, and globally ranked current open positions. Read-only and credential-free, so unlike the other
+service clients it takes no wallet client or linked signer.
+
+[Full SDK Documentation](https://nadohq.github.io/nado-typescript-sdk/index.html)
+
+## Usage
+
+```ts
+import { NuanzeClient, NUANZE_CLIENT_ENDPOINTS } from '@nadohq/nuanze-client';
+
+const nuanze = new NuanzeClient({
+  url: NUANZE_CLIENT_ENDPOINTS.inkMainnet,
+});
+
+const { markets, asOf } = await nuanze.getMarkets({ venue: 'perp' });
+```
+
+It is also available on a `NadoClient` context, configured from the chain env like the other service clients:
+
+```ts
+const markets = await nadoClient.context.nuanzeClient.getMarkets();
+```
+
+Nuanze runs a single public deployment that serves mainnet data, so every entry in
+`NUANZE_CLIENT_ENDPOINTS` points at the same host.
+
+## API Surface
+
+Each method maps one-to-one onto a public operation. Most are GET; `getFollowedLeaderboard` is a
+non-mutating POST whose body carries the followed set:
+
+- `getNews`
+- `getMarkets`
+- `getMarketByTicker`
+- `getFundingRates`
+- `getLeaderboard`
+- `getPlatformSummary`
+- `getFollowedLeaderboard`
+- `getWalletSummary`
+- `getWalletPositions`
+- `getMarketTrades`
+- `getMarketCandles`
+- `getWalletTrades`
+- `getWalletPnl`
+- `getWalletPnlSeries`
+- `getCollateralFlows`
+- `getCollateralFlowSummary`
+- `getCollateralFlowSeries`
+- `getMarketPositioning`
+- `getMarketPositions`
+- `getOpenPositions`
+
+Decimal fields are mapped to `BigNumber`; timestamps stay UTC ISO 8601 strings, matching the API contract.
+
+## Errors
+
+Failures arrive as `NuanzeServerFailureError`, carrying `errorCode` (comparable against
+`NUANZE_ERROR_CODES`), `httpStatus`, and the `requestId` to quote when reporting the failure.
+
+## Rate Limits
+
+The API meters a weighted token bucket per client IP and reports its state in the `RateLimit-Limit`,
+`RateLimit-Remaining`, and `RateLimit-Reset` response headers. The client never retries, sleeps, or
+self-throttles; add an interceptor on `nuanze.axiosInstance` to observe the headers or to apply per-request
+timeouts and cancellation.
+
+## License
+
+ISC

package/dist/NuanzeClient-BUjoXpWV.cjs

@@ -0,0 +1,327 @@
+//#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");
+const require_types_NuanzeServerFailureError = require("./types/NuanzeServerFailureError.cjs");
+const require_types_serverQueryTypes = require("./types/serverQueryTypes.cjs");
+let axios = require("axios");
+axios = __toESM(axios, 1);
+//#region src/NuanzeClient.ts
+/**
+* Client for the Nuanze public analytics API: markets, wallets, trades, candles, collateral flows,
+* and positioning.
+*
+* Read-only and credential-free, so unlike the other service clients it takes no wallet client or
+* linked signer. It also sends no `x-nado-client-type` header: Nuanze is a public API that does not
+* attribute traffic per client, and its `Access-Control-Allow-Headers` does not list the header, so
+* sending it would fail CORS preflight in the browser. Most operations are GET;
+* {@link NuanzeClient.getFollowedLeaderboard} is a non-mutating POST whose body carries a followed
+* set larger than a query string can reliably hold. The API meters a weighted token bucket per
+* client IP and reports its state in the `RateLimit-Limit`, `RateLimit-Remaining`, and
+* `RateLimit-Reset` response headers; add an interceptor on {@link axiosInstance} to observe them.
+*/
+var NuanzeClient = class {
+	constructor(opts) {
+		this.opts = opts;
+		this.axiosInstance = axios.default.create({
+			withCredentials: false,
+			validateStatus: () => true,
+			paramsSerializer: { indexes: null }
+		});
+	}
+	/**
+	* Lists published editorial stories, sorted by `publishedAt` descending then `id` descending.
+	* The opaque cursor is exclusive and bound to normalized filters. Raw article ingestion, scoring,
+	* queue, and newsdesk fields are excluded.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST`, `INVALID_CURSOR`, or
+	* `CURSOR_FILTER_MISMATCH` when filters or the cursor are invalid.
+	*/
+	async getNews(params = {}) {
+		return require_dataMappers.mapNuanzeNewsResponse(await this.getJson("/news", params));
+	}
+	/**
+	* Gets the active market universe, ordered by `productId` ascending. Never truncated, so `count`
+	* always equals the length of `markets`. Market metadata refreshes about every five minutes and
+	* prices about every minute.
+	*
+	* @throws {NuanzeServerFailureError} With error code `BAD_REQUEST` if a filter value is not a
+	* documented venue or tradability state.
+	*/
+	async getMarkets(params = {}) {
+		return require_dataMappers.mapNuanzeMarketsResponse(await this.getJson("/markets", params));
+	}
+	/**
+	* Resolves a market by ticker. Lookup is case-insensitive and accepts canonical tickers or
+	* legacy source symbols. An explicit unavailable venue returns `MARKET_NOT_FOUND`. With no
+	* venue, `strictVenue=true` returns `AMBIGUOUS_MARKET` for multi-venue assets; otherwise the
+	* primary venue is used.
+	*
+	* @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or
+	* `BAD_REQUEST` on invalid selectors, and `MARKET_NOT_FOUND` when the ticker does not resolve.
+	*/
+	async getMarketByTicker(params) {
+		const { ticker, ...query } = params;
+		return require_dataMappers.mapNuanzeMarketByTickerResponse(await this.getJson(`/markets/${encodeURIComponent(ticker)}`, query));
+	}
+	/**
+	* Lists the latest funding observation per active perpetual market, refreshed about every five
+	* minutes.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.
+	*/
+	async getFundingRates(params = {}) {
+		return require_dataMappers.mapNuanzeFundingRatesResponse(await this.getJson("/funding/rates", params));
+	}
+	/**
+	* Gets the account PnL leaderboard. Equity-basis account PnL includes realized and unrealized
+	* movement plus funding and is not realized PnL. All-time analytics cost five rate-limit units.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.
+	*/
+	async getLeaderboard(params = {}) {
+		return require_dataMappers.mapNuanzeLeaderboardResponse(await this.getJson("/leaderboard", params));
+	}
+	/**
+	* Gets platform activity summary from five-minute aggregates.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST` if the window is not a documented value.
+	*/
+	async getPlatformSummary(params = {}) {
+		return require_dataMappers.mapNuanzePlatformSummaryResponse(await this.getJson("/platform/summary", params));
+	}
+	/**
+	* Gets leaderboard stats for a set of followed subaccounts. POST rather than GET so the body can
+	* carry up to 300 `subaccountHex` values. The response preserves request order. Subaccounts with
+	* no data in the window are backfilled with `pnl: null`, `globalRank: null`, zero counts, and an
+	* empty `productIds`. Costs five rate-limit units. The response is not cached.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_SUBACCOUNT` if a hex is not 32-byte
+	* 0x-prefixed, and `BAD_REQUEST` if the set is empty, exceeds 300, or `timeframe` is not a
+	* documented value.
+	*/
+	async getFollowedLeaderboard(params) {
+		return require_dataMappers.mapNuanzeFollowedLeaderboardResponse(await this.postJson("/wallets/leaderboard", params));
+	}
+	/**
+	* Gets replica-backed wallet analytics. Without `subaccountName`, latest cumulative values are
+	* selected per known subaccount and then summed. The response is a snapshot and does not claim
+	* live health, withdrawable collateral, open-order, or signer state.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,
+	* and `WALLET_NOT_FOUND` when the address has no wallet data.
+	*/
+	async getWalletSummary(params) {
+		const { address, ...query } = params;
+		return require_dataMappers.mapNuanzeWalletSummaryResponse(await this.getJson(`/wallets/${encodeURIComponent(address)}`, query));
+	}
+	/**
+	* Lists at most 500 current replica position rows across all known subaccounts by default. Rows
+	* remain per subaccount. Spot rows are excluded unless `includeSpot=true`. This is not an
+	* execution-grade live feed.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,
+	* and `WALLET_NOT_FOUND` when the address has no wallet data.
+	*/
+	async getWalletPositions(params) {
+		const { address, ...query } = params;
+		return require_dataMappers.mapNuanzeWalletPositionsResponse(await this.getJson(`/wallets/${encodeURIComponent(address)}/positions`, query));
+	}
+	/**
+	* Lists market trades: one taker-side row per match, sorted by `matchedAt` then `id` descending.
+	* The exclusive cursor is bound to operation and normalized filters. `from` is inclusive and
+	* `to` exclusive. Wallet identity is absent.
+	*
+	* @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`,
+	* `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, `RANGE_TOO_LARGE`, or `BAD_REQUEST` on invalid
+	* input, and `MARKET_NOT_FOUND` when the ticker does not resolve.
+	*/
+	async getMarketTrades(params) {
+		const { ticker, ...query } = params;
+		return require_dataMappers.mapNuanzeMarketTradesResponse(await this.getJson(`/markets/${encodeURIComponent(ticker)}/trades`, query));
+	}
+	/**
+	* Lists market candles. Source storage is 1h; 4h and 1d are UTC-aligned rollups and missing bars
+	* are not interpolated. The newest `limit` matching bars are selected and returned
+	* oldest-to-newest, at most 750, with no pagination. A current bucket has `complete=false`.
+	*
+	* @throws {NuanzeServerFailureError} With `UNSUPPORTED_INTERVAL`, `RANGE_TOO_LARGE`,
+	* `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or `BAD_REQUEST` on invalid input, and
+	* `MARKET_NOT_FOUND` when the ticker does not resolve.
+	*/
+	async getMarketCandles(params) {
+		const { ticker, ...query } = params;
+		return require_dataMappers.mapNuanzeMarketCandlesResponse(await this.getJson(`/markets/${encodeURIComponent(ticker)}/candles`, query));
+	}
+	/**
+	* Lists wallet-owned maker and taker execution rows, sorted by `matchedAt` then `id` descending.
+	* The cursor is exclusive and filter-bound. `from` is inclusive and `to` exclusive.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_ADDRESS`, `INVALID_CURSOR`,
+	* `CURSOR_FILTER_MISMATCH`, `RANGE_TOO_LARGE`, or `BAD_REQUEST` on invalid input, and
+	* `WALLET_NOT_FOUND` when the address has no wallet data.
+	*/
+	async getWalletTrades(params) {
+		const { address, ...query } = params;
+		return require_dataMappers.mapNuanzeWalletTradesResponse(await this.getJson(`/wallets/${encodeURIComponent(address)}/trades`, query));
+	}
+	/**
+	* Gets wallet account PnL. 24h is rolling and uses hourly snapshots with a daily fallback
+	* baseline. Longer windows use daily snapshots; `all` starts at earliest coverage. PnL includes
+	* realized and unrealized movement plus funding.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,
+	* and `WALLET_NOT_FOUND` when the address has no wallet data.
+	*/
+	async getWalletPnl(params) {
+		const { address, ...query } = params;
+		return require_dataMappers.mapNuanzeWalletPnlResponse(await this.getJson(`/wallets/${encodeURIComponent(address)}/pnl`, query));
+	}
+	/**
+	* Gets a wallet account series of at most 1,000 deterministically sampled points ordered by
+	* timestamp. Series contain a boundary anchor and a carried-forward request-time tip; synthetic
+	* points are identified. Latest buckets may be provisional.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,
+	* and `WALLET_NOT_FOUND` when the address has no wallet data.
+	*/
+	async getWalletPnlSeries(params) {
+		const { address, ...query } = params;
+		return require_dataMappers.mapNuanzeWalletPnlSeriesResponse(await this.getJson(`/wallets/${encodeURIComponent(address)}/pnl/series`, query));
+	}
+	/**
+	* Lists public collateral events, sorted by timestamp then `id` descending. Repeated `productId`
+	* uses OR semantics. `minUsd` excludes unvalued events; without it unvalued events remain.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST`, `INVALID_CURSOR`, or
+	* `CURSOR_FILTER_MISMATCH` when filters or the cursor are invalid.
+	*/
+	async getCollateralFlows(params = {}) {
+		return require_dataMappers.mapNuanzeCollateralFlowsResponse(await this.getJson("/flows", params));
+	}
+	/**
+	* Gets collateral flow aggregates: deposited, withdrawn, net, and gross, with valuation coverage
+	* and a prior equal-window comparison. `all` has no prior window.
+	*
+	* @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.
+	*/
+	async getCollateralFlowSummary(params = {}) {
+		return require_dataMappers.mapNuanzeCollateralFlowSummaryResponse(await this.getJson("/flows/summary", params));
+	}
+	/**
+	* Gets collateral flow series of at most 1,000 UTC buckets. Allowed timeframe/bucket pairs are
+	* 24h/hour, 7d/hour or day (default hour), 30d/day, and all/day.
+	*
+	* @throws {NuanzeServerFailureError} With `UNSUPPORTED_BUCKET` or `BAD_REQUEST` when the pair or
+	* filters are invalid.
+	*/
+	async getCollateralFlowSeries(params = {}) {
+		return require_dataMappers.mapNuanzeCollateralFlowSeriesResponse(await this.getJson("/flows/series", params));
+	}
+	/**
+	* Gets privacy-preserving aggregate positioning for an active perpetual. Cross and isolated legs
+	* are summed within owner/subaccount/product before direction classification. Every cell requires
+	* at least 20 distinct contributing owners. No identity, individual position, entry price, PnL,
+	* margin, or leverage fields are returned. This operation costs five rate-limit units.
+	*
+	* @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or
+	* `BAD_REQUEST` on invalid input, and `MARKET_NOT_FOUND` when the ticker does not resolve to a
+	* perp.
+	*/
+	async getMarketPositioning(params) {
+		const { ticker, ...query } = params;
+		return require_dataMappers.mapNuanzeMarketPositioningResponse(await this.getJson(`/markets/${encodeURIComponent(ticker)}/positioning`, query));
+	}
+	/**
+	* Lists open perpetual position legs for the resolved market. Results default to absolute
+	* notional descending and can be ordered by signed unrealized PnL or absolute base amount in
+	* either direction. Spot markets are not supported. Legs below $10 absolute notional are excluded.
+	* Wallet addresses and signed exact base amounts are returned.
+	*
+	* @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`,
+	* `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, or `BAD_REQUEST` on invalid input, and
+	* `MARKET_NOT_FOUND` when the ticker does not resolve to a perp.
+	*/
+	async getMarketPositions(params) {
+		const { ticker, ...query } = params;
+		return require_dataMappers.mapNuanzeMarketPositionsResponse(await this.getJson(`/markets/${encodeURIComponent(ticker)}/positions`, query));
+	}
+	/**
+	* Lists current open perpetual position legs across every market by signed unrealized PnL.
+	* Descending returns the largest gainers and ascending returns the largest losers. This is a
+	* latest indexed snapshot with no timeframe. Legs below $10 absolute notional are excluded.
+	* Each row includes market identity and its source snapshot timestamp. Costs five rate-limit
+	* units.
+	*
+	* @throws {NuanzeServerFailureError} With `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, or
+	* `BAD_REQUEST` when the query or cursor is invalid.
+	*/
+	async getOpenPositions(params = {}) {
+		return require_dataMappers.mapNuanzeOpenPositionsResponse(await this.getJson("/positions", params));
+	}
+	/**
+	* Performs a GET against `{baseUrl}{path}` and classifies the status before returning the body.
+	*/
+	async getJson(path, params) {
+		return this.requestJson("GET", path, { params });
+	}
+	/**
+	* Performs a POST against `{baseUrl}{path}` with a JSON body and classifies the status before
+	* returning the response. Used only for the non-mutating followed-leaderboard operation.
+	*/
+	async postJson(path, data) {
+		return this.requestJson("POST", path, { data });
+	}
+	async requestJson(method, path, config = {}) {
+		const response = await this.axiosInstance.request({
+			method,
+			url: `${this.opts.url}${path}`,
+			...config
+		});
+		this.checkResponseStatus(response);
+		return response.data;
+	}
+	/**
+	* Validates the HTTP status before interpreting the body. Nuanze maps every domain failure onto a
+	* non-2xx status carrying a failure envelope, so anything else is a transport-level error.
+	*/
+	checkResponseStatus(response) {
+		if (response.status >= 200 && response.status < 300) return;
+		if (require_types_serverQueryTypes.isNuanzeServerFailureResponse(response.data)) throw new require_types_NuanzeServerFailureError.NuanzeServerFailureError(response.data, response.status);
+		throw new Error(`Unexpected response from Nuanze: ${response.status} ${response.statusText}. Data: ${JSON.stringify(response.data)}`);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "NuanzeClient", {
+	enumerable: true,
+	get: function() {
+		return NuanzeClient;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+
+//# sourceMappingURL=NuanzeClient-BUjoXpWV.cjs.map

package/dist/NuanzeClient-BUjoXpWV.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NuanzeClient-BUjoXpWV.cjs","names":["mapNuanzeNewsResponse","mapNuanzeMarketsResponse","mapNuanzeMarketByTickerResponse","mapNuanzeFundingRatesResponse","mapNuanzeLeaderboardResponse","mapNuanzePlatformSummaryResponse","mapNuanzeFollowedLeaderboardResponse","mapNuanzeWalletSummaryResponse","mapNuanzeWalletPositionsResponse","mapNuanzeMarketTradesResponse","mapNuanzeMarketCandlesResponse","mapNuanzeWalletTradesResponse","mapNuanzeWalletPnlResponse","mapNuanzeWalletPnlSeriesResponse","mapNuanzeCollateralFlowsResponse","mapNuanzeCollateralFlowSummaryResponse","mapNuanzeCollateralFlowSeriesResponse","mapNuanzeMarketPositioningResponse","mapNuanzeMarketPositionsResponse","mapNuanzeOpenPositionsResponse","isNuanzeServerFailureResponse","NuanzeServerFailureError"],"sources":["../src/NuanzeClient.ts"],"sourcesContent":["import axios, { AxiosInstance, AxiosResponse } from 'axios';\nimport {\n  mapNuanzeCollateralFlowSeriesResponse,\n  mapNuanzeCollateralFlowSummaryResponse,\n  mapNuanzeCollateralFlowsResponse,\n  mapNuanzeFollowedLeaderboardResponse,\n  mapNuanzeFundingRatesResponse,\n  mapNuanzeLeaderboardResponse,\n  mapNuanzeMarketByTickerResponse,\n  mapNuanzeMarketCandlesResponse,\n  mapNuanzeMarketPositioningResponse,\n  mapNuanzeMarketPositionsResponse,\n  mapNuanzeMarketTradesResponse,\n  mapNuanzeMarketsResponse,\n  mapNuanzeNewsResponse,\n  mapNuanzeOpenPositionsResponse,\n  mapNuanzePlatformSummaryResponse,\n  mapNuanzeWalletPnlResponse,\n  mapNuanzeWalletPnlSeriesResponse,\n  mapNuanzeWalletPositionsResponse,\n  mapNuanzeWalletSummaryResponse,\n  mapNuanzeWalletTradesResponse,\n} from './dataMappers';\nimport {\n  GetNuanzeCollateralFlowSeriesParams,\n  GetNuanzeCollateralFlowSeriesResponse,\n  GetNuanzeCollateralFlowSummaryParams,\n  GetNuanzeCollateralFlowSummaryResponse,\n  GetNuanzeCollateralFlowsParams,\n  GetNuanzeCollateralFlowsResponse,\n  GetNuanzeFollowedLeaderboardParams,\n  GetNuanzeFollowedLeaderboardResponse,\n  GetNuanzeFundingRatesParams,\n  GetNuanzeFundingRatesResponse,\n  GetNuanzeLeaderboardParams,\n  GetNuanzeLeaderboardResponse,\n  GetNuanzeMarketByTickerParams,\n  GetNuanzeMarketByTickerResponse,\n  GetNuanzeMarketCandlesParams,\n  GetNuanzeMarketCandlesResponse,\n  GetNuanzeMarketPositioningParams,\n  GetNuanzeMarketPositioningResponse,\n  GetNuanzeMarketPositionsParams,\n  GetNuanzeMarketPositionsResponse,\n  GetNuanzeMarketTradesParams,\n  GetNuanzeMarketTradesResponse,\n  GetNuanzeMarketsParams,\n  GetNuanzeMarketsResponse,\n  GetNuanzeNewsParams,\n  GetNuanzeNewsResponse,\n  GetNuanzeOpenPositionsParams,\n  GetNuanzeOpenPositionsResponse,\n  GetNuanzePlatformSummaryParams,\n  GetNuanzePlatformSummaryResponse,\n  GetNuanzeWalletPnlParams,\n  GetNuanzeWalletPnlResponse,\n  GetNuanzeWalletPnlSeriesParams,\n  GetNuanzeWalletPnlSeriesResponse,\n  GetNuanzeWalletPositionsParams,\n  GetNuanzeWalletPositionsResponse,\n  GetNuanzeWalletSummaryParams,\n  GetNuanzeWalletSummaryResponse,\n  GetNuanzeWalletTradesParams,\n  GetNuanzeWalletTradesResponse,\n} from './types/clientTypes';\nimport { NuanzeServerFailureError } from './types/NuanzeServerFailureError';\nimport { NuanzeServerMarketPositioningResponse } from './types/serverModelTypes';\nimport {\n  NuanzeServerCollateralFlowSeriesResponse,\n  NuanzeServerCollateralFlowSummaryResponse,\n  NuanzeServerCollateralFlowsResponse,\n  NuanzeServerFollowedLeaderboardResponse,\n  NuanzeServerFundingRatesResponse,\n  NuanzeServerLeaderboardResponse,\n  NuanzeServerMarketByTickerResponse,\n  NuanzeServerMarketCandlesResponse,\n  NuanzeServerMarketPositionsResponse,\n  NuanzeServerMarketTradesResponse,\n  NuanzeServerMarketsResponse,\n  NuanzeServerNewsResponse,\n  NuanzeServerOpenPositionsResponse,\n  NuanzeServerPlatformSummaryResponse,\n  NuanzeServerWalletPnlResponse,\n  NuanzeServerWalletPnlSeriesResponse,\n  NuanzeServerWalletPositionsResponse,\n  NuanzeServerWalletSummaryResponse,\n  NuanzeServerWalletTradesResponse,\n  isNuanzeServerFailureResponse,\n} from './types/serverQueryTypes';\n\n/**\n * Options for constructing a {@link NuanzeClient}.\n */\nexport interface NuanzeClientOpts {\n  /**\n   * Base URL of the Nuanze API, including the version segment, e.g. {@link NUANZE_CLIENT_ENDPOINTS}.\n   */\n  url: string;\n}\n\n/**\n * Client for the Nuanze public analytics API: markets, wallets, trades, candles, collateral flows,\n * and positioning.\n *\n * Read-only and credential-free, so unlike the other service clients it takes no wallet client or\n * linked signer. It also sends no `x-nado-client-type` header: Nuanze is a public API that does not\n * attribute traffic per client, and its `Access-Control-Allow-Headers` does not list the header, so\n * sending it would fail CORS preflight in the browser. Most operations are GET;\n * {@link NuanzeClient.getFollowedLeaderboard} is a non-mutating POST whose body carries a followed\n * set larger than a query string can reliably hold. The API meters a weighted token bucket per\n * client IP and reports its state in the `RateLimit-Limit`, `RateLimit-Remaining`, and\n * `RateLimit-Reset` response headers; add an interceptor on {@link axiosInstance} to observe them.\n */\nexport class NuanzeClient {\n  readonly opts: NuanzeClientOpts;\n  readonly axiosInstance: AxiosInstance;\n\n  constructor(opts: NuanzeClientOpts) {\n    this.opts = opts;\n    this.axiosInstance = axios.create({\n      // Nuanze is public and answers every origin with `Access-Control-Allow-Origin: *`, which\n      // browsers reject for credentialed requests.\n      withCredentials: false,\n      // We have custom logic to validate response status and create an appropriate error\n      validateStatus: () => true,\n      // Repeatable `productId` must serialize as `productId=1&productId=2` (OpenAPI explode).\n      paramsSerializer: { indexes: null },\n    });\n  }\n\n  /**\n   * Lists published editorial stories, sorted by `publishedAt` descending then `id` descending.\n   * The opaque cursor is exclusive and bound to normalized filters. Raw article ingestion, scoring,\n   * queue, and newsdesk fields are excluded.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST`, `INVALID_CURSOR`, or\n   * `CURSOR_FILTER_MISMATCH` when filters or the cursor are invalid.\n   */\n  async getNews(\n    params: GetNuanzeNewsParams = {},\n  ): Promise<GetNuanzeNewsResponse> {\n    return mapNuanzeNewsResponse(\n      await this.getJson<NuanzeServerNewsResponse>('/news', params),\n    );\n  }\n\n  /**\n   * Gets the active market universe, ordered by `productId` ascending. Never truncated, so `count`\n   * always equals the length of `markets`. Market metadata refreshes about every five minutes and\n   * prices about every minute.\n   *\n   * @throws {NuanzeServerFailureError} With error code `BAD_REQUEST` if a filter value is not a\n   * documented venue or tradability state.\n   */\n  async getMarkets(\n    params: GetNuanzeMarketsParams = {},\n  ): Promise<GetNuanzeMarketsResponse> {\n    return mapNuanzeMarketsResponse(\n      await this.getJson<NuanzeServerMarketsResponse>('/markets', params),\n    );\n  }\n\n  /**\n   * Resolves a market by ticker. Lookup is case-insensitive and accepts canonical tickers or\n   * legacy source symbols. An explicit unavailable venue returns `MARKET_NOT_FOUND`. With no\n   * venue, `strictVenue=true` returns `AMBIGUOUS_MARKET` for multi-venue assets; otherwise the\n   * primary venue is used.\n   *\n   * @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or\n   * `BAD_REQUEST` on invalid selectors, and `MARKET_NOT_FOUND` when the ticker does not resolve.\n   */\n  async getMarketByTicker(\n    params: GetNuanzeMarketByTickerParams,\n  ): Promise<GetNuanzeMarketByTickerResponse> {\n    const { ticker, ...query } = params;\n    return mapNuanzeMarketByTickerResponse(\n      await this.getJson<NuanzeServerMarketByTickerResponse>(\n        `/markets/${encodeURIComponent(ticker)}`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists the latest funding observation per active perpetual market, refreshed about every five\n   * minutes.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.\n   */\n  async getFundingRates(\n    params: GetNuanzeFundingRatesParams = {},\n  ): Promise<GetNuanzeFundingRatesResponse> {\n    return mapNuanzeFundingRatesResponse(\n      await this.getJson<NuanzeServerFundingRatesResponse>(\n        '/funding/rates',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets the account PnL leaderboard. Equity-basis account PnL includes realized and unrealized\n   * movement plus funding and is not realized PnL. All-time analytics cost five rate-limit units.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.\n   */\n  async getLeaderboard(\n    params: GetNuanzeLeaderboardParams = {},\n  ): Promise<GetNuanzeLeaderboardResponse> {\n    return mapNuanzeLeaderboardResponse(\n      await this.getJson<NuanzeServerLeaderboardResponse>(\n        '/leaderboard',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets platform activity summary from five-minute aggregates.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST` if the window is not a documented value.\n   */\n  async getPlatformSummary(\n    params: GetNuanzePlatformSummaryParams = {},\n  ): Promise<GetNuanzePlatformSummaryResponse> {\n    return mapNuanzePlatformSummaryResponse(\n      await this.getJson<NuanzeServerPlatformSummaryResponse>(\n        '/platform/summary',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets leaderboard stats for a set of followed subaccounts. POST rather than GET so the body can\n   * carry up to 300 `subaccountHex` values. The response preserves request order. Subaccounts with\n   * no data in the window are backfilled with `pnl: null`, `globalRank: null`, zero counts, and an\n   * empty `productIds`. Costs five rate-limit units. The response is not cached.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_SUBACCOUNT` if a hex is not 32-byte\n   * 0x-prefixed, and `BAD_REQUEST` if the set is empty, exceeds 300, or `timeframe` is not a\n   * documented value.\n   */\n  async getFollowedLeaderboard(\n    params: GetNuanzeFollowedLeaderboardParams,\n  ): Promise<GetNuanzeFollowedLeaderboardResponse> {\n    return mapNuanzeFollowedLeaderboardResponse(\n      await this.postJson<NuanzeServerFollowedLeaderboardResponse>(\n        '/wallets/leaderboard',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets replica-backed wallet analytics. Without `subaccountName`, latest cumulative values are\n   * selected per known subaccount and then summed. The response is a snapshot and does not claim\n   * live health, withdrawable collateral, open-order, or signer state.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,\n   * and `WALLET_NOT_FOUND` when the address has no wallet data.\n   */\n  async getWalletSummary(\n    params: GetNuanzeWalletSummaryParams,\n  ): Promise<GetNuanzeWalletSummaryResponse> {\n    const { address, ...query } = params;\n    return mapNuanzeWalletSummaryResponse(\n      await this.getJson<NuanzeServerWalletSummaryResponse>(\n        `/wallets/${encodeURIComponent(address)}`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists at most 500 current replica position rows across all known subaccounts by default. Rows\n   * remain per subaccount. Spot rows are excluded unless `includeSpot=true`. This is not an\n   * execution-grade live feed.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,\n   * and `WALLET_NOT_FOUND` when the address has no wallet data.\n   */\n  async getWalletPositions(\n    params: GetNuanzeWalletPositionsParams,\n  ): Promise<GetNuanzeWalletPositionsResponse> {\n    const { address, ...query } = params;\n    return mapNuanzeWalletPositionsResponse(\n      await this.getJson<NuanzeServerWalletPositionsResponse>(\n        `/wallets/${encodeURIComponent(address)}/positions`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists market trades: one taker-side row per match, sorted by `matchedAt` then `id` descending.\n   * The exclusive cursor is bound to operation and normalized filters. `from` is inclusive and\n   * `to` exclusive. Wallet identity is absent.\n   *\n   * @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`,\n   * `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, `RANGE_TOO_LARGE`, or `BAD_REQUEST` on invalid\n   * input, and `MARKET_NOT_FOUND` when the ticker does not resolve.\n   */\n  async getMarketTrades(\n    params: GetNuanzeMarketTradesParams,\n  ): Promise<GetNuanzeMarketTradesResponse> {\n    const { ticker, ...query } = params;\n    return mapNuanzeMarketTradesResponse(\n      await this.getJson<NuanzeServerMarketTradesResponse>(\n        `/markets/${encodeURIComponent(ticker)}/trades`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists market candles. Source storage is 1h; 4h and 1d are UTC-aligned rollups and missing bars\n   * are not interpolated. The newest `limit` matching bars are selected and returned\n   * oldest-to-newest, at most 750, with no pagination. A current bucket has `complete=false`.\n   *\n   * @throws {NuanzeServerFailureError} With `UNSUPPORTED_INTERVAL`, `RANGE_TOO_LARGE`,\n   * `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or `BAD_REQUEST` on invalid input, and\n   * `MARKET_NOT_FOUND` when the ticker does not resolve.\n   */\n  async getMarketCandles(\n    params: GetNuanzeMarketCandlesParams,\n  ): Promise<GetNuanzeMarketCandlesResponse> {\n    const { ticker, ...query } = params;\n    return mapNuanzeMarketCandlesResponse(\n      await this.getJson<NuanzeServerMarketCandlesResponse>(\n        `/markets/${encodeURIComponent(ticker)}/candles`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists wallet-owned maker and taker execution rows, sorted by `matchedAt` then `id` descending.\n   * The cursor is exclusive and filter-bound. `from` is inclusive and `to` exclusive.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_ADDRESS`, `INVALID_CURSOR`,\n   * `CURSOR_FILTER_MISMATCH`, `RANGE_TOO_LARGE`, or `BAD_REQUEST` on invalid input, and\n   * `WALLET_NOT_FOUND` when the address has no wallet data.\n   */\n  async getWalletTrades(\n    params: GetNuanzeWalletTradesParams,\n  ): Promise<GetNuanzeWalletTradesResponse> {\n    const { address, ...query } = params;\n    return mapNuanzeWalletTradesResponse(\n      await this.getJson<NuanzeServerWalletTradesResponse>(\n        `/wallets/${encodeURIComponent(address)}/trades`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Gets wallet account PnL. 24h is rolling and uses hourly snapshots with a daily fallback\n   * baseline. Longer windows use daily snapshots; `all` starts at earliest coverage. PnL includes\n   * realized and unrealized movement plus funding.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,\n   * and `WALLET_NOT_FOUND` when the address has no wallet data.\n   */\n  async getWalletPnl(\n    params: GetNuanzeWalletPnlParams,\n  ): Promise<GetNuanzeWalletPnlResponse> {\n    const { address, ...query } = params;\n    return mapNuanzeWalletPnlResponse(\n      await this.getJson<NuanzeServerWalletPnlResponse>(\n        `/wallets/${encodeURIComponent(address)}/pnl`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Gets a wallet account series of at most 1,000 deterministically sampled points ordered by\n   * timestamp. Series contain a boundary anchor and a carried-forward request-time tip; synthetic\n   * points are identified. Latest buckets may be provisional.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_ADDRESS` or `BAD_REQUEST` on invalid input,\n   * and `WALLET_NOT_FOUND` when the address has no wallet data.\n   */\n  async getWalletPnlSeries(\n    params: GetNuanzeWalletPnlSeriesParams,\n  ): Promise<GetNuanzeWalletPnlSeriesResponse> {\n    const { address, ...query } = params;\n    return mapNuanzeWalletPnlSeriesResponse(\n      await this.getJson<NuanzeServerWalletPnlSeriesResponse>(\n        `/wallets/${encodeURIComponent(address)}/pnl/series`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists public collateral events, sorted by timestamp then `id` descending. Repeated `productId`\n   * uses OR semantics. `minUsd` excludes unvalued events; without it unvalued events remain.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST`, `INVALID_CURSOR`, or\n   * `CURSOR_FILTER_MISMATCH` when filters or the cursor are invalid.\n   */\n  async getCollateralFlows(\n    params: GetNuanzeCollateralFlowsParams = {},\n  ): Promise<GetNuanzeCollateralFlowsResponse> {\n    return mapNuanzeCollateralFlowsResponse(\n      await this.getJson<NuanzeServerCollateralFlowsResponse>('/flows', params),\n    );\n  }\n\n  /**\n   * Gets collateral flow aggregates: deposited, withdrawn, net, and gross, with valuation coverage\n   * and a prior equal-window comparison. `all` has no prior window.\n   *\n   * @throws {NuanzeServerFailureError} With `BAD_REQUEST` if a filter value is invalid.\n   */\n  async getCollateralFlowSummary(\n    params: GetNuanzeCollateralFlowSummaryParams = {},\n  ): Promise<GetNuanzeCollateralFlowSummaryResponse> {\n    return mapNuanzeCollateralFlowSummaryResponse(\n      await this.getJson<NuanzeServerCollateralFlowSummaryResponse>(\n        '/flows/summary',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets collateral flow series of at most 1,000 UTC buckets. Allowed timeframe/bucket pairs are\n   * 24h/hour, 7d/hour or day (default hour), 30d/day, and all/day.\n   *\n   * @throws {NuanzeServerFailureError} With `UNSUPPORTED_BUCKET` or `BAD_REQUEST` when the pair or\n   * filters are invalid.\n   */\n  async getCollateralFlowSeries(\n    params: GetNuanzeCollateralFlowSeriesParams = {},\n  ): Promise<GetNuanzeCollateralFlowSeriesResponse> {\n    return mapNuanzeCollateralFlowSeriesResponse(\n      await this.getJson<NuanzeServerCollateralFlowSeriesResponse>(\n        '/flows/series',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Gets privacy-preserving aggregate positioning for an active perpetual. Cross and isolated legs\n   * are summed within owner/subaccount/product before direction classification. Every cell requires\n   * at least 20 distinct contributing owners. No identity, individual position, entry price, PnL,\n   * margin, or leverage fields are returned. This operation costs five rate-limit units.\n   *\n   * @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`, or\n   * `BAD_REQUEST` on invalid input, and `MARKET_NOT_FOUND` when the ticker does not resolve to a\n   * perp.\n   */\n  async getMarketPositioning(\n    params: GetNuanzeMarketPositioningParams,\n  ): Promise<GetNuanzeMarketPositioningResponse> {\n    const { ticker, ...query } = params;\n    return mapNuanzeMarketPositioningResponse(\n      await this.getJson<NuanzeServerMarketPositioningResponse>(\n        `/markets/${encodeURIComponent(ticker)}/positioning`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists open perpetual position legs for the resolved market. Results default to absolute\n   * notional descending and can be ordered by signed unrealized PnL or absolute base amount in\n   * either direction. Spot markets are not supported. Legs below $10 absolute notional are excluded.\n   * Wallet addresses and signed exact base amounts are returned.\n   *\n   * @throws {NuanzeServerFailureError} With `AMBIGUOUS_MARKET`, `MARKET_SELECTOR_MISMATCH`,\n   * `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, or `BAD_REQUEST` on invalid input, and\n   * `MARKET_NOT_FOUND` when the ticker does not resolve to a perp.\n   */\n  async getMarketPositions(\n    params: GetNuanzeMarketPositionsParams,\n  ): Promise<GetNuanzeMarketPositionsResponse> {\n    const { ticker, ...query } = params;\n    return mapNuanzeMarketPositionsResponse(\n      await this.getJson<NuanzeServerMarketPositionsResponse>(\n        `/markets/${encodeURIComponent(ticker)}/positions`,\n        query,\n      ),\n    );\n  }\n\n  /**\n   * Lists current open perpetual position legs across every market by signed unrealized PnL.\n   * Descending returns the largest gainers and ascending returns the largest losers. This is a\n   * latest indexed snapshot with no timeframe. Legs below $10 absolute notional are excluded.\n   * Each row includes market identity and its source snapshot timestamp. Costs five rate-limit\n   * units.\n   *\n   * @throws {NuanzeServerFailureError} With `INVALID_CURSOR`, `CURSOR_FILTER_MISMATCH`, or\n   * `BAD_REQUEST` when the query or cursor is invalid.\n   */\n  async getOpenPositions(\n    params: GetNuanzeOpenPositionsParams = {},\n  ): Promise<GetNuanzeOpenPositionsResponse> {\n    return mapNuanzeOpenPositionsResponse(\n      await this.getJson<NuanzeServerOpenPositionsResponse>(\n        '/positions',\n        params,\n      ),\n    );\n  }\n\n  /**\n   * Performs a GET against `{baseUrl}{path}` and classifies the status before returning the body.\n   */\n  private async getJson<T>(path: string, params?: object): Promise<T> {\n    return this.requestJson<T>('GET', path, { params });\n  }\n\n  /**\n   * Performs a POST against `{baseUrl}{path}` with a JSON body and classifies the status before\n   * returning the response. Used only for the non-mutating followed-leaderboard operation.\n   */\n  private async postJson<T>(path: string, data: object): Promise<T> {\n    return this.requestJson<T>('POST', path, { data });\n  }\n\n  private async requestJson<T>(\n    method: 'GET' | 'POST',\n    path: string,\n    config: { params?: object; data?: object } = {},\n  ): Promise<T> {\n    const response = await this.axiosInstance.request<T>({\n      method,\n      url: `${this.opts.url}${path}`,\n      ...config,\n    });\n    this.checkResponseStatus(response);\n    return response.data;\n  }\n\n  /**\n   * Validates the HTTP status before interpreting the body. Nuanze maps every domain failure onto a\n   * non-2xx status carrying a failure envelope, so anything else is a transport-level error.\n   */\n  private checkResponseStatus(response: AxiosResponse<unknown>) {\n    if (response.status >= 200 && response.status < 300) {\n      return;\n    }\n    if (isNuanzeServerFailureResponse(response.data)) {\n      throw new NuanzeServerFailureError(response.data, response.status);\n    }\n    throw new Error(\n      `Unexpected response from Nuanze: ${response.status} ${response.statusText}. Data: ${JSON.stringify(response.data)}`,\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/NuanzeClient.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_NuanzeClient = require("./NuanzeClient-BUjoXpWV.cjs");
+require("./dataMappers.cjs");
+exports.NuanzeClient = require_NuanzeClient.NuanzeClient;