@xochi/client 0.0.0-stage → 0.1.2

package/dist/esm/shared/chains.js

@@ -0,0 +1,236 @@
+/**
+ * Chain Definitions
+ *
+ * Supported chains and their configuration.
+ *
+ * `CHAIN_REGISTRY` is the ONE literal in this file: the `ChainId` union, every
+ * display/lookup map and `SUPPORTED_CHAIN_IDS` are derived from it. `SUPPORTED_CHAIN_IDS`
+ * is typed `readonly ChainId[]`, so a hand-maintained copy that omitted a chain compiled
+ * cleanly and silently excluded it from `isChainId`, `SETTLEABLE_CHAIN_IDS` and the
+ * capabilities fallback; the per-chain maps outside this file (`tokens.ts`) fail to
+ * compile until they carry a new registry entry.
+ */
+/**
+ * The single source of truth for supported EVM chains.
+ *
+ * Keyed by slug rather than by id for two reasons: the slugs are themselves
+ * public API (`CHAIN_IDS.base`), and string keys preserve insertion order, so
+ * `SUPPORTED_CHAIN_IDS` keeps its declared order. Integer-like keys would be
+ * re-sorted ascending by the runtime, which would silently reorder the
+ * `/api/capabilities` fallback payload built from that array.
+ *
+ * Non-EVM and virtual chains are deliberately NOT here: Tron (base58 addresses,
+ * TronWeb signing, hash-route explorer) and the Aztec virtual source chain (0)
+ * are display-only, and join the extended maps below through their own
+ * constants. EVM-only code (viem/wagmi/RPC) must never receive those ids.
+ *
+ * Short names are the compact UI labels; explorers are the origins the link
+ * helpers below build on (one map, so per-component explorer maps cannot
+ * drift).
+ */
+export const CHAIN_REGISTRY = {
+    ethereum: { id: 1, name: "Ethereum", shortName: "ETH", explorer: "https://etherscan.io" },
+    optimism: {
+        id: 10,
+        name: "Optimism",
+        shortName: "OP",
+        explorer: "https://optimistic.etherscan.io",
+    },
+    polygon: {
+        id: 137,
+        name: "Polygon",
+        shortName: "POLY",
+        explorer: "https://polygonscan.com",
+        nativeCurrency: "POL",
+    },
+    arbitrum: { id: 42161, name: "Arbitrum", shortName: "ARB", explorer: "https://arbiscan.io" },
+    base: { id: 8453, name: "Base", shortName: "BASE", explorer: "https://basescan.org" },
+    robinhood: {
+        id: 4663,
+        name: "Robinhood",
+        shortName: "HOOD",
+        explorer: "https://robinhoodchain.blockscout.com",
+    },
+    arc: {
+        id: 5042,
+        name: "Arc",
+        shortName: "ARC",
+        explorer: "https://explorer.arc.io",
+        nativeCurrency: "USDC",
+    },
+    gnosis: {
+        id: 100,
+        name: "Gnosis",
+        shortName: "GNO",
+        explorer: "https://gnosisscan.io",
+        nativeCurrency: "xDAI",
+    },
+};
+/** Registry entries in declaration order. */
+const CHAIN_LIST = Object.values(CHAIN_REGISTRY);
+/**
+ * Project the registry into a per-chain lookup.
+ *
+ * The assertion is confined to this helper: the loop writes exactly one entry
+ * per registry chain, so the result is exhaustive by construction, but TS cannot
+ * prove exhaustiveness of a runtime iteration. Call sites stay plain
+ * `Record<ChainId, T>` with no cast of their own.
+ */
+function byChainId(project) {
+    const lookup = {};
+    for (const chain of CHAIN_LIST)
+        lookup[chain.id] = project(chain);
+    return lookup;
+}
+/**
+ * Tron mainnet chain id. Tron is non-EVM (base58 addresses, TronWeb signing),
+ * so it is deliberately kept OUT of the EVM `ChainId` union -- EVM-only code
+ * (viem, wagmi, contract reads) must never receive it. UI-level chain selection
+ * uses `SelectableChainId` below.
+ */
+export const TRON_CHAIN_ID = 728_126_428;
+/** Tron display names (Tron is outside CHAIN_REGISTRY, being non-EVM). */
+export const TRON_CHAIN_NAME = "Tron";
+export const TRON_SHORT_NAME = "TRON";
+/** Type guard for the Tron mainnet chain id. */
+export function isTronChainId(value) {
+    return value === TRON_CHAIN_ID;
+}
+/**
+ * Type guard for any chain the UI can render a link/name for (every EVM `ChainId`
+ * plus Tron). Guards raw `settlementChainId` values from Riddler -- which adds
+ * chains on its own cadence -- so an unknown id falls back to inference instead of
+ * producing a dead `href=""` or a `View undefined tx` label.
+ */
+export function isSelectableChainId(value) {
+    return isChainId(value) || isTronChainId(value);
+}
+/**
+ * Robinhood Chain (4663): an Arbitrum Orbit L2 whose native stablecoin is USDG
+ * (Global Dollar, Paxos). It has no USDC. The solver settles USDC<->USDG (and
+ * other stablecoin) cross-asset corridors to and from it. It is fully EVM (0x
+ * addresses, EIP-712 signing, Permit2 pull on USDG) and a first-class member
+ * of `ChainId`: the trade UI lists Robinhood + USDG, so the per-chain token
+ * maps carry it. USDG is a first-class token (see USDG_ADDRESSES in
+ * tokens.ts), never shoehorned into USDC_ADDRESSES (that map is Permit2-free
+ * ERC-3009 USDC only, and USDG supports neither ERC-3009 nor EIP-2612).
+ * `ROBINHOOD_CHAIN_ID` is kept for readable references and the settleable
+ * guards below.
+ */
+export const ROBINHOOD_CHAIN_ID = 4663;
+/** Type guard for the Robinhood Chain id. */
+export function isRobinhoodChainId(value) {
+    return value === ROBINHOOD_CHAIN_ID;
+}
+/**
+ * Arc chain id. Arc is Circle's EVM-compatible L1 where USDC is the native
+ * gas token (18 dec protocol-level, 6 dec ERC-20). No WETH, no ETH --
+ * stablecoin-only chain. Feature-flagged behind ARC_LIVE.
+ */
+export const ARC_CHAIN_ID = 5042;
+/** Type guard for the Arc chain id. */
+export function isArcChainId(value) {
+    return value === ARC_CHAIN_ID;
+}
+/**
+ * Gnosis Chain id. Native gas is xDAI. Xochi lists a single token here,
+ * Monerium EURe (18 dec, no ERC-3009, Permit2 pull); there is no WETH or USDC
+ * leg. Feature-flagged in the UI behind GNOSIS_LIVE.
+ */
+export const GNOSIS_CHAIN_ID = 100;
+/** Type guard for the Gnosis Chain id. */
+export function isGnosisChainId(value) {
+    return value === GNOSIS_CHAIN_ID;
+}
+/** Per-slug ids. Same assertion rationale as `byChainId`: `Object.fromEntries`
+ * erases the key/value correlation that the mapped type expresses. */
+const CHAIN_IDS_BY_SLUG = Object.fromEntries(Object.entries(CHAIN_REGISTRY).map(([slug, chain]) => [slug, chain.id]));
+/** All supported chain IDs */
+export const CHAIN_IDS = {
+    ...CHAIN_IDS_BY_SLUG,
+    aztec: 0,
+};
+/** Chain names for display */
+export const CHAIN_NAMES = byChainId((chain) => chain.name);
+/**
+ * Short chain names for compact display. Keyed by `SelectableChainId` so the
+ * non-EVM Tron destination (base58) has a short name too -- the tx-link/name
+ * helpers in the trade result surfaces index this with a destination chain id
+ * that can be Tron.
+ */
+export const CHAIN_SHORT_NAMES = {
+    ...byChainId((chain) => chain.shortName),
+    [TRON_CHAIN_ID]: TRON_SHORT_NAME,
+};
+/**
+ * Block explorer origins by chain (no trailing path). Single source of truth --
+ * build tx/address URLs through the helpers below so links always target the
+ * right chain (the old per-component maps drifted and one hardcoded Arbiscan).
+ */
+export const CHAIN_EXPLORERS = byChainId((chain) => chain.explorer);
+/**
+ * Native currency symbol per chain. Used for gas display (QuoteDetails) and
+ * balance labels (usePublicBalances). Most chains use ETH; Polygon uses POL,
+ * Arc uses USDC (native gas token on Circle's stablecoin L1).
+ * Derived from `CHAIN_REGISTRY.nativeCurrency`, defaulting to "ETH".
+ */
+export const CHAIN_NATIVE_CURRENCY = byChainId((chain) => chain.nativeCurrency ?? "ETH");
+/**
+ * Tronscan uses a `#/` hash route (not the `/tx/` path shape of the EVM
+ * explorers), so Tron links are built separately from `CHAIN_EXPLORERS`.
+ */
+export const TRON_EXPLORER = "https://tronscan.org";
+/**
+ * Build a transaction URL on the given chain's explorer (empty if unknown).
+ * Accepts a `SelectableChainId` so a Tron destination fill can be linked; Tron
+ * routes to tronscan's hash-route form.
+ */
+export function getExplorerTxUrl(chainId, txHash) {
+    if (isTronChainId(chainId))
+        return `${TRON_EXPLORER}/#/transaction/${txHash}`;
+    const base = CHAIN_EXPLORERS[chainId];
+    return base ? `${base}/tx/${txHash}` : "";
+}
+/** Build an address URL on the given chain's explorer (empty if unknown). */
+export function getExplorerAddressUrl(chainId, address) {
+    if (isTronChainId(chainId))
+        return `${TRON_EXPLORER}/#/address/${address}`;
+    const base = CHAIN_EXPLORERS[chainId];
+    return base ? `${base}/address/${address}` : "";
+}
+/**
+ * Extended chain names including the Aztec source + non-EVM destinations. The
+ * Aztec virtual chain is branded "Xochi" in the UI, which is why its display
+ * name is not simply a chain name.
+ */
+export const EXTENDED_CHAIN_NAMES = {
+    ...CHAIN_NAMES,
+    0: "Xochi",
+    [TRON_CHAIN_ID]: TRON_CHAIN_NAME,
+};
+/** Supported chain IDs as array */
+export const SUPPORTED_CHAIN_IDS = CHAIN_LIST.map((chain) => chain.id);
+/** Type guard for ChainId */
+export function isChainId(value) {
+    return typeof value === "number" && SUPPORTED_CHAIN_IDS.includes(value);
+}
+/**
+ * Chain ids the solver can settle to or from; exactly `SUPPORTED_CHAIN_IDS`. The intent API
+ * (`/api/intent/quote` and `/api/intent/execute`) validates request chain ids against this set.
+ * Token addresses ride in the request body, so the API needs no per-chain token config to
+ * accept a corridor; the solver decides feasibility.
+ */
+export const SETTLEABLE_CHAIN_IDS = SUPPORTED_CHAIN_IDS;
+/** Type guard for a settleable chain id (any supported chain, including Robinhood). */
+export function isSettleableChainId(value) {
+    return typeof value === "number" && SETTLEABLE_CHAIN_IDS.includes(value);
+}
+/** Type guard for ExtendedChainId (EVM chains + Aztec source + Tron destination). */
+export function isExtendedChainId(value) {
+    return (typeof value === "number" &&
+        (value === 0 || value === TRON_CHAIN_ID || SUPPORTED_CHAIN_IDS.includes(value)));
+}
+/** Check if route between chains is supported */
+export function isRouteSupported(from, to) {
+    return isChainId(from) && isChainId(to);
+}

