@rhinestone/sdk 2.8.0 → 2.10.0

package/dist/src/hypercore/market.js

@@ -0,0 +1,120 @@
+// Reads of Hyperliquid's public `info` endpoint — the market metadata an order
+// needs and cannot be derived: the asset INDEX an order carries, the size
+// precision it must round to, and the mark to price against.
+//
+// `prepareTransaction` does these reads itself when a transaction carries
+// `hyperCore.openPerp` or `hyperCore.closePerp`. What is exported here is for the
+// questions a caller asks BEFORE sending one: which markets exist, what leverage
+// one allows, whether there is a position to close at all.
+import { HyperCoreInfoRequestError, UnknownPerpAssetError } from './errors.js';
+/** Hyperliquid's mainnet API. */
+const HYPERLIQUID_API_URL = 'https://api.hyperliquid.xyz';
+async function readInfo(body, options) {
+    const url = `${options?.apiUrl ?? HYPERLIQUID_API_URL}/info`;
+    const request = options?.fetch ?? globalThis.fetch;
+    const response = await request(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new HyperCoreInfoRequestError(url, response.status, text);
+    }
+    return (await response.json());
+}
+/**
+ * List every tradeable Hyperliquid perpetual market.
+ *
+ * Delisted assets are left out, but the index of the ones returned is their
+ * position in the full universe — Hyperliquid never renumbers it, and it is
+ * what an order carries.
+ *
+ * @param options where to reach Hyperliquid's info endpoint
+ * @returns one entry per tradeable perp market, with a live mark price
+ * @example
+ * const markets = await getPerpMarkets()
+ * markets.map((market) => market.asset) // ['BTC', 'ETH', ...]
+ * @see {@link getPerpMarket}
+ */
+async function getPerpMarkets(options) {
+    const [meta, contexts] = await readInfo({ type: 'metaAndAssetCtxs' }, options);
+    return meta.universe
+        .map((entry, assetIndex) => ({ entry, assetIndex }))
+        .filter(({ entry }) => !entry.isDelisted)
+        .map(({ entry, assetIndex }) => ({
+        asset: entry.name,
+        assetIndex,
+        szDecimals: entry.szDecimals,
+        maxLeverage: entry.maxLeverage,
+        markPx: contexts[assetIndex]?.markPx ?? '',
+    }));
+}
+/**
+ * Read one Hyperliquid perpetual market by ticker.
+ *
+ * A transaction carrying `hyperCore.openPerp` does this read itself, so reach
+ * for this when you need the market's own facts — its mark to quote a size
+ * against, or its `maxLeverage` before offering one.
+ *
+ * @param asset ticker as Hyperliquid names it — the coin alone, e.g. `BTC`
+ * @param options where to reach Hyperliquid's info endpoint
+ * @returns the market, including its asset index, size precision, and mark
+ * @throws {UnknownPerpAssetError} if no tradeable market carries that ticker
+ * @example
+ * const market = await getPerpMarket('BTC')
+ * const maxNotional = Number(market.markPx) * market.maxLeverage
+ * @see {@link getPerpMarkets}
+ */
+async function getPerpMarket(asset, options) {
+    const markets = await getPerpMarkets(options);
+    const market = markets.find((entry) => entry.asset === asset);
+    if (!market)
+        throw new UnknownPerpAssetError(asset);
+    return market;
+}
+/**
+ * List an account's open Hyperliquid perpetual positions.
+ *
+ * @param account the account holding the positions — the smart account itself,
+ *   since that is what the intent delivers collateral to
+ * @param options where to reach Hyperliquid's info endpoint
+ * @returns one entry per open position; empty when the account holds none
+ * @see {@link getPerpPosition}
+ */
+async function getPerpPositions(account, options) {
+    const state = await readInfo({ type: 'clearinghouseState', user: account }, options);
+    return (state.assetPositions ?? []).flatMap(({ position }) => position?.coin && position.szi
+        ? [
+            {
+                asset: position.coin,
+                size: position.szi,
+                entryPx: position.entryPx ?? '0',
+                leverage: position.leverage?.value ?? 1,
+            },
+        ]
+        : []);
+}
+/**
+ * Read an account's open position on one Hyperliquid perpetual market.
+ *
+ * A transaction carrying `hyperCore.closePerp` does this read itself and is
+ * rejected when there is nothing to close, so this is the check to make before
+ * offering a close at all.
+ *
+ * @param account the account holding the position
+ * @param asset ticker as Hyperliquid names it, e.g. `BTC`
+ * @param options where to reach Hyperliquid's info endpoint
+ * @returns the position, or `null` when the account has none open on that asset
+ * @example
+ * const position = await getPerpPosition(account.getAddress(), 'BTC')
+ * if (position) {
+ *   // offer a close
+ * }
+ * @see {@link getPerpPositions}
+ */
+async function getPerpPosition(account, asset, options) {
+    const positions = await getPerpPositions(account, options);
+    return positions.find((position) => position.asset === asset) ?? null;
+}
+export { getPerpMarket, getPerpMarkets, getPerpPosition, getPerpPositions };

