# @deeeed/hyperliquid-node20 中文文档

规范地址：https://npmcn.com/package/%40deeeed/hyperliquid-node20/

版本：0\.23\.1-node20\.1
npm 元数据更新时间：2025-07-03T14:46:03.955Z
中文译文更新时间：2026-11-16T02:07:34.754Z
软件包许可：MIT

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/%40deeeed/hyperliquid-node20
原文对照：https://npmcn.com/package/%40deeeed/hyperliquid-node20/?lang=original
项目主页：https://github.com/abretonc7s/hyperliquid
源码仓库：https://github.com/abretonc7s/hyperliquid

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：1.4 MB，211 个文件
- 模块格式：ESM + CJS
- TypeScript 类型：包内自带
- Node.js 要求：\>=20\.18\.0
- 运行依赖：4 个
- 首次发布：2025-07-03T14:46:03.024Z
- 最新版本发布：2025-07-03T14:46:03.680Z
- 近 30 天下载量：1960（2026-10-12 至 2026-11-10，npm 官方下载统计）
- 已发布版本数：1（近 12 个月 0 个）

## 中文简介

非官方的超液态API SDK用于所有主要JS运行时间,用TypeScript来写作. 与节点.js 20.1.8.0+相容性的分叉.

## 安装

```sh
npm install @deeeed/hyperliquid-node20
```

也可以使用：`pnpm add @deeeed/hyperliquid-node20`、`yarn add @deeeed/hyperliquid-node20`、`bun add @deeeed/hyperliquid-node20`

## README

# 超液态 API 类型SDK(节点.js 20+相容分叉)

