@0xmonaco/core 1.1.7 → 1.1.8

package/dist/api/fees/api.d.ts

@@ -90,6 +90,8 @@ export declare class FeesAPIImpl extends BaseAPI implements FeesAPI {
      *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      * });
      * console.log(`Current tier: ${tier.currentTierLevel}`);
+     * console.log(`Rate source: ${tier.rateSource}`);
+     * console.log(`Maker ${tier.makerFeeBps} bps, taker ${tier.takerFeeBps} bps`);
      * console.log(`14d volume: ${tier.weightedVolume14d}`);
      * for (const row of tier.feeSchedule) {
      *   console.log(`Tier ${row.tierLevel}: taker ${row.takerFeeBps} bps`);

package/dist/api/fees/api.js

@@ -108,6 +108,8 @@ export class FeesAPIImpl extends BaseAPI {
      *   tradingPairId: "123e4567-e89b-12d3-a456-426614174000",
      * });
      * console.log(`Current tier: ${tier.currentTierLevel}`);
+     * console.log(`Rate source: ${tier.rateSource}`);
+     * console.log(`Maker ${tier.makerFeeBps} bps, taker ${tier.takerFeeBps} bps`);
      * console.log(`14d volume: ${tier.weightedVolume14d}`);
      * for (const row of tier.feeSchedule) {
      *   console.log(`Tier ${row.tierLevel}: taker ${row.takerFeeBps} bps`);

package/dist/api/sweeper/api.d.ts

@@ -22,9 +22,16 @@
  * const margin = await sdk.sweeper.register({ depositTarget: "margin" });
  * ```
  */
-import type { GetSweeperChainsResponse, GetSweeperDepositStatusResponse, ListSweeperDepositsParams, ListSweeperDepositsResponse, RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
+import type { DepositFromHypercoreRequest, DepositFromHypercoreResponse, DepositFromHyperEvmRequest, DepositFromHyperEvmResponse, GetSweeperChainsResponse, GetSweeperDepositStatusResponse, HypercoreDepositInfo, HyperEvmDepositInfo, ListSweeperDepositsParams, ListSweeperDepositsResponse, RegisterSweeperRequest, RegisterSweeperResponse, SweeperAPI } from "@0xmonaco/types";
+import { type WalletClient } from "viem";
 import { BaseAPI } from "../base";
 export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
+    private walletClient;
+    /**
+     * Set the wallet client that signs {@link depositFromHypercore}. Its
+     * account must be the one holding the Hyperliquid balance.
+     */
+    setWalletClient(walletClient: WalletClient): void;
     /**
      * Registers an (application, user, deposit target) deposit address for
      * monitoring. Requires authentication; the user is the session's own
@@ -90,4 +97,105 @@ export declare class SweeperAPIImpl extends BaseAPI implements SweeperAPI {
      *   on the last page)
      */
     listDeposits(params?: ListSweeperDepositsParams): Promise<ListSweeperDepositsResponse>;
+    /**
+     * Deposits USDC the wallet holds on Hyperliquid (HyperCore). The wallet
+     * signs Circle's CCTP withdrawal (`sendToEvmWithData`) to the caller's
+     * deposit address on Sei, and the SDK posts it to Hyperliquid, which
+     * executes it — no gas and no HyperEVM transaction from the user. Circle
+     * forwards the mint to Sei, keeping up to `maxFee` of it, and the sweeper
+     * credits the rest like any deposit made straight to the address; it lists
+     * in {@link listDeposits} by its Sei mint.
+     *
+     * The Hyperliquid balance is chosen from the account itself (see
+     * {@link getHypercoreDepositInfo}): spot for a unified or portfolio-margin
+     * account, otherwise whichever of perp (first) or spot covers `amount`.
+     * Before registering or signing, this refuses an amount below the minimum
+     * — a credit under the hub's floor would sit on the address unswept, and a
+     * withdrawal that does not exceed Circle's fee reverts on HyperEVM — and an
+     * amount no single balance covers. It then registers the deposit address
+     * (so it is monitored) and signs.
+     *
+     * @param body - The raw USDC amount (6 decimals), and optionally the
+     *   deposit target
+     * @returns Promise resolving once Hyperliquid accepts the withdrawal
+     * @throws {InvalidConfigError} On an invalid amount, a missing wallet, a
+     *   wallet off Sei, or an amount below the minimum or above what one
+     *   balance holds
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When a Hyperliquid read fails (nothing signed), or
+     *   when Hyperliquid refuses the action (nothing moved). A lost or
+     *   unreadable reply to the withdrawal itself is an unknown outcome and
+     *   carries `retryable: false`: calling again signs a second withdrawal, so
+     *   check {@link listDeposits} or the Hyperliquid balance first.
+     */
+    depositFromHypercore(body: DepositFromHypercoreRequest): Promise<DepositFromHypercoreResponse>;
+    /**
+     * What the wallet can deposit from Hyperliquid: its account mode and USDC
+     * balances, the most one deposit can draw, Circle's fee, and the smallest
+     * amount {@link depositFromHypercore} accepts. Reads only public data
+     * (Hyperliquid's info endpoint, Circle's CoreDepositWallet on HyperEVM and
+     * {@link getChains}), so it needs a wallet client on Sei but no session.
+     *
+     * @returns Promise resolving to the account's deposit info, amounts in raw
+     *   USDC base units (6 decimals)
+     * @throws {InvalidConfigError} On a missing wallet or a wallet off Sei
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When a Hyperliquid read fails
+     */
+    getHypercoreDepositInfo(): Promise<HypercoreDepositInfo>;
+    /**
+     * Deposits Circle USDC the wallet holds on HyperEVM. The wallet approves
+     * (when its allowance is short) and burns it through Circle's
+     * TokenMessengerV2 on HyperEVM, naming the caller's Sei deposit address as
+     * the recipient and asking Circle to forward the mint. Circle mints on Sei,
+     * keeping up to `maxFee`, and the sweeper credits the rest like any deposit
+     * made straight to the address; it lists in {@link listDeposits} by its Sei
+     * mint. The wallet pays HYPE for gas; no Monaco contract is involved on
+     * HyperEVM.
+     *
+     * A browser or embedded wallet is switched to HyperEVM (added first when it
+     * does not know the chain) and back to Sei afterwards. Before registering
+     * or sending, this refuses an amount below the minimum or above the
+     * wallet's HyperEVM USDC, and a wallet with no HYPE.
+     *
+     * @param body - The raw USDC amount (6 decimals), and optionally the
+     *   deposit target
+     * @returns Promise resolving once the burn lands on HyperEVM
+     * @throws {InvalidConfigError} On an invalid amount, a missing wallet, a
+     *   wallet off Sei, or an amount below the minimum or above the balance
+     * @throws {InvalidStateError} When the hub does not sweep USDC or the
+     *   wallet has no HYPE
+     * @throws {APIError} When Circle's fee quote fails (nothing sent), or when
+     *   the burn was sent but its receipt cannot be read: an unknown outcome
+     *   carrying `retryable: false` and the burn's hash, since calling again
+     *   burns a second time
+     * @throws {ContractError} When the approval or the burn reverts (nothing
+     *   burned)
+     */
+    depositFromHyperEvm(body: DepositFromHyperEvmRequest): Promise<DepositFromHyperEvmResponse>;
+    /**
+     * What the wallet can deposit from HyperEVM: its Circle USDC and HYPE
+     * there, Circle's forwarding fee, and the smallest amount
+     * {@link depositFromHyperEvm} accepts. Reads only public data (the
+     * HyperEVM RPC, Circle's fee API and {@link getChains}), so it needs a
+     * wallet client on Sei but no session.
+     *
+     * @returns Promise resolving to the wallet's HyperEVM deposit info
+     * @throws {InvalidConfigError} On a missing wallet or a wallet off Sei
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When Circle's fee quote fails
+     */
+    getHyperEvmDepositInfo(): Promise<HyperEvmDepositInfo>;
+    /** The reads both Hyperliquid (HyperCore) methods start from, made in parallel. */
+    private readHypercoreDepositInfo;
+    /** The reads both HyperEVM methods start from, made in parallel. */
+    private readHyperEvmDepositInfo;
+    /** The wallet client, which must be on Sei, and the Hyperliquid network that pairs with its chain. */
+    private walletOnSei;
+    /**
+     * The Sei hub's minimum for Circle's USDC, raw. By address, never by symbol:
+     * Sei also carries Noble's bridged USDC.n, and both routes mint Circle's
+     * native USDC.
+     */
+    private hubUsdcFloor;
 }

package/dist/api/sweeper/api.js

@@ -22,9 +22,13 @@
  * const margin = await sdk.sweeper.register({ depositTarget: "margin" });
  * ```
  */
-import { InvalidConfigError } from "../../errors";
+import { formatUnits } from "viem";
+import { sei, seiTestnet } from "viem/chains";
+import { InvalidConfigError, InvalidStateError } from "../../errors";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp/routes";
+import { availableToDraw, chooseSource, hypercoreNetworkFor, postToExchange, readHypercoreAccount, readMaxFee, signWithdrawalToSei, USDC_DECIMALS, } from "./hypercore";
+import { burnToSei, quoteForwardFee, readHyperEvmAccount } from "./hyperevm";
 /**
  * Ergonomic target to its wire form.
  *
@@ -52,6 +56,14 @@ function toWireDepositTarget(target) {
     throw new InvalidConfigError(`Invalid deposit target: ${JSON.stringify(target)}. Expected "spot" or "margin".`);
 }
 export class SweeperAPIImpl extends BaseAPI {
+    walletClient;
+    /**
+     * Set the wallet client that signs {@link depositFromHypercore}. Its
+     * account must be the one holding the Hyperliquid balance.
+     */
+    setWalletClient(walletClient) {
+        this.walletClient = walletClient;
+    }
     /**
      * Registers an (application, user, deposit target) deposit address for
      * monitoring. Requires authentication; the user is the session's own
@@ -143,6 +155,218 @@ export class SweeperAPIImpl extends BaseAPI {
             method: "GET",
         });
     }
+    /**
+     * Deposits USDC the wallet holds on Hyperliquid (HyperCore). The wallet
+     * signs Circle's CCTP withdrawal (`sendToEvmWithData`) to the caller's
+     * deposit address on Sei, and the SDK posts it to Hyperliquid, which
+     * executes it — no gas and no HyperEVM transaction from the user. Circle
+     * forwards the mint to Sei, keeping up to `maxFee` of it, and the sweeper
+     * credits the rest like any deposit made straight to the address; it lists
+     * in {@link listDeposits} by its Sei mint.
+     *
+     * The Hyperliquid balance is chosen from the account itself (see
+     * {@link getHypercoreDepositInfo}): spot for a unified or portfolio-margin
+     * account, otherwise whichever of perp (first) or spot covers `amount`.
+     * Before registering or signing, this refuses an amount below the minimum
+     * — a credit under the hub's floor would sit on the address unswept, and a
+     * withdrawal that does not exceed Circle's fee reverts on HyperEVM — and an
+     * amount no single balance covers. It then registers the deposit address
+     * (so it is monitored) and signs.
+     *
+     * @param body - The raw USDC amount (6 decimals), and optionally the
+     *   deposit target
+     * @returns Promise resolving once Hyperliquid accepts the withdrawal
+     * @throws {InvalidConfigError} On an invalid amount, a missing wallet, a
+     *   wallet off Sei, or an amount below the minimum or above what one
+     *   balance holds
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When a Hyperliquid read fails (nothing signed), or
+     *   when Hyperliquid refuses the action (nothing moved). A lost or
+     *   unreadable reply to the withdrawal itself is an unknown outcome and
+     *   carries `retryable: false`: calling again signs a second withdrawal, so
+     *   check {@link listDeposits} or the Hyperliquid balance first.
+     */
+    async depositFromHypercore(body) {
+        const { amount, depositTarget } = body;
+        if (typeof amount !== "bigint" || amount <= 0n) {
+            throw new InvalidConfigError(`Invalid amount: ${String(amount)}. Expected a positive bigint of raw USDC base units (6 decimals).`, "amount", amount);
+        }
+        const { walletClient, network, account, info } = await this.readHypercoreDepositInfo("depositFromHypercore");
+        if (amount < info.minimumAmount) {
+            throw new InvalidConfigError(`Deposit at least ${formatUnits(info.minimumAmount, USDC_DECIMALS)} USDC from Hyperliquid: Circle keeps up to ${formatUnits(info.maxFee, USDC_DECIMALS)} USDC to forward it to Sei, and the hub only sweeps a credit above its minimum.`, "amount", amount);
+        }
+        const source = chooseSource(account, amount);
+        if (!source) {
+            throw new InvalidConfigError(`Hyperliquid holds too little USDC: one deposit can draw at most ${formatUnits(info.available, USDC_DECIMALS)} USDC (perp ${formatUnits(info.perpBalance, USDC_DECIMALS)}, spot ${formatUnits(info.spotBalance, USDC_DECIMALS)}).`, "amount", amount);
+        }
+        const { sweeperAddress } = await this.register(depositTarget === undefined ? {} : { depositTarget });
+        const nonce = Date.now();
+        const withdrawal = await signWithdrawalToSei({
+            walletClient,
+            network,
+            amount: formatUnits(amount, USDC_DECIMALS),
+            sourceDex: source === "perp" ? "" : "spot",
+            recipient: sweeperAddress,
+            nonce,
+        });
+        await postToExchange(network, withdrawal);
+        return { sweeperAddress, amount, source, maxFee: info.maxFee, minimumCredit: amount - info.maxFee, nonce };
+    }
+    /**
+     * What the wallet can deposit from Hyperliquid: its account mode and USDC
+     * balances, the most one deposit can draw, Circle's fee, and the smallest
+     * amount {@link depositFromHypercore} accepts. Reads only public data
+     * (Hyperliquid's info endpoint, Circle's CoreDepositWallet on HyperEVM and
+     * {@link getChains}), so it needs a wallet client on Sei but no session.
+     *
+     * @returns Promise resolving to the account's deposit info, amounts in raw
+     *   USDC base units (6 decimals)
+     * @throws {InvalidConfigError} On a missing wallet or a wallet off Sei
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When a Hyperliquid read fails
+     */
+    async getHypercoreDepositInfo() {
+        return (await this.readHypercoreDepositInfo("getHypercoreDepositInfo")).info;
+    }
+    /**
+     * Deposits Circle USDC the wallet holds on HyperEVM. The wallet approves
+     * (when its allowance is short) and burns it through Circle's
+     * TokenMessengerV2 on HyperEVM, naming the caller's Sei deposit address as
+     * the recipient and asking Circle to forward the mint. Circle mints on Sei,
+     * keeping up to `maxFee`, and the sweeper credits the rest like any deposit
+     * made straight to the address; it lists in {@link listDeposits} by its Sei
+     * mint. The wallet pays HYPE for gas; no Monaco contract is involved on
+     * HyperEVM.
+     *
+     * A browser or embedded wallet is switched to HyperEVM (added first when it
+     * does not know the chain) and back to Sei afterwards. Before registering
+     * or sending, this refuses an amount below the minimum or above the
+     * wallet's HyperEVM USDC, and a wallet with no HYPE.
+     *
+     * @param body - The raw USDC amount (6 decimals), and optionally the
+     *   deposit target
+     * @returns Promise resolving once the burn lands on HyperEVM
+     * @throws {InvalidConfigError} On an invalid amount, a missing wallet, a
+     *   wallet off Sei, or an amount below the minimum or above the balance
+     * @throws {InvalidStateError} When the hub does not sweep USDC or the
+     *   wallet has no HYPE
+     * @throws {APIError} When Circle's fee quote fails (nothing sent), or when
+     *   the burn was sent but its receipt cannot be read: an unknown outcome
+     *   carrying `retryable: false` and the burn's hash, since calling again
+     *   burns a second time
+     * @throws {ContractError} When the approval or the burn reverts (nothing
+     *   burned)
+     */
+    async depositFromHyperEvm(body) {
+        const { amount, depositTarget } = body;
+        if (typeof amount !== "bigint" || amount <= 0n) {
+            throw new InvalidConfigError(`Invalid amount: ${String(amount)}. Expected a positive bigint of raw USDC base units (6 decimals).`, "amount", amount);
+        }
+        const { walletClient, network, account, info } = await this.readHyperEvmDepositInfo("depositFromHyperEvm");
+        if (amount < info.minimumAmount) {
+            throw new InvalidConfigError(`Deposit at least ${formatUnits(info.minimumAmount, USDC_DECIMALS)} USDC from HyperEVM: Circle keeps up to ${formatUnits(info.maxFee, USDC_DECIMALS)} USDC to forward it to Sei, and the hub only sweeps a credit above its minimum.`, "amount", amount);
+        }
+        if (amount > info.usdcBalance) {
+            throw new InvalidConfigError(`The wallet holds ${formatUnits(info.usdcBalance, USDC_DECIMALS)} USDC on HyperEVM.`, "amount", amount);
+        }
+        if (info.gasBalance === 0n) {
+            throw new InvalidStateError("The wallet holds no HYPE on HyperEVM to pay gas for the approval and burn.");
+        }
+        const { sweeperAddress } = await this.register(depositTarget === undefined ? {} : { depositTarget });
+        const { approveTxHash, burnTxHash } = await burnToSei({
+            walletClient,
+            network,
+            amount,
+            recipient: sweeperAddress,
+            maxFee: info.maxFee,
+            allowance: account.allowance,
+        });
+        return {
+            sweeperAddress,
+            amount,
+            maxFee: info.maxFee,
+            minimumCredit: amount - info.maxFee,
+            ...(approveTxHash === undefined ? {} : { approveTxHash }),
+            burnTxHash,
+        };
+    }
+    /**
+     * What the wallet can deposit from HyperEVM: its Circle USDC and HYPE
+     * there, Circle's forwarding fee, and the smallest amount
+     * {@link depositFromHyperEvm} accepts. Reads only public data (the
+     * HyperEVM RPC, Circle's fee API and {@link getChains}), so it needs a
+     * wallet client on Sei but no session.
+     *
+     * @returns Promise resolving to the wallet's HyperEVM deposit info
+     * @throws {InvalidConfigError} On a missing wallet or a wallet off Sei
+     * @throws {InvalidStateError} When the hub does not sweep USDC
+     * @throws {APIError} When Circle's fee quote fails
+     */
+    async getHyperEvmDepositInfo() {
+        return (await this.readHyperEvmDepositInfo("getHyperEvmDepositInfo")).info;
+    }
+    /** The reads both Hyperliquid (HyperCore) methods start from, made in parallel. */
+    async readHypercoreDepositInfo(caller) {
+        const { walletClient, network, address } = this.walletOnSei(caller);
+        const [floor, maxFee, account] = await Promise.all([this.hubUsdcFloor(network), readMaxFee(network), readHypercoreAccount(network, address)]);
+        const info = {
+            account: address,
+            accountMode: account.mode,
+            perpBalance: account.perp,
+            spotBalance: account.spot,
+            available: availableToDraw(account),
+            maxFee,
+            minimumAmount: minimumAmount(maxFee, floor),
+        };
+        return { walletClient, network, account, info };
+    }
+    /** The reads both HyperEVM methods start from, made in parallel. */
+    async readHyperEvmDepositInfo(caller) {
+        const { walletClient, network, address } = this.walletOnSei(caller);
+        const [floor, maxFee, account] = await Promise.all([this.hubUsdcFloor(network), quoteForwardFee(network), readHyperEvmAccount(network, address)]);
+        const info = {
+            account: address,
+            usdcBalance: account.usdc,
+            gasBalance: account.gas,
+            maxFee,
+            minimumAmount: minimumAmount(maxFee, floor),
+        };
+        return { walletClient, network, account, info };
+    }
+    /** The wallet client, which must be on Sei, and the Hyperliquid network that pairs with its chain. */
+    walletOnSei(caller) {
+        const walletClient = this.walletClient;
+        if (!walletClient?.account) {
+            throw new InvalidConfigError("Wallet client not set. Connect the wallet that holds the USDC first.", "walletClient");
+        }
+        const network = hypercoreNetworkFor(walletClient.chain?.id);
+        if (!network) {
+            throw new InvalidConfigError(`${caller} needs the wallet on Sei (chain ${sei.id} or ${seiTestnet.id}); got chain ${walletClient.chain?.id}.`, "walletClient");
+        }
+        return { walletClient, network, address: walletClient.account.address };
+    }
+    /**
+     * The Sei hub's minimum for Circle's USDC, raw. By address, never by symbol:
+     * Sei also carries Noble's bridged USDC.n, and both routes mint Circle's
+     * native USDC.
+     */
+    async hubUsdcFloor(network) {
+        const { chains } = await this.getChains();
+        const seiUsdc = network.seiUsdc.toLowerCase();
+        const usdc = chains.find((chain) => chain.hub)?.assets.find((asset) => asset.tokenAddress.toLowerCase() === seiUsdc);
+        if (!usdc) {
+            throw new InvalidStateError("The Sei hub does not sweep USDC, so a deposit from Hyperliquid would not be credited.");
+        }
+        return BigInt(usdc.minSweepRaw);
+    }
+}
+/**
+ * The smallest amount a forwarded deposit accepts: Circle's fee plus the
+ * hub's floor. Circle reverts a transfer that does not exceed its fee, and the
+ * hub leaves a credit below its floor on the address until a later deposit.
+ */
+function minimumAmount(maxFee, floor) {
+    return maxFee + (floor > 0n ? floor : 1n);
 }
 /** The deposit listing's page size bounds, matching the endpoint's schema. */
 const MAX_DEPOSIT_PAGE_SIZE = 100;

