lampamazaza-new-internal-utils 0.24.3

package/dist/utils/messageFactory.d.cts

@@ -0,0 +1,70 @@
+import { IntentsUserId } from "../types/intentsUserId.cjs";
+import { WalletMessage } from "../types/walletMessage.cjs";
+import { Nep413DefuseMessageFor_DefuseIntents } from "lampamazaza-contract-types";
+
+//#region src/utils/messageFactory.d.ts
+declare namespace messageFactory_d_exports {
+  export { makeChallenge, makeEmptyMessage, makeInnerSwapMessage, makeInnerTransferMessage, makeSwapMessage, randomDefuseNonce };
+}
+/**
+ * @param tokenDeltas
+ * @param signerId
+ * @param deadlineTimestamp Unix timestamp in milliseconds
+ * @param referral
+ * @param memo
+ * @param appFee
+ * @param appFeeRecipient
+ */
+declare function makeInnerSwapMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  referral,
+  memo,
+  appFee,
+  appFeeRecipient
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  referral?: string;
+  memo?: string;
+  appFee: [string, bigint][];
+  appFeeRecipient: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+declare function makeSwapMessage({
+  innerMessage,
+  nonce
+}: {
+  innerMessage: Nep413DefuseMessageFor_DefuseIntents;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function makeEmptyMessage({
+  signerId,
+  deadlineTimestamp,
+  nonce
+}: {
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function randomDefuseNonce(): Uint8Array;
+/**
+ * Converts UTF-8 string to bytes for WebAuthn challenge
+ */
+declare function makeChallenge(payload: Uint8Array): Uint8Array;
+declare function makeInnerTransferMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  receiverId,
+  memo
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  receiverId: string;
+  memo?: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+//#endregion
+export { messageFactory_d_exports };

package/dist/utils/messageFactory.d.ts

@@ -0,0 +1,70 @@
+import { IntentsUserId } from "../types/intentsUserId.js";
+import { WalletMessage } from "../types/walletMessage.js";
+import { Nep413DefuseMessageFor_DefuseIntents } from "lampamazaza-contract-types";
+
+//#region src/utils/messageFactory.d.ts
+declare namespace messageFactory_d_exports {
+  export { makeChallenge, makeEmptyMessage, makeInnerSwapMessage, makeInnerTransferMessage, makeSwapMessage, randomDefuseNonce };
+}
+/**
+ * @param tokenDeltas
+ * @param signerId
+ * @param deadlineTimestamp Unix timestamp in milliseconds
+ * @param referral
+ * @param memo
+ * @param appFee
+ * @param appFeeRecipient
+ */
+declare function makeInnerSwapMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  referral,
+  memo,
+  appFee,
+  appFeeRecipient
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  referral?: string;
+  memo?: string;
+  appFee: [string, bigint][];
+  appFeeRecipient: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+declare function makeSwapMessage({
+  innerMessage,
+  nonce
+}: {
+  innerMessage: Nep413DefuseMessageFor_DefuseIntents;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function makeEmptyMessage({
+  signerId,
+  deadlineTimestamp,
+  nonce
+}: {
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  nonce?: Uint8Array;
+}): WalletMessage;
+declare function randomDefuseNonce(): Uint8Array;
+/**
+ * Converts UTF-8 string to bytes for WebAuthn challenge
+ */
+declare function makeChallenge(payload: Uint8Array): Uint8Array;
+declare function makeInnerTransferMessage({
+  tokenDeltas,
+  signerId,
+  deadlineTimestamp,
+  receiverId,
+  memo
+}: {
+  tokenDeltas: [string, bigint][];
+  signerId: IntentsUserId;
+  deadlineTimestamp: number;
+  receiverId: string;
+  memo?: string;
+}): Nep413DefuseMessageFor_DefuseIntents;
+//#endregion
+export { messageFactory_d_exports };

package/dist/utils/messageFactory.js

@@ -0,0 +1,132 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { config } from "../config.js";
+import { assert } from "./assert.js";
+import { base64 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha256";
+
+//#region src/utils/messageFactory.ts
+var messageFactory_exports = /* @__PURE__ */ __exportAll({
+	makeChallenge: () => makeChallenge,
+	makeEmptyMessage: () => makeEmptyMessage,
+	makeInnerSwapMessage: () => makeInnerSwapMessage,
+	makeInnerTransferMessage: () => makeInnerTransferMessage,
+	makeSwapMessage: () => makeSwapMessage,
+	randomDefuseNonce: () => randomDefuseNonce
+});
+/**
+* @param tokenDeltas
+* @param signerId
+* @param deadlineTimestamp Unix timestamp in milliseconds
+* @param referral
+* @param memo
+* @param appFee
+* @param appFeeRecipient
+*/
+function makeInnerSwapMessage({ tokenDeltas, signerId, deadlineTimestamp, referral, memo, appFee, appFeeRecipient }) {
+	const tokenDiff = {};
+	const tokenDiffNum = {};
+	const intents = [{
+		intent: "token_diff",
+		diff: tokenDiff,
+		referral,
+		memo
+	}];
+	if (appFee.length) intents.push({
+		intent: "transfer",
+		tokens: Object.fromEntries(appFee.map(([token, amount]) => [token, amount.toString()])),
+		receiver_id: appFeeRecipient,
+		memo: "APP_FEE"
+	});
+	for (const [token, amount] of tokenDeltas) {
+		tokenDiffNum[token] ??= 0n;
+		tokenDiffNum[token] += amount;
+		tokenDiff[token] = tokenDiffNum[token].toString();
+	}
+	if (Object.keys(tokenDiff).length === 0) return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [],
+		signer_id: signerId
+	};
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents,
+		signer_id: signerId
+	};
+}
+function makeSwapMessage({ innerMessage, nonce = randomDefuseNonce() }) {
+	const payload = {
+		signer_id: innerMessage.signer_id,
+		verifying_contract: config.env.contractID,
+		deadline: innerMessage.deadline,
+		nonce: base64.encode(nonce),
+		intents: innerMessage.intents
+	};
+	const payloadSerialized = JSON.stringify(payload);
+	const payloadBytes = new TextEncoder().encode(payloadSerialized);
+	return {
+		NEP413: {
+			message: JSON.stringify(innerMessage),
+			recipient: config.env.contractID,
+			nonce
+		},
+		ERC191: { message: JSON.stringify(payload, null, 2) },
+		SOLANA: { message: payloadBytes },
+		STELLAR: { message: JSON.stringify(payload, null, 2) },
+		WEBAUTHN: {
+			challenge: makeChallenge(payloadBytes),
+			payload: payloadSerialized,
+			parsedPayload: payload
+		},
+		TON_CONNECT: { message: {
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		} },
+		TRON: { message: JSON.stringify(payload, null, 2) }
+	};
+}
+function makeEmptyMessage({ signerId, deadlineTimestamp, nonce = randomDefuseNonce() }) {
+	return makeSwapMessage({
+		innerMessage: {
+			deadline: new Date(deadlineTimestamp).toISOString(),
+			intents: [],
+			signer_id: signerId
+		},
+		nonce
+	});
+}
+function randomDefuseNonce() {
+	return randomBytes(32);
+}
+function randomBytes(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Converts UTF-8 string to bytes for WebAuthn challenge
+*/
+function makeChallenge(payload) {
+	const hash = sha256(payload);
+	return new Uint8Array(hash);
+}
+function makeInnerTransferMessage({ tokenDeltas, signerId, deadlineTimestamp, receiverId, memo }) {
+	const tokens = {};
+	const seenTokens = /* @__PURE__ */ new Set();
+	for (const [token, amount] of tokenDeltas) {
+		assert(!seenTokens.has(token), `Duplicate token found: ${token}`);
+		seenTokens.add(token);
+		assert(amount > 0n, `Transfer amount must be positive, got: ${amount} for token ${token}`);
+		tokens[token] = amount.toString();
+	}
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [{
+			intent: "transfer",
+			tokens,
+			receiver_id: receiverId,
+			...memo ? { memo } : {}
+		}],
+		signer_id: signerId
+	};
+}
+
+//#endregion
+export { messageFactory_exports };

package/dist/utils/multiPayload/webauthn.cjs

@@ -0,0 +1,27 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_assert = require('../assert.cjs');
+const require_webAuthn = require('../webAuthn.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/utils/multiPayload/webauthn.ts
+function makeWebAuthnMultiPayload(userInfo, signature) {
+	require_assert.assert(userInfo.userChainType === "webauthn", "User chain and signature chain must match");
+	const { curveType, publicKey } = require_webAuthn.parsePublicKey(userInfo.userAddress);
+	return {
+		standard: "webauthn",
+		payload: signature.signedData.payload,
+		public_key: formatPublicKey(publicKey, curveType),
+		signature: formatSignature(require_webAuthn.extractRawSignature(signature.signatureData.signature, curveType), curveType),
+		client_data_json: new TextDecoder("utf-8").decode(signature.signatureData.clientDataJSON),
+		authenticator_data: _scure_base.base64urlnopad.encode(new Uint8Array(signature.signatureData.authenticatorData))
+	};
+}
+function formatPublicKey(publicKey, curveType) {
+	return `${curveType}:${_scure_base.base58.encode(publicKey)}`;
+}
+function formatSignature(signature, curveType) {
+	return `${curveType}:${_scure_base.base58.encode(new Uint8Array(signature))}`;
+}
+
+//#endregion
+exports.makeWebAuthnMultiPayload = makeWebAuthnMultiPayload;

package/dist/utils/multiPayload/webauthn.js

@@ -0,0 +1,26 @@
+import { assert } from "../assert.js";
+import { extractRawSignature, parsePublicKey } from "../webAuthn.js";
+import { base58, base64urlnopad } from "@scure/base";
+
+//#region src/utils/multiPayload/webauthn.ts
+function makeWebAuthnMultiPayload(userInfo, signature) {
+	assert(userInfo.userChainType === "webauthn", "User chain and signature chain must match");
+	const { curveType, publicKey } = parsePublicKey(userInfo.userAddress);
+	return {
+		standard: "webauthn",
+		payload: signature.signedData.payload,
+		public_key: formatPublicKey(publicKey, curveType),
+		signature: formatSignature(extractRawSignature(signature.signatureData.signature, curveType), curveType),
+		client_data_json: new TextDecoder("utf-8").decode(signature.signatureData.clientDataJSON),
+		authenticator_data: base64urlnopad.encode(new Uint8Array(signature.signatureData.authenticatorData))
+	};
+}
+function formatPublicKey(publicKey, curveType) {
+	return `${curveType}:${base58.encode(publicKey)}`;
+}
+function formatSignature(signature, curveType) {
+	return `${curveType}:${base58.encode(new Uint8Array(signature))}`;
+}
+
+//#endregion
+export { makeWebAuthnMultiPayload };

package/dist/utils/near.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/utils/near.ts
+/**
+* Use this function to decode a raw response from `nearClient.query()`
+*/
+function decodeQueryResult(response, schema) {
+	const parsed = valibot.parse(valibot.object({ result: valibot.array(valibot.number()) }), response);
+	const uint8Array = new Uint8Array(parsed.result);
+	const result = new TextDecoder().decode(uint8Array);
+	return valibot.parse(schema, JSON.parse(result));
+}
+function getBlockReference({ blockId, finality }) {
+	if (blockId != null) return { blockId };
+	if (finality != null) return { finality };
+	return { finality: "optimistic" };
+}
+async function queryContract({ nearClient, contractId, methodName, args, blockId, finality, schema }) {
+	return decodeQueryResult(await nearClient.query({
+		request_type: "call_function",
+		account_id: contractId,
+		method_name: methodName,
+		args_base64: btoa(JSON.stringify(args)),
+		...getBlockReference({
+			blockId,
+			finality
+		})
+	}), schema);
+}
+const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+const MIN_ACCOUNT_ID_LENGTH = 2;
+const ETH_IMPLICIT_ACCOUNT_LENGTH = 42;
+const NEAR_IMPLICIT_ACCOUNT_LENGTH = 64;
+function validateNearAddress(accountId) {
+	if (accountId.length < MIN_ACCOUNT_ID_LENGTH || accountId.length > NEAR_IMPLICIT_ACCOUNT_LENGTH) return false;
+	if (isImplicitAccount(accountId)) return true;
+	return ACCOUNT_ID_REGEX.test(accountId);
+}
+function isEthImplicitAccount(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0x") && /^[0-9a-f]+$/i.test(accountId.slice(2));
+}
+function isNearDeterministic(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0s") && /^[0-9a-f]+$/i.test(accountId.slice(2));
+}
+function isNearImplicit(accountId) {
+	return accountId.length === NEAR_IMPLICIT_ACCOUNT_LENGTH && /^[0-9a-f]+$/i.test(accountId);
+}
+function isImplicitAccount(accountId) {
+	return isEthImplicitAccount(accountId) || isNearImplicit(accountId) || isNearDeterministic(accountId);
+}
+
+//#endregion
+exports.decodeQueryResult = decodeQueryResult;
+exports.isImplicitAccount = isImplicitAccount;
+exports.queryContract = queryContract;
+exports.validateNearAddress = validateNearAddress;

package/dist/utils/near.d.cts

@@ -0,0 +1,35 @@
+import { providers } from "near-api-js";
+import { BlockId, Finality } from "near-api-js/lib/providers/provider";
+import * as v from "valibot";
+
+//#region src/utils/near.d.ts
+
+/**
+ * Use this function to decode a raw response from `nearClient.query()`
+ */
+declare function decodeQueryResult<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>(response: unknown, schema: T): v.InferOutput<T>;
+type OptionalBlockReference = {
+  blockId?: BlockId;
+  finality?: Finality;
+};
+declare function queryContract<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>({
+  nearClient,
+  contractId,
+  methodName,
+  args,
+  blockId,
+  finality,
+  schema
+}: {
+  nearClient: providers.Provider;
+  contractId: string;
+  methodName: string;
+  args: Record<string, unknown>;
+  blockId?: BlockId;
+  finality?: Finality;
+  schema: T;
+}): Promise<v.InferOutput<T>>;
+declare function validateNearAddress(accountId: string): boolean;
+declare function isImplicitAccount(accountId: string): boolean;
+//#endregion
+export { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };

package/dist/utils/near.d.ts

@@ -0,0 +1,35 @@
+import * as v from "valibot";
+import { providers } from "near-api-js";
+import { BlockId, Finality } from "near-api-js/lib/providers/provider";
+
+//#region src/utils/near.d.ts
+
+/**
+ * Use this function to decode a raw response from `nearClient.query()`
+ */
+declare function decodeQueryResult<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>(response: unknown, schema: T): v.InferOutput<T>;
+type OptionalBlockReference = {
+  blockId?: BlockId;
+  finality?: Finality;
+};
+declare function queryContract<T extends v.BaseSchema<TInput, TOutput, TIssue>, TInput, TOutput, TIssue extends v.BaseIssue<unknown>>({
+  nearClient,
+  contractId,
+  methodName,
+  args,
+  blockId,
+  finality,
+  schema
+}: {
+  nearClient: providers.Provider;
+  contractId: string;
+  methodName: string;
+  args: Record<string, unknown>;
+  blockId?: BlockId;
+  finality?: Finality;
+  schema: T;
+}): Promise<v.InferOutput<T>>;
+declare function validateNearAddress(accountId: string): boolean;
+declare function isImplicitAccount(accountId: string): boolean;
+//#endregion
+export { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };

package/dist/utils/near.js

@@ -0,0 +1,53 @@
+import * as v from "valibot";
+
+//#region src/utils/near.ts
+/**
+* Use this function to decode a raw response from `nearClient.query()`
+*/
+function decodeQueryResult(response, schema) {
+	const parsed = v.parse(v.object({ result: v.array(v.number()) }), response);
+	const uint8Array = new Uint8Array(parsed.result);
+	const result = new TextDecoder().decode(uint8Array);
+	return v.parse(schema, JSON.parse(result));
+}
+function getBlockReference({ blockId, finality }) {
+	if (blockId != null) return { blockId };
+	if (finality != null) return { finality };
+	return { finality: "optimistic" };
+}
+async function queryContract({ nearClient, contractId, methodName, args, blockId, finality, schema }) {
+	return decodeQueryResult(await nearClient.query({
+		request_type: "call_function",
+		account_id: contractId,
+		method_name: methodName,
+		args_base64: btoa(JSON.stringify(args)),
+		...getBlockReference({
+			blockId,
+			finality
+		})
+	}), schema);
+}
+const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+const MIN_ACCOUNT_ID_LENGTH = 2;
+const ETH_IMPLICIT_ACCOUNT_LENGTH = 42;
+const NEAR_IMPLICIT_ACCOUNT_LENGTH = 64;
+function validateNearAddress(accountId) {
+	if (accountId.length < MIN_ACCOUNT_ID_LENGTH || accountId.length > NEAR_IMPLICIT_ACCOUNT_LENGTH) return false;
+	if (isImplicitAccount(accountId)) return true;
+	return ACCOUNT_ID_REGEX.test(accountId);
+}
+function isEthImplicitAccount(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0x") && /^[0-9a-f]+$/i.test(accountId.slice(2));
+}
+function isNearDeterministic(accountId) {
+	return accountId.length === ETH_IMPLICIT_ACCOUNT_LENGTH && accountId.startsWith("0s") && /^[0-9a-f]+$/i.test(accountId.slice(2));
+}
+function isNearImplicit(accountId) {
+	return accountId.length === NEAR_IMPLICIT_ACCOUNT_LENGTH && /^[0-9a-f]+$/i.test(accountId);
+}
+function isImplicitAccount(accountId) {
+	return isEthImplicitAccount(accountId) || isNearImplicit(accountId) || isNearDeterministic(accountId);
+}
+
+//#endregion
+export { decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress };

package/dist/utils/poll.cjs

@@ -0,0 +1,87 @@
+const require_base = require('../errors/base.cjs');
+
+//#region src/utils/poll.ts
+const PHASE = {
+	HOT: "HOT",
+	COOLING: "COOLING",
+	COLD: "COLD"
+};
+const DEFAULT_INTERVALS = {
+	[PHASE.HOT]: 300,
+	[PHASE.COOLING]: 3e3,
+	[PHASE.COLD]: 1e4
+};
+/**
+* Sentinel value to signal that polling should continue.
+* Return this from the poll function to indicate "not done yet".
+*/
+const POLL_PENDING = Symbol("poll.pending");
+var PollTimeoutError = class extends require_base.BaseError {
+	constructor(elapsedMs, timeoutMs) {
+		super("Polling timed out", { details: `Operation did not complete within ${timeoutMs}ms (elapsed: ${elapsedMs}ms)` });
+		this.elapsedMs = elapsedMs;
+		this.timeoutMs = timeoutMs;
+		this.name = "PollTimeoutError";
+	}
+};
+/**
+* Polls a function using latency-optimized intervals.
+*
+* Polls aggressively early (when completion is most likely), backs off later
+* for outliers. Optimized for latency-sensitive operations like swaps.
+*
+* Interval strategy:
+* - 0 → p50: HOT (300ms) - most completions happen here (~50%)
+* - p50 → p90: COOLING (3s) - moderate polling (~40%)
+* - p90 → p99: COLD (10s) - back off for outliers (~9%)
+*
+* @param fn - Function to poll. Return POLL_PENDING to continue, any other value to complete.
+* @param options - Polling configuration with completion stats
+* @returns The resolved value from fn
+* @throws PollTimeoutError when p99 is exceeded
+* @throws AbortError when signal is aborted
+*/
+async function poll(fn, options) {
+	const { stats, signal, minInterval = 300, maxInterval = 3e4 } = options;
+	const { p50, p90, p99 } = stats;
+	const startTime = performance.now();
+	while (true) {
+		signal?.throwIfAborted();
+		const elapsed = performance.now() - startTime;
+		if (elapsed >= p99) throw new PollTimeoutError(elapsed, p99);
+		const result = await fn();
+		if (result !== POLL_PENDING) return result;
+		const rawInterval = DEFAULT_INTERVALS[getPhase(elapsed, p50, p90)];
+		await sleep(clamp(rawInterval, minInterval, maxInterval), signal);
+	}
+}
+function getPhase(elapsed, p50, p90) {
+	if (elapsed < p50) return PHASE.HOT;
+	if (elapsed < p90) return PHASE.COOLING;
+	return PHASE.COLD;
+}
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const abortHandler = () => {
+			clearTimeout(timeoutId);
+			reject(signal?.reason);
+		};
+		const timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", abortHandler);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", abortHandler);
+	});
+}
+
+//#endregion
+exports.POLL_PENDING = POLL_PENDING;
+exports.PollTimeoutError = PollTimeoutError;
+exports.poll = poll;

package/dist/utils/poll.d.cts

@@ -0,0 +1,54 @@
+import { BaseError } from "../errors/base.cjs";
+
+//#region src/utils/poll.d.ts
+
+/**
+ * Sentinel value to signal that polling should continue.
+ * Return this from the poll function to indicate "not done yet".
+ */
+declare const POLL_PENDING: unique symbol;
+type PollTimeoutErrorType = PollTimeoutError & {
+  name: "PollTimeoutError";
+};
+declare class PollTimeoutError extends BaseError {
+  elapsedMs: number;
+  timeoutMs: number;
+  name: "PollTimeoutError";
+  constructor(elapsedMs: number, timeoutMs: number);
+}
+interface CompletionStats {
+  /** 50th percentile (median completion time in ms) */
+  p50: number;
+  /** 90th percentile (in ms) */
+  p90: number;
+  /** 99th percentile - hard timeout (in ms) */
+  p99: number;
+}
+interface PollOptions {
+  stats: CompletionStats;
+  signal?: AbortSignal;
+  /** Minimum interval floor (default: 300ms) */
+  minInterval?: number;
+  /** Maximum interval ceiling (default: 30000ms) */
+  maxInterval?: number;
+}
+/**
+ * Polls a function using latency-optimized intervals.
+ *
+ * Polls aggressively early (when completion is most likely), backs off later
+ * for outliers. Optimized for latency-sensitive operations like swaps.
+ *
+ * Interval strategy:
+ * - 0 → p50: HOT (300ms) - most completions happen here (~50%)
+ * - p50 → p90: COOLING (3s) - moderate polling (~40%)
+ * - p90 → p99: COLD (10s) - back off for outliers (~9%)
+ *
+ * @param fn - Function to poll. Return POLL_PENDING to continue, any other value to complete.
+ * @param options - Polling configuration with completion stats
+ * @returns The resolved value from fn
+ * @throws PollTimeoutError when p99 is exceeded
+ * @throws AbortError when signal is aborted
+ */
+declare function poll<T>(fn: () => Promise<T | typeof POLL_PENDING>, options: PollOptions): Promise<T>;
+//#endregion
+export { CompletionStats, POLL_PENDING, PollOptions, PollTimeoutError, PollTimeoutErrorType, poll };