package/dist/src/hypercore/orders.d.ts

@@ -0,0 +1,26 @@
+import type { HyperCoreOrderAction } from '../clients/orchestrator/public.js';
+import type { PerpMarket, PerpPosition } from './market.js';
+import type { ClosePerpRequest, OpenPerpRequest } from './types.js';
+/**
+ * A marketable IOC that opens a position: it fills against the book at up to
+ * `slippageBps` through the mark and cancels the rest, which is how a market
+ * order is expressed on Hyperliquid.
+ */
+declare function buildOpenPerpOrder(market: PerpMarket, request: OpenPerpRequest): HyperCoreOrderAction;
+/**
+ * A reduce-only marketable IOC in the direction that flattens the position,
+ * sized from the position itself.
+ */
+declare function buildClosePerpOrder(market: PerpMarket, position: PerpPosition, request: ClosePerpRequest): HyperCoreOrderAction;
+/**
+ * Round a price onto Hyperliquid's grid: at most 5 significant figures, and at
+ * most `6 - szDecimals` decimals.
+ *
+ * Rounded in the direction that keeps the order marketable — up for a buy, down
+ * for a sell — so the grid never eats the slippage it was given.
+ */
+declare function formatPerpPrice(price: number, szDecimals: number, roundUp: boolean): string;
+/** Round a size down onto the asset's size grid — never up past what was asked. */
+declare function formatPerpSize(size: number, szDecimals: number): string;
+export { buildClosePerpOrder, buildOpenPerpOrder, formatPerpPrice, formatPerpSize, };
+//# sourceMappingURL=orders.d.ts.map

package/dist/src/hypercore/orders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../hypercore/orders.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,gCAAgC,CAAA;AAEvC,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAkBhE;;;;GAIG;AACH,iBAAS,kBAAkB,CACzB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,eAAe,GACvB,oBAAoB,CAetB;AAED;;;GAGG;AACH,iBAAS,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,gBAAgB,GACxB,oBAAoB,CAmBtB;AAwED;;;;;;GAMG;AACH,iBAAS,eAAe,CACtB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GACf,MAAM,CAUR;AAED,mFAAmF;AACnF,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAEhE;AA4CD,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,cAAc,GACf,CAAA"}

package/dist/src/hypercore/orders.js

