Class: Hyperliquid::Info

Inherits:
Object
  • Object
show all
Defined in:
lib/hyperliquid/info.rb

Overview

Client for read-only Info API endpoints

Instance Method Summary collapse

Constructor Details

#initialize(client) ⇒ Info

Returns a new instance of Info.



6
7
8
 
# File 'lib/hyperliquid/info.rb', line 6

def initialize(client)
  @client = client
end

Instance Method Details

#active_asset_data(user, coin) ⇒ Hash

Retrieve User’s Active Asset Data

Parameters:

  • user (String)
  • coin (String)

Returns:

  • (Hash) 


464
465
466
 
# File 'lib/hyperliquid/info.rb', line 464

def active_asset_data(user, coin)
  @client.post(Constants::INFO_ENDPOINT, { type: 'activeAssetData', user: user, coin: coin })
end

#aligned_quote_token_info(token) ⇒ Hash

Get supply, rate, and pending payment information for an aligned quote token

Parameters:

  • token (Integer) —

    Token index

Returns:

  • (Hash) —

    Hash with isAligned, firstAlignedTime, evmMintedSupply, dailyAmountOwed (array of [date, amount] tuples), predictedRate



591
592
593
 
# File 'lib/hyperliquid/info.rb', line 591

def aligned_quote_token_info(token)
  @client.post(Constants::INFO_ENDPOINT, { type: 'alignedQuoteTokenInfo', token: token })
end

#all_borrow_lend_reserve_states ⇒ Array<Array>

Retrieve borrow/lend reserve states for all tokens

Returns:

  • (Array<Array>) —

    Array of [reserveId (Integer), state (Hash)] tuples; each state has borrowYearlyRate, supplyYearlyRate, balance, utilization, oraclePx, ltv, totalSupplied, totalBorrowed



619
620
621
 
# File 'lib/hyperliquid/info.rb', line 619

def all_borrow_lend_reserve_states
  @client.post(Constants::INFO_ENDPOINT, { type: 'allBorrowLendReserveStates' })
end

#all_mids(dex: nil) ⇒ Hash

Get all market mid prices

Parameters:

  • dex (String, nil) (defaults to: nil) —

    Optional perp dex name (defaults to first perp dex; spot mids only included with first perp dex)

Returns:

  • (Hash) —

    Hash containing mid prices for all markets



18
19
20
21
22
 
# File 'lib/hyperliquid/info.rb', line 18

def all_mids(dex: nil)
  body = { type: 'allMids' }
  body[:dex] = dex if dex
  @client.post(Constants::INFO_ENDPOINT, body)
end

#all_perp_metas ⇒ Array<Hash>

Get trading metadata for all perpetual dexs

Returns:

  • (Array<Hash>) —

    Array of meta payloads (one per dex), each with universe and other fields



428
429
430
 
# File 'lib/hyperliquid/info.rb', line 428

def all_perp_metas
  @client.post(Constants::INFO_ENDPOINT, { type: 'allPerpMetas' })
end

#approved_builders(user) ⇒ Array<String>

Query approved builders for a user

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array<String>) —

    Array of approved builder addresses



140
141
142
 
# File 'lib/hyperliquid/info.rb', line 140

def approved_builders(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'approvedBuilders', user: user })
end

#block_details(height) ⇒ Hash

Get block details by block height

Parameters:

  • height (Integer) —

    Block height

Returns:

  • (Hash) —

    Block details including blockTime, hash, height, numTxs, proposer, txs



107
108
109
 
# File 'lib/hyperliquid/info.rb', line 107

def block_details(height)
  @client.post(Constants::INFO_ENDPOINT, { type: 'blockDetails', height: height })
end

#borrow_lend_reserve_state(token) ⇒ Hash

Retrieve borrow/lend reserve state for a single token

Parameters:

  • token (Integer) —

    Token index

Returns:

  • (Hash) —

    Hash with borrowYearlyRate, supplyYearlyRate, balance, utilization, oraclePx, ltv, totalSupplied, totalBorrowed



611
612
613
 
# File 'lib/hyperliquid/info.rb', line 611

