@gibs/bridge-sdk 1.13.0 → 1.17.0

package/dist/cjs/execution.js

@@ -0,0 +1,468 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPulseXSectionQuote = exports.planCandidateExecution = exports.planExecution = exports.assumeNoAllowance = void 0;
+const viem_1 = require("viem");
+const abis = __importStar(require("./abis.js"));
+const config_js_1 = require("./config.js");
+const consolidated_quote_js_1 = require("./consolidated-quote.js");
+const pulsex_js_1 = require("./routing/carriers/pulsex.js");
+const swap_transactions_js_1 = require("./routing/swap-transactions.js");
+const settings_js_1 = require("./settings.js");
+/**
+ * An {@link AllowanceReader} that reports no allowance anywhere, so the plan
+ * includes every approval. For a caller that reads allowances itself at send
+ * time.
+ */
+const assumeNoAllowance = async () => 0n;
+exports.assumeNoAllowance = assumeNoAllowance;
+const refusal = (value) => ({ kind: 'refused', refusal: value });
+/** The fee director a delivery choice encodes, or null when the reader buys no delivery. */
+const encodeDelivery = ({ leg, pathway, }) => {
+    const { delivery } = leg;
+    if (!delivery.shouldDeliver)
+        return { kind: 'encoded', feeDirector: null };
+    if (!pathway.requiresDelivery)
+        return refusal({ reason: 'delivery-not-offered' });
+    // A zero fee pays no relayer, so the transfer would wait for a delivery that never comes.
+    if (delivery.fee.maximumFee <= 0n)
+        return refusal({ reason: 'delivery-fee-missing' });
+    const feeDirector = (0, settings_js_1.feeDirectorStructEncoded)({
+        recipient: leg.recipient,
+        bridgePathway: pathway,
+        feeType: delivery.fee.feeType,
+        priceCorrective: delivery.fee.priceCorrective,
+        gasTipFee: delivery.fee.gasTipFee,
+        percentFee: delivery.fee.percentFee,
+        feeTypeSettings: (0, settings_js_1.feeTypeSettings)({ feeType: delivery.fee.feeType, unwrap: leg.unwrap }),
+        limit: delivery.fee.maximumFee,
+        assetOut: delivery.fee.assetOut,
+    });
+    if (feeDirector === null)
+        return refusal({ reason: 'delivery-fee-unencodable' });
+    return { kind: 'encoded', feeDirector };
+};
+const deliveryTermsOf = (delivery) => {
+    if (!delivery.shouldDeliver)
+        return { status: 'not-requested' };
+    return {
+        status: 'requested',
+        feeType: delivery.fee.feeType,
+        maximumFee: delivery.fee.maximumFee,
+        feeToken: delivery.fee.assetOut,
+    };
+};
+const omnibridgeCalls = (leg, account) => {
+    if (leg.amountIn <= 0n)
+        return refusal({ reason: 'amount-not-positive' });
+    const pathway = (0, settings_js_1.bridgePathway)({ bridgeKey: leg.bridgeKey, isProd: leg.isProd, assetIn: leg.assetIn });
+    if (pathway === null)
+        return refusal({ reason: 'no-pathway' });
+    const encoded = encodeDelivery({ leg, pathway });
+    if (encoded.kind !== 'encoded')
+        return encoded;
+    const { feeDirector } = encoded;
+    const dataParam = (0, settings_js_1.destinationDataParam)({
+        recipient: leg.recipient,
+        bridgePathway: pathway,
+        assetIn: leg.assetIn,
+        destinationRouter: pathway.destinationRouter,
+        feeDirectorStructEncoded: feeDirector,
+        assetLink: leg.assetLink,
+        shouldDeliver: leg.delivery.shouldDeliver,
+        unwrap: leg.unwrap,
+    });
+    const call = (0, settings_js_1.transactionInputs)({
+        bridgeKey: leg.bridgeKey,
+        signedCrossing: { originChainId: Number(leg.bridgeKey[1]), destinationChainId: Number(leg.bridgeKey[2]) },
+        bridgePathway: pathway,
+        assetIn: leg.assetIn,
+        recipient: leg.recipient,
+        account,
+        assetLink: leg.assetLink,
+        destinationDataParam: dataParam,
+        amountToBridge: leg.amountIn,
+        feeDirectorStructEncoded: feeDirector,
+        shouldDeliver: leg.delivery.shouldDeliver,
+    });
+    if (call === null)
+        return refusal({ reason: 'bridge-call-refused' });
+    return {
+        kind: 'calls',
+        approval: (0, settings_js_1.omnibridgeApproval)({
+            bridgePathway: pathway,
+            assetIn: leg.assetIn,
+            assetLink: leg.assetLink,
+            amountToBridge: leg.amountIn,
+        }),
+        action: { chainId: Number(leg.bridgeKey[1]), kind: 'bridge', ...call, gasLimit: null },
+        delivery: deliveryTermsOf(leg.delivery),
+    };
+};
+const pulseXSwapCalls = (leg) => {
+    const { edge } = leg.hop;
+    const chainId = edge.from.chainId;
+    const routerAddress = (0, pulsex_js_1.pulseXRouterForEdge)(edge);
+    // The builder refuses a hop that records no priced path, a router other
+    // than the edge's own, and a leg on screen that disagrees.
+    const call = (0, swap_transactions_js_1.buildPulseXSwapTransaction)({
+        hop: leg.hop,
+        amountIn: leg.amountIn,
+        minAmountOut: leg.minAmountOut,
+        recipient: leg.recipient,
+        deadline: leg.deadline,
+        signedLeg: { kind: 'swap', chainId },
+        chainId,
+        routerAddress,
+    });
+    if (call === null || routerAddress === null)
+        return refusal({ reason: 'swap-refused' });
+    const spendsNative = edge.from.address.toLowerCase() === viem_1.zeroAddress;
+    return {
+        kind: 'calls',
+        approval: spendsNative
+            ? null
+            : { chainId, token: edge.from.address, spender: routerAddress, minimum: leg.amountIn },
+        action: { chainId, kind: 'swap', ...call, gasLimit: null },
+        delivery: null,
+    };
+};
+const wrapCalls = (leg) => {
+    const call = (0, swap_transactions_js_1.buildWrapTransaction)({ edge: leg.edge, amountIn: leg.amountIn });
+    if (call === null)
+        return refusal({ reason: 'wrap-refused' });
+    const wraps = leg.edge.from.address.toLowerCase() === viem_1.zeroAddress;
+    return {
+        kind: 'calls',
+        approval: null,
+        action: { chainId: leg.edge.from.chainId, kind: wraps ? 'wrap' : 'unwrap', ...call, gasLimit: null },
+        delivery: null,
+    };
+};
+const aggregatorCalls = (leg) => {
+    const origin = (0, consolidated_quote_js_1.aggregatorOriginCalls)({ quote: leg.quote, request: leg.request });
+    if (origin.kind === 'refused')
+        return refusal({ reason: 'aggregator-origin-refused', origin: origin.refusal });
+    const { approval, deposit } = origin;
+    const staysOnChain = leg.request.toChainId === leg.request.fromChainId;
+    return {
+        kind: 'calls',
+        approval,
+        action: {
+            chainId: leg.request.fromChainId,
+            kind: staysOnChain ? 'swap' : 'bridge',
+            to: deposit.to,
+            data: deposit.data,
+            value: deposit.value,
+            gasLimit: deposit.gasLimit,
+        },
+        delivery: null,
+    };
+};
+const legCalls = (leg, account) => {
+    if (leg.kind === 'omnibridge')
+        return omnibridgeCalls(leg, account);
+    if (leg.kind === 'pulsex-swap')
+        return pulseXSwapCalls(leg);
+    if (leg.kind === 'wrap')
+        return wrapCalls(leg);
+    return aggregatorCalls(leg);
+};
+/** The approve transactions an approval needs now: none when the allowance on chain covers it. */
+const approvalTransactions = async ({ approval, account, readAllowance, }) => {
+    const allowance = await readAllowance(approval.chainId, approval.token, account, approval.spender);
+    return (0, settings_js_1.approvalAmounts)({ allowance, minimum: approval.minimum }).map((amount) => ({
+        chainId: approval.chainId,
+        kind: 'approve',
+        ...(0, settings_js_1.approveCall)({ token: approval.token, spender: approval.spender, amount }),
+        gasLimit: null,
+    }));
+};
+/**
+ * Plans the transactions for a list of legs, in order.
+ *
+ * Each leg contributes the exact approval it needs when the allowance on
+ * chain does not cover it (a reset to zero first when a smaller allowance
+ * remains), then its own call. Nothing is sent.
+ *
+ * @param options.account - the account that signs every transaction
+ * @param options.legs - the legs, in the order the wallet signs them
+ * @param options.readAllowance - reads an allowance on chain; see {@link AllowanceReader}
+ * @returns the ordered transactions, or the first leg that cannot be planned
+ */
+const planExecution = async ({ account, legs, readAllowance, }) => {
+    const calls = legs.map((leg) => legCalls(leg, account));
+    const refusedIndex = calls.findIndex((entry) => entry.kind === 'refused');
+    const refused = calls[refusedIndex];
+    if (refused !== undefined && refused.kind === 'refused') {
+        return { kind: 'refused', legIndex: refusedIndex, refusal: refused.refusal };
+    }
+    const planned = calls.flatMap((entry) => (entry.kind === 'calls' ? [entry] : []));
+    const perLeg = await Promise.all(planned.map(async (entry) => {
+        const approvals = entry.approval === null
+            ? []
+            : await approvalTransactions({ approval: entry.approval, account, readAllowance });
+        return [...approvals, entry.action];
+    }));
+    const ordered = perLeg.flat();
+    const transactions = ordered.map((action, index) => ({ ...action, waitForReceipt: index < ordered.length - 1 }));
+    const deliveries = planned.flatMap((entry, legIndex) => entry.delivery === null ? [] : [{ ...entry.delivery, legIndex }]);
+    return { kind: 'planned', transactions, deliveries };
+};
+exports.planExecution = planExecution;
+const OMNIBRIDGE_CARRIERS = new Set(Object.values(config_js_1.Providers));
+const isOmnibridgeCarrier = (carrier) => OMNIBRIDGE_CARRIERS.has(carrier);
+const missing = (needs) => ({
+    kind: 'refused',
+    refusal: { reason: 'section-inputs-missing', needs },
+});
+const shape = (detail) => ({ kind: 'refused', refusal: { reason: 'section-shape', detail } });
+const omnibridgeSectionLeg = ({ carrier, from, to, inputs, assetIn, }) => {
+    if (inputs.omnibridge === undefined)
+        return missing('omnibridge');
+    return {
+        kind: 'leg',
+        leg: {
+            kind: 'omnibridge',
+            bridgeKey: [carrier, (0, config_js_1.toChain)(from.chainId), (0, config_js_1.toChain)(to.chainId)],
+            isProd: inputs.omnibridge.isProd,
+            assetIn,
+            assetLink: inputs.omnibridge.assetLink,
+            amountIn: inputs.amountIn,
+            recipient: inputs.recipient,
+            delivery: inputs.omnibridge.delivery,
+            unwrap: inputs.omnibridge.unwrap,
+        },
+    };
+};
+const liveQuoteRequired = { kind: 'refused', refusal: { reason: 'live-quote-required' } };
+const aggregatorSectionLeg = (carrier, inputs) => {
+    if (inputs.aggregator === undefined)
+        return liveQuoteRequired;
+    const { quote, request } = inputs.aggregator;
+    if (quote.provider !== carrier) {
+        return {
+            kind: 'refused',
+            refusal: { reason: 'quote-provider-mismatch', quoteProvider: quote.provider, sectionCarrier: carrier },
+        };
+    }
+    return { kind: 'leg', leg: { kind: 'aggregator', quote, request } };
+};
+const pulseXSectionLeg = (hop, inputs) => {
+    if (inputs.swap === undefined)
+        return missing('swap');
+    const { quotedAmountOut } = inputs.swap;
+    if (quotedAmountOut !== undefined && quotedAmountOut <= 0n) {
+        return { kind: 'refused', refusal: { reason: 'swap-quote-not-positive' } };
+    }
+    // Without a fresh quote the floor comes from the hop's own figure, so it must be a real quote.
+    if (quotedAmountOut === undefined && hop.outcome.kind !== 'quote') {
+        return { kind: 'refused', refusal: { reason: 'swap-estimate-only' } };
+    }
+    return {
+        kind: 'leg',
+        leg: {
+            kind: 'pulsex-swap',
+            hop,
+            amountIn: inputs.amountIn,
+            minAmountOut: (0, swap_transactions_js_1.swapMinimumOut)({
+                quotedAmount: quotedAmountOut ?? hop.outcome.deliveredAmount,
+                slippageBasisPoints: inputs.swap.slippageBasisPoints,
+            }),
+            recipient: inputs.recipient,
+            deadline: inputs.swap.deadline,
+        },
+    };
+};
+/** Turns one section of an engine plan into its leg, dispatching on the first hop's carrier. */
+const planSectionLeg = ({ hops, inputs, resolveToken, }) => {
+    const firstHop = hops[0];
+    if (firstHop === undefined)
+        return shape('the section has no hops');
+    const { carrier, origin, from, to } = firstHop.edge;
+    if (origin === 'by-hand')
+        return { kind: 'refused', refusal: { reason: 'paid-by-hand' } };
+    // An aggregator section may run several hops inside one signature (a fused
+    // omnibridge entry); every other carrier signs exactly one hop.
+    const singleHop = hops.length === 1;
+    if (isOmnibridgeCarrier(carrier)) {
+        if (!singleHop)
+            return shape('an omnibridge section is exactly one hop');
+        return omnibridgeSectionLeg({ carrier, from, to, inputs, assetIn: resolveToken(from) });
+    }
+    if (carrier === 'PulseX') {
+        if (!singleHop)
+            return shape('a swap section is exactly one hop');
+        return pulseXSectionLeg(firstHop, inputs);
+    }
+    if (carrier === 'wrap') {
+        if (!singleHop)
+            return shape('a wrap section is exactly one hop');
+        return { kind: 'leg', leg: { kind: 'wrap', edge: firstHop.edge, amountIn: inputs.amountIn } };
+    }
+    return aggregatorSectionLeg(carrier, inputs);
+};
+/** The sections of a plan, each as its hops. */
+const planSections = (plan) => plan.signatures.map((group) => group.flatMap((hopIndex) => plan.hops[hopIndex] ?? []));
+/**
+ * A candidate built without an engine plan is one signature: either a
+ * same-chain omnibridge crossing (`buildDirectCrossingCandidate`, whose quote
+ * names the bridge) or an aggregator quote.
+ *
+ * THE CANDIDATE'S OWN QUOTE IS NEVER SIGNED. It priced the route on screen
+ * and may be stale or a dry probe; only the live quote in
+ * `inputs.aggregator` is. Without one the section is refused with
+ * `live-quote-required`.
+ */
+const planlessSectionLeg = (candidate, inputs) => {
+    const provider = candidate.quote.provider;
+    if (isOmnibridgeCarrier(provider)) {
+        return omnibridgeSectionLeg({
+            carrier: provider,
+            from: candidate.originToken,
+            to: candidate.destinationToken,
+            inputs,
+            assetIn: candidate.originToken,
+        });
+    }
+    return aggregatorSectionLeg(provider, inputs);
+};
+/**
+ * What is wrong with the requested window of sections, or null when it fits.
+ * A window starts at `firstSectionIndex` and spans `plannedCount` sections.
+ */
+const sectionWindowProblem = ({ firstSectionIndex, plannedCount, sectionCount, }) => {
+    if (!Number.isSafeInteger(firstSectionIndex) || firstSectionIndex < 0) {
+        return `firstSectionIndex must be a non-negative safe integer, received ${firstSectionIndex}`;
+    }
+    if (plannedCount < 1)
+        return `pass at least 1 section input, received ${plannedCount}`;
+    if (firstSectionIndex + plannedCount > sectionCount) {
+        return `sections ${firstSectionIndex} to ${firstSectionIndex + plannedCount - 1} do not fit a route of ${sectionCount} section${sectionCount === 1 ? '' : 's'}`;
+    }
+    return null;
+};
+/**
+ * Plans the transactions for a chosen route candidate: the candidate
+ * `buildRouteCandidateFromPlan` returns for an engine plan (the interface's
+ * `buildCandidateFromEnginePlan`), or a candidate built without a plan.
+ *
+ * ONE SECTION IS ONE SIGNATURE. A plan's `signatures` groups its hops into
+ * sections; the section's first hop names its carrier. An omnibridge section
+ * becomes a crossing, a PulseX section a swap signed on its recorded path, a
+ * wrap section a wrap or unwrap, and any other wallet-signed carrier an
+ * aggregator deposit from the live quote the caller supplies. A section paid
+ * by hand has nothing to sign and is refused.
+ *
+ * A LATER SECTION CAN BE PLANNED ALONE. Pass `firstSectionIndex` to skip the
+ * sections that already landed. The wallet then plans the swap after the
+ * crossing arrived, from the amount that arrived, with a fresh
+ * `swap.quotedAmountOut` and a fresh `swap.deadline`. The slippage floor and the
+ * deadline are not fixed minutes before the swap is signed. Every safety check
+ * still applies to the later section: verified spenders, live quotes for
+ * aggregator sections, exact approvals.
+ *
+ * Every `sectionIndex` in a refusal and every `legIndex` in `deliveries` is
+ * the absolute section index.
+ *
+ * @param inputs - see {@link CandidateExecutionInputs}
+ * @returns the ordered transactions with the deliveries they buy, or the first section that cannot be planned
+ */
+const planCandidateExecution = async (inputs) => {
+    const { candidate, account, readAllowance, resolveToken, sections } = inputs;
+    const firstSectionIndex = inputs.firstSectionIndex ?? 0;
+    const plan = candidate.plan;
+    const allSections = plan === undefined ? null : planSections(plan);
+    const sectionCount = allSections === null ? 1 : allSections.length;
+    const problem = sectionWindowProblem({ firstSectionIndex, plannedCount: sections.length, sectionCount });
+    if (problem !== null) {
+        const validIndex = Number.isSafeInteger(firstSectionIndex) && firstSectionIndex >= 0;
+        return {
+            kind: 'refused',
+            sectionIndex: validIndex ? firstSectionIndex : 0,
+            refusal: { reason: 'section-shape', detail: problem },
+        };
+    }
+    const sectionLegs = sections.map((sectionInputs, index) => allSections === null
+        ? planlessSectionLeg(candidate, sectionInputs)
+        : planSectionLeg({ hops: allSections[firstSectionIndex + index] ?? [], inputs: sectionInputs, resolveToken }));
+    const refusedIndex = sectionLegs.findIndex((entry) => entry.kind === 'refused');
+    const refused = sectionLegs[refusedIndex];
+    if (refused !== undefined && refused.kind === 'refused') {
+        return { kind: 'refused', sectionIndex: firstSectionIndex + refusedIndex, refusal: refused.refusal };
+    }
+    const legs = sectionLegs.flatMap((entry) => (entry.kind === 'leg' ? [entry.leg] : []));
+    const planned = await (0, exports.planExecution)({ account, legs, readAllowance });
+    if (planned.kind === 'refused') {
+        return { kind: 'refused', sectionIndex: firstSectionIndex + planned.legIndex, refusal: planned.refusal };
+    }
+    return {
+        kind: 'planned',
+        transactions: planned.transactions,
+        deliveries: planned.deliveries.map((delivery) => ({ ...delivery, legIndex: firstSectionIndex + delivery.legIndex })),
+        remainingSectionCount: sectionCount - firstSectionIndex - sections.length,
+    };
+};
+exports.planCandidateExecution = planCandidateExecution;
+/**
+ * Reads a fresh quote for a PulseX section: what the router's `getAmountsOut`
+ * says the swap delivers for `amountIn`, along the exact path the swap signs
+ * ({@link pulseXSwapPathForHop}) on the edge's own router. A wallet passes the
+ * result as `swap.quotedAmountOut` just before it signs.
+ *
+ * @param options.hop - the swap hop; its recorded path and edge name what to read
+ * @param options.amountIn - the amount the swap spends, in base units
+ * @param options.client - a client that can call `readContract`
+ * @returns the amount the last token of the path delivers, or null when the hop records no path, names no known router, the amount is not positive, or the read fails or returns nothing
+ */
+const readPulseXSectionQuote = async ({ hop, amountIn, client, }) => {
+    const path = (0, pulsex_js_1.pulseXSwapPathForHop)(hop);
+    const router = (0, pulsex_js_1.pulseXRouterForEdge)(hop.edge);
+    if (path === null || router === null || amountIn <= 0n)
+        return null;
+    try {
+        const amounts = await client.readContract({
+            address: router,
+            abi: abis.univ2Router,
+            functionName: 'getAmountsOut',
+            args: [amountIn, path],
+        });
+        return amounts.at(-1) ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+exports.readPulseXSectionQuote = readPulseXSectionQuote;

package/dist/cjs/fee-type.d.ts

@@ -0,0 +1,10 @@
+/** The type of fee to use for the bridge */
+export declare enum FeeType {
+    PERCENT = "%",
+    GAS_TIP = "gas+%",
+    FIXED = "fixed"
+}
+/** The keys of the fee type */
+export type FeeTypeKeys = keyof typeof FeeType;
+/** A map of fee type values to keys */
+export declare const feeTypeValToKeyMap: Map<FeeType, "PERCENT" | "GAS_TIP" | "FIXED">;

package/dist/cjs/fee-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feeTypeValToKeyMap = exports.FeeType = void 0;
+(function (FeeType) {
+    FeeType["PERCENT"] = "%";
+    FeeType["GAS_TIP"] = "gas+%";
+    FeeType["FIXED"] = "fixed";
+})(exports.FeeType || (exports.FeeType = {}));
+/** A map of fee type values to keys */
+exports.feeTypeValToKeyMap = new Map(Object.keys(exports.FeeType).map((key) => [exports.FeeType[key], key]));

package/dist/cjs/hyperliquid-execution.d.ts

@@ -0,0 +1,152 @@
+import { type Hex } from 'viem';
+import type { HyperliquidAuthorization, HyperliquidDeposit, TypedDataField } from './origin-deposit.js';
+/**
+ * Executing a Hyperliquid deposit, as pure data.
+ *
+ * Hyperliquid is the one origin whose deposit is never broadcast to a chain.
+ * The user signs a typed-data ACTION and that signed action is posted to
+ * Hyperliquid's own exchange API; Relay then observes the transfer and fills the
+ * route. Two details make this impossible to derive from the quote alone, and
+ * both are encoded here rather than rediscovered at a call site:
+ *
+ * 1. Relay's quote supplies `eip712Types`, `eip712PrimaryType` and the action,
+ *    but NOT the signing domain. The domain is fixed by Hyperliquid and is
+ *    reconstructed by {@link buildHyperliquidTypedData}.
+ * 2. Hyperliquid wants the signature split into `r`/`s`/`v` components, not the
+ *    concatenated hex string a wallet returns.
+ *
+ * Kept free of transport so it is fully testable: nothing here signs, fetches,
+ * or reads a clock. The caller supplies the signature and performs the request.
+ *
+ * The shape mirrors Relay's own client, which is the only reference
+ * implementation of this exchange — their public documentation covers the
+ * generic `signature` step but not this action-bearing `transaction` step.
+ */
+/** Where a signed Hyperliquid action is submitted. Hyperliquid's API, not Relay's. */
+export declare const hyperliquidExchangeUrl = "https://api.hyperliquid.xyz/exchange";
+/** The signing domain Hyperliquid requires. Fixed; never supplied by the quote. */
+export declare const hyperliquidDomainName = "HyperliquidSignTransaction";
+/** The signing domain's version. Fixed alongside {@link hyperliquidDomainName}. */
+export declare const hyperliquidDomainVersion = "1";
+/**
+ * The domain's `verifyingContract`. Hyperliquid actions are verified off-chain,
+ * so no contract is involved and the field is the all-zero address.
+ */
+export declare const hyperliquidVerifyingContract: "0x0000000000000000000000000000000000000000";
+/** A complete typed-data payload, ready to hand to a wallet's typed-data signing call. */
+export type HyperliquidTypedData = {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: Hex;
+    };
+    types: Record<string, TypedDataField[]>;
+    primaryType: string;
+    /**
+     * The signed message. This exact object is ALSO the `action` submitted to the
+     * exchange, so the bytes signed and the bytes submitted cannot drift apart.
+     */
+    message: Record<string, unknown>;
+};
+/**
+ * Builds the typed-data payload for a Hyperliquid deposit.
+ *
+ * The message is the action's parameters plus the action `type` and a
+ * `signatureChainId`; the latter is the signing chain in hex and MUST agree
+ * with `domain.chainId`, because Hyperliquid recovers the signer using both.
+ * They are derived from the single `signatureChainId` argument so they cannot
+ * disagree.
+ *
+ * @param deposit - the parsed Hyperliquid origin deposit
+ * @param options.signatureChainId - the chain id the connected wallet signs
+ *   under. Not the Relay origin chain id: it identifies the signing domain, and
+ *   Relay's own client uses the wallet's active chain here.
+ * @returns the payload to sign, whose `message` doubles as the submitted action
+ */
+export declare const buildHyperliquidTypedData: (deposit: HyperliquidDeposit, { signatureChainId }: {
+    signatureChainId: number;
+}) => HyperliquidTypedData;
+/** The JSON body Hyperliquid's exchange endpoint expects for a signed action. */
+export type HyperliquidExchangeRequest = {
+    /** The signature split into components; the concatenated hex form is rejected. */
+    signature: {
+        r: Hex;
+        s: Hex;
+        v: number;
+    };
+    /** Replay-protection nonce, which must match the nonce inside the signed action. */
+    nonce: number;
+    /** The signed message, submitted verbatim. */
+    action: Record<string, unknown>;
+};
+/**
+ * Builds the exchange request for an action the user has signed.
+ *
+ * The nonce is read back out of the signed message rather than passed in: it is
+ * covered by the signature, so any independently supplied value could disagree
+ * with what was signed and be rejected.
+ *
+ * @param options.typedData - the payload that was signed
+ * @param options.signature - the wallet's signature over it
+ * @returns the request body, or null when the signed action carries no usable nonce
+ */
+export declare const buildHyperliquidExchangeRequest: ({ typedData, signature, }: {
+    typedData: HyperliquidTypedData;
+    signature: Hex;
+}) => HyperliquidExchangeRequest | null;
+/**
+ * Whether an exchange response reports success. Hyperliquid answers with HTTP
+ * 200 even for a rejected action, so the body's own status is the only reliable
+ * signal — treating the status code as the outcome would report a failed
+ * transfer as a completed one.
+ *
+ * @param payload - the parsed response body
+ * @returns true only when the body explicitly reports success
+ */
+export declare const isHyperliquidExchangeSuccess: (payload: unknown) => boolean;
+/**
+ * The typed-data payload for the authorization that must be completed BEFORE
+ * the action is submitted.
+ *
+ * Relay builds the authorization against a chain it picks when quoting, but the
+ * signature is produced by whichever chain the wallet is actually on. Both the
+ * domain here and `signatureChainId` in {@link buildHyperliquidAuthorizationRequest}
+ * are therefore overridden with the active wallet chain; leaving Relay's value in
+ * place makes the recovered signer disagree with the submitted one and the
+ * authorization is rejected.
+ *
+ * @param authorization - the authorization carried by the deposit
+ * @param options.signatureChainId - the chain id the connected wallet signs under
+ * @returns the payload to sign
+ */
+export declare const buildHyperliquidAuthorizationTypedData: (authorization: HyperliquidAuthorization, { signatureChainId }: {
+    signatureChainId: number;
+}) => HyperliquidTypedData;
+/** A prepared authorization submission: where to send it, and what to send. */
+export type HyperliquidAuthorizationRequest = {
+    /**
+     * The absolute URL, INCLUDING the signature as a query parameter. Relay reads
+     * the signature from the query string, not the body — a request carrying it in
+     * the body is accepted and then fails to authorize.
+     */
+    url: string;
+    method: string;
+    body: Record<string, unknown>;
+};
+/**
+ * Builds the authorization submission for a signed authorization.
+ *
+ * @param options.authorization - the authorization that was signed
+ * @param options.signature - the wallet's signature over its typed data
+ * @param options.signatureChainId - the chain id the wallet signed under, which
+ *   replaces the value Relay quoted so the body agrees with the signature
+ * @param options.baseUrl - Relay's API root; the step's endpoint is relative
+ * @returns the request to perform, or null when the endpoint is not a usable path
+ */
+export declare const buildHyperliquidAuthorizationRequest: ({ authorization, signature, signatureChainId, baseUrl, }: {
+    authorization: HyperliquidAuthorization;
+    signature: Hex;
+    signatureChainId: number;
+    baseUrl?: string;
+}) => HyperliquidAuthorizationRequest | null;