@@ -0,0 +1,148 @@
+// Hyperliquid's order arithmetic, and nothing else. Pure: everything these need
+// is an argument, and `resolve.ts` is what reads it from Hyperliquid.
+//
+// What they own is the part a caller should never have to reconstruct — the
+// asset INDEX an order carries instead of a ticker, the tick and size grids a
+// price and size must land on, and a limit priced far enough through the book to
+// still cross when the intent delivers ~30s later.
+import { HyperCoreError, PerpOrderTooSmallError } from './errors.js';
+/** How far through the mark a marketable limit is placed, when not given. */
+const DEFAULT_SLIPPAGE_BPS = 50;
+/**
+ * Hyperliquid's cap on a perp price's significant figures. Integer prices are
+ * exempt from it, which we do not exploit — five figures is always accepted,
+ * and at any price where the difference shows it is far inside the slippage.
+ */
+const MAX_PRICE_SIGNIFICANT_FIGURES = 5;
+/** A perp price may carry `6 - szDecimals` decimals. */
+const PERP_PRICE_DECIMAL_BUDGET = 6;
+/** Hyperliquid refuses an order worth less than this. */
+const MIN_ORDER_VALUE_USD = 10;
+/**
+ * A marketable IOC that opens a position: it fills against the book at up to
+ * `slippageBps` through the mark and cancels the rest, which is how a market
+ * order is expressed on Hyperliquid.
+ */
+function buildOpenPerpOrder(market, request) {
+    const mark = markPrice(market);
+    const size = request.size === undefined
+        ? request.notionalUsd / mark
+        : Number(request.size);
+    return orderAction({
+        market,
+        mark,
+        isBuy: request.direction === 'long',
+        size,
+        reduceOnly: false,
+        slippageBps: request.slippageBps,
+        ...(request.cloid ? { cloid: request.cloid } : {}),
+    });
+}
+/**
+ * A reduce-only marketable IOC in the direction that flattens the position,
+ * sized from the position itself.
+ */
+function buildClosePerpOrder(market, position, request) {
+    const held = Number(position.size);
+    const open = Math.abs(held);
+    const size = request.size === undefined ? open : Number(request.size);
+    if (size > open) {
+        throw new HyperCoreError(`Cannot close ${size} ${request.asset} against an open position of ${open}. Hyperliquid rejects a reduce-only order larger than the position it reduces.`);
+    }
+    return orderAction({
+        market,
+        mark: markPrice(market),
+        // Flatten: sell a long, buy back a short.
+        isBuy: held < 0,
+        size,
+        reduceOnly: true,
+        slippageBps: request.slippageBps,
+        ...(request.cloid ? { cloid: request.cloid } : {}),
+    });
+}
+function orderAction(input) {
+    const { market, mark, isBuy, reduceOnly } = input;
+    const slippageBps = input.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+    if (!Number.isInteger(slippageBps) ||
+        slippageBps < 0 ||
+        slippageBps > 10_000) {
+        throw new HyperCoreError(`slippageBps must be a whole number of basis points between 0 and 10000, got ${input.slippageBps}.`);
+    }
+    if (!Number.isFinite(input.size)) {
+        throw new HyperCoreError(`Order size for ${market.asset} is not a number: ${input.size}.`);
+    }
+    const limit = mark * (isBuy ? 1 + slippageBps / 10_000 : 1 - slippageBps / 10_000);
+    const p = formatPerpPrice(limit, market.szDecimals, isBuy);
+    const s = formatPerpSize(input.size, market.szDecimals);
+    if (Number(s) <= 0) {
+        throw new HyperCoreError(`An order size of ${input.size} rounds to zero at ${market.asset}'s ${market.szDecimals} decimals of size precision.`);
+    }
+    // Reduce-only orders are exempt from the minimum on Hyperliquid's side, and
+    // enforcing it here would leave a dust position with no way to close it.
+    const notional = Number(s) * mark;
+    if (!reduceOnly && notional < MIN_ORDER_VALUE_USD) {
+        throw new PerpOrderTooSmallError(market.asset, s, Math.round(notional * 100) / 100, MIN_ORDER_VALUE_USD);
+    }
+    const order = {
+        a: market.assetIndex,
+        b: isBuy,
+        p,
+        s,
+        r: reduceOnly,
+        t: { limit: { tif: 'Ioc' } },
+        ...(input.cloid ? { c: input.cloid } : {}),
+    };
+    return { type: 'order', orders: [order], grouping: 'na' };
+}
+function markPrice(market) {
+    const mark = Number(market.markPx);
+    if (!Number.isFinite(mark) || mark <= 0) {
+        throw new HyperCoreError(`Hyperliquid reported no usable mark price for ${market.asset} (got ${JSON.stringify(market.markPx)}), so an order cannot be priced against it.`);
+    }
+    return mark;
+}
+/**
+ * Round a price onto Hyperliquid's grid: at most 5 significant figures, and at
+ * most `6 - szDecimals` decimals.
+ *
+ * Rounded in the direction that keeps the order marketable — up for a buy, down
+ * for a sell — so the grid never eats the slippage it was given.
+ */
+function formatPerpPrice(price, szDecimals, roundUp) {
+    const decimals = Math.max(0, PERP_PRICE_DECIMAL_BUDGET - szDecimals);
+    const significant = roundSignificant(price, MAX_PRICE_SIGNIFICANT_FIGURES, roundUp);
+    return trimDecimal(roundToGrid(significant, decimals, roundUp).toFixed(decimals));
+}
+/** Round a size down onto the asset's size grid — never up past what was asked. */
+function formatPerpSize(size, szDecimals) {
+    return trimDecimal(roundToGrid(size, szDecimals, false).toFixed(szDecimals));
+}
+function roundSignificant(value, digits, roundUp) {
+    if (value === 0)
+        return 0;
+    const magnitude = Math.floor(Math.log10(Math.abs(value)));
+    return roundToFactor(value, 10 ** (digits - 1 - magnitude), roundUp);
+}
+function roundToGrid(value, decimals, roundUp) {
+    return roundToFactor(value, 10 ** decimals, roundUp);
+}
+function roundToFactor(value, factor, roundUp) {
+    // Binary floats leave dust in the last ulp, and `ceil`/`floor` would turn it
+    // into a whole extra tick. 15 digits is the widest a double carries exactly,
+    // so it clears the dust without rounding away a digit the caller meant.
+    const scaled = Number((value * factor).toPrecision(15));
+    return (roundUp ? Math.ceil(scaled) : Math.floor(scaled)) / factor;
+}
+/**
+ * Hyperliquid normalises a decimal before encoding it, so `"1.50"` and `"1.5"`
+ * are one price with two spellings. Emitting the normalised one keeps the
+ * string a caller reads in the action identical to the one that gets hashed
+ * into the agent authorising it.
+ */
+function trimDecimal(value) {
+    if (!value.includes('.'))
+        return value;
+    const trimmed = value.replace(/0+$/, '').replace(/\.$/, '');
+    return trimmed === '' || trimmed === '-' ? '0' : trimmed;
+}
+export { buildClosePerpOrder, buildOpenPerpOrder, formatPerpPrice, formatPerpSize, };

package/dist/src/hypercore/resolve.d.ts