def borrow_lend_reserve_state(token)
  @client.post(Constants::INFO_ENDPOINT, { type: 'borrowLendReserveState', token: token })
end

#borrow_lend_user_state(user) ⇒ Hash

Retrieve a user’s borrow/lend state across tokens

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Hash with tokenToState (array of [tokenId, state] tuples; state has borrow value and supply value), health, healthFactor



603
604
605
 
# File 'lib/hyperliquid/info.rb', line 603

def borrow_lend_user_state(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'borrowLendUserState', user: user })
end

#candles_snapshot(coin, interval, start_time, end_time) ⇒ Array

Get candlestick data

Parameters:

  • coin (String) —

    Coin symbol

  • interval (String) —

    Time interval (e.g., “1m”, “1h”, “1d”)

  • start_time (Integer) —

    Start timestamp in milliseconds

  • end_time (Integer) —

    End timestamp in milliseconds

Returns:

  • (Array) —

    Array of candlestick data



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/hyperliquid/info.rb', line 117

def candles_snapshot(coin, interval, start_time, end_time)
  @client.post(Constants::INFO_ENDPOINT, {
                 type: 'candleSnapshot',
                 req: {
                   coin: coin,
                   interval: interval,
                   startTime: start_time,
                   endTime: end_time
                 }
               })
end

#delegations(user) ⇒ Array

Query a user’s staking delegations

Parameters:

  • user (String)

Returns:

  • (Array) 


253
254
255
 
# File 'lib/hyperliquid/info.rb', line 253

def delegations(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'delegations', user: user })
end

#delegator_history(user) ⇒ Array

Query a user’s staking history

Parameters:

  • user (String)

Returns:

  • (Array) 


267
268
269
 
# File 'lib/hyperliquid/info.rb', line 267

def delegator_history(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'delegatorHistory', user: user })
end

#delegator_rewards(user) ⇒ Array

Query a user’s staking rewards

Parameters:

  • user (String)

Returns:

  • (Array) 


274
275
276
 
# File 'lib/hyperliquid/info.rb', line 274

def delegator_rewards(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'delegatorRewards', user: user })
end

#delegator_summary(user) ⇒ Hash

Query a user’s staking summary

Parameters:

  • user (String)

Returns:

  • (Hash) 


260
261
262
 
# File 'lib/hyperliquid/info.rb', line 260

def delegator_summary(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'delegatorSummary', user: user })
end

#exchange_status ⇒ Hash

Retrieve exchange system status information

Returns:

  • (Hash) —

    Keys: time (Integer, ms since epoch), specialStatuses (Object or nil)



339
340
341
 
# File 'lib/hyperliquid/info.rb', line 339

def exchange_status
  @client.post(Constants::INFO_ENDPOINT, { type: 'exchangeStatus' })
end

#extra_agents(user) ⇒ Array

Get authorized agent addresses for a user

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array) —

    Array of authorized agent addresses



281
282
283
 
# File 'lib/hyperliquid/info.rb', line 281

def extra_agents(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'extraAgents', user: user })
end

#frontend_open_orders(user, dex: nil) ⇒ Array

Get a user’s open orders with additional frontend info

Parameters:

  • user (String) —

    Wallet address

  • dex (String, nil) (defaults to: nil) —

    Optional perp dex name

Returns:

  • (Array) 


38
39
40
41
42
 
# File 'lib/hyperliquid/info.rb', line 38

def frontend_open_orders(user, dex: nil)
  body = { type: 'frontendOpenOrders', user: user }
  body[:dex] = dex if dex
  @client.post(Constants::INFO_ENDPOINT, body)
end

#funding_history(coin, start_time, end_time = nil) ⇒ Array

Retrieve historical funding rates

Parameters:

  • coin (String)
  • start_time (Integer)
  • end_time (Integer, nil) (defaults to: nil)

Returns:

  • (Array) 


538
539
540
541
542
 
# File 'lib/hyperliquid/info.rb', line 538

def funding_history(coin, start_time, end_time = nil)
  body = { type: 'fundingHistory', coin: coin, startTime: start_time }
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#gossip_root_ips ⇒ Array<String>

