Struct Info

pub struct Info {
    pub client: Client,
    pub chain: Chain,
}

Endpoint to fetch information about the exchange and specific users.

Fields

client: Client

chain: Chain

Implementations

impl Info

pub async fn metadata(&self) -> Result<Universe>

Retrieve exchange metadata

Examples found in repository

examples/info/perps.rs (line 61)

async fn metadata(info: &Info) {
    let metadata = info.metadata().await.unwrap();
    println!("{SEP}\nMetadata \n{:?}{SEP}", metadata.universe);
}

pub async fn mids(&self) -> Result<HashMap<String, String>>

Retrieve all mids for all actively traded coins

Examples found in repository

examples/info/perps.rs (line 66)

async fn mids(info: &Info) {
    let mids = info.mids().await.unwrap();
    println!("Mids \n{:?}{SEP}", mids);
}

pub async fn contexts(&self) -> Result<Vec<AssetContext>>

Retrieve asset contexts i.e mark price, current funding, open interest, etc

Examples found in repository

examples/info/perps.rs (line 71)

async fn contexts(info: &Info) {
    let contexts = info.contexts().await.unwrap();
    println!("Asset Contexts \n{:?}{SEP}", contexts);
}

pub async fn user_state(&self, user: Address) -> Result<UserState>

Retrieve a user’s state to see user’s open positions and margin summary

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/perps.rs (line 76)

async fn user_state(info: &Info, user: Address) {
    let user_state = info.user_state(user).await.unwrap();
    println!("User state for {user} \n{:?}{SEP}", user_state);
}

examples/leverage.rs (line 44)

async fn main() {
    // Key was randomly generated for testing and shouldn't be used with any real funds
    let wallet: Arc<LocalWallet> = Arc::new(
        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
            .parse()
            .unwrap(),
    );

    let exchange: Exchange = Hyperliquid::new(Chain::Dev);

    let leverage = 2;
    let asset = 4;
    let is_cross = false;

    println!("Updating leverage to {}x ...", leverage);

    let res = exchange
        .update_leverage(wallet.clone(), leverage, asset, is_cross)
        .await
        .unwrap();

    println!("Response: {:?}", res);

    let margin = 1;

    println!("--\nUpdating isolated margin for ETH to {margin}% ...");

    let res = exchange
        .update_isolated_margin(wallet.clone(), asset, true, margin)
        .await
        .unwrap();

    println!("Response: {:?}", res);

    let info: Info = Hyperliquid::new(Chain::Dev);

    // user state
    let res = info.user_state(wallet.address()).await.unwrap();

    println!("--\nUser state: {:?}", res);
}

pub async fn user_states(&self, users: Vec<Address>) -> Result<Vec<UserState>>

Retrieve a user’s state to see user’s open positions and margin summary in batch

Arguments

• users - A list of user addresses in 42-character hexadecimal format

Examples found in repository

examples/info/perps.rs (line 81)

async fn batch_user_states(info: &Info, users: Vec<Address>) {
    let user_states = info.user_states(users.clone()).await.unwrap();
    println!("User states for {:?} \n{:?}{SEP}", users, user_states);
}

pub async fn open_orders(&self, user: Address) -> Result<Vec<OpenOrder>>

Retrieve a user’s open orders

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/perps.rs (line 86)

async fn open_orders(info: &Info, user: Address) {
    let open_orders = info.open_orders(user).await.unwrap();
    println!("Open orders for {user} \n{:?}{SEP}", open_orders);
}

pub async fn frontend_open_orders( &self, user: Address, ) -> Result<Vec<FrontendOpenOrders>>

Retrieve a user’s open orders with additional frontend info. This is useful for displaying orders in a UI

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/perps.rs (line 91)

async fn frontend_open_orders(info: &Info, user: Address) {
    let open_orders = info.frontend_open_orders(user).await.unwrap();
    println!("Frontend Open orders for {user} \n{:?}{SEP}", open_orders);
}

pub async fn user_fills(&self, user: Address) -> Result<Vec<UserFill>>

Retrieve a user’s Userfills

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/perps.rs (line 96)

async fn user_fills(info: &Info, user: Address) {
    let user_fills = info.user_fills(user).await.unwrap();
    println!("User fills for {user} \n{:?}{SEP}", user_fills);
}

pub async fn user_fills_by_time( &self, user: Address, start_time: u64, end_time: Option<u64>, ) -> Result<Vec<UserFill>>