package/dist/esm/shared/eip712.d.ts

@@ -0,0 +1,44 @@
+/**
+ * EIP-712 Types and Builders
+ *
+ * Typed data shapes served for signing, and the origin-pull amount reader.
+ */
+export interface Eip712Domain {
+    name: string;
+    version: string;
+    chainId: number;
+    /**
+     * Present on Xochi-owned structs (Intent/LimitOrder/Mandate) and token-pull
+     * domains (ERC-3009/Permit2). The Riddler-served XochiIntent v3 domain omits
+     * it in favor of `salt`, so it is optional -- never assume it is set.
+     */
+    verifyingContract?: string;
+    /**
+     * Present on the Riddler-served XochiIntent v3 domain (keccak256(version));
+     * absent on verifyingContract-based domains. Part of the signed domain
+     * separator, so it must reach the signer verbatim.
+     */
+    salt?: string;
+}
+export interface Eip712TypeField {
+    name: string;
+    type: string;
+}
+export interface Eip712TypedData<T = Record<string, unknown>> {
+    domain: Eip712Domain;
+    types: Record<string, Eip712TypeField[]>;
+    primaryType: string;
+    message: T;
+}
+/**
+ * Extract the origin-token amount (smallest units) a served origin-pull
+ * authorization would collect. ERC-3009 carries it as `value`; Permit2 as
+ * `permitted.amount`. Returns null for an unrecognized type or a
+ * missing/unparseable amount so callers fail closed.
+ *
+ * The pulled amount is what the user's signature authorizes on-chain (ERC-3009
+ * moves exactly `value`; Permit2 caps at `permitted.amount`), so binding it to
+ * the intended input amount is the origin leg's value guard (#170; see
+ * solverPin).
+ */
+export declare function extractPullAmount(pull: Eip712TypedData): bigint | null;