Retrieve gossip root IPs

Returns:

  • (Array<String>) —

    Array of dotted-quad IPv4 addresses



358
359
360
 
# File 'lib/hyperliquid/info.rb', line 358

def gossip_root_ips
  @client.post(Constants::INFO_ENDPOINT, { type: 'gossipRootIps' })
end

#historical_orders(user, start_time = nil, end_time = nil) ⇒ Array

Retrieve a user’s historical orders

Parameters:

  • user (String) —

    Wallet address

  • start_time (Integer, nil) (defaults to: nil) —

    Optional start timestamp in milliseconds

  • end_time (Integer, nil) (defaults to: nil) —

    Optional end timestamp in milliseconds

Returns:

  • (Array) 


149
150
151
152
153
154
 
# File 'lib/hyperliquid/info.rb', line 149

def historical_orders(user, start_time = nil, end_time = nil)
  body = { type: 'historicalOrders', user: user }
  body[:startTime] = start_time if start_time
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#l2_book(coin) ⇒ Hash

Get L2 order book for a coin

Parameters:

  • coin (String) —

    Coin symbol (e.g., “BTC”, “ETH”)

Returns:

  • (Hash) —

    L2 order book data with bids and asks



93
94
95
 
# File 'lib/hyperliquid/info.rb', line 93

def l2_book(coin)
  @client.post(Constants::INFO_ENDPOINT, { type: 'l2Book', coin: coin })
end

#leading_vaults(user) ⇒ Array<Hash>

Retrieve the vaults a user is leading

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array<Hash>) —

    Array of { address (String), name (String) } entries



379
380
381
 
# File 'lib/hyperliquid/info.rb', line 379

def leading_vaults(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'leadingVaults', user: user })
end

#legal_check(user) ⇒ Hash

Retrieve a user’s legal verification status

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Keys: ipAllowed (Boolean), acceptedTerms (Boolean), userAllowed (Boolean)



365
366
367
 
# File 'lib/hyperliquid/info.rb', line 365

def legal_check(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'legalCheck', user: user })
end

#liquidatable ⇒ Array

Retrieve addresses of currently liquidatable users

Returns:

  • (Array) —

    Array of liquidatable user entries



325
326
327
 
# File 'lib/hyperliquid/info.rb', line 325

def liquidatable
  @client.post(Constants::INFO_ENDPOINT, { type: 'liquidatable' })
end

#margin_table(id) ⇒ Hash

Retrieve the margin requirements table for a given id

Parameters:

  • id (Integer) —

    Margin table id

Returns:

  • (Hash) —

    Keys: description (String), marginTiers (Array of { lowerBound, maxLeverage })



372
373
374
 
# File 'lib/hyperliquid/info.rb', line 372

def margin_table(id)
  @client.post(Constants::INFO_ENDPOINT, { type: 'marginTable', id: id })
end

#max_builder_fee(user, builder) ⇒ Hash

Check builder fee approval

Parameters:

  • user (String) —

    Wallet address

  • builder (String) —

    Builder address

Returns:

  • (Hash) 


133
134
135
 
# File 'lib/hyperliquid/info.rb', line 133

def max_builder_fee(user, builder)
  @client.post(Constants::INFO_ENDPOINT, { type: 'maxBuilderFee', user: user, builder: builder })
end

#max_market_order_ntls ⇒ Array<Array>

Retrieve maximum market order notionals per asset

Returns:

  • (Array<Array>) —

    Array of [notional (Numeric), symbol (String)] tuples



345
346
347
 
# File 'lib/hyperliquid/info.rb', line 345

def max_market_order_ntls
  @client.post(Constants::INFO_ENDPOINT, { type: 'maxMarketOrderNtls' })
end

#meta(dex: nil) ⇒ Hash

Get metadata for all assets

Parameters:

  • dex (String, nil) (defaults to: nil) —

    Optional perp dex name (defaults to first perp dex when not provided)

Returns:

  • (Hash) —

    Metadata for all tradable assets



414
415
416
417
418
 
