The Making of: Breaking Down the Financial Performance of HyperLiquid Vaults

Note from the author: This article is the interactive twin of our original HyperLiquid Vaults Analysis. While the first article presents the insights in a reader-friendly format, this version includes new sections, such as data preparation, and displays the actual code blocks, allowing you to run the code in real-time, explore the data, and recreate the analysis step by step.

TL;DR (Summary) – HyperLiquid Vaults Analysis by Growi.fi

The HyperLiquid Vaults ecosystem provides a way for investors to access automated strategies, but each vault has different risk and return profiles. To help the community better understand performance, we analyzed key financial metrics like annual returns, volatility, and Sharpe ratio.

🌍 HyperLiquid Vaults: A Growing Ecosystem

HyperLiquid has gained strong traction, further boosted by its recent airdrop that distributed billions of dollars. While most attention has been on trading volume and fees, Vaults are emerging as a key part of the ecosystem.

📈 The total TVL in HyperLiquid is $1.6B, with Vaults holding $442.8M (27% of the total).

💰 However, most of this belongs to HyperLiquid’s own Vaults—external Vaults hold just $35.4M, highlighting major growth potential.

🛠️ Vault creation is active, with 2,396 open Vaults, but only 16.2% have been profitable in the last 30 days. Only 20.1% of Vaults have a lifetime profit, showing that careful selection is crucial.

🔍 Vaults provide transparency and flexibility, allowing strategies to be tracked on-chain, but enhancements like customizable fees, scheduled fee collection, and personalized lock-in periods could drive further adoption.

📊 Understanding Vault Performance

To help the community compare different Vaults, we analyzed their risk-adjusted performance, focusing on:

✅ Only 24 strategies met the defined criteria of being at least 6 months old, having $20k+ TVL, and showing profitability since inception.

📊 Returns vs. risk: Some vaults showed high returns but extreme volatility, with some exceeding 500% annualized volatility, making consistency a key challenge.

💡 Sharpe ratio analysis helped identify the most consistent performers, where Growi HF had the highest Sharpe among all Vaults analyzed.

📊 Compared to HyperLiquid’s own Vault, Growi HF delivered higher yield (over 100%) with slightly lower risk (19%), based on direct data from the HL Vault API. This shows that independent Vaults can provide strong opportunities beyond HL’s strategies.

At Growi.fi, we believe transparency in DeFi investments benefits everyone. Our analysis shows that HyperLiquid Vaults hold great potential, and careful strategy selection is key to maximizing returns.

🚀 Growi HF stands as a top performer, balancing strong yield with controlled risk.

Preparing the Data

General HyperLiquid Metrics on DeFiLlama

First, we extract global data from DeFiLlama to analyze HyperLiquid's Total Value Locked (TVL). Key variables to consider: HL_global_tvl, formatted_tvl, and HL_TVL_formatted_date.

import requests from datetime import datetime # Function to get ordinal suffix for a day def ordinal(n): if 11 <= n % 100 <= 13: return f"{n}th" elif n % 10 == 1: return f"{n}st" elif n % 10 == 2: return f"{n}nd" elif n % 10 == 3: return f"{n}rd" else: return f"{n}th" # Function to format large numbers into billions or millions def format_large_number(value, decimals=1): abs_value = abs(value) # Tomar el valor absoluto para el formateo format_str = f".{decimals}f" # Crear la cadena de formato dinámicamente if abs_value >= 1e9: formatted_value = f"{abs_value / 1e9:{format_str}} billion" elif abs_value >= 1e6: formatted_value = f"{abs_value / 1e6:{format_str}} million" else: formatted_value = f"{abs_value:{format_str}}" # Restaurar el signo negativo si el valor original era negativo return f"-{formatted_value}" if value < 0 else formatted_value # Variables to hold TVL and date HL_global_tvl = None HL_TVL_formatted_date = None # Fetch data from the API url = "https://api.llama.fi/protocol/hyperliquid" response = requests.get(url) if response.status_code == 200: data = response.json() # Extract the TVL history tvl_history = data.get('tvl', []) if tvl_history: # Get the last entry last_entry = tvl_history[-1] timestamp = last_entry['date'] HL_global_tvl = last_entry['totalLiquidityUSD'] # Convert to readable format date_obj = datetime.utcfromtimestamp(timestamp) day = ordinal(date_obj.day) HL_TVL_formatted_date = f"{day} of {date_obj.strftime('%B')} of {date_obj.year}" # Format the TVL formatted_tvl = format_large_number(HL_global_tvl) # Create the desired text text = f"As of {HL_TVL_formatted_date}, the TVL in HyperLiquid is {formatted_tvl}." print(text) else: print("No TVL data available.") else: print(f"Failed to fetch data. Status code: {response.status_code}") # At this point, you can use `HL_global_tvl` and `HL_TVL_formatted_date` later in your program.

Extracting Vault Data from HyperLiquid

We retrieve data from all pools on HyperLiquid to build a complete dataset of existing Vaults.

🔹 Key output: df_vaultsHL – a DataFrame containing data for all Vaults.

Next, we extract global Vault data from HyperLiquid’s https://stats-data.hyperliquid.xyz/Mainnet/vaults. This allows us to analyze aggregated Vault statistics and better understand the overall distribution of assets.

