@nktkas/hyperliquid 0.21.0 → 0.22.0

package/script/src/signing.js

@@ -60,6 +60,7 @@
 })(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;
@@ -67,7 +68,6 @@
     exports.isAbstractViemWalletClient = isAbstractViemWalletClient;
     exports.isAbstractEthersSigner = isAbstractEthersSigner;
     exports.isAbstractEthersV5Signer = isAbstractEthersV5Signer;
-    exports.isAbstractExtendedViemWalletClient = isAbstractExtendedViemWalletClient;
     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");
@@ -303,7 +303,6 @@
      *   signatureChainId: "0x66eee",
      * });
      * ```
-     * @unstable May not behave as expected and the interface may change in the future.
      */
     async function signMultiSigAction(args) {
         const { wallet, action, nonce, hyperliquidChain, signatureChainId, vaultAddress, expiresAfter, } = args;
@@ -330,7 +329,7 @@
     /** Signs typed data with the provided wallet using EIP-712. */
     async function abstractSignTypedData(args) {
         const { wallet, domain, types, message } = args;
-        if (isAbstractViemWalletClient(wallet) || isAbstractExtendedViemWalletClient(wallet)) {
+        if (isAbstractViemWalletClient(wallet)) {
             return await wallet.signTypedData({
                 domain,
                 types: {
@@ -399,7 +398,7 @@
     function isAbstractViemWalletClient(client) {
         return typeof client === "object" && client !== null &&
             "signTypedData" in client && typeof client.signTypedData === "function" &&
-            client.signTypedData.length === 1;
+            (client.signTypedData.length === 1 || client.signTypedData.length === 2);
     }
     /** Checks if the given value is an abstract ethers signer. */
     function isAbstractEthersSigner(client) {
@@ -413,16 +412,718 @@
             "_signTypedData" in client && typeof client._signTypedData === "function" &&
             client._signTypedData.length === 3;
     }
-    /** Checks if the given value is an abstract extended viem wallet (e.g. privy `useSignTypedData`). */
-    function isAbstractExtendedViemWalletClient(client) {
-        return typeof client === "object" && client !== null &&
-            "signTypedData" in client && typeof client.signTypedData === "function" &&
-            client.signTypedData.length === 2;
-    }
     /** 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" },
+            ],
+        },
+    };
 });