Introduction

In a financial context, the term “security” refers to a fungible, negotiable financial instrument that holds some type of monetary value. Securities typically represent ownership, debt, or the right to claim ownership or debt interest in an entity (such as a corporation or government). Securities can take various forms, including stocks, bonds, options, futures contracts, and other investment instruments. They are bought and sold in financial markets, often regulated by governmental authorities, and play a crucial role in investment portfolios and capital markets.

ETH(Ether), on the other hand, is the native cryptocurrency of the Ethereum blockchain platform. It serves as a form of digital currency within the Ethereum network, facilitating transactions and powering the execution of smart contracts and decentralized applications (DApps).

However, ETH is currently at the center of a significant debate concerning its classification as a security. Proponents of this viewpoint argue that ETH could be considered a security primarily because of its Initial Coin Offering (ICO), which resembles traditional securities offerings where investors purchase tokens with the expectation of profit derived from the efforts of others. Furthermore, the Ethereum network’s decentralized applications (dApps) and smart contracts, which can facilitate investment contracts, add complexity to its classification.

Contrarily, the argument against categorizing ETH as a security centers on its operational utility and the decentralized nature of its network. ETH is not just an investment; it’s a fuel for transactions and smart contracts on the Ethereum platform, distinguishing it from traditional securities that represent ownership interests or debts and are typically central to generating profits for holders. The decentralized decision-making process in Ethereum’s development and its broad utility for users beyond mere investment speculation further challenge the security label.

In this study, we will look at this question by taking the perspective of financial risk. We will evaluate metrics like Value at Risk (VaR) and Expected Shortfall (ES)to gain nuanced insights into ETH’s behavior compared to traditional securities. These metrics can highlight differences in risk profiles, market reactions, and the extreme values under particular market conditions. By quantitatively comparing ETH’s financial risk attributes with those of established securities, we can uncover evidence that may support or refute ETH’s classification as a security, offering a data-driven perspective to this complex debate.

We specifically chose not to focus on debt instruments like bonds as our choice for security in this comparison for a straightforward reason: debt securities fundamentally differ from equities and cryptocurrencies in their risk-return profile, legal structure, and market behavior. Bonds, with their fixed income characteristics and typically lower volatility, do not provide the direct comparability needed to address the research question effectively.

In this analysis, AAPL(Stock of Apple Inc) is selected to embody the quintessential characteristics of stock securities as Apple represents one of the most recognized and financially scrutinized companies globally. Its stock is often considered a bellwether for the technology sector and, by extension, the broader stock market, making it an exemplary case for a traditional security. By comparing AAPL’s established financial risk metrics with those of ETH, we aim to quantitatively assess their similarities or differences.

Package Installation

library(MASS)
library(moments)
library(data.table)
library(quantmod)
library(xts)
library(zoo)
library(ggplot2)

Data Gathering

## Retrive ETH data from Yahoo Finance
date.from <- "2017-11-19"  # Earilst available date on Yahoo Finance
date.to   <- "2024-03-01"  # Ending date
eth_data <- getSymbols("ETH-USD", src="yahoo", from=date.from, to=date.to, auto.assign=FALSE)[,6]

# Remove NAs
eth_data <- na.omit(eth_data)

# Convert to data.table
eth_data <- as.data.table(eth_data)
names(eth_data)[1] <- 'date'
head(eth_data)
# Retrive AAPL data from Yahoo Finance
date.from <- "1980-12-12"  # Apple's IPO date
date.to   <- "2024-03-01"  # Ending date
aapl_data <- getSymbols("AAPL", src="yahoo", from=date.from, to=date.to, auto.assign=FALSE)[,6]

# Remove NAs
aapl_data <- na.omit(aapl_data)

# Convert to data.table
aapl_data <- as.data.table(aapl_data)
names(aapl_data)[1] <- 'date'
head(aapl_data)

Accessing Simple Return and Log Return

First of all, we need find the simple return and the log return of ETH and APPL.

Simple return The simple return is calculated as:

\[ \text{simple return} = \frac{P_t - P_{t-1}}{P_{t-1}} \]

where:

Simple return measures the percentage change in the value of an investment over a specific period. It is calculated by taking the difference between the current and initial values, divided by the initial value, and is usually expressed as a percentage. Simple return ranges from -100% (indicating a total loss) to infinity, reflecting percentage changes in investment value.

Log return The log return is calculated as:

\[ \text{log return} = \ln\left(\frac{P_t}{P_{t-1}}\right) \]

where:

The log return, however, spans from negative infinity (for total losses) to positive infinity, representing the natural logarithm of price ratios. The log return is calculated as follows:

This makes log returns symmetric: a specific percentage increase has a log return of equal magnitude but opposite sign to the same percentage decrease. This symmetry and the ability to treat return series additively make log returns more conducive for statistical analysis and performance evaluation, as they align better with the assumptions of many statistical models and simplify the computation of compound returns over multiple periods.

# Calculate ETH's log returns
eth_data[, logret := c(NA, diff(log(eth_data$`ETH-USD.Adjusted`)))]

# Remove the first row since its log return is NA
eth_data <- eth_data[-1]

# Calculate ETH's simple returns
eth_data[, ret := exp(logret) - 1]

# Plotting the histogram of daily log returns
hist(eth_data$logret, main = "Histogram of Ethereum Daily Log Returns", xlab = "Log Returns", ylab = "Frequency", col = "blue", breaks = 50)
title(main = "Histogram of Ethereum Daily Log Returns", col.main = "red", font.main = 4)

# Calculate APPL's log returns
aapl_data[, logret := c(NA, diff(log(aapl_data$`AAPL.Adjusted`)))]

# Remove the first row since its log return is NA
aapl_data <- aapl_data[-1]

# Calculate ETH's simple returns
aapl_data[, ret := exp(logret) - 1]

# Plotting the histogram of daily log returns
hist(aapl_data$logret, main = "Histogram of APPL Daily Log Returns", xlab = "Log Returns", ylab = "Frequency", col = "blue", breaks = 50)
title(main = "Histogram of APPL Daily Log Returns", col.main = "red", font.main = 4)

# Calculate average, max, and min log return for ETH
eth_avg_logret <- mean(eth_data$logret, na.rm = TRUE)
eth_max_logret <- max(eth_data$logret, na.rm = TRUE)
eth_min_logret <- min(eth_data$logret, na.rm = TRUE)

# Calculate average, max, and min log return for AAPL
aapl_avg_logret <- mean(aapl_data$logret, na.rm = TRUE)
aapl_max_logret <- max(aapl_data$logret, na.rm = TRUE)
aapl_min_logret <- min(aapl_data$logret, na.rm = TRUE)

# Output the results for comparison
cat("ETH - Average Log Return:", eth_avg_logret, "Max Log Return:", eth_max_logret, "Min Log Return:", eth_min_logret, "\n")
## ETH - Average Log Return: 0.0009901488 Max Log Return: 0.2347406 Min Log Return: -0.5507317
cat("AAPL - Average Log Return:", aapl_avg_logret, "Max Log Return:", aapl_max_logret, "Min Log Return:", aapl_min_logret, "\n")
## AAPL - Average Log Return: 0.0006892327 Max Log Return: 0.2868918 Min Log Return: -0.731248

From this statistic, we can observe that the average log return for ETH is 0.00099, slightly higher than AAPL’s 0.00069, suggesting ETH, on average, offers marginally higher daily returns. ETH’s daily log returns ranged from -0.5507 to 0.2347, while AAPL’s ranged more broadly from -0.7312 to 0.2869. This indicates that while ETH shows steadier performance, AAPL, despite its higher potential for gains, also carries a risk of more significant losses, demonstrating their distinct risk-return dynamics.

Accessing the Normality

Next, we will assessed the normality of Ethereum and Apple Inc.’s daily log returns by evaluating their skewness, kurtosis, and conducting the Jarque-Bera (JB) test.

We want to get these metrics because, while a histogram seems visually suggest normality, these statistical tests provide a more precise, quantitative evaluation of the distribution’s characteristics.
1. Skewness measures the asymmetry of a distribution; a skewness close to zero indicates symmetry akin to a normal distribution.
2. Kurtosis indicates the “tailedness” of the distribution; a kurtosis of around 3 suggests normal distribution tails.
3. The Jarque-Bera Test is a statistical test that compares the skewness and kurtosis of the sample with those expected from a normal distribution. Significant JB test results (small p-value) reject the hypothesis of normality.