@@ -0,0 +1,10 @@
+import type { Address } from 'viem';
+import type { HyperCoreAction } from '../clients/orchestrator/public.js';
+import { type HyperliquidConfig } from './market.js';
+import type { HyperCoreOptions } from './types.js';
+export declare function resolveHyperCoreAction(input: {
+    readonly options: HyperCoreOptions | undefined;
+    readonly account: Address;
+    readonly hyperliquid?: HyperliquidConfig;
+}): Promise<HyperCoreAction | undefined>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/src/hypercore/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../hypercore/resolve.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAErE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,wBAAsB,sBAAsB,CAAC,KAAK,EAAE;IAClD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAA;IAC9C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAA;CACzC,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAsBvC"}

package/dist/src/hypercore/resolve.js

@@ -0,0 +1,30 @@
+// Turns the declarative `hyperCore` on a transaction into the concrete action
+// the orchestrator quotes against.
+//
+// This runs inside `prepareTransaction`, before the quote, because that is the
+// last moment it can: the agent authorising the action is derived from the
+// action's own bytes, and the quote's `signData` carries a registration for that
+// agent. Nothing about the action — the price included — can be chosen after.
+import { NoOpenPerpPositionError } from './errors.js';
+import { getPerpMarket, getPerpPosition, } from './market.js';
+import { buildClosePerpOrder, buildOpenPerpOrder } from './orders.js';
+export async function resolveHyperCoreAction(input) {
+    const { options } = input;
+    if (!options)
+        return undefined;
+    if (options.action)
+        return options.action;
+    if (options.openPerp) {
+        const market = await getPerpMarket(options.openPerp.asset, input.hyperliquid);
+        return buildOpenPerpOrder(market, options.openPerp);
+    }
+    const request = options.closePerp;
+    const [market, position] = await Promise.all([
+        getPerpMarket(request.asset, input.hyperliquid),
+        getPerpPosition(input.account, request.asset, input.hyperliquid),
+    ]);
+    if (!position) {
+        throw new NoOpenPerpPositionError(request.asset, input.account);
+    }
+    return buildClosePerpOrder(market, position, request);
+}

package/dist/src/hypercore/types.d.ts

@@ -0,0 +1,80 @@
+import type { Hex } from 'viem';
+import type { HyperCoreAction } from '../clients/orchestrator/public.js';
+/** Size, either as a USD notional to convert or in units of the asset. */
+type PerpOrderSize = {
+    /**
+     * Position size in USD, converted at the market's mark and rounded DOWN
+     * to the asset's size precision, so the result never exceeds what you
+     * asked for.
+     *
+     * This is the position's notional, not the collateral behind it — at 5x
+     * leverage a $25 position needs $5 of margin, and it is the margin the
+     * transaction's `tokenRequests` deliver.
+     */
+    notionalUsd: number;
+    size?: never;
+} | {
+    /** Position size in units of the asset, e.g. `'0.0002'` BTC. */
+    size: string;
+    notionalUsd?: never;
+};
+/** Open a perpetual position as part of this transaction. */
+type OpenPerpRequest = PerpOrderSize & {
+    /** Ticker as Hyperliquid names it — the coin alone, e.g. `BTC`. */
+    asset: string;
+    direction: 'long' | 'short';
+    /**
+     * How far through the mark to place the limit, in basis points. Defaults to
+     * 50 (0.5%).
+     *
+     * The price is fixed when the transaction is signed but the order is not
+     * placed until the collateral has bridged, so this is the room the book is
+     * allowed to move in between. Too tight and the order is refused with the
+     * funds already on HyperCore.
+     */
+    slippageBps?: number;
+    /** Optional client order id — 128-bit hex — echoed back by the exchange. */
+    cloid?: Hex;
+};
+/** Close an open perpetual position as part of this transaction. */
+interface ClosePerpRequest {
+    /** Ticker as Hyperliquid names it — the coin alone, e.g. `BTC`. */
+    asset: string;
+    /** Close only part of the position, in units of the asset. */
+    size?: string;
+    /** How far through the mark to place the limit, in basis points. */
+    slippageBps?: number;
+    /** Optional client order id — 128-bit hex — echoed back by the exchange. */
+    cloid?: Hex;
+}
+/**
+ * What this transaction does on HyperCore. Exactly one of the three.
+ *
+ * `openPerp` and `closePerp` are resolved for you: the asset index, the price
+ * and size grids, and the mark to price against are all read from Hyperliquid
+ * while the transaction is prepared. `action` is the escape hatch — a
+ * Hyperliquid L1 action passed through exactly as you wrote it, for the cases
+ * the two above do not cover.
+ *
+ * An action that needs collateral (opening a position) must be paired with
+ * `tokenRequests` that deliver it; one that does not (a close, a cancel, a
+ * leverage change) rides a transaction that requests no tokens.
+ *
+ * One per transaction, whichever form: an agent authorises exactly one action,
+ * and registering a second evicts the first.
+ */
+type HyperCoreOptions = {
+    openPerp: OpenPerpRequest;
+    closePerp?: never;
+    action?: never;
+} | {
+    closePerp: ClosePerpRequest;
+    openPerp?: never;
+    action?: never;
+} | {
+    action: HyperCoreAction;
+    openPerp?: never;
+    closePerp?: never;
+};
+export type { ClosePerpRequest, HyperCoreOptions, OpenPerpRequest, PerpOrderSize, };
+//# sourceMappingURL=types.d.ts.map