# File 'lib/hyperliquid/info.rb', line 414

def meta(dex: nil)
  body = { type: 'meta' }
  body[:dex] = dex if dex
  @client.post(Constants::INFO_ENDPOINT, body)
end

#meta_and_asset_ctxs ⇒ Hash

Get metadata for all assets including universe info

Returns:

  • (Hash) —

    Extended metadata for all assets with universe information



422
423
424
 
# File 'lib/hyperliquid/info.rb', line 422

def meta_and_asset_ctxs
  @client.post(Constants::INFO_ENDPOINT, { type: 'metaAndAssetCtxs' })
end

#open_orders(user, dex: nil) ⇒ Array

Get a user’s open orders

Parameters:

  • user (String) —

    Wallet address

  • dex (String, nil) (defaults to: nil) —

    Optional perp dex name

Returns:

  • (Array) —

    Array of open orders for the user



28
29
30
31
32
 
# File 'lib/hyperliquid/info.rb', line 28

def open_orders(user, dex: nil)
  body = { type: 'openOrders', user: user }
  body[:dex] = dex if dex
  @client.post(Constants::INFO_ENDPOINT, body)
end

#order_status(user, oid) ⇒ Hash

Get order status by order ID

Parameters:

  • user (String) —

    Wallet address

  • oid (Integer) —

    Order ID

Returns:

  • (Hash) —

    Order status information



78
79
80
 
# File 'lib/hyperliquid/info.rb', line 78

def order_status(user, oid)
  @client.post(Constants::INFO_ENDPOINT, { type: 'orderStatus', user: user, oid: oid })
end

#order_status_by_cloid(user, cloid) ⇒ Hash

Get order status by client order ID (cloid)

Parameters:

  • user (String) —

    Wallet address

  • cloid (String) —

    Client order ID

Returns:

  • (Hash) —

    Order status information



86
87
88
 
# File 'lib/hyperliquid/info.rb', line 86

def order_status_by_cloid(user, cloid)
  @client.post(Constants::INFO_ENDPOINT, { type: 'orderStatus', user: user, cloid: cloid })
end

#outcome_meta ⇒ Hash

Retrieve prediction market outcome metadata

Returns:

  • (Hash) —

    Hash with outcomes (each with outcome, name, description, sideSpecs) and questions (each with question, name, description, fallbackOutcome, namedOutcomes, settledNamedOutcomes)



507
508
509
 
# File 'lib/hyperliquid/info.rb', line 507

def outcome_meta
  @client.post(Constants::INFO_ENDPOINT, { type: 'outcomeMeta' })
end

#perp_annotation(coin) ⇒ Hash?

Retrieve perp annotation for a single perpetual asset

Parameters:

  • coin (String) —

    Coin symbol (e.g., “BTC”)

Returns:

  • (Hash, nil) —

    Hash with category, description, and optional displayName/keywords; nil if no annotation exists for the coin



492
493
494
 
# File 'lib/hyperliquid/info.rb', line 492

def perp_annotation(coin)
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpAnnotation', coin: coin })
end

#perp_categories ⇒ Array<Array(String, String)>

Retrieve perpetual asset categories

Returns:

  • (Array<Array(String, String)>) —

    Array of [coin, category] tuples



484
485
486
 
# File 'lib/hyperliquid/info.rb', line 484

def perp_categories
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpCategories' })
end

#perp_concise_annotations ⇒ Array<Array>

Retrieve concise annotations for all perpetual assets

Returns:

  • (Array<Array>) —

    Array of [coin (String), annotation (Hash)] tuples; each annotation has category and optional displayName/keywords



499
500
501
 
# File 'lib/hyperliquid/info.rb', line 499

def perp_concise_annotations
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpConciseAnnotations' })
end

#perp_deploy_auction_status ⇒ Hash

Retrieve information about the Perp Deploy Auction

Returns:

  • (Hash) 


456
457
458
 
# File 'lib/hyperliquid/info.rb', line 456

def perp_deploy_auction_status
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpDeployAuctionStatus' })
end

#perp_dex_limits(dex) ⇒ Hash

