@nktkas/hyperliquid 0.22.1 → 0.23.0

package/script/src/signing/mod.d.ts

@@ -0,0 +1,272 @@
+/**
+ * This module contains functions for generating Hyperliquid transaction signatures
+ * and interfaces to various wallet implementations.
+ *
+ * @example Signing an L1 action
+ * ```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,
+ * });
+ * ```
+ *
+ * @example Signing a user-signed action
+ * ```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],
+ * });
+ * ```
+ *
+ * @example Signing a multi-signature action
+ * ```ts
+ * import { actionSorter, signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
+ * import { privateKeyToAccount } from "viem/accounts";
+ *
+ * const wallet = privateKeyToAccount("0x..."); // or `ethers`, private key with address
+ * const multiSigUser = "0x...";
+ *
+ * const nonce = Date.now();
+ * const action = {
+ *     type: "scheduleCancel",
+ *     time: Date.now() + 10000,
+ * } as const;
+ *
+ * // First, create the required number of signatures
+ * const signature = await signL1Action({
+ *     wallet,
+ *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), actionSorter[action.type](action)],
+ *     nonce,
+ * });
+ *
+ * // Then use signatures in the multi-sig action
+ * const multiSigSignature = await signMultiSigAction({
+ *     wallet,
+ *     action: {
+ *         signatureChainId: "0x66eee",
+ *         signatures: [signature],
+ *         payload: {
+ *             multiSigUser,
+ *             outerSigner: wallet.address,
+ *             action,
+ *         },
+ *     },
+ *     nonce,
+ * });
+ * ```
+ *
+ * @module
+ */
+import type { Hex } from "../base.js";
+import { type AbstractEthersSigner, type AbstractEthersV5Signer, type AbstractViemWalletClient, type AbstractWallet, type AbstractWindowEthereum, isAbstractEthersSigner, isAbstractEthersV5Signer, isAbstractViemWalletClient, isAbstractWindowEthereum, isValidPrivateKey, type Signature } from "./_signTypedData/mod.js";
+export { type AbstractEthersSigner, type AbstractEthersV5Signer, type AbstractViemWalletClient, type AbstractWallet, type AbstractWindowEthereum, type Hex, isAbstractEthersSigner, isAbstractEthersV5Signer, isAbstractViemWalletClient, isAbstractWindowEthereum, isValidPrivateKey, type Signature, };
+export * from "./_sorter.js";
+/**
+ * Create a hash of the L1 action.
+ * @example
+ * ```ts
+ * import { actionSorter, createL1ActionHash } from "@nktkas/hyperliquid/signing";
+ *
+ * const action = {
+ *     type: "cancel",
+ *     cancels: [
+ *         { a: 0, o: 12345 },
+ *     ],
+ * } as const;
+ * const nonce = Date.now();
+ *
+ * const actionHash = createL1ActionHash({
+ *     action: actionSorter[action.type](action),
+ *     nonce,
+ *     vaultAddress: "0x...", // optional
+ *     expiresAfter: Date.now() + 10_000, // optional
+ * });
+ * ```
+ */
+export declare function createL1ActionHash(args: {
+    /** The action to be hashed (hash depends on key order). */
+    action: Record<string, unknown> | unknown[];
+    /** The current timestamp in ms. */
+    nonce: number;
+    /** Optional vault address used in the action. */
+    vaultAddress?: Hex;
+    /** Optional expiration time of the action in ms since the epoch. */
+    expiresAfter?: number;
+}): Hex;
+/**
+ * Sign an L1 action.
+ * @example
+ * ```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();
+ * ```
+ */
+export declare function signL1Action(args: {
+    /** Wallet to sign the action. */
+    wallet: AbstractWallet;
+    /** The action to be signed (hash depends on key order). */
+    action: Record<string, unknown> | unknown[];
+    /** The current timestamp in ms. */
+    nonce: number;
+    /** Indicates if the action is for the testnet. (default: false) */
+    isTestnet?: boolean;
+    /** Optional vault address used in the action. */
+    vaultAddress?: Hex;
+    /** Optional expiration time of the action in ms since the epoch. */
+    expiresAfter?: number;
+}): Promise<Signature>;
+/**
+ * Sign a user-signed action.
+ * @example
+ * ```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();
+ * ```
+ */
+export declare function signUserSignedAction(args: {
+    /** Wallet to sign the action. */
+    wallet: AbstractWallet;
+    /** The action to be signed. */
+    action: {
+        signatureChainId: Hex;
+        [key: string]: unknown;
+    };
+    /** The types of the action (hash depends on key order). */
+    types: {
+        [key: string]: {
+            name: string;
+            type: string;
+        }[];
+    };
+}): Promise<Signature>;
+/**
+ * Sign a multi-signature action.
+ * @example
+ * ```ts
+ * import { actionSorter, signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
+ * import { privateKeyToAccount } from "viem/accounts";
+ *
+ * const wallet = privateKeyToAccount("0x..."); // or `ethers`, private key with address
+ * const multiSigUser = "0x...";
+ *
+ * const nonce = Date.now();
+ * const action = {
+ *     type: "scheduleCancel",
+ *     time: Date.now() + 10000,
+ * } as const;
+ *
+ * // First, create the required number of signatures
+ * const signature = await signL1Action({
+ *     wallet,
+ *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), actionSorter[action.type](action)],
+ *     nonce,
+ * });
+ *
+ * // Then use signatures in the multi-sig action
+ * const multiSigSignature = await signMultiSigAction({
+ *     wallet,
+ *     action: {
+ *         signatureChainId: "0x66eee",
+ *         signatures: [signature],
+ *         payload: {
+ *             multiSigUser,
+ *             outerSigner: wallet.address,
+ *             action,
+ *         },
+ *     },
+ *     nonce,
+ * });
+ * ```
+ */
+export declare function signMultiSigAction(args: {
+    /** Wallet to sign the action. */
+    wallet: AbstractWallet;
+    /** The action to be signed (hash depends on key order). */
+    action: {
+        signatureChainId: Hex;
+        [key: string]: unknown;
+    };
+    /** The current timestamp in ms. */
+    nonce: number;
+    /** Indicates if the action is for the testnet. (default: false) */
+    isTestnet?: boolean;
+    /** Optional vault address used in the action. */
+    vaultAddress?: Hex;
+    /** Optional expiration time of the action in ms since the epoch. */
+    expiresAfter?: number;
+}): Promise<Signature>;
+//# sourceMappingURL=mod.d.ts.map

