Struct HyperliquidData

pub struct HyperliquidData {
    pub symbol: String,
    pub datetime: Vec<DateTime<FixedOffset>>,
    pub open: Vec<f64>,
    pub high: Vec<f64>,
    pub low: Vec<f64>,
    pub close: Vec<f64>,
    pub volume: Vec<f64>,
    pub funding_rates: Vec<f64>,
}

Main data structure for Hyperliquid market data

This structure contains OHLC price data along with funding rates for perpetual futures. It provides a comprehensive view of market conditions including both price action and funding dynamics.

Fields

• symbol: Trading pair symbol (e.g., “BTC”, “ETH”)
• datetime: Timestamps for each data point (UTC with timezone info)
• open, high, low, close: OHLC price data
• volume: Trading volume for each period
• funding_rates: Funding rates (NaN for non-funding periods)

Data Alignment

All arrays have the same length and are aligned by index. The funding_rates array contains NaN values for periods where funding is not applied (typically every 8 hours).

Example

use hyperliquid_backtest::prelude::*;

#[tokio::main]
async fn main() -> Result<(), HyperliquidBacktestError> {
    let data = HyperliquidData::fetch("BTC", "1h", start_time, end_time).await?;
     
    // Access price data
    println!("Latest close price: ${:.2}", data.close.last().unwrap());
     
    // Check data integrity
    assert_eq!(data.datetime.len(), data.close.len());
    assert_eq!(data.close.len(), data.funding_rates.len());
     
    Ok(())
}

Fields

symbol: String

Trading pair symbol (e.g., “BTC”, “ETH”, “SOL”)

datetime: Vec<DateTime<FixedOffset>>

Array of timestamps for each data point (UTC with timezone information)

open: Vec<f64>

Array of opening prices for each period

high: Vec<f64>

Array of highest prices for each period

low: Vec<f64>

Array of lowest prices for each period

close: Vec<f64>

Array of closing prices for each period

volume: Vec<f64>

Array of trading volumes for each period

funding_rates: Vec<f64>

Array of funding rates (NaN for non-funding periods, typically every 8 hours)

Implementations

impl HyperliquidData

pub async fn fetch( coin: &str, interval: &str, start_time: u64, end_time: u64, ) -> Result<Self>

Fetch historical market data from Hyperliquid API

This is the primary method for obtaining market data for backtesting. It fetches both OHLC price data and funding rate information from the Hyperliquid API.

Arguments

• coin - Trading pair symbol (e.g., “BTC”, “ETH”, “SOL”)
• interval - Time interval for candles (“1m”, “5m”, “15m”, “1h”, “4h”, “1d”)
• start_time - Start timestamp in Unix seconds
• end_time - End timestamp in Unix seconds

Returns

Returns a Result<HyperliquidData, HyperliquidBacktestError> containing the market data or an error if the fetch operation fails.

Errors

This method can return several types of errors:

• UnsupportedInterval - If the interval is not supported
• InvalidTimeRange - If start_time >= end_time
• HyperliquidApi - If the API request fails
• DataConversion - If the response data is invalid
• Network - If there are network connectivity issues

Examples

use hyperliquid_backtest::prelude::*;
use chrono::Utc;

#[tokio::main]
async fn main() -> Result<(), HyperliquidBacktestError> {
    let end_time = Utc::now().timestamp() as u64;
    let start_time = end_time - (24 * 60 * 60); // 24 hours ago
     
    // Fetch BTC data with 1-hour intervals
    let data = HyperliquidData::fetch("BTC", "1h", start_time, end_time).await?;
     
    println!("Fetched {} data points", data.len());
    println!("Latest price: ${:.2}", data.close.last().unwrap());
     
    Ok(())
}

Performance Notes

• Larger time ranges will take longer to fetch and process
• Consider caching data locally for repeated backtests
• Use appropriate intervals for your analysis (higher frequency = more data)

pub fn with_ohlc_data( symbol: String, datetime: Vec<DateTime<FixedOffset>>, open: Vec<f64>, high: Vec<f64>, low: Vec<f64>, close: Vec<f64>, volume: Vec<f64>, ) -> Result<Self>

Create a new HyperliquidData instance with OHLC data only

This constructor creates a HyperliquidData instance with OHLC price data but no funding rate information. Funding rates will be set to NaN for all periods.

Arguments

• symbol - Trading pair symbol
• datetime - Vector of timestamps
• open - Vector of opening prices
• high - Vector of high prices
• low - Vector of low prices
• close - Vector of closing prices
• volume - Vector of trading volumes

Returns

Returns a Result<HyperliquidData, HyperliquidBacktestError> or a validation error if the input arrays have different lengths.

Examples

use hyperliquid_backtest::prelude::*;
use chrono::{DateTime, FixedOffset, Utc};

let timestamps = vec![Utc::now().with_timezone(&FixedOffset::east_opt(0).unwrap())];
let prices = vec![50000.0];
let volumes = vec![1000.0];

let data = HyperliquidData::with_ohlc_data(
    "BTC".to_string(),
    timestamps,
    prices.clone(), // open
    prices.clone(), // high
    prices.clone(), // low
    prices.clone(), // close
    volumes,
)?;

pub fn with_ohlc_and_funding_data( symbol: String, datetime: Vec<DateTime<FixedOffset>>, open: Vec<f64>, high: Vec<f64>, low: Vec<f64>, close: Vec<f64>, volume: Vec<f64>, funding_rates: Vec<f64>, ) -> Result<Self>

Create a new HyperliquidData instance with OHLC and funding data

pub fn len(&self) -> usize

Get the number of data points

pub fn is_empty(&self) -> bool

Check if the data is empty

pub fn validate_all_data(&self) -> Result<()>

Validate all data for consistency

pub fn to_rs_backtester_data(&self) -> Data

Convert to rs-backtester Data format

pub fn get_funding_rate_at( &self, timestamp: DateTime<FixedOffset>, ) -> Option<f64>

Get funding rate at a specific timestamp

pub fn get_price_at_or_near( &self, timestamp: DateTime<FixedOffset>, ) -> Option<f64>

Get the price (close) at or near a specific timestamp

pub fn calculate_funding_statistics(&self) -> FundingStatistics

Calculate funding statistics

pub fn validate_fetch_parameters( coin: &str, interval: &str, start_time: u64, end_time: u64, ) -> Result<()>

Validate fetch parameters

pub fn popular_trading_pairs() -> &'static [&'static str]

Get list of popular trading pairs

pub fn is_popular_pair(coin: &str) -> bool

Check if a trading pair is popular

Trait Implementations

impl Clone for HyperliquidData

fn clone(&self) -> HyperliquidData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HyperliquidData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HyperliquidData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for HyperliquidData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.