# Calculate ETH skewness
eth_skewness <- skewness(eth_data$logret)
cat("Skewness of Ethereum daily log returns: ", round(eth_skewness, 2), "\n")
## Skewness of Ethereum daily log returns:  -0.94
# Calculate ETH kurtosis
eth_kurtosis <- kurtosis(eth_data$logret)
cat("Kurtosis of Ethereum daily log returns: ", round(eth_kurtosis, 2), "\n")
## Kurtosis of Ethereum daily log returns:  14.01
# Perform the Jarque-Bera test for ETH normality
jb_test_ETH <- jarque.test(as.vector(eth_data$logret))
print(jb_test_ETH)
## 
##  Jarque-Bera Normality Test
## 
## data:  as.vector(eth_data$logret)
## JB = 11927, p-value < 2.2e-16
## alternative hypothesis: greater
# Calculate APPL skewness
appl_skewness <- skewness(aapl_data$logret)
cat("Skewness of APPL daily log returns: ", round(appl_skewness, 2), "\n")
## Skewness of APPL daily log returns:  -1.75
# Calculate APPL kurtosis
appl_kurtosis <- kurtosis(aapl_data$logret)
cat("Kurtosis of APPL daily log returns: ", round(appl_skewness, 2), "\n")
## Kurtosis of APPL daily log returns:  -1.75
# Perform the Jarque-Bera test for APPL normality
jb_test_APPL <- jarque.test(as.vector(aapl_data$logret))
print(jb_test_APPL)
## 
##  Jarque-Bera Normality Test
## 
## data:  as.vector(aapl_data$logret)
## JB = 1031241, p-value < 2.2e-16
## alternative hypothesis: greater

Ethereum’s log returns show a skewness of -0.94 and kurtosis of 14.01, indicating a left-skewed distribution with heavy tails compared to a normal distribution. The JB test for ETH confirms non-normality with a significant result.

For AAPL, a skewness and kurtosis both at -1.75 suggest a pronounced left skew and lighter tails than a normal distribution, which is unusual for kurtosis. AAPL’s JB test also indicates non-normality.

These results highlight that the returns for both assets do not adhere to a normal distribution, affecting the applicability of financial models that assume normality in returns.

Modeling Log Return with T-Distribution

Therefore, in this section, we fit a t-distribution to the log returns of Ethereum (ETH) and Apple Inc. (AAPL) to better model their return distributions, given that our earlier analysis revealed non-normality in their returns.

The t-distribution is preferred here over the normal distribution because it can accommodate heavier tails and asymmetry in the data, as indicated by the skewness, kurtosis, and Jarque-Bera test results. By fitting a t-distribution, we aim to capture the underlying distribution of returns more accurately, which is crucial for subsequent risk and performance analyses.

The parameters ‘m’, ‘s’, and ‘df’ represent the location, scale, and degrees of freedom of the t-distribution, respectively.
1. ‘m’ (mean) locates the center of the distribution.
2. ‘s’ (scale) determines the spread or width of the distribution.
3. ‘df’ (degrees of freedom) controls the heaviness of the tails. The log-likelihood is a statistical measure that indicates how well the t-distribution fits the data; a higher log-likelihood value suggests a better fit.

# Fit a t-distribution to the ETH log returns 
fit_t_ETH <- fitdistr(eth_data$logret, "t")

# Print the estimated parameters rounded to six decimal places
cat("Estimates for m, s, and df:\n")
## Estimates for m, s, and df:
print(round(fit_t_ETH$estimate, 6))
##        m        s       df 
## 0.001595 0.028630 2.724758
# Store the estimated parameters for easy access
m <- fit_t_ETH$estimate["m"]
s <- fit_t_ETH$estimate["s"]
df <- fit_t_ETH$estimate["df"]

# Fit a t-distribution to the APPL log returns 
fit_t_appl <- fitdistr(aapl_data$logret, "t")

# Print the estimated parameters rounded to six decimal places
cat("Estimates for m, s, and df:\n")
## Estimates for m, s, and df:
print(round(fit_t_appl$estimate, 6))
##        m        s       df 
## 0.000708 0.018704 3.599690
# Store the estimated parameters for easy access
m <- fit_t_appl$estimate["m"]
s <- fit_t_appl$estimate["s"]
df <- fit_t_appl$estimate["df"]

The fitted parameters for ETH show a mean (m) of 0.001595, a scale (s) of 0.028630, and degrees of freedom (df) of 2.724758, which indicate a distribution centered slightly to the right, with a moderate spread and substantial tail weight.

For AAPL, the mean (m) of 0.000708, scale (s) of 0.018713, and degrees of freedom (df) of 3.607138 illustrate a tighter, more central distribution with relatively significant tails.

Evaluating Model Fit Using AIC

However,is the t-distribution truly more capable of describing the log returns of AAPL and ETH than the normal distribution? To substantiate this, we’re computing the Akaike Information Criterion (AIC) for both distributions as they’re fitted to the log returns of ETH and AAPL. This metric is pivotal in determining which distribution more accurately encapsulates the behavior of each asset’s returns.