package/dist/esm/shared/eip712.js

@@ -0,0 +1,61 @@
+/**
+ * EIP-712 Types and Builders
+ *
+ * Typed data shapes served for signing, and the origin-pull amount reader.
+ */
+// ============================================================
+// Origin-pull amount extraction
+// ============================================================
+/**
+ * Origin-pull primaryTypes that carry the collected amount. ERC-3009
+ * (ReceiveWithAuthorization / TransferWithAuthorization) carries it top-level as
+ * `value`; Permit2 (PermitWitnessTransferFrom) as `permitted.amount`. Mirrors the
+ * set the solver pin recognizes.
+ */
+const ERC3009_PULL_TYPES = new Set([
+    "ReceiveWithAuthorization",
+    "TransferWithAuthorization",
+]);
+const PERMIT2_PULL_TYPE = "PermitWitnessTransferFrom";
+/** Coerce a typed-data uint256 (decimal string / number / bigint) to bigint, or null. */
+function coercePullAmount(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number" && Number.isInteger(value))
+        return BigInt(value);
+    if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+        try {
+            return BigInt(value.trim());
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Extract the origin-token amount (smallest units) a served origin-pull
+ * authorization would collect. ERC-3009 carries it as `value`; Permit2 as
+ * `permitted.amount`. Returns null for an unrecognized type or a
+ * missing/unparseable amount so callers fail closed.
+ *
+ * The pulled amount is what the user's signature authorizes on-chain (ERC-3009
+ * moves exactly `value`; Permit2 caps at `permitted.amount`), so binding it to
+ * the intended input amount is the origin leg's value guard (#170; see
+ * solverPin).
+ */
+export function extractPullAmount(pull) {
+    const message = pull.message;
+    if (!message)
+        return null;
+    if (ERC3009_PULL_TYPES.has(pull.primaryType)) {
+        return coercePullAmount(message.value);
+    }
+    if (pull.primaryType === PERMIT2_PULL_TYPE) {
+        const permitted = message.permitted;
+        return permitted ? coercePullAmount(permitted.amount) : null;
+    }
+    return null;
+}
+// ============================================================
+// Intent EIP-712 (XochiIntent v3)