Retrieve Builder-Deployed Perp Market Limits

Parameters:

  • dex (String)

Returns:

  • (Hash) 


471
472
473
 
# File 'lib/hyperliquid/info.rb', line 471

def perp_dex_limits(dex)
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpDexLimits', dex: dex })
end

#perp_dex_status(dex) ⇒ Hash

Retrieve perp DEX status (e.g. total net deposit) for a builder-deployed dex

Parameters:

  • dex (String) —

    Perp dex name; the empty string represents the first perp dex

Returns:

  • (Hash) —

    Keys: totalNetDeposit (String)



478
479
480
 
# File 'lib/hyperliquid/info.rb', line 478

def perp_dex_status(dex)
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpDexStatus', dex: dex })
end

#perp_dexs ⇒ Array

Retrieve all perpetual dexs

Returns:

  • (Array) 


407
408
409
 
# File 'lib/hyperliquid/info.rb', line 407

def perp_dexs
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpDexs' })
end

#perps_at_open_interest_cap ⇒ Array

Query perps at open interest caps

Returns:

  • (Array) 


450
451
452
 
# File 'lib/hyperliquid/info.rb', line 450

def perps_at_open_interest_cap
  @client.post(Constants::INFO_ENDPOINT, { type: 'perpsAtOpenInterestCap' })
end

#portfolio(user) ⇒ Array

Query a user’s portfolio time series

Parameters:

  • user (String)

Returns:

  • (Array) 


232
233
234
 
# File 'lib/hyperliquid/info.rb', line 232

def portfolio(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'portfolio', user: user })
end

#pre_transfer_check(user, source) ⇒ Hash

Check user existence, activation fee, and sanctions status before a transfer

Parameters:

  • user (String) —

    Destination user address

  • source (String) —

    Source (funding) address

Returns:

  • (Hash) —

    Keys: fee (String), isSanctioned (Boolean), userExists (Boolean), userHasSentTx (Boolean)



312
313
314
 
# File 'lib/hyperliquid/info.rb', line 312

def pre_transfer_check(user, source)
  @client.post(Constants::INFO_ENDPOINT, { type: 'preTransferCheck', user: user, source: source })
end

#predicted_fundings ⇒ Array

Retrieve predicted funding rates for different venues

Returns:

  • (Array) 


444
445
446
 
# File 'lib/hyperliquid/info.rb', line 444

def predicted_fundings
  @client.post(Constants::INFO_ENDPOINT, { type: 'predictedFundings' })
end

#recent_trades(coin) ⇒ Array

Get recent trades for a coin

Parameters:

  • coin (String) —

    Asset symbol (e.g., “BTC”)

Returns:

  • (Array) —

    Recent trades with coin, side, px, sz, time, hash, tid, users (maker, taker)



100
101
102
 
# File 'lib/hyperliquid/info.rb', line 100

def recent_trades(coin)
  @client.post(Constants::INFO_ENDPOINT, { type: 'recentTrades', coin: coin })
end

#referral(user) ⇒ Hash

Query a user’s referral information

Parameters:

  • user (String)

Returns:

  • (Hash) 


239
240
241
 
# File 'lib/hyperliquid/info.rb', line 239

def referral(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'referral', user: user })
end

#spot_balances(user) ⇒ Hash

Get a user’s spot token balances

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Object containing balances array



563
564
565
 
# File 'lib/hyperliquid/info.rb', line 563

def spot_balances(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'spotClearinghouseState', user: user })
end

#spot_deploy_state(user) ⇒ Hash

Get Spot Deploy Auction state for a user

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Spot deploy state



570
571
572
 
# File 'lib/hyperliquid/info.rb', line 570

def spot_deploy_state(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'spotDeployState', user: user })
end

#spot_meta ⇒ Hash

Get spot metadata

Returns:

  • (Hash) —

    Spot tokens and universe metadata



550
551
552
 
# File 'lib/hyperliquid/info.rb', line 550

def spot_meta
  @client.post(Constants::INFO_ENDPOINT, { type: 'spotMeta' })
end

#spot_meta_and_asset_ctxs ⇒ Array