import requests import datetime import pandas as pd def fetch_all_vaults(url): """Fetches all vault data from the given URL.""" try: response = requests.get(url) if response.status_code == 200: return response.json() else: print(f"Error fetching data: Status code {response.status_code}") return None except Exception as e: print(f"Connection error: {e}") return None def process_vaults_data(vaultsHL): """Processes vault data into a structured DataFrame.""" vaults_dict = {} for vault in vaultsHL: summary = vault["summary"] vault_address = summary["vaultAddress"] # Convert createTimeMillis to date format create_time_millis = summary["createTimeMillis"] dt = datetime.datetime.utcfromtimestamp(create_time_millis / 1000.0) create_time_str = dt.strftime('%Y-%m-%d') vaults_dict[vault_address] = { "vaultAddress": vault_address, "name": summary["name"], "leader": summary["leader"], "tvl": summary["tvl"], "isClosed": summary["isClosed"], "relationship": summary["relationship"]["type"], "createDate": create_time_str, "apr": vault["apr"], } # Convert PnLs list into dictionary pnls_dict = {entry[0]: entry[1] for entry in vault["pnls"]} vaults_dict[vault_address]["pnls"] = pnls_dict # Convert to DataFrame data_for_df = [] for vault_address, vault_data in vaults_dict.items(): row = vault_data.copy() row["allTimeLastVal"] = vault_data["pnls"].get("allTime", [None])[-1] row["perpAllTimeLastVal"] = vault_data["pnls"].get("perpAllTime", [None])[-1] data_for_df.append(row) df_vaultsHL = pd.DataFrame(data_for_df) # Convert columns to appropriate data types df_vaultsHL["tvl"] = pd.to_numeric(df_vaultsHL["tvl"], errors="coerce") df_vaultsHL["allTimeLastVal"] = pd.to_numeric(df_vaultsHL["allTimeLastVal"], errors="coerce") df_vaultsHL = df_vaultsHL.dropna(subset=["tvl", "allTimeLastVal"]) df_vaultsHL["createDate"] = pd.to_datetime(df_vaultsHL["createDate"], errors="coerce") df_vaultsHL["vaultAgeDays"] = (pd.Timestamp.today() - df_vaultsHL["createDate"]).dt.days return df_vaultsHL # Lo aplicamos a nuestro caso: url = "https://stats-data.hyperliquid.xyz/Mainnet/vaults" vaultsHL = fetch_all_vaults(url) if vaultsHL: df_vaultsHL = process_vaults_data(vaultsHL)

Breaking Down the Financial Performance of HyperLiquid Vaults

HyperLiquid has been gaining popularity for some time, and its recent airdrop has further increased its visibility. This event gave away hundreds of millions of dollars to participants. As the token price increased, the total value of the airdrop grew to several billion dollars, benefiting more than 94,000 addresses.

Since then, people have been closely watching HyperLiquid's trading volume and fees. These numbers help estimate how much the HYPE token might be worth. However, one important part of HyperLiquid that many have overlooked is its Vaults.

While the DEX holds most of the total value locked (TVL), we believe Vaults could play a big role in HyperLiquid’s future growth. More businesses are starting to build on HyperLiquid—just like we have at Growi.fi—which means Vaults could become much more important.

In this analysis, we will explore HyperLiquid Vaults from an investor perspective. Our goal is to provide clear insights that help compare different Vaults, identify the best-performing ones, and understand broader trends.

The steps in this analysis are: 1. Present basic statistics about HyperLiquid and its Vaults. 2. Analyze all existing Vaults and summarize key numbers. 3. Select Vaults based on key criteria such as age, activity status, and TVL. 4. Evaluate the financial performance of these selected Vaults and highlight the top performers.

Overview of HyperLiquid Vaults: Basic Statistics and Key Insights

Calculating General Statistics for All HyperLiquid Vaults:

Analyzing Vault TVL – Measuring the total value locked in Vaults and its proportion relative to HyperLiquid’s total TVL.

# Filter out vaults where relationship is "child" filtered_vaults = df_vaultsHL[df_vaultsHL["relationship"] != "child"] # Compute total TVL for filtered vaults total_tvl_vaults = filtered_vaults["tvl"].sum() # Print formatted result print(f"Total TVL (excluding 'child' vaults): ${total_tvl_vaults:,.2f}")

# Format the output formatted_tvl_vaults = format_large_number(total_tvl_vaults) # Display the result print(f"Total TVL: {formatted_tvl_vaults}") # Save the formatted number in a variable total_tvl_vaults_formatted = formatted_tvl_vaults # qué porcentaje del TVL de HL se ha invertido en Vaults? # Calculate the percentage of the total TVL percentage_tvl_vaults = (total_tvl_vaults / HL_global_tvl) * 100 # Format the output formatted_percentage_tvl_vaults = "{:.1f}%".format(percentage_tvl_vaults) # Display the result print(f"Total TVL: {formatted_percentage_tvl_vaults}")

Counting Vaults – Determining the total number of Vaults and how many are currently open.

total_number_vaults = len(df_vaultsHL) print(f"Total number of vaults: {total_number_vaults}") open_number_vaults = df_vaultsHL[df_vaultsHL["isClosed"] == False].shape[0] print(f"Number of open vaults: {open_number_vaults}") # percentage of open vaults percentage_open_vaults = (open_number_vaults / total_number_vaults) * 100 formatted_percentage_open_vaults = "{:.1f}%".format(percentage_open_vaults) print(f"Percentage of open vaults: {formatted_percentage_open_vaults}")

Filtering for Active Vaults – Removing closed Vaults

df_vaultsHL=df_vaultsHL[df_vaultsHL["isClosed"] == False] print(df_vaultsHL.shape[0]) df_vaultsHL = df_vaultsHL.drop(columns=["isClosed"]) # dropping the classification column, as it no longer holds relevant information. print(df_vaultsHL.columns)

Using DefiLlama's updated data and the HyperLiquid API, we will examine key metrics such as TVL, age, and profitability across all Vaults. Let us start with TVL:

TVL

To better understand the distribution of TVL across Vaults, we begin by ranking the top 10 Vaults by TVL:

# Sort DataFrame from highest to lowest TVL df_vaultsHL = df_vaultsHL.sort_values(by="tvl", ascending=False) df_vaultsHL.head()