package/dist/esm/shared/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The client-facing public subset of Xochi's shared vocabulary: chains, intent
+ * statuses, trading bounds, the served EIP-712 shapes, address validators,
+ * stealth factory trust, and the Worker's quote/execute response contract.
+ */
+export * from "./chains.js";
+export * from "./intents.js";
+export * from "./trading.js";
+export * from "./types.js";
+export * from "./stealth.js";
+export * from "./eip712.js";
+export * from "./validators.js";
+export * from "./schemas.js";
+export * from "./api.js";
+export * from "./intentStream.js";
+export * from "./shieldedPreview.js";

package/dist/esm/shared/index.js

@@ -0,0 +1,16 @@
+/**
+ * The client-facing public subset of Xochi's shared vocabulary: chains, intent
+ * statuses, trading bounds, the served EIP-712 shapes, address validators,
+ * stealth factory trust, and the Worker's quote/execute response contract.
+ */
+export * from "./chains.js";
+export * from "./intents.js";
+export * from "./trading.js";
+export * from "./types.js";
+export * from "./stealth.js";
+export * from "./eip712.js";
+export * from "./validators.js";
+export * from "./schemas.js";
+export * from "./api.js";
+export * from "./intentStream.js";
+export * from "./shieldedPreview.js";

package/dist/esm/shared/intentStream.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Intent lifecycle frame: the wire shape of a status transition published on an
+ * intent's stream topic (`GET /api/stream/:topicId`, settlement-protocol D5 5.9).
+ *
+ * The worker builds it (`broadcastStatusFrame`) and the browser parses it
+ * (`useIntentStream`); agents subscribed to the topic consume the same JSON.
+ * Defined here so the producer and the consumers cannot drift: the worker
+ * cannot publish a field the client schema does not know about without a type
+ * error, and the client tests feed this builder's output through the parser.
+ */
+import { z } from "zod";
+import { type IntentStatus } from "./intents.js";
+export declare const IntentStatusFrameSchema: z.ZodObject<{
+    type: z.ZodLiteral<"status">;
+    intent_id: z.ZodString;
+    from_status: z.ZodEffects<z.ZodString, IntentStatus, string>;
+    status: z.ZodEffects<z.ZodString, IntentStatus, string>;
+    /** The intent's settlement protocol (`intents.protocol`, e.g. `v1`). */
+    protocol: z.ZodString;
+    /**
+     * `intent_status_history` rowid: monotonic, so a subscriber can drop a frame
+     * older than one it already applied. Null only if D1 did not report it.
+     */
+    revision: z.ZodNullable<z.ZodNumber>;
+    /** Unix ms at publish. */
+    ts: z.ZodNumber;
+    /** Present only for a PUBLIC settlement with a known hash. */
+    tx_hash: z.ZodOptional<z.ZodString>;
+    /**
+     * `NOT_EXECUTED_SUBSTATUS` on the `failed` transition of a row the worker
+     * finished itself knowing nothing moved; absent on every other frame.
+     */
+    substatus: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: IntentStatus;
+    type: "status";
+    intent_id: string;
+    from_status: IntentStatus;
+    protocol: string;
+    revision: number | null;
+    ts: number;
+    tx_hash?: string | undefined;
+    substatus?: string | undefined;
+}, {
+    status: string;
+    type: "status";
+    intent_id: string;
+    from_status: string;
+    protocol: string;
+    revision: number | null;
+    ts: number;
+    tx_hash?: string | undefined;
+    substatus?: string | undefined;
+}>;
+export type IntentStatusFrame = z.infer<typeof IntentStatusFrameSchema>;
+/**
+ * Build the frame for one transition.
+ *
+ * `tx_hash` is omitted for any non-public settlement: a subscriber to a stealth
+ * or shielded intent holds the topic, but the hash is the one field that
+ * deanonymises the recipient on a public chain, and the relay replays its
+ * buffer for 10 minutes (D7 7.3).
+ */
+export declare function buildIntentStatusFrame(input: {
+    intentId: string;
+    fromStatus: IntentStatus;
+    toStatus: IntentStatus;
+    protocol: string;
+    settlementType: string;
+    revision: number | null;
+    txHash?: string | null;
+    substatus?: string | null;
+    ts: number;
+}): IntentStatusFrame;