package/dist/src/hypercore/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../hypercore/types.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAErE,0EAA0E;AAC1E,KAAK,aAAa,GACd;IACE;;;;;;;;OAQG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,KAAK,CAAA;CACb,GACD;IACE,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,KAAK,CAAA;CACpB,CAAA;AAEL,6DAA6D;AAC7D,KAAK,eAAe,GAAG,aAAa,GAAG;IACrC,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;IAC3B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,GAAG,CAAA;CACZ,CAAA;AAED,oEAAoE;AACpE,UAAU,gBAAgB;IACxB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,GAAG,CAAA;CACZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,KAAK,gBAAgB,GACjB;IAAE,QAAQ,EAAE,eAAe,CAAC;IAAC,SAAS,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,GAChE;IAAE,SAAS,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAA;CAAE,GACjE;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;IAAC,SAAS,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAEpE,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,aAAa,GACd,CAAA"}

package/dist/src/hypercore/types.js

@@ -0,0 +1,8 @@
+// The HyperCore surface of a transaction: what you want done on Hyperliquid,
+// stated as data rather than built by hand.
+//
+// `openPerp` and `closePerp` are DECLARATIVE — `prepareTransaction` resolves
+// them into a concrete action before it quotes, because that is when the action
+// has to exist: the agent authorising it is derived from its bytes, and the
+// signature covers a registration carrying that agent's address.
+export {};

package/dist/src/index.d.ts

@@ -7,8 +7,8 @@ import { WEBAUTHN_VALIDATOR_ADDRESS } from './modules/validators/webauthn.js';
 export { RhinestoneSDK, hyperCorePerp, hyperCoreSpot, solanaMainnet, stellarMainnet, tronMainnet, OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_V2_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, };
 export type { RhinestoneAccount, SignedIntentData } from './api/account.js';
 export type { DestinationChain, NonEvmAddress, NonEvmChain, } from './chains/non-evm.js';