The largest Vaults, with a significant difference from the rest, belong to HyperLiquid itself. These include HLP, which acts as the parent Vault for other strategies such as A, B, and Liquidator. The total TVL of HyperLiquid Vaults is represented by HLP, which includes the TVL of its child strategies.

By removing HyperLiquid’s own Vaults, we get a different perspective on the remaining Vaults as a group.

df_vaultsHL_HLP = df_vaultsHL.iloc[:1].copy() # conservo sólo el HLP para luego ver el performance financiero df_vaultsHL = df_vaultsHL.iloc[4:].reset_index(drop=True) total_tvl_vaults = df_vaultsHL["tvl"].sum() # ahora sin HL! formatted_tvl_vaults = format_large_number(total_tvl_vaults) # Display the result print(f"Total TVL: {formatted_tvl_vaults}") # Save the formatted number in a variable total_tvl_vaults_formatted = formatted_tvl_vaults # qué porcentaje del TVL de HL se ha invertido en Vaults? # Calculate the percentage of the total TVL percentage_tvl_vaults = (total_tvl_vaults / HL_global_tvl) * 100 # Format the output formatted_percentage_tvl_vaults = "{:.1f}%".format(percentage_tvl_vaults) # Display the result print(f"Total TVL: {formatted_percentage_tvl_vaults}")

Vaults offer a clear and transparent way for other protocols to build on HyperLiquid, as they allow easy tracking of strategies. However, more flexibility could encourage broader adoption. Features like customizable fees, scheduled fee collection, and personalized lock-in periods could make Vaults even more attractive. While Accounts can also be used for building on HyperLiquid, they lack the visibility and auditability of Vaults.

The following graph shows the distribution of Vaults by TVL (excluding HyperLiquid’s own Vaults). As expected, the distribution follows a Pareto-like pattern, with a few large Vaults and many smaller ones.

Let us illustrate this further with a Pareto Chart:

Determining the 80% Cutoff in a Pareto Chart:

import numpy as np # Sort vaults by TVL in descending order df_vaultsHL_sorted = df_vaultsHL.sort_values(by="tvl", ascending=False) # Calculate cumulative TVL percentage cumulative_tvl = df_vaultsHL_sorted["tvl"].cumsum() total_tvl = cumulative_tvl.iloc[-1] cumulative_percentage = (cumulative_tvl / total_tvl) * 100 # Find the index where cumulative percentage reaches 80% index_80_tvl = np.argmax(cumulative_percentage >= 80) # Calculate the percentage of vaults contributing to 80% of TVL percent_vaults_for_80_tvl = (index_80_tvl / len(df_vaultsHL_sorted)) * 100 number_vaults_for_80_tvl = open_number_vaults * percent_vaults_for_80_tvl / 100 TVL_active_80 = 0.80 * total_tvl TVL_active_80 = format_large_number(TVL_active_80) print(percent_vaults_for_80_tvl) print(f"{number_vaults_for_80_tvl:.0f}") print(TVL_active_80)

Age

# Oldest vault (maximum age in years) oldest_vault_days = df_vaultsHL["vaultAgeDays"].max() oldest_vault_years = oldest_vault_days / 365 # Convert days to years # Newest vault (minimum age in days) newest_vault_days = df_vaultsHL["vaultAgeDays"].min() # Average age of vaults (in months) average_age_days = df_vaultsHL["vaultAgeDays"].mean() average_age_months = average_age_days / 30 # Convert days to months # Median age of vaults (in months) median_age_days = df_vaultsHL["vaultAgeDays"].median() median_age_months = median_age_days / 30 # Convert days to months # Print results with formatting print(f"Oldest Vault Age: {oldest_vault_days} days (~{oldest_vault_years:.1f} years)") print(f"Newest Vault Age: {newest_vault_days} days") print(f"Average Vault Age: {average_age_days:.2f} days (~{average_age_months:.1f} months)") print(f"Median Vault Age: {median_age_days} days (~{median_age_months:.1f} months)")

Next, we examine the age of the Vaults:

Most Vaults are relatively new, though there are some exceptions. The histogram below shows the distribution of Vault ages:

Interestingly, most Vaults are only 1-3 months old, but there is also a peak around the one-year mark.

Below is a list of the Vaults that have been active the longest:

df_vaultsHL.sort_values(by="vaultAgeDays", ascending=False).head(5)

APR & Profitability

HyperLiquid provides APR data for all Vaults. However, it is important to note that APR is calculated based only on the last 30 days, which does not accurately reflect long-term performance. Still, let us take a quick look at the number of Vaults currently showing a positive APR.

num_positive_apr = (df_vaultsHL["apr"] > 0).sum() print(f"Number of vaults with positive APR: {num_positive_apr}") # veo ahora qué porcentaje significa: percentage_positive_apr = (num_positive_apr / open_number_vaults) * 100 print(f"Percentage of open vaults with positive APR: {percentage_positive_apr:.1f}%") max_apr = df_vaultsHL["apr"].max()*100 min_apr = df_vaultsHL["apr"].min()*100 print(f"Maximum APR: {max_apr:.1f}%") print(f"Minimum APR: {min_apr:.1f}%") average_apr = df_vaultsHL["apr"].mean()*100 print(f"Average APR: {average_apr:.1f}%") median_apr = df_vaultsHL["apr"].median()*100 print(f"Median APR: {median_apr:.1f}%")

A more useful metric is the total profit and loss (PnL) accumulated by each Vault over its lifetime. This gives a clearer picture of actual earnings.

First, let us determine if HyperLiquid Vaults (excluding HyperLiquid’s own Vaults) have generated net positive wealth.

total_all_time_last_val = df_vaultsHL["allTimeLastVal"].sum() print(format_large_number(total_all_time_last_val)) min_val = df_vaultsHL["allTimeLastVal"].min() max_val = df_vaultsHL["allTimeLastVal"].max() avg_val = df_vaultsHL["allTimeLastVal"].mean() median_val = df_vaultsHL["allTimeLastVal"].median() print(f"Min: {format_large_number(min_val)}") print(f"Max: {format_large_number(max_val)}") print(f"Average: {format_large_number(avg_val)}") print(f"Median: {format_large_number(median_val)}")

