@rabby-wallet/hyperliquid-sdk 1.0.0-beta.1

package/dist/client/exchange-client.js

@@ -0,0 +1,521 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangeClient = void 0;
+const ethUtil = __importStar(require("@ethereumjs/util"));
+const http_client_1 = require("./http-client");
+const constants_1 = require("../types/constants");
+const signer_1 = require("../utils/signer");
+/**
+ * Client for executing trades on Hyperliquid (perpetuals only)
+ * Only includes essential trading APIs as specified
+ */
+class ExchangeClient {
+    constructor(config) {
+        this.masterAddress = config.masterAddress;
+        this.httpClient = new http_client_1.HttpClient({
+            isTestnet: config.isTestnet,
+            timeout: config.timeout,
+        });
+        this.agentPrivateKey = config.agentPrivateKey.startsWith('0x') ? config.agentPrivateKey : ethUtil.addHexPrefix(config.agentPrivateKey);
+        this.agentPublicKey = config.agentPublicKey.startsWith('0x') ? config.agentPublicKey : ethUtil.addHexPrefix(config.agentPublicKey);
+        this.agentName = config.agentName || 'Rabby';
+        this.isTestnet = config.isTestnet || false;
+        this.symbolConversion = config.symbolConversion;
+    }
+    /**
+     * Get the wallet address
+     */
+    get address() {
+        return this.masterAddress;
+    }
+    // 50 = '0.05%'
+    updateBuilder(address, fee) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (fee < 0 || fee > 100) {
+                throw new Error('Fee must be between 0 and 100');
+            }
+            this.builder = {
+                address: address.toLowerCase(),
+                fee,
+            };
+        });
+    }
+    updateLeverage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const action = {
+                type: constants_1.ExchangeType.UPDATE_LEVERAGE,
+                asset: yield this.symbolConversion.getAssetIndex(params.coin),
+                isCross: params.isCross || false,
+                leverage: params.leverage,
+            };
+            const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
+    /**
+     * Place a single order
+     */
+    placeOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const orderWire = {
+                a: yield this.symbolConversion.getAssetIndex(params.coin),
+                b: params.isBuy,
+                p: params.limitPx,
+                s: params.sz,
+                r: params.reduceOnly || false,
+                t: params.orderType || { limit: { tif: 'Gtc' } },
+            };
+            const action = {
+                type: constants_1.ExchangeType.ORDER,
+                orders: [orderWire],
+                grouping: 'na',
+            };
+            if (this.builder) {
+                action.builder = {
+                    b: this.builder.address,
+                    f: this.builder.fee,
+                };
+            }
+            const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
+    getSlippagePx(midPx, slippage, isBuy) {
+        var _a;
+        const decimals = ((_a = midPx.toString().split('.')[1]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        const prepDecimals = Math.max(0, decimals - 1);
+        const px = isBuy ? (Number(midPx) * (1 + slippage)).toFixed(prepDecimals) : (Number(midPx) * (1 - slippage)).toFixed(prepDecimals);
+        return px;
+    }
+    /**
+     * Place a market order
+     * default slippage is 0.08
+     * need to update leverage before place order
+     */
+    marketOrderOpen(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const slippage = params.slippage || constants_1.SLIPPAGE;
+                const px = this.getSlippagePx(params.midPx, slippage, params.isBuy);
+                const orders = [{
+                        coin: params.coin,
+                        isBuy: params.isBuy,
+                        sz: params.size,
+                        limitPx: px,
+                        reduceOnly: false,
+                        orderType: { limit: { tif: 'Ioc' } },
+                    }];
+                if (params.tpTriggerPx) {
+                    const tpOrder = {
+                        coin: params.coin,
+                        isBuy: !params.isBuy,
+                        sz: params.size,
+                        limitPx: params.tpTriggerPx,
+                        reduceOnly: true,
+                        orderType: {
+                            trigger: {
+                                isMarket: true,
+                                triggerPx: params.tpTriggerPx,
+                                tpsl: 'tp',
+                            }
+                        }
+                    };
+                    orders.push(tpOrder);
+                }
+                if (params.slTriggerPx) {
+                    const slOrder = {
+                        coin: params.coin,
+                        isBuy: !params.isBuy,
+                        sz: params.size,
+                        limitPx: params.slTriggerPx,
+                        reduceOnly: true,
+                        orderType: {
+                            trigger: {
+                                isMarket: true,
+                                triggerPx: params.slTriggerPx,
+                                tpsl: 'sl',
+                            }
+                        }
+                    };
+                    orders.push(slOrder);
+                }
+                const res = yield this.multiOrder({
+                    orders,
+                });
+                return res;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    marketOrderClose(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const slippage = params.slippage || constants_1.SLIPPAGE;
+                const px = this.getSlippagePx(params.midPx, slippage, params.isBuy);
+                const orders = [{
+                        coin: params.coin,
+                        isBuy: params.isBuy,
+                        sz: params.size,
+                        limitPx: px,
+                        reduceOnly: true,
+                        orderType: { limit: { tif: 'Ioc' } },
+                    }];
+                const res = yield this.multiOrder({
+                    orders,
+                });
+                return res;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Place multiple orders at once
+     */
+    multiOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const assetIndexCache = new Map();
+            const orderWires = yield Promise.all(params.orders.map((order) => __awaiter(this, void 0, void 0, function* () {
+                let assetIndex = assetIndexCache.get(order.coin);
+                if (assetIndex === undefined) {
+                    assetIndex = yield this.symbolConversion.getAssetIndex(order.coin);
+                    assetIndexCache.set(order.coin, assetIndex);
+                }
+                return {
+                    a: assetIndex,
+                    b: order.isBuy,
+                    p: order.limitPx,
+                    s: order.sz,
+                    r: order.reduceOnly || false,
+                    t: order.orderType || { limit: { tif: 'Gtc' } },
+                };
+            })));
+            const action = {
+                type: constants_1.ExchangeType.ORDER,
+                orders: orderWires,
+                grouping: params.grouping || 'na',
+            };
+            if (this.builder) {
+                action.builder = {
+                    b: this.builder.address,
+                    f: this.builder.fee,
+                };
+            }
+            const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
+    bindTpslByOrderId(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let orders = [];
+            if (params.tpTriggerPx) {
+                orders.push({
+                    coin: params.coin,
+                    isBuy: !params.isBuy,
+                    sz: '0',
+                    limitPx: this.getSlippagePx(params.tpTriggerPx, constants_1.SLIPPAGE, !params.isBuy),
+                    reduceOnly: true,
+                    orderType: {
+                        trigger: {
+                            isMarket: true,
+                            triggerPx: params.tpTriggerPx,
+                            tpsl: 'tp',
+                        }
+                    }
+                });
+            }
+            if (params.slTriggerPx) {
+                orders.push({
+                    coin: params.coin,
+                    isBuy: !params.isBuy,
+                    sz: '0',
+                    limitPx: this.getSlippagePx(params.slTriggerPx, constants_1.SLIPPAGE, !params.isBuy),
+                    reduceOnly: true,
+                    orderType: {
+                        trigger: {
+                            isMarket: true,
+                            triggerPx: params.slTriggerPx,
+                            tpsl: 'sl',
+                        }
+                    }
+                });
+            }
+            if (orders.length === 0) {
+                throw new Error('Must have at least one tp or sl');
+            }
+            return this.multiOrder({
+                orders,
+                grouping: 'positionTpsl'
+            });
+        });
+    }
+    /**
+     * Cancel order(s)
+     */
+    cancelOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const cancels = yield Promise.all(params.map((param) => __awaiter(this, void 0, void 0, function* () {
+                const assetIndex = yield this.symbolConversion.getAssetIndex(param.coin);
+                return {
+                    a: assetIndex,
+                    o: param.oid,
+                };
+            })));
+            const action = {
+                type: constants_1.ExchangeType.CANCEL,
+                cancels: cancels,
+            };
+            const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
+    /**
+     * Modify an existing order
+     */
+    modifyOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            const modify = {
+                oid: params.oid,
+                order: {
+                    a: yield this.symbolConversion.getAssetIndex(params.coin),
+                    b: params.isBuy,
+                    p: params.limitPx,
+                    s: params.sz,
+                    r: params.reduceOnly || false,
+                    t: params.orderType || { limit: { tif: 'Gtc' } },
+                },
+            };
+            const action = {
+                type: constants_1.ExchangeType.MODIFY,
+                modifies: [modify],
+            };
+            const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+            return this.httpClient.exchange({
+                action,
+                nonce,
+                signature,
+            });
+        });
+    }
+    /**
+     * Set referrer for 10% fee
+     */
+    setReferrer(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = Date.now();
+            try {
+                const action = {
+                    type: constants_1.ExchangeType.SET_REFERRER,
+                    code,
+                };
+                const signature = (0, signer_1.signL1AgentAction)(this.agentPrivateKey, action, this.isTestnet, nonce);
+                return this.httpClient.exchange({
+                    action,
+                    nonce,
+                    signature,
+                });
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Prepare approve agent data for main wallet signing
+     * Returns typed data that needs to be signed by the main wallet
+     */
+    prepareApproveAgent() {
+        const nonce = Date.now();
+        const action = {
+            type: constants_1.ExchangeType.APPROVE_AGENT,
+            hyperliquidChain: this.isTestnet ? 'Testnet' : 'Mainnet',
+            signatureChainId: this.isTestnet ? '0x66eee' : '0xa4b1',
+            agentAddress: this.agentPublicKey,
+            agentName: this.agentName, // no name is temp, and has name is persist in backend
+            nonce,
+        };
+        const { domain, types, primaryType, message } = (0, signer_1.prepareMasterSignData)({
+            action,
+            payloadTypes: [
+                { name: 'hyperliquidChain', type: 'string' },
+                { name: 'agentAddress', type: 'address' },
+                { name: 'agentName', type: 'string' },
+                { name: 'nonce', type: 'uint64' },
+            ],
+            primaryType: 'HyperliquidTransaction:ApproveAgent',
+            isMainnet: !this.isTestnet,
+        });
+        return {
+            domain,
+            types,
+            primaryType,
+            message,
+            nonce,
+        };
+    }
+    /**
+     * Send approve agent request with main wallet signature
+     * nonce must be the same as the nonce in the prepareApproveAgent
+     */
+    sendApproveAgent(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const splitSignature = (0, signer_1.splitSig)(params.signature);
+            return this.httpClient.exchange({
+                action: params.action,
+                nonce: params.nonce,
+                signature: splitSignature,
+            });
+        });
+    }
+    /**
+     * Prepare approve builder fee data for main wallet signing
+     * Returns typed data that needs to be signed by the main wallet
+     * maxFee :  max fee rate = '0.1%'
+     */
+    prepareApproveBuilderFee(params) {
+        const nonce = Date.now();
+        const action = {
+            type: constants_1.ExchangeType.APPROVE_BUILDER_FEE,
+            hyperliquidChain: this.isTestnet ? 'Testnet' : 'Mainnet',
+            signatureChainId: this.isTestnet ? '0x66eee' : '0x42161',
+            builder: params.builder.toLowerCase(),
+            maxFee: params.maxFee || '0.1%',
+            nonce,
+        };
+        const { domain, types, primaryType, message } = (0, signer_1.prepareMasterSignData)({
+            action,
+            payloadTypes: [
+                { name: 'type', type: 'string' },
+                { name: 'hyperliquidChain', type: 'string' },
+                { name: 'signatureChainId', type: 'string' },
+                { name: 'builder', type: 'string' },
+                { name: 'maxFee', type: 'string' },
+                { name: 'nonce', type: 'uint64' },
+            ],
+            primaryType: 'HyperliquidTransaction:ApproveBuilderFee',
+            isMainnet: !this.isTestnet,
+        });
+        return {
+            domain,
+            types,
+            primaryType,
+            message,
+            nonce,
+        };
+    }
+    /**
+     * Send approve builder fee request with main wallet signature
+     * nonce must be the same as the nonce in the prepareApproveBuilderFee
+     * signature is the signature of the main wallet by the prepareApproveBuilderFee action
+     */
+    sendApproveBuilderFee(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.httpClient.exchange({
+                action: params.action,
+                nonce: params.nonce,
+                signature: params.signature,
+            });
+        });
+    }
+    /**
+     * Withdraw funds to L1 need use master wallet
+     */
+    prepareWithdraw(params) {
+        const nonce = Date.now();
+        const action = {
+            type: constants_1.ExchangeType.WITHDRAW,
+            hyperliquidChain: this.isTestnet ? 'Testnet' : 'Mainnet',
+            signatureChainId: this.isTestnet ? '0x66eee' : '0x42161',
+            destination: params.destination,
+            amount: params.amount,
+            time: Date.now(),
+        };
+        const { domain, types, primaryType, message } = (0, signer_1.prepareMasterSignData)({
+            action,
+            payloadTypes: [
+                { name: 'type', type: 'string' },
+                { name: 'hyperliquidChain', type: 'string' },
+                { name: 'signatureChainId', type: 'string' },
+                { name: 'destination', type: 'string' },
+                { name: 'amount', type: 'string' },
+                { name: 'time', type: 'uint64' },
+            ],
+            primaryType: 'HyperliquidTransaction:Withdraw',
+            isMainnet: !this.isTestnet,
+        });
+        return {
+            domain,
+            types,
+            primaryType,
+            message,
+            nonce,
+        };
+    }
+}
+exports.ExchangeClient = ExchangeClient;

