How Risky Is Binance CMC Cryptocurrency Top 10 Equal-Weighted index? A Comparison with Modern Portfolio Theory
Tags: python, datascience, programming, web3
Published: 2023-12-01 05:54:29

Cryptocurrencies have taken the financial world by storm, offering a new asset class that promises high returns but also comes with high volatility. Binance , one of the world’s leading cryptocurrency exchanges, introduced the CoinMarketCap Cryptocurrency Top 10 Equal-Weighted Index(about a year ago). But how risky is this index? Let’s delve into it and compare its risk level with the results from Modern Portfolio Theory (MPT).

## What is the Binance CMC Cryptocurrency Top 10 Equal-Weighted index?
According to the [Binance Website](https://www.binance.com/en/ew-index), Binance CoinMarketCap (CMC) Top 10 Equal-Weighted Index aims to track the performance of the top 10 eligible digital assets by market capitalization. The index assigns a 10% weight to every asset in it. The index is maintained and rebalanced monthly. For a detailed explanation about the index visit the [official website](https://www.binance.com/en/index-methodology).

## Modern Portfolio Theory (MPT) at a glance
Introduced by Harry Markowitz in 1952, the Modern Portfolio Theory (MPT) is a framework for constructing portfolios that maximize expected return for a given level of risk. MPT emphasizes the benefits of diversification, suggesting that an investor can reduce portfolio risk by combining assets that are not perfectly correlated.

## Risk Level of Binance CMC Cryptocurrency Top 10 Equal-Weighted Index
Portfolio Risk is measured by the standard deviation/variance of portfolio return over time and is also referred to as portfolio volatility, this method of standard deviation/variance takes into account the relationship between assets in the portfolio and is given by the equation;

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c9vvvcrp2j6g3tvn5plt.jpg)
where;
𝜎² = portfolio variance
𝜎= portfolio standard deviation
w= the weights of the assets in the portfolio
w^T = Tranpose of the weights of the assets in the portfolio.
Cov= the covariance of the returns of the assets in the portfolio, this tells us how the assets in the portfolio are related to each other.

### Calculating The Risk Level Of Binance CMC Cryptocurrency Top 10 Equal-Weighted index
For us to quantify the risk of the equally weighted index we need to consider the fact that Binance rebalances the index monthly, there by removing and adding some cryptocurrencies. But there are some coins that have stayed in the index far longer than others since the index was created, as we can see

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/omhxu993h6powkfugqwc.jpg)
we select the top 10 most occurring currencies; since they have constituted the index most of the time.
Next, in order to calculate the risk level of the index, we get daily data starting from when Binance published the index to the beginning of the present month i.e 2022/09/22 to 2023/09/01 using the yahoo finance api in python

```
import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

top_crypto= ['ADA-USD', 'BNB-USD', 'BTC', 'DOT-USD', 'ETH-USD', 'LTC-USD','MATIC-USD', 'SOL-USD', 'TRX-USD', 'XRP-USD']
data=yf.download(top_crypto, start='2022-09-22', end='2023-09-01', interval='1d')
data.head()
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mfa4fzno8djj70rtu1ny.jpg)
We have seen that in order to calculate the risk of a portfolio, we need the weights (w) of the currencies and covariance (cov) of returns; since the index is equally weighted the weights (w) = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]. The code below allows us to get the covariance of returns

```
### calculate the daily returns on each asset
portfolio_daily_returns= data.Close.pct_change().dropna()

##### calculate the annualized covariance of the daily returns
covariance = portfolio_daily_returns.cov()*365
covariance
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mn668qvagj4txcf8q4lq.jpg)
we have all we need to calculate the risk of the portfolio (weights and covariance). we implement this calculation in the code below

```
### calculate the volatility of the portfolio 
weights_equal = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] # from binance equal weight
weights_equal= np.array(weights_equal)

equal_weight_portfolio_variance = np.transpose(weights_equal) @ covariance @ weights_equal

equal_weight_portfolio_volatility = np.sqrt(equal_weight_portfolio_variance)
equal_weight_portfolio_volatility= round(equal_weight_portfolio_volatility*100, 2)
print('Risk Level: ', equal_weight_portfolio_volatility, '%')
```

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/74d092wwtqa5h8y0sx2n.jpg)
Now we know the risk level of the index, you may be wondering what amount of reward does this level of risk brings? In order to answer that, let’s look at the expected annual return
##### Calculating The Expected Return Of Binance CMC Cryptocurrency Top 10 Equal-Weighted index.
The returns of the portfolio is calculated using the below formula (each r represents the daily return of the portfolio)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ex7d7jnhof56qh6tdk1y.jpg)
In order to get the daily return (r) of the portfolio we multiply each asset’s daily return by it weight in the index and sum it up as shown in the code