# Count total number of values total_values = len(df_vaultsHL["allTimeLastVal"]) # Count positive values positive_values = (df_vaultsHL["allTimeLastVal"] > 0).sum() # Calculate percentage positive_percentage = (positive_values / total_values) * 100 print(f"Percentage of positive values: {positive_percentage:.2f}%")

The following histogram shows the distribution of PnL across all Vaults:

The PnL distribution resembles a normal curve with a slight skew toward negative results.

Measuring yield since inception would provide better insights, but using aggregated data from HyperLiquid makes this challenging. Deposits and withdrawals significantly impact TVL and PnL, making general statistics less reliable.

To gain a more accurate understanding of each Vault’s actual performance, we will now conduct a detailed analysis using direct API calls to individual Vaults within HyperLiquid. The next section will focus on this in-depth evaluation.

Analysis of the financial performance (including risks) of selected vaults

Selection criteria

In this section, we analyze the financial performance of Vaults that meet specific criteria. We have defined what we consider reasonable for assessing a Vault's viability:

At least 6 months old, ensuring enough time to gather meaningful performance statistics.

At least $20,000 in TVL at the time of the study, assuming this represents a serious level of investment.

from datetime import datetime, timedelta # Define the filtering criteria six_months_ago = datetime.today() - timedelta(days=6*30) # Approximate 6 months df_vaultsHL = df_vaultsHL[ (df_vaultsHL["createDate"] <= six_months_ago) & # Vault age at least 6 months (df_vaultsHL["tvl"] >= 20000) # TVL at least $20,000 ] # Print the number of strategies that fulfill the criteria num_strategies_meeting_criteria = len(df_vaultsHL) print(f"Number of strategies fulfilling the criteria: {num_strategies_meeting_criteria}")

We then apply an additional filter: the vault must also have been profitable over its (minimum six-month) history.

# Apply additional filtering for positive PnL df_vaultsHL = df_vaultsHL[df_vaultsHL["allTimeLastVal"] > 0] # Check how many strategies fulfill the criteria num_strategies_meeting_criteria_and_positive = len(df_vaultsHL) print(f"Number of strategies meeting all criteria: {num_strategies_meeting_criteria_and_positive}")

Since the number is small, we list them here:

from tabulate import tabulate # Extract the strategy names strategy_names = df_vaultsHL["name"].tolist() # Split into rows of 4 columns rows = [strategy_names[i:i+4] for i in range(0, len(strategy_names), 4)] # Print using tabulate without index print(tabulate(rows, tablefmt="grid"))

# Extract all vault addresses from df_vaultsHL vault_addresses = df_vaultsHL["vaultAddress"].tolist() # Display the extracted vault addresses print(len(vault_addresses)) print(vault_addresses)

