@nktkas/hyperliquid 0.22.1 → 0.23.0

package/script/src/signing.js

@@ -1,1129 +0,0 @@
-/**
- * This module contains functions for generating Hyperliquid transaction signatures
- * and interfaces to various wallet implementations.
- *
- * @example
- * ```ts
- * import { signL1Action } from "@nktkas/hyperliquid/signing";
- *
- * const action = {
- *   type: "cancel",
- *   cancels: [{ a: 0, o: 12345 }],
- * };
- * const nonce = Date.now();
- *
- * const signature = await signL1Action({
- *   wallet,
- *   action,
- *   nonce,
- *   isTestnet: true, // Change to false for mainnet
- * });
- * ```
- * @example
- * ```ts
- * import { signUserSignedAction } from "@nktkas/hyperliquid/signing";
- *
- * const action = {
- *   type: "approveAgent",
- *   hyperliquidChain: "Testnet", // "Mainnet" or "Testnet"
- *   signatureChainId: "0x66eee",
- *   nonce: Date.now(),
- *   agentAddress: "0x...",
- *   agentName: "Agent",
- * };
- *
- * const signature = await signUserSignedAction({
- *   wallet,
- *   action,
- *   types: {
- *     "HyperliquidTransaction:ApproveAgent": [
- *       { name: "hyperliquidChain", type: "string" },
- *       { name: "agentAddress", type: "address" },
- *       { name: "agentName", type: "string" },
- *       { name: "nonce", type: "uint64" },
- *     ],
- *   },
- *   chainId: parseInt(action.signatureChainId, 16),
- * });
- * ```
- *
- * @module
- */
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@noble/hashes/sha3", "../deps/jsr.io/@std/msgpack/1.0.3/encode.js", "../deps/jsr.io/@std/encoding/1.0.10/hex.js", "../deps/jsr.io/@std/bytes/1.0.6/concat.js"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.userSignedActionEip712Types = exports.actionSorter = void 0;
-    exports.createL1ActionHash = createL1ActionHash;
-    exports.signL1Action = signL1Action;
-    exports.signUserSignedAction = signUserSignedAction;
-    exports.signMultiSigAction = signMultiSigAction;
-    exports.isAbstractViemWalletClient = isAbstractViemWalletClient;
-    exports.isAbstractEthersSigner = isAbstractEthersSigner;
-    exports.isAbstractEthersV5Signer = isAbstractEthersV5Signer;
-    exports.isAbstractWindowEthereum = isAbstractWindowEthereum;
-    const sha3_1 = require("@noble/hashes/sha3");
-    const encode_js_1 = require("../deps/jsr.io/@std/msgpack/1.0.3/encode.js");
-    const hex_js_1 = require("../deps/jsr.io/@std/encoding/1.0.10/hex.js");
-    const concat_js_1 = require("../deps/jsr.io/@std/bytes/1.0.6/concat.js");
-    /**
-     * Create a hash of the L1 action.
-     *
-     * Note: Hash generation depends on the order of the action keys.
-     * @param action - The action to be hashed.
-     * @param nonce - Unique request identifier (recommended current timestamp in ms).
-     * @param vaultAddress - Optional vault address used in the action.
-     * @param expiresAfter - Optional expiration time of the action in milliseconds since the epoch.
-     * @returns The hash of the action.
-     */
-    function createL1ActionHash(action, nonce, vaultAddress, expiresAfter) {
-        // 1. Action
-        const actionBytes = (0, encode_js_1.encode)(normalizeIntegersForMsgPack(action));
-        // 2. Nonce
-        const nonceBytes = new Uint8Array(8);
-        new DataView(nonceBytes.buffer).setBigUint64(0, BigInt(nonce));
-        // 3. Vault address
-        let vaultMarker;
-        let vaultBytes;
-        if (vaultAddress) {
-            vaultMarker = Uint8Array.of(1);
-            vaultBytes = (0, hex_js_1.decodeHex)(vaultAddress.slice(2));
-        }
-        else {
-            vaultMarker = new Uint8Array(1);
-            vaultBytes = new Uint8Array();
-        }
-        // 4. Expires after
-        let expiresMarker;
-        let expiresBytes;
-        if (expiresAfter !== undefined) {
-            expiresMarker = new Uint8Array(1);
-            expiresBytes = new Uint8Array(8);
-            new DataView(expiresBytes.buffer).setBigUint64(0, BigInt(expiresAfter));
-        }
-        else {
-            expiresMarker = new Uint8Array();
-            expiresBytes = new Uint8Array();
-        }
-        // Create a keccak256 hash
-        const chunks = [
-            actionBytes,
-            nonceBytes,
-            vaultMarker,
-            vaultBytes,
-            expiresMarker,
-            expiresBytes,
-        ];
-        const bytes = (0, concat_js_1.concat)(chunks);
-        const hash = (0, sha3_1.keccak_256)(bytes);
-        return `0x${(0, hex_js_1.encodeHex)(hash)}`;
-    }
-    /** Layer to make {@link https://jsr.io/@std/msgpack | @std/msgpack} compatible with {@link https://github.com/msgpack/msgpack-javascript | @msgpack/msgpack}. */
-    function normalizeIntegersForMsgPack(obj) {
-        const THIRTY_ONE_BITS = 2147483648;
-        const THIRTY_TWO_BITS = 4294967296;
-        if (typeof obj === "number" && Number.isInteger(obj) &&
-            obj <= Number.MAX_SAFE_INTEGER && obj >= Number.MIN_SAFE_INTEGER &&
-            (obj >= THIRTY_TWO_BITS || obj < -THIRTY_ONE_BITS)) {
-            return BigInt(obj);
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(normalizeIntegersForMsgPack);
-        }
-        if (obj && typeof obj === "object" && obj !== null) {
-            return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, normalizeIntegersForMsgPack(value)]));
-        }
-        return obj;
-    }
-    /**
-     * Sign an L1 action.
-     *
-     * Note: Signature generation depends on the order of the action keys.
-     * @param args - Arguments for signing the action.
-     * @returns The signature components r, s, and v.
-     * @example
-     * ```ts
-     * import { signL1Action } from "@nktkas/hyperliquid/signing";
-     * import { privateKeyToAccount } from "viem/accounts";
-     *
-     * const wallet = privateKeyToAccount("0x..."); // Your private key
-     *
-     * const action = {
-     *     type: "cancel",
-     *     cancels: [
-     *         { a: 0, o: 12345 }, // Asset index and order ID
-     *     ],
-     * };
-     * const nonce = Date.now();
-     *
-     * const signature = await signL1Action({
-     *     wallet,
-     *     action,
-     *     nonce,
-     *     isTestnet: true, // Change to false for mainnet
-     * });
-     *
-     * const response = await fetch("https://api.hyperliquid-testnet.xyz/exchange", {
-     *     method: "POST",
-     *     headers: { "Content-Type": "application/json" },
-     *     body: JSON.stringify({ action, signature, nonce }),
-     * });
-     * const body = await response.json();
-     * ```
-     */
-    async function signL1Action(args) {
-        const { wallet, action, nonce, isTestnet = false, vaultAddress, expiresAfter, } = args;
-        const domain = {
-            name: "Exchange",
-            version: "1",
-            chainId: 1337,
-            verifyingContract: "0x0000000000000000000000000000000000000000",
-        };
-        const types = {
-            Agent: [
-                { name: "source", type: "string" },
-                { name: "connectionId", type: "bytes32" },
-            ],
-        };
-        const actionHash = createL1ActionHash(action, nonce, vaultAddress, expiresAfter);
-        const message = {
-            source: isTestnet ? "b" : "a",
-            connectionId: actionHash,
-        };
-        const signature = await abstractSignTypedData({ wallet, domain, types, message });
-        return splitSignature(signature);
-    }
-    /**
-     * Sign a user-signed action.
-     *
-     * Note: Signature generation depends on the order of types.
-     *
-     * @param args - Arguments for signing the action.
-     * @returns The signature components r, s, and v.
-     * @example
-     * ```ts
-     * import { signUserSignedAction } from "@nktkas/hyperliquid/signing";
-     * import { privateKeyToAccount } from "viem/accounts";
-     *
-     * const wallet = privateKeyToAccount("0x..."); // Your private key
-     *
-     * const action = {
-     *     type: "approveAgent",
-     *     hyperliquidChain: "Testnet", // "Mainnet" or "Testnet"
-     *     signatureChainId: "0x66eee",
-     *     nonce: Date.now(),
-     *     agentAddress: "0x...", // Change to your agent address
-     *     agentName: "Agent",
-     * };
-     *
-     * const signature = await signUserSignedAction({
-     *     wallet,
-     *     action,
-     *     types: {
-     *         "HyperliquidTransaction:ApproveAgent": [
-     *             { name: "hyperliquidChain", type: "string" },
-     *             { name: "agentAddress", type: "address" },
-     *             { name: "agentName", type: "string" },
-     *             { name: "nonce", type: "uint64" },
-     *         ],
-     *     },
-     *     chainId: parseInt(action.signatureChainId, 16),
-     * });
-     *
-     * const response = await fetch("https://api.hyperliquid-testnet.xyz/exchange", {
-     *     method: "POST",
-     *     headers: { "Content-Type": "application/json" },
-     *     body: JSON.stringify({ action, signature, nonce: action.nonce }),
-     * });
-     * const body = await response.json();
-     * ```
-     */
-    async function signUserSignedAction(args) {
-        const { wallet, action, types, chainId } = args;
-        const domain = {
-            name: "HyperliquidSignTransaction",
-            version: "1",
-            chainId,
-            verifyingContract: "0x0000000000000000000000000000000000000000",
-        };
-        const signature = await abstractSignTypedData({ wallet, domain, types, message: action });
-        return splitSignature(signature);
-    }
-    /**
-     * Sign a multi-signature action.
-     *
-     * Note: Signature generation depends on the order of the action keys.
-     *
-     * @param args - Arguments for signing the action.
-     * @returns The signature components r, s, and v.
-     * @example
-     * ```ts
-     * import { signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
-     * import { privateKeyToAccount } from "viem/accounts";
-     *
-     * const wallet = privateKeyToAccount("0x..."); // Your private key
-     * const multiSigUser = "0x..."; // Multi-sig user address
-     *
-     * const nonce = Date.now();
-     * const action = { // Example action
-     *   type: "scheduleCancel",
-     *   time: Date.now() + 10000
-     * };
-     *
-     * // First, create signature from one of the authorized signers
-     * const signature = await signL1Action({
-     *   wallet,
-     *   action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), action],
-     *   nonce,
-     *   isTestnet: true,
-     * });
-     *
-     * // Then use it in the multi-sig action
-     * const multiSigSignature = await signMultiSigAction({
-     *   wallet,
-     *   action: {
-     *     type: "multiSig",
-     *     signatureChainId: "0x66eee",
-     *     signatures: [signature],
-     *     payload: {
-     *       multiSigUser,
-     *       outerSigner: wallet.address,
-     *       action,
-     *     }
-     *   },
-     *   nonce,
-     *   hyperliquidChain: "Testnet",
-     *   signatureChainId: "0x66eee",
-     * });
-     * ```
-     */
-    async function signMultiSigAction(args) {
-        const { wallet, action, nonce, hyperliquidChain, signatureChainId, vaultAddress, expiresAfter, } = args;
-        const multiSigActionHash = createL1ActionHash(action, nonce, vaultAddress, expiresAfter);
-        const message = {
-            multiSigActionHash,
-            hyperliquidChain,
-            signatureChainId,
-            nonce,
-        };
-        return await signUserSignedAction({
-            wallet,
-            action: message,
-            types: {
-                "HyperliquidTransaction:SendMultiSig": [
-                    { name: "hyperliquidChain", type: "string" },
-                    { name: "multiSigActionHash", type: "bytes32" },
-                    { name: "nonce", type: "uint64" },
-                ],
-            },
-            chainId: parseInt(signatureChainId, 16),
-        });
-    }
-    /** Signs typed data with the provided wallet using EIP-712. */
-    async function abstractSignTypedData(args) {
-        const { wallet, domain, types, message } = args;
-        if (isAbstractViemWalletClient(wallet)) {
-            return await wallet.signTypedData({
-                domain,
-                types: {
-                    EIP712Domain: [
-                        { name: "name", type: "string" },
-                        { name: "version", type: "string" },
-                        { name: "chainId", type: "uint256" },
-                        { name: "verifyingContract", type: "address" },
-                    ],
-                    ...types,
-                },
-                primaryType: Object.keys(types)[0],
-                message,
-            });
-        }
-        else if (isAbstractEthersSigner(wallet)) {
-            return await wallet.signTypedData(domain, types, message);
-        }
-        else if (isAbstractEthersV5Signer(wallet)) {
-            return await wallet._signTypedData(domain, types, message);
-        }
-        else if (isAbstractWindowEthereum(wallet)) {
-            return await signTypedDataWithWindowEthereum(wallet, domain, types, message);
-        }
-        else {
-            throw new Error("Unsupported wallet for signing typed data");
-        }
-    }
-    /** Signs typed data using `window.ethereum` (EIP-1193) with `eth_signTypedData_v4` (EIP-712). */
-    async function signTypedDataWithWindowEthereum(ethereum, domain, types, message) {
-        const accounts = await ethereum.request({
-            method: "eth_requestAccounts",
-            params: [],
-        });
-        if (!Array.isArray(accounts) || accounts.length === 0) {
-            throw new Error("No Ethereum accounts available");
-        }
-        const from = accounts[0];
-        const dataToSign = JSON.stringify({
-            domain,
-            types: {
-                EIP712Domain: [
-                    { name: "name", type: "string" },
-                    { name: "version", type: "string" },
-                    { name: "chainId", type: "uint256" },
-                    { name: "verifyingContract", type: "address" },
-                ],
-                ...types,
-            },
-            primaryType: Object.keys(types)[0],
-            message,
-        });
-        return await ethereum.request({
-            method: "eth_signTypedData_v4",
-            params: [from, dataToSign],
-        });
-    }
-    /** Splits a signature hexadecimal string into its components. */
-    function splitSignature(signature) {
-        const r = `0x${signature.slice(2, 66)}`;
-        const s = `0x${signature.slice(66, 130)}`;
-        const v = parseInt(signature.slice(130, 132), 16);
-        return { r, s, v };
-    }
-    /** Checks if the given value is an abstract viem wallet. */
-    function isAbstractViemWalletClient(client) {
-        return typeof client === "object" && client !== null &&
-            "signTypedData" in client && typeof client.signTypedData === "function" &&
-            (client.signTypedData.length === 1 || client.signTypedData.length === 2);
-    }
-    /** Checks if the given value is an abstract ethers signer. */
-    function isAbstractEthersSigner(client) {
-        return typeof client === "object" && client !== null &&
-            "signTypedData" in client && typeof client.signTypedData === "function" &&
-            client.signTypedData.length === 3;
-    }
-    /** Checks if the given value is an abstract ethers v5 signer. */
-    function isAbstractEthersV5Signer(client) {
-        return typeof client === "object" && client !== null &&
-            "_signTypedData" in client && typeof client._signTypedData === "function" &&
-            client._signTypedData.length === 3;
-    }
-    /** Checks if the given value is an abstract `window.ethereum` object. */
-    function isAbstractWindowEthereum(client) {
-        return typeof client === "object" && client !== null &&
-            "request" in client && typeof client.request === "function" &&
-            client.request.length >= 1;
-    }
-    /** Action sorter for correct signature generation. */
-    exports.actionSorter = {
-        /** Sorts and formats an `approveAgent` action. */
-        approveAgent: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                agentAddress: action.agentAddress.toLowerCase(),
-                agentName: action.agentName ?? "",
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats an `approveBuilderFee` action. */
-        approveBuilderFee: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                maxFeeRate: action.maxFeeRate,
-                builder: action.builder.toLowerCase(),
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `batchModify` action. */
-        batchModify: (action) => {
-            return {
-                type: action.type,
-                modifies: action.modifies.map((modify) => {
-                    const sortedModify = {
-                        oid: modify.oid,
-                        order: {
-                            a: modify.order.a,
-                            b: modify.order.b,
-                            p: formatDecimal(modify.order.p),
-                            s: formatDecimal(modify.order.s),
-                            r: modify.order.r,
-                            t: "limit" in modify.order.t
-                                ? {
-                                    limit: {
-                                        tif: modify.order.t.limit.tif,
-                                    },
-                                }
-                                : {
-                                    trigger: {
-                                        isMarket: modify.order.t.trigger.isMarket,
-                                        triggerPx: formatDecimal(modify.order.t.trigger.triggerPx),
-                                        tpsl: modify.order.t.trigger.tpsl,
-                                    },
-                                },
-                            c: modify.order.c,
-                        },
-                    };
-                    if (sortedModify.order.c === undefined)
-                        delete sortedModify.order.c;
-                    return sortedModify;
-                }),
-            };
-        },
-        /** Sorts and formats a `cancel` action. */
-        cancel: (action) => {
-            return {
-                type: action.type,
-                cancels: action.cancels.map((cancel) => ({
-                    a: cancel.a,
-                    o: cancel.o,
-                })),
-            };
-        },
-        /** Sorts and formats a `cancelByCloid` action. */
-        cancelByCloid: (action) => {
-            return {
-                type: action.type,
-                cancels: action.cancels.map((cancel) => ({
-                    asset: cancel.asset,
-                    cloid: cancel.cloid,
-                })),
-            };
-        },
-        /** Sorts and formats a `cDeposit` action. */
-        cDeposit: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                wei: action.wei,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `claimRewards` action. */
-        claimRewards: (action) => {
-            return {
-                type: action.type,
-            };
-        },
-        /** Sorts and formats a `convertToMultiSigUser` action. */
-        convertToMultiSigUser: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                signers: action.signers,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `createSubAccount` action. */
-        createSubAccount: (action) => {
-            return {
-                type: action.type,
-                name: action.name,
-            };
-        },
-        /** Sorts and formats a `createVault` action. */
-        createVault: (action) => {
-            return {
-                type: action.type,
-                name: action.name,
-                description: action.description,
-                initialUsd: action.initialUsd,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `CSignerAction` action (jail/unjail). */
-        CSignerAction: (action) => {
-            if ("jailSelf" in action) {
-                return {
-                    type: action.type,
-                    jailSelf: action.jailSelf,
-                };
-            }
-            else {
-                return {
-                    type: action.type,
-                    unjailSelf: action.unjailSelf,
-                };
-            }
-        },
-        /** Sorts and formats a `CValidatorAction` action (register/unregister/change profile). */
-        CValidatorAction: (action) => {
-            if ("changeProfile" in action) {
-                return {
-                    type: action.type,
-                    changeProfile: {
-                        node_ip: action.changeProfile.node_ip ?? null,
-                        name: action.changeProfile.name ?? null,
-                        description: action.changeProfile.description ?? null,
-                        unjailed: action.changeProfile.unjailed,
-                        disable_delegations: action.changeProfile.disable_delegations ?? null,
-                        commission_bps: action.changeProfile.commission_bps ?? null,
-                        signer: action.changeProfile.signer?.toLowerCase() ?? null,
-                    },
-                };
-            }
-            else if ("register" in action) {
-                return {
-                    type: action.type,
-                    register: {
-                        profile: {
-                            node_ip: {
-                                Ip: action.register.profile.node_ip.Ip,
-                            },
-                            name: action.register.profile.name,
-                            description: action.register.profile.description,
-                            delegations_disabled: action.register.profile.delegations_disabled,
-                            commission_bps: action.register.profile.commission_bps,
-                            signer: action.register.profile.signer.toLowerCase(),
-                        },
-                        unjailed: action.register.unjailed,
-                        initial_wei: action.register.initial_wei,
-                    },
-                };
-            }
-            else { // "unregister" in action
-                return {
-                    type: action.type,
-                    unregister: action.unregister,
-                };
-            }
-        },
-        /** Sorts and formats a `cWithdraw` action. */
-        cWithdraw: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                wei: action.wei,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats an `evmUserModify` action. */
-        evmUserModify: (action) => {
-            return {
-                type: action.type,
-                usingBigBlocks: action.usingBigBlocks,
-            };
-        },
-        /** Sorts and formats a `modify` action. */
-        modify: (action) => {
-            const sortedAction = {
-                type: action.type,
-                oid: action.oid,
-                order: {
-                    a: action.order.a,
-                    b: action.order.b,
-                    p: formatDecimal(action.order.p),
-                    s: formatDecimal(action.order.s),
-                    r: action.order.r,
-                    t: "limit" in action.order.t
-                        ? {
-                            limit: {
-                                tif: action.order.t.limit.tif,
-                            },
-                        }
-                        : {
-                            trigger: {
-                                isMarket: action.order.t.trigger.isMarket,
-                                triggerPx: formatDecimal(action.order.t.trigger.triggerPx),
-                                tpsl: action.order.t.trigger.tpsl,
-                            },
-                        },
-                    c: action.order.c,
-                },
-            };
-            if (sortedAction.order.c === undefined)
-                delete sortedAction.order.c;
-            return sortedAction;
-        },
-        /** Sorts and formats a `multiSig` action. */
-        multiSig: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                signatures: action.signatures.map((signature) => ({
-                    r: signature.r.replace(/^0x0+/, "0x").toLowerCase(),
-                    s: signature.s.replace(/^0x0+/, "0x").toLowerCase(),
-                    v: signature.v,
-                })),
-                payload: {
-                    multiSigUser: action.payload.multiSigUser.toLowerCase(),
-                    outerSigner: action.payload.outerSigner.toLowerCase(),
-                    action: action.payload.action,
-                },
-            };
-        },
-        /** Sorts and formats an `order` action. */
-        order: (action) => {
-            const sortedAction = {
-                type: action.type,
-                orders: action.orders.map((order) => {
-                    const sortedOrder = {
-                        a: order.a,
-                        b: order.b,
-                        p: formatDecimal(order.p),
-                        s: formatDecimal(order.s),
-                        r: order.r,
-                        t: "limit" in order.t
-                            ? {
-                                limit: {
-                                    tif: order.t.limit.tif,
-                                },
-                            }
-                            : {
-                                trigger: {
-                                    isMarket: order.t.trigger.isMarket,
-                                    triggerPx: formatDecimal(order.t.trigger.triggerPx),
-                                    tpsl: order.t.trigger.tpsl,
-                                },
-                            },
-                        c: order.c,
-                    };
-                    if (order.c === undefined)
-                        delete sortedOrder.c;
-                    return sortedOrder;
-                }),
-                grouping: action.grouping,
-                builder: action.builder
-                    ? {
-                        b: action.builder.b.toLowerCase(),
-                        f: action.builder.f,
-                    }
-                    : action.builder,
-            };
-            if (sortedAction.builder === undefined)
-                delete sortedAction.builder;
-            return sortedAction;
-        },
-        /** Sorts and formats a `perpDeploy` action. */
-        perpDeploy: (action) => {
-            if ("registerAsset" in action) {
-                return {
-                    type: action.type,
-                    registerAsset: {
-                        maxGas: action.registerAsset.maxGas ?? null,
-                        assetRequest: {
-                            coin: action.registerAsset.assetRequest.coin,
-                            szDecimals: action.registerAsset.assetRequest.szDecimals,
-                            oraclePx: action.registerAsset.assetRequest.oraclePx,
-                            marginTableId: action.registerAsset.assetRequest.marginTableId,
-                            onlyIsolated: action.registerAsset.assetRequest.onlyIsolated,
-                        },
-                        dex: action.registerAsset.dex,
-                        schema: action.registerAsset.schema
-                            ? {
-                                fullName: action.registerAsset.schema.fullName,
-                                collateralToken: action.registerAsset.schema.collateralToken,
-                                oracleUpdater: action.registerAsset.schema.oracleUpdater?.toLowerCase() ?? null,
-                            }
-                            : null,
-                    },
-                };
-            }
-            else {
-                return {
-                    type: action.type,
-                    setOracle: {
-                        dex: action.setOracle.dex,
-                        oraclePxs: action.setOracle.oraclePxs,
-                        markPxs: action.setOracle.markPxs,
-                    },
-                };
-            }
-        },
-        /** Sorts and formats a `PerpDexClassTransfer` action. */
-        PerpDexClassTransfer: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                dex: action.dex,
-                token: action.token,
-                amount: action.amount,
-                toPerp: action.toPerp,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `registerReferrer` action. */
-        registerReferrer: (action) => {
-            return {
-                type: action.type,
-                code: action.code,
-            };
-        },
-        /** Sorts and formats a `reserveRequestWeight` action. */
-        reserveRequestWeight: (action) => {
-            return {
-                type: action.type,
-                weight: action.weight,
-            };
-        },
-        /** Sorts and formats a `scheduleCancel` action. */
-        scheduleCancel: (action) => {
-            const sortedAction = {
-                type: action.type,
-                time: action.time,
-            };
-            if (sortedAction.time === undefined)
-                delete sortedAction.time;
-            return sortedAction;
-        },
-        /** Sorts and formats a `setDisplayName` action. */
-        setDisplayName: (action) => {
-            return {
-                type: action.type,
-                displayName: action.displayName,
-            };
-        },
-        /** Sorts and formats a `setReferrer` action. */
-        setReferrer: (action) => {
-            return {
-                type: action.type,
-                code: action.code,
-            };
-        },
-        /** Sorts and formats a `spotDeploy` action. */
-        spotDeploy: (action) => {
-            if ("genesis" in action) {
-                const sortedAction = {
-                    type: action.type,
-                    genesis: {
-                        token: action.genesis.token,
-                        maxSupply: action.genesis.maxSupply,
-                        noHyperliquidity: action.genesis.noHyperliquidity,
-                    },
-                };
-                if (sortedAction.genesis.noHyperliquidity === undefined) {
-                    delete sortedAction.genesis.noHyperliquidity;
-                }
-                return sortedAction;
-            }
-            else if ("registerHyperliquidity" in action) {
-                const sortedAction = {
-                    type: action.type,
-                    registerHyperliquidity: {
-                        spot: action.registerHyperliquidity.spot,
-                        startPx: action.registerHyperliquidity.startPx,
-                        orderSz: action.registerHyperliquidity.orderSz,
-                        nOrders: action.registerHyperliquidity.nOrders,
-                        nSeededLevels: action.registerHyperliquidity.nSeededLevels,
-                    },
-                };
-                if (sortedAction.registerHyperliquidity.nSeededLevels === undefined) {
-                    delete sortedAction.registerHyperliquidity.nSeededLevels;
-                }
-                return sortedAction;
-            }
-            else if ("registerSpot" in action) {
-                return {
-                    type: action.type,
-                    registerSpot: {
-                        tokens: action.registerSpot.tokens,
-                    },
-                };
-            }
-            else if ("registerToken2" in action) {
-                const sortedAction = {
-                    type: action.type,
-                    registerToken2: {
-                        spec: {
-                            name: action.registerToken2.spec.name,
-                            szDecimals: action.registerToken2.spec.szDecimals,
-                            weiDecimals: action.registerToken2.spec.weiDecimals,
-                        },
-                        maxGas: action.registerToken2.maxGas,
-                        fullName: action.registerToken2.fullName,
-                    },
-                };
-                if (sortedAction.registerToken2.fullName === undefined) {
-                    delete sortedAction.registerToken2.fullName;
-                }
-                return sortedAction;
-            }
-            else if ("setDeployerTradingFeeShare" in action) {
-                return {
-                    type: action.type,
-                    setDeployerTradingFeeShare: {
-                        token: action.setDeployerTradingFeeShare.token,
-                        share: action.setDeployerTradingFeeShare.share,
-                    },
-                };
-            }
-            else { // "userGenesis" in action
-                const sortedAction = {
-                    type: action.type,
-                    userGenesis: {
-                        token: action.userGenesis.token,
-                        userAndWei: action.userGenesis.userAndWei,
-                        existingTokenAndWei: action.userGenesis.existingTokenAndWei,
-                        blacklistUsers: action.userGenesis.blacklistUsers,
-                    },
-                };
-                if (sortedAction.userGenesis.blacklistUsers === undefined) {
-                    delete sortedAction.userGenesis.blacklistUsers;
-                }
-                return sortedAction;
-            }
-        },
-        /** Sorts and formats a `spotSend` action. */
-        spotSend: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                destination: action.destination.toLowerCase(),
-                token: action.token,
-                amount: action.amount,
-                time: action.time,
-            };
-        },
-        /** Sorts and formats a `spotUser` action. */
-        spotUser: (action) => {
-            return {
-                type: action.type,
-                toggleSpotDusting: {
-                    optOut: action.toggleSpotDusting.optOut,
-                },
-            };
-        },
-        /** Sorts and formats a `subAccountSpotTransfer` action. */
-        subAccountSpotTransfer: (action) => {
-            return {
-                type: action.type,
-                subAccountUser: action.subAccountUser.toLowerCase(),
-                isDeposit: action.isDeposit,
-                token: action.token,
-                amount: action.amount,
-            };
-        },
-        /** Sorts and formats a `subAccountTransfer` action. */
-        subAccountTransfer: (action) => {
-            return {
-                type: action.type,
-                subAccountUser: action.subAccountUser.toLowerCase(),
-                isDeposit: action.isDeposit,
-                usd: action.usd,
-            };
-        },
-        /** Sorts and formats a `tokenDelegate` action. */
-        tokenDelegate: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                validator: action.validator.toLowerCase(),
-                wei: action.wei,
-                isUndelegate: action.isUndelegate,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats a `twapCancel` action. */
-        twapCancel: (action) => {
-            return {
-                type: action.type,
-                a: action.a,
-                t: action.t,
-            };
-        },
-        /** Sorts and formats a `twapOrder` action. */
-        twapOrder: (action) => {
-            return {
-                type: action.type,
-                twap: {
-                    a: action.twap.a,
-                    b: action.twap.b,
-                    s: formatDecimal(action.twap.s),
-                    r: action.twap.r,
-                    m: action.twap.m,
-                    t: action.twap.t,
-                },
-            };
-        },
-        /** Sorts and formats an `updateIsolatedMargin` action. */
-        updateIsolatedMargin: (action) => {
-            return {
-                type: action.type,
-                asset: action.asset,
-                isBuy: action.isBuy,
-                ntli: action.ntli,
-            };
-        },
-        /** Sorts and formats an `updateLeverage` action. */
-        updateLeverage: (action) => {
-            return {
-                type: action.type,
-                asset: action.asset,
-                isCross: action.isCross,
-                leverage: action.leverage,
-            };
-        },
-        /** Sorts and formats an `usdClassTransfer` action. */
-        usdClassTransfer: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                amount: action.amount,
-                toPerp: action.toPerp,
-                nonce: action.nonce,
-            };
-        },
-        /** Sorts and formats an `usdSend` action. */
-        usdSend: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                destination: action.destination.toLowerCase(),
-                amount: action.amount,
-                time: action.time,
-            };
-        },
-        /** Sorts and formats a `vaultDistribute` action. */
-        vaultDistribute: (action) => {
-            return {
-                type: action.type,
-                vaultAddress: action.vaultAddress,
-                usd: action.usd,
-            };
-        },
-        /** Sorts and formats a `vaultModify` action. */
-        vaultModify: (action) => {
-            return {
-                type: action.type,
-                vaultAddress: action.vaultAddress,
-                allowDeposits: action.allowDeposits,
-                alwaysCloseOnWithdraw: action.alwaysCloseOnWithdraw,
-            };
-        },
-        /** Sorts and formats a `vaultTransfer` action. */
-        vaultTransfer: (action) => {
-            return {
-                type: action.type,
-                vaultAddress: action.vaultAddress,
-                isDeposit: action.isDeposit,
-                usd: action.usd,
-            };
-        },
-        /** Sorts and formats a `withdraw3` action. */
-        withdraw3: (action) => {
-            return {
-                type: action.type,
-                signatureChainId: action.signatureChainId,
-                hyperliquidChain: action.hyperliquidChain,
-                destination: action.destination.toLowerCase(),
-                amount: action.amount,
-                time: action.time,
-            };
-        },
-    };
-    /** Removes trailing zeros from decimal string. */
-    function formatDecimal(numStr) {
-        if (!numStr.includes("."))
-            return numStr;
-        const [intPart, fracPart] = numStr.split(".");
-        const newFrac = fracPart.replace(/0+$/, "");
-        return newFrac ? `${intPart}.${newFrac}` : intPart;
-    }
-    /** EIP-712 type definitions for user-signed actions. */
-    exports.userSignedActionEip712Types = {
-        approveAgent: {
-            "HyperliquidTransaction:ApproveAgent": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "agentAddress", type: "address" },
-                { name: "agentName", type: "string" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        approveBuilderFee: {
-            "HyperliquidTransaction:ApproveBuilderFee": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "maxFeeRate", type: "string" },
-                { name: "builder", type: "address" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        cDeposit: {
-            "HyperliquidTransaction:CDeposit": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "wei", type: "uint64" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        convertToMultiSigUser: {
-            "HyperliquidTransaction:ConvertToMultiSigUser": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "signers", type: "string" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        cWithdraw: {
-            "HyperliquidTransaction:CWithdraw": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "wei", type: "uint64" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        PerpDexClassTransfer: {
-            "HyperliquidTransaction:PerpDexClassTransfer": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "dex", type: "string" },
-                { name: "token", type: "string" },
-                { name: "amount", type: "string" },
-                { name: "toPerp", type: "bool" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        spotSend: {
-            "HyperliquidTransaction:SpotSend": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "destination", type: "string" },
-                { name: "token", type: "string" },
-                { name: "amount", type: "string" },
-                { name: "time", type: "uint64" },
-            ],
-        },
-        tokenDelegate: {
-            "HyperliquidTransaction:TokenDelegate": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "validator", type: "address" },
-                { name: "wei", type: "uint64" },
-                { name: "isUndelegate", type: "bool" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        usdClassTransfer: {
-            "HyperliquidTransaction:UsdClassTransfer": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "amount", type: "string" },
-                { name: "toPerp", type: "bool" },
-                { name: "nonce", type: "uint64" },
-            ],
-        },
-        usdSend: {
-            "HyperliquidTransaction:UsdSend": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "destination", type: "string" },
-                { name: "amount", type: "string" },
-                { name: "time", type: "uint64" },
-            ],
-        },
-        withdraw3: {
-            "HyperliquidTransaction:Withdraw": [
-                { name: "hyperliquidChain", type: "string" },
-                { name: "destination", type: "string" },
-                { name: "amount", type: "string" },
-                { name: "time", type: "uint64" },
-            ],
-        },
-    };
-});