```
### each asset's daily return
assets_daily_returns= data.Close.pct_change().dropna()

### multiply each asset's daily return by it weight in the index
r =assets_daily_returns.mul(weights_equal, axis=1).sum(axis=1) # dot product
r
```
we have the daily return of the portfolio saved in variable r, next we implement expected annual return formula

```
annual_return= r.mean()*365*100
annual_return= round(annual_return, 2)
print('Expected Reward:', annual_return, '%')
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0xp8u7mw6oiv9n7hk9tq.jpg)
We have seen that the index has a risk level of 54.82% and an annual expected return of 10.8%. Are there ways we can adjust the weights of the index to give a minimal risk level and how efficient is this portfolio?
## Deriving A Minimal Variance Portfolio Using Modern Portfolio Theory
Applying MPT, we get different weights of the cryptocurrencies and the respective risk and expected reward of these weights. These respective risk and reward gotten from these different weights is graphed to give rise to what is called the Efficient Frontier

```
from pypfopt import EfficientFrontier
from pypfopt import CovarianceShrinkage, CLA, expected_returns

prices= data.Close
portfolio_expected_returns=  expected_returns.mean_historical_return(prices, frequency=365, compounding=False)
eff_covariance= CovarianceShrinkage(prices).ledoit_wolf()
cla= CLA(portfolio_expected_returns, eff_covariance)
minimum_variance= cla.min_volatility()
(returns, volatility, weights) = cla.efficient_frontier()

plt.figure(figsize=(10,5))
plt.scatter(volatility, returns, label='Portfolios on efficient frontier')
plt.plot(equal_weight_portfolio_volatility/100, annual_return/100,'ro', label='Binance CMC Equal Weight Index')
plt.legend()
plt.ylabel('Expected Reward')
plt.xlabel('Volatiity')
plt.show()
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ss9wag8x7ovfyoepp199.jpg)
From the efficient frontier, we choose the weights with the lowest volatility(variance), we also note that the Binance CMC equal weight index seems to be a sub-optimal portfolio because it doesn’t provide the best possible return for its level of risk or, conversely, it has a higher level of risk for its level of return.

```
# Get the weights with lowest risk
optimized_weight=weights[volatility.index(min(volatility))]
pie_df=pd.DataFrame(optimized_weight*100, index=prices.columns, columns=['weights'])
pie_df= pie_df.sort_values(by=['weights'], ascending=False)
pie_df
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vjvjgthvoy9pkcdzxxod.jpg)

```
### Showing Pie Chart of this weight

pie_df= pie_df.query('weights != 0.000000')

fig, ax = plt.subplots()
ax.pie(pie_df.weights, labels=pie_df.index.values.tolist(), autopct='%1.1f%%', radius=2)
plt.show()
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p4gkyn8m25tz6czfkvtx.png)
The weights with lowest volatility suggests 79.64% of Bitcoin, 13.31% of TRX, 6.4% of BNB, 0.43% of Polkadot and 0.22% of Ethereum, we get the risk level and expected reward from the efficient frontier.

```
lowest_volatility= min(volatility)
reward_level= returns[volatility.index(min(volatility))]
print('Risk Level: ', round(lowest_volatility*100, 2), '%')
print('Expected Reward: ', round(reward_level*100, 2), '%')
```
## Conclusion
In this article, we delved deep into understanding the risk and potential rewards associated with the Binance CMC Cryptocurrency Top 10 Equal-Weighted Index. By applying the principles of Modern Portfolio Theory, we were able to visualize the Efficient Frontier and compare the index’s performance against it. Our analysis revealed that the Binance CMC index, while promising, does not lie on the Efficient Frontier, indicating that there might be more optimal combinations of cryptocurrency weights that could offer better risk-adjusted returns.
Furthermore, our exploration into optimizing the portfolio showed that certain cryptocurrencies, like Bitcoin, might play a more dominant role in minimizing risk. However, it’s crucial to note that the world of cryptocurrencies is highly volatile and ever-changing. While our analysis provides insights based on historical data, future performance can be unpredictable and the result of our analysis would change as more data is collected.
Lastly, it’s essential to emphasize that this article is intended for educational purposes only. It does not serve as financial advice, and readers should always conduct their own research and consult with financial professionals before making investment decisions.