package/dist/api/sweeper/hypercore.d.ts

@@ -0,0 +1,103 @@
+/**
+ * USDC withdrawals from Hyperliquid (HyperCore) to a Sei deposit address.
+ *
+ * Circle's CCTP integration on HyperCore withdraws USDC to any CCTP domain
+ * through one user-signed HyperCore action, `sendToEvmWithData`
+ * (developers.circle.com/cctp/howtos/withdraw-usdc-from-hypercore-to-evm).
+ * Hyperliquid executes the signed action itself, so the user pays no gas: its
+ * system call into Circle's CoreDepositWallet on HyperEVM burns the USDC with
+ * Sei as the destination domain and the deposit address as the mint
+ * recipient. Empty `data` selects Circle's default forwarding hook, so Circle
+ * mints on Sei and keeps its fee out of the mint. The hub then sweeps the
+ * deposit address like any deposit made straight to it.
+ */
+import type { HypercoreAccountMode, HypercoreBalanceSource } from "@0xmonaco/types";
+import { type Address, type Chain, type Hex, type WalletClient } from "viem";
+/** Sei's CCTP domain: where the withdrawal mints. Not its EVM chain id. */
+export declare const SEI_CCTP_DOMAIN = 16;
+/** USDC's decimals on HyperEVM and Sei. */
+export declare const USDC_DECIMALS = 6;
+/** Where one Hyperliquid network's withdrawals are signed for and sent. */
+export interface HypercoreNetwork {
+    hyperliquidChain: "Mainnet" | "Testnet";
+    exchangeUrl: string;
+    infoUrl: string;
+    hyperEvm: Chain;
+    /** Circle's CoreDepositWallet (developers.circle.com/cctp/references/hypercore-contract-addresses) */
+    coreDepositWallet: Address;
+    /** Circle's native USDC on the paired Sei chain: what the withdrawal mints */
+    seiUsdc: Address;
+    /** Circle's native USDC on HyperEVM */
+    hyperEvmUsdc: Address;
+    /** Circle's TokenMessengerV2 on HyperEVM */
+    tokenMessenger: Address;
+    /** Circle's attestation API (Iris), which quotes CCTP fees */
+    irisUrl: string;
+}
+/**
+ * The Hyperliquid network that pairs with the SDK's Sei chain: mainnet with
+ * Sei mainnet, testnet with Sei testnet (where every non-mainnet Monaco
+ * network settles). `undefined` for any other chain.
+ */
+export declare function hypercoreNetworkFor(chainId: number | undefined): HypercoreNetwork | undefined;
+/**
+ * The most Circle deducts from a forwarded withdrawal to Sei: the CCTP
+ * `maxFee` its CoreDepositWallet burns with (its forwarding fee for the
+ * domain plus CCTP's own cap). Owner-configurable per domain, so it is read
+ * rather than assumed. The wallet also reverts a withdrawal that does not
+ * exceed it.
+ */
+export declare function readMaxFee(network: HypercoreNetwork): Promise<bigint>;
+/** A Hyperliquid account's USDC, in raw 6-decimal base units. */
+export interface HypercoreAccount {
+    mode: HypercoreAccountMode;
+    perp: bigint;
+    spot: bigint;
+}
+/** Read the account's mode and USDC balances from Hyperliquid's public info endpoint. */
+export declare function readHypercoreAccount(network: HypercoreNetwork, user: Address): Promise<HypercoreAccount>;
+/**
+ * The balance one withdrawal of `amount` draws on, or `undefined` when none
+ * covers it with room for Hyperliquid's fee. A unified or portfolio-margin
+ * account draws on spot: Hyperliquid refuses any other source for it
+ * ("Unified account only supports sending assets through spot"). Otherwise
+ * perp comes first, where a deposit to Hyperliquid lands by default.
+ */
+export declare function chooseSource(account: HypercoreAccount, amount: bigint): HypercoreBalanceSource | undefined;
+/** The most one withdrawal can draw: it draws on a single balance and leaves room for Hyperliquid's fee. */
+export declare function availableToDraw(account: HypercoreAccount): bigint;
+/** One signed `sendToEvmWithData` action, as Hyperliquid's exchange endpoint takes it. */
+export interface SignedWithdrawal {
+    action: Record<string, unknown>;
+    nonce: number;
+    signature: {
+        r: Hex;
+        s: Hex;
+        v: number;
+    };
+}
+/**
+ * Sign a USDC withdrawal from Hyperliquid to `recipient` on Sei.
+ *
+ * The signature's domain uses the wallet's own chain (Sei), which Hyperliquid
+ * accepts from any chain and wallets that hold the domain to the active
+ * network sign without switching.
+ */
+export declare function signWithdrawalToSei(params: {
+    walletClient: WalletClient;
+    network: HypercoreNetwork;
+    amount: string;
+    sourceDex: "" | "spot";
+    recipient: string;
+    nonce: number;
+}): Promise<SignedWithdrawal>;
+/**
+ * Post a signed withdrawal to Hyperliquid's exchange endpoint.
+ *
+ * Hyperliquid answers a decided rejection with HTTP 200 and
+ * `{"status":"err","response":"<reason>"}`, so the status alone does not tell
+ * success from refusal. A refusal is a decided outcome (nothing moved); a
+ * dropped connection, a 5xx, or a reply that is neither `ok` nor `err` leaves
+ * the outcome unknown. The signed body is never attached to an error.
+ */
+export declare function postToExchange(network: HypercoreNetwork, withdrawal: SignedWithdrawal): Promise<void>;