Retrieve a user’s fills by time

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000
• start_time - Start time in milliseconds, inclusive
• end_time - End time in milliseconds, inclusive. If None, it will default to the current time

Note

• Number of fills is limited to 2000

Examples found in repository

examples/info/perps.rs (line 101)

async fn user_fills_by_time(info: &Info, user: Address, start_time: u64, end_time: Option<u64>) {
    let user_fills = info.user_fills_by_time(user, start_time, end_time).await;
    // .unwrap();
    println!("User fills by time for {user} \n{:?}{SEP}", user_fills);
}

pub async fn user_funding( &self, user: Address, start_time: u64, end_time: Option<u64>, ) -> Result<Vec<UserFunding>>

Retrieve a user’s funding history

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000
• start_time - Start time in milliseconds, inclusive
• end_time - End time in milliseconds, inclusive. If None, it will default to the current time

Examples found in repository

examples/info/perps.rs (line 111)

async fn user_funding(info: &Info, user: Address) {
    let start_timestamp = 1690540602225;
    let end_timestamp = 1690569402225;

    let user_funding = info
        .user_funding(user, start_timestamp, Some(end_timestamp))
        .await
        .unwrap();
    println!(
        "User funding for {user} between {start_timestamp} and {end_timestamp} \n{:?}{SEP}",
        user_funding
    );
}

pub async fn funding_history( &self, coin: String, start_time: u64, end_time: Option<u64>, ) -> Result<Vec<FundingHistory>>

Retrieve historical funding rates for a coin

Arguments

• coin - The coin to retrieve funding history for e.g BTC, ETH, etc
• start_time - Start time in milliseconds, inclusive
• end_time - End time in milliseconds, inclusive. If None, it will default to the current time

Examples found in repository

examples/info/perps.rs (line 127)

async fn funding_history(info: &Info) {
    let coin = "ETH";

    let start_timestamp = 1690540602225;
    let end_timestamp = 1690569402225;

    let funding_history = info
        .funding_history(coin.to_string(), start_timestamp, Some(end_timestamp))
        .await
        .unwrap();
    println!(
        "Funding history for {coin} between {start_timestamp} and {end_timestamp} \n{:?}{SEP}",
        funding_history
    );
}

pub async fn l2_book(&self, coin: String) -> Result<L2Book>

Retrieve the L2 order book for a coin

Arguments

• coin - The coin to retrieve the L2 order book for e.g BTC, ETH, etc

Examples found in repository

examples/info/perps.rs (line 139)

async fn l2_book(info: &Info) {
    let coin = "ETH";

    let l2_book = info.l2_book(coin.to_string()).await.unwrap();
    println!("L2 book for {coin} \n{:?}{SEP}", l2_book);
}

pub async fn recent_trades(&self, coin: String) -> Result<Vec<RecentTrades>>

Retrieve the recent trades for a coin

Arguments

• coin - The coin to retrieve the recent trades for

Examples found in repository

examples/info/perps.rs (line 146)

async fn recent_trades(info: &Info) {
    let coin = "ETH";

    let recent_trades = info.recent_trades(coin.to_string()).await.unwrap();
    println!("Recent trades for {coin} \n{:?}{SEP}", recent_trades);
}

pub async fn candle_snapshot( &self, coin: String, interval: String, start_time: u64, end_time: u64, ) -> Result<Vec<CandleSnapshot>>

Retrieve candle snapshot for a coin

Arguments

• coin - The coin to retrieve the candle snapshot for e.g BTC, ETH, etc
• interval - The interval to retrieve the candle snapshot for
• start_time - Start time in milliseconds, inclusive
• end_time - End time in milliseconds, inclusive.

Examples found in repository

examples/info/perps.rs (lines 157-162)

async fn candle_snapshot(info: &Info) {
    let coin = "ETH";
    let interval = "15m";
    let start_timestamp = 1690540602225;
    let end_timestamp = 1690569402225;

    let snapshot = info
        .candle_snapshot(
            coin.to_string(),
            interval.to_string(),
            start_timestamp,
            end_timestamp,
        )
        .await
        .unwrap();
    println!("Candle snapshot for {coin} between {start_timestamp} and {end_timestamp} with interval {interval} \n{:?}{SEP}",snapshot);
}

pub async fn order_status(&self, user: Address, oid: Oid) -> Result<OrderStatus>

Query the status of an order by oid or cloid

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000
• oid - The order id either u64 representing the order id or 16-byte hex string representing the client order id

Examples found in repository

