Struct Exchange

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

Endpoint to interact with and trade on the Hyperliquid chain.

Fields

client: Client

chain: Chain

Implementations

impl Exchange

pub async fn place_order( &self, wallet: Arc<LocalWallet>, orders: Vec<OrderRequest>, vault_address: Option<Address>, ) -> Result<Response>

Place an order

Arguments

• wallet - The wallet to sign the order with
• orders - The orders to place
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Note

• cloid in argument order is an optional 128 bit hex string, e.g. 0x1234567890abcdef1234567890abcdef

Examples found in repository

examples/info/perps.rs (line 184)

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/agent.rs (line 62)

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::ArbitrumTestnet);

    // Create a new wallet with the agent. This agent can't transfer or withdraw funds
    // but can place orders.

    let agent = Arc::new(LocalWallet::new(&mut thread_rng()));

    let agent_address = agent.address();

    println!("Agent address: {:?}", agent_address);

    let res = exchange
        .approve_agent(wallet.clone(), agent_address, Some("WETH".to_string()))
        .await
        .unwrap();

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

    // place order with agent
    let order_type = OrderType::Limit(Limit { tif: Tif::Gtc });
    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1700".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: None,
    };
    let vault_address = None;

    println!("Placing order with agent...");

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

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

examples/order-status.rs (line 47)

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);
}

examples/modify-order.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 order_type = OrderType::Limit(Limit { tif: Tif::Gtc });
    let cloid = Uuid::new_v4();

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1800".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: Some(cloid),
    };

    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),
    };

    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!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    let limit_px = "1710".to_string();
    // Modifying the order
    println!("Modifying order {oid} limit price to {limit_px}.");

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px,
        sz: "0.1".to_string(),
        order_type: OrderType::Limit(Limit { tif: Tif::Gtc }),
        cloid: Some(cloid),
    };

    let order = ModifyRequest { order, oid };

    let response = exchange
        .modify_order(wallet.clone(), order, vault_address)
        .await
        .expect("Failed to modify order");

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

examples/place-order.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 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");

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

    println!("-----------------");
    println!("Placing an order with cloid...");

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

    let cloid = Uuid::new_v4();

    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: Some(cloid),
    };

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

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

    println!("-----------------");
    println!("Placing a trigger order with tpsl...");

    let order_type = OrderType::Trigger(Trigger {
        is_market: false,
        trigger_px: parse_price(2800.0),
        tpsl: TpSl::Tp,
    });

    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: Some(cloid),
    };

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

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