package/dist/client/http-client.d.ts

@@ -0,0 +1,26 @@
+export interface HttpClientConfig {
+    baseURL?: string;
+    timeout?: number;
+    isTestnet?: boolean;
+}
+/**
+ * Simple HTTP client for Hyperliquid API requests
+ * No rate limiting - designed for frontend usage
+ */
+export declare class HttpClient {
+    private readonly baseURL;
+    private readonly timeout;
+    constructor(config?: HttpClientConfig);
+    /**
+     * Make a POST request using fetch
+     */
+    private request;
+    /**
+     * Make a request to the info endpoint
+     */
+    info<T = any>(data: any): Promise<T>;
+    /**
+     * Make a request to the exchange endpoint
+     */
+    exchange<T = any>(data: any): Promise<T>;
+}

package/dist/client/http-client.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const constants_1 = require("../types/constants");
+/**
+ * Simple HTTP client for Hyperliquid API requests
+ * No rate limiting - designed for frontend usage
+ */
+class HttpClient {
+    constructor(config = {}) {
+        this.baseURL = config.baseURL || (config.isTestnet ? constants_1.BASE_URLS.TESTNET : constants_1.BASE_URLS.PRODUCTION);
+        this.timeout = config.timeout || 10000;
+    }
+    /**
+     * Make a POST request using fetch
+     */
+    request(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            try {
+                const response = yield fetch(`${this.baseURL}${endpoint}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(data),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const result = yield response.json();
+                return result;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof Error) {
+                    if (error.name === 'AbortError') {
+                        throw new Error('Request timeout');
+                    }
+                    throw new Error(`API Error: ${error.message}`);
+                }
+                throw new Error('Unknown API error');
+            }
+        });
+    }
+    /**
+     * Make a request to the info endpoint
+     */
+    info(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(constants_1.ENDPOINTS.INFO, data);
+        });
+    }
+    /**
+     * Make a request to the exchange endpoint
+     */
+    exchange(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(constants_1.ENDPOINTS.EXCHANGE, data);
+        });
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/client/info-client.d.ts

@@ -0,0 +1,49 @@
+import type { Meta, AssetCtx, ClearinghouseState, UserFills, CandleSnapshot, AllMids, ExtraAgent, OpenOrder, FeeResponse } from '../types';
+import { SymbolConversion } from './symbolConversion';
+export interface InfoClientConfig {
+    isTestnet?: boolean;
+    timeout?: number;
+    masterAddress: string;
+    symbolConversion: SymbolConversion;
+}
+/**
+ * Client for querying Hyperliquid info endpoints (perpetuals only)
+ * Only includes essential APIs as specified
+ */
+export declare class InfoClient {
+    private readonly httpClient;
+    private readonly masterAddress;
+    private readonly symbolConversion;
+    constructor(config: InfoClientConfig);
+    /**
+     * Get all mid prices for all assets
+     */
+    getAllMids(): Promise<AllMids>;
+    /**
+     * Get metadata and asset contexts
+     */
+    metaAndAssetCtxs(): Promise<[Meta, AssetCtx[]]>;
+    getClearingHouseState(): Promise<ClearinghouseState>;
+    getFrontendOpenOrders(): Promise<OpenOrder[]>;
+    /**
+     * Get user's fill history
+     */
+    getUserFills(): Promise<UserFills>;
+    /**
+     * Get candlestick data snapshot
+     * Supported intervals: "1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "8h", "12h", "1d", "3d", "1w", "1M"
+     */
+    candleSnapshot(coin: string, interval: string, startTime?: number, endTime?: number): Promise<CandleSnapshot>;
+    /**
+     * Check builder fee approval status
+     */
+    checkBuilderFeeApproval(builder: string): Promise<any>;
+    /**
+     * Get user fees information
+     */
+    getUsersFees(): Promise<FeeResponse>;
+    /**
+     * Get user's approved persistent agents
+     */
+    extraAgents(): Promise<ExtraAgent[]>;
+}