@gibs/bridge-sdk 1.12.0 → 1.13.0

package/dist/ecosystems.js

@@ -0,0 +1,288 @@
+import { getAddress, isAddress } from 'viem';
+// Solana public keys are base58 (no 0, O, I, l) and 32–44 characters long.
+const base58Solana = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+// Bitcoin mainnet: bech32 (bc1…) or base58 pay-to-key/script (starts 1 or 3).
+const bech32Bitcoin = /^bc1[0-9ac-hj-np-z]{6,87}$/;
+const base58Bitcoin = /^[13][1-9A-HJ-NP-Za-km-z]{25,39}$/;
+// Tron base58check addresses are always 34 characters and always begin with a
+// capital T (the encoding of the 0x41 mainnet prefix byte).
+const base58Tron = /^T[1-9A-HJ-NP-Za-km-z]{33}$/;
+// The Open Network has two interchangeable address encodings, and Relay uses
+// both: the 48-character "user-friendly" base64url form (EQ/UQ on mainnet,
+// kQ/0Q on testnet), and the "raw" form of a workchain, a colon, and a
+// 64-character hex account identifier.
+const friendlyTon = /^[EUk0]Q[A-Za-z0-9_-]{46}$/;
+const rawTon = /^-?\d+:[0-9a-fA-F]{64}$/;
+// HyperCore token identifiers are hex of a length Ethereum never uses: sixteen
+// bytes for most tokens, nineteen for a few. Twenty is allowed too so a token
+// that is addressed by a full Ethereum address still resolves.
+const hyperliquidTokenId = /^0x[0-9a-fA-F]{32,40}$/;
+// Zcash TRANSPARENT addresses only, and the restriction is the service's, not
+// ours: a shielded (`zs1…`) or unified (`u1…`) address is refused at the door
+// with `refundTo is not valid`, before a solver is ever reached. Both
+// transparent forms are base58check over a two-byte prefix, which always
+// encodes to exactly 35 characters: `t1` pays to a public key hash, `t3` to a
+// script hash. The pattern rejects the shielded forms by construction, because
+// neither begins with `t`.
+const transparentZcash = /^t[13][1-9A-HJ-NP-Za-km-z]{33}$/;
+const evmDescriptor = {
+    id: 'evm',
+    label: 'Ethereum Virtual Machine',
+    caipNamespace: 'eip155',
+    // The all-zero address, exactly as the Relay builder uses across every
+    // Ethereum Virtual Machine chain for the native gas token.
+    nativeAssetSentinel: '0x0000000000000000000000000000000000000000',
+    // The only proof the product holds. The bridge's own contracts run on
+    // PulseChain, Ethereum and Binance Smart Chain, and every aggregator origin
+    // LI.FI carries is an Ethereum Virtual Machine chain, so this is the family
+    // real transfers have crossed.
+    endToEndProof: 'verified',
+    isValidAddress: (value) => isAddress(value),
+    // getAddress applies the mixed-case checksum; it throws on a non-address, so
+    // fall back to the raw input to keep normalize total and side-effect-free.
+    normalizeAddress: (value) => (isAddress(value) ? getAddress(value) : value),
+    addressCasing: 'insensitive',
+};
+const svmDescriptor = {
+    id: 'svm',
+    label: 'Solana',
+    caipNamespace: 'solana',
+    // Solana native currency (the System Program address), as Relay expects it.
+    nativeAssetSentinel: '11111111111111111111111111111111',
+    // Connects through the Reown AppKit Solana adapter and signs for real
+    // (`useSolanaDepositSigner` builds a versioned transaction and calls the
+    // wallet's sign-and-send). Every test around it drives a mocked wallet, and
+    // Relay — the only provider that quotes this origin — has never had its
+    // on-chain execution confirmed by a funded transfer.
+    endToEndProof: 'pending',
+    isValidAddress: (value) => base58Solana.test(value),
+    // base58 is case-significant; canonical form is the input unchanged.
+    normalizeAddress: (value) => value,
+    addressCasing: 'significant',
+};
+const bvmDescriptor = {
+    id: 'bvm',
+    label: 'Bitcoin',
+    caipNamespace: 'bip122',
+    // Bitcoin native currency string, as Relay expects it.
+    nativeAssetSentinel: 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8',
+    // The best-evidenced of the four, and still short of proof. A partially
+    // signed transaction the pipeline builds is accepted by a real node, but
+    // that test runs against a local regtest node behind `BITCOIN_REGTEST=1`
+    // and never in the normal suite. The browser wallet that signs in
+    // production is driven by nothing but a mock, and no funded mainnet
+    // transfer has completed.
+    endToEndProof: 'pending',
+    isValidAddress: (value) => bech32Bitcoin.test(value) || base58Bitcoin.test(value),
+    // bech32 and base58 are case-significant; canonical form is the input unchanged.
+    normalizeAddress: (value) => value,
+    addressCasing: 'significant',
+};
+const tvmDescriptor = {
+    id: 'tvm',
+    label: 'Tron',
+    caipNamespace: 'tron',
+    // Tron native currency (TRX), as Relay expects it. Not a real contract: it is
+    // the placeholder address Relay publishes for the chain's native asset.
+    nativeAssetSentinel: 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb',
+    // The first wallet the interface reaches outside Reown AppKit: it reads an
+    // injected provider directly. That is more of the connection path owned
+    // here, and therefore more of it unexercised outside a mock. No funded
+    // transfer has completed.
+    endToEndProof: 'pending',
+    isValidAddress: (value) => base58Tron.test(value),
+    // base58check is case-significant; canonical form is the input unchanged.
+    normalizeAddress: (value) => value,
+    addressCasing: 'significant',
+};
+const tonvmDescriptor = {
+    id: 'tonvm',
+    label: 'The Open Network',
+    caipNamespace: 'ton',
+    // Relay publishes Gram — NOT the Toncoin gas asset — as this chain's native
+    // currency, so a native-asset route on The Open Network is denominated in
+    // Gram. Kept byte-equal to Relay's own value rather than "corrected".
+    nativeAssetSentinel: 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c',
+    // The second wallet outside Reown AppKit, on a separate connection library,
+    // and the one origin whose deposit identifier is derived from the returned
+    // cell rather than handed back by the wallet. Only a mock has ever returned
+    // that cell. No funded transfer has completed.
+    endToEndProof: 'pending',
+    isValidAddress: (value) => friendlyTon.test(value) || rawTon.test(value),
+    // both encodings are case-significant; canonical form is the input unchanged.
+    normalizeAddress: (value) => value,
+    addressCasing: 'significant',
+};
+const hypevmDescriptor = {
+    id: 'hypevm',
+    label: 'Hyperliquid',
+    caipNamespace: 'hyperliquid',
+    // Relay publishes USD Coin — NOT the Hype gas asset — as this chain's native
+    // currency, and addresses it by a sixteen-byte HyperCore token identifier
+    // rather than the twenty-byte all-zero address every Ethereum Virtual Machine
+    // chain uses. The two sentinels are therefore different strings.
+    nativeAssetSentinel: '0x00000000000000000000000000000000',
+    // THE WORST OF THE SIX, and the one that was actively misleading. The
+    // interface's source picker never offers Hyperliquid — nothing can quote it
+    // — yet the landing page drew a pill for it that set the source chain to
+    // Hyperliquid on click. A reader who pressed it arrived at a chain the form
+    // does not list and no provider answers. Removing the pill removes that dead
+    // end; the descriptor stays because the route layer still has to be able to
+    // NAME the chain.
+    endToEndProof: 'pending',
+    // This predicate checks TOKEN addresses, and HyperCore identifies a token by a
+    // hex string SHORTER than an Ethereum address — sixteen bytes for most,
+    // nineteen for a few — so the twenty-byte `isAddress` check would reject the
+    // very identifiers it exists to accept. Its only consumer silently falls back
+    // to the native sentinel when this returns false, so an over-strict pattern
+    // would quietly swallow valid token links instead of surfacing an error.
+    // Accounts are a different namespace (ordinary twenty-byte Ethereum
+    // addresses) and are validated by the wallet layer, not here.
+    isValidAddress: (value) => hyperliquidTokenId.test(value),
+    // Hex is case-insensitive and Relay emits lower case, so lower case is the
+    // canonical form. It matters: the token-equality check compares non-Ethereum
+    // addresses exactly, and only a single canonical case makes that correct.
+    normalizeAddress: (value) => hyperliquidTokenId.test(value) ? value.toLowerCase() : value,
+    addressCasing: 'significant',
+};
+const zcashDescriptor = {
+    id: 'zcash',
+    label: 'Zcash',
+    // Zcash is not a Relay chain and has no widely-registered chain-agnostic
+    // namespace. `zcash` is this repository's own key, and nothing maps a
+    // connected wallet through it, because no wallet connects to this family.
+    caipNamespace: 'zcash',
+    // DERIVED, NOT INVENTED: the transparent pay-to-public-key-hash address of
+    // an all-zero key hash, base58check over the mainnet prefix `1cb8` followed
+    // by twenty zero bytes. Nobody holds a key for it. It follows the pattern of
+    // Relay's Bitcoin sentinel, an all-zero witness program, and for the same
+    // reason: the sentinel stands where a token address is expected, so it must
+    // pass this family's own address check. Zcash carries no tokens on this
+    // route, so the native asset is the only asset.
+    nativeAssetSentinel: 't1Hsc1LR8yKnbbe3twRp88p6vFfC5t7DLbs',
+    // THE FIRST ECOSYSTEM WITH NO WALLET AT ALL, and therefore the first whose
+    // hold cannot be cleared by connecting one. The reader pays an address by
+    // hand from wherever they hold the coin, so every part of the journey that
+    // this repository owns — the quote, the address, the amount, the deadline,
+    // the status poll — is exercised only by a fixture. Nothing funded has
+    // crossed. Clearing this is one word, after one transfer.
+    endToEndProof: 'pending',
+    isValidAddress: (value) => transparentZcash.test(value),
+    // base58check is case-significant; canonical form is the input unchanged.
+    normalizeAddress: (value) => value,
+    addressCasing: 'significant',
+};
+/**
+ * Every ecosystem the bridge can originate from. LI.FI-compatible one first.
+ *
+ * Registration means the library can MODEL and QUOTE the ecosystem, not that an
+ * interface can sign it — see the note on {@link Ecosystem}.
+ *
+ * It means less than that again where a public claim is concerned: read
+ * {@link EndToEndProof} before listing this registry anywhere a reader will
+ * take it as an offer.
+ */
+export const ecosystemRegistry = [
+    evmDescriptor,
+    svmDescriptor,
+    bvmDescriptor,
+    tvmDescriptor,
+    tonvmDescriptor,
+    hypevmDescriptor,
+    zcashDescriptor,
+];
+const byId = new Map(ecosystemRegistry.map((descriptor) => [descriptor.id, descriptor]));
+/**
+ * Looks up the descriptor for an ecosystem id. Total over the `Ecosystem` union;
+ * throws only if the registry is ever left incomplete (a programming error the
+ * round-trip test would catch).
+ *
+ * @param id - the ecosystem key
+ * @returns the descriptor whose `id` equals `id`
+ */
+export const ecosystemById = (id) => {
+    const descriptor = byId.get(id);
+    if (descriptor === undefined) {
+        throw new Error(`no ecosystem descriptor registered for id "${id}"`);
+    }
+    return descriptor;
+};
+/**
+ * Whether a transfer has been carried through this ecosystem end to end.
+ *
+ * The predicate a surface calls before ADVERTISING an origin. It is separate
+ * from anything the router asks, and deliberately so: the router must keep
+ * quoting and naming every registered ecosystem, because a reader who reaches
+ * an unproven chain through a link still needs the page to work. This governs
+ * only what the product offers unprompted.
+ *
+ * @param id - the ecosystem key
+ * @returns true when a real transfer has completed through it
+ */
+export const isEcosystemProvenEndToEnd = (id) => ecosystemById(id).endToEndProof === 'verified';
+const byNamespace = new Map(ecosystemRegistry.map((descriptor) => [descriptor.caipNamespace, descriptor]));
+/**
+ * Resolves an ecosystem from a chain-agnostic identifier namespace.
+ *
+ * @param namespace - the leading segment of a "namespace:reference:address" id
+ * @returns the matching descriptor, or undefined when the namespace is unknown
+ */
+export const ecosystemByCaipNamespace = (namespace) => byNamespace.get(namespace);
+/**
+ * Whether two addresses in the same ecosystem name the same thing.
+ *
+ * THE ONE PLACE THIS QUESTION IS ANSWERED. It was answered in two: this
+ * registry, which knows each family's address rules, and a ternary in the
+ * interface's routing module that hard-coded "Ethereum is case-insensitive,
+ * everything else is not". Two homes means a family added here is still
+ * compared wrongly there, silently, because a loose comparison does not fail —
+ * it merges two different accounts into one.
+ *
+ * @param a - an address
+ * @param b - an address, in the same ecosystem
+ * @param ecosystem - the ecosystem both belong to
+ * @returns whether they are the same address
+ */
+export const sameAddress = (a, b, ecosystem) => ecosystemById(ecosystem).addressCasing === 'insensitive'
+    ? a.toLowerCase() === b.toLowerCase()
+    : a === b;
+/**
+ * Whether an address is the ecosystem's own native asset rather than a token.
+ *
+ * Every ecosystem already declares its `nativeAssetSentinel`, and this is the
+ * predicate that reads it. The comparison goes through {@link sameAddress}
+ * rather than `toLowerCase()`, which matters for exactly the families where the
+ * hand-written checks were wrong to begin with: Solana's, Bitcoin's and The
+ * Open Network's sentinels are case-significant, so lower-casing them before
+ * comparing can match an address that is not the sentinel.
+ *
+ * @param value - the address to test
+ * @param ecosystem - the ecosystem it belongs to
+ * @returns whether it names the native asset
+ */
+export const isNativeAsset = (value, ecosystem) => sameAddress(value, ecosystemById(ecosystem).nativeAssetSentinel, ecosystem);
+/**
+ * Whether a string is a well-formed address in this ecosystem.
+ *
+ * A free function over the registry, so a caller needs the ecosystem key and
+ * nothing else. Reaching for viem's `isAddress` directly is the thing this
+ * replaces: it answers only for Ethereum and answers FALSE — confidently — for
+ * every valid Solana, Bitcoin, Tron and Open Network address.
+ *
+ * @param value - the string to test
+ * @param ecosystem - the ecosystem to test it against
+ * @returns whether the string is a valid address there
+ */
+export const isValidAddressIn = (value, ecosystem) => ecosystemById(ecosystem).isValidAddress(value);
+/**
+ * The ecosystem's canonical spelling of an address.
+ *
+ * Total and side-effect-free: an input this ecosystem cannot parse comes back
+ * unchanged rather than throwing, because normalizing is something callers do
+ * on the way to a comparison and a throw there would be a crash on a typo.
+ *
+ * @param value - the address to normalize
+ * @param ecosystem - the ecosystem it belongs to
+ * @returns the canonical form, or the input when it cannot be parsed
+ */
+export const normalizeAddressIn = (value, ecosystem) => ecosystemById(ecosystem).normalizeAddress(value);

