@outcome.xyz/hip4 1.0.0-beta

package/dist/index.d.cts

@@ -0,0 +1,1058 @@
+import { ac as PredictionEvent, ab as PredictionCategory, F as FetchMarketsParams, H as HIP4Market, a5 as MarketsByType, a4 as MarketsByQuestion, ai as PredictionOrderParams, aj as PredictionOrderResult, a9 as PredictionBatchOrderResult, aa as PredictionCancelParams, f as HLCancelResponse, af as PredictionModifyParams, a8 as PredictionAuthState, al as PredictionPosition, a7 as PredictionActivity, ag as PredictionOrderBook, am as PredictionPrice, an as PredictionTrade, O as HLWsAllMidsData, N as HLWsActiveSpotAssetCtxData, Z as HLWsSpotAssetCtxsData, M as HLWsActivePerpAssetCtxData, v as HLOutcomeMeta, z as HLSettledOutcome, n as HLL2Book, G as HLTrade, c as HLAllMids, h as HLCandle, i as HLClearinghouseState, l as HLFill, E as HLSpotClearinghouseState, k as HLExtraAgent, x as HLReferralState, L as HLUserRoleResponse, J as HLUserFees, I as HLUserAbstraction, m as HLFrontendOrder, t as HLOrderAction, A as HLSignature, j as HLExchangeResponse, e as HLCancelAction, q as HLModifyAction, r as HLModifyResponse, d as HLBatchModifyAction, U as HLWsOutcomeMetaUpdate, b as HIP4Signer, w as HLQuestion, u as HLOutcome, Y as HLWsSpotAssetCtxItem } from './index-ubGjjLVg.cjs';
+export { B as BaseMarket, D as DefaultBinaryMarket, a as FetchMarketsResult, g as HLCancelStatus, o as HLMergeOutcomeAction, p as HLMergeQuestionAction, s as HLNegateOutcomeAction, y as HLScheduleCancelAction, C as HLSplitOutcomeAction, K as HLUserOutcomeAction, P as HLWsBboData, Q as HLWsClearinghouseStateEvent, R as HLWsL2BookData, S as HLWsOpenOrdersEvent, T as HLWsOutcomeMetaSideSpec, V as HLWsOutcomeMetaUpdates, W as HLWsOutcomeSpec, X as HLWsQuestionSpec, _ as HLWsSpotStateEvent, $ as HLWsTradesEvent, a0 as HLWsUserFillsEvent, a1 as LabelledBinaryMarket, a2 as MarketSide, a3 as MarketType, a6 as MultiOutcomeMarket, ad as PredictionEventStatus, ae as PredictionMarket, ah as PredictionOrderBookLevel, ak as PredictionOutcome, ao as PriceBucketMarket, ap as normalizeSignature, aq as splitHexSignature } from './index-ubGjjLVg.cjs';
+
+/** Callback returned by subscribe methods; call it to unsubscribe. */
+type Unsubscribe = () => void;
+/** Top-level adapter that groups all prediction-market sub-adapters. */
+interface PredictionsAdapter {
+    readonly id: string;
+    readonly name: string;
+    readonly events: PredictionEventAdapter;
+    readonly marketData: PredictionMarketDataAdapter;
+    readonly account: PredictionAccountAdapter;
+    readonly trading: PredictionTradingAdapter;
+    readonly auth: PredictionAuthAdapter;
+    readonly wallet: PredictionWalletAdapter;
+    /** Initialize connections and internal state. Must be called before use. */
+    initialize(): Promise<void>;
+    /** Tear down connections and clean up subscriptions. */
+    destroy(): void;
+}
+interface PredictionEventAdapter {
+    /** List events with optional filters (category, active, limit, offset, query). */
+    fetchEvents(params?: {
+        category?: string;
+        active?: boolean;
+        limit?: number;
+        offset?: number;
+        query?: string;
+    }): Promise<PredictionEvent[]>;
+    /** Fetch a single event by ID. IDs are "q<n>" for questions, "o<n>" for standalone outcomes. */
+    fetchEvent(eventId: string): Promise<PredictionEvent>;
+    /** List available categories (e.g. "custom", "recurring"). */
+    fetchCategories(): Promise<PredictionCategory[]>;
+    /** Fetch typed HIP-4 markets with optional type filtering, grouping, and pagination. */
+    fetchMarkets(params?: FetchMarketsParams): Promise<HIP4Market[] | MarketsByType | MarketsByQuestion>;
+}
+interface PredictionMarketDataAdapter {
+    /** Fetch the order book for a market. marketId is the outcome ID as string; sideIndex defaults to 0 (Yes). */
+    fetchOrderBook(marketId: string, sideIndex?: number): Promise<PredictionOrderBook>;
+    /** Fetch the current price for both sides of a market. Names are generic ("Side 0"/"Side 1") - use event.markets[].outcomes[].name for real names. */
+    fetchPrice(marketId: string): Promise<PredictionPrice>;
+    /** Fetch recent trades for a market. */
+    fetchTrades(marketId: string, limit?: number): Promise<PredictionTrade[]>;
+    /** Fetch OHLCV candles for a market. Defaults to 1h interval, 14 days lookback. */
+    fetchCandles(marketId: string, interval?: string, startTime?: number, endTime?: number): Promise<Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>>;
+    /** Subscribe to real-time order book updates. Returns an unsubscribe callback. */
+    subscribeOrderBook(marketId: string, onData: (book: PredictionOrderBook) => void): Unsubscribe;
+    /** Subscribe to real-time price updates. Returns an unsubscribe callback. */
+    subscribePrice(marketId: string, onData: (price: PredictionPrice) => void): Unsubscribe;
+    /** Subscribe to real-time trade updates. Returns an unsubscribe callback. */
+    subscribeTrades(marketId: string, onData: (trade: PredictionTrade) => void): Unsubscribe;
+    /** Subscribe to all mid-price updates across every market. Returns an unsubscribe callback. */
+    subscribeAllMids(onData: (data: HLWsAllMidsData) => void): Unsubscribe;
+    /** Subscribe to real-time asset context (volume, OI, mark price) for a spot coin. Returns an unsubscribe callback. */
+    subscribeActiveAssetCtx(coin: string, onData: (data: HLWsActiveSpotAssetCtxData) => void): Unsubscribe;
+    /** Subscribe to bulk spot asset context updates for all spot coins. Returns an unsubscribe callback. */
+    subscribeSpotAssetCtxs(onData: (data: HLWsSpotAssetCtxsData) => void): Unsubscribe;
+    /** Subscribe to real-time perp asset context (mark price, oracle, funding) for a perp coin. Returns an unsubscribe callback. */
+    subscribePerpAssetCtx(coin: string, onData: (data: HLWsActivePerpAssetCtxData) => void): Unsubscribe;
+}
+interface PredictionAccountAdapter {
+    /** Fetch all open positions for an address. */
+    fetchPositions(address: string): Promise<PredictionPosition[]>;
+    /** Fetch account activity (trades, redeems, deposits, withdrawals) for an address. */
+    fetchActivity(address: string): Promise<PredictionActivity[]>;
+    /** Fetch raw spot balances (including USDH) for an address. */
+    fetchBalance(address: string): Promise<Array<{
+        coin: string;
+        total: string;
+        hold: string;
+    }>>;
+    /** Fetch resting limit orders from frontendOpenOrders for an address. */
+    fetchOpenOrders(address: string): Promise<Array<{
+        coin: string;
+        side: "B" | "A";
+        limitPx: string;
+        sz: string;
+        oid: number;
+        timestamp: number;
+    }>>;
+    /** Subscribe to position changes. Polls at 10s interval (no WS channel for spot). */
+    subscribePositions(address: string, onData: (positions: PredictionPosition[]) => void): Unsubscribe;
+}
+interface PredictionTradingAdapter {
+    /** Place a market or limit order. Returns { success, orderId?, status?, shares?, error? }. Never throws. */
+    placeOrder(params: PredictionOrderParams): Promise<PredictionOrderResult>;
+    /** Place multiple orders in a single batched request. Never throws. */
+    placeOrders(params: PredictionOrderParams[]): Promise<PredictionBatchOrderResult>;
+    /** Cancel one or more resting orders in a single request. */
+    cancelOrder(params: PredictionCancelParams[]): Promise<HLCancelResponse>;
+    /**
+     * Modify a resting order (price and/or size). Preserves queue priority
+     * when only size changes. Returns the same shape as placeOrder so the
+     * result carries the (potentially new) order id. Never throws.
+     */
+    modifyOrder(params: PredictionModifyParams): Promise<PredictionOrderResult>;
+}
+interface PredictionAuthAdapter {
+    /** Initialize auth with a wallet. Accepts a viem PrivateKeyAccount or ethers Signer. */
+    initAuth(walletAddress: string, signer: unknown): Promise<PredictionAuthState>;
+    /** Return the current authentication state. */
+    getAuthStatus(): PredictionAuthState;
+    /** Clear stored auth credentials and reset state to disconnected. */
+    clearAuth(): void;
+}
+interface WalletActionResult$1 {
+    success: boolean;
+    error?: string;
+    filledSz?: string;
+    avgPx?: string;
+    /**
+     * Order id of the resulting fill (set only on `success: true` for actions
+     * that produce a fill - `buyUsdh`, `sellUsdh`, etc). Callers use this to
+     * look up the realized fee in `userFills` / `userFillsByTime`, since the
+     * synchronous order ack does not carry fee.
+     */
+    oid?: number;
+}
+interface PredictionWalletAdapter {
+    /** Set the user's wallet signer for EIP-712 operations (transfers, withdrawals). */
+    setSigner(signer: {
+        address: string;
+        signTypedData: (...args: unknown[]) => Promise<string>;
+    } | unknown): void;
+    /** Buy USDH on the spot market. Uses L1 agent signing. */
+    buyUsdh(amount: string): Promise<WalletActionResult$1>;
+    /** Sell USDH on the spot market. Uses L1 agent signing. */
+    sellUsdh(amount: string): Promise<WalletActionResult$1>;
+    /** Transfer USDC from Perp to Spot account. */
+    transferToSpot(amount: string): Promise<WalletActionResult$1>;
+    /** Transfer USDC from Spot to Perp account. */
+    transferToPerps(amount: string): Promise<WalletActionResult$1>;
+    /** Withdraw USDC to an external address. */
+    withdraw(params: {
+        destination: string;
+        amount: string;
+    }): Promise<WalletActionResult$1>;
+    /** Send USDC to another Hyperliquid address. */
+    usdSend(params: {
+        destination: string;
+        amount: string;
+    }): Promise<WalletActionResult$1>;
+}
+
+declare class HLApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+interface HIP4ClientConfig {
+    testnet?: boolean;
+    infoUrl?: string;
+    exchangeUrl?: string;
+    /** Optional logger. Default: no-op. */
+    logger?: (level: "debug" | "info" | "warn" | "error", msg: string, data?: unknown) => void;
+}
+/**
+ * Canonical value for info queries that should span every perp dex.
+ * Replaces reliance on DEX abstraction, which Hyperliquid is deprecating.
+ */
+declare const ALL_DEXS = "ALL_DEXS";
+/**
+ * Predicate: does this abstraction mode require a `usdClassTransfer`
+ * step to move USDC between spot and perps silos?
+ *
+ * - `disabled` (Standard): spot/perp split, transfer required.
+ * - `dexAbstraction`: unifies multiple perp DEXes only - spot/perp
+ *   split is preserved, transfer still required. Verified empirically:
+ *   addresses on `dexAbstraction` carry independent spot-USDC and
+ *   perp-`withdrawable` balances.
+ * - `unifiedAccount` / `portfolioMargin`: spot↔perp merged into a
+ *   single balance - `usdClassTransfer` is rejected with `"Action
+ *   disabled when unified account is active"`.
+ */
+declare function isUsdClassTransferRequired(abstraction: HLUserAbstraction): boolean;
+/** Outcome-level coin name (AMM instrument) */
+declare function outcomeCoin(outcomeId: number): string;
+/** Per-side probability coin name */
+declare function sideCoin(outcomeId: number, sideIndex: number): string;
+/** Asset ID for order placement: 100_000_000 + outcomeId * 10 + sideIndex */
+declare function sideAssetId(outcomeId: number, sideIndex: number): number;
+/** Parse a side coin like "#5160" or "+5160" into {outcomeId, sideIndex} */
+declare function parseSideCoin(coin: string): {
+    outcomeId: number;
+    sideIndex: number;
+} | null;
+/** Parse an outcome-level coin like "@1338" into {outcomeId} */
+declare function parseOutcomeCoin(coin: string): {
+    outcomeId: number;
+} | null;
+declare class HIP4Client {
+    readonly infoUrl: string;
+    readonly exchangeUrl: string;
+    readonly wsUrl: string;
+    readonly testnet: boolean;
+    readonly log: (level: "debug" | "info" | "warn" | "error", msg: string, data?: unknown) => void;
+    constructor(config?: HIP4ClientConfig);
+    fetchOutcomeMeta(): Promise<HLOutcomeMeta>;
+    fetchSettledOutcome(outcome: number): Promise<HLSettledOutcome | null>;
+    fetchL2Book(coin: string): Promise<HLL2Book>;
+    fetchRecentTrades(coin: string): Promise<HLTrade[]>;
+    fetchAllMids(): Promise<HLAllMids>;
+    fetchCandleSnapshot(coin: string, interval: string, startTime: number, endTime: number): Promise<HLCandle[]>;
+    fetchClearinghouseState(user: string): Promise<HLClearinghouseState>;
+    fetchUserFills(user: string): Promise<HLFill[]>;
+    /** Spot meta + asset contexts (includes markPx / oracle price for each spot asset) */
+    fetchSpotAssetCtx(spotIndex: number): Promise<{
+        markPx: string;
+        midPx: string;
+    } | null>;
+    /** Spot balances - HIP-4 prediction market positions live here (USDH, outcome tokens) */
+    fetchSpotClearinghouseState(user: string): Promise<HLSpotClearinghouseState>;
+    /** Trade fills with time range filtering */
+    fetchUserFillsByTime(user: string, startTime: number, endTime: number): Promise<HLFill[]>;
+    /** Approved extra agents for a user */
+    fetchExtraAgents(user: string): Promise<HLExtraAgent[]>;
+    /**
+     * Check the maximum builder fee a user has approved for a given builder.
+     * Returns the approved fee in tenths of a basis point (e.g. 100 = 0.1%).
+     * Returns 0 if no approval exists.
+     */
+    fetchMaxBuilderFee(user: string, builder: string): Promise<number>;
+    /**
+     * Fetch all approved builder addresses for a user.
+     * Hyperliquid limits each address to a maximum of 3 approved builders.
+     */
+    fetchApprovedBuilders(user: string): Promise<string[]>;
+    /**
+     * Fetch a user's referral state from Hyperliquid.
+     * Returns the referral state object, or null if no referrer is set.
+     */
+    fetchReferralState(user: string): Promise<HLReferralState>;
+    /**
+     * Fetch the role assigned to a user by Hyperliquid.
+     * `role === "missing"` indicates the wallet has never interacted with HL.
+     */
+    fetchUserRole(user: string): Promise<HLUserRoleResponse>;
+    /**
+     * Fetch the user's effective fee schedule (post-discount).
+     * Spot rates (`userSpotCrossRate` / `userSpotAddRate`) are what apply to
+     * HIP-4 outcome closes; opens are 0-fee.
+     */
+    fetchUserFees(user: string): Promise<HLUserFees>;
+    /**
+     * Fetch the user's account abstraction mode.
+     *
+     * Returns one of `"default" | "disabled" | "dexAbstraction" |
+     * "unifiedAccount" | "portfolioMargin"`. Standard accounts return
+     * `"default"` (or `"disabled"`); both keep spot and perp as separate
+     * silos and require a `usdClassTransfer` before `withdraw3`. Only
+     * `"unifiedAccount"` / `"portfolioMargin"` merge the balances and reject
+     * `usdClassTransfer`. Use {@link isUsdClassTransferRequired} to gate the
+     * spot↔perp transfer step in deposit/withdraw flows.
+     *
+     * Endpoint: `POST /info` body `{ type: "userAbstraction", user }`.
+     */
+    fetchUserAbstraction(user: string): Promise<HLUserAbstraction>;
+    /** Frontend-formatted open orders */
+    fetchFrontendOpenOrders(user: string): Promise<HLFrontendOrder[]>;
+    placeOrder(action: HLOrderAction, nonce: number, signature: HLSignature, vaultAddress?: string | null): Promise<HLExchangeResponse>;
+    cancelOrder(action: HLCancelAction, nonce: number, signature: HLSignature, vaultAddress?: string | null): Promise<HLCancelResponse>;
+    modifyOrder(action: HLModifyAction, nonce: number, signature: HLSignature, vaultAddress?: string | null): Promise<HLModifyResponse>;
+    batchModifyOrders(action: HLBatchModifyAction, nonce: number, signature: HLSignature, vaultAddress?: string | null): Promise<HLModifyResponse>;
+    /** Submit a user-signed action (withdraw, usdClassTransfer, etc.) */
+    submitUserSignedAction(action: Record<string, unknown>, nonce: number, signature: HLSignature): Promise<{
+        status: string;
+        response?: unknown;
+    }>;
+    private ws;
+    private wsPendingMessages;
+    /** Callbacks keyed by response channel (for message routing). */
+    private wsCallbacks;
+    /** Active subscribe messages as JSON strings (for reconnection). */
+    private wsActiveSubs;
+    /**
+     * Subscribe to a Hyperliquid WebSocket channel.
+     * Returns an unsubscribe function.
+     *
+     * @param options.responseChannel  Channel name HL uses in response messages
+     *   when it differs from `subscription.type` (e.g. subscribe as
+     *   "activeAssetCtx" but receive on "activeSpotAssetCtx").
+     */
+    subscribe(subscription: {
+        type: string;
+        [key: string]: unknown;
+    }, onData: (data: unknown) => void, options?: {
+        responseChannel?: string;
+    }): () => void;
+    /** Tear down WebSocket and clear all subscriptions. */
+    closeWs(): void;
+    private ensureWs;
+    private wsReconnectAttempts;
+    private wsReconnectTimer;
+    private wsDestroyed;
+    private scheduleReconnect;
+    private infoPost;
+    private doInfoPost;
+    private exchangePost;
+}
+
+/**
+ * Resolve side names for an outcome by ID.
+ * Returns [side0Name, side1Name] (e.g. ["Yes", "No"] or ["Hypurr", "Usain Bolt"]).
+ * Returns null if the outcome ID is unknown.
+ */
+type SideNameResolver = (outcomeId: number) => [string, string] | null;
+declare class HIP4EventAdapter implements PredictionEventAdapter {
+    private readonly client;
+    private cache;
+    private metaCache;
+    private static readonly CACHE_TTL_MS;
+    /** Side names from outcomeMeta. Populated once, never cleared (sideSpecs don't change). */
+    private sideNames;
+    constructor(client: HIP4Client);
+    /** Returns a resolver function that looks up side names by outcome ID. */
+    getSideNameResolver(): SideNameResolver;
+    /** Ensure sideNames are loaded. Call before using the resolver if data may not be cached yet. */
+    ensureSideNames(): Promise<void>;
+    /**
+     * Subscribe to live outcome-meta updates (HIP-4 catalog changes).
+     *
+     * Each frame is an array of one or more updates. The handler is invoked
+     * once per update with the discriminated payload. Internally we also:
+     *   - extend `sideNames` for newly created outcomes (so `getSideNameResolver`
+     *     returns real names instead of falling back to "Side 0/1")
+     *   - invalidate the events + markets caches so the next read refetches
+     *     and reflects the change
+     *
+     * Returns an unsubscribe callback.
+     */
+    subscribeOutcomeMetaUpdates(onData: (update: HLWsOutcomeMetaUpdate) => void): Unsubscribe;
+    private applyMetaUpdate;
+    private populateSideNames;
+    fetchEvents(params?: {
+        category?: string;
+        active?: boolean;
+        limit?: number;
+        offset?: number;
+        query?: string;
+    }): Promise<PredictionEvent[]>;
+    fetchEvent(eventId: string): Promise<PredictionEvent>;
+    fetchCategories(): Promise<PredictionCategory[]>;
+    /**
+     * Fetch and classify all HIP-4 markets.
+     *
+     * Supports optional type filtering, groupBy, limit, and offset.
+     * Results are cached for CACHE_TTL_MS alongside the events cache.
+     */
+    fetchMarkets(params?: FetchMarketsParams): Promise<HIP4Market[] | MarketsByType | MarketsByQuestion>;
+    private loadMarkets;
+    private loadEvents;
+}
+
+declare class HIP4Auth implements PredictionAuthAdapter {
+    private state;
+    private signer;
+    initAuth(walletAddress: string, signer: unknown): Promise<PredictionAuthState>;
+    getAuthStatus(): PredictionAuthState;
+    clearAuth(): void;
+    /** Internal - used by the trading adapter to get the active signer */
+    getSigner(): HIP4Signer | null;
+}
+
+interface SplitOutcomeParams {
+    /** Outcome ID (numeric, matches HL's `outcomeMeta.outcomes[].outcome`). */
+    outcome: number;
+    /** Amount of quote tokens to split. Decimal string (e.g. "12.5"). */
+    amount: string;
+}
+interface MergeOutcomeParams {
+    outcome: number;
+    /** Amount of paired Yes+No shares to merge. `null` means max available. */
+    amount: string | null;
+}
+interface MergeQuestionParams {
+    /** Question ID (numeric, matches HL's `outcomeMeta.questions[].question`). */
+    question: number;
+    /** Yes-share count to redeem from each member outcome. `null` = max. */
+    amount: string | null;
+}
+interface NegateOutcomeParams {
+    question: number;
+    /** Source outcome whose No shares are being converted. */
+    outcome: number;
+    /** No-share count to convert. */
+    amount: string;
+}
+/**
+ * @deprecated Use {@link formatPrice} from pricing.ts instead.
+ */
+declare function formatPredictionPrice(price: number): string;
+interface TradingAdapterConfig {
+    builderAddress?: string;
+    builderFee?: number;
+}
+declare class HIP4TradingAdapter implements PredictionTradingAdapter {
+    private readonly client;
+    private readonly auth;
+    private readonly builderAddress?;
+    private readonly builderFee?;
+    constructor(client: HIP4Client, auth: HIP4Auth, config?: TradingAdapterConfig);
+    private buildOrderWire;
+    placeOrder(params: PredictionOrderParams): Promise<PredictionOrderResult>;
+    placeOrders(params: PredictionOrderParams[]): Promise<PredictionBatchOrderResult>;
+    cancelOrder(params: PredictionCancelParams[]): Promise<HLCancelResponse>;
+    modifyOrder(params: PredictionModifyParams): Promise<PredictionOrderResult>;
+    /** Split X quote tokens into X Yes + X No shares of one outcome. */
+    splitOutcome(params: SplitOutcomeParams): Promise<WalletActionResult$1>;
+    /** Merge X Yes + X No shares of one outcome back into X quote tokens. */
+    mergeOutcome(params: MergeOutcomeParams): Promise<WalletActionResult$1>;
+    /** Merge X Yes shares from every outcome of a question into X quote tokens. */
+    mergeQuestion(params: MergeQuestionParams): Promise<WalletActionResult$1>;
+    /**
+     * Convert X No shares of one outcome into X Yes shares of every *other*
+     * outcome belonging to the same question (including the fallback). The
+     * wire sub-key is `negateOutcome` - confirmed against HL's own testnet
+     * "Convert Outcomes" UI; their docs body's `negateQuestion` is a typo.
+     */
+    negateOutcome(params: NegateOutcomeParams): Promise<WalletActionResult$1>;
+    private submitUserOutcomeAction;
+    scheduleCancel(time: number | null): Promise<WalletActionResult$1>;
+}
+
+interface UsdClassTransferParams {
+    amount: string;
+    toPerp: boolean;
+}
+declare const USDH_SPOT_INDEX_TESTNET = 1338;
+declare const USDH_SPOT_INDEX_MAINNET = 230;
+declare const USDH_ASSET_ID_TESTNET: number;
+declare const USDH_ASSET_ID_MAINNET: number;
+declare const USDH_SPOT_PAIR_TESTNET = "@1338";
+declare const USDH_SPOT_PAIR_MAINNET = "@230";
+declare const USDH_TOKEN_INDEX_MAINNET = 360;
+declare const USDH_TOKEN_INDEX_TESTNET = 1452;
+declare const USDH_TOKEN_HASH_MAINNET = "0x54e00a5988577cb0b0c9ab0cb6ef7f4b";
+declare const USDH_TOKEN_HASH_TESTNET = "0x471fd4480bb9943a1fe080ab0d4ff36c";
+declare const USDH_HL_TOKEN_MAINNET = "USDH:0x54e00a5988577cb0b0c9ab0cb6ef7f4b";
+declare const USDH_HL_TOKEN_TESTNET = "USDH:0x471fd4480bb9943a1fe080ab0d4ff36c";
+declare const USDH_EVM_ADDRESS_MAINNET = "0x111111a1a0667d36bD57c0A9f569b98057111111";
+declare const USDH_EVM_ADDRESS_TESTNET = "0x22222245c52c817F95b74664Ae8546B490222222";
+declare const USDH_CORE_DECIMALS = 8;
+declare const USDH_EVM_DECIMALS = 6;
+/** HL spot USDC token identifier. Mainnet index 0, testnet index 0.
+ *  Format: `"NAME:0xHEX"` per sendToEvmWithData / spotSend spec. */
+declare const USDC_HL_TOKEN_MAINNET = "USDC:0x6d1e7cde53ba9467b783cb7c530ce054";
+declare const USDC_HL_TOKEN_TESTNET = "USDC:0xeb62eee3685fc4c43992febcd9e75443";
+/** @deprecated Use network-specific variants (TESTNET/MAINNET) instead */
+declare const USDH_ASSET_ID: number;
+/** @deprecated Use network-specific variants (TESTNET/MAINNET) instead */
+declare const USDH_SPOT_PAIR = "@1338";
+interface WithdrawParams {
+    destination: string;
+    amount: string;
+}
+interface UsdSendParams {
+    destination: string;
+    amount: string;
+}
+interface SpotSendParams {
+    destination: string;
+    /** Token identifier in Hyperliquid format "NAME:0xHEX" (e.g. "USDH:0x471fd4480bb9943a1fe080ab0d4ff36c"). */
+    token: string;
+    amount: string;
+}
+interface SendAssetParams {
+    destination: string;
+    /** Token identifier "NAME:0xHEX". */
+    token: string;
+    amount: string;
+    /** Source silo: `""` = perp USDC, `"spot"` = spot, or a perp DEX name. Defaults to `"spot"`. */
+    sourceDex?: string;
+    /** Destination silo: `""` = perp USDC / EVM system address, `"spot"` = spot, or a perp DEX name. Defaults to `""`. */
+    destinationDex?: string;
+    /** Sub-account to debit. Empty string = main account. */
+    fromSubAccount?: string;
+}
+interface SendSpotTokenToEvmParams {
+    /** Token index from `info: spotMeta → tokens[].index`. NOT the spot-pair
+     *  market index. Passing a pair index routes funds to the wrong token. */
+    tokenIndex: number;
+    /** Token identifier `"SYMBOL:0x<32-hex>"` from the same spotMeta entry. */
+    tokenId: string;
+    /** Decimal amount in the token's display decimals, as a string. */
+    amount: string;
+    /** HYPE bypasses index-derived address at `0x2222…2222`. */
+    isHype?: boolean;
+}
+interface SendToEvmWithDataParams {
+    /** Token identifier "NAME:0xHEX". */
+    token: string;
+    /** Decimal amount as a string, in the token's display decimals. */
+    amount: string;
+    /** Recipient on the destination chain (hex for EVM, base58 for Solana). */
+    destinationRecipient: string;
+    /** CCTP domain ID of the destination chain (0=Eth, 3=Arb, 6=Base, ...). */
+    destinationChainId: number;
+    /** Gas budget for the `coreReceiveWithData` call on HyperEVM. Empirical
+     *  ceiling of the Circle `CoreDepositWallet` path is ~289k; 350k is a
+     *  safe default. Under-provisioning reverts and funds land badly. */
+    gasLimit: number;
+    /** Hook data passed to the linked contract. "0x" = default Circle forwarder
+     *  on Arbitrum. Non-magic bytes disable forwarding (user self-attests on
+     *  destination, not recommended for UX). */
+    data?: string;
+    /** Hyperliquid perp dex name or "spot". Defaults to "spot". */
+    sourceDex?: string;
+    /** Recipient address encoding. Defaults to "hex". */
+    addressEncoding?: "hex" | "base58";
+}
+interface WalletActionResult {
+    success: boolean;
+    error?: string;
+    filledSz?: string;
+    avgPx?: string;
+    /**
+     * Order id of the resulting fill (set only on `success: true` for actions
+     * that produce a fill - `buyUsdh`, `sellUsdh`, etc). Callers use this to
+     * look up the realized fee in `userFills` / `userFillsByTime`, since the
+     * synchronous order ack does not carry fee.
+     */
+    oid?: number;
+}
+declare class HIP4WalletAdapter {
+    private readonly client;
+    private readonly auth;
+    private signer;
+    constructor(client: HIP4Client, auth: HIP4Auth);
+    setSigner(signer: HIP4Signer | {
+        address: string;
+        signTypedData: (...args: unknown[]) => Promise<string>;
+    }): void;
+    buyUsdh(amount: string): Promise<WalletActionResult>;
+    sellUsdh(amount: string): Promise<WalletActionResult>;
+    transferToSpot(amount: string): Promise<WalletActionResult>;
+    transferToPerps(amount: string): Promise<WalletActionResult>;
+    usdClassTransfer(params: UsdClassTransferParams): Promise<WalletActionResult>;
+    withdraw(params: WithdrawParams): Promise<WalletActionResult>;
+    usdSend(params: UsdSendParams): Promise<WalletActionResult>;
+    spotSend(params: SpotSendParams): Promise<WalletActionResult>;
+    /**
+     * Unified-account-compatible transfer primitive. Supersedes `spotSend`,
+     * `usdSend`, `usdClassTransfer`, and `subAccountSpotTransfer` when the
+     * account is in `unifiedAccount` or `portfolioMargin` abstraction mode
+     * (where silo-specific actions return "Action disabled when unified
+     * account is active").
+     *
+     * Use cases:
+     *   - User → user spot transfer: `sourceDex: "spot", destinationDex: "spot"`
+     *   - Core → HyperEVM bridge: `destination = systemAddress`, both dex = `""`
+     *   - Spot → perp silo move: `sourceDex: "spot", destinationDex: ""`
+     */
+    sendAsset(params: SendAssetParams): Promise<WalletActionResult>;
+    /**
+     * Move a spot token from HyperCore to HyperEVM.
+     *
+     * Mechanism: `sendAsset` to the token's system address, with
+     * `sourceDex = "spot"` and `destinationDex = ""`. HL credits the sender's
+     * HyperEVM address by calling `transfer(sender, amount)` on the token's
+     * linked ERC-20 contract. No hook data, no CCTP - the token stays as the
+     * same token on HyperEVM.
+     *
+     * Why `sendAsset` and not `spotSend`: `spotSend` is rejected under
+     * `unifiedAccount` / `portfolioMargin` abstraction modes with "Action
+     * disabled when unified account is active". Unified is the app default
+     * for new accounts, so `sendAsset` is the only flow that works for both
+     * modes.
+     *
+     * Use this for USDH (and any non-USDC spot token). For USDC destinations
+     * on other EVM chains, use `sendUsdcToEvm` instead (CCTP is strictly
+     * cheaper + faster than sendAsset-to-HyperEVM + bridge).
+     *
+     * HYPE is the documented exception: callers must set `isHype: true` so
+     * the destination resolves to the hardcoded `0x2222…2222` slot rather
+     * than the index-derived address.
+     */
+    sendSpotTokenToEvm(params: SendSpotTokenToEvmParams): Promise<WalletActionResult>;
+    /**
+     * Transfer a spot token from HyperCore to the EVM side, invoking the
+     * linked contract's `coreReceiveWithData` hook with user-provided data.
+     *
+     * For Circle-managed tokens (USDC), this bridges via CCTP directly to
+     * `destinationChainId` - `destinationRecipient` receives USDC there. No
+     * secondary `withdraw3` or Across hop needed to land on Arbitrum.
+     *
+     * Fee model: HyperEVM gas (`gasLimit × baseFee × HYPE/USDC_oracle`,
+     * deducted from L1 USDC) + Circle forwarder fee on destination (0.2 USDC
+     * flat, subtracted from amount). CCTP protocol fee is 0.
+     */
+    sendToEvmWithData(params: SendToEvmWithDataParams): Promise<WalletActionResult>;
+    /**
+     * Convenience wrapper: `sendToEvmWithData` with the USDC token string
+     * for the current network auto-filled. Circle's CoreDepositWallet picks
+     * up the call and CCTPs USDC to `destinationChainId`.
+     */
+    sendUsdcToEvm(params: Omit<SendToEvmWithDataParams, "token">): Promise<WalletActionResult>;
+    private executeSpotOrder;
+    /**
+     * Set a referral code on Hyperliquid.
+     * Uses L1 agent signing (requires auth to be initialized).
+     */
+    setReferrer(code: string): Promise<WalletActionResult>;
+    private executeUserSigned;
+}
+
+declare class HyperliquidHip4Adapter implements PredictionsAdapter {
+    readonly id = "hyperliquid";
+    readonly name: string;
+    readonly events: HIP4EventAdapter;
+    readonly marketData: PredictionsAdapter["marketData"];
+    readonly account: PredictionsAdapter["account"];
+    readonly trading: HIP4TradingAdapter;
+    readonly auth: PredictionsAdapter["auth"];
+    readonly wallet: HIP4WalletAdapter;
+    readonly client: HIP4Client;
+    private readonly _marketData;
+    constructor(config?: CreateHIP4AdapterConfig);
+    initialize(): Promise<void>;
+    destroy(): void;
+}
+
+/** Configuration for creating a HIP-4 prediction market adapter. */
+interface CreateHIP4AdapterConfig {
+    testnet?: boolean;
+    infoUrl?: string;
+    exchangeUrl?: string;
+    /**
+     * Builder address for fee collection.
+     * When set, all orders will include this builder address.
+     */
+    builderAddress?: string;
+    /**
+     * Builder fee in tenths of a basis point (0-1000).
+     * 0 = no fee. 100 = 0.1%. 1000 = 1.0% (maximum).
+     */
+    builderFee?: number;
+    /** Optional logger. Default: no-op. */
+    logger?: (level: "debug" | "info" | "warn" | "error", msg: string, data?: unknown) => void;
+}
+/** Create a PredictionsAdapter backed by Hyperliquid HIP-4 spot markets. */
+declare function createHIP4Adapter(config?: CreateHIP4AdapterConfig): HyperliquidHip4Adapter;
+
+/** Build EIP-712 typed data for an agent-wallet approval signature. */
+declare function getAgentApprovalTypedData(agentAddress: `0x${string}`, agentName: string, nonce: number, isMainnet?: boolean): {
+    domain: {
+        readonly name: "HyperliquidSignTransaction";
+        readonly version: "1";
+        readonly chainId: 42161 | 421614;
+        readonly verifyingContract: `0x${string}`;
+    };
+    types: {
+        "HyperliquidTransaction:ApproveAgent": {
+            name: string;
+            type: string;
+        }[];
+    };
+    primaryType: "HyperliquidTransaction:ApproveAgent";
+    message: {
+        hyperliquidChain: string;
+        agentAddress: `0x${string}`;
+        agentName: string;
+        nonce: bigint;
+    };
+};
+/** Build EIP-712 typed data for a builder-fee approval signature. */
+declare function getBuilderFeeApprovalTypedData(builderAddress: `0x${string}`, maxFeeRate: string, nonce: number, isMainnet?: boolean): {
+    domain: {
+        readonly name: "HyperliquidSignTransaction";
+        readonly version: "1";
+        readonly chainId: 42161 | 421614;
+        readonly verifyingContract: `0x${string}`;
+    };
+    types: Record<string, {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: string;
+    message: {
+        hyperliquidChain: string;
+        maxFeeRate: string;
+        builder: `0x${string}`;
+        nonce: bigint;
+    };
+};
+/** Submit a signed builder-fee approval to the Hyperliquid exchange API. */
+declare function submitBuilderFeeApproval(signature: `0x${string}`, builderAddress: `0x${string}`, maxFeeRate: string, nonce: number, isMainnet?: boolean, exchangeUrl?: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/** Submit a signed agent-approval transaction to the Hyperliquid exchange API. */
+declare function submitAgentApproval(signature: `0x${string}`, agentAddress: `0x${string}`, agentName: string, nonce: number, isMainnet?: boolean, exchangeUrl?: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+
+interface ParsedDescription {
+    class: "priceBinary";
+    underlying: string;
+    expiry: Date;
+    targetPrice: number;
+    period: string;
+}
+interface ParsedPriceBucketDescription {
+    class: "priceBucket";
+    underlying: string;
+    expiry: Date;
+    /** Sorted ascending price thresholds. N thresholds → N+1 buckets. */
+    priceThresholds: number[];
+    period: string;
+}
+/**
+ * A single active HIP-4 recurring price binary market.
+ *
+ * Coin naming conventions:
+ *   #<coinNum>    - API coin used in allMids, l2Book, candle, recentTrades
+ *   @<pairNum>    - Token pair (EMPTY orderbook  - not traded directly)
+ *   +<coinNum>    - Token balance key in spotClearinghouseState
+ *   a = 100000000 + coinNum  - order asset field
+ */
+interface PriceBinaryMarket {
+    outcomeId: number;
+    underlying: string;
+    targetPrice: number;
+    expiry: Date;
+    period: string;
+    yesCoinNum: number;
+    noCoinNum: number;
+    yesCoin: string;
+    noCoin: string;
+    yesAsset: number;
+    noAsset: number;
+}
+/**
+ * Parse a pipe-delimited outcome description string.
+ *
+ * Format: "class:priceBinary|underlying:BTC|expiry:20260310-0300|targetPrice:66200|period:15m"
+ *
+ * Returns null if not a valid priceBinary description.
+ */
+declare function parseDescription(desc: string): ParsedDescription | null;
+/**
+ * Parse a pipe-delimited priceBucket description string.
+ *
+ * Format: "class:priceBucket|underlying:BTC|expiry:20260505-1700|priceThresholds:81015.3,81258.7|period:15m"
+ *
+ * Returns null if not a valid priceBucket description.
+ */
+declare function parsePriceBucketDescription(desc: string): ParsedPriceBucketDescription | null;
+interface OutcomeMeta {
+    outcomes: Array<{
+        outcome: number;
+        name: string;
+        description: string;
+        sideSpecs: Array<{
+            name: string;
+        }>;
+    }>;
+    questions: unknown[];
+}
+/**
+ * Discover all active priceBinary markets from outcomeMeta + allMids.
+ *
+ * A market is included when:
+ * 1. Its description parses as class:priceBinary
+ * 2. Expiry is in the future
+ * 3. A live price exists in mids for the underlying
+ */
+declare function discoverPriceBinaryMarkets(meta: OutcomeMeta, mids: Record<string, string>): PriceBinaryMarket[];
+/** Minutes until market expires. Negative means already expired. */
+declare function timeToExpiry(market: PriceBinaryMarket): number;
+/**
+ * Parse a period string to minutes.
+ * "1m"→1, "5m"→5, "15m"→15, "1h"→60, "4h"→240, "1d"→1440
+ */
+declare function periodMinutes(period: string): number;
+/** Human-readable label: "BTC-1d", "HYPE-15m" */
+declare function formatMarketLabel(market: PriceBinaryMarket): string;
+
+interface QuestionEntry {
+    question: HLQuestion;
+    isFallback: boolean;
+    /** Index in question.namedOutcomes; -1 for fallback */
+    bucketIndex: number;
+    /** Pre-parsed priceBucket spec on the question, if any */
+    bucket: ParsedPriceBucketDescription | null;
+}
+/**
+ * Pre-computed lookup from outcomeId → parent question metadata.
+ * Reuse across multiple `classifyOutcome` calls to avoid O(N) rebuilds per
+ * call (see {@link buildQuestionIndex}).
+ */
+interface QuestionIndex {
+    /** outcomeId → entry */
+    byOutcome: Map<number, QuestionEntry>;
+}
+/**
+ * Build the question index once and reuse it when classifying many outcomes
+ * via `classifyOutcome`. `classifyAllOutcomes` builds its own index
+ * internally - this helper exists for callers that need per-outcome
+ * classification in a loop.
+ */
+declare function buildQuestionIndex(questions: HLQuestion[]): QuestionIndex;
+/**
+ * Resolve the [lowerBound, upperBound) for a bucket within a priceBucket
+ * question, given the question's `priceThresholds`. Bounds are half-open:
+ * `lowerBound` is inclusive, `upperBound` is exclusive.
+ *
+ *   bucketIndex < 0           → both null (fallback bucket)
+ *   bucketIndex === 0         → lowerBound is null (unbounded below)
+ *   bucketIndex >= len        → upperBound is null (unbounded above)
+ *
+ * @param thresholds Sorted list of bucket boundaries from the question.
+ * @param bucketIndex Position in the question's namedOutcomes array.
+ */
+declare function getPriceBucketBounds(thresholds: readonly number[], bucketIndex: number): {
+    lowerBound: number | null;
+    upperBound: number | null;
+};
+/**
+ * Classify a single HLOutcome into a typed HIP4Market.
+ *
+ * Detection priority:
+ *   1. Description parses as class:priceBinary → defaultBinary
+ *   2. Outcome is in a question → multiOutcome (or priceBucket)
+ *   3. Everything else → labelledBinary
+ *
+ * For batch classification, prefer `classifyAllOutcomes` (builds the index
+ * once). When calling `classifyOutcome` repeatedly, pass a pre-built
+ * `precomputedIndex` to avoid rebuilding it on every call:
+ *
+ *     const index = buildQuestionIndex(questions);
+ *     for (const o of outcomes) classifyOutcome(o, questions, index);
+ */
+declare function classifyOutcome(outcome: HLOutcome, questions: HLQuestion[], precomputedIndex?: QuestionIndex): HIP4Market;
+/**
+ * Classify all outcomes in one pass.
+ * Builds the question index once and reuses it.
+ */
+declare function classifyAllOutcomes(outcomes: HLOutcome[], questions: HLQuestion[]): HIP4Market[];
+
+declare const MIN_NOTIONAL = 10;
+declare function computeTickSize(price: number): number;
+declare function roundToTick(price: number): number;
+declare function formatPrice(price: number): string;
+declare function stripZeros(s: string): string;
+declare function getMinShares(markPx: number): number;
+
+/** HYPE is the one documented exception to the 0x20-prefix rule. */
+declare const HYPE_CORE_EVM_SYSTEM_ADDRESS: "0x2222222222222222222222222222222222222222";
+/**
+ * Upper bound on derivable token indices. 19-byte big-endian can hold values
+ * up to 2^152 - 1, which overflows JS numbers. We clamp to MAX_SAFE_INTEGER
+ * so the derivation math stays exact; every real Hyperliquid token index is
+ * orders of magnitude below this.
+ */
+declare const MAX_CORE_EVM_TOKEN_INDEX: number;
+/**
+ * Derive the HyperCore system address for a given spot token index.
+ *
+ * IMPORTANT: `tokenIndex` is the value from `info: spotMeta → tokens[].index`,
+ * not the spot-pair/market index from `universe[]`. Passing the wrong one
+ * sends funds to an unrelated token's system address.
+ *
+ * For HYPE, import `HYPE_CORE_EVM_SYSTEM_ADDRESS` directly - there is no
+ * derivable address.
+ */
+declare function deriveCoreEvmSystemAddress(tokenIndex: number): string;
+
+/** HL-canonical gas budget for Core→HyperEVM system-tx credit. Fixed, from
+ *  the docs. Over/under-provisioning at the action level is not applicable
+ *  - the protocol uses exactly this value. */
+declare const CORE_TO_EVM_GAS_LIMIT = 200000n;
+interface CoreToEvmFeeInputs {
+    /** HyperEVM block baseFee in wei. Prefer a median-over-history sample
+     *  (`medianBaseFeeWei`) to stay robust against single-block MEV spikes. */
+    readonly baseFeeWei: bigint;
+    /** User's HYPE balance on HL Core spot, as a decimal number. */
+    readonly hypeCoreSpotBalance: number;
+    /** HYPE/USDC spot `markPx` in USD. Source: HL info endpoint,
+     *  `{"type":"spotMetaAndAssetCtxs"}`, pair `@107` mainnet / `@1035` testnet.
+     *  Using midPx or perp mark diverges from HL's actual debit. */
+    readonly hypeSpotMarkPxUsd: number;
+    /** USD price of the token being sent (USDH ≈ 1.0). Used only in the
+     *  source-token fallback path - ignored when the user has HYPE. */
+    readonly sourceTokenPriceUsd: number;
+}
+interface CoreToEvmFeeBreakdown {
+    /** Which balance HL will actually debit. */
+    readonly currency: "HYPE" | "source";
+    /** Fee amount if debited in HYPE. Zero in the source-token path. */
+    readonly amountHype: number;
+    /** Fee amount if debited in the source token. Zero in the HYPE path. */
+    readonly amountSourceToken: number;
+    /** USD-equivalent of the fee. Identical between both paths. */
+    readonly usd: number;
+    /** Echoed back for UI tooltips / audit. */
+    readonly gasLimit: bigint;
+    readonly baseFeeWei: bigint;
+}
+/**
+ * Estimate the Core→HyperEVM transfer fee and which balance will be debited.
+ *
+ * Pure, synchronous. Call once per quote with freshly-fetched inputs.
+ */
+declare function estimateCoreToEvmFee(inputs: CoreToEvmFeeInputs): CoreToEvmFeeBreakdown;
+/**
+ * Median over an `eth_feeHistory` baseFee sample.
+ *
+ * Why median, not max: a single MEV-saturated block can spike baseFee briefly
+ * before mean-reverting under EIP-1559's 12.5%-per-block decay. `max` lets
+ * one outlier dominate the UI quote; `median` is robust in both directions
+ * while still tracking genuine trends over a few blocks' lag.
+ *
+ * Why not a safety multiplier on top: the fee we display is the fee the
+ * user pays. Padding the display hides the true accounting - users compare
+ * UI fee vs ledger debit and notice. Accuracy over pessimism.
+ */
+declare function medianBaseFeeWei(samples: readonly bigint[]): bigint;
+
+declare const HYPE_USDC_SPOT_PAIR_MAINNET: "@107";
+declare const HYPE_USDC_SPOT_PAIR_TESTNET: "@1035";
+interface SelectHypeSpotMarkPxOptions {
+    readonly testnet?: boolean;
+}
+/**
+ * Pull the HYPE/USDC `markPx` (USD) from a bulk spotAssetCtxs store map.
+ *
+ * Returns `null` when the pair entry is missing or its markPx is not a
+ * positive finite number. Callers should treat `null` as "price not yet
+ * available" (pre-WS-hydration) rather than zero.
+ *
+ * Deliberately does NOT fall back to midPx when markPx is absent - midPx
+ * diverges from markPx during volatile periods and using it would misprice
+ * the fee relative to HL's actual debit.
+ */
+declare function selectHypeSpotMarkPx(ctxs: Record<string, HLWsSpotAssetCtxItem | undefined>, options?: SelectHypeSpotMarkPxOptions): number | null;
+interface SpotMetaShape {
+    readonly tokens: ReadonlyArray<{
+        name: string;
+        index: number;
+    }>;
+    readonly universe: ReadonlyArray<{
+        index: number;
+        tokens: readonly [number, number];
+    }>;
+}
+/**
+ * Discover the HYPE/USDC pair coin string (`@N`) dynamically from spotMeta.
+ *
+ * Belt-and-suspenders against HL renumbering. The hardcoded constants above
+ * are the steady-state truth; this helper lets a caller recover gracefully
+ * if HL ever reindexes a pair. USDC is always token index 0.
+ */
+declare function findHypeUsdcSpotPairCoin(meta: SpotMetaShape): string | null;
+
+interface PriceFeedCandle {
+    /** Unix timestamp in **seconds** (matches fetchCandles convention). */
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/** Convert an interval string like `"1h"` to milliseconds. Falls back to 1 h. */
+declare function intervalToMs(interval: string): number;
+/** Floor a millisecond timestamp to its candle boundary (in ms). */
+declare function candleBoundaryMs(timestampMs: number, intervalMs: number): number;
+/**
+ * Process a price tick against a mutable candle array.
+ * Either updates the last candle's OHLC or appends a new one.
+ * Returns `true` if the tick was applied (not stale).
+ *
+ * Internal mutable accumulator - callers own the array and snapshot via
+ * `candles.map(c => ({ ...c }))` before emitting to consumers.
+ */
+declare function processTick(candles: PriceFeedCandle[], price: number, timestampMs: number, intervalMs: number): boolean;
+
+interface PerpPriceFeedOptions {
+    /** Candle interval string accepted by Hyperliquid (e.g. "1m", "5m", "1h", "1d"). Default: `"1h"`. */
+    interval?: string;
+    /** How far back to fetch historical candles, in milliseconds. Default: 14 days. */
+    lookbackMs?: number;
+}
+interface PerpPriceFeedSnapshot {
+    coin: string;
+    /** Full candle array (historical + live). */
+    candles: PriceFeedCandle[];
+    /** Latest mid-price received (may be newer than the last candle close). */
+    currentMid: number | null;
+    /** `false` until the initial candle fetch resolves. */
+    ready: boolean;
+}
+/**
+ * Create a live price feed for a perpetual market coin.
+ *
+ * 1. Subscribes to `allMids` for live mid-price updates (currentMid).
+ * 2. Subscribes to `candle` WS for authoritative OHLCV candle updates.
+ * 3. Fetches historical candles for the lookback window.
+ * 4. After historical fetch, replays buffered data and emits snapshots
+ *    on every candle WS update or allMids tick.
+ *
+ * Returns an **unsubscribe** function - call it to stop the feed.
+ */
+declare function createPerpPriceFeed(client: HIP4Client, coin: string, onSnapshot: (snapshot: PerpPriceFeedSnapshot) => void, options?: PerpPriceFeedOptions): () => void;
+
+interface PriceFeedOptions {
+    /** Candle interval string accepted by Hyperliquid (e.g. "1m", "5m", "1h", "1d"). Default: `"1h"`. */
+    interval?: string;
+    /** How far back to fetch historical candles, in milliseconds. Default: 14 days. */
+    lookbackMs?: number;
+    /** Which side to track - 0 for Yes, 1 for No. Default: `0`. */
+    sideIndex?: number;
+}
+interface PriceFeedSnapshot {
+    marketId: string;
+    /** Full candle array (historical + live). */
+    candles: PriceFeedCandle[];
+    /** Latest mid-price received (may be newer than the last candle close). */
+    currentMid: number | null;
+    /** `false` until the initial candle fetch resolves. */
+    ready: boolean;
+}
+/**
+ * Create a live price feed for a single prediction market.
+ *
+ * 1. Immediately subscribes to real-time mid-price updates (ticks are buffered
+ *    until the historical fetch completes).
+ * 2. Fetches historical candles for the lookback window.
+ * 3. Merges buffered ticks into the candle array.
+ * 4. On every subsequent tick, updates the latest candle or appends a new one,
+ *    then emits a {@link PriceFeedSnapshot}.
+ *
+ * Returns an **unsubscribe** function - call it to stop the feed.
+ */
+declare function createPriceFeed(marketData: PredictionMarketDataAdapter, marketId: string, onSnapshot: (snapshot: PriceFeedSnapshot) => void, options?: PriceFeedOptions): Unsubscribe;
+
+interface TradeCostResult {
+    readonly estimatedCost: number;
+    readonly potentialReturn: number;
+    readonly displayShares: number;
+}
+declare function computeEstimatedCost(tokenAmount: number, orderType: "market" | "limit", limitPriceCents: number | null, marketPriceCents?: number): number;
+declare function computeTradeCost(params: {
+    tokenAmount: number;
+    orderType: "market" | "limit";
+    limitPriceCents: number | null;
+    marketPriceCents?: number;
+}): TradeCostResult;
+declare function computePotentialReturn(tokenAmount: number): number;
+
+export { ALL_DEXS, CORE_TO_EVM_GAS_LIMIT, type CoreToEvmFeeBreakdown, type CoreToEvmFeeInputs, type CreateHIP4AdapterConfig, FetchMarketsParams, HIP4Client, type HIP4ClientConfig, HIP4EventAdapter, HIP4Market, HIP4Signer, HIP4TradingAdapter, HIP4WalletAdapter, HLApiError, HLCancelResponse, HLCandle, HLExtraAgent, HLFill, HLOutcome, HLOutcomeMeta, HLQuestion, HLReferralState, HLSettledOutcome, HLSignature, HLSpotClearinghouseState, HLUserAbstraction, HLUserFees, HLUserRoleResponse, HLWsActivePerpAssetCtxData, HLWsActiveSpotAssetCtxData, HLWsAllMidsData, HLWsOutcomeMetaUpdate, HLWsSpotAssetCtxItem, HLWsSpotAssetCtxsData, HYPE_CORE_EVM_SYSTEM_ADDRESS, HYPE_USDC_SPOT_PAIR_MAINNET, HYPE_USDC_SPOT_PAIR_TESTNET, MAX_CORE_EVM_TOKEN_INDEX, MIN_NOTIONAL, MarketsByQuestion, MarketsByType, type MergeOutcomeParams, type MergeQuestionParams, type NegateOutcomeParams, type ParsedDescription, type ParsedPriceBucketDescription, type PerpPriceFeedOptions, type PerpPriceFeedSnapshot, type PredictionAccountAdapter, PredictionActivity, type PredictionAuthAdapter, PredictionAuthState, PredictionBatchOrderResult, PredictionCancelParams, PredictionCategory, PredictionEvent, type PredictionEventAdapter, type PredictionMarketDataAdapter, PredictionModifyParams, PredictionOrderBook, PredictionOrderParams, PredictionOrderResult, PredictionPosition, PredictionPrice, PredictionTrade, type PredictionTradingAdapter, type PredictionWalletAdapter, type PredictionsAdapter, type PriceBinaryMarket, type PriceFeedCandle, type PriceFeedOptions, type PriceFeedSnapshot, type QuestionIndex, type SelectHypeSpotMarkPxOptions, type SplitOutcomeParams, type SpotMetaShape, type SpotSendParams, type TradeCostResult, USDC_HL_TOKEN_MAINNET, USDC_HL_TOKEN_TESTNET, USDH_ASSET_ID, USDH_ASSET_ID_MAINNET, USDH_ASSET_ID_TESTNET, USDH_CORE_DECIMALS, USDH_EVM_ADDRESS_MAINNET, USDH_EVM_ADDRESS_TESTNET, USDH_EVM_DECIMALS, USDH_HL_TOKEN_MAINNET, USDH_HL_TOKEN_TESTNET, USDH_SPOT_INDEX_MAINNET, USDH_SPOT_INDEX_TESTNET, USDH_SPOT_PAIR, USDH_SPOT_PAIR_MAINNET, USDH_SPOT_PAIR_TESTNET, USDH_TOKEN_HASH_MAINNET, USDH_TOKEN_HASH_TESTNET, USDH_TOKEN_INDEX_MAINNET, USDH_TOKEN_INDEX_TESTNET, type Unsubscribe, type UsdClassTransferParams, type UsdSendParams, type WalletActionResult$1 as WalletActionResult, type WithdrawParams, buildQuestionIndex, candleBoundaryMs, classifyAllOutcomes, classifyOutcome, computeEstimatedCost, computePotentialReturn, computeTickSize, computeTradeCost, createHIP4Adapter, createPerpPriceFeed, createPriceFeed, deriveCoreEvmSystemAddress, discoverPriceBinaryMarkets, estimateCoreToEvmFee, findHypeUsdcSpotPairCoin, formatMarketLabel, formatPredictionPrice, formatPrice, getAgentApprovalTypedData, getBuilderFeeApprovalTypedData, getMinShares, getPriceBucketBounds, intervalToMs, isUsdClassTransferRequired, medianBaseFeeWei, outcomeCoin, parseDescription, parseOutcomeCoin, parsePriceBucketDescription, parseSideCoin, periodMinutes, processTick, roundToTick, selectHypeSpotMarkPx, sideAssetId, sideCoin, stripZeros, submitAgentApproval, submitBuilderFeeApproval, timeToExpiry };