Get spot metadata and asset contexts

Returns:

  • (Array) —
    spot_meta, spot_asset_ctxs


556
557
558
 
# File 'lib/hyperliquid/info.rb', line 556

def spot_meta_and_asset_ctxs
  @client.post(Constants::INFO_ENDPOINT, { type: 'spotMetaAndAssetCtxs' })
end

#spot_pair_deploy_auction_status ⇒ Hash

Get Spot Pair Deploy Auction status

Returns:

  • (Hash) —

    Auction timing and gas parameters



576
577
578
 
# File 'lib/hyperliquid/info.rb', line 576

def spot_pair_deploy_auction_status
  @client.post(Constants::INFO_ENDPOINT, { type: 'spotPairDeployAuctionStatus' })
end

#sub_accounts2(user) ⇒ Array<Hash>?

Retrieve a user’s V2 subaccounts (per-dex clearinghouse + spot state)

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array<Hash>, nil) —

    Array of entries with name, subAccountUser, master, dexToClearinghouseState (array of [dex, state] tuples), and spotState; nil if the user has no subaccounts



194
195
196
 
# File 'lib/hyperliquid/info.rb', line 194

def sub_accounts2(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'subAccounts2', user: user })
end

#token_details(token_id) ⇒ Hash

Get token details by tokenId

Parameters:

  • token_id (String) —

    34-character hexadecimal token id

Returns:

  • (Hash) —

    Token details



583
584
585
 
# File 'lib/hyperliquid/info.rb', line 583

def token_details(token_id)
  @client.post(Constants::INFO_ENDPOINT, { type: 'tokenDetails', tokenId: token_id })
end

#twap_history(user) ⇒ Array<Hash>