> **分叉通知**:这是极品的叉子 [`@nktkas/hyperliquid`](https://github.com/nktkas/hyperliquid) 软件包由 [纳克卡](https://github.com/nktkas),修改后支持节点.js 20.1.8.0+. 原执行的功劳全部归原作者.
> 
> **原始软件包**数字 : [`@nktkas/hyperliquid`](https://www.npmjs.com/package/@nktkas/hyperliquid)  
> **这个叉子**数字 : [`@deeeed/hyperliquid-node20`](https://www.npmjs.com/package/@deeeed/hyperliquid-node20)  
> **仓库**数字 : [github.com/abretonc7s/高液态](https://github.com/abretonc7s/hyperliquid)
> 
> **为什么这个叉子?** 由于JavaScript较新的特性,原包需要Node.js ≥24.0.0. 此叉会添加多填充来支持Node.js ≥20.18.0,同时保持100%的API相容性.
> 
> 📄 **见 [变相( M)](https://npmcn.com/package/%40deeeed/hyperliquid-node20/FORK_CHANGES.md) 详细了解所作修改.**

[![npm](https://img.shields.io/npm/v/@deeeed/hyperliquid-node20?style=flat-square&color=blue)](https://www.npmjs.com/package/@deeeed/hyperliquid-node20) [![Node.js Compatibility](https://img.shields.io/badge/node-%3E%3D20.18.0-brightgreen?style=flat-square)](https://nodejs.org/)

非正式 [超液态 API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api) 所有主要联署材料的SDK 运行时间,用TypeScript来写,并提供测试.

## 特征

-   🖋️ **类型**:源代码为100% TypeScript.
-   🧪 **已测试**:良好的代码覆盖和类型安全API响应.
-   📦 **最小依赖性**:几个小的可信赖的依赖关系.
-   🌐 **跨环境支助**: 与所有主要JS运行时间相兼容.
-   🔧 **难分**: 易于使用 [维姆](https://github.com/wevm/viem), (中文(简体) ), [醚](https://github.com/ethers-io/ethers.js) 和其他钱包库.
-   📚 **记录**: JSDoc 说明,有源代码中的用法示例.

## 安装

> \[注\] 虽然这个库在TypeScript中,但它也可以被用在JavaScript中,并支持ESM/CommonJS.

### 节点.js(选择您的软件包管理器)

```
npm i @deeeed/hyperliquid-node20

pnpm add @deeeed/hyperliquid-node20

yarn add @deeeed/hyperliquid-node20
```

> **从原移民**: 简单替换 `@nktkas/hyperliquid` 与 `@deeeed/hyperliquid-node20` 在进口。 所有API都一样.

### 德诺

```
deno add jsr:@deeeed/hyperliquid-node20
```

### 网页

```html
<script type="module">
    import * as hl from "https://esm.sh/jsr/@deeeed/hyperliquid-node20";
</script>
```

### 原生反应

对于反应原生,在导入 SDK 之前需要导入多填充:

```js
// React Native 0.76.3 / Expo v52
// Issues:
// - signing: does not support private keys directly, use viem or ethers

import { Event, EventTarget } from "event-target-shim";

if (!globalThis.EventTarget || !globalThis.Event) {
    globalThis.EventTarget = EventTarget;
    globalThis.Event = Event;
}

if (!globalThis.CustomEvent) {
    globalThis.CustomEvent = function (type, params) {
        params = params || {};
        const event = new Event(type, params);
        event.detail = params.detail || null;
        return event;
    };
}

if (!AbortSignal.timeout) {
    AbortSignal.timeout = function (delay) {
        const controller = new AbortController();
        setTimeout(() => controller.abort(), delay);
        return controller.signal;
    };
}

if (!Promise.withResolvers) {
    Promise.withResolvers = function () {
        let resolve, reject;
        const promise = new Promise((res, rej) => {
            resolve = res;
            reject = rej;
        });
        return { promise, resolve, reject };
    };
}
```

## 快速启动

#### 信息端点

```ts
import * as hl from "@deeeed/hyperliquid-node20";

const transport = new hl.HttpTransport();
const infoClient = new hl.InfoClient({ transport });

const openOrders = await infoClient.openOrders({ user: "0x..." });
```

#### 交换端点

```ts
import * as hl from "@deeeed/hyperliquid-node20";

const privateKey = "0x..."; // or `viem`, `ethers`

const transport = new hl.HttpTransport();
const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });

const result = await exchClient.order({
    orders: [{
        a: 0,
        b: true,
        p: "30000",
        s: "0.1",
        r: false,
        t: {
            limit: {
                tif: "Gtc",
            },
        },
    }],
    grouping: "na",
});
```

#### 订阅

```ts
import * as hl from "@deeeed/hyperliquid-node20";

const transport = new hl.WebSocketTransport();
const subsClient = new hl.SubscriptionClient({ transport });

const sub = await subsClient.allMids((event) => {
    console.log(event);
});

await sub.unsubscribe(); // unsubscribe from the event
```

#### 多签名

```ts
import * as hl from "@deeeed/hyperliquid-node20";

const multiSignAddress = "0x...";
const signers = [
    "0x...", // Private key; or any other wallet libraries
] as const;

const transport = new hl.HttpTransport();
const multiSignClient = new hl.MultiSignClient({ transport, multiSignAddress, signers }); // extends `ExchangeClient`

const data = await multiSignClient.approveAgent({ // same API as `ExchangeClient`
    agentAddress: "0x...",
    agentName: "agentName",
});
```

## 使用量

### (1) 初始化运输

首先,选择和配置您的传输层(详见 [API 参考](https://npmcn.com/package/%40deeeed/hyperliquid-node20/#readme-transports):

```ts
import * as hl from "@nktkas/hyperliquid";

// 1. HTTP Transport: suitable for one-time requests or serverless environments
const httpTransport = new hl.HttpTransport(); // Accepts optional parameters (e.g. isTestnet, timeout, etc.)

// 2. WebSocket Transport: has better network latency than HTTP transport
const wsTransport = new hl.WebSocketTransport(); // Accepts optional parameters (e.g. url, timeout, reconnect, etc.)
```

### 2) 初始化客户端

接下来,以传输层初始化客户端(详见 [API 参考](https://npmcn.com/package/%40deeeed/hyperliquid-node20/#readme-clients):

#### 创建信息客户端

```ts
import * as hl from "@nktkas/hyperliquid";

const transport = new hl.HttpTransport(); // or `WebSocketTransport`
const infoClient = new hl.InfoClient({ transport });
```

#### 创建交换客户端

```ts
import * as hl from "@nktkas/hyperliquid";
import { createWalletClient, custom } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { ethers } from "ethers";

const transport = new hl.HttpTransport(); // or `WebSocketTransport`

// 1. Using private key directly
const privateKey = "0x...";
const exchClient_privateKey = new hl.ExchangeClient({ wallet: privateKey, transport });

// 2. Using Viem
const viemAccount = privateKeyToAccount("0x...");
const exchClient_viem = new hl.ExchangeClient({ wallet: viemAccount, transport });

// 3. Using Ethers (or Ethers V5)
const ethersWallet = new ethers.Wallet("0x...");
const exchClient_ethers = new hl.ExchangeClient({ wallet: ethersWallet, transport });

// 4. Using external wallet (e.g. MetaMask) via Viem
const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
const externalWallet = createWalletClient({ account, transport: custom(window.ethereum) });
const exchClient_viemMetamask = new hl.ExchangeClient({ wallet: externalWallet, transport });

// 5. Using external wallet (e.g. MetaMask) via `window.ethereum`
const exchClient_windowMetamask = new hl.ExchangeClient({ wallet: window.ethereum, transport });
```

#### 创建订阅客户端

```ts
import * as hl from "@nktkas/hyperliquid";

const transport = new hl.WebSocketTransport(); // only `WebSocketTransport`
const subsClient = new hl.SubscriptionClient({ transport });
```

#### 创建多标志

```ts
import * as hl from "@nktkas/hyperliquid";
import { privateKeyToAccount } from "viem/accounts";
import { ethers } from "ethers";

const multiSignAddress = "0x...";
const signers = [
    privateKeyToAccount("0x..."), // first is leader for multi-sign transaction, must contain own address
    new ethers.Wallet("0x..."),
    { // can be a custom async wallet
        async signTypedData(params: {
            domain: {
                name: string;
                version: string;
                chainId: number;
                verifyingContract: Hex;
            };
            types: {
                [key: string]: {
                    name: string;
                    type: string;
                }[];
            };
            primaryType: string;
            message: Record<string, unknown>;
        }): Promise<Hex> {
            // Custom signer logic
            return "0x..."; // return hex signature
        },
    },
    "0x...", // private key directly
];

const transport = new hl.HttpTransport();
const multiSignClient = new hl.MultiSignClient({ transport, multiSignAddress, signers }); // extends `ExchangeClient`
```

### 3)使用客户端

最后,使用客户端方法与超液态API交互(详见: [API 参考](https://npmcn.com/package/%40deeeed/hyperliquid-node20/#readme-clients):

#### 使用 InfoClient 的实例

```ts
import * as hl from "@nktkas/hyperliquid";

const transport = new hl.HttpTransport();
const infoClient = new hl.InfoClient({ transport });

// L2 Book
const l2Book = await infoClient.l2Book({ coin: "BTC" });

// Account clearinghouse state
const clearinghouseState = await infoClient.clearinghouseState({ user: "0x..." });

// Open orders
const openOrders = await infoClient.openOrders({ user: "0x..." });
```

#### 使用交换对象的例子

```ts
import * as hl from "@nktkas/hyperliquid";

const privateKey = "0x..."; // or `viem`, `ethers`

const transport = new hl.HttpTransport();
const exchClient = new hl.ExchangeClient({ wallet: privateKey, transport });

// Place an orders
const result = await exchClient.order({
    orders: [{
        a: 0,
        b: true,
        p: "30000",
        s: "0.1",
        r: false,
        t: {
            limit: {
                tif: "Gtc",
            },
        },
    }],
    grouping: "na",
});

// Approve an agent
const result = await exchClient.approveAgent({
    agentAddress: "0x...",
    agentName: "agentName",
});

// Withdraw funds
const result = await exchClient.withdraw3({
    destination: account.address,
    amount: "100",
});
```

#### 使用订阅工具的示例

```ts
import * as hl from "@nktkas/hyperliquid";

const transport = new hl.WebSocketTransport();
const subsClient = new hl.SubscriptionClient({ transport });

// L2 Book updates
await subsClient.l2Book({ coin: "BTC" }, (data) => {
    console.log(data);
});

// User fills
await subsClient.userFills({ user: "0x..." }, (data) => {
    console.log(data);
});

// Candle updates
const sub = await subsClient.candle({ coin: "BTC", interval: "1h" }, (data) => {
    console.log(data);
});
```

#### 使用多符号的示例

```ts
import * as hl from "@nktkas/hyperliquid";

const multiSignAddress = "0x...";
const signers = [
    "0x...", // Private keys
] as const;

const transport = new hl.HttpTransport();
const multiSignClient = new hl.MultiSignClient({ transport, multiSignAddress, signers });

// Interaction is the same as with `ExchangeClient`

// Place an orders
const result = await multiSignClient.order({
    orders: [{
        a: 0,
        b: true,
        p: "30000",
        s: "0.1",
        r: false,
        t: {
            limit: {
                tif: "Gtc",
            },
        },
    }],
    grouping: "na",
});

// Approve an agent
const result = await multiSignClient.approveAgent({
    agentAddress: "0x...",
    agentName: "agentName",
});

// Withdraw funds
const result = await multiSignClient.withdraw3({
    destination: account.address,
    amount: "100",
});
```

## API 参考

### 客户

客户端是一个界面,您可以通过它与超液态API进行交互.

客户端负责格式化动作,正确创建签名,发送请求并验证一个 反应.

#### 信息客户端

```ts
class InfoClient {
    constructor(args: {
        transport: HttpTransport | WebSocketTransport;
    });

    // Market
    allMids(): Promise<AllMids>;
    candleSnapshot(args: CandleSnapshotParameters): Promise<Candle[]>;
    fundingHistory(args: FundingHistoryParameters): Promise<FundingHistory[]>;
    l2Book(args: L2BookParameters): Promise<Book>;
    liquidatable(): Promise<unknown[]>;
    marginTable(args: MarginTableParameters): Promise<MarginTable>;
    maxMarketOrderNtls(): Promise<[number, string][]>;
    meta(): Promise<PerpsMeta>;
    metaAndAssetCtxs(): Promise<PerpsMetaAndAssetCtxs>;
    perpDeployAuctionStatus(): Promise<DeployAuctionStatus>;
    perpDexs(): Promise<(PerpDex | null)[]>;
    perpsAtOpenInterestCap(): Promise<string[]>;
    predictedFundings(): Promise<PredictedFunding[]>;
    spotDeployState(args: SpotDeployStateParameters): Promise<SpotDeployState>;
    spotMeta(): Promise<SpotMeta>;
    spotMetaAndAssetCtxs(): Promise<SpotMetaAndAssetCtxs>;
    tokenDetails(args: TokenDetailsParameters): Promise<TokenDetails>;

    // Account
    clearinghouseState(args: ClearinghouseStateParameters): Promise<PerpsClearinghouseState>;
    extraAgents(args: ExtraAgentsParameters): Promise<ExtraAgent[]>;
    isVip(args: IsVipParameters): Promise<boolean>;
    legalCheck(args: LegalCheckParameters): Promise<LegalCheck>;
    maxBuilderFee(args: MaxBuilderFeeParameters): Promise<number>;
    portfolio(args: PortfolioParameters): Promise<PortfolioPeriods>;
    preTransferCheck(args: PreTransferCheckParameters): Promise<PreTransferCheck>;
    referral(args: ReferralParameters): Promise<Referral>;
    spotClearinghouseState(args: SpotClearinghouseStateParameters): Promise<SpotClearinghouseState>;
    subAccounts(args: SubAccountsParameters): Promise<SubAccount[] | null>;
    userFees(args: UserFeesParameters): Promise<UserFees>;
    userFunding(args: UserFundingParameters): Promise<UserFundingUpdate[]>;
    userNonFundingLedgerUpdates(args: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdate[]>;
    userRateLimit(args: UserRateLimitParameters): Promise<UserRateLimit>;
    userRole(args: UserRoleParameters): Promise<UserRole>;
    userToMultiSigSigners(args: UserToMultiSigSignersParameters): Promise<MultiSigSigners | null>;

    // Order
    frontendOpenOrders(args: FrontendOpenOrdersParameters): Promise<FrontendOrder[]>;
    historicalOrders(args: HistoricalOrdersParameters): Promise<OrderStatus<FrontendOrder>[]>;
    openOrders(args: OpenOrdersParameters): Promise<Order[]>;
    orderStatus(args: OrderStatusParameters): Promise<OrderLookup>;
    twapHistory(args: TwapHistoryParameters): Promise<TwapHistory[]>;
    userFills(args: UserFillsParameters): Promise<Fill[]>;
    userFillsByTime(args: UserFillsByTimeParameters): Promise<Fill[]>;
    userTwapSliceFills(args: UserTwapSliceFillsParameters): Promise<TwapSliceFill[]>;
    userTwapSliceFillsByTime(args: UserTwapSliceFillsByTimeParameters): Promise<TwapSliceFill[]>;

    // Validator
    delegations(args: DelegationsParameters): Promise<Delegation[]>;
    delegatorHistory(args: DelegatorHistoryParameters): Promise<DelegatorUpdate[]>;
    delegatorRewards(args: DelegatorRewardsParameters): Promise<DelegatorReward[]>;
    delegatorSummary(args: DelegatorSummaryParameters): Promise<DelegatorSummary>;
    validatorL1Votes(): Promise<unknown[]>;
    validatorSummaries(): Promise<ValidatorSummary[]>;

    // Vault
    leadingVaults(args: LeadingVaultsParameters): Promise<VaultLeading[]>;
    userVaultEquities(args: UserVaultEquitiesParameters): Promise<VaultEquity[]>;
    vaultDetails(args: VaultDetailsParameters): Promise<VaultDetails | null>;
    vaultSummaries(): Promise<VaultSummary[]>;

    // Server
    exchangeStatus(): Promise<ExchangeStatus>;

    // Explorer (RPC endpoint)
    blockDetails(args: BlockDetailsParameters): Promise<BlockDetails>;
    txDetails(args: TxDetailsParameters): Promise<TxDetails>;
    userDetails(args: UserDetailsParameters): Promise<TxDetails[]>;
}
```

#### 交换客户端

```ts
class ExchangeClient {
    constructor(args: {
        transport: HttpTransport | WebSocketTransport;
        wallet:
            | Hex // Private key directly
            | AbstractViemWalletClient // viem
            | AbstractEthersSigner // ethers
            | AbstractEthersV5Signer // ethers v5
            | AbstractWindowEthereum; // window.ethereum (EIP-1193)
        isTestnet?: boolean; // Whether to use testnet (default: false)
        defaultVaultAddress?: Hex; // Vault address used by default if not provided in method call
        signatureChainId?: Hex | (() => MaybePromise<Hex>); // Chain ID used for signing (default: trying to guess based on wallet and `isTestnet`)
        nonceManager?: () => MaybePromise<number>; // Function to get the next nonce (default: auto-incrementing `Date.now()`)
    });

    // Order
    batchModify(args: BatchModifyParameters): Promise<OrderResponseSuccess>;
    cancel(args: CancelParameters): Promise<CancelResponseSuccess>;
    cancelByCloid(args: CancelByCloidParameters): Promise<CancelResponseSuccess>;
    modify(args: ModifyParameters): Promise<SuccessResponse>;
    order(args: OrderParameters): Promise<OrderResponseSuccess>;
    scheduleCancel(args?: ScheduleCancelParameters): Promise<SuccessResponse>;
    twapCancel(args: TwapCancelParameters): Promise<TwapCancelResponseSuccess>;
    twapOrder(args: TwapOrderParameters): Promise<TwapOrderResponseSuccess>;
    updateIsolatedMargin(args: UpdateIsolatedMarginParameters): Promise<SuccessResponse>;
    updateLeverage(args: UpdateLeverageParameters): Promise<SuccessResponse>;

    // Account
    approveAgent(args: ApproveAgentParameters): Promise<SuccessResponse>;
    approveBuilderFee(args: ApproveBuilderFeeParameters): Promise<SuccessResponse>;
    claimRewards(): Promise<SuccessResponse>;
    createSubAccount(args: CreateSubAccountParameters): Promise<CreateSubAccountResponse>;
    evmUserModify(args: EvmUserModifyParameters): Promise<SuccessResponse>;
    registerReferrer(args: RegisterReferrerParameters): Promise<SuccessResponse>;
    reserveRequestWeight(args: ReserveRequestWeightParameters): Promise<SuccessResponse>;
    setDisplayName(args: SetDisplayNameParameters): Promise<SuccessResponse>;
    setReferrer(args: SetReferrerParameters): Promise<SuccessResponse>;
    subAccountModify(args: SubAccountModifyParameters): Promise<SuccessResponse>;
    spotUser(args: SpotUserParameters): Promise<SuccessResponse>;

    // Transfer
    perpDexClassTransfer(args: PerpDexClassTransferParameters): Promise<SuccessResponse>;
    perpDexTransfer(args: PerpDexTransferParameters): Promise<SuccessResponse>;
    spotSend(args: SpotSendParameters): Promise<SuccessResponse>;
    subAccountSpotTransfer(args: SubAccountSpotTransferParameters): Promise<SuccessResponse>;
    subAccountTransfer(args: SubAccountTransferParameters): Promise<SuccessResponse>;
    usdClassTransfer(args: UsdClassTransferParameters): Promise<SuccessResponse>;
    usdSend(args: UsdSendParameters): Promise<SuccessResponse>;
    withdraw3(args: Withdraw3Parameters): Promise<SuccessResponse>;

    // Staking
    cDeposit(args: CDepositParameters): Promise<SuccessResponse>;
    cWithdraw(args: CWithdrawParameters): Promise<SuccessResponse>;
    tokenDelegate(args: TokenDelegateParameters): Promise<SuccessResponse>;

    // Market
    perpDeploy(args: PerpDeployParameters): Promise<SuccessResponse>;
    spotDeploy(args: SpotDeployParameters): Promise<SuccessResponse>;

    // Vault
    createVault(args: CreateVaultParameters): Promise<CreateVaultResponse>;
    vaultDistribute(args: VaultDistributeParameters): Promise<SuccessResponse>;
    vaultModify(args: VaultModifyParameters): Promise<SuccessResponse>;
    vaultTransfer(args: VaultTransferParameters): Promise<SuccessResponse>;

    // Multi-Sign
    convertToMultiSigUser(args: ConvertToMultiSigUserParameters): Promise<SuccessResponse>;
    multiSig(args: MultiSigParameters): Promise<BaseExchangeResponse>;

    // Validator
    cSignerAction(args: CSignerActionParameters): Promise<SuccessResponse>;
    cValidatorAction(args: CValidatorActionParameters): Promise<SuccessResponse>;
}
```

#### 订阅客户端

```ts
class SubscriptionClient {
    constructor(args: {
        transport: WebSocketTransport;
    });

    // Market
    activeAssetCtx(args: EventActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
    activeAssetData(args: EventActiveAssetDataParameters, listener: (data: WsActiveAssetData) => void): Promise<Subscription>;
    allMids(listener: (data: WsAllMids) => void): Promise<Subscription>;
    bbo(args: EventBboParameters, listener: (data: WsBbo) => void): Promise<Subscription>;
    candle(args: EventCandleParameters, listener: (data: Candle) => void): Promise<Subscription>;
    l2Book(args: EventL2BookParameters, listener: (data: Book) => void): Promise<Subscription>;
    trades(args: EventTradesParameters, listener: (data: WsTrade[]) => void): Promise<Subscription>;

    // Account
    notification(args: EventNotificationParameters, listener: (data: WsNotification) => void): Promise<Subscription>;
    userEvents(args: EventUserEventsParameters, listener: (data: WsUserEvent) => void): Promise<Subscription>;
    userFundings(args: EventUserFundingsParameters, listener: (data: WsUserFundings) => void): Promise<Subscription>;
    userNonFundingLedgerUpdates(args: EventUserNonFundingLedgerUpdatesParameters, listener: (data: WsUserNonFundingLedgerUpdates) => void): Promise<Subscription>;
    webData2(args: EventWebData2Parameters, listener: (data: WsWebData2) => void): Promise<Subscription>;

    // Order
    orderUpdates(args: EventOrderUpdatesParameters, listener: (data: OrderStatus<Order>[]) => void): Promise<Subscription>;
    userFills(args: EventUserFillsParameters, listener: (data: WsUserFills) => void): Promise<Subscription>;
    userTwapHistory(args: EventUserTwapHistory, listener: (data: WsUserTwapHistory) => void): Promise<Subscription>;
    userTwapSliceFills(args: EventUserTwapSliceFills, listener: (data: WsUserTwapSliceFills) => void): Promise<Subscription>;

    // Explorer
    explorerBlock(listener: (data: WsBlockDetails[]) => void): Promise<Subscription>;
    explorerTxs(listener: (data: TxDetails[]) => void): Promise<Subscription>;
}
```

#### 多符号

```ts
class MultiSignClient extends ExchangeClient {
    constructor(
        args:
            & Omit<ExchangeClientParameters, "wallet"> // Instead of `wallet`, you should specify the following parameters:
            & {
                multiSignAddress: Hex; // Multi-signature address
                signers: [ // Array of signers
                    AbstractWalletWithAddress, // First signer is the leader of a multi-sign transaction
                    ...AbstractWallet[], // Any number of additional signers
                ];
            },
    );

    // Same methods as `ExchangeClient`
}
```

### 运输

运输在类请求和超液态服务器之间起到分层的作用.

#### HTTP 运输

HTTP运输适合一次性请求或无服务器环境.

```ts
class HttpTransport {
    constructor(options?: {
        isTestnet?: boolean; // Whether to use testnet url (default: false)
        timeout?: number; // Request timeout in ms (default: 10_000)
        server?: { // Custom server URLs
            mainnet?: { api?: string | URL; rpc?: string | URL };
            testnet?: { api?: string | URL; rpc?: string | URL };
        };
        fetchOptions?: RequestInit; // A custom fetch options
        onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>; // A callback before request is sent
        onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>; // A callback after response is received
    });
}
```

#### WebSocket 运输

WebSocket Transport比HTTP Transport更好的网络耐用.

```ts
class WebSocketTransport {
    constructor(options?: {
        url?: string | URL; // WebSocket URL (default: "wss://api.hyperliquid.xyz/ws")
        timeout?: number; // Request timeout in ms (default: 10_000)
        keepAlive?: {
            interval?: number; // Ping interval in ms (default: 30_000)
            timeout?: number; // Pong timeout in ms (default: same as `timeout` for requests)
        };
        reconnect?: {
            maxRetries?: number; // Maximum number of reconnection attempts (default: 3)
            connectionTimeout?: number; // Connection timeout in ms (default: 10_000)
            connectionDelay?: number | ((attempt: number) => number | Promise<number>); // Delay between reconnection (default: Exponential backoff (max 10s))
            shouldReconnect?: (event: CloseEvent) => boolean | Promise<boolean>; // Custom reconnection logic (default: Always reconnect)
            messageBuffer?: MessageBufferStrategy; // Message buffering strategy between reconnection (default: FIFO buffer)
        };
        autoResubscribe?: boolean; // Whether to automatically resubscribe to events after reconnection (default: true)
    });
    ready(signal?: AbortSignal): Promise<void>;
    close(signal?: AbortSignal): Promise<void>;
}
```

## 其他导入点

### `/types`

导入点允许访问所有与超液态相关的类型,包括类方法所依据的基准类型 基础.

### `/signing`

导入点可访问生成超流动交易签名的函数.

### 实例

#### 取消订购

```ts
import { actionSorter, signL1Action } from "@nktkas/hyperliquid/signing";

const privateKey = "0x..."; // or `viem`, `ethers`

const nonce = Date.now();
const action = {
    type: "cancel",
    cancels: [
        { a: 0, o: 12345 },
    ],
} as const;

const signature = await signL1Action({
    wallet: privateKey,
    action: actionSorter[action.type](action),
    nonce,
});

// Send the signed action to the Hyperliquid API
const response = await fetch("https://api.hyperliquid.xyz/exchange", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ action, signature, nonce }),
});
const body = await response.json();
```

#### 自己批准经纪人

```ts
import { signUserSignedAction, userSignedActionEip712Types } from "@nktkas/hyperliquid/signing";

const privateKey = "0x..."; // or `viem`, `ethers`

const action = {
    type: "approveAgent",
    signatureChainId: "0x66eee",
    hyperliquidChain: "Mainnet",
    agentAddress: "0x...",
    agentName: "Agent",
    nonce: Date.now(),
} as const;

const signature = await signUserSignedAction({
    wallet: privateKey,
    action,
    types: userSignedActionEip712Types[action.type],
});

// Send the signed action to the Hyperliquid API
const response = await fetch("https://api.hyperliquid.xyz/exchange", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ action, signature, nonce: action.nonce }),
});
const body = await response.json();
```

## 财务问题

### 如何通过外部钱包( 如 MetaMask) 执行 L1 动作 ?

超液态需要链 `1337` 用于 L1 动作(开放命令、改变杠杆等)。 有两种方法执行 L1 通过外部钱包的动作 :

-   (建议)创建 [代理钱包](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets#api-wallets) 并通过它执行所有 L1 动作
-   更改用户链为 `1337`但是,用户会签署无法读取的数据

### 如何创造出市场秩序?

超液态公司没有传统的市场订单,但通过设置限制订单可以实现类似市场的执行 与 `tif: "Ioc"` 保证立即执行的价格:

-   购买: 设定限价 QQ 当前最好查询
-   销售:定出限价 · 当前的最佳出价

### 如何使用 [代理钱包](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets#api-wallets) 编号 : [默认](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#subaccounts-and-vaults) 编号 : [分账户](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#subaccounts-and-vaults) 内 `ExchangeClient`? 吗?

**代理钱包**:在构造器中使用代理机的私人密钥,而不是主账户的私人密钥.

**破损和分账户**: 通过金库或子账户地址 `vaultAddress` 方法或设置的参数 `defaultVaultAddress` 在建筑师.

## 捐款

我们感谢你的帮助! 请阅读 [提供说明](https://npmcn.com/package/%40deeeed/hyperliquid-node20/CONTRIBUTING.md)。 。 。 .

## 常见问题

### @deeeed/hyperliquid-node20 是什么？

非官方的超液态API SDK用于所有主要JS运行时间,用TypeScript来写作\. 与节点\.js 20\.1\.8\.0\+相容性的分叉\.

### 如何安装 @deeeed/hyperliquid-node20？

在项目目录运行 npm install @deeeed/hyperliquid-node20，或使用 pnpm add / yarn add / bun add。

### @deeeed/hyperliquid-node20 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package\.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

### @deeeed/hyperliquid-node20 支持 ESM 还是 CommonJS？

同时提供 ES Module 与 CommonJS 入口，import 和 require\(\) 都可以使用，打包工具会自动选择合适的版本。

### @deeeed/hyperliquid-node20 需要什么版本的 Node\.js？

package\.json 的 engines 字段要求 Node\.js \>=20\.18\.0。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

### @deeeed/hyperliquid-node20 可以商用吗？

@deeeed/hyperliquid-node20 使用 MIT 许可。宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

### @deeeed/hyperliquid-node20 的下载量有多少？

根据 npm 官方下载统计，@deeeed/hyperliquid-node20 在 2026/10/12 – 2026/11/10 这 30 天内被下载 1,960 次，日均约 65 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### @deeeed/hyperliquid-node20 还在维护吗？

最新版本 0\.23\.1-node20\.1 发布于 2025/07/03（1\.4 年前）；至今共发布 1 个版本，其中过去 12 个月发布了 0 个；首次发布于 2025/07/03。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。