The AIC is a metric used to compare how well different statistical models fit the same dataset. AIC balances the model’s goodness of fit with the number of parameters used, penalizing overcomplex models to prevent overfitting.

The scale of the AIC values isn’t directly interpretable in isolation; what matters is the relative difference between AIC values when comparing models. A model with a lower AIC value is generally considered better as it indicates a good balance between the model’s complexity and its ability to fit the data well.

# For ETH
# Fit a t-distribution to the ETH log returns
fit_t_ETH <- fitdistr(eth_data$logret, "t")
# Calculating AIC for the t-distribution fit for ETH
AIC_t_ETH <- 2 * length(fit_t_ETH$estimate) - 2 * fit_t_ETH$loglik
cat("AIC of t-distribution for ETH:", AIC_t_ETH, "\n")
## AIC of t-distribution for ETH: -7990.571
# Fit a normal distribution to the ETH log returns
fit_n_ETH <- fitdistr(eth_data$logret, "normal")
# Calculating AIC for the normal distribution fit for ETH
AIC_n_ETH <- 2 * length(fit_n_ETH$estimate) - 2 * fit_n_ETH$loglik
cat("AIC of normal distribution for ETH:", AIC_n_ETH, "\n")
## AIC of normal distribution for ETH: -7454.111
# For AAPL
# Fit a t-distribution to the AAPL log returns
fit_t_APPL <- fitdistr(aapl_data$logret, "t")
# Calculating AIC for the t-distribution fit for AAPL
AIC_t_APPL <- 2 * length(fit_t_APPL$estimate) - 2 * fit_t_APPL$loglik
cat("AIC of t-distribution for AAPL:", AIC_t_APPL, "\n")
## AIC of t-distribution for AAPL: -49292.71
# Fit a normal distribution to the AAPL log returns
fit_n_APPL <- fitdistr(aapl_data$logret, "normal")
# Calculating AIC for the normal distribution fit for AAPL
AIC_n_APPL <- 2 * length(fit_n_APPL$estimate) - 2 * fit_n_APPL$loglik
cat("AIC of normal distribution for AAPL:", AIC_n_APPL, "\n")
## AIC of normal distribution for AAPL: -46672.47
# Visualization for ETH
# Find the maximum y-value for the t-distribution curve for ETH
max_y_t_ETH <- max(dt((seq(min(eth_data$logret), max(eth_data$logret), length.out = 100) - fit_t_ETH$estimate["m"]) / fit_t_ETH$estimate["s"], df = fit_t_ETH$estimate["df"]) / fit_t_ETH$estimate["s"])

# Find the maximum y-value for the normal distribution curve for ETH
max_y_n_ETH <- max(dnorm(seq(min(eth_data$logret), max(eth_data$logret), length.out = 100), mean = fit_n_ETH$estimate["mean"], sd = fit_n_ETH$estimate["sd"]))

# Set the upper limit of y-axis to the higher of the two maxima for ETH
upper_ylim_ETH <- max(max_y_t_ETH, max_y_n_ETH) * 1.1  # 1.1 to add some padding

# Histogram for ETH log returns with adjusted y-axis limits
hist(eth_data$logret, breaks = 50, probability = TRUE, main = "ETH Log Returns with Fitted Distributions", xlab = "Log Returns", col = "gray", ylim = c(0, upper_ylim_ETH))
curve(dnorm(x, mean = fit_n_ETH$estimate["mean"], sd = fit_n_ETH$estimate["sd"]), add = TRUE, col = "red", lwd = 2)
curve(dt((x - fit_t_ETH$estimate["m"])/fit_t_ETH$estimate["s"], df = fit_t_ETH$estimate["df"]) / fit_t_ETH$estimate["s"], add = TRUE, col = "blue", lwd = 2)
legend("topleft", legend = c("Normal Distribution", "t-Distribution"), col = c("red", "blue"), lwd = 2)

# Visualization for AAPL
# Find the maximum y-value for the t-distribution curve
max_y_t <- max(dt((seq(min(aapl_data$logret), max(aapl_data$logret), length.out = 100) - fit_t_APPL$estimate["m"]) / fit_t_APPL$estimate["s"], df = fit_t_APPL$estimate["df"]) / fit_t_APPL$estimate["s"])

