@satianurag/hiero-mirror-client 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2218 @@
+import { parse } from "lossless-json";
+//#region src/errors/HieroError.ts
+/**
+* Base error class for all Hiero Mirror Client errors.
+*
+* Modeled after Stripe's error hierarchy — every SDK error extends this class,
+* enabling `instanceof HieroError` to catch all SDK-specific errors.
+*
+* @public
+*/
+var HieroError = class extends Error {
+	/** HTTP status code, if the error originated from an HTTP response. */
+	statusCode;
+	/** The raw response body, if available. */
+	rawBody;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "HieroError";
+		this.statusCode = options?.statusCode;
+		this.rawBody = options?.rawBody;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			statusCode: this.statusCode
+		};
+	}
+};
+//#endregion
+//#region src/errors/HieroNotFoundError.ts
+/**
+* Thrown when the server returns HTTP 404 (Not Found) for a specific entity.
+*
+* @public
+*/
+var HieroNotFoundError = class extends HieroError {
+	/** The entity ID that was not found, if available. */
+	entityId;
+	constructor(message, options) {
+		super(message, {
+			statusCode: 404,
+			rawBody: options?.rawBody
+		});
+		this.name = "HieroNotFoundError";
+		this.entityId = options?.entityId;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			entityId: this.entityId
+		};
+	}
+};
+//#endregion
+//#region src/errors/HieroParseError.ts
+/**
+* Thrown when the response body cannot be parsed as JSON,
+* or when the response Content-Type is unexpected (e.g., `text/html`
+* for Unicode parameter errors — EC153).
+*
+* @public
+*/
+var HieroParseError = class extends HieroError {
+	/** The raw body text that could not be parsed. */
+	body;
+	constructor(message, options) {
+		super(message, {
+			statusCode: options.statusCode,
+			rawBody: options.body,
+			cause: options.cause
+		});
+		this.name = "HieroParseError";
+		this.body = options.body;
+	}
+};
+//#endregion
+//#region src/errors/HieroRateLimitError.ts
+/**
+* Thrown when the server returns HTTP 429 (Too Many Requests).
+*
+* @public
+*/
+var HieroRateLimitError = class extends HieroError {
+	/** Seconds to wait before retrying, parsed from `Retry-After` header. */
+	retryAfter;
+	constructor(message, options) {
+		super(message, {
+			statusCode: 429,
+			rawBody: options?.rawBody
+		});
+		this.name = "HieroRateLimitError";
+		this.retryAfter = options?.retryAfter;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			retryAfter: this.retryAfter
+		};
+	}
+};
+//#endregion
+//#region src/errors/HieroServerError.ts
+/**
+* Thrown when the server returns an HTTP 5xx error.
+*
+* @public
+*/
+var HieroServerError = class extends HieroError {
+	constructor(message, options) {
+		super(message, {
+			statusCode: options?.statusCode ?? 500,
+			rawBody: options?.rawBody
+		});
+		this.name = "HieroServerError";
+	}
+};
+//#endregion
+//#region src/errors/HieroValidationError.ts
+/**
+* Thrown when the server returns HTTP 400 or 415, or when client-side
+* input validation fails before the request is sent.
+*
+* @public
+*/
+var HieroValidationError = class extends HieroError {
+	/** The specific parameter that caused the validation error, if known. */
+	parameter;
+	constructor(message, options) {
+		super(message, {
+			statusCode: options?.statusCode ?? 400,
+			rawBody: options?.rawBody
+		});
+		this.name = "HieroValidationError";
+		this.parameter = options?.parameter;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			parameter: this.parameter
+		};
+	}
+};
+//#endregion
+//#region src/errors/factory.ts
+/**
+* Attempts to extract the error message from the Mirror Node's custom error shape.
+* Falls back to a generic message if parsing fails.
+*
+* @internal
+*/
+function extractErrorMessage(body) {
+	if (typeof body === "object" && body !== null) {
+		const firstMessage = body._status?.messages?.[0];
+		if (firstMessage) {
+			const parts = [firstMessage.message];
+			if (firstMessage.detail) parts.push(firstMessage.detail);
+			return parts.filter(Boolean).join(": ");
+		}
+	}
+	return "Unknown error";
+}
+/**
+* Attempts to extract a parameter name from Mirror Node error messages.
+* Messages like "Invalid parameter: limit" → returns "limit".
+*
+* @internal
+*/
+function extractParameter(message) {
+	return /Invalid parameter:\s*(.+)/i.exec(message)?.[1]?.trim();
+}
+/**
+* Creates the appropriate error subclass from an HTTP response.
+*
+* Maps HTTP status codes to error subclasses:
+* - 400 → `HieroValidationError`
+* - 404 → `HieroNotFoundError`
+* - 415 → `HieroValidationError` (wrong Content-Type, EC52)
+* - 429 → `HieroRateLimitError`
+* - 5xx → `HieroServerError`
+* - Other → `HieroError`
+*
+* @internal
+*/
+function createErrorFromResponse(statusCode, body, rawBody, headers) {
+	const message = extractErrorMessage(body);
+	switch (true) {
+		case statusCode === 400:
+		case statusCode === 415: return new HieroValidationError(message, {
+			statusCode,
+			parameter: extractParameter(message),
+			rawBody
+		});
+		case statusCode === 404: return new HieroNotFoundError(message, { rawBody });
+		case statusCode === 429: {
+			let retryAfter;
+			const retryAfterHeader = headers?.get("retry-after");
+			if (retryAfterHeader) {
+				const parsed = Number.parseInt(retryAfterHeader, 10);
+				if (!Number.isNaN(parsed)) retryAfter = parsed;
+			}
+			return new HieroRateLimitError(message, {
+				retryAfter,
+				rawBody
+			});
+		}
+		case statusCode >= 500: return new HieroServerError(message, {
+			statusCode,
+			rawBody
+		});
+		default: return new HieroError(message, {
+			statusCode,
+			rawBody
+		});
+	}
+}
+/**
+* Creates an error from a non-JSON response body (e.g., HTML error pages from EC153).
+*
+* @internal
+*/
+function createParseError(rawBody, statusCode, cause) {
+	return new HieroParseError("Failed to parse response body as JSON", {
+		body: rawBody,
+		statusCode,
+		cause
+	});
+}
+//#endregion
+//#region src/errors/HieroNetworkError.ts
+/**
+* Thrown when a network-level error occurs: DNS resolution failure,
+* connection refused, socket hangup, etc.
+*
+* @public
+*/
+var HieroNetworkError = class extends HieroError {
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "HieroNetworkError";
+	}
+};
+//#endregion
+//#region src/errors/HieroTimeoutError.ts
+/**
+* Thrown when a request exceeds the configured timeout (AbortController).
+*
+* @public
+*/
+var HieroTimeoutError = class extends HieroError {
+	/** The timeout duration in milliseconds that was exceeded. */
+	timeoutMs;
+	constructor(timeoutMs, options) {
+		super(`Request timed out after ${timeoutMs}ms`, { cause: options?.cause });
+		this.name = "HieroTimeoutError";
+		this.timeoutMs = timeoutMs;
+	}
+};
+//#endregion
+//#region src/http/etag-cache.ts
+/**
+* Simple in-memory ETag cache.
+*
+* Keys are normalized URLs (no trailing slashes).
+*/
+var ETagCache = class {
+	store = /* @__PURE__ */ new Map();
+	/**
+	* Look up a cached ETag for the given URL.
+	*
+	* @returns The cached ETag string, or `undefined` if not cached.
+	*/
+	getETag(url) {
+		return this.store.get(this.normalizeKey(url))?.etag;
+	}
+	/**
+	* Look up the cached response body for the given URL.
+	*
+	* @returns The cached body, or `undefined` if not cached.
+	*/
+	getCachedBody(url) {
+		return this.store.get(this.normalizeKey(url))?.body;
+	}
+	/**
+	* Store or update a cache entry.
+	*/
+	set(url, etag, body) {
+		this.store.set(this.normalizeKey(url), {
+			etag,
+			body
+		});
+	}
+	/**
+	* Remove a cache entry.
+	*/
+	delete(url) {
+		this.store.delete(this.normalizeKey(url));
+	}
+	/**
+	* Clear all cached entries.
+	*/
+	clear() {
+		this.store.clear();
+	}
+	/**
+	* Number of entries in the cache.
+	*/
+	get size() {
+		return this.store.size;
+	}
+	/**
+	* Normalize a URL for use as a cache key.
+	*
+	* EC43: Removes trailing slashes.
+	*/
+	normalizeKey(url) {
+		return url.replace(/\/+$/, "");
+	}
+};
+//#endregion
+//#region src/http/json-parser.ts
+/**
+* Safe JSON parser that prevents int64 precision loss.
+*
+* **Primary:** TC39 Stage 4 `context.source` reviver (Node 22+, modern browsers as of March 2026).
+* **Fallback:** `lossless-json` library (4KB, for Node 18-20 without `context.source`).
+*
+* Numbers exceeding `Number.MAX_SAFE_INTEGER` are returned as strings.
+* Decimals (e.g., `0.1`) remain as numbers.
+*
+* @internal
+*/
+/** Maximum response body size (10MB) before parsing is rejected. */
+const MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
+/**
+* Feature-detect `context.source` support (TC39 Stage 4, Nov 2025).
+* Evaluated once at module load time.
+*/
+const HAS_CONTEXT_SOURCE = (() => {
+	try {
+		let seen = false;
+		JSON.parse("1", (_key, _value, context) => {
+			if (context?.source !== void 0) seen = true;
+		});
+		return seen;
+	} catch {
+		return false;
+	}
+})();
+/**
+* Reviver function for `JSON.parse` that uses TC39 `context.source` to detect
+* unsafe integers and return them as strings.
+*
+* Rules:
+* - Integers exceeding MAX_SAFE_INTEGER → return raw source string
+* - Safe integers → return as number
+* - Decimals (non-integer numbers like 0.1) → return as number
+* - All other types → pass through unchanged
+*/
+function safeReviver(_key, value, context) {
+	if (typeof value === "number" && context?.source !== void 0) {
+		const source = context.source;
+		if (!source.includes(".") && !source.includes("e") && !source.includes("E") && !Number.isSafeInteger(value)) return source;
+	}
+	return value;
+}
+/**
+* Fallback parser using `lossless-json` for environments without `context.source`.
+*
+* The lossless-json library parses all numbers as `LosslessNumber` objects,
+* then the reviver converts them back to `number` (if safe) or `string` (if unsafe).
+*/
+function safeJsonParseFallback(text) {
+	return parse(text, void 0, (value) => {
+		const num = Number(value);
+		if (Number.isNaN(num)) return value;
+		if (!(!value.includes(".") && !value.includes("e") && !value.includes("E"))) return num;
+		if (Number.isSafeInteger(num)) return num;
+		return value;
+	});
+}
+/**
+* Parses a JSON string safely, preserving precision for large integers.
+*
+* Numbers exceeding `Number.MAX_SAFE_INTEGER` are returned as strings.
+* Decimals remain as JavaScript `number` values.
+*
+* @param text - The raw JSON string to parse
+* @returns The parsed value
+* @throws {Error} If the input exceeds the maximum response size
+* @throws {SyntaxError} If the input is not valid JSON
+*
+* @internal
+*/
+function safeJsonParse(text) {
+	if (text.length > MAX_RESPONSE_SIZE) throw new Error(`Response body exceeds maximum size of ${MAX_RESPONSE_SIZE} bytes (${text.length} bytes received)`);
+	if (HAS_CONTEXT_SOURCE) return JSON.parse(text, safeReviver);
+	return safeJsonParseFallback(text);
+}
+//#endregion
+//#region src/http/rate-limiter.ts
+/**
+* Token bucket rate limiter for client-side request throttling.
+*
+* Uses a simple token bucket algorithm:
+* - Bucket starts full with `maxTokens` tokens
+* - Each request consumes 1 token
+* - Tokens replenish at `tokensPerSecond` rate
+* - If no tokens available, `acquire()` waits until a token is available
+*
+* Default: 50 requests per second.
+*
+* @internal
+*/
+var RateLimiter = class {
+	tokens;
+	maxTokens;
+	refillRate;
+	lastRefillTime;
+	constructor(tokensPerSecond = 50) {
+		this.maxTokens = tokensPerSecond;
+		this.tokens = tokensPerSecond;
+		this.refillRate = tokensPerSecond / 1e3;
+		this.lastRefillTime = Date.now();
+	}
+	/**
+	* Refills tokens based on elapsed time since last refill.
+	*/
+	refill() {
+		const now = Date.now();
+		const newTokens = (now - this.lastRefillTime) * this.refillRate;
+		this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
+		this.lastRefillTime = now;
+	}
+	/**
+	* Acquires a token. If no tokens are available, waits until one is.
+	*
+	* @param signal - Optional abort signal for cancellation
+	* @returns Promise that resolves when a token is acquired
+	*/
+	async acquire(signal) {
+		this.refill();
+		if (this.tokens >= 1) {
+			this.tokens -= 1;
+			return;
+		}
+		const deficit = 1 - this.tokens;
+		const waitMs = Math.ceil(deficit / this.refillRate);
+		await new Promise((resolve, reject) => {
+			if (signal?.aborted) {
+				reject(signal.reason);
+				return;
+			}
+			const timer = setTimeout(() => {
+				this.refill();
+				this.tokens -= 1;
+				resolve();
+			}, waitMs);
+			signal?.addEventListener("abort", () => {
+				clearTimeout(timer);
+				reject(signal.reason);
+			}, { once: true });
+		});
+	}
+	/**
+	* Returns the current number of available tokens (for testing).
+	*
+	* @internal
+	*/
+	get availableTokens() {
+		this.refill();
+		return this.tokens;
+	}
+};
+//#endregion
+//#region src/http/retry.ts
+const DEFAULT_RETRY_OPTIONS = {
+	maxRetries: 2,
+	baseDelay: 500,
+	maxDelay: 1e4
+};
+/**
+* Determines whether a given HTTP status code is retryable.
+*
+* - 429 (Too Many Requests): always retryable
+* - 5xx (Server Error): retryable
+* - 4xx (Client Error): not retryable (except 429)
+*
+* @internal
+*/
+function isRetryableStatus(statusCode) {
+	if (statusCode === 429) return true;
+	if (statusCode >= 500) return true;
+	return false;
+}
+/**
+* Determines whether an error is a retryable network error.
+*
+* @internal
+*/
+function isRetryableError(error) {
+	if (error instanceof TypeError) return true;
+	if (error instanceof DOMException && error.name === "AbortError") return false;
+	return false;
+}
+/**
+* Computes the delay before the next retry attempt using exponential backoff
+* with full jitter.
+*
+* Formula: `random(0, min(maxDelay, baseDelay * 2^attempt))`
+*
+* @param attempt - Zero-based attempt number (0 = first retry)
+* @param options - Retry configuration
+* @param retryAfter - Optional `Retry-After` value from 429 response (seconds)
+* @returns Delay in milliseconds
+*
+* @internal
+*/
+function computeRetryDelay(attempt, options, retryAfter) {
+	if (retryAfter !== void 0 && retryAfter > 0) return retryAfter * 1e3;
+	const exponentialDelay = options.baseDelay * 2 ** attempt;
+	const cappedDelay = Math.min(exponentialDelay, options.maxDelay);
+	return Math.random() * cappedDelay;
+}
+/**
+* Sleeps for the specified number of milliseconds.
+* Returns a promise that resolves after the delay, respecting abort signals.
+*
+* @internal
+*/
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		}, { once: true });
+	});
+}
+//#endregion
+//#region src/http/url-builder.ts
+/** Maximum URL length before rejection (EC34). */
+const MAX_URL_LENGTH = 4096;
+/**
+* Mapping of SDK-friendly camelCase parameter names to the dot-notation
+* parameter names expected by the Mirror Node API (EC64).
+*/
+const PARAM_NAME_MAP = {
+	senderId: "sender.id",
+	receiverId: "receiver.id",
+	accountId: "account.id",
+	tokenId: "token.id",
+	nodeId: "node.id",
+	scheduleId: "schedule.id",
+	nonce: "nonce"
+};
+/**
+* Resolves a parameter name through the camelCase→dot.notation map.
+*/
+function resolveParamName(name) {
+	return PARAM_NAME_MAP[name] ?? name;
+}
+/**
+* Builds a complete URL from base URL, path segments, and query parameters.
+*
+* Handles:
+* - Double-slash collapsing (EC115)
+* - Null byte stripping (EC154)
+* - Trailing slash removal (EC43)
+* - Operator query params: `timestamp=gt:1234` (EC10)
+* - Scalar query params: `limit=10` (EC42)
+* - CamelCase→dot.notation parameter name mapping (EC64)
+* - URL length validation (<4KB, EC34)
+* - Omission of undefined/null/"" param values (EC119)
+*
+* @param baseUrl - The base URL (e.g., `https://testnet.mirrornode.hedera.com`)
+* @param path - The API path (e.g., `/api/v1/accounts`)
+* @param params - Optional query parameters
+* @returns The fully constructed URL string
+* @throws {HieroValidationError} If the resulting URL exceeds the max length
+*
+* @internal
+*/
+function buildUrl(baseUrl, path, params) {
+	let cleanPath = path.replace(/\0/g, "");
+	cleanPath = cleanPath.replace(/(?<!:)\/{2,}/g, "/");
+	if (cleanPath.length > 1 && cleanPath.endsWith("/")) cleanPath = cleanPath.slice(0, -1);
+	const url = new URL(cleanPath, baseUrl);
+	if (params) for (const [key, value] of Object.entries(params)) {
+		if (value === void 0 || value === null || value === "") continue;
+		const resolvedKey = resolveParamName(key);
+		if (typeof value === "object" && "operator" in value) url.searchParams.append(resolvedKey, `${value.operator}:${value.value}`);
+		else if (Array.isArray(value)) {
+			for (const item of value) if (typeof item === "object" && "operator" in item) url.searchParams.append(resolvedKey, `${item.operator}:${item.value}`);
+		} else url.searchParams.set(resolvedKey, String(value));
+	}
+	const result = url.toString();
+	if (result.length > MAX_URL_LENGTH) throw new HieroValidationError(`URL exceeds maximum length of ${MAX_URL_LENGTH} characters (${result.length} chars).`, { parameter: "url" });
+	return result;
+}
+//#endregion
+//#region src/http/client.ts
+/**
+* Core HTTP client for the Hiero Mirror Node SDK.
+*
+* Wraps `fetch` with:
+* - Timeout via `AbortController`
+* - Safe JSON parsing (int64 precision)
+* - Error factory integration
+* - Rate limiting
+* - Request deduplication
+* - Retry with exponential backoff
+* - ETag/conditional request support (stubbed for Step 11)
+*
+* @internal
+*/
+var HttpClient = class {
+	baseUrl;
+	timeout;
+	retryOptions;
+	rateLimiter;
+	inflight = /* @__PURE__ */ new Map();
+	etagCache;
+	logger;
+	fetchFn;
+	constructor(options) {
+		this.baseUrl = options.baseUrl;
+		this.timeout = options.timeout ?? 3e4;
+		this.retryOptions = {
+			...DEFAULT_RETRY_OPTIONS,
+			...options.retry
+		};
+		this.rateLimiter = new RateLimiter(options.rateLimitRps ?? 50);
+		this.etagCache = new ETagCache();
+		this.logger = options.logger ?? {};
+		this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+	}
+	/**
+	* Performs a GET request with in-flight deduplication.
+	*
+	* @param path - API path (e.g., `/api/v1/accounts`)
+	* @param params - Optional query parameters
+	* @param options - Optional request options
+	* @returns Parsed response
+	*/
+	async get(path, params, options) {
+		const url = buildUrl(this.baseUrl, path, params);
+		const existing = this.inflight.get(url);
+		if (existing) return existing;
+		const cachedETag = this.etagCache.getETag(url);
+		const mergedOptions = cachedETag ? {
+			...options,
+			headers: {
+				...options?.headers,
+				"If-None-Match": cachedETag
+			}
+		} : options ?? {};
+		const promise = this.request("GET", url, void 0, mergedOptions);
+		this.inflight.set(url, promise);
+		try {
+			return await promise;
+		} finally {
+			this.inflight.delete(url);
+		}
+	}
+	/**
+	* Performs a POST request.
+	*
+	* POST requests are NOT deduplicated (they have side effects).
+	*
+	* @param path - API path
+	* @param body - Request body (will be JSON-serialized)
+	* @param options - Optional request options
+	* @returns Parsed response
+	*/
+	async post(path, body, options) {
+		const url = buildUrl(this.baseUrl, path);
+		return this.request("POST", url, body, options);
+	}
+	/**
+	* Core request method with retry, rate limiting, timeout, and error handling.
+	*/
+	async request(method, url, body, options) {
+		let lastError;
+		for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) try {
+			await this.rateLimiter.acquire(options?.signal);
+			const timeoutMs = options?.timeout ?? this.timeout;
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+			if (options?.signal) options.signal.addEventListener("abort", () => controller.abort(options.signal?.reason), { once: true });
+			try {
+				const headers = {
+					Accept: "application/json",
+					"Accept-Encoding": "gzip",
+					...options?.headers
+				};
+				if (body !== void 0) headers["Content-Type"] = "application/json";
+				this.logger.debug?.(`[HTTP] ${method} ${url}`, { attempt });
+				const response = await this.fetchFn(url, {
+					method,
+					headers,
+					body: body !== void 0 ? JSON.stringify(body) : void 0,
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				return await this.handleResponse(response, url, attempt);
+			} catch (error) {
+				clearTimeout(timeoutId);
+				if (error instanceof DOMException && error.name === "AbortError" && !options?.signal?.aborted) throw new HieroTimeoutError(timeoutMs);
+				throw error;
+			}
+		} catch (error) {
+			lastError = error;
+			if (error instanceof HieroTimeoutError) throw error;
+			if (options?.signal?.aborted) throw error;
+			if (!(isRetryableError(error) || error !== null && typeof error === "object" && "statusCode" in error && isRetryableStatus(error.statusCode)) || attempt >= this.retryOptions.maxRetries) throw error;
+			const retryAfter = error !== null && typeof error === "object" && "retryAfter" in error ? error.retryAfter : void 0;
+			const delay = computeRetryDelay(attempt, this.retryOptions, retryAfter);
+			this.logger.warn?.(`[HTTP] Retry ${attempt + 1}/${this.retryOptions.maxRetries} after ${Math.round(delay)}ms`, { url });
+			await sleep(delay, options?.signal);
+		}
+		if (lastError instanceof Error) throw lastError;
+		throw new HieroNetworkError("Request failed after all retries");
+	}
+	/**
+	* Handles the HTTP response: checks content type, parses JSON safely,
+	* and throws appropriate errors for non-2xx responses.
+	*/
+	async handleResponse(response, url, _attempt) {
+		const rawBody = await response.text();
+		if (response.status === 304) {
+			const cachedBody = this.etagCache.getCachedBody(url);
+			this.logger.debug?.(`[HTTP] 304 Not Modified — returning cached body for ${url}`);
+			return {
+				data: cachedBody ?? null,
+				status: 304,
+				headers: response.headers
+			};
+		}
+		const contentType = response.headers.get("content-type") ?? "";
+		const isJson = contentType.includes("application/json") || contentType.includes("text/json");
+		if (!response.ok) {
+			let parsedBody = null;
+			if (isJson && rawBody) try {
+				parsedBody = JSON.parse(rawBody);
+			} catch {}
+			if (parsedBody) throw createErrorFromResponse(response.status, parsedBody, rawBody, response.headers);
+			throw createParseError(rawBody, response.status);
+		}
+		if (response.status === 204 || !rawBody) return {
+			data: null,
+			status: response.status,
+			headers: response.headers
+		};
+		if (!isJson) this.logger.warn?.(`[HTTP] Unexpected content-type "${contentType}" for ${url}`);
+		try {
+			const data = safeJsonParse(rawBody);
+			const etag = response.headers.get("etag");
+			if (etag) this.etagCache.set(url, etag, data);
+			return {
+				data,
+				status: response.status,
+				headers: response.headers
+			};
+		} catch (cause) {
+			throw createParseError(rawBody, response.status, cause);
+		}
+	}
+};
+//#endregion
+//#region src/mappers/common.ts
+/**
+* Shared mapper utilities for transforming raw API JSON → SDK types.
+*
+* @internal
+* @packageDocumentation
+*/
+/**
+* Decodes a Base64 string to a `Uint8Array`.
+*
+* Uses `atob()` which is available in all modern environments
+* (browsers, Node 16+, Deno, Bun).
+*/
+function decodeBase64(value) {
+	const binaryString = atob(value);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
+}
+/**
+* Decodes a hex-encoded string (e.g., `0x57524f4e475f4e4f4e4345`) to UTF-8.
+*
+* EC24: Contract `error_message` fields are hex-encoded.
+*
+* @returns The decoded string, or `null` if the input is not valid hex.
+*/
+function decodeHexString(hex) {
+	if (hex == null || hex === "") return null;
+	const raw = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+	if (raw.length === 0 || raw.length % 2 !== 0) return null;
+	try {
+		const bytes = [];
+		for (let i = 0; i < raw.length; i += 2) bytes.push(Number.parseInt(raw.substring(i, i + 2), 16));
+		return new TextDecoder().decode(new Uint8Array(bytes));
+	} catch {
+		return null;
+	}
+}
+/**
+* Coerces a value to a string representation.
+*
+* EC14/88: `decimals` is sometimes returned as a number (list endpoints)
+* and sometimes as a string (detail endpoints). We normalize to string.
+*/
+function ensureString(value) {
+	if (value == null) return "0";
+	return String(value);
+}
+/**
+* Casts unknown to a record for field extraction.
+*
+* @internal
+*/
+function asRecord(value) {
+	if (value != null && typeof value === "object" && !Array.isArray(value)) return value;
+	return {};
+}
+/**
+* Extracts a string field with optional fallback.
+*/
+function str(raw, key, fallback = null) {
+	const v = raw[key];
+	if (v == null) return fallback;
+	return String(v);
+}
+/**
+* Extracts a required string field (returns empty string if missing).
+*/
+function strReq(raw, key) {
+	return str(raw, key, "");
+}
+/**
+* Extracts a number field with optional fallback.
+*/
+function num(raw, key, fallback = 0) {
+	const v = raw[key];
+	if (v == null) return fallback;
+	return typeof v === "number" ? v : Number(v);
+}
+/**
+* Extracts a boolean field.
+*/
+function bool(raw, key, fallback = false) {
+	const v = raw[key];
+	if (v == null) return fallback;
+	return Boolean(v);
+}
+/**
+* Extracts an array field.
+*/
+function arr(raw, key) {
+	const v = raw[key];
+	return Array.isArray(v) ? v : [];
+}
+//#endregion
+//#region src/mappers/account.ts
+function mapKey$3(raw) {
+	if (raw == null) return null;
+	const r = asRecord(raw);
+	return {
+		_type: strReq(r, "_type"),
+		key: strReq(r, "key")
+	};
+}
+function mapTokenBalance(raw) {
+	const r = asRecord(raw);
+	return {
+		token_id: strReq(r, "token_id"),
+		balance: strReq(r, "balance")
+	};
+}
+function mapAccountBalance(raw) {
+	const r = asRecord(raw);
+	return {
+		balance: strReq(r, "balance"),
+		timestamp: strReq(r, "timestamp"),
+		tokens: arr(r, "tokens").map(mapTokenBalance)
+	};
+}
+function mapAccountSummary(raw) {
+	const r = asRecord(raw);
+	return {
+		account: strReq(r, "account"),
+		alias: str(r, "alias"),
+		auto_renew_period: str(r, "auto_renew_period"),
+		balance: mapAccountBalance(r.balance),
+		created_timestamp: str(r, "created_timestamp"),
+		decline_reward: bool(r, "decline_reward"),
+		deleted: bool(r, "deleted"),
+		ethereum_nonce: strReq(r, "ethereum_nonce"),
+		evm_address: str(r, "evm_address"),
+		expiry_timestamp: str(r, "expiry_timestamp"),
+		key: mapKey$3(r.key),
+		max_automatic_token_associations: num(r, "max_automatic_token_associations"),
+		memo: strReq(r, "memo"),
+		pending_reward: strReq(r, "pending_reward"),
+		receiver_sig_required: r.receiver_sig_required == null ? null : bool(r, "receiver_sig_required"),
+		staked_account_id: str(r, "staked_account_id"),
+		staked_node_id: r.staked_node_id == null ? null : num(r, "staked_node_id"),
+		stake_period_start: str(r, "stake_period_start")
+	};
+}
+function mapAccountDetail(raw) {
+	const r = asRecord(raw);
+	const summary = mapAccountSummary(raw);
+	const linksRaw = asRecord(r.links);
+	return {
+		...summary,
+		transactions: arr(r, "transactions").map(mapAccountTransaction),
+		links: { next: str(linksRaw, "next") }
+	};
+}
+function mapAccountTransaction(raw) {
+	const r = asRecord(raw);
+	return {
+		bytes: str(r, "bytes"),
+		charged_tx_fee: strReq(r, "charged_tx_fee"),
+		consensus_timestamp: strReq(r, "consensus_timestamp"),
+		entity_id: str(r, "entity_id"),
+		max_fee: strReq(r, "max_fee"),
+		memo_base64: strReq(r, "memo_base64"),
+		name: strReq(r, "name"),
+		nft_transfers: arr(r, "nft_transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				is_approval: bool(tr, "is_approval"),
+				receiver_account_id: str(tr, "receiver_account_id"),
+				sender_account_id: str(tr, "sender_account_id"),
+				serial_number: strReq(tr, "serial_number"),
+				token_id: strReq(tr, "token_id")
+			};
+		}),
+		node: str(r, "node"),
+		nonce: num(r, "nonce"),
+		parent_consensus_timestamp: str(r, "parent_consensus_timestamp"),
+		result: strReq(r, "result"),
+		scheduled: bool(r, "scheduled"),
+		staking_reward_transfers: arr(r, "staking_reward_transfers").map((s) => {
+			const sr = asRecord(s);
+			return {
+				account: strReq(sr, "account"),
+				amount: strReq(sr, "amount")
+			};
+		}),
+		token_transfers: arr(r, "token_transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				account: strReq(tr, "account"),
+				amount: strReq(tr, "amount"),
+				is_approval: bool(tr, "is_approval"),
+				token_id: strReq(tr, "token_id")
+			};
+		}),
+		transaction_hash: strReq(r, "transaction_hash"),
+		transaction_id: strReq(r, "transaction_id"),
+		transfers: arr(r, "transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				account: strReq(tr, "account"),
+				amount: strReq(tr, "amount"),
+				is_approval: bool(tr, "is_approval")
+			};
+		}),
+		valid_duration_seconds: strReq(r, "valid_duration_seconds"),
+		valid_start_timestamp: strReq(r, "valid_start_timestamp")
+	};
+}
+function mapTokenRelationship(raw) {
+	const r = asRecord(raw);
+	return {
+		automatic_association: bool(r, "automatic_association"),
+		balance: strReq(r, "balance"),
+		created_timestamp: strReq(r, "created_timestamp"),
+		decimals: String(r.decimals ?? "0"),
+		freeze_status: strReq(r, "freeze_status"),
+		kyc_status: strReq(r, "kyc_status"),
+		token_id: strReq(r, "token_id")
+	};
+}
+function mapStakingReward(raw) {
+	const r = asRecord(raw);
+	return {
+		account_id: strReq(r, "account_id"),
+		amount: strReq(r, "amount"),
+		timestamp: strReq(r, "timestamp")
+	};
+}
+function mapTimestampRange$2(raw) {
+	const r = asRecord(raw);
+	return {
+		from: strReq(r, "from"),
+		to: str(r, "to")
+	};
+}
+function mapCryptoAllowance(raw) {
+	const r = asRecord(raw);
+	return {
+		amount: strReq(r, "amount"),
+		amount_granted: strReq(r, "amount_granted"),
+		owner: strReq(r, "owner"),
+		spender: strReq(r, "spender"),
+		timestamp: mapTimestampRange$2(r.timestamp)
+	};
+}
+function mapTokenAllowance(raw) {
+	const r = asRecord(raw);
+	return {
+		amount: strReq(r, "amount"),
+		amount_granted: strReq(r, "amount_granted"),
+		owner: strReq(r, "owner"),
+		spender: strReq(r, "spender"),
+		token_id: strReq(r, "token_id"),
+		timestamp: mapTimestampRange$2(r.timestamp)
+	};
+}
+function mapNftAllowance(raw) {
+	const r = asRecord(raw);
+	return {
+		approved_for_all: bool(r, "approved_for_all"),
+		owner: strReq(r, "owner"),
+		spender: strReq(r, "spender"),
+		token_id: strReq(r, "token_id"),
+		timestamp: mapTimestampRange$2(r.timestamp)
+	};
+}
+function mapAirdrop(raw) {
+	const r = asRecord(raw);
+	return {
+		amount: strReq(r, "amount"),
+		receiver_id: strReq(r, "receiver_id"),
+		sender_id: strReq(r, "sender_id"),
+		serial_number: str(r, "serial_number"),
+		token_id: strReq(r, "token_id"),
+		timestamp: mapTimestampRange$2(r.timestamp)
+	};
+}
+//#endregion
+//#region src/mappers/token.ts
+function mapKey$2(raw) {
+	if (raw == null) return null;
+	const r = asRecord(raw);
+	return {
+		_type: strReq(r, "_type"),
+		key: strReq(r, "key")
+	};
+}
+function mapFractionAmount(raw) {
+	const r = asRecord(raw);
+	return {
+		numerator: num(r, "numerator"),
+		denominator: num(r, "denominator")
+	};
+}
+function mapFixedFee(raw) {
+	const r = asRecord(raw);
+	return {
+		all_collectors_are_exempt: bool(r, "all_collectors_are_exempt"),
+		amount: strReq(r, "amount"),
+		collector_account_id: strReq(r, "collector_account_id"),
+		denominating_token_id: str(r, "denominating_token_id")
+	};
+}
+function mapFractionalFee(raw) {
+	const r = asRecord(raw);
+	return {
+		all_collectors_are_exempt: bool(r, "all_collectors_are_exempt"),
+		amount: mapFractionAmount(r.amount),
+		collector_account_id: strReq(r, "collector_account_id"),
+		denominating_token_id: str(r, "denominating_token_id"),
+		maximum: str(r, "maximum"),
+		minimum: strReq(r, "minimum"),
+		net_of_transfers: bool(r, "net_of_transfers")
+	};
+}
+function mapRoyaltyFee(raw) {
+	const r = asRecord(raw);
+	return {
+		all_collectors_are_exempt: bool(r, "all_collectors_are_exempt"),
+		amount: mapFractionAmount(r.amount),
+		collector_account_id: strReq(r, "collector_account_id"),
+		fallback_fee: r.fallback_fee != null ? mapFixedFee(r.fallback_fee) : null
+	};
+}
+function mapCustomFees(raw) {
+	const r = asRecord(raw);
+	return {
+		created_timestamp: strReq(r, "created_timestamp"),
+		fixed_fees: arr(r, "fixed_fees").map(mapFixedFee),
+		fractional_fees: arr(r, "fractional_fees").map(mapFractionalFee),
+		royalty_fees: arr(r, "royalty_fees").map(mapRoyaltyFee)
+	};
+}
+function mapTokenSummary(raw) {
+	const r = asRecord(raw);
+	return {
+		admin_key: mapKey$2(r.admin_key),
+		decimals: ensureString(r.decimals),
+		metadata: strReq(r, "metadata"),
+		name: strReq(r, "name"),
+		symbol: strReq(r, "symbol"),
+		token_id: strReq(r, "token_id"),
+		type: strReq(r, "type")
+	};
+}
+function mapTokenDetail(raw) {
+	const r = asRecord(raw);
+	return {
+		...mapTokenSummary(raw),
+		auto_renew_account: str(r, "auto_renew_account"),
+		auto_renew_period: str(r, "auto_renew_period"),
+		created_timestamp: strReq(r, "created_timestamp"),
+		custom_fees: mapCustomFees(r.custom_fees),
+		deleted: bool(r, "deleted"),
+		expiry_timestamp: str(r, "expiry_timestamp"),
+		fee_schedule_key: mapKey$2(r.fee_schedule_key),
+		freeze_default: bool(r, "freeze_default"),
+		freeze_key: mapKey$2(r.freeze_key),
+		initial_supply: strReq(r, "initial_supply"),
+		kyc_key: mapKey$2(r.kyc_key),
+		max_supply: strReq(r, "max_supply"),
+		memo: strReq(r, "memo"),
+		metadata_key: mapKey$2(r.metadata_key),
+		modified_timestamp: strReq(r, "modified_timestamp"),
+		pause_key: mapKey$2(r.pause_key),
+		pause_status: strReq(r, "pause_status"),
+		supply_key: mapKey$2(r.supply_key),
+		supply_type: strReq(r, "supply_type"),
+		total_supply: strReq(r, "total_supply"),
+		treasury_account_id: strReq(r, "treasury_account_id"),
+		wipe_key: mapKey$2(r.wipe_key)
+	};
+}
+function mapTokenNft(raw) {
+	const r = asRecord(raw);
+	return {
+		account_id: strReq(r, "account_id"),
+		created_timestamp: strReq(r, "created_timestamp"),
+		delegating_spender: str(r, "delegating_spender"),
+		deleted: bool(r, "deleted"),
+		metadata: strReq(r, "metadata"),
+		modified_timestamp: strReq(r, "modified_timestamp"),
+		serial_number: strReq(r, "serial_number"),
+		spender: str(r, "spender"),
+		token_id: strReq(r, "token_id")
+	};
+}
+function mapTokenBalanceEntry(raw) {
+	const r = asRecord(raw);
+	return {
+		account: strReq(r, "account"),
+		balance: strReq(r, "balance"),
+		decimals: ensureString(r.decimals)
+	};
+}
+//#endregion
+//#region src/pagination/paginator.ts
+/**
+* Lazy paginator that fetches pages on demand.
+*
+* Implements `PromiseLike<Page<T>>` so `await` returns the first page.
+* Implements `AsyncIterable<T>` so `for await...of` yields items.
+*
+* EC19: Uses `links.next` as an opaque cursor (never constructs cursors).
+* EC47: Terminates when `links.next` is null.
+* EC8: Resolves relative `links.next` URLs against the base URL.
+*/
+var Paginator = class {
+	client;
+	initialPath;
+	params;
+	extract;
+	constructor(options) {
+		this.client = options.client;
+		this.initialPath = options.path;
+		this.params = options.params;
+		this.extract = options.extract;
+	}
+	then(onfulfilled, onrejected) {
+		return this.fetchFirstPage().then(onfulfilled, onrejected);
+	}
+	async *[Symbol.asyncIterator]() {
+		for await (const page of this.pages()) yield* page.data;
+	}
+	/**
+	* Returns an async iterable of page objects.
+	*
+	* Follows `links.next` until null (EC47).
+	*/
+	async *pages() {
+		let nextPath = this.initialPath;
+		let isFirst = true;
+		while (nextPath != null) {
+			const response = isFirst ? await this.client.get(nextPath, this.params) : await this.client.get(nextPath);
+			isFirst = false;
+			const page = this.extract(response.data);
+			if (page.links.next == null) {
+				const linkHeader = response.headers.get("link") ?? response.headers.get("Link");
+				if (linkHeader) {
+					const match = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+					if (match?.[1]) page.links.next = match[1];
+				}
+			}
+			yield page;
+			nextPath = page.links.next;
+		}
+	}
+	async fetchFirstPage() {
+		const response = await this.client.get(this.initialPath, this.params);
+		return this.extract(response.data);
+	}
+};
+/**
+* Creates a standard page extractor for the common envelope:
+* `{ <key>: T[], links: { next: string | null } }`
+*/
+function createPageExtractor(dataKey, mapItem) {
+	return (raw) => {
+		const record = raw != null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+		const items = Array.isArray(record[dataKey]) ? record[dataKey].map(mapItem) : [];
+		const linksRaw = record.links != null && typeof record.links === "object" ? record.links : {};
+		return {
+			data: items,
+			links: { next: typeof linksRaw.next === "string" ? linksRaw.next : null }
+		};
+	};
+}
+//#endregion
+//#region src/resources/accounts.ts
+var AccountsResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/accounts",
+			params,
+			extract: createPageExtractor("accounts", mapAccountSummary)
+		});
+	}
+	async get(idOrAliasOrEvmAddress) {
+		return mapAccountDetail((await this.client.get(`/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}`)).data);
+	}
+	getNFTs(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/nfts`,
+			params,
+			extract: createPageExtractor("nfts", mapTokenNft)
+		});
+	}
+	getTokens(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/tokens`,
+			params,
+			extract: createPageExtractor("tokens", mapTokenRelationship)
+		});
+	}
+	getRewards(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/rewards`,
+			params,
+			extract: createPageExtractor("rewards", mapStakingReward)
+		});
+	}
+	getCryptoAllowances(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/allowances/crypto`,
+			params,
+			extract: createPageExtractor("allowances", mapCryptoAllowance)
+		});
+	}
+	getTokenAllowances(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/allowances/tokens`,
+			params,
+			extract: createPageExtractor("allowances", mapTokenAllowance)
+		});
+	}
+	getNftAllowances(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/allowances/nfts`,
+			params,
+			extract: createPageExtractor("allowances", mapNftAllowance)
+		});
+	}
+	getOutstandingAirdrops(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/airdrops/outstanding`,
+			params,
+			extract: createPageExtractor("airdrops", mapAirdrop)
+		});
+	}
+	getPendingAirdrops(idOrAliasOrEvmAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/accounts/${encodeURIComponent(idOrAliasOrEvmAddress)}/airdrops/pending`,
+			params,
+			extract: createPageExtractor("airdrops", mapAirdrop)
+		});
+	}
+};
+//#endregion
+//#region src/resources/balances.ts
+function mapBalanceEntry(raw) {
+	const r = asRecord(raw);
+	return {
+		account: strReq(r, "account"),
+		balance: strReq(r, "balance"),
+		tokens: arr(r, "tokens").map((t) => {
+			const tr = asRecord(t);
+			return {
+				token_id: strReq(tr, "token_id"),
+				balance: strReq(tr, "balance")
+			};
+		})
+	};
+}
+var BalancesResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/balances",
+			params,
+			extract: createPageExtractor("balances", mapBalanceEntry)
+		});
+	}
+};
+//#endregion
+//#region src/mappers/block.ts
+function mapBlock(raw) {
+	const r = asRecord(raw);
+	const tsRaw = asRecord(r.timestamp);
+	return {
+		count: num(r, "count"),
+		gas_used: strReq(r, "gas_used"),
+		hapi_version: strReq(r, "hapi_version"),
+		hash: strReq(r, "hash"),
+		logs_bloom: strReq(r, "logs_bloom"),
+		name: strReq(r, "name"),
+		number: num(r, "number"),
+		previous_hash: strReq(r, "previous_hash"),
+		size: num(r, "size"),
+		timestamp: {
+			from: strReq(tsRaw, "from"),
+			to: str(tsRaw, "to")
+		}
+	};
+}
+//#endregion
+//#region src/resources/blocks.ts
+var BlocksResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/blocks",
+			params,
+			extract: createPageExtractor("blocks", mapBlock)
+		});
+	}
+	async get(hashOrNumber) {
+		return mapBlock((await this.client.get(`/api/v1/blocks/${encodeURIComponent(String(hashOrNumber))}`)).data);
+	}
+};
+//#endregion
+//#region src/mappers/contract.ts
+function mapKey$1(raw) {
+	if (raw == null) return null;
+	const r = asRecord(raw);
+	return {
+		_type: strReq(r, "_type"),
+		key: strReq(r, "key")
+	};
+}
+function mapTimestampRange$1(raw) {
+	const r = asRecord(raw);
+	return {
+		from: strReq(r, "from"),
+		to: str(r, "to")
+	};
+}
+function mapContractSummary(raw) {
+	const r = asRecord(raw);
+	return {
+		admin_key: mapKey$1(r.admin_key),
+		auto_renew_account: str(r, "auto_renew_account"),
+		auto_renew_period: str(r, "auto_renew_period"),
+		contract_id: strReq(r, "contract_id"),
+		created_timestamp: strReq(r, "created_timestamp"),
+		deleted: bool(r, "deleted"),
+		evm_address: strReq(r, "evm_address"),
+		expiration_timestamp: str(r, "expiration_timestamp"),
+		file_id: str(r, "file_id"),
+		max_automatic_token_associations: num(r, "max_automatic_token_associations"),
+		memo: strReq(r, "memo"),
+		nonce: strReq(r, "nonce"),
+		obtainer_id: str(r, "obtainer_id"),
+		permanent_removal: r.permanent_removal == null ? null : bool(r, "permanent_removal"),
+		proxy_account_id: str(r, "proxy_account_id"),
+		timestamp: mapTimestampRange$1(r.timestamp)
+	};
+}
+function mapContractDetail(raw) {
+	const r = asRecord(raw);
+	return {
+		...mapContractSummary(raw),
+		bytecode: strReq(r, "bytecode"),
+		runtime_bytecode: strReq(r, "runtime_bytecode")
+	};
+}
+function mapContractLog(raw) {
+	const r = asRecord(raw);
+	return {
+		address: strReq(r, "address"),
+		bloom: strReq(r, "bloom"),
+		contract_id: strReq(r, "contract_id"),
+		data: strReq(r, "data"),
+		index: num(r, "index"),
+		topics: arr(r, "topics"),
+		root_contract_id: str(r, "root_contract_id"),
+		timestamp: strReq(r, "timestamp"),
+		block_hash: strReq(r, "block_hash"),
+		block_number: num(r, "block_number"),
+		transaction_hash: strReq(r, "transaction_hash"),
+		transaction_index: num(r, "transaction_index")
+	};
+}
+function mapStateChange$1(raw) {
+	const r = asRecord(raw);
+	return {
+		address: strReq(r, "address"),
+		contract_id: strReq(r, "contract_id"),
+		slot: strReq(r, "slot"),
+		value_read: strReq(r, "value_read"),
+		value_written: str(r, "value_written")
+	};
+}
+function mapContractResult(raw) {
+	const r = asRecord(raw);
+	const errorMessage = str(r, "error_message");
+	return {
+		access_list: str(r, "access_list"),
+		address: strReq(r, "address"),
+		amount: strReq(r, "amount"),
+		block_gas_used: strReq(r, "block_gas_used"),
+		block_hash: strReq(r, "block_hash"),
+		block_number: num(r, "block_number"),
+		bloom: strReq(r, "bloom"),
+		call_result: str(r, "call_result"),
+		chain_id: strReq(r, "chain_id"),
+		contract_id: str(r, "contract_id"),
+		created_contract_ids: arr(r, "created_contract_ids"),
+		error_message: errorMessage,
+		error_message_decoded: decodeHexString(errorMessage),
+		failed_initcode: str(r, "failed_initcode"),
+		from: strReq(r, "from"),
+		function_parameters: strReq(r, "function_parameters"),
+		gas_consumed: str(r, "gas_consumed"),
+		gas_limit: strReq(r, "gas_limit"),
+		gas_price: strReq(r, "gas_price"),
+		gas_used: strReq(r, "gas_used"),
+		hash: strReq(r, "hash"),
+		logs: arr(r, "logs").map(mapContractLog),
+		max_fee_per_gas: strReq(r, "max_fee_per_gas"),
+		max_priority_fee_per_gas: strReq(r, "max_priority_fee_per_gas"),
+		nonce: num(r, "nonce"),
+		r: strReq(r, "r"),
+		result: strReq(r, "result"),
+		s: strReq(r, "s"),
+		state_changes: arr(r, "state_changes").map(mapStateChange$1),
+		status: strReq(r, "status"),
+		timestamp: strReq(r, "timestamp"),
+		to: str(r, "to"),
+		transaction_index: num(r, "transaction_index"),
+		type: num(r, "type"),
+		v: num(r, "v")
+	};
+}
+function mapContractAction(raw) {
+	const r = asRecord(raw);
+	return {
+		call_depth: num(r, "call_depth"),
+		call_operation_type: strReq(r, "call_operation_type"),
+		call_type: strReq(r, "call_type"),
+		caller: strReq(r, "caller"),
+		caller_type: strReq(r, "caller_type"),
+		from: strReq(r, "from"),
+		gas: strReq(r, "gas"),
+		gas_used: strReq(r, "gas_used"),
+		index: num(r, "index"),
+		input: str(r, "input"),
+		recipient: str(r, "recipient"),
+		recipient_type: str(r, "recipient_type"),
+		result_data: str(r, "result_data"),
+		result_data_type: strReq(r, "result_data_type"),
+		timestamp: strReq(r, "timestamp"),
+		to: str(r, "to"),
+		value: strReq(r, "value")
+	};
+}
+//#endregion
+//#region src/resources/contracts.ts
+function mapStateChange(raw) {
+	const r = asRecord(raw);
+	return {
+		address: strReq(r, "address"),
+		contract_id: strReq(r, "contract_id"),
+		slot: strReq(r, "slot"),
+		value_read: strReq(r, "value_read"),
+		value_written: r.value_written == null ? null : strReq(r, "value_written")
+	};
+}
+var ContractsResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/contracts",
+			params,
+			extract: createPageExtractor("contracts", mapContractSummary)
+		});
+	}
+	async get(contractIdOrAddress) {
+		return mapContractDetail((await this.client.get(`/api/v1/contracts/${encodeURIComponent(contractIdOrAddress)}`)).data);
+	}
+	/**
+	* POST /api/v1/contracts/call — smart contract read-only simulation.
+	*
+	* EC29/51/130-133.
+	*/
+	async call(request) {
+		return { result: strReq(asRecord((await this.client.post("/api/v1/contracts/call", request)).data), "result") };
+	}
+	getResults(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/contracts/results",
+			params,
+			extract: createPageExtractor("results", mapContractResult)
+		});
+	}
+	getResultsByContract(contractIdOrAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/contracts/${encodeURIComponent(contractIdOrAddress)}/results`,
+			params,
+			extract: createPageExtractor("results", mapContractResult)
+		});
+	}
+	async getResultByTimestamp(contractIdOrAddress, timestamp) {
+		return mapContractResult((await this.client.get(`/api/v1/contracts/${encodeURIComponent(contractIdOrAddress)}/results/${encodeURIComponent(timestamp)}`)).data);
+	}
+	async getResultByTransactionIdOrHash(transactionIdOrHash) {
+		return mapContractResult((await this.client.get(`/api/v1/contracts/results/${encodeURIComponent(transactionIdOrHash)}`)).data);
+	}
+	getActions(transactionIdOrHash) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/contracts/results/${encodeURIComponent(transactionIdOrHash)}/actions`,
+			extract: createPageExtractor("actions", mapContractAction)
+		});
+	}
+	getLogs(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/contracts/results/logs",
+			params,
+			extract: createPageExtractor("logs", mapContractLog)
+		});
+	}
+	getLogsByContract(contractIdOrAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/contracts/${encodeURIComponent(contractIdOrAddress)}/results/logs`,
+			params,
+			extract: createPageExtractor("logs", mapContractLog)
+		});
+	}
+	getState(contractIdOrAddress, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/contracts/${encodeURIComponent(contractIdOrAddress)}/state`,
+			params,
+			extract: createPageExtractor("state", mapStateChange)
+		});
+	}
+	async getOpcodes(transactionIdOrHash) {
+		return (await this.client.get(`/api/v1/contracts/results/${encodeURIComponent(transactionIdOrHash)}/opcodes`)).data;
+	}
+};
+//#endregion
+//#region src/mappers/network.ts
+function mapTimestampRange(raw) {
+	const r = asRecord(raw);
+	return {
+		from: strReq(r, "from"),
+		to: str(r, "to")
+	};
+}
+function mapServiceEndpoint(raw) {
+	const r = asRecord(raw);
+	return {
+		ip_address_v4: strReq(r, "ip_address_v4"),
+		port: num(r, "port"),
+		domain_name: strReq(r, "domain_name")
+	};
+}
+function mapNetworkNode(raw) {
+	const r = asRecord(raw);
+	return {
+		admin_key: r.admin_key ?? null,
+		description: strReq(r, "description"),
+		file_id: strReq(r, "file_id"),
+		max_stake: strReq(r, "max_stake"),
+		memo: strReq(r, "memo"),
+		min_stake: strReq(r, "min_stake"),
+		node_account_id: strReq(r, "node_account_id"),
+		node_id: num(r, "node_id"),
+		node_cert_hash: strReq(r, "node_cert_hash"),
+		public_key: strReq(r, "public_key"),
+		reward_rate_start: strReq(r, "reward_rate_start"),
+		service_endpoints: arr(r, "service_endpoints").map(mapServiceEndpoint),
+		stake: strReq(r, "stake"),
+		stake_not_rewarded: strReq(r, "stake_not_rewarded"),
+		stake_rewarded: strReq(r, "stake_rewarded"),
+		staking_period: mapTimestampRange(r.staking_period),
+		timestamp: mapTimestampRange(r.timestamp)
+	};
+}
+function mapNetworkStake(raw) {
+	const r = asRecord(raw);
+	return {
+		max_stake_rewarded: strReq(r, "max_stake_rewarded"),
+		max_staking_reward_rate_per_hbar: strReq(r, "max_staking_reward_rate_per_hbar"),
+		max_total_reward: strReq(r, "max_total_reward"),
+		node_reward_fee_fraction: num(r, "node_reward_fee_fraction"),
+		reserved_staking_rewards: strReq(r, "reserved_staking_rewards"),
+		reward_balance_threshold: strReq(r, "reward_balance_threshold"),
+		stake_total: strReq(r, "stake_total"),
+		staking_period: mapTimestampRange(r.staking_period),
+		staking_period_duration: strReq(r, "staking_period_duration"),
+		staking_periods_stored: strReq(r, "staking_periods_stored"),
+		staking_reward_fee_fraction: num(r, "staking_reward_fee_fraction"),
+		staking_reward_rate: strReq(r, "staking_reward_rate"),
+		staking_start_threshold: strReq(r, "staking_start_threshold"),
+		unreserved_staking_reward_balance: strReq(r, "unreserved_staking_reward_balance")
+	};
+}
+function mapExchangeRate(raw) {
+	const r = asRecord(raw);
+	return {
+		cent_equivalent: num(r, "cent_equivalent"),
+		expiration_time: num(r, "expiration_time"),
+		hbar_equivalent: num(r, "hbar_equivalent")
+	};
+}
+function mapExchangeRateSet(raw) {
+	const r = asRecord(raw);
+	return {
+		current_rate: mapExchangeRate(r.current_rate),
+		next_rate: mapExchangeRate(r.next_rate),
+		timestamp: strReq(r, "timestamp")
+	};
+}
+function mapSupply(raw) {
+	const r = asRecord(raw);
+	return {
+		released_supply: strReq(r, "released_supply"),
+		timestamp: strReq(r, "timestamp"),
+		total_supply: strReq(r, "total_supply")
+	};
+}
+function mapFee(raw) {
+	const r = asRecord(raw);
+	return {
+		gas: strReq(r, "gas"),
+		transaction_type: strReq(r, "transaction_type")
+	};
+}
+function mapFeeSchedule(raw) {
+	const r = asRecord(raw);
+	return {
+		current: r.current != null ? arr(r, "current").map(mapFee) : void 0,
+		next: r.next != null ? arr(r, "next").map(mapFee) : void 0,
+		timestamp: strReq(r, "timestamp")
+	};
+}
+//#endregion
+//#region src/resources/network.ts
+var NetworkResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	async getExchangeRate() {
+		return mapExchangeRateSet((await this.client.get("/api/v1/network/exchangerate")).data);
+	}
+	async getFees(params) {
+		return mapFeeSchedule((await this.client.get("/api/v1/network/fees", params)).data);
+	}
+	/**
+	* POST /api/v1/network/fees — estimate fees from protobuf payload.
+	*
+	* EC52: Accepts raw Uint8Array (user must serialize protobuf externally).
+	*/
+	async estimateFees(body) {
+		return (await this.client.post("/api/v1/network/fees", body, { headers: { "Content-Type": "application/protobuf" } })).data;
+	}
+	getNodes(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/network/nodes",
+			params,
+			extract: createPageExtractor("nodes", mapNetworkNode)
+		});
+	}
+	async getStake() {
+		return mapNetworkStake((await this.client.get("/api/v1/network/stake")).data);
+	}
+	async getSupply(params) {
+		return mapSupply((await this.client.get("/api/v1/network/supply", params)).data);
+	}
+};
+//#endregion
+//#region src/mappers/schedule.ts
+function mapKey(raw) {
+	if (raw == null) return null;
+	const r = asRecord(raw);
+	return {
+		_type: strReq(r, "_type"),
+		key: strReq(r, "key")
+	};
+}
+function mapSignature(raw) {
+	const r = asRecord(raw);
+	return {
+		consensus_timestamp: strReq(r, "consensus_timestamp"),
+		public_key_prefix: strReq(r, "public_key_prefix"),
+		signature: strReq(r, "signature"),
+		type: strReq(r, "type")
+	};
+}
+/** EC58: Same type for list and detail. */
+function mapSchedule(raw) {
+	const r = asRecord(raw);
+	return {
+		admin_key: mapKey(r.admin_key),
+		consensus_timestamp: str(r, "consensus_timestamp"),
+		creator_account_id: strReq(r, "creator_account_id"),
+		deleted: bool(r, "deleted"),
+		executed_timestamp: str(r, "executed_timestamp"),
+		expiration_time: str(r, "expiration_time"),
+		memo: strReq(r, "memo"),
+		payer_account_id: strReq(r, "payer_account_id"),
+		schedule_id: strReq(r, "schedule_id"),
+		signatures: arr(r, "signatures").map(mapSignature),
+		transaction_body: strReq(r, "transaction_body"),
+		wait_for_expiry: bool(r, "wait_for_expiry")
+	};
+}
+//#endregion
+//#region src/resources/schedules.ts
+var SchedulesResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/schedules",
+			params,
+			extract: createPageExtractor("schedules", mapSchedule)
+		});
+	}
+	async get(scheduleId) {
+		return mapSchedule((await this.client.get(`/api/v1/schedules/${encodeURIComponent(scheduleId)}`)).data);
+	}
+};
+//#endregion
+//#region src/mappers/transaction.ts
+function mapTransaction(raw) {
+	const r = asRecord(raw);
+	return {
+		bytes: str(r, "bytes"),
+		charged_tx_fee: strReq(r, "charged_tx_fee"),
+		consensus_timestamp: strReq(r, "consensus_timestamp"),
+		entity_id: str(r, "entity_id"),
+		max_fee: strReq(r, "max_fee"),
+		memo_base64: strReq(r, "memo_base64"),
+		name: strReq(r, "name"),
+		nft_transfers: arr(r, "nft_transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				is_approval: bool(tr, "is_approval"),
+				receiver_account_id: str(tr, "receiver_account_id"),
+				sender_account_id: str(tr, "sender_account_id"),
+				serial_number: strReq(tr, "serial_number"),
+				token_id: strReq(tr, "token_id")
+			};
+		}),
+		node: str(r, "node"),
+		nonce: num(r, "nonce"),
+		parent_consensus_timestamp: str(r, "parent_consensus_timestamp"),
+		result: strReq(r, "result"),
+		scheduled: bool(r, "scheduled"),
+		staking_reward_transfers: arr(r, "staking_reward_transfers").map((s) => {
+			const sr = asRecord(s);
+			return {
+				account: strReq(sr, "account"),
+				amount: strReq(sr, "amount")
+			};
+		}),
+		token_transfers: arr(r, "token_transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				account: strReq(tr, "account"),
+				amount: strReq(tr, "amount"),
+				is_approval: bool(tr, "is_approval"),
+				token_id: strReq(tr, "token_id")
+			};
+		}),
+		transaction_hash: strReq(r, "transaction_hash"),
+		transaction_id: strReq(r, "transaction_id"),
+		transfers: arr(r, "transfers").map((t) => {
+			const tr = asRecord(t);
+			return {
+				account: strReq(tr, "account"),
+				amount: strReq(tr, "amount"),
+				is_approval: bool(tr, "is_approval")
+			};
+		}),
+		valid_duration_seconds: strReq(r, "valid_duration_seconds"),
+		valid_start_timestamp: strReq(r, "valid_start_timestamp")
+	};
+}
+/**
+* Unwraps the `{ transactions: [...] }` envelope returned by GET /transactions/{id}.
+*
+* EC21/150/151: Detail endpoint wraps in array. `.get()` extracts `transactions[0]`.
+*/
+function unwrapTransaction(raw) {
+	const txns = arr(asRecord(raw), "transactions");
+	if (txns.length === 0) throw new Error("Transaction response contained empty transactions array");
+	return mapTransaction(txns[0]);
+}
+/** EC77: NFT transaction has a separate shape. */
+function mapNftTransaction(raw) {
+	const r = asRecord(raw);
+	return {
+		consensus_timestamp: strReq(r, "consensus_timestamp"),
+		is_approval: bool(r, "is_approval"),
+		nonce: num(r, "nonce"),
+		receiver_account_id: str(r, "receiver_account_id"),
+		sender_account_id: str(r, "sender_account_id"),
+		transaction_id: strReq(r, "transaction_id"),
+		type: strReq(r, "type")
+	};
+}
+//#endregion
+//#region src/resources/tokens.ts
+var TokensResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/tokens",
+			params,
+			extract: createPageExtractor("tokens", mapTokenSummary)
+		});
+	}
+	async get(tokenId) {
+		return mapTokenDetail((await this.client.get(`/api/v1/tokens/${encodeURIComponent(tokenId)}`)).data);
+	}
+	getBalances(tokenId, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/tokens/${encodeURIComponent(tokenId)}/balances`,
+			params,
+			extract: createPageExtractor("balances", mapTokenBalanceEntry)
+		});
+	}
+	getNFTs(tokenId, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/tokens/${encodeURIComponent(tokenId)}/nfts`,
+			params,
+			extract: createPageExtractor("nfts", mapTokenNft)
+		});
+	}
+	async getNFTBySerial(tokenId, serialNumber) {
+		return mapTokenNft((await this.client.get(`/api/v1/tokens/${encodeURIComponent(tokenId)}/nfts/${serialNumber}`)).data);
+	}
+	getNFTTransactions(tokenId, serialNumber, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/tokens/${encodeURIComponent(tokenId)}/nfts/${serialNumber}/transactions`,
+			params,
+			extract: createPageExtractor("transactions", mapNftTransaction)
+		});
+	}
+};
+//#endregion
+//#region src/mappers/topic.ts
+function mapChunkInfo(raw) {
+	if (raw == null) return null;
+	const r = asRecord(raw);
+	const initTxRaw = asRecord(r.initial_transaction_id);
+	return {
+		initial_transaction_id: {
+			account_id: strReq(initTxRaw, "account_id"),
+			nonce: num(initTxRaw, "nonce"),
+			scheduled: bool(initTxRaw, "scheduled"),
+			transaction_valid_start: strReq(initTxRaw, "transaction_valid_start")
+		},
+		number: num(r, "number"),
+		total: num(r, "total")
+	};
+}
+/**
+* Maps a raw topic message to a `TopicMessage`.
+*
+* EC3/18: Auto-decodes Base64 `message` and `running_hash` to `Uint8Array`.
+*/
+function mapTopicMessage(raw) {
+	const r = asRecord(raw);
+	const messageStr = strReq(r, "message");
+	const runningHashStr = strReq(r, "running_hash");
+	return {
+		chunk_info: mapChunkInfo(r.chunk_info),
+		consensus_timestamp: strReq(r, "consensus_timestamp"),
+		message: decodeBase64(messageStr),
+		payer_account_id: strReq(r, "payer_account_id"),
+		running_hash: decodeBase64(runningHashStr),
+		running_hash_version: num(r, "running_hash_version"),
+		sequence_number: strReq(r, "sequence_number"),
+		topic_id: strReq(r, "topic_id")
+	};
+}
+//#endregion
+//#region src/pagination/stream.ts
+/**
+* Adaptive polling stream for topic messages.
+*
+* - Polls at high frequency (500ms) when messages are flowing.
+* - Backs off exponentially (up to 5s) when no messages arrive.
+* - Cancellable via `AbortController`.
+* - Rate-limit aware (shares the HttpClient's token bucket).
+*/
+var TopicStream = class TopicStream {
+	client;
+	topicId;
+	options;
+	/** Minimum polling interval (ms). */
+	static MIN_INTERVAL = 500;
+	/** Maximum polling interval (ms). */
+	static MAX_INTERVAL = 5e3;
+	/** Factor by which interval increases on empty polls. */
+	static BACKOFF_FACTOR = 1.5;
+	constructor(client, topicId, options = {}) {
+		this.client = client;
+		this.topicId = topicId;
+		this.options = {
+			startTimestamp: options.startTimestamp ?? Math.floor(Date.now() / 1e3).toString(),
+			interval: options.interval ?? TopicStream.MIN_INTERVAL,
+			limit: options.limit ?? 100,
+			signal: options.signal
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		let cursor = this.options.startTimestamp;
+		let currentInterval = this.options.interval;
+		while (!this.options.signal?.aborted) {
+			try {
+				const raw = (await this.client.get(`/api/v1/topics/${this.topicId}/messages`, {
+					timestamp: `gt:${cursor}`,
+					limit: String(this.options.limit),
+					order: "asc"
+				}, { signal: this.options.signal })).data;
+				const messages = Array.isArray(raw.messages) ? raw.messages : [];
+				if (messages.length > 0) {
+					currentInterval = TopicStream.MIN_INTERVAL;
+					for (const msg of messages) {
+						const mapped = mapTopicMessage(msg);
+						yield mapped;
+						cursor = mapped.consensus_timestamp;
+					}
+				} else currentInterval = Math.min(currentInterval * TopicStream.BACKOFF_FACTOR, TopicStream.MAX_INTERVAL);
+			} catch (_error) {
+				if (this.options.signal?.aborted) return;
+				currentInterval = Math.min(currentInterval * TopicStream.BACKOFF_FACTOR * 2, TopicStream.MAX_INTERVAL);
+			}
+			await this.sleep(currentInterval);
+		}
+	}
+	sleep(ms) {
+		return new Promise((resolve) => {
+			const timer = setTimeout(resolve, ms);
+			this.options.signal?.addEventListener("abort", () => {
+				clearTimeout(timer);
+				resolve();
+			}, { once: true });
+		});
+	}
+};
+//#endregion
+//#region src/resources/topics.ts
+function mapTopicInfo(raw) {
+	const r = asRecord(raw);
+	const tsRaw = asRecord(r.timestamp);
+	return {
+		admin_key: r.admin_key ?? null,
+		auto_renew_account: str(r, "auto_renew_account"),
+		auto_renew_period: str(r, "auto_renew_period"),
+		created_timestamp: strReq(r, "created_timestamp"),
+		deleted: bool(r, "deleted"),
+		memo: strReq(r, "memo"),
+		submit_key: r.submit_key ?? null,
+		timestamp: {
+			from: strReq(tsRaw, "from"),
+			to: str(tsRaw, "to")
+		},
+		topic_id: strReq(r, "topic_id")
+	};
+}
+var TopicsResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	async get(topicId) {
+		return mapTopicInfo((await this.client.get(`/api/v1/topics/${encodeURIComponent(topicId)}`)).data);
+	}
+	getMessages(topicId, params) {
+		return new Paginator({
+			client: this.client,
+			path: `/api/v1/topics/${encodeURIComponent(topicId)}/messages`,
+			params,
+			extract: createPageExtractor("messages", mapTopicMessage)
+		});
+	}
+	async getMessageBySequence(topicId, sequenceNumber) {
+		return mapTopicMessage((await this.client.get(`/api/v1/topics/${encodeURIComponent(topicId)}/messages/${sequenceNumber}`)).data);
+	}
+	async getMessageByTimestamp(timestamp) {
+		return mapTopicMessage((await this.client.get(`/api/v1/topics/messages/${encodeURIComponent(timestamp)}`)).data);
+	}
+	stream(topicId, options) {
+		return new TopicStream(this.client, topicId, options);
+	}
+};
+//#endregion
+//#region src/resources/transactions.ts
+var TransactionsResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+	list(params) {
+		return new Paginator({
+			client: this.client,
+			path: "/api/v1/transactions",
+			params,
+			extract: createPageExtractor("transactions", mapTransaction)
+		});
+	}
+	/**
+	* Get a transaction by ID.
+	*
+	* EC21/150/151: The API returns `{ transactions: [{ ... }] }`.
+	* This method unwraps to return the single transaction.
+	*/
+	async get(transactionId, params) {
+		return unwrapTransaction((await this.client.get(`/api/v1/transactions/${encodeURIComponent(transactionId)}`, params)).data);
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* MirrorNodeClient — the main entrypoint for the Hiero Mirror Client SDK.
+*
+* ```ts
+* import { MirrorNodeClient } from '@satianurag/hiero-mirror-client';
+*
+* const client = new MirrorNodeClient({ network: 'testnet' });
+* const account = await client.accounts.get('0.0.1234');
+* ```
+*
+* @packageDocumentation
+*/
+const NETWORK_URLS = {
+	mainnet: "https://mainnet-public.mirrornode.hedera.com",
+	testnet: "https://testnet.mirrornode.hedera.com",
+	previewnet: "https://previewnet.mirrornode.hedera.com"
+};
+/**
+* The main Hiero Mirror Client SDK entry point.
+*
+* Provides typed access to all Mirror Node REST API resources with:
+* - Automatic pagination via `Paginator`
+* - Safe JSON parsing for int64 precision
+* - ETag caching, retry/backoff, and rate limiting
+* - Type-safe responses via response mappers
+*/
+var MirrorNodeClient = class {
+	/** Account operations: list, get, NFTs, tokens, rewards, allowances, airdrops. */
+	accounts;
+	/** Global balance queries. */
+	balances;
+	/** Block queries. */
+	blocks;
+	/** Contract queries and smart contract call simulation. */
+	contracts;
+	/** Network info: exchange rate, fees, nodes, stake, supply. */
+	network;
+	/** Schedule queries. */
+	schedules;
+	/** Token queries: list, get, balances, NFTs, NFT transactions. */
+	tokens;
+	/** Topic queries and HCS message streaming. */
+	topics;
+	/** Transaction queries. */
+	transactions;
+	/** The underlying HTTP client (exposed for advanced usage). */
+	httpClient;
+	constructor(options = {}) {
+		let baseUrl;
+		if (options.baseUrl) baseUrl = options.baseUrl;
+		else baseUrl = NETWORK_URLS[options.network ?? "mainnet"];
+		this.httpClient = new HttpClient({
+			baseUrl,
+			timeout: options.timeout ?? 3e4,
+			retry: { maxRetries: options.maxRetries ?? 2 },
+			rateLimitRps: options.rateLimitRps ?? 50,
+			logger: options.logger,
+			fetch: options.fetch
+		});
+		this.accounts = new AccountsResource(this.httpClient);
+		this.balances = new BalancesResource(this.httpClient);
+		this.blocks = new BlocksResource(this.httpClient);
+		this.contracts = new ContractsResource(this.httpClient);
+		this.network = new NetworkResource(this.httpClient);
+		this.schedules = new SchedulesResource(this.httpClient);
+		this.tokens = new TokensResource(this.httpClient);
+		this.topics = new TopicsResource(this.httpClient);
+		this.transactions = new TransactionsResource(this.httpClient);
+	}
+};
+//#endregion
+//#region src/errors/HieroCapabilityError.ts
+/**
+* Thrown when a known feature is disabled on the mirror node
+* (e.g., `/stateproof` returns 404 on valid transaction IDs — EC62).
+*
+* Distinct from {@link HieroNotFoundError} because the entity exists
+* but the feature is unavailable on this mirror node instance.
+*
+* @public
+*/
+var HieroCapabilityError = class extends HieroError {
+	/** The feature/endpoint that is disabled. */
+	feature;
+	constructor(message, options) {
+		super(message, {
+			statusCode: 404,
+			rawBody: options.rawBody
+		});
+		this.name = "HieroCapabilityError";
+		this.feature = options.feature;
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			feature: this.feature
+		};
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* @satianurag/hiero-mirror-client
+*
+* Standalone TypeScript client for the Hedera/Hiero Mirror Node REST API.
+*
+* @packageDocumentation
+*/
+const VERSION = "0.0.0";
+//#endregion
+export { HieroCapabilityError, HieroError, HieroNetworkError, HieroNotFoundError, HieroParseError, HieroRateLimitError, HieroServerError, HieroTimeoutError, HieroValidationError, MirrorNodeClient, Paginator, TopicStream, VERSION };
+
+//# sourceMappingURL=index.mjs.map