@nktkas/hyperliquid 0.21.0 → 0.22.0

package/esm/src/signing.js

@@ -283,7 +283,6 @@ export async function signUserSignedAction(args) {
  *   signatureChainId: "0x66eee",
  * });
  * ```
- * @unstable May not behave as expected and the interface may change in the future.
  */
 export async function signMultiSigAction(args) {
     const { wallet, action, nonce, hyperliquidChain, signatureChainId, vaultAddress, expiresAfter, } = args;
@@ -310,7 +309,7 @@ export async function signMultiSigAction(args) {
 /** 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: {
@@ -379,7 +378,7 @@ function splitSignature(signature) {
 export 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. */
 export function isAbstractEthersSigner(client) {
@@ -393,15 +392,717 @@ export function isAbstractEthersV5Signer(client) {
         "_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`). */
-export 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. */
 export 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. */
+export const 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. */
+export const 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" },
+        ],
+    },
+};