Retrieve a user’s TWAP order history

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array<Hash>) —

    Array of entries with time (Integer, sec since epoch), state (Hash), status (Hash with ‘status` and optional `description`), and optional twapId (Integer)



387
388
389
 
# File 'lib/hyperliquid/info.rb', line 387

def twap_history(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'twapHistory', user: user })
end

#user_abstraction(user) ⇒ String

Query a user’s abstraction state

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (String) —

    Abstraction state (e.g., “unifiedAccount”, “portfolioMargin”, “disabled”, “default”, “dexAbstraction”)



303
304
305
 
# File 'lib/hyperliquid/info.rb', line 303

def user_abstraction(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userAbstraction', user: user })
end

#user_borrow_lend_interest(user, start_time, end_time = nil) ⇒ Array<Hash>

Retrieve a user’s borrow/lend interest accrual history

Parameters:

  • user (String) —

    Wallet address

  • start_time (Integer) —

    Start timestamp in milliseconds

  • end_time (Integer, nil) (defaults to: nil) —

    Optional end timestamp in milliseconds

Returns:

  • (Array<Hash>) —

    Array of token, borrow, supply entries; borrow and supply are decimal-string interest amounts



629
630
631
632
633
 
# File 'lib/hyperliquid/info.rb', line 629

def user_borrow_lend_interest(user, start_time, end_time = nil)
  body = { type: 'userBorrowLendInterest', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_dex_abstraction(user) ⇒ Hash

Get dex abstraction config for a user

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Dex abstraction configuration



295
296
297
 
# File 'lib/hyperliquid/info.rb', line 295

def user_dex_abstraction(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userDexAbstraction', user: user })
end

#user_fees(user) ⇒ Hash

Query a user’s effective fee rates and schedule

Parameters:

  • user (String)

Returns:

  • (Hash) 


246
247
248
 
# File 'lib/hyperliquid/info.rb', line 246

def user_fees(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userFees', user: user })
end

#user_fills(user) ⇒ Array

Get a user’s fill history

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array) —

    Array of fill history for the user



47
48
49
 
# File 'lib/hyperliquid/info.rb', line 47

def user_fills(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userFills', user: user })
end

#user_fills_by_time(user, start_time, end_time = nil, aggregate_by_time: nil, reversed: nil) ⇒ Array

Get a user’s fills within a time range

Parameters:

  • user (String) —

    Wallet address

  • start_time (Integer) —

    Start timestamp in milliseconds

  • end_time (Integer, nil) (defaults to: nil) —

    Optional end timestamp in milliseconds

  • aggregate_by_time (Boolean, nil) (defaults to: nil) —

    If true, partial fills are aggregated when a crossing order fills multiple resting orders

  • reversed (Boolean, nil) (defaults to: nil) —

    If true, fills are returned in reverse chronological order (newest first)

Returns:

  • (Array) 


59
60
61
62
63
64
65
 
# File 'lib/hyperliquid/info.rb', line 59

def user_fills_by_time(user, start_time, end_time = nil, aggregate_by_time: nil, reversed: nil)
  body = { type: 'userFillsByTime', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  body[:aggregateByTime] = aggregate_by_time unless aggregate_by_time.nil?
  body[:reversed] = reversed unless reversed.nil?
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_funding(user, start_time, end_time = nil) ⇒ Array

Retrieve a user’s funding history

Parameters:

  • user (String)
  • start_time (Integer)
  • end_time (Integer, nil) (defaults to: nil)

Returns:

  • (Array) 


516
517
518
519
520
 
# File 'lib/hyperliquid/info.rb', line 516

def user_funding(user, start_time, end_time = nil)
  body = { type: 'userFunding', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_non_funding_ledger_updates(user, start_time, end_time = nil) ⇒ Array

Retrieve a user’s non-funding ledger updates

Parameters:

  • user (String)
  • start_time (Integer)
  • end_time (Integer, nil) (defaults to: nil)

Returns:

  • (Array) 


527
528
529
530
531
 
# File 'lib/hyperliquid/info.rb', line 527

def user_non_funding_ledger_updates(user, start_time, end_time = nil)
  body = { type: 'userNonFundingLedgerUpdates', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_rate_limit(user) ⇒ Hash

Query user rate limits and usage

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) 


70
71
72
 
# File 'lib/hyperliquid/info.rb', line 70

def user_rate_limit(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userRateLimit', user: user })
end

#user_role(user) ⇒ Hash

Query a user’s role

Parameters:

  • user (String)

Returns:

  • (Hash) 


225
226
227
 
# File 'lib/hyperliquid/info.rb', line 225

def user_role(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userRole', user: user })
end

#user_state(user, dex: nil) ⇒ Hash

Get user’s trading state

Parameters:

  • user (String) —

    Wallet address

  • dex (String, nil) (defaults to: nil) —

    Optional perp dex name

Returns:

  • (Hash) —

    User’s trading state including positions and balances



436
437
438
439
440
 
# File 'lib/hyperliquid/info.rb', line 436

def user_state(user, dex: nil)
  body = { type: 'clearinghouseState', user: user }
  body[:dex] = dex if dex
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_subaccounts(user) ⇒ Array

Retrieve a user’s subaccounts

Parameters:

  • user (String)

Returns:

  • (Array) 


185
186
187
 
# File 'lib/hyperliquid/info.rb', line 185

def user_subaccounts(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'subaccounts', user: user })
end

#user_to_multi_sig_signers(user) ⇒ Hash

Get multi-sig signer mappings for a user

Parameters:

  • user (String) —

    Multi-sig wallet address

Returns:

  • (Hash) —

    Multi-sig signer information



288
289
290
 
# File 'lib/hyperliquid/info.rb', line 288

def user_to_multi_sig_signers(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userToMultiSigSigners', user: user })
end

#user_twap_slice_fills(user, start_time = nil, end_time = nil) ⇒ Array

Retrieve a user’s TWAP slice fills

Parameters:

  • user (String) —

    Wallet address

  • start_time (Integer, nil) (defaults to: nil) —

    Optional start timestamp in milliseconds

  • end_time (Integer, nil) (defaults to: nil) —

    Optional end timestamp in milliseconds

Returns:

  • (Array) 


161
162
163
164
165
166
 
# File 'lib/hyperliquid/info.rb', line 161

def user_twap_slice_fills(user, start_time = nil, end_time = nil)
  body = { type: 'userTwapSliceFills', user: user }
  body[:startTime] = start_time if start_time
  body[:endTime] = end_time if end_time
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_twap_slice_fills_by_time(user, start_time, end_time = nil, aggregate_by_time: nil) ⇒ Array

Retrieve a user’s TWAP slice fills within a time range

Parameters:

  • user (String) —

    Wallet address

  • start_time (Integer) —

    Start timestamp in milliseconds

  • end_time (Integer, nil) (defaults to: nil) —

    Optional end timestamp in milliseconds

  • aggregate_by_time (Boolean, nil) (defaults to: nil) —

    If true, partial fills are aggregated when a crossing order fills multiple resting orders

Returns:

  • (Array) 


175
176
177
178
179
180
 
# File 'lib/hyperliquid/info.rb', line 175

def user_twap_slice_fills_by_time(user, start_time, end_time = nil, aggregate_by_time: nil)
  body = { type: 'userTwapSliceFillsByTime', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  body[:aggregateByTime] = aggregate_by_time unless aggregate_by_time.nil?
  @client.post(Constants::INFO_ENDPOINT, body)
end

#user_vault_equities(user) ⇒ Array

Retrieve a user’s vault deposits

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array) 


211
212
213
 
# File 'lib/hyperliquid/info.rb', line 211

def user_vault_equities(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userVaultEquities', user: user })
end

#validator_l1_votes ⇒ Array

Retrieve L1 governance votes cast by validators

Returns:

  • (Array) —

    Array of entries with expireTime (ms since epoch), action (hash with either ‘D` string or `C` array of strings), and votes (array of validator addresses)