examples/cancel-order.rs (line 43)

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 order_type = OrderType::Limit(Limit { tif: Tif::Gtc });

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1800".to_string(),
        sz: "0.1".to_string(),
        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),
    };

    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, status: {:?}", status);
        }
    };

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    // Cancel order

    println!("Cancelling order with oid {oid}.");
    let cancel = CancelRequest { asset: 4, oid };

    let vault_address = None;

    let response = exchange
        .cancel_order(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

    let cloid = Uuid::new_v4();

    println!("Placing order with cloid: {}", cloid.simple());

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

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1700".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: Some(cloid),
    };

    let vault_address = None;

    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),
    };

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

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

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Cancelling order with cloid: {}", cloid.simple());
    let cancel = CancelByCloidRequest { asset: 4, cloid };

    let response = exchange
        .cancel_order_by_cloid(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

pub async fn normal_tpsl( &self, wallet: Arc<LocalWallet>, orders: Vec<OrderRequest>, vault_address: Option<Address>, ) -> Result<Response>

Place a normal order with tpsl order

Arguments

• wallet - The wallet to sign the order with
• orders - The orders to place
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Note

• cloid in argument order is an optional 128 bit hex string, e.g. 0x1234567890abcdef1234567890abcdef

Examples found in repository

examples/normal-tpsl.rs (line 68)

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 asset = 4;
    let sz_decimals = 4;

    let normal = OrderRequest {
        asset,
        is_buy: true,
        reduce_only: false,
        limit_px: parse_price(2800.0),
        sz: parse_size(0.0331, sz_decimals),
        order_type: OrderType::Limit(Limit { tif: Tif::Gtc }),
        cloid: None,
    };

    let tp = OrderRequest {
        asset,
        is_buy: false,
        reduce_only: true,
        limit_px: parse_price(2810.0),
        sz: parse_size(0.0331, sz_decimals),
        order_type: OrderType::Trigger(Trigger {
            is_market: true,
            trigger_px: parse_price(2810.0),
            tpsl: TpSl::Tp,
        }),
        cloid: None,
    };

    let sl = OrderRequest {
        asset,
        is_buy: false,
        reduce_only: true,
        limit_px: parse_price(2750.0),
        sz: parse_size(0.0331, sz_decimals),
        order_type: OrderType::Trigger(Trigger {
            is_market: true,
            trigger_px: parse_price(2750.0),
            tpsl: TpSl::Tp,
        }),
        cloid: None,
    };

    let vault_address = None;

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

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

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

pub async fn cancel_order( &self, wallet: Arc<LocalWallet>, cancels: Vec<CancelRequest>, vault_address: Option<Address>, ) -> Result<Response>

Cancel an order

Arguments

• wallet - The wallet to sign the order with
• cancels - The orders to cancel
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/cancel-order.rs (line 81)

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 order_type = OrderType::Limit(Limit { tif: Tif::Gtc });

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1800".to_string(),
        sz: "0.1".to_string(),
        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),
    };

    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, status: {:?}", status);
        }
    };

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    // Cancel order

    println!("Cancelling order with oid {oid}.");
    let cancel = CancelRequest { asset: 4, oid };

    let vault_address = None;

    let response = exchange
        .cancel_order(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

    let cloid = Uuid::new_v4();

    println!("Placing order with cloid: {}", cloid.simple());

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

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1700".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: Some(cloid),
    };

    let vault_address = None;

    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),
    };

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

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

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Cancelling order with cloid: {}", cloid.simple());
    let cancel = CancelByCloidRequest { asset: 4, cloid };

    let response = exchange
        .cancel_order_by_cloid(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

pub async fn cancel_order_by_cloid( &self, wallet: Arc<LocalWallet>, cancels: Vec<CancelByCloidRequest>, vault_address: Option<Address>, ) -> Result<Response>

Cancel order(s) by client order id (cloid)

Arguments

• wallet - The wallet to sign the order with
• cancels - The client orders to cancel
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Note: cloid in argument cancel is a 128 bit hex string, e.g. 0x1234567890abcdef1234567890abcdef

Examples found in repository

examples/cancel-order.rs (line 137)

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 order_type = OrderType::Limit(Limit { tif: Tif::Gtc });

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1800".to_string(),
        sz: "0.1".to_string(),
        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),
    };

    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, status: {:?}", status);
        }
    };

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    // Cancel order

    println!("Cancelling order with oid {oid}.");
    let cancel = CancelRequest { asset: 4, oid };

    let vault_address = None;

    let response = exchange
        .cancel_order(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

    let cloid = Uuid::new_v4();

    println!("Placing order with cloid: {}", cloid.simple());

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

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1700".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: Some(cloid),
    };

    let vault_address = None;

    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),
    };

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

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

    println!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Cancelling order with cloid: {}", cloid.simple());
    let cancel = CancelByCloidRequest { asset: 4, cloid };

    let response = exchange
        .cancel_order_by_cloid(wallet.clone(), vec![cancel], vault_address)
        .await
        .expect("Failed to cancel order");

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

pub async fn modify_order( &self, wallet: Arc<LocalWallet>, order: ModifyRequest, vault_address: Option<Address>, ) -> Result<Response>

Modify an order

Arguments

• wallet - The wallet to sign the order with
• order - The orders to modify
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Note: cloid in argument order is an optional 128 bit hex string, e.g. 0x1234567890abcdef1234567890abcdef

Examples found in repository

examples/modify-order.rs (line 89)

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 order_type = OrderType::Limit(Limit { tif: Tif::Gtc });
    let cloid = Uuid::new_v4();

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1800".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: Some(cloid),
    };

    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),
    };

    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!("Order placed: {:?}", oid);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    let limit_px = "1710".to_string();
    // Modifying the order
    println!("Modifying order {oid} limit price to {limit_px}.");

    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px,
        sz: "0.1".to_string(),
        order_type: OrderType::Limit(Limit { tif: Tif::Gtc }),
        cloid: Some(cloid),
    };

    let order = ModifyRequest { order, oid };

    let response = exchange
        .modify_order(wallet.clone(), order, vault_address)
        .await
        .expect("Failed to modify order");

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

pub async fn batch_modify_orders( &self, wallet: Arc<LocalWallet>, orders: Vec<ModifyRequest>, vault_address: Option<Address>, ) -> Result<Response>

Batch modify orders

Arguments

• wallet - The wallet to sign the order with
• orders - The orders to modify
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

pub async fn update_leverage( &self, wallet: Arc<LocalWallet>, leverage: u32, asset: u32, is_cross: bool, ) -> Result<Response>

Update cross or isolated leverage on a coin

Arguments

• wallet - The wallet to sign the order with
• leverage - The new leverage to set
• asset - The asset to set the leverage for
• is_cross - true if cross leverage, false if isolated leverage

Examples found in repository

examples/leverage.rs (line 24)

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 update_isolated_margin( &self, wallet: Arc<LocalWallet>, asset: u32, is_buy: bool, ntli: i64, ) -> Result<Response>

Add or remove margin from isolated position

Arguments