-export type { AppFeeBalances, AppFeeRate, ApprovalRequired, AuxiliaryFunds, BridgeFill, ChainOperation, FailureReason, IntentInput, IntentOpStatus, OperationStatus, OriginSignature, Portfolio, ProtocolFeeRate, Quote, SerializedIntentInput, SettlementLayer, SettlementLayerFilter, SignData, SplitIntentsInput, SplitIntentsResult, SwapQuoter, SwapQuoterFilter, TokenRequirements, WrapRequired, } from './clients/orchestrator/public.js';
-export type { AccountProviderConfig, AccountType, BundlerConfig, Call, CallInput, ChainSessionConfig, CrossChainPermissionInput, CrossChainPermit, CrossChainSettlementLayer, FromLeg, GuardiansSignerSet, MultiFactorValidatorConfig, NonEvmTokenRequest, NonEvmTokenRequests, OwnableValidatorConfig, OwnerSet, ParamConstraint, PaymasterConfig, Permission, PermissionFunctionConfig, Permit2ClaimPolicy, Policy, ProviderConfig, QuorumOwner, QuorumValidatorConfig, Recovery, RhinestoneAccountConfig, Session, SessionDefinition, SessionSigning, SessionSigningContent, SignerSet, SourceCallInput, SourceCallProvidedFunds, SwapScope, TokenRequest, TokenSymbol, ToLeg, Transaction, UniversalActionPolicyParamCondition, WebauthnValidatorConfig, } from './config/account.js';
+export type { AppFeeBalances, AppFeeRate, ApprovalRequired, AuxiliaryFunds, BridgeFill, ChainOperation, FailureReason, HyperCoreAction, HyperCoreBatchModifyAction, HyperCoreCancelAction, HyperCoreCancelByCloidAction, HyperCoreModifyAction, HyperCoreOrder, HyperCoreOrderAction, HyperCoreOrderType, HyperCoreTimeInForce, HyperCoreUpdateIsolatedMarginAction, HyperCoreUpdateLeverageAction, IntentInput, IntentOpStatus, OperationStatus, OriginSignature, Portfolio, ProtocolFeeRate, Quote, SerializedIntentInput, SettlementLayer, SettlementLayerFilter, SignData, SplitIntentsInput, SplitIntentsResult, SwapQuoter, SwapQuoterFilter, TokenRequirements, WrapRequired, } from './clients/orchestrator/public.js';
+export type { AccountProviderConfig, AccountType, BundlerConfig, Call, CallInput, ChainSessionConfig, ClosePerpRequest, CrossChainPermissionInput, CrossChainPermit, CrossChainSettlementLayer, FromLeg, GuardiansSignerSet, HyperCoreOptions, HyperliquidConfig, MultiFactorValidatorConfig, NonEvmTokenRequest, NonEvmTokenRequests, OpenPerpRequest, OwnableValidatorConfig, OwnerSet, ParamConstraint, PaymasterConfig, Permission, PermissionFunctionConfig, Permit2ClaimPolicy, Policy, ProviderConfig, QuorumOwner, QuorumValidatorConfig, Recovery, RhinestoneAccountConfig, Session, SessionDefinition, SessionSigning, SessionSigningContent, SignerSet, SourceCallInput, SourceCallProvidedFunds, SwapScope, TokenRequest, TokenSymbol, ToLeg, Transaction, UniversalActionPolicyParamCondition, WebauthnValidatorConfig, } from './config/account.js';
 export type { OwnerPasskeySignature, OwnerSignature, OwnerSignatureData, SignAsOwnerOptions, } from './signing/types.js';
 export type { PreparedQuotes, PreparedTransactionData, QuoteSelection, SignedTransactionData, TransactionResult, } from './transactions/intents/types.js';
 export type { PreparedUserOperationData, SignedUserOperationData, UserOperationResult, } from './transactions/user-operations/types.js';

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EACZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,8BAA8B,EAC9B,iCAAiC,EAClC,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAA;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAA;AAC3F,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAE1E,OAAO,EACL,aAAa,EAEb,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EAEX,yBAAyB,EACzB,0BAA0B,EAC1B,8BAA8B,EAC9B,iCAAiC,EACjC,8BAA8B,GAC/B,CAAA;AAED,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACxE,YAAY,EACV,gBAAgB,EAChB,aAAa,EACb,WAAW,GACZ,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,cAAc,EACd,aAAa,EACb,WAAW,EACX,cAAc,EACd,eAAe,EACf,eAAe,EACf,SAAS,EACT,eAAe,EACf,KAAK,EACL,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,QAAQ,EACR,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,+BAA+B,CAAA;AACtC,YAAY,EACV,qBAAqB,EACrB,WAAW,EACX,aAAa,EACb,IAAI,EACJ,SAAS,EACT,kBAAkB,EAClB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,EACzB,OAAO,EACP,kBAAkB,EAClB,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,UAAU,EACV,wBAAwB,EACxB,kBAAkB,EAClB,MAAM,EACN,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,uBAAuB,EACvB,OAAO,EACP,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,SAAS,EACT,eAAe,EACf,uBAAuB,EACvB,SAAS,EACT,YAAY,EACZ,WAAW,EACX,KAAK,EACL,WAAW,EACX,mCAAmC,EACnC,uBAAuB,GACxB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,sCAAsC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EACZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,8BAA8B,EAC9B,iCAAiC,EAClC,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAA;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,4CAA4C,CAAA;AAC3F,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAE1E,OAAO,EACL,aAAa,EAEb,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EAEX,yBAAyB,EACzB,0BAA0B,EAC1B,8BAA8B,EAC9B,iCAAiC,EACjC,8BAA8B,GAC/B,CAAA;AAED,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACxE,YAAY,EACV,gBAAgB,EAChB,aAAa,EACb,WAAW,GACZ,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,UAAU,EACV,cAAc,EACd,aAAa,EACb,eAAe,EACf,0BAA0B,EAC1B,qBAAqB,EACrB,4BAA4B,EAC5B,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,mCAAmC,EACnC,6BAA6B,EAC7B,WAAW,EACX,cAAc,EACd,eAAe,EACf,eAAe,EACf,SAAS,EACT,eAAe,EACf,KAAK,EACL,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,QAAQ,EACR,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,+BAA+B,CAAA;AACtC,YAAY,EACV,qBAAqB,EACrB,WAAW,EACX,aAAa,EACb,IAAI,EACJ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,EAChB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,EACzB,OAAO,EACP,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,0BAA0B,EAC1B,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,sBAAsB,EACtB,QAAQ,EACR,eAAe,EACf,eAAe,EACf,UAAU,EACV,wBAAwB,EACxB,kBAAkB,EAClB,MAAM,EACN,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,uBAAuB,EACvB,OAAO,EACP,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,SAAS,EACT,eAAe,EACf,uBAAuB,EACvB,SAAS,EACT,YAAY,EACZ,WAAW,EACX,KAAK,EACL,WAAW,EACX,mCAAmC,EACnC,uBAAuB,GACxB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EACV,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,sCAAsC,CAAA"}

package/dist/src/signing/typed-data.d.ts

