@recoilpay/intent-core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,623 @@
+import { PublicClient, Hex, Address, Abi, WalletClient } from 'viem';
+
+/**
+ * Types mirroring the OIF aggregator HTTP API (camelCase JSON).
+ * Source of truth: oif-aggregator crates/types. Only the surface Phase 0 needs is
+ * modelled here; quote/order types arrive in Phase 2.
+ */
+/** A token a solver can source/deliver, from GET /api/v1/solvers. */
+interface SolverAsset {
+    address: string;
+    chainId: number;
+    symbol: string;
+    name: string;
+    decimals: number;
+}
+interface SolverSupportedAssets {
+    type: 'assets' | 'routes';
+    assets?: SolverAsset[];
+    source?: 'autoDiscovered' | 'config';
+}
+interface Solver {
+    solverId: string;
+    adapterId: string;
+    name: string;
+    description?: string;
+    endpoint: string;
+    status: string;
+    supportedAssets: SolverSupportedAssets;
+    createdAt?: string;
+    lastSeen?: string;
+}
+interface SolversResponse {
+    solvers: Solver[];
+    totalSolvers: number;
+}
+/** An ERC-7930 interop-encoded address. */
+type InteropAddress$1 = `0x${string}`;
+interface Input {
+    user: InteropAddress$1;
+    asset: InteropAddress$1;
+    amount?: string;
+    lock?: AssetLockReference;
+}
+interface Output {
+    receiver: InteropAddress$1;
+    asset: InteropAddress$1;
+    amount?: string;
+    calldata?: string;
+}
+interface AssetLockReference {
+    kind: 'the-compact' | 'rhinestone';
+    params?: unknown;
+}
+interface OriginSubmission {
+    mode: 'user' | 'protocol';
+    schemes?: ('erc4337' | 'permit2' | 'erc20-permit' | 'eip3009')[];
+}
+interface SolverOptions {
+    timeout?: number;
+    solverTimeout?: number;
+    minQuotes?: number;
+    solverSelection?: 'all' | 'sampled' | 'priority';
+    includeSolvers?: string[];
+    excludeSolvers?: string[];
+    sampleSize?: number;
+    priorityThreshold?: number;
+}
+interface IntentRequest {
+    intentType: 'oif-swap';
+    inputs: Input[];
+    outputs: Output[];
+    swapType?: 'exact-input' | 'exact-output';
+    preference?: 'price' | 'speed' | 'inputPriority' | 'trustMinimization';
+    partialFill?: boolean;
+    minValidUntil?: number;
+    failureHandling?: ('refund-automatic' | 'refund-claim' | 'needs-new-signature')[];
+    originSubmission?: OriginSubmission;
+    metadata?: unknown;
+}
+interface QuoteRequest {
+    user: InteropAddress$1;
+    intent: IntentRequest;
+    supportedTypes: string[];
+    metadata?: unknown;
+    solverOptions?: SolverOptions;
+}
+/** EIP-712 typed data carried by an order, ready to feed to a wallet signer. */
+interface OrderPayload {
+    signatureType: 'eip712';
+    domain: {
+        name: string;
+        version?: string;
+        chainId: string | number;
+        verifyingContract: string;
+    };
+    primaryType: string;
+    message: Record<string, unknown>;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+}
+interface Order {
+    type: string;
+    payload: OrderPayload;
+    metadata?: Record<string, unknown>;
+}
+interface QuotePreview {
+    inputs: Input[];
+    outputs: Output[];
+}
+/** A single quote from POST /api/v1/quotes. */
+interface Quote {
+    quoteId: string;
+    solverId: string;
+    order: Order;
+    partialFill: boolean;
+    preview: QuotePreview;
+    integrityChecksum: string;
+    provider?: string;
+    eta?: number;
+    failureHandling?: 'refund-automatic' | 'refund-claim' | 'needs-new-signature';
+    validUntil?: number;
+    metadata?: unknown;
+}
+interface AggregationMetadata {
+    totalDurationMs: number;
+    solverTimeoutMs: number;
+    globalTimeoutMs: number;
+    earlyTermination: boolean;
+    totalSolversAvailable: number;
+    solversQueried: number;
+    solversRespondedSuccess: number;
+    solversRespondedError: number;
+    solversTimedOut: number;
+    minQuotesRequired: number;
+    solverSelectionMode: string;
+}
+interface QuotesResponse {
+    quotes: Quote[];
+    totalQuotes: number;
+    metadata?: AggregationMetadata;
+}
+interface OrderRequest {
+    /** The full Quote object returned by /quotes. */
+    quoteResponse: Quote;
+    /** Hex signature produced by ./sign (scheme-prefixed). */
+    signature: string;
+    originSubmission?: OriginSubmission;
+    metadata?: unknown;
+}
+/**
+ * Order lifecycle: created → pending → executing → executed → settled →
+ * settling → finalized. Terminal: finalized | failed | refunded.
+ */
+type OrderStatus = 'created' | 'pending' | 'executing' | 'executed' | 'settled' | 'settling' | 'finalized' | 'refunded' | {
+    failed: [string, string];
+};
+interface AssetAmount {
+    asset: InteropAddress$1;
+    amount?: string;
+}
+interface Settlement {
+    type: 'escrow' | 'resourceLock';
+    data: unknown;
+}
+interface OrderResponse {
+    orderId: string;
+    status: OrderStatus;
+    createdAt: string;
+    updatedAt: string;
+    inputAmounts: AssetAmount[];
+    outputAmounts: AssetAmount[];
+    orderType: string;
+    settlement: Settlement;
+    quoteId?: string;
+    fillTransaction?: unknown;
+}
+
+/** Production aggregator. Override with `apiUrl` for staging or a local instance. */
+declare const DEFAULT_API_URL = "https://api.recoilpay.com";
+interface ApiOptions {
+    /** Aggregator base URL, without the `/api/v1` suffix. Defaults to production. */
+    apiUrl?: string;
+    /** Custom fetch (tests, server runtimes, proxies). Defaults to the global fetch. */
+    fetch?: typeof fetch;
+}
+/** One chain from GET /api/v1/chains. Keys are snake_case on this endpoint. */
+interface ChainInfo {
+    chain_id: number;
+    name: string;
+    rpc_url: string;
+    input_settler: string;
+    output_settler: string;
+    oracle: string;
+    permit2: string;
+    tokens: {
+        symbol: string;
+        address: string;
+        decimals: number;
+    }[];
+}
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+type ApiClient = ReturnType<typeof createApiClient>;
+/** Thin typed client for the RecoilPay aggregator's public API. */
+declare function createApiClient(options?: ApiOptions): {
+    /** The fetch this client uses (shared with the session's parser). */
+    fetch: typeof fetch;
+    /** Supported chains with RPC endpoints and settlement contracts. */
+    getChains(): Promise<ChainInfo[]>;
+    getSolvers: () => Promise<SolversResponse>;
+    /**
+     * Every asset an active solver can fill, de-duplicated — the set that
+     * decides whether an intent is executable right now.
+     */
+    getSupportedAssets(): Promise<SolverAsset[]>;
+    getQuotes: (req: QuoteRequest) => Promise<QuotesResponse>;
+    submitOrder: (req: OrderRequest) => Promise<OrderResponse>;
+    getOrder: (id: string) => Promise<OrderResponse>;
+};
+
+/** Intent parser types. See docs/intent-parser-design.md. */
+type IntentAction = 'swap' | 'send';
+type AmountKind = 'token' | 'usd';
+/** Output of the grammar parser, before resolution. Raw alias strings as typed. */
+interface RawIntent {
+    action: IntentAction;
+    amount: string | null;
+    amountKind: AmountKind;
+    tokenIn: string | null;
+    chainIn: string | null;
+    tokenOut: string | null;
+    chainOut: string | null;
+    recipient: string | null;
+}
+type ParseResult = {
+    ok: true;
+    intents: RawIntent[];
+} | {
+    ok: false;
+    offTemplate: true;
+    message: string;
+};
+type IssueField = 'amount' | 'tokenIn' | 'chainIn' | 'tokenOut' | 'chainOut' | 'recipient';
+type IssueKind = 'missing' | 'unknown' | 'unsupported';
+interface ValidationIssue {
+    field: IssueField;
+    kind: IssueKind;
+    message: string;
+}
+/** Fully resolved intent ready for the OIF order builder. */
+interface ResolvedIntent {
+    action: IntentAction;
+    user: string;
+    srcChainId: number;
+    dstChainId: number;
+    inputToken: string;
+    inputDecimals: number;
+    inputAmount: bigint;
+    outputToken: string;
+    recipient: string;
+}
+
+declare const TEMPLATE_HINT = "Try: swap <amount> <token> on <chain> for <token> on <chain> [to <address>] (e.g. swap 10 USDC on Base for ETH on Arbitrum) OR send <amount> <token> on <chain> to <address>";
+/** Hugging Face's OpenAI-compatible router: the endpoint @huggingface/inference's chatCompletion uses. */
+declare const HF_ROUTER_URL = "https://router.huggingface.co/v1/chat/completions";
+declare const DEFAULT_INTENT_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct";
+interface ParserOptions {
+    /**
+     * Your Hugging Face access token. Parsing runs in the browser, so this
+     * token is visible to anyone who loads your page: use a dedicated,
+     * inference-only token you can rotate. Without one, parsing is off.
+     */
+    hfAccessToken?: string | null;
+    /** Model on the Hugging Face router. */
+    model?: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Pulls intents out of a model reply. Models wrap JSON in code fences or add
+ * a sentence around it, so this takes a fenced block, or else the span from
+ * the first `{`/`[` to the last `}`/`]`.
+ */
+declare function extractIntents(content: string): ParseResult;
+/**
+ * Plain English → intents, by asking a model on Hugging Face from the
+ * browser. Never throws: every failure is `{ ok: false, message }` with text
+ * that can be shown to the user as-is.
+ */
+declare function parseIntent(text: string, options?: ParserOptions): Promise<ParseResult>;
+
+declare const SOLANA_CHAIN_IDS: ReadonlySet<number>;
+declare function chainName(chainId: number, info?: ChainInfo): string;
+declare function explorerUrl(chainId: number): string | undefined;
+/**
+ * The read-only chain access the flow needs: Permit2 allowance checks and
+ * waiting for the approval transaction. Anything viem-shaped fits.
+ */
+type ChainReader = Pick<PublicClient, 'readContract' | 'waitForTransactionReceipt'>;
+/** Readers built from the aggregator's own RPC endpoints, cached per chain. */
+declare function rpcReaders(chains: () => Promise<ChainInfo[]>): (chainId: number) => Promise<ChainReader | null>;
+
+/**
+ * Quote signing for the OIF escrow (Permit2) and EIP-3009 order types.
+ *
+ * Adapted from the aggregator demo's `quoteSigner.ts`, but signs with the
+ * CONNECTED WALLET (wagmi/viem `signTypedDataAsync`) instead of a raw private
+ * key. The quote response already carries the full EIP-712 typed data in
+ * `quote.order.payload` (domain / types / message / primaryType) — verified
+ * against the live aggregator for both order types — so we feed that straight
+ * to the wallet and apply the demo's per-scheme post-processing:
+ *   - `oif-escrow-v0` (Permit2 `PermitBatchWitnessTransferFrom`): prefix `0x00`.
+ *   - `oif-3009-v0` (EIP-3009 `ReceiveWithAuthorization` / `TransferWithAuthorization`):
+ *     prefix `0x01`, and for multi-input orders wrap the signature(s) in an ABI
+ *     `bytes[]` array.
+ *
+ * `oif-resource-lock-v0` (TheCompact) and `oif-generic-v0` are not implemented
+ * and throw clearly.
+ */
+
+/**
+ * Wallet typed-data signer. Pass wagmi's `signTypedDataAsync` (from
+ * `useSignTypedData`) or viem wallet client's `signTypedData`.
+ */
+type TypedDataSigner = (args: {
+    domain: Record<string, unknown>;
+    types: Record<string, ReadonlyArray<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}) => Promise<Hex>;
+/**
+ * Sign a quote with the connected wallet.
+ *
+ * @param quote - the full Quote object returned by /quotes
+ * @param signTypedDataAsync - wagmi/viem typed-data signer (uses connected wallet)
+ * @returns the scheme-prefixed signature to put in the order's `signature` field
+ */
+declare function signQuote(quote: Quote, signTypedDataAsync: TypedDataSigner): Promise<Hex>;
+
+/**
+ * Everything the intent flow needs from a wallet. Deliberately small so any
+ * stack can supply it: wagmi, a viem WalletClient (see `viemWallet`), an
+ * embedded wallet SDK, or a test double.
+ */
+interface IntentWallet {
+    /** The connected EVM account. */
+    address: Address;
+    /** Solana account, when the host also has one connected (Solana-destination swaps). */
+    solanaAddress?: string | null;
+    getChainId(): Promise<number>;
+    switchChain(chainId: number): Promise<void>;
+    /** EIP-712 signing. `types` never includes `EIP712Domain`. */
+    signTypedData: TypedDataSigner;
+    writeContract(req: {
+        chainId: number;
+        address: Address;
+        abi: Abi;
+        functionName: string;
+        args: readonly unknown[];
+    }): Promise<Hex>;
+    sendTransaction(req: {
+        chainId: number;
+        to: Address;
+        value: bigint;
+    }): Promise<Hex>;
+}
+/** Adapt a viem `WalletClient` (with an account attached) to `IntentWallet`. */
+declare function viemWallet(client: WalletClient): IntentWallet;
+/** viem rejects an `EIP712Domain` entry inside `types`; wallets add it themselves. */
+declare function stripDomainType(types: Record<string, ReadonlyArray<{
+    name: string;
+    type: string;
+}>>): Record<string, ReadonlyArray<{
+    name: string;
+    type: string;
+}>>;
+
+/**
+ * Where the flow is.
+ *
+ *   idle          nothing submitted yet
+ *   parsing       turning the text into intents
+ *   offTemplate   couldn't parse; show `hint`
+ *   invalid       parsed, but `issues` need fixing
+ *   needsWallet   ready to quote once a wallet is set
+ *   quoting       resolving and racing solvers
+ *   quoted        `preview` is ready to confirm
+ *   switchingChain / approving / signing / submitting   confirm() progress
+ *   tracking      order submitted, polling its status
+ *   done          every intent reached a terminal status
+ *   error         something threw; see `error`
+ */
+type IntentPhase = 'idle' | 'parsing' | 'offTemplate' | 'invalid' | 'needsWallet' | 'quoting' | 'quoted' | 'switchingChain' | 'approving' | 'signing' | 'submitting' | 'tracking' | 'done' | 'error';
+/** What a confirm card shows: human amounts and names, no addresses or base units. */
+interface IntentPreview {
+    action: 'swap' | 'send';
+    payAmount: string;
+    paySymbol: string;
+    srcChainName: string;
+    receiveAmount: string;
+    receiveSymbol: string;
+    dstChainName: string;
+    recipient?: string;
+    etaSeconds?: number;
+    /** Quotes received (1 for a direct wallet transfer). */
+    solverCount: number;
+    solversQueried?: number;
+    raceMs?: number;
+}
+interface IntentState {
+    phase: IntentPhase;
+    assetsLoading: boolean;
+    assetsError: boolean;
+    /** The supported-asset set has loaded, so input can be accepted. */
+    ready: boolean;
+    hint: string | null;
+    issues: ValidationIssue[];
+    resolved: ResolvedIntent | null;
+    /**
+     * `solver` goes through the aggregator. `direct` is a same-chain send,
+     * which solvers don't quote, so the wallet transfers it itself.
+     */
+    route: 'solver' | 'direct' | null;
+    quote: Quote | null;
+    preview: IntentPreview | null;
+    /** Escrow route only: an ERC-20 approval to Permit2 comes first. */
+    needsApproval: boolean;
+    orderId: string | null;
+    status: OrderStatus | null;
+    order: OrderResponse | null;
+    /** Destination-chain explorer link: the fill tx when known, else the recipient. */
+    explorerUrl: string | null;
+    error: string | null;
+    isConnected: boolean;
+    /** Multi-intent sentences run one after another. */
+    queueIndex: number;
+    queueTotal: number;
+}
+interface IntentSession {
+    getState(): IntentState;
+    /** Called after every state change. Returns an unsubscribe function. */
+    subscribe(listener: (state: IntentState) => void): () => void;
+    run(text: string): Promise<void>;
+    confirm(): Promise<void>;
+    reset(): void;
+    /** Connect, switch or disconnect. A pending intent continues automatically. */
+    setWallet(wallet: IntentWallet | null): void;
+    refreshAssets(): Promise<void>;
+    /** Set or replace the Hugging Face token used for parsing (null turns parsing off). */
+    setHfAccessToken(token: string | null): void;
+    /** Stop polling and drop listeners. */
+    destroy(): void;
+}
+interface SessionOptions extends ApiOptions {
+    /**
+     * Your Hugging Face access token, for turning plain English into intents.
+     * Parsing runs in the browser, so the token is visible to anyone who loads
+     * the page: use a dedicated, inference-only token. Without one, `run()`
+     * answers with the example-sentence hint.
+     */
+    hfAccessToken?: string | null;
+    /** Hugging Face model for parsing. */
+    hfModel?: ParserOptions['model'];
+    /** Share one client across sessions; otherwise built from `apiUrl`/`fetch`. */
+    api?: ApiClient;
+    wallet?: IntentWallet | null;
+    /** Order-status polling interval. Default 2500ms. */
+    pollIntervalMs?: number;
+    /** Chain reads (Permit2 allowance, receipts). Defaults to the aggregator's RPCs. */
+    chainReader?: (chainId: number) => Promise<ChainReader | null>;
+}
+declare function isTerminalStatus(status: OrderStatus): boolean;
+/**
+ * The whole intent flow as a framework-free store: parse → validate →
+ * resolve → quote → (approve) → sign → submit → track. UI layers subscribe
+ * and render `getState()`; they never talk to the aggregator themselves.
+ */
+declare function createIntentSession(options?: SessionOptions): IntentSession;
+
+/**
+ * The registry has two layers (see docs/intent-parser-design.md §2):
+ *  - alias layer (static): maps loose user words → canonical token symbol / chain.
+ *  - support layer (dynamic): what solvers can actually fill, from the live aggregator.
+ *
+ * A word can be a token OR a chain depending on slot (e.g. "eth", "sol"); the grammar
+ * decides which table to consult by position, so the same word appears in both.
+ */
+interface CanonicalChain {
+    id: number;
+    name: string;
+}
+declare const TOKEN_ALIASES: Record<string, string>;
+declare const CHAIN_ALIASES: Record<string, CanonicalChain>;
+declare function normalizeToken(raw: string | null): string | null;
+declare function normalizeChain(raw: string | null): CanonicalChain | null;
+interface SupportedSet {
+    chains: Set<number>;
+    assets: Map<string, SolverAsset>;
+}
+declare const EMPTY_SUPPORTED: SupportedSet;
+declare function buildSupportedSet(assets: SolverAsset[]): SupportedSet;
+declare function findAsset(set: SupportedSet, chainId: number, symbol: string): SolverAsset | undefined;
+
+/**
+ * Validate a parsed intent against the live support set. Collects EVERY problem
+ * (missing / unknown / unsupported) so the user can fix them in one edit.
+ * Empty array = ready to resolve.
+ */
+declare function validateIntent(raw: RawIntent, supported: SupportedSet): ValidationIssue[];
+
+/**
+ * Resolve a validated RawIntent into a ResolvedIntent (canonical addresses, chain
+ * ids, base-unit amount). PRECONDITION: validateIntent(raw, supported) returned [].
+ * Throws if that precondition is violated.
+ */
+declare function resolveIntent(raw: RawIntent, supported: SupportedSet, user: string, solanaUser?: string | null): ResolvedIntent;
+
+/**
+ * Build the POST /api/v1/quotes body from a resolved intent.
+ *
+ * Shape matches the verified oif-aggregator contract: every address is
+ * ERC-7930 interop-encoded (see ./interop), and the input amount is a base-unit
+ * decimal string.
+ *
+ * We request the **Permit2 escrow** path only (`schemes:['permit2']`,
+ * `supportedTypes:['oif-escrow-v0']`). The solver's custody logic checks the
+ * requested schemes and, when EIP-3009 is offered, prefers it — but the live
+ * 3009 open path reverts on-chain (`SignatureAndInputsNotEqual`). Permit2 escrow
+ * is the proven-working route (it needs a one-time Permit2 approval, handled in
+ * useIntent's confirm flow).
+ *
+ * For a `send`, `recipient` differs from `user`; for a `swap` they're equal.
+ * Either way the input is sourced on `srcChainId` from `user`, and the output
+ * is delivered on `dstChainId` to `recipient`.
+ */
+declare function buildQuoteRequest(resolved: ResolvedIntent): QuoteRequest;
+/**
+ * Build the POST /api/v1/orders body from a quote and its scheme-prefixed
+ * signature (produced by ./sign `signQuote`).
+ *
+ * The submission scheme (`permit2` / `eip3009`) is negotiated at quote time via
+ * the quote request's `originSubmission` — the demo does NOT repeat it on the
+ * order, so neither do we. The order just pairs the full quote back with its
+ * signature.
+ */
+declare function buildOrderRequest(quote: Quote, signature: string): OrderRequest;
+
+/**
+ * ERC-7930 InteropAddress encoding.
+ *
+ * Ported faithfully from the OIF aggregator demo
+ * (`oif-aggregator/demo/src/utils/interopAddress.ts`). The aggregator expects
+ * addresses as ERC-7930 "interop" hex strings (NOT plain `0x` addresses): get the
+ * encoding wrong and `/quotes` returns zero quotes or an error.
+ *
+ * Format per EIP-7930:
+ *   0x [version(2 bytes)] [chainType(2 bytes)] [chainRefLen(1)] [chainRef] [addrLen(1)] [address]
+ *
+ * version    = 0x0001
+ * chainType  = 0x0000 (EIP-155)
+ * chainRef   = chainId as minimal big-endian bytes
+ * address    = the 20-byte EVM address
+ */
+/** An ERC-7930 interop address, hex-encoded. */
+type InteropAddress = `0x${string}`;
+declare function interopAddress(chainId: number, address: string): InteropAddress;
+
+/**
+ * Permit2 allowance helpers.
+ *
+ * The OIF escrow (Permit2) flow needs the input ERC-20 to be approved for the
+ * canonical Permit2 spender before an escrow order can pull funds. These helpers
+ * are framework-light: reads take a viem `PublicClient`, and the approve is
+ * exposed both as a plain contract-write request (use with wagmi `useWriteContract`
+ * or any signer) and as a convenience that sends via a viem `WalletClient`.
+ */
+
+/** Canonical Permit2 contract address (same on every chain). */
+declare const PERMIT2_ADDRESS: Address;
+/** Max uint256 — used for an unlimited approval. */
+declare const MAX_UINT256: bigint;
+/**
+ * Read the current Permit2 allowance the owner has granted on `token`
+ * (i.e. allowance(owner, PERMIT2_ADDRESS)).
+ */
+declare function getPermit2Allowance(publicClient: PublicClient, token: Address, owner: Address): Promise<bigint>;
+/** True if the owner's Permit2 allowance on `token` covers `required`. */
+declare function hasPermit2Allowance(publicClient: PublicClient, token: Address, owner: Address, required: bigint): Promise<boolean>;
+/**
+ * Build the contract-write request to approve Permit2 to spend `token`.
+ * Defaults to an unlimited (max uint256) approval. Returns a plain object you
+ * can hand to wagmi `writeContract`/`useWriteContract` or viem `writeContract`.
+ */
+declare function buildPermit2ApproveRequest(token: Address, amount?: bigint): {
+    address: `0x${string}`;
+    abi: readonly [{
+        readonly name: "approve";
+        readonly type: "function";
+        readonly stateMutability: "nonpayable";
+        readonly inputs: readonly [{
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly outputs: readonly [{
+            readonly name: "";
+            readonly type: "bool";
+        }];
+    }];
+    functionName: "approve";
+    args: readonly [`0x${string}`, bigint];
+};
+
+export { type AggregationMetadata, type AmountKind, type ApiClient, ApiError, type ApiOptions, type AssetAmount, type AssetLockReference, CHAIN_ALIASES, type CanonicalChain, type ChainInfo, type ChainReader, DEFAULT_API_URL, DEFAULT_INTENT_MODEL, EMPTY_SUPPORTED, HF_ROUTER_URL, type Input, type IntentAction, type IntentPhase, type IntentPreview, type IntentRequest, type IntentSession, type IntentState, type IntentWallet, type InteropAddress, type IssueField, type IssueKind, MAX_UINT256, type Order, type OrderPayload, type OrderRequest, type OrderResponse, type OrderStatus, type OriginSubmission, type Output, PERMIT2_ADDRESS, type ParseResult, type ParserOptions, type Quote, type QuotePreview, type QuoteRequest, type QuotesResponse, type RawIntent, type ResolvedIntent, SOLANA_CHAIN_IDS, type SessionOptions, type Settlement, type Solver, type SolverAsset, type SolverOptions, type SolverSupportedAssets, type SolversResponse, type SupportedSet, TEMPLATE_HINT, TOKEN_ALIASES, type TypedDataSigner, type ValidationIssue, buildOrderRequest, buildPermit2ApproveRequest, buildQuoteRequest, buildSupportedSet, chainName, createApiClient, createIntentSession, explorerUrl, extractIntents, findAsset, getPermit2Allowance, hasPermit2Allowance, interopAddress, isTerminalStatus, normalizeChain, normalizeToken, parseIntent, resolveIntent, rpcReaders, signQuote, stripDomainType, validateIntent, viemWallet };