Among them, Growi.HF (https://hf.growi.fi/) is our own developed strategy.

To compare performance, we also include HyperLiquid’s own Vault (HLP) alongside the selected strategies.

vault_addresses.append("0xdfc24b077bc1425ad1dea75bcb6f8158e10df303") df_vaultsHL = pd.concat([df_vaultsHL, df_vaultsHL_HLP], ignore_index=True) print(len(vault_addresses)) print(len(df_vaultsHL))

Data Processing & Filtering Challenges

To extract relevant financial parameters for our analysis, we processed the data. However, some Vaults encountered issues in data retrieval and processing, and as a result, they will not be included in our analysis:

def transform_vault_details_flat(vault_details): """ Transforms the input JSON (vault_details) into a structured and flattened Python dictionary with optimized data organization for the portfolio section. Args: vault_details (dict): The input JSON-like object containing vault details. Returns: dict: A flattened dictionary with cleaned and organized data. """ vault_details_dic = { "name": vault_details["name"], "vaultAddress": vault_details["vaultAddress"], "leader": vault_details["leader"], "description": vault_details["description"], "portfolio": { timeframe: { "accountValueHistory": { "timestamps": [entry[0] for entry in details["accountValueHistory"]], "values": [float(entry[1]) for entry in details["accountValueHistory"]], }, "pnlHistory": { "timestamps": [entry[0] for entry in details["pnlHistory"]], "values": [float(entry[1]) for entry in details["pnlHistory"]], }, "vlm": float(details["vlm"]), } for timeframe, details in vault_details["portfolio"] # Unpack list into timeframe and details }, "apr": float(vault_details["apr"]), "followerState": vault_details.get("followerState"), # Use .get() to handle nullable "leaderFraction": float(vault_details["leaderFraction"]), "leaderCommission": float(vault_details["leaderCommission"]), "followers": [ { "user": follower["user"], "vaultEquity": float(follower["vaultEquity"]), "pnl": float(follower["pnl"]), "allTimePnl": float(follower["allTimePnl"]), "daysFollowing": follower["daysFollowing"], "vaultEntryTime": follower["vaultEntryTime"], "lockupUntil": follower["lockupUntil"], } for follower in vault_details["followers"] ], "maxDistributable": float(vault_details["maxDistributable"]), "maxWithdrawable": float(vault_details["maxWithdrawable"]), "isClosed": int(vault_details["isClosed"]), "relationship": { "type": vault_details["relationship"]["type"] }, "allowDeposits": int(vault_details["allowDeposits"]), "alwaysCloseOnWithdraw": int(vault_details["alwaysCloseOnWithdraw"]), } return vault_details_dic

import json import pandas as pd import numpy as np def filter_vault_details(vault_details): """ Filtra el diccionario vault_details conservando todos los valores excepto en 'portfolio', donde solo mantiene 'allTime' y calcula métricas financieras adicionales. Args: vault_details (dict): El diccionario de detalles de la vault. Returns: dict: Diccionario filtrado con solo 'allTime' dentro de 'portfolio' y con las siguientes métricas añadidas: - deltaTime: Diferencia en días entre timestamps consecutivos en accountValueHistory. - deltaTVL: Diferencia en valores consecutivos de accountValueHistory/values. - deltaPNL: Diferencia en valores consecutivos de pnlHistory/values. - NetFlows: Diferencia entre deltaTVL y deltaPNL. - TWR: Retorno total ponderado por tiempo, calculado como deltaPNL / (NetFlows + AccountValue[t-1]). - TWR_wkly: Ajuste semanal del TWR, usando la fórmula (1 + TWR)^(7/deltaTime) - 1. - TWR_acc: Retorno acumulado, comenzando en 1 y multiplicando por (1 + TWR) en cada iteración. - DrawDown: Pérdida relativa desde el máximo histórico de TWR_acc en cada punto. - values_tvl: Valores históricos de accountValueHistory. - MDD: Maximum Drawdown, el mínimo de la columna DrawDown. - RoMaD: Ratio de TWR_acc final sobre MDD. - wkly_average: Promedio de TWR_wkly. - wkly_volatility: Desviación estándar de TWR_wkly. - wkly_sharpe: Ratio de wkly_average sobre wkly_volatility. - wkly_volatility_neg: Desviación estándar de los valores negativos de TWR_wkly. - wkly_sortino: Ratio de wkly_average sobre wkly_volatility_neg. - ann_yield: Rendimiento anualizado. - ann_volatility: Volatilidad anualizada. - ann_sharpe: Sharpe anualizado. - DD_TWR_acc: Máxima caída absoluta de TWR_acc sin hacerlo porcentual. - Calmar_VGM: Ratio de (último valor de TWR_acc - 1) sobre DD_TWR_acc. """ filtered_vault_details = {key: value for key, value in vault_details.items() if key != "portfolio"} if "portfolio" in vault_details and "allTime" in vault_details["portfolio"]: filtered_vault_details["portfolio"] = {"allTime": vault_details["portfolio"]["allTime"]} # Calcular deltaTime en días timestamps = filtered_vault_details["portfolio"]["allTime"]["accountValueHistory"]["timestamps"] deltaTime = [(timestamps[i] - timestamps[i-1]) / 86400000 for i in range(1, len(timestamps))] filtered_vault_details["portfolio"]["allTime"]["deltaTime"] = deltaTime # Obtener valores TVL values_tvl = filtered_vault_details["portfolio"]["allTime"]["accountValueHistory"]["values"] filtered_vault_details["portfolio"]["allTime"]["values_tvl"] = values_tvl # Calcular deltaTVL deltaTVL = [values_tvl[i] - values_tvl[i-1] for i in range(1, len(values_tvl))] filtered_vault_details["portfolio"]["allTime"]["deltaTVL"] = deltaTVL # Calcular deltaPNL values_pnl = filtered_vault_details["portfolio"]["allTime"]["pnlHistory"]["values"] deltaPNL = [values_pnl[i] - values_pnl[i-1] for i in range(1, len(values_pnl))] filtered_vault_details["portfolio"]["allTime"]["deltaPNL"] = deltaPNL # Calcular NetFlows como deltaTVL - deltaPNL netFlows = [deltaTVL[i] - deltaPNL[i] for i in range(len(deltaTVL))] filtered_vault_details["portfolio"]["allTime"]["NetFlows"] = netFlows # Calcular TWR twr = [deltaPNL[i+1] / (netFlows[i+1] + values_tvl[i+1]) for i in range(len(deltaPNL)-1)] filtered_vault_details["portfolio"]["allTime"]["TWR"] = twr # Calcular TWR_wkly twr_wkly = [(1 + twr[i])**(7 / deltaTime[i+1]) - 1 for i in range(len(twr))] filtered_vault_details["portfolio"]["allTime"]["TWR_wkly"] = twr_wkly # Calcular estadísticas semanales wkly_average = np.mean(twr_wkly) wkly_volatility = np.std(twr_wkly) wkly_sharpe = wkly_average / wkly_volatility if wkly_volatility != 0 else None wkly_volatility_neg = np.std([x for x in twr_wkly if x < 0]) wkly_sortino = wkly_average / wkly_volatility_neg if wkly_volatility_neg != 0 else None # Calcular TWR_acc twr_acc = [1] for i in range(1, len(twr)+1): twr_acc.append(twr_acc[i-1] * (1 + twr[i-1])) filtered_vault_details["portfolio"]["allTime"]["TWR_acc"] = twr_acc # Calcular DrawDown max_twr_acc = [max(twr_acc[:i+1]) for i in range(len(twr_acc))] drawdown = [(twr_acc[i] - max_twr_acc[i]) / max_twr_acc[i] if max_twr_acc[i] != 0 else 0 for i in range(len(twr_acc))] filtered_vault_details["portfolio"]["allTime"]["DrawDown"] = drawdown # Calcular DD_TWR_acc como el peor drawdown absoluto sin porcentaje dd_twr_acc = max([max_twr_acc[i] - twr_acc[i] for i in range(len(twr_acc))]) # Calcular métricas adicionales MDD = min(drawdown) ann_yield = (twr_acc[-1])**(365 / ((timestamps[-1] - timestamps[0]) / 86400000)) - 1 ann_volatility = wkly_volatility * np.sqrt(54) ann_sharpe = ann_yield / ann_volatility if ann_volatility != 0 else None RoMaD = ann_yield / abs(MDD) if MDD != 0 else None Calmar_VGM = (twr_acc[-1] - 1) / abs(dd_twr_acc) if dd_twr_acc != 0 else None filtered_vault_details["portfolio"]["allTime"].update({ "MDD": MDD, "RoMaD": RoMaD, "wkly_average": wkly_average, "wkly_volatility": wkly_volatility, "wkly_sharpe": wkly_sharpe, "wkly_volatility_neg": wkly_volatility_neg, "wkly_sortino": wkly_sortino, "ann_yield": ann_yield, "ann_volatility": ann_volatility, "ann_sharpe": ann_sharpe, "DD_TWR_acc": dd_twr_acc, "Calmar_VGM": Calmar_VGM }) return filtered_vault_details

import requests import numpy as np def get_vault_details(vault_address): """ Fetches vault details from HyperLiquid API. """ url = "https://api-ui.hyperliquid.xyz/info" payload = { "type": "vaultDetails", "vaultAddress": vault_address } response = requests.post(url, json=payload) if response.status_code == 200: return response.json() else: print(f"Error fetching vault {vault_address}: {response.status_code}") return None def analyze_multiple_vaults(vault_addresses): """ Fetches details for multiple vaults, processes them, and returns aggregated results. """ all_vaults_data = {} error_vaults = [] for address in vault_addresses: try: vault_details = get_vault_details(address) if vault_details: vault_details_dic = transform_vault_details_flat(vault_details) filtered_vault_details = filter_vault_details(vault_details_dic) all_vaults_data[address] = filtered_vault_details except Exception as e: print(f"Error processing vault {address}: {e}") error_vaults.append(address) continue return all_vaults_data, error_vaults

vaults_analysis, error_vaults = analyze_multiple_vaults(vault_addresses)

# Filter the vaults with errors from df_vaultsHL error_vaults_df = df_vaultsHL[df_vaultsHL["vaultAddress"].isin(error_vaults)][["name", "vaultAddress"]] # Display the DataFrame with vaults that had errors print(error_vaults_df.to_string(index=False))

(Funny name if you speak Spanish!)

Risk-adjusted financial performance

Sorting by annualized yield, we see some staggering returns! Here are the top five:

import pandas as pd from tabulate import tabulate # Extract ann_yield and strategy names from vaults_analysis strategy_yield_data = [] for vault, data in vaults_analysis.items(): if "ann_yield" in data["portfolio"]["allTime"]: strategy_row = df_vaultsHL[df_vaultsHL["vaultAddress"] == vault] # Ensure the vault address exists in df_vaultsHL before proceeding if not strategy_row.empty: strategy_name = strategy_row["name"].values[0] ann_yield_value = int(round(data["portfolio"]["allTime"]["ann_yield"] * 100, 0)) # Convert to percentage, round to int strategy_yield_data.append((strategy_name, ann_yield_value)) # Convert to DataFrame and sort by ann_yield df_ann_yield = pd.DataFrame(strategy_yield_data, columns=["Strategy Name", "Ann. Yield (%)"]) # Ensure we have at least 5 rows before applying head(5) df_ann_yield = df_ann_yield.sort_values(by="Ann. Yield (%)", ascending=False).head(min(5, len(df_ann_yield))) # Format numbers with thousands separator and right-aligned df_ann_yield["Ann. Yield (%)"] = df_ann_yield["Ann. Yield (%)"].apply(lambda x: f"{x:>10,}") # Display the top 5 strategies sorted by ann_yield print(tabulate(df_ann_yield, headers="keys", tablefmt="grid", showindex=False, stralign="right"))

However, we need to put these returns in context by including volatility:

import pandas as pd from tabulate import tabulate # Extract ann_yield, ann_volatility, and strategy names from vaults_analysis strategy_yield_data = [] for vault, data in vaults_analysis.items(): if "ann_yield" in data["portfolio"]["allTime"] and "ann_volatility" in data["portfolio"]["allTime"]: strategy_row = df_vaultsHL[df_vaultsHL["vaultAddress"] == vault] strategy_name = strategy_row["name"].values[0] ann_yield_value = int(round(data["portfolio"]["allTime"]["ann_yield"] * 100, 0)) # Convert to percentage, round to int ann_volatility_value = int(round(data["portfolio"]["allTime"]["ann_volatility"] * 100, 0)) # Convert to percentage, round to int age_days = strategy_row["vaultAgeDays"].values[0] # Extract age in days age_months = round(age_days / 30, 1) # Convert age to months strategy_yield_data.append((strategy_name, ann_yield_value, ann_volatility_value, age_months)) # Convert to DataFrame and sort by ann_yield df_ann_yield = pd.DataFrame(strategy_yield_data, columns=["Strategy Name", "Ann. Yield (%)", "Ann. Volatility (%)", "Age (Months)"]) # Ensure we have at least 5 rows before applying head(5) df_ann_yield = df_ann_yield.sort_values(by="Ann. Yield (%)", ascending=False).head(5) # Format numbers with thousands separator and right-aligned df_ann_yield["Ann. Yield (%)"] = df_ann_yield["Ann. Yield (%)"].apply(lambda x: f"{x:>10,}") df_ann_yield["Ann. Volatility (%)"] = df_ann_yield["Ann. Volatility (%)"].apply(lambda x: f"{x:>10,}") df_ann_yield["Age (Months)"] = df_ann_yield["Age (Months)"].apply(lambda x: f"{x:>10.1f}") # Display the top 5 strategies sorted by ann_yield print(tabulate(df_ann_yield, headers="keys", tablefmt="grid", showindex=False, stralign="right"))

These Vaults also exhibit extreme volatilities. A volatility of 800% with an average return of 7,000% represents the standard deviation of returns over a year. Theoretically, this means there is a 32% probability that the return in a year falls outside the range of 7,000% ± 800%.

At first glance, this may seem like a great deal — after all, you always win, right? But such large swings usually indicate inconsistency, with extreme ups and downs.

Is Volatility Underestimated?: In reality, volatility in all strategies is likely even higher. The HyperLiquid API (and website) does not use traditional financial "candles" (open, high, low, close) but instead samples historical PnL or TVL. This means the actual highs and lows are likely greater than the reported figures.

Below, we visualize annual yield vs. annualized volatility:

# Extract ann_yield and ann_volatility from vaults_analysis ann_yield = [] ann_volatility = [] vault_names = [] for vault, data in vaults_analysis.items(): if "ann_yield" in data["portfolio"]["allTime"] and "ann_volatility" in data["portfolio"]["allTime"]: ann_yield.append(data["portfolio"]["allTime"]["ann_yield"]) ann_volatility.append(data["portfolio"]["allTime"]["ann_volatility"]) vault_names.append(df_vaultsHL[df_vaultsHL["vaultAddress"] == vault]["name"].values[0]) # Compute efficiency ratio (yield/volatility) efficiency_ratios = np.array(ann_yield) / np.array(ann_volatility) # Find the most efficient strategy max_efficiency_idx = np.argmax(efficiency_ratios) max_efficiency_ratio = efficiency_ratios[max_efficiency_idx] # Convert ann_yield and ann_volatility to percentages ann_yield_pct = [y * 100 for y in ann_yield] ann_volatility_pct = [v * 100 for v in ann_volatility] # Compute efficiency ratio (yield/volatility) in percentage terms efficiency_ratios_pct = np.array(ann_yield_pct) / np.array(ann_volatility_pct) # Find the most efficient strategy max_efficiency_idx = np.argmax(efficiency_ratios_pct) max_efficiency_ratio_pct = efficiency_ratios_pct[max_efficiency_idx]

import matplotlib.ticker as mtick # Generate efficiency frontier values in percentage terms with an extended range up to 130% x_values_extended = np.logspace(0, np.log10(130), 100) # Values from 1% to 130% y_values_extended = x_values_extended * max_efficiency_ratio_pct # Plot ann_yield vs ann_volatility plt.figure(figsize=(10, 6)) plt.scatter(ann_volatility_pct, ann_yield_pct, color='blue', alpha=0.7, label="Vault Strategies") # Add labels for each point for i, name in enumerate(vault_names): plt.annotate(name, (ann_volatility_pct[i], ann_yield_pct[i]), fontsize=9, alpha=0.75) # Set log scale for axes plt.xscale("log") plt.yscale("log") # Format axes labels to include percentage signs plt.gca().xaxis.set_major_formatter(mtick.PercentFormatter()) plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter()) plt.xlabel("Annualized Volatility (log scale)") plt.ylabel("Annualized Yield (log scale)") plt.title("Annualized Yield vs. Volatility for Vault Strategies (Log Scale)") plt.grid(True, which="both", linestyle="--", linewidth=0.5) plt.legend() # Show the plot plt.show()

For most investors, choosing a strategy with volatility above 50% might not be ideal. A strong strategy should be consistent, with returns behaving predictably rather than wildly fluctuating.

Understanding the Risk-Return Trade-Off

The graph clearly shows that higher returns come with higher volatility (note the log scale axes). A strategy is superior when, for the same level of risk, it achieves a higher yield (i.e., for a fixed x-axis value, the higher y-axis points are better).

This leads us to the Sharpe Ratio, a widely used measure that compares returns relative to risk:

Since quantitative strategies typically ignore the risk-free rate, we simplify the formula to:

This ratio compares average returns to standard deviation, where higher values indicate a more stable and reliable strategy.

Other risk-adjusted metrics, such as Sortino Ratio, Calmar Ratio, or RoMaD, also exist. For this analysis, we focus on Sharpe Ratio, but future studies could incorporate these alternatives.

Now, let’s zoom in on strategies with volatilities below 100%:

filtered_ann_yield = [] filtered_ann_volatility = [] filtered_vault_names = [] for vault, data in vaults_analysis.items(): if "ann_yield" in data["portfolio"]["allTime"] and "ann_volatility" in data["portfolio"]["allTime"]: ann_vol = data["portfolio"]["allTime"]["ann_volatility"] if ann_vol < 1: # Filtering condition: ann_volatility < 50% filtered_ann_yield.append(data["portfolio"]["allTime"]["ann_yield"] * 100) # Convert to percentage filtered_ann_volatility.append(ann_vol * 100) # Convert to percentage filtered_vault_names.append(df_vaultsHL[df_vaultsHL["vaultAddress"] == vault]["name"].values[0])

import matplotlib.ticker as mtick # Plot ann_yield vs ann_volatility for filtered vaults without log scale and including (0,0) plt.figure(figsize=(10, 6)) plt.scatter(filtered_ann_volatility, filtered_ann_yield, color='blue', alpha=0.7, label="Filtered Vault Strategies") # Add labels for each point for i, name in enumerate(filtered_vault_names): plt.annotate(name, (filtered_ann_volatility[i], filtered_ann_yield[i]), fontsize=9, alpha=0.75) # Set linear scale for axes and include (0,0) in the graph plt.xlim(0, max(filtered_ann_volatility) * 1.1) # Extend slightly beyond max value plt.ylim(0, max(filtered_ann_yield) * 1.1) # Format axes labels to include percentage signs plt.gca().xaxis.set_major_formatter(mtick.PercentFormatter()) plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter()) plt.xlabel("Annualized Volatility") plt.ylabel("Annualized Yield") plt.title("Annualized Yield vs. Volatility (Filtered, Linear Scale)") plt.grid(True, linestyle="--", linewidth=0.5) plt.legend() # Show the plot plt.show()

Identifying the Best Strategy Using Risk-Adjusted Returns

Using the Sharpe Ratio, the best-performing strategy corresponds to the point with the highest slope from (0,0) in our chart.

Let’s visualize this:

# Ensure vaults_analysis is available and contains relevant data import matplotlib.ticker as mtick # Compute efficiency ratio (yield/volatility) for filtered vaults if filtered_ann_yield and filtered_ann_volatility: efficiency_ratios = np.array(filtered_ann_yield) / np.array(filtered_ann_volatility) # Find the most efficient strategy max_efficiency_idx = np.argmax(efficiency_ratios) max_efficiency_ratio = efficiency_ratios[max_efficiency_idx] # Generate efficiency frontier values x_values = np.linspace(0, max(filtered_ann_volatility) * 1.1, 100) # From 0 to slightly beyond max volatility y_values = x_values * max_efficiency_ratio # Plot ann_yield vs ann_volatility for filtered vaults plt.figure(figsize=(10, 6)) plt.scatter(filtered_ann_volatility, filtered_ann_yield, color='blue', alpha=0.7, label="Filtered Vault Strategies") # Add labels for each point for i, name in enumerate(filtered_vault_names): plt.annotate(name, (filtered_ann_volatility[i], filtered_ann_yield[i]), fontsize=9, alpha=0.75) # Plot efficiency frontier plt.plot(x_values, y_values, linestyle="--", color="red", label="Best Risk-Adjusted Vault") # Set linear scale for axes and include (0,0) in the graph plt.xlim(0, max(filtered_ann_volatility) * 1.1) # Extend slightly beyond max value plt.ylim(0, max(filtered_ann_yield) * 1.1) plt.xlabel("Annualized Volatility") plt.ylabel("Annualized Yield") plt.title("Annualized Yield vs. Volatility (Filtered, Linear Scale)") # Format axes labels to include percentage signs plt.gca().xaxis.set_major_formatter(mtick.PercentFormatter()) plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter()) plt.grid(True, linestyle="--", linewidth=0.5) plt.legend() # Show the plot plt.show() else: print("No vaults meet the filtering condition (ann_volatility < 100%).")

As shown, Growi HF has the highest Sharpe Ratio, but several strong Vaults on HyperLiquid also exhibit competitive risk-adjusted performance.

Comparing Growi HF with HyperLiquid's HLP vault:

Growi HF exhibits slightly less risk than HyperLiquid’s own Vault, yet delivers significantly higher returns

While Growi HF manages fewer funds, it likely cannot scale to HyperLiquid’s level due to its controlled leverage—but its volatility remains well-managed, demonstrating that great opportunities exist beyond HyperLiquid’s own Vaults.

import pandas as pd from tabulate import tabulate # Extract relevant metrics from vaults_analysis for the filtered vaults filtered_strategy_data = [] for vault, data in vaults_analysis.items(): if "ann_yield" in data["portfolio"]["allTime"] and "ann_volatility" in data["portfolio"]["allTime"]: ann_vol = data["portfolio"]["allTime"]["ann_volatility"] if ann_vol < 1: # Filtering condition: ann_volatility < 50% strategy_name = df_vaultsHL[df_vaultsHL["vaultAddress"] == vault]["name"].values[0] ann_sharpe_value = round(data["portfolio"]["allTime"]["ann_sharpe"], 1) ann_volatility_value = int(round(ann_vol * 100, 0)) # Convert to % ann_yield_value = int(round(data["portfolio"]["allTime"]["ann_yield"] * 100, 0)) # Convert to % tvl_value = "{:>10,}".format(int(df_vaultsHL[df_vaultsHL["vaultAddress"] == vault]["tvl"].values[0] / 1000)) # TVL in k$ with ',' and right-aligned age_days = df_vaultsHL[df_vaultsHL["vaultAddress"] == vault]["vaultAgeDays"].values[0] age_months = round(age_days / 30, 1) # Convert age to months allow_deposits = "Yes" if data.get("allowDeposits", 0) == 1 else "No" # Check if deposits are allowed filtered_strategy_data.append((strategy_name, ann_sharpe_value, ann_yield_value, ann_volatility_value, tvl_value, age_months, allow_deposits)) # Convert to DataFrame and sort by ann_sharpe df_filtered_ann_sharpe = pd.DataFrame(filtered_strategy_data, columns=[ "Strategy Name", "Ann. Sharpe", "Ann. Return (%)", "Ann. Volatility (%)", "TVL (k$)", "Age (Months)", "Allow Deposits" ]) df_filtered_ann_sharpe = df_filtered_ann_sharpe.sort_values(by="Ann. Sharpe", ascending=False) # Print the sorted strategies using tabulate without index and with right-aligned TVL print(tabulate(df_filtered_ann_sharpe, headers="keys", tablefmt="grid", showindex=False, stralign="right"))

How Does HyperLiquid Vaults Compare to Traditional Finance?

If we examine the tweet below, many HyperLiquid Vaults outperform major hedge funds in TradFi. As DeFi traders know, the space is full of high-yield opportunities!

How to Invest in Growi HF

If you want to invest in Growi HF, visit our website: ➡️ https://hf.growi.fi/

For direct access to the protocol, visit our web app: ➡️ https://app.hf.growi.fi/

⚠️ Note: We do not recommend investing directly through HyperLiquid. As mentioned earlier, due to factors such as customizable fees, scheduled fee collection, and lock-in periods, we plan to restrict deposits through HyperLiquid in the short term, allowing deposits only through our protocol.

Want to Learn More? Connect With Us!

Meet the team behind Growi on Linkedin.

Stay updated on protocol developments and our new upcoming strategy by following: Growi Finance and Growi.HF on Twitter

Your Feedback Matters!

Did you find this study useful? Would you like additional analyses or insights? Let us know in the comments!

.css-15w88e5{color:var(--chakra-colors-fg-neutral-primary);font-weight:inherit;letter-spacing:-0.09px;}The Making of: Breaking Down the Financial Performance of HyperLiquid Vaults

.css-hdxizt{color:var(--chakra-colors-fg-neutral-primary);font-weight:var(--chakra-fontWeights-bold);letter-spacing:-0.09px;}TL;DR (Summary) – HyperLiquid Vaults Analysis by Growi.fi