package/script/src/signing/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/src/signing/mod.ts"],"names":[],"mappings":"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"}

package/script/src/signing/mod.js

@@ -0,0 +1,331 @@
+"use strict";
+/**
+ * This module contains functions for generating Hyperliquid transaction signatures
+ * and interfaces to various wallet implementations.
+ *
+ * @example Signing an L1 action
+ * ```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,
+ * });
+ * ```
+ *
+ * @example Signing a user-signed action
+ * ```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],
+ * });
+ * ```
+ *
+ * @example Signing a multi-signature action
+ * ```ts
+ * import { actionSorter, signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
+ * import { privateKeyToAccount } from "viem/accounts";
+ *
+ * const wallet = privateKeyToAccount("0x..."); // or `ethers`, private key with address
+ * const multiSigUser = "0x...";
+ *
+ * const nonce = Date.now();
+ * const action = {
+ *     type: "scheduleCancel",
+ *     time: Date.now() + 10000,
+ * } as const;
+ *
+ * // First, create the required number of signatures
+ * const signature = await signL1Action({
+ *     wallet,
+ *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), actionSorter[action.type](action)],
+ *     nonce,
+ * });
+ *
+ * // Then use signatures in the multi-sig action
+ * const multiSigSignature = await signMultiSigAction({
+ *     wallet,
+ *     action: {
+ *         signatureChainId: "0x66eee",
+ *         signatures: [signature],
+ *         payload: {
+ *             multiSigUser,
+ *             outerSigner: wallet.address,
+ *             action,
+ *         },
+ *     },
+ *     nonce,
+ * });
+ * ```
+ *
+ * @module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPrivateKey = exports.isAbstractWindowEthereum = exports.isAbstractViemWalletClient = exports.isAbstractEthersV5Signer = exports.isAbstractEthersSigner = void 0;
+exports.createL1ActionHash = createL1ActionHash;
+exports.signL1Action = signL1Action;
+exports.signUserSignedAction = signUserSignedAction;
+exports.signMultiSigAction = signMultiSigAction;
+const sha3_1 = require("@noble/hashes/sha3");
+const secp256k1_1 = require("@noble/secp256k1");
+const msgpack_1 = require("@msgpack/msgpack");
+const mod_js_1 = require("./_signTypedData/mod.js");
+Object.defineProperty(exports, "isAbstractEthersSigner", { enumerable: true, get: function () { return mod_js_1.isAbstractEthersSigner; } });
+Object.defineProperty(exports, "isAbstractEthersV5Signer", { enumerable: true, get: function () { return mod_js_1.isAbstractEthersV5Signer; } });
+Object.defineProperty(exports, "isAbstractViemWalletClient", { enumerable: true, get: function () { return mod_js_1.isAbstractViemWalletClient; } });
+Object.defineProperty(exports, "isAbstractWindowEthereum", { enumerable: true, get: function () { return mod_js_1.isAbstractWindowEthereum; } });
+Object.defineProperty(exports, "isValidPrivateKey", { enumerable: true, get: function () { return mod_js_1.isValidPrivateKey; } });
+__exportStar(require("./_sorter.js"), exports);
+/**
+ * Create a hash of the L1 action.
+ * @example
+ * ```ts
+ * import { actionSorter, createL1ActionHash } from "@nktkas/hyperliquid/signing";
+ *
+ * const action = {
+ *     type: "cancel",
+ *     cancels: [
+ *         { a: 0, o: 12345 },
+ *     ],
+ * } as const;
+ * const nonce = Date.now();
+ *
+ * const actionHash = createL1ActionHash({
+ *     action: actionSorter[action.type](action),
+ *     nonce,
+ *     vaultAddress: "0x...", // optional
+ *     expiresAfter: Date.now() + 10_000, // optional
+ * });
+ * ```
+ */
+function createL1ActionHash(args) {
+    const { action, nonce, vaultAddress, expiresAfter } = args;
+    // 1. Action
+    const actionBytes = (0, msgpack_1.encode)(action);
+    // 2. Nonce
+    const nonceBytes = toUint64Bytes(nonce);
+    // 3. Vault address
+    const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
+    const vaultBytes = vaultAddress ? secp256k1_1.etc.hexToBytes(vaultAddress.slice(2)) : new Uint8Array();
+    // 4. Expires after
+    const expiresMarker = expiresAfter !== undefined ? new Uint8Array([0]) : new Uint8Array();
+    const expiresBytes = expiresAfter !== undefined ? toUint64Bytes(expiresAfter) : new Uint8Array();
+    // Create a hash
+    const bytes = secp256k1_1.etc.concatBytes(actionBytes, nonceBytes, vaultMarker, vaultBytes, expiresMarker, expiresBytes);
+    const hash = (0, sha3_1.keccak_256)(bytes);
+    return `0x${secp256k1_1.etc.bytesToHex(hash)}`;
+}
+function toUint64Bytes(n) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, BigInt(n));
+    return bytes;
+}
+/**
+ * Sign an L1 action.
+ * @example
+ * ```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();
+ * ```
+ */
+async function signL1Action(args) {
+    const { wallet, action, nonce, isTestnet = false, vaultAddress, expiresAfter, } = args;
+    const actionHash = createL1ActionHash({ action, nonce, vaultAddress, expiresAfter });
+    const message = {
+        source: isTestnet ? "b" : "a",
+        connectionId: actionHash,
+    };
+    return await (0, mod_js_1.signTypedData)({
+        wallet,
+        domain: {
+            name: "Exchange",
+            version: "1",
+            chainId: 1337, // hyperliquid requires chainId to be 1337
+            verifyingContract: "0x0000000000000000000000000000000000000000",
+        },
+        types: {
+            Agent: [
+                { name: "source", type: "string" },
+                { name: "connectionId", type: "bytes32" },
+            ],
+        },
+        primaryType: "Agent",
+        message,
+    });
+}
+/**
+ * Sign a user-signed action.
+ * @example
+ * ```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();
+ * ```
+ */
+async function signUserSignedAction(args) {
+    const { wallet, action, types } = args;
+    return await (0, mod_js_1.signTypedData)({
+        wallet,
+        domain: {
+            name: "HyperliquidSignTransaction",
+            version: "1",
+            chainId: parseInt(action.signatureChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000",
+        },
+        types,
+        primaryType: Object.keys(types)[0],
+        message: action,
+    });
+}
+/**
+ * Sign a multi-signature action.
+ * @example
+ * ```ts
+ * import { actionSorter, signL1Action, signMultiSigAction } from "@nktkas/hyperliquid/signing";
+ * import { privateKeyToAccount } from "viem/accounts";
+ *
+ * const wallet = privateKeyToAccount("0x..."); // or `ethers`, private key with address
+ * const multiSigUser = "0x...";
+ *
+ * const nonce = Date.now();
+ * const action = {
+ *     type: "scheduleCancel",
+ *     time: Date.now() + 10000,
+ * } as const;
+ *
+ * // First, create the required number of signatures
+ * const signature = await signL1Action({
+ *     wallet,
+ *     action: [multiSigUser.toLowerCase(), wallet.address.toLowerCase(), actionSorter[action.type](action)],
+ *     nonce,
+ * });
+ *
+ * // Then use signatures in the multi-sig action
+ * const multiSigSignature = await signMultiSigAction({
+ *     wallet,
+ *     action: {
+ *         signatureChainId: "0x66eee",
+ *         signatures: [signature],
+ *         payload: {
+ *             multiSigUser,
+ *             outerSigner: wallet.address,
+ *             action,
+ *         },
+ *     },
+ *     nonce,
+ * });
+ * ```
+ */
+async function signMultiSigAction(args) {
+    const { wallet, action, nonce, isTestnet = false, vaultAddress, expiresAfter, } = args;
+    const multiSigActionHash = createL1ActionHash({ action, nonce, vaultAddress, expiresAfter });
+    const message = {
+        signatureChainId: action.signatureChainId,
+        hyperliquidChain: isTestnet ? "Testnet" : "Mainnet",
+        multiSigActionHash,
+        nonce,
+    };
+    return await (0, mod_js_1.signTypedData)({
+        wallet,
+        domain: {
+            name: "HyperliquidSignTransaction",
+            version: "1",
+            chainId: parseInt(message.signatureChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000",
+        },
+        types: {
+            "HyperliquidTransaction:SendMultiSig": [
+                { name: "hyperliquidChain", type: "string" },
+                { name: "multiSigActionHash", type: "bytes32" },
+                { name: "nonce", type: "uint64" },
+            ],
+        },
+        primaryType: "HyperliquidTransaction:SendMultiSig",
+        message,
+    });
+}

package/script/src/transports/base.d.ts

@@ -42,6 +42,6 @@ export interface Subscription {
 }
 /** Base class for all transport-related errors. */
 export declare class TransportError extends HyperliquidError {
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 //# sourceMappingURL=base.d.ts.map

package/script/src/transports/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/src/transports/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,eAAe,CAAC;IAC/D;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9G;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,OAAO,CAAC,eAAe,CAAC;IACpE;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACpH;AAED,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IACzB,kFAAkF;IAClF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,wEAAwE;IACxE,iBAAiB,CAAC,EAAE,WAAW,CAAC;CACnC;AAED,mDAAmD;AACnD,qBAAa,cAAe,SAAQ,gBAAgB;gBACpC,OAAO,CAAC,EAAE,MAAM;CAI/B"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/src/transports/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAAC,eAAe,CAAC;IAC/D;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9G;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,OAAO,CAAC,eAAe,CAAC;IACpE;;;;;;OAMG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACpH;AAED,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IACzB,kFAAkF;IAClF,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,wEAAwE;IACxE,iBAAiB,CAAC,EAAE,WAAW,CAAC;CACnC;AAED,mDAAmD;AACnD,qBAAa,cAAe,SAAQ,gBAAgB;gBACpC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIvD"}

package/script/src/transports/base.js

@@ -1,22 +1,12 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportError = void 0;
+const base_js_1 = require("../base.js");
+/** Base class for all transport-related errors. */
+class TransportError extends base_js_1.HyperliquidError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "TransportError";
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../base.js"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.TransportError = void 0;
-    const base_js_1 = require("../base.js");
-    /** Base class for all transport-related errors. */
-    class TransportError extends base_js_1.HyperliquidError {
-        constructor(message) {
-            super(message);
-            this.name = "TransportError";
-        }
-    }
-    exports.TransportError = TransportError;
-});
+}
+exports.TransportError = TransportError;