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) 


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

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

#all_mids ⇒ Hash

Get all market mid prices

Returns:

  • (Hash) —

    Hash containing mid prices for all markets



16
17
18
 
# File 'lib/hyperliquid/info.rb', line 16

def all_mids
  @client.post(Constants::INFO_ENDPOINT, { type: 'allMids' })
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



94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/hyperliquid/info.rb', line 94

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) 


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

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) 


207
208
209
 
# File 'lib/hyperliquid/info.rb', line 207

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) 


214
215
216
 
# File 'lib/hyperliquid/info.rb', line 214

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) 


200
201
202
 
# File 'lib/hyperliquid/info.rb', line 200

def delegator_summary(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'delegatorSummary', 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) 


34
35
36
37
38
 
# File 'lib/hyperliquid/info.rb', line 34

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) 


313
314
315
316
317
 
# File 'lib/hyperliquid/info.rb', line 313

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

#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) 


119
120
121
122
123
124
 
# File 'lib/hyperliquid/info.rb', line 119

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



84
85
86
 
# File 'lib/hyperliquid/info.rb', line 84

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

#max_builder_fee(user, builder) ⇒ Hash

Check builder fee approval

Parameters:

  • user (String) —

    Wallet address

  • builder (String) —

    Builder address

Returns:

  • (Hash) 


110
111
112
 
# File 'lib/hyperliquid/info.rb', line 110

def max_builder_fee(user, builder)
  @client.post(Constants::INFO_ENDPOINT, { type: 'maxBuilderFee', user: user, builder: builder })
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



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

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



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

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



24
25
26
27
28
 
# File 'lib/hyperliquid/info.rb', line 24

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



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

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



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

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

#perp_deploy_auction_status ⇒ Hash

Retrieve information about the Perp Deploy Auction

Returns:

  • (Hash) 


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

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) 


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

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

#perp_dexs ⇒ Array

Retrieve all perpetual dexs

Returns:

  • (Array) 


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

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) 


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

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) 


172
173
174
 
# File 'lib/hyperliquid/info.rb', line 172

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

#predicted_fundings ⇒ Array

Retrieve predicted funding rates for different venues

Returns:

  • (Array) 


255
256
257
 
# File 'lib/hyperliquid/info.rb', line 255

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

#referral(user) ⇒ Hash

Query a user’s referral information

Parameters:

  • user (String)

Returns:

  • (Hash) 


179
180
181
 
# File 'lib/hyperliquid/info.rb', line 179

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



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

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



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

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



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

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


331
332
333
 
# File 'lib/hyperliquid/info.rb', line 331

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



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

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

#token_details(token_id) ⇒ Hash

Get token details by tokenId

Parameters:

  • token_id (String) —

    34-character hexadecimal token id

Returns:

  • (Hash) —

    Token details



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

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

#user_fees(user) ⇒ Hash

Query a user’s effective fee rates and schedule

Parameters:

  • user (String)

Returns:

  • (Hash) 


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

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



43
44
45
 
# File 'lib/hyperliquid/info.rb', line 43

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

#user_fills_by_time(user, start_time, end_time = 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

Returns:

  • (Array) 


52
53
54
55
56
 
# File 'lib/hyperliquid/info.rb', line 52

def user_fills_by_time(user, start_time, end_time = nil)
  body = { type: 'userFillsByTime', user: user, startTime: start_time }
  body[:endTime] = end_time if end_time
  @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) 


291
292
293
294
295
 
# File 'lib/hyperliquid/info.rb', line 291

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) 


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

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) 


61
62
63
 
# File 'lib/hyperliquid/info.rb', line 61

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) 


165
166
167
 
# File 'lib/hyperliquid/info.rb', line 165

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



247
248
249
250
251
 
# File 'lib/hyperliquid/info.rb', line 247

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) 


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

def user_subaccounts(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'subaccounts', 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) 


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

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_vault_equities(user) ⇒ Array

Retrieve a user’s vault deposits

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Array) 


158
159
160
 
# File 'lib/hyperliquid/info.rb', line 158

def user_vault_equities(user)
  @client.post(Constants::INFO_ENDPOINT, { type: 'userVaultEquities', user: user })
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) 


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

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