• wallet - The wallet to sign the order with
• asset - The asset to set the margin for
• is_buy - true if adding margin, false if removing margin
• ntli - The new margin to set

Examples found in repository

examples/leverage.rs (line 35)

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 twap_order( &self, wallet: Arc<LocalWallet>, twap: TwapRequest, vault_address: Option<Address>, ) -> Result<Response>

Place a TWAP order

Arguments

• wallet - The wallet to sign the order with
• twap - The twap order to place
• vault_address - If trading on behalf of a vault, its onchain address in 42-character hexadecimal format e.g. 0x0000000000000000000000000000000000000000

Examples found in repository

examples/twap_order.rs (line 37)

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 asset = 0;
    let sz_decimals = 2;

    let twap = TwapRequest {
        asset,
        is_buy: true,
        reduce_only: false,
        duration: 10,
        sz: parse_size(13.85, sz_decimals),
        randomize: true,
    };

    let vault_address = None;

    println!("Placing a TWAP order...");
    let response = exchange
        .twap_order(wallet.clone(), twap, vault_address)
        .await
        .expect("Failed to place twap order");

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

pub async fn usdc_transfer( &self, from: Arc<LocalWallet>, destination: Address, amount: String, ) -> Result<Response>

Send usd to another address. This transfer does not touch the EVM bridge. The signature format is human readable for wallet interfaces.

Arguments

• from - The wallet to sign the transfer with
• destination - The address to send the usd to
• amount - The amount of usd to send

Examples found in repository

examples/usd_send.rs (line 31)

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::ArbitrumTestnet);

    let destination = "0x0D1d9635D0640821d15e323ac8AdADfA9c111414"
        .parse()
        .expect("Invalid address");

    let amount = "1".to_string(); // USD

    println!(
        "Transferring ${} from {:?} to {:?}",
        amount,
        wallet.address(),
        destination
    );

    let res = exchange
        .usdc_transfer(wallet.clone(), destination, amount)
        .await
        .unwrap();

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

pub async fn withdraw_from_bridge( &self, wallet: Arc<LocalWallet>, destination: Address, amount: String, ) -> Result<Response>

Withdraw from bridge

Arguments

• wallet - The wallet to sign the withdrawal with
• destination - The address to send the usd to
• amount - The amount of usd to send

Examples found in repository

examples/bridge.rs (line 26)

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

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

    let destination = "0x0D1d9635D0640821d15e323ac8AdADfA9c111414"
        .parse()
        .expect("Invalid address");

    let usd = "10".to_string(); // USD

    println!("Withdrawing ${} from bridge to {:?}", usd, destination);

    let res = exchange
        .withdraw_from_bridge(wallet.clone(), destination, usd)
        .await
        .unwrap();

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

pub async fn approve_agent( &self, wallet: Arc<LocalWallet>, agent_address: Address, agent_name: Option<String>, ) -> Result<Response>

Approve an agent to trade on behalf of the user

Arguments

• wallet - The wallet to sign the approval with
• agent_address - The address of the agent to approve
• agent_name - An optional name for the agent

Examples found in repository

examples/agent.rs (line 40)

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::ArbitrumTestnet);

    // Create a new wallet with the agent. This agent can't transfer or withdraw funds
    // but can place orders.

    let agent = Arc::new(LocalWallet::new(&mut thread_rng()));

    let agent_address = agent.address();

    println!("Agent address: {:?}", agent_address);

    let res = exchange
        .approve_agent(wallet.clone(), agent_address, Some("WETH".to_string()))
        .await
        .unwrap();

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

    // place order with agent
    let order_type = OrderType::Limit(Limit { tif: Tif::Gtc });
    let order = OrderRequest {
        asset: 4,
        is_buy: true,
        reduce_only: false,
        limit_px: "1700".to_string(),
        sz: "0.1".to_string(),
        order_type,
        cloid: None,
    };
    let vault_address = None;

    println!("Placing order with agent...");

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

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

pub async fn create_sub_account( &self, wallet: Arc<LocalWallet>, name: String, ) -> Result<Response>

Create subaccount for the user

Arguments

• wallet - The wallet to create the subaccount with
• name - The name of the subaccount

Examples found in repository