352
353
354
 
# File 'lib/hyperliquid/info.rb', line 352

def validator_l1_votes
  @client.post(Constants::INFO_ENDPOINT, { type: 'validatorL1Votes' })
end

#validator_summaries ⇒ Array

Retrieve validator performance summaries

Returns:

  • (Array) —

    Array of validator entries with validator, signer, name, description, nRecentBlocks, stake, isJailed, unjailableAfter, isActive, commission, and stats (day/week/month uptime fraction, predicted APR, and sample count)



333
334
335
 
# File 'lib/hyperliquid/info.rb', line 333

def validator_summaries
  @client.post(Constants::INFO_ENDPOINT, { type: 'validatorSummaries' })
end

#vault_details(vault_address, user = nil) ⇒ Hash

Retrieve details for a vault

Parameters:

  • vault_address (String) —

    Vault address

  • user (String, nil) (defaults to: nil) —

    Optional wallet address

Returns:

  • (Hash) 


202
203
204
205
206
 
# File 'lib/hyperliquid/info.rb', line 202

def vault_details(vault_address, user = nil)
  body = { type: 'vaultDetails', vaultAddress: vault_address }
  body[:user] = user if user
  @client.post(Constants::INFO_ENDPOINT, body)
end

#vault_summaries ⇒ Array

Retrieve a list of vaults less than 2 hours old

Returns:

  • (Array) —

    Recently created vaults with name, address, leader, tvl, isClosed, relationship, createTimeMillis



218
219
220
 
# File 'lib/hyperliquid/info.rb', line 218

def vault_summaries
  @client.post(Constants::INFO_ENDPOINT, { type: 'vaultSummaries' })
end

#vip?(user) ⇒ Boolean?

Check whether a user is a VIP

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Boolean, nil) —

    True/false VIP status, or nil if the user is unknown



319
320
321
 
# File 'lib/hyperliquid/info.rb', line 319

def vip?(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'isVip', user: user })
end

#web_data2(user) ⇒ Hash

Retrieve comprehensive user and market data in a single response

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Aggregated payload containing keys including clearinghouseState, leadingVaults, totalVaultEquity, openOrders, agentAddress, agentValidUntil, cumLedger, meta, assetCtxs, serverTime, isVault, user, twapStates, spotState, spotAssetCtxs, optOutOfSpotDusting, perpsAtOpenInterestCap



397
398
399
 
# File 'lib/hyperliquid/info.rb', line 397

def web_data2(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'webData2', user: user })
end