package/dist/esm/shared/intentStream.js

@@ -0,0 +1,55 @@
+/**
+ * Intent lifecycle frame: the wire shape of a status transition published on an
+ * intent's stream topic (`GET /api/stream/:topicId`, settlement-protocol D5 5.9).
+ *
+ * The worker builds it (`broadcastStatusFrame`) and the browser parses it
+ * (`useIntentStream`); agents subscribed to the topic consume the same JSON.
+ * Defined here so the producer and the consumers cannot drift: the worker
+ * cannot publish a field the client schema does not know about without a type
+ * error, and the client tests feed this builder's output through the parser.
+ */
+import { z } from "zod";
+import { isIntentStatus } from "./intents.js";
+export const IntentStatusFrameSchema = z.object({
+    type: z.literal("status"),
+    intent_id: z.string().min(1),
+    from_status: z.string().refine(isIntentStatus),
+    status: z.string().refine(isIntentStatus),
+    /** The intent's settlement protocol (`intents.protocol`, e.g. `v1`). */
+    protocol: z.string(),
+    /**
+     * `intent_status_history` rowid: monotonic, so a subscriber can drop a frame
+     * older than one it already applied. Null only if D1 did not report it.
+     */
+    revision: z.number().int().nullable(),
+    /** Unix ms at publish. */
+    ts: z.number().int(),
+    /** Present only for a PUBLIC settlement with a known hash. */
+    tx_hash: z.string().optional(),
+    /**
+     * `NOT_EXECUTED_SUBSTATUS` on the `failed` transition of a row the worker
+     * finished itself knowing nothing moved; absent on every other frame.
+     */
+    substatus: z.string().optional(),
+});
+/**
+ * Build the frame for one transition.
+ *
+ * `tx_hash` is omitted for any non-public settlement: a subscriber to a stealth
+ * or shielded intent holds the topic, but the hash is the one field that
+ * deanonymises the recipient on a public chain, and the relay replays its
+ * buffer for 10 minutes (D7 7.3).
+ */
+export function buildIntentStatusFrame(input) {
+    return {
+        type: "status",
+        intent_id: input.intentId,
+        from_status: input.fromStatus,
+        status: input.toStatus,
+        protocol: input.protocol,
+        revision: input.revision,
+        ts: input.ts,
+        ...(input.settlementType === "public" && input.txHash ? { tx_hash: input.txHash } : {}),
+        ...(input.substatus ? { substatus: input.substatus } : {}),
+    };
+}