@@ -31,6 +31,12 @@ export declare function resolveAccountTypedDataSigning(input: {
      * the EIP-712 hash of `typedData`.
      */
     readonly validationHash?: Hex;
+    /**
+     * Set when one signature over this payload has to validate on more than one
+     * chain (a `MultiChainOps` set whose leaves span chains). `chain` is then
+     * only the leg being resolved, not the reach of the signature.
+     */
+    readonly spansMultipleChains?: boolean;
 }): AccountTypedDataSigningRoute;
 export declare function createTypedDataSigningPlan(input: TypedDataSigningPlanInput): SigningPlan;
 export declare function signAccountTypedData(input: {

package/dist/src/signing/typed-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-data.d.ts","sourceRoot":"","sources":["../../../signing/typed-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAiB,KAAK,mBAAmB,EAAE,MAAM,MAAM,CAAA;AAMxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAG/C,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAA;AAQ9E,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,sBAAsB,CAAA;IACjD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,2BAA2B,CAAA;IACxD,QAAQ,CAAC,kBAAkB,EAAE,wBAAwB,CAAA;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,IAAI,CAClB,oBAAoB,EACpB,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CACrC,CAAA;IACD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAC3B,OAAO,SAAS,EAAE,qBAAqB,EACvC;QAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;KAAE,CACxC,CAAA;CACF;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,SAAS,GAAG,YAAY,CAAA;IAC9C,QAAQ,CAAC,eAAe,EAAE,oBAAoB,GAAG,uBAAuB,CAAA;IACxE,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,0BAA0B,CAAA;IAC9E,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAA;CAClD;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,GAAG,CAAA;CAC9B,GAAG,4BAA4B,CA2C/B;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,yBAAyB,GAC/B,WAAW,CAkBb;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;CAC5C,GAAG,OAAO,CAAC;IACV,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,CAAC,CAmBD;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,cAAc,GACtB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CA6D/B"}
+{"version":3,"file":"typed-data.d.ts","sourceRoot":"","sources":["../../../signing/typed-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAiB,KAAK,mBAAmB,EAAE,MAAM,MAAM,CAAA;AAMxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAG/C,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,WAAW,CAAA;AAQ9E,OAAO,KAAK,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,sBAAsB,CAAA;IACjD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,2BAA2B,CAAA;IACxD,QAAQ,CAAC,kBAAkB,EAAE,wBAAwB,CAAA;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,IAAI,CAClB,oBAAoB,EACpB,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CACrC,CAAA;IACD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAC3B,OAAO,SAAS,EAAE,qBAAqB,EACvC;QAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;KAAE,CACxC,CAAA;CACF;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAA;IACzC,QAAQ,CAAC,WAAW,EAAE,SAAS,GAAG,YAAY,CAAA;IAC9C,QAAQ,CAAC,eAAe,EAAE,oBAAoB,GAAG,uBAAuB,CAAA;IACxE,QAAQ,CAAC,kBAAkB,EAAE,oBAAoB,GAAG,0BAA0B,CAAA;IAC9E,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAA;CAClD;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAA;IACvC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,GAAG,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CACvC,GAAG,4BAA4B,CA8D/B;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,yBAAyB,GAC/B,WAAW,CAkBb;AAED,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAA;CAC5C,GAAG,OAAO,CAAC;IACV,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CACvC,CAAC,CAmBD;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,yBAAyB,EAChC,OAAO,EAAE,cAAc,GACtB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CA6D/B"}

package/dist/src/signing/typed-data.js

@@ -15,6 +15,19 @@ export function resolveAccountTypedDataSigning(input) {
         input.context.validatorCapabilities.compatibilityKey.moduleAddress.toLowerCase() ===
             K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
     const requiresRawHash = accountKind === 'kernel' || input.context.validator.kind === 'quorum';
+    // A quorum validator hashes the chain id into what the signer signs, and
+    // Startale's K1 route puts it in the ERC-7739 verifier domain. Either one
+    // yields a signature that validates on `input.chain` and nowhere else, so a
+    // payload whose legs are spread across chains must be refused here — while
+    // the caller is still preparing, not after the user has approved a bundle
+    // whose later legs cannot execute. Same-chain legs are unaffected, and
+    // Kernel's wrapping is address-only, so it stays fine either way.
+    if (input.spansMultipleChains &&
+        (input.context.validator.kind === 'quorum' || startaleK1)) {
+        throw new Error(`Cannot sign a multi-chain intent payload with ${input.context.validator.kind === 'quorum'
+            ? 'a quorum validator'
+            : "Startale's K1 validator"}: it binds the chain id into the signed hash, so the signature would validate only on chain ${input.chain.id} and fail on the intent's legs on other chains`);
+    }
     const messagePayload = requiresRawHash
         ? resolveAccountValidatorSignableHash({
             hash: payload,

package/dist/src/transactions/intents/origin-chain.d.ts

@@ -0,0 +1,35 @@
+import type { TypedDataDefinition } from 'viem';
+/**
+ * The chain an origin payload is signed for.
+ *
+ * Throws rather than yielding `NaN` for a payload that names no chain at all:
+ * the value flows into signer and session resolution, and on this path a
+ * failure lands after the user has already approved the intent.
+ */
+export declare function originChainId(typedData: TypedDataDefinition): number;
+/**
+ * The chain whose account runtime signs an intent, read off the last origin
+ * payload as the callers here have always done.
+ *
+ * A `MultiChainOps` quote carries exactly one origin entry however many legs it
+ * covers, so first and last are the same payload and the choice only matters
+ * for the per-leg shape.
+ */
+export declare function accountChainIdFromOrigins(origins: readonly TypedDataDefinition[]): number;
+/**
+ * True when one signature over this payload has to validate on more than one
+ * chain.
+ *
+ * An absent domain chainId is not the test on its own: `MultiChainOps` does not
+ * require its leaves to be on DIFFERENT chains, and same-chain legs with
+ * distinct nonces are a valid set — that is how a bundle splits its destination
+ * ops across blocks. Such a payload is chainless in the domain yet every leg
+ * runs on one chain, so a chain-bound wrapper still validates on all of them.
+ *
+ * Callers that wrap the digest with anything chain-specific must refuse only
+ * the genuinely multi-chain case, where signing against the leg being resolved
+ * gives a signature that fails on the rest — on chain, after the user has
+ * approved.
+ */
+export declare function signatureSpansMultipleChains(typedData: TypedDataDefinition): boolean;
+//# sourceMappingURL=origin-chain.d.ts.map

package/dist/src/transactions/intents/origin-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"origin-chain.d.ts","sourceRoot":"","sources":["../../../../transactions/intents/origin-chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAA;AA0C/C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAkBpE;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,MAAM,CAIR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAGT"}

package/dist/src/transactions/intents/origin-chain.js

@@ -0,0 +1,89 @@
+// A `SingleChainOps` origin payload binds its chain in the EIP-712 domain, so
+// `domain.chainId` names it. A `MultiChainOps` payload is one signature over
+// every leg of a multi-leg bundle, and the contract verifies it with
+// `_hashTypedDataSansChainId` — the domain deliberately carries no chainId, and
+// each leg's chain lives in its own `ChainOps` leaf instead.
+//
+// The signature is identical on every leg, so any leaf is a valid context for
+// resolving a signer; the first is taken because the leaves are in signed order
+// and the choice has to be deterministic.
+function readChainId(value) {
+    if (typeof value !== 'bigint' &&
+        typeof value !== 'number' &&
+        typeof value !== 'string') {
+        return undefined;
+    }
+    const chainId = Number(value);
+    return Number.isFinite(chainId) ? chainId : undefined;
+}
+function domainChainId(typedData) {
+    const { chainId } = typedData.domain ?? {};
+    return chainId === null ? undefined : chainId;
+}
+function leafChainIds(typedData) {
+    const ops = typedData.message?.ops;
+    if (!Array.isArray(ops))
+        return [];
+    const chainIds = [];
+    for (const leaf of ops) {
+        const chainId = readChainId(leaf?.chainId);
+        if (chainId !== undefined)
+            chainIds.push(chainId);
+    }
+    return chainIds;
+}
+/**
+ * The chain an origin payload is signed for.
+ *
+ * Throws rather than yielding `NaN` for a payload that names no chain at all:
+ * the value flows into signer and session resolution, and on this path a
+ * failure lands after the user has already approved the intent.
+ */
+export function originChainId(typedData) {
+    const fromDomain = domainChainId(typedData);
+    if (fromDomain !== undefined) {
+        const chainId = readChainId(fromDomain);
+        if (chainId === undefined) {
+            throw new Error(`Intent origin payload has an unreadable domain chainId: ${String(fromDomain)}`);
+        }
+        return chainId;
+    }
+    const [fromLeaf] = leafChainIds(typedData);
+    if (fromLeaf !== undefined)
+        return fromLeaf;
+    throw new Error(`Intent origin payload "${String(typedData.primaryType)}" names no chain: it carries neither a domain chainId nor a ChainOps leaf to read one from`);
+}
+/**
+ * The chain whose account runtime signs an intent, read off the last origin
+ * payload as the callers here have always done.
+ *
+ * A `MultiChainOps` quote carries exactly one origin entry however many legs it
+ * covers, so first and last are the same payload and the choice only matters
+ * for the per-leg shape.
+ */
+export function accountChainIdFromOrigins(origins) {
+    const last = origins.at(-1);
+    if (!last)
+        throw new Error('Intent quote has no origin payloads');
+    return originChainId(last);
+}
+/**
+ * True when one signature over this payload has to validate on more than one
+ * chain.
+ *
+ * An absent domain chainId is not the test on its own: `MultiChainOps` does not
+ * require its leaves to be on DIFFERENT chains, and same-chain legs with
+ * distinct nonces are a valid set — that is how a bundle splits its destination
+ * ops across blocks. Such a payload is chainless in the domain yet every leg
+ * runs on one chain, so a chain-bound wrapper still validates on all of them.
+ *
+ * Callers that wrap the digest with anything chain-specific must refuse only
+ * the genuinely multi-chain case, where signing against the leg being resolved
+ * gives a signature that fails on the rest — on chain, after the user has
+ * approved.
+ */
+export function signatureSpansMultipleChains(typedData) {
+    if (domainChainId(typedData) !== undefined)
+        return false;
+    return new Set(leafChainIds(typedData)).size > 1;
+}