Backtest Period
Markets Traded
Cryptocurrencies
Maximum Drawdown
Period of Rebalancing
Weekly
Return (Annual)
Sharpe Ratio
Standard Deviation (Annual)
Original paper
SSRN-id3342842.pdf773.7KB
Abstract
We examine whether blockchain characteristics such as network size and computing power affect cryptocurrency prices and returns. Network size reflects adoption and usage of the blockchain while computing power proxies for the real-world resources expended on securing and confirming transactions. Consistent with theoretical models, we find that cryptocurrency prices exhibit comovement with these two blockchain characteristics. Further, aggregate network and computing power explain the variation in expected cryptocurrency returns at least as well as models with return-based factors such as market, size, and momentum. Overall, our results show that blockchain-based factors are important for explaining cryptocurrency prices and returns.
Keywords:Â Hashrate, Network, Factor Analysis, GMM, Rolling Estimation
Trading rules
- Investment universe: Bitcoin, Ethereum, Litecoin, Monero, Dash.
- Determine each currency's daily computing power:
- Multiply average mining difficulty by number of blocks mined.
- Compute weekly average log values:
- Take natural log of daily computing power values
- Calculate weekly average (ending on Fridays)
- Identify computing power growth:
- Evaluate the first difference in weekly average log values.
- Construct factor-mimicking portfolio:
- Estimate OLS regressions for each cryptocurrency’s log computing power change on the returns of the other four
- Calculate weights using coefficients from OLS regressions
- Multiply weights by returns of respective four cryptocurrencies
- Repeat process for all five cryptocurrencies
- Calculate aggregate computing power factor:
- Weighted average of factor-mimicking portfolios
- Use ranked relative market capitalization as weights
- Adjust the approach on a weekly basis.
Python code
Backtrader
import backtrader as bt
import numpy as np
import pandas as pd
import statsmodels.api as sm
class ComputingPowerFactor(bt.Strategy):
def __init__(self):
self.cryptos = ['BTC', 'ETH', 'LTC', 'XMR', 'DASH']
def next(self):
if self.datetime.date(ago=0).weekday() == 4: # Friday
self.rebalance()
def rebalance(self):
daily_computing_power = self.compute_daily_computing_power()
weekly_average_log_values = self.compute_weekly_average_log_values(daily_computing_power)
growth_computing_power = self.calculate_growth(weekly_average_log_values)
factor_mimicking_portfolio = self.construct_factor_mimicking_portfolio(growth_computing_power)
aggregate_computing_power_factor = self.calculate_aggregate_factor(factor_mimicking_portfolio)
self.allocate_portfolio(aggregate_computing_power_factor)
def compute_daily_computing_power(self):
daily_computing_power = {}
for crypto in self.cryptos:
avg_mining_difficulty = self.data.crypto.difficulty # Replace with actual data access
blocks_mined = self.data.crypto.blocks_mined # Replace with actual data access
daily_computing_power[crypto] = avg_mining_difficulty * blocks_mined
return daily_computing_power
def compute_weekly_average_log_values(self, daily_computing_power):
weekly_log_values = {crypto: np.log(daily_computing_power[crypto]).resample('W-FRI').mean() for crypto in self.cryptos}
return weekly_log_values
def calculate_growth(self, weekly_average_log_values):
growth = {crypto: weekly_average_log_values[crypto].diff() for crypto in self.cryptos}
return growth
def construct_factor_mimicking_portfolio(self, growth_computing_power):
factor_mimicking_portfolio = {}
for crypto in self.cryptos:
other_cryptos = [c for c in self.cryptos if c != crypto]
X = np.column_stack([growth_computing_power[c] for c in other_cryptos])
X = sm.add_constant(X)
y = growth_computing_power[crypto]
model = sm.OLS(y, X, missing='drop').fit()
weights = model.params[1:]
factor_mimicking_portfolio[crypto] = np.sum([weights[i] * self.data.crypto.close for i, c in enumerate(other_cryptos)], axis=0)
return factor_mimicking_portfolio
def calculate_aggregate_factor(self, factor_mimicking_portfolio):
market_caps = {crypto: self.data.crypto.market_cap for crypto in self.cryptos} # Replace with actual data access
total_market_cap = sum(market_caps.values())
weights = {crypto: market_caps[crypto] / total_market_cap for crypto in self.cryptos}
aggregate_computing_power_factor = np.sum([weights[crypto] * factor_mimicking_portfolio[crypto] for crypto in self.cryptos], axis=0)
return aggregate_computing_power_factor
def allocate_portfolio(self, aggregate_computing_power_factor):
for i, crypto in enumerate(self.cryptos):
target_percent = aggregate_computing_power_factor[i]
self.order_target_percent(self.data.crypto, target_percent) # Replace with actual data access