package/dist/esm/shared/intents.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Intent Types
+ *
+ * Status types, order types, and state machine transitions
+ * for the cross-chain intent system.
+ */
+export type SettlementType = "public" | "shielded" | "stealth";
+export declare function isSettlementType(value: unknown): value is SettlementType;
+export type OrderType = "market" | "limit";
+export declare function isOrderType(value: unknown): value is OrderType;
+export type TriggerCondition = "gte" | "lte";
+export declare function isTriggerCondition(value: unknown): value is TriggerCondition;
+export type IntentStatus = "idle" | "pending" | "quoting" | "quoted" | "signing" | "awaiting_deposit" | "executing" | "bridging" | "settling" | "completed" | "refunded" | "failed" | "expired";
+/** All valid intent statuses */
+export declare const INTENT_STATUSES: readonly IntentStatus[];
+export declare function isIntentStatus(value: unknown): value is IntentStatus;
+/**
+ * The `substatus` the worker puts on a `failed` it wrote knowing nothing
+ * moved. The one list of its sources is docs/contracts/xochi-intent-api.md,
+ * "The worker's `not_executed` marker"; this mirrors it. Writers:
+ * 1. an intent read (`GET /api/intent/{id}`, the status poll) of an unsigned
+ *    market `quoted` row (never a Tron deposit route or a limit order; never
+ *    claimed, or every claim undone) past its signed deadline +
+ *    `QUOTED_EXPIRY_GRACE_SECS`;
+ * 2. the quote sweep's finish of a touched `quoted` row past its 30 s quote
+ *    expiry + 60 s;
+ * 3. the resend budget's finish after the solver's not-accepted refusals;
+ * 4. a not-accepted refusal finished because its un-claim's write failed
+ *    (`NOT_ACCEPTED_FAULT_FINISH_ERROR`);
+ * 5. an execute refused because no solver is configured;
+ * 6. a solver refusal of the execute whose body says
+ *    `details.funds_moved === false` (refused before this request's claim and
+ *    before any pull).
+ * Served on every intent read, the history list, the stream frame of that
+ * transition, the execute 502 of writers 3-6, and echoed from the row by the
+ * execute's lost-race 502 and in-doubt 200. Any other solver-reported
+ * `failed` (which may follow an origin pull) never carries it, and neither
+ * does a `failed` nothing vouches for, such as a solver refusal without that
+ * body. A client that sent an execute may offer Retry on a `failed` with this
+ * marker; any other `failed` may follow moved funds (`@xochi/client` holds it
+ * as "may have moved"; the app and widget do not read the marker yet,
+ * xochi#691).
+ *
+ * Writers 1-4 and 6, and the sweep's deletion of an untouched `quoted` row
+ * (which a client holding the intent as not sent reads as nothing moved),
+ * rest on one premise: the worker is the only caller of the solver's execute
+ * for its quotes, which the solver enforces (its execute refuses a caller
+ * other than the one the quote was issued to, Riddler#1346).
+ *
+ * Mirrors `NOT_EXECUTED_SUBSTATUS` in xochi's `@xochi/shared` `intents.ts`
+ * verbatim (the doc path above is in xochi). In this package: README "Fund
+ * safety" (Retry only on this marker, or on a 404 while "not sent yet" past
+ * the Worker's finish).
+ */
+export declare const NOT_EXECUTED_SUBSTATUS = "not_executed";
+/** Status transitions for the market order intent state machine */
+export declare const INTENT_STATUS_TRANSITIONS: Record<IntentStatus, IntentStatus[]>;
+/** Check if a status transition is valid */
+export declare function canTransitionTo(from: IntentStatus, to: IntentStatus): boolean;
+/** Get human-readable status label */
+export declare function getStatusLabel(status: IntentStatus): string;
+/**
+ * Plain-language copy for a deposit refund. Riddler returns a machine-readable
+ * `refundReason` code on a `refunded` status; map it to something a
+ * non-technical user understands. Every case reassures that funds are safe.
+ * Unknown codes fall back to the generic line rather than leaking the raw code.
+ */
+export declare function getRefundReasonLabel(code: string | null | undefined): string;
+export type LimitOrderStatus = "idle" | "limit_quoting" | "limit_quoted" | "signing" | "waiting" | "triggered" | "executing" | "completed" | "cancelled" | "expired";
+/** All valid limit order statuses */
+export declare const LIMIT_ORDER_STATUSES: readonly LimitOrderStatus[];
+export declare function isLimitOrderStatus(value: unknown): value is LimitOrderStatus;
+/** Status transitions for limit order state machine */
+export declare const LIMIT_ORDER_STATUS_TRANSITIONS: Record<LimitOrderStatus, LimitOrderStatus[]>;
+/** Check if a limit order status transition is valid */
+export declare function canLimitOrderTransitionTo(from: LimitOrderStatus, to: LimitOrderStatus): boolean;
+/** Get human-readable status label for limit orders */
+export declare function getLimitOrderStatusLabel(status: LimitOrderStatus): string;
+/** Expiry presets for limit orders (in milliseconds) */
+export declare const LIMIT_ORDER_EXPIRY_PRESETS: {
+    readonly "1h": number;
+    readonly "24h": number;
+    readonly "7d": number;
+    readonly "30d": number;
+};
+export type LimitOrderExpiryPreset = keyof typeof LIMIT_ORDER_EXPIRY_PRESETS;
+export type DestinationType = "chain" | "aztec" | "stealth";
+export declare function isDestinationType(value: unknown): value is DestinationType;