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) 


376
377
378
 
# File 'lib/hyperliquid/info.rb', line 376

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

#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

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


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

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) 


237
238
239
 
# File 'lib/hyperliquid/info.rb', line 237

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) 


244
245
246
 
# File 'lib/hyperliquid/info.rb', line 244

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) 


230
231
232
 
# File 'lib/hyperliquid/info.rb', line 230

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)



309
310
311
 
# File 'lib/hyperliquid/info.rb', line 309

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



251
252
253
 
# File 'lib/hyperliquid/info.rb', line 251

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) 


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

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) 


142
143
144
145
146
147
 
# File 'lib/hyperliquid/info.rb', line 142

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

#liquidatable ⇒ Array

Retrieve addresses of currently liquidatable users

Returns:

  • (Array) —

    Array of liquidatable user entries



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

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



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

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



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

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



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

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

#perp_deploy_auction_status ⇒ Hash

Retrieve information about the Perp Deploy Auction

Returns:

  • (Hash) 


368
369
370
 
# File 'lib/hyperliquid/info.rb', line 368

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) 


383
384
385
 
# File 'lib/hyperliquid/info.rb', line 383

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

#perp_dexs ⇒ Array

Retrieve all perpetual dexs

Returns:

  • (Array) 


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

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) 


362
363
364
 
# File 'lib/hyperliquid/info.rb', line 362

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) 


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

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)



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

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) 


356
357
358
 
# File 'lib/hyperliquid/info.rb', line 356

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) 


209
210
211
 
# File 'lib/hyperliquid/info.rb', line 209

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



439
440
441
 
# File 'lib/hyperliquid/info.rb', line 439

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



446
447
448
 
# File 'lib/hyperliquid/info.rb', line 446

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



426
427
428
 
# File 'lib/hyperliquid/info.rb', line 426

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


432
433
434
 
# File 'lib/hyperliquid/info.rb', line 432

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



452
453
454
 
# File 'lib/hyperliquid/info.rb', line 452

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



459
460
461
 
# File 'lib/hyperliquid/info.rb', line 459

def token_details(token_id)
  @client.post(Constants::INFO_ENDPOINT, { type: 'tokenDetails', tokenId: token_id })
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”)



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

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

#user_dex_abstraction(user) ⇒ Hash

Get dex abstraction config for a user

Parameters:

  • user (String) —

    Wallet address

Returns:

  • (Hash) —

    Dex abstraction configuration



265
266
267
 
# File 'lib/hyperliquid/info.rb', line 265

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) 


216
217
218
 
# File 'lib/hyperliquid/info.rb', line 216

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) 


392
393
394
395
396
 
# File 'lib/hyperliquid/info.rb', line 392

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) 


403
404
405
406
407
 
# File 'lib/hyperliquid/info.rb', line 403

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) 


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

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



348
349
350
351
352
 
# File 'lib/hyperliquid/info.rb', line 348

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) 


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

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



258
259
260
 
# File 'lib/hyperliquid/info.rb', line 258

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) 


154
155
156
157
158
159
 
# File 'lib/hyperliquid/info.rb', line 154

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) 


181
182
183
 
# File 'lib/hyperliquid/info.rb', line 181

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



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

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) 


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

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



188
189
190
 
# File 'lib/hyperliquid/info.rb', line 188

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



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

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