package/dist/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/fee-type.js

@@ -0,0 +1,9 @@
+/** The type of fee to use for the bridge */
+export var FeeType;
+(function (FeeType) {
+    FeeType["PERCENT"] = "%";
+    FeeType["GAS_TIP"] = "gas+%";
+    FeeType["FIXED"] = "fixed";
+})(FeeType || (FeeType = {}));
+/** A map of fee type values to keys */
+export const feeTypeValToKeyMap = new Map(Object.keys(FeeType).map((key) => [FeeType[key], key]));

package/dist/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;

package/dist/hyperliquid-execution.js

@@ -0,0 +1,168 @@
+import { parseSignature } from 'viem';
+import { relayApiBaseUrl } from './relay-quote.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 const hyperliquidExchangeUrl = 'https://api.hyperliquid.xyz/exchange';
+/** The signing domain Hyperliquid requires. Fixed; never supplied by the quote. */
+export const hyperliquidDomainName = 'HyperliquidSignTransaction';
+/** The signing domain's version. Fixed alongside {@link hyperliquidDomainName}. */
+export 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 const hyperliquidVerifyingContract = '0x0000000000000000000000000000000000000000';
+/** The standard typed-data domain type, which the action's type table must include. */
+const eip712DomainType = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+];
+/**
+ * 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 const buildHyperliquidTypedData = (deposit, { signatureChainId }) => ({
+    domain: {
+        name: hyperliquidDomainName,
+        version: hyperliquidDomainVersion,
+        chainId: signatureChainId,
+        verifyingContract: hyperliquidVerifyingContract,
+    },
+    types: {
+        ...deposit.eip712Types,
+        EIP712Domain: eip712DomainType,
+    },
+    primaryType: deposit.eip712PrimaryType,
+    message: {
+        ...deposit.action.parameters,
+        type: deposit.action.type,
+        signatureChainId: `0x${signatureChainId.toString(16)}`,
+    },
+});
+/**
+ * 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 const buildHyperliquidExchangeRequest = ({ typedData, signature, }) => {
+    // Hyperliquid names it `nonce`; the older action shapes name it `time`.
+    const rawNonce = typedData.message.nonce ?? typedData.message.time;
+    if (typeof rawNonce !== 'number' && typeof rawNonce !== 'bigint') {
+        return null;
+    }
+    const { r, s, v, yParity } = parseSignature(signature);
+    return {
+        // The exchange wants the 27/28 form. A signature whose final byte is the
+        // PARITY form (0 or 1) — which some hardware wallets and smart-account flows
+        // produce — parses with `v` absent and the parity carried separately, so
+        // reading `v` alone and defaulting would send recovery value 0: not a value
+        // the exchange accepts, and the deposit dies for those wallets only. The
+        // parity is the same fact in the other encoding, so shift it rather than
+        // guess.
+        signature: { r, s, v: v === undefined ? yParity + 27 : Number(v) },
+        nonce: Number(rawNonce),
+        action: typedData.message,
+    };
+};
+/**
+ * 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 const isHyperliquidExchangeSuccess = (payload) => {
+    if (typeof payload !== 'object' || payload === null) {
+        return false;
+    }
+    return payload.status === 'ok';
+};
+/**
+ * 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 const buildHyperliquidAuthorizationTypedData = (authorization, { signatureChainId }) => ({
+    domain: {
+        ...authorization.sign.domain,
+        chainId: signatureChainId,
+    },
+    types: authorization.sign.types,
+    primaryType: authorization.sign.primaryType,
+    message: authorization.sign.value,
+});
+/**
+ * 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 const buildHyperliquidAuthorizationRequest = ({ authorization, signature, signatureChainId, baseUrl = relayApiBaseUrl, }) => {
+    const { endpoint, method, body } = authorization.post;
+    if (!endpoint.startsWith('/')) {
+        return null;
+    }
+    const url = new URL(`${baseUrl}${endpoint}`);
+    url.searchParams.set('signature', signature);
+    return {
+        url: url.href,
+        method,
+        body: { ...body, signatureChainId },
+    };
+};