examples/subaccount.rs (line 34)

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::ArbitrumTestnet);

    println!("Creating subaccount...");
    let name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    let response = exchange
        .create_sub_account(wallet.clone(), name.clone())
        .await
        .expect("Failed to create subaccount");

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

    let sub_account_user = match response.data {
        Some(StatusType::Address(address)) => address,
        _ => panic!("Failed to get subaccount address: {:?}", response),
    };

    println!(
        "Subaccount created with name {} and user address: {:x} ✓",
        name, sub_account_user
    );

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    let new_name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    println!("Renaming subaccount to: {}", new_name);

    let response = exchange
        .sub_account_modify(wallet.clone(), new_name, sub_account_user)
        .await
        .expect("Failed to rename subaccount");

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

    println!("Subaccount rename response: {:?} ✓", response);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Depositing 1 USD to subaccount...");

    let usd = 1_000_000;

    let is_deposit = true;

    let response = exchange
        .sub_account_transfer(wallet.clone(), is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to deposit funds");

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

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

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    println!("Withdrawing funds from subaccount...");

    let response = exchange
        .sub_account_transfer(wallet.clone(), !is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to withdraw funds");

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

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

pub async fn sub_account_modify( &self, wallet: Arc<LocalWallet>, name: String, sub_account_user: Address, ) -> Result<Response>

Rename subaccount

Arguments

• wallet - The wallet to sign the rename with
• name - The new name of the subaccount
• sub_account_user - The address of the subaccount to rename

Examples found in repository

examples/subaccount.rs (line 69)

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::ArbitrumTestnet);

    println!("Creating subaccount...");
    let name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    let response = exchange
        .create_sub_account(wallet.clone(), name.clone())
        .await
        .expect("Failed to create subaccount");

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

    let sub_account_user = match response.data {
        Some(StatusType::Address(address)) => address,
        _ => panic!("Failed to get subaccount address: {:?}", response),
    };

    println!(
        "Subaccount created with name {} and user address: {:x} ✓",
        name, sub_account_user
    );

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    let new_name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    println!("Renaming subaccount to: {}", new_name);

    let response = exchange
        .sub_account_modify(wallet.clone(), new_name, sub_account_user)
        .await
        .expect("Failed to rename subaccount");

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

    println!("Subaccount rename response: {:?} ✓", response);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Depositing 1 USD to subaccount...");

    let usd = 1_000_000;

    let is_deposit = true;

    let response = exchange
        .sub_account_transfer(wallet.clone(), is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to deposit funds");

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

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

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    println!("Withdrawing funds from subaccount...");

    let response = exchange
        .sub_account_transfer(wallet.clone(), !is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to withdraw funds");

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

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

pub async fn sub_account_transfer( &self, wallet: Arc<LocalWallet>, is_deposit: bool, sub_account_user: Address, usd: u64, ) -> Result<Response>

Transfer funds between subaccounts

Arguments

• wallet - The wallet to sign the transfer with
• from - The subaccount to transfer from

Examples found in repository

examples/subaccount.rs (line 91)

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::ArbitrumTestnet);

    println!("Creating subaccount...");
    let name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    let response = exchange
        .create_sub_account(wallet.clone(), name.clone())
        .await
        .expect("Failed to create subaccount");

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

    let sub_account_user = match response.data {
        Some(StatusType::Address(address)) => address,
        _ => panic!("Failed to get subaccount address: {:?}", response),
    };

    println!(
        "Subaccount created with name {} and user address: {:x} ✓",
        name, sub_account_user
    );

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    let new_name = {
        let suffix = timestamp().to_string();

        // slice the last 4 characters
        let suffix = &suffix[suffix.len() - 4..];

        format!("Acc-{}", suffix)
    };

    println!("Renaming subaccount to: {}", new_name);

    let response = exchange
        .sub_account_modify(wallet.clone(), new_name, sub_account_user)
        .await
        .expect("Failed to rename subaccount");

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

    println!("Subaccount rename response: {:?} ✓", response);

    tokio::time::sleep(std::time::Duration::from_secs(5)).await;

    println!("Depositing 1 USD to subaccount...");

    let usd = 1_000_000;

    let is_deposit = true;

    let response = exchange
        .sub_account_transfer(wallet.clone(), is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to deposit funds");

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

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

    tokio::time::sleep(std::time::Duration::from_secs(10)).await;

    println!("Withdrawing funds from subaccount...");

    let response = exchange
        .sub_account_transfer(wallet.clone(), !is_deposit, sub_account_user, usd)
        .await
        .expect("Failed to withdraw funds");

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

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

pub async fn set_referrer( &self, wallet: Arc<LocalWallet>, code: String, ) -> Result<Response>

Set referrer for the user

Arguments

• wallet - The wallet to sign the transfer with
• code - The referrer code

pub async fn schedule_cancel( &self, wallet: Arc<LocalWallet>, time: Option<u64>, ) -> Result<Response>

Schedule a time in (UTC ms) to cancel all open orders

Arguments

• wallet - The wallet to sign the transaction with
• time - Optional time in milliseconds to cancel all open orders

Note

• If time is None, then unsets any cancel time in the future. time must be atleast 5 seconds after the current time
• Once the time is reached, all open orders will be cancelled and trigger count will be incremented. The max number of triggers is 10 per day. Trigger count resets at 00:00 UTC

Trait Implementations

impl Hyperliquid for Exchange

fn new(chain: Chain) -> Self

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