examples/info/perps.rs (line 192)

async fn order_status(info: &Info, exchange: &Exchange, wallet: Arc<LocalWallet>) {
    let user = wallet.address();
    let vault_address = None;
    let cloid = Uuid::new_v4();
    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: parse_price(2800.0),
        sz: parse_size(0.0331, 4),
        order_type: OrderType::Limit(Limit { tif: Tif::Gtc }),
        cloid: Some(cloid),
    };

    println!("Placing order with cloid: {}{SEP}", cloid.simple());
    let response = exchange
        .place_order(wallet, vec![order], vault_address)
        .await
        .expect("Failed to place order");

    println!("Response: {:?}", response);

    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;

    let order_status = info.order_status(user, Oid::Cloid(cloid)).await.unwrap();

    println!(
        "Order status for {} \n{:?}{SEP}",
        cloid.simple(),
        order_status
    );
}

examples/order-status.rs (line 78)

async fn main() {
    // Key was randomly generated for testing and shouldn't be used with any real funds
    let wallet: Arc<LocalWallet> = Arc::new(
        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
            .parse()
            .unwrap(),
    );

    let exchange: Exchange = Hyperliquid::new(Chain::Dev);
    let info: Info = Hyperliquid::new(Chain::Dev);

    let asset = 4;
    let sz_decimals = 4;

    let order_type = OrderType::Limit(Limit { tif: Tif::Gtc });

    let order = OrderRequest {
        asset,
        is_buy: true,
        reduce_only: false,
        limit_px: parse_price(2800.0),
        sz: parse_size(0.0331, sz_decimals),
        order_type,
        cloid: None,
    };

    let vault_address = None;

    println!("Placing order...");
    let response = exchange
        .place_order(wallet.clone(), vec![order], vault_address)
        .await
        .expect("Failed to place order");

    let response = match response {
        Response::Ok(order) => order,
        Response::Err(error) => panic!("Failed to place order: {:?}", error),
    };

    println!("Response: {:?}", response.data);

    let status_type = &response.data.unwrap();

    let status = match status_type {
        StatusType::Statuses(statuses) => &statuses[0],
        _ => {
            panic!("Failed to place order: {:?}", status_type);
        }
    };

    let oid = match status {
        Status::Filled(order) => order.oid,
        Status::Resting(order) => order.oid,
        _ => panic!("Order is not filled or resting"),
    };

    println!("-----------------");

    println!("Fetching order {} status...", oid);

    let status = info
        .order_status(wallet.address(), Oid::Order(oid))
        .await
        .expect("Failed to fetch order status");

    println!("Order status: {:#?}", status.order);
}

pub async fn sub_accounts( &self, user: Address, ) -> Result<Option<Vec<SubAccount>>>

Query user sub-accounts

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/perps.rs (line 202)

async fn sub_accounts(info: &Info, user: Address) {
    let sub_accounts = info.sub_accounts(user).await.unwrap();
    println!("Sub accounts for {user} \n{:?}{SEP}", sub_accounts);
}

impl Info

pub async fn spot_meta(&self) -> Result<SpotMeta>

Retrieve spot metadata

Examples found in repository

examples/info/spot.rs (line 32)

async fn spot_meta(info: &Info) {
    let spot_meta = info.spot_meta().await.unwrap();
    println!("{SEP}\nSpot Metadata \n{:?}{SEP}", spot_meta);
}

pub async fn spot_meta_and_asset_ctxs( &self, ) -> Result<Vec<SpotMetaAndAssetCtxs>>

Retrieve spot asset contexts

Examples found in repository

examples/info/spot.rs (line 37)

async fn spot_meta_and_asset_ctxs(info: &Info) {
    let spot_asset_ctxs = info.spot_meta_and_asset_ctxs().await.unwrap();
    println!("Spot Asset Contexts \n{:?}{SEP}", spot_asset_ctxs);
}

pub async fn spot_clearinghouse_state( &self, user: Address, ) -> Result<UserSpotState>

Retrieve a user’s token balances

Arguments

• user - The user’s address in 42-character hexadecimal format; e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/info/spot.rs (line 42)

async fn spot_clearinghouse_state(info: &Info, user: Address) {
    let states = info.spot_clearinghouse_state(user).await.unwrap();
    println!("User spot state for {user} \n{:?}{SEP}", states);
}

Trait Implementations

impl Hyperliquid for Info

fn new(chain: Chain) -> Self

fn new_with_config(chain: Chain, config: &Config) -> Self