# Find the maximum y-value for the normal distribution curve
max_y_n <- max(dnorm(seq(min(aapl_data$logret), max(aapl_data$logret), length.out = 100), mean = fit_n_APPL$estimate["mean"], sd = fit_n_APPL$estimate["sd"]))

# Set the upper limit of y-axis to the higher of the two maxima
upper_ylim <- max(max_y_t, max_y_n) * 1.1  # 1.1 to add some padding

# Histogram for AAPL log returns with adjusted y-axis limits
hist(aapl_data$logret, breaks = 50, probability = TRUE, main = "AAPL Log Returns with Fitted Distributions", xlab = "Log Returns", col = "gray", ylim = c(0, upper_ylim))
curve(dnorm(x, mean = fit_n_APPL$estimate["mean"], sd = fit_n_APPL$estimate["sd"]), add = TRUE, col = "red", lwd = 2)
curve(dt((x - fit_t_APPL$estimate["m"])/fit_t_APPL$estimate["s"], df = fit_t_APPL$estimate["df"]) / fit_t_APPL$estimate["s"], add = TRUE, col = "blue", lwd = 2)
legend("topleft", legend = c("Normal Distribution", "t-Distribution"), col = c("red", "blue"), lwd = 2)

The AIC results for both ETH and AAPL indicate that the t-distribution provides a better fit for the log returns of each asset compared to the normal distribution.

For ETH, the AIC for the t-distribution is -7990.571, which is lower than the -7454.111 for the normal distribution, suggesting a more favorable model fit with the t-distribution. Similarly, for AAPL, the t-distribution’s AIC is -49292.55, outperforming the normal distribution’s AIC of -46672.47.

The graphs visualize the same story.

AAPL Analysis: 1. The normal distribution appears to fit closely to the center of the data but does not capture the tail behavior effectively.
2. The t-distribution, on the other hand, fits the central peak well and extends more into the tails, suggesting it accounts for extreme values better than the normal distribution.

ETH Analysis:
1. Similar to AAPL, the normal distribution for ETH log returns fits the central peak but underestimates the tail behavior.
2. The t-distribution provides a visibly better fit in both the center and tails of the distribution, reflecting the heavy-tailed nature of cryptocurrency returns.

Estimating Risk Metrics Using Bootstrap Simulation

After confirming that the t-distribution is the model we want, we can finally proceed to the last step: using simulation to calculate the Value at Risk (VaR) and Expected Shortfall (ES) for ETH and AAPL.

In this step, we are using the bootstrap method to estimate the Value at Risk (VaR) and Expected Shortfall (ES) for Ethereum and APPL. By resampling the empirical distribution of log returns, we calculate VaR and ES, providing a non-parametric approach(does not assume a specific parametric form or distribution for the data) to risk assessment.

Bootstrap is employed in this step because it doesn’t assume a specific underlying distribution, making it ideal for our dataset, where the returns don’t follow a normal distribution. By directly resampling the observed data, bootstrap captures the empirical characteristics of the dataset, including outliers and the shape of the distribution, providing a more accurate and data-driven estimation of risk metrics.

Risk Metrics:
1. Value at Risk (VaR) is a threshold value such that the loss on an investment over a specified period will likely not exceed this threshold at a predetermined confidence level (95% here).
2. Expected Shortfall (ES) is the average loss expected when the loss exceeds the VaR threshold, offering a deeper insight into the tail risk.

# t-distribution simulation for ETH
nsim <- 100000  # Number of simulations
set.seed(123789)  # Ensures reproducibility
sim <- sample(eth_data$logret, nsim, replace = TRUE)  # Bootstrap sampling from ETH log returns
alpha <- 0.95  # Confidence level for VaR and ES
VaR <- quantile(sim, 1 - alpha)  # Compute the 95th percentile for VaR
ES <- mean(sim[sim < VaR])  # Average of returns below the VaR threshold for ES
cat("Value at Risk (VaR) for ETH at", alpha * 100, "% level:", VaR, "\n") 
## Value at Risk (VaR) for ETH at 95 % level: -0.07419318
cat("Expected Shortfall (ES) for ETH at", alpha * 100, "% level:", ES, "\n") 
## Expected Shortfall (ES) for ETH at 95 % level: -0.1190721
# t-distribution simulation for APPL
nsim <- 100000 # Number of simulations
set.seed(123789)  # Ensure reproducibility
sim_appl <- sample(aapl_data$logret, nsim, replace = TRUE) # Bootstrap sampling from ETH log returns
alpha <- 0.95  # Confidence levelfor VaR and ES
VaR_appl <- quantile(sim_appl, 1 - alpha)  # Compute the 95th percentile for VaR
ES_appl <- mean(sim_appl[sim_appl < VaR_appl])  # Average of returns below the VaR threshold for ES
cat("Value at Risk (VaR) for AAPL at", alpha * 100, "% level:", VaR_appl, "\n")
## Value at Risk (VaR) for AAPL at 95 % level: -0.04182941
cat("Expected Shortfall (ES) for AAPL at", alpha * 100, "% level:", ES_appl, "\n")
## Expected Shortfall (ES) for AAPL at 95 % level: -0.06344605
# ETH Visual 
# Histogram for ETH simulated returns
hist(sim, breaks = 50, main = "Histogram of Simulated ETH Returns", xlab = "Returns", col = "blue")
abline(v = VaR, col = "red", lwd = 2, lty = 2)
abline(v = ES, col = "green", lwd = 2, lty = 2)
legend("topright", legend = c("VaR", "ES"), col = c("red", "green"), lty = 2, lwd = 2)

# APPL Visual
# Histogram for AAPL simulated returns
hist(sim_appl, breaks = 50, main = "Histogram of Simulated AAPL Returns", xlab = "Returns", col = "blue")
abline(v = VaR_appl, col = "red", lwd = 2, lty = 2)
abline(v = ES_appl, col = "green", lwd = 2, lty = 2)
legend("topright", legend = c("VaR", "ES"), col = c("red", "green"), lty = 2, lwd = 2)

In the above sector, we performed a simulation based on the t-distribution to estimate the Value at Risk (VaR) and Expected Shortfall (ES) for ETH and APPL.

We set up a large number (100,000) of simulations to capture a wide range of outcomes, ensuring the reproducibility of results by setting a seed for the random number generator. We then use bootstrap sampling to draw from the observed log returns of ETH, simulating what future returns might look like. With these simulated returns, we calculate the VaR at the 95th percentile, which gives us the threshold that we expect returns to exceed with 95% confidence on any given day. We also calculate the ES, which is the average of the simulated returns that fall below the VaR threshold, giving us an expectation of the average loss in the worst 5% of cases.

ETH VaR and ES:
1. The Value at Risk (VaR) for ETH at the 95% level is -0.07419318. This means that there is a 95% confidence level that ETH will not lose more than 7.42% of its value in the given time frame.
2. The Expected Shortfall (ES) for ETH at the 95% level is -0.119072. This indicates that, in the worst 5% of cases (when losses exceed the VaR threshold), the average loss will be around 11.91%. ES provides a deeper insight into the potential losses in extreme scenarios.

AAPL VaR and ES:
1. The Value at Risk (VaR) for AAPL at the 95% level is -0.04182921. It suggests a 95% confidence level that AAPL will not lose more than 4.18% of its value in the given time frame.
2. The Expected Shortfall (ES) for AAPL at the 95% level is -0.06344605. This means that in the worst 5% of scenarios, the average loss is expected to be around 6.34%, offering a perspective on potential losses beyond the VaR threshold.

Comparing the two sets of results, ETH exhibits higher VaR and ES values than AAPL, suggesting that Ethereum is considered riskier than Apple Inc. in terms of potential loss magnitude.

Conclusion

In our study, we aimed to unravel whether Ethereum (ETH) should be categorized alongside traditional securities, with a particular focus on comparing its financial risk metrics against those of Apple Inc. (AAPL). The analysis revealed that Ethereum’s Value at Risk (VaR) and Expected Shortfall (ES) are significantly higher than those of AAPL, indicating a more substantial risk profile for ETH. Specifically, Ethereum’s VaR suggests a potential daily loss 77% greater than that of AAPL, while its ES indicates that in the worst 5% of scenarios, Ethereum’s losses could be almost 88% higher than Apple’s.

These findings highlight Ethereum’s distinct risk characteristics compared to a conventional security like AAPL. The substantial difference in the risk measures, particularly the magnitude of potential losses, underscores the argument that Ethereum possesses unique risk attributes that are not typically associated with traditional securities. Of course, this study, due to the limited data availability (Ethereum has less than a decade of data), cannot definitively prove that ETH’s financial risk is greater than that of traditional securities.

However, it provides valuable insights for future research directions, such as examining the volatility patterns of Ethereum over extended periods. Future studies could investigate how the inherent volatility of cryptocurrencies, compared to traditional securities, affects their risk profiles, particularly focusing on how market developments, regulatory environments, and technological progress influence these volatility trends over time.