Crypto · Global · cryptos · Daily · Global Free

The Realized Jumps Predict Cryptocurrency Returns

Academic paper

Good Volatility, Bad Volatility, and the Cross Section of Cryptocurrency Returns

AuthorsZehua Zhang; Ran Zhao

Institute

Hunan University
Claremont Graduate University
?Claremont Graduate University, Drucker School of Management

Paper linkhttps://papers.ssrn.com/sol3/papers.cfm?abstract_id=3910202

Strategy in a nutshell

The investment universe consists of the 51 most actively traded cryptocurrencies with market capitalization above $1 million, obtained from FirstRateData (filtered to be U.S. dollar–based). Realized volatility is computed over 5-minute intervals. First, calculate the daily realized volatility as the sum of squared returns, and the positive and negative semivariances as the sum of squared returns multiplied by an indicator for positive or negative returns. Next, compute the signed jump measure as the difference between positive and negative semivariances. The realized signed jump measure (RSJ) is then defined as the signed jump divided by realized volatility. Each day, cryptocurrencies are sorted into quintiles based on RSJ. The strategy goes long the bottom quintile and short the top quintile. Portfolios are rebalanced daily and equally weighted.

Economic rationale

Volatility captures both positive (“good”) and negative (“bad”) variations in returns. Research shows that positive semivariance is more informative for predicting future realized volatility than negative semivariance. Higher positive semivariance or signed jump variation tends to lead to higher future realized volatility, while higher negative semivariance and minor signed jumps predict lower future volatility. Betting on greater “good” volatility and signed jumps can appear attractive, as one expects these jumps to repeat, but this often carries higher uncertainty and little fundamental support. In the crypto market, extrapolating past signed jump behavior to predict future performance follows a similar pattern as traditional momentum, yet realized signed jumps generally act as a negative predictor of future returns.

Backtest performance

Annualised return54.81%

Volatility12.36%

Beta-0

Sharpe ratio4.43

Sortino ratio-0.934

Win rate48%

Full Python code

1import numpy as np
2from datetime import datetime, timedelta
3from AlgorithmImports import *
4#endregion
5
6class TheRealizedJumpsPredictCryptocurrencyReturns(QCAlgorithm):
7
8def Initialize(self) -> None:
9 self.SetStartDate(2017, 1, 1)
10 self.SetCash(1000000)
11 
12 self.min_prices: int = 60 * 6 # m minuties * n hours
13 self.quantile: int = 5
14 self.portfolio_percentage: float = .1
15 self.leverage: int = 5
16
17 self.cryptos: List[str] = [
18     "BTC", # Bitcoin
19     "EOS", # EOS
20     "ETH", # Ethereum
21     "LTC", # Litecoin
22     "NEO", # Neo
23     "OMG", # OMG Network
24     "TRX", # Tron
25     "XLM", # Stellar
26     "XMR", # Monero
27     "XRP", # XRP
28     "XVG", # Verge
29     "ZRX"  # Ox
30 ]
31 
32 self.data: Dict[Symbol, SymbolData] = {}
33 self.SetBrokerageModel(BrokerageName.Bitfinex)
34 self.Settings.MinimumOrderMarginPortfolioPercentage = 0.
35 
36 for crypto in self.cryptos:
37     crypto_ticker: str = crypto + 'USD'
38     data: Securities = self.AddCrypto(crypto_ticker, Resolution.Minute, Market.Bitfinex)
39     data.SetFeeModel(CustomFeeModel())
40     data.SetLeverage(self.leverage)
41
42     crypto_symbol: Symbol = data.Symbol
43     network_symbol: Symbol = self.AddData(CryptoNetworkData, crypto, Resolution.Daily).Symbol
44
45     self.data[crypto_symbol] = SymbolData(network_symbol)
46 
47 self.curr_day: int = -1
48
49def OnData(self, data: Slice) -> None:
50 crypto_data_last_update_date: Dict[Symbol, datetime.date] = CryptoNetworkData.get_last_update_date()
51
52 # rebalance daily
53 if self.Time.day != self.curr_day: 
54     self.curr_day = self.Time.day
55
56     realized_signed_jump: Dict[Symbol, float] = {}
57
58     for crypto_symbol, symbol_obj in self.data.items():
59         network_symbol: Symbol = symbol_obj.network_symbol
60         # make sure crypto data are ready and new data are still comming
61         if self.Securities[network_symbol].GetLastData() and self.Time.date() > crypto_data_last_update_date[network_symbol]:
62             self.Liquidate()
63             return
64
65         if symbol_obj.is_ready(self.min_prices):
66             # calculate crypto's realized signed jump
67             realized_signed_jump_value: float = symbol_obj.realized_signed_jump()
68
69             # clear crypto prices from last day
70             symbol_obj.prices.clear()
71
72             if realized_signed_jump_value != None:
73                 realized_signed_jump[crypto_symbol] = realized_signed_jump_value
74
75     weight: Dict[Symbol, float] = {}
76
77     # trade only, when there are enough cryptos with realized signed jump value
78     if len(realized_signed_jump) > self.quantile:
79         # perform selection
80         quantile: int = int(len(realized_signed_jump) / self.quantile)
81
82         sorted_by_jump: List[Symbol] = [x[0] for x in sorted(realized_signed_jump.items(), key=lambda item: item[1])]
83         
84         # long bottom quantile
85         long: List[Symbol] = sorted_by_jump[:quantile]
86
87         # short top quantile
88         short: List[Symbol] = sorted_by_jump[-quantile:]
89
90         # value weighting
91         for i, portfolio in enumerate([long, short]):
92             mc_sum:float = sum(list(map(lambda symbol: self.data[symbol].cap_mrkt_cur_usd, portfolio)))
93             for symbol in portfolio:
94                 weight[symbol] = ((-1)**i) * self.data[symbol].cap_mrkt_cur_usd / mc_sum
95
96     # trade execution
97     portfolio: List[PortfolioTarget] = [PortfolioTarget(symbol, self.portfolio_percentage * w) for symbol, w in weight.items() if symbol in data and data[symbol]]
98     if len(portfolio) != 0:
99         self.SetHoldings(portfolio, True)
100     
101 # update prices each minute
102 for crypto_symbol, symbol_obj in self.data.items():
103     network_symbol: Symbol = symbol_obj.network_symbol
104     
105     if crypto_symbol in data.Bars and data[crypto_symbol]:
106         # update prices
107         price: float = data[crypto_symbol].Value
108         self.data[crypto_symbol].update_prices(price)
109     
110     if network_symbol in data and data[network_symbol]:
111         # get market capitalization
112         cap_mrkt_cur_usd: float = data[network_symbol].Value
113         self.data[crypto_symbol].update_cap(cap_mrkt_cur_usd)
114
115class SymbolData():
116def __init__(self, network_symbol: Symbol) -> None:
117 self.network_symbol: Symbol = network_symbol
118 self.prices: List[float] = []
119 self.cap_mrkt_cur_usd: Union[None, float] = None
120     
121def update_prices(self, price: float) -> None:
122 self.prices.append(price)
123 
124def update_cap(self, cap_mrkt_cur_usd: float) -> None:
125 self.cap_mrkt_cur_usd = cap_mrkt_cur_usd
126     
127def is_ready(self, min_prices: int) -> bool: 
128 return self.cap_mrkt_cur_usd and len(self.prices) >= min_prices
129
130def realized_signed_jump(self) -> Union[None, float]:
131 # the time interval for the realized volatility computation is 5 minutes
132 # compute the daily realized volatility (sum of squared returns)
133 interval_length: int = 5
134 prices_length: int = len(self.prices)
135
136 # split minute prices to intervals with same length and for each interval calculate it's return
137 intervals_returns: List[float] = [self.calc_return(self.prices[i:i+interval_length]) for i in range(0, prices_length, interval_length)]
138
139 realized_volatility: float = sum(list(map(lambda interval_return: interval_return ** 2, intervals_returns)))
140
141 # can't perform division by zero
142 if realized_volatility == 0:
143     return None
144 
145 positive_semivariance, negative_semivariance = 0, 0
146
147 # calculate positive and negative semivarince
148 for interval_return in intervals_returns:
149     if interval_return > 0:
150         # positive semivariance contains is sum of positive interval returns squared
151         positive_semivariance += (interval_return ** 2)
152     else:
153         # negative semivariance contains is sum of negatie interval returns squared
154         negative_semivariance += (interval_return ** 2)
155
156 signed_jump: float = positive_semivariance - negative_semivariance
157 realized_signed_jump: float = signed_jump / realized_volatility
158
159 return realized_signed_jump
160
161def calc_return(self, prices: List[float]) -> float:
162 return (prices[-1] - prices[0]) / prices[0]
163
164# Crypto network data.
165# NOTE: IMPORTANT: Data order must be ascending (datewise)
166# Data source: https://coinmetrics.io/community-network-data/
167class CryptoNetworkData(PythonData):
168_last_update_date: Dict[Symbol, datetime.date] = {}
169
170@staticmethod
171def get_last_update_date() -> Dict[Symbol, datetime.date]:
172return CryptoNetworkData._last_update_date
173
174def GetSource(self, config: SubscriptionDataConfig, date: datetime, isLiveMode: bool) -> SubscriptionDataSource:
175 self.cap_mrkt_cur_usd_index = None
176 return SubscriptionDataSource(f"data.quantpedia.com/backtesting_data/crypto/{config.Symbol.Value}_network_data.csv", SubscriptionTransportMedium.RemoteFile, FileFormat.Csv)
177
178# File exmaple:
179# date,AdrActCnt,AdrBal1in100KCnt,AdrBal1in100MCnt,AdrBal1in10BCnt,AdrBal1in10KCnt,AdrBal1in10MCnt,AdrBal1in1BCnt,AdrBal1in1KCnt,AdrBal1in1MCnt,AdrBalCnt,AdrBalNtv0.001Cnt,AdrBalNtv0.01Cnt,AdrBalNtv0.1Cnt,AdrBalNtv100Cnt,AdrBalNtv100KCnt,AdrBalNtv10Cnt,AdrBalNtv10KCnt,AdrBalNtv1Cnt,AdrBalNtv1KCnt,AdrBalNtv1MCnt,AdrBalUSD100Cnt,AdrBalUSD100KCnt,AdrBalUSD10Cnt,AdrBalUSD10KCnt,AdrBalUSD10MCnt,AdrBalUSD1Cnt,AdrBalUSD1KCnt,AdrBalUSD1MCnt,AssetEODCompletionTime,BlkCnt,BlkSizeMeanByte,BlkWghtMean,BlkWghtTot,CapAct1yrUSD,CapMVRVCur,CapMVRVFF,CapMrktCurUSD,CapMrktFFUSD,CapRealUSD,DiffLast,DiffMean,FeeByteMeanNtv,FeeMeanNtv,FeeMeanUSD,FeeMedNtv,FeeMedUSD,FeeTotNtv,FeeTotUSD,FlowInExNtv,FlowInExUSD,FlowOutExNtv,FlowOutExUSD,FlowTfrFromExCnt,HashRate,HashRate30d,IssContNtv,IssContPctAnn,IssContPctDay,IssContUSD,IssTotNtv,IssTotUSD,NDF,NVTAdj,NVTAdj90,NVTAdjFF,NVTAdjFF90,PriceBTC,PriceUSD,ROI1yr,ROI30d,RevAllTimeUSD,RevHashNtv,RevHashRateNtv,RevHashRateUSD,RevHashUSD,RevNtv,RevUSD,SER,SplyAct10yr,SplyAct180d,SplyAct1d,SplyAct1yr,SplyAct2yr,SplyAct30d,SplyAct3yr,SplyAct4yr,SplyAct5yr,SplyAct7d,SplyAct90d,SplyActEver,SplyActPct1yr,SplyAdrBal1in100K,SplyAdrBal1in100M,SplyAdrBal1in10B,SplyAdrBal1in10K,SplyAdrBal1in10M,SplyAdrBal1in1B,SplyAdrBal1in1K,SplyAdrBal1in1M,SplyAdrBalNtv0.001,SplyAdrBalNtv0.01,SplyAdrBalNtv0.1,SplyAdrBalNtv1,SplyAdrBalNtv10,SplyAdrBalNtv100,SplyAdrBalNtv100K,SplyAdrBalNtv10K,SplyAdrBalNtv1K,SplyAdrBalNtv1M,SplyAdrBalUSD1,SplyAdrBalUSD10,SplyAdrBalUSD100,SplyAdrBalUSD100K,SplyAdrBalUSD10K,SplyAdrBalUSD10M,SplyAdrBalUSD1K,SplyAdrBalUSD1M,SplyAdrTop100,SplyAdrTop10Pct,SplyAdrTop1Pct,SplyCur,SplyExpFut10yr,SplyFF,SplyMiner0HopAllNtv,SplyMiner0HopAllUSD,SplyMiner1HopAllNtv,SplyMiner1HopAllUSD,TxCnt,TxCntSec,TxTfrCnt,TxTfrValAdjNtv,TxTfrValAdjUSD,TxTfrValMeanNtv,TxTfrValMeanUSD,TxTfrValMedNtv,TxTfrValMedUSD,VelCur1yr,VtyDayRet180d,VtyDayRet30d
180# 2009-01-09,19,19,19,19,19,19,19,19,19,19,19,19,19,0,0,19,0,19,0,0,0,0,0,0,0,0,0,0,1614334886,19,215,860,16340,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,9.44495122962963E-7,0,950,36500,100,0,950,0,1,0,0,0,0,1,0,0,0,0,11641.53218269,1005828380.584716757433,0,0,950,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,950,950,950,950,950,950,950,950,950,950,950,950,950,0,0,0,0,0,0,0,0,0,0,0,0,0,950,50,50,950,17070250,950,1000,0,1000,0,0,0,0,0,0,0,0,0,0,0,0,0
181def Reader(self, config: SubscriptionDataConfig, line: str, date: datetime, isLiveMode: bool) -> BaseData:
182 data: CryptoNetworkData = CryptoNetworkData()
183 data.Symbol = config.Symbol
184 
185 try:
186     cols:str = ['CapMrktCurUSD']
187
188     if not line[0].isdigit():
189         header_split = line.split(',')
190         self.col_index = [header_split.index(x) for x in cols]
191         return None
192
193     split = line.split(',')
194     
195     data.Time = datetime.strptime(split[0], "%Y-%m-%d") + timedelta(days=1)
196     
197     for i, col in enumerate(cols):
198         data[col] = float(split[self.col_index[i]])
199
200     data.Value = float(split[self.col_index[0]])
201
202     if config.Symbol not in CryptoNetworkData._last_update_date:
203         CryptoNetworkData._last_update_date[config.Symbol] = datetime(1,1,1).date()
204     if data.Time.date() > CryptoNetworkData._last_update_date[config.Symbol]:
205         CryptoNetworkData._last_update_date[config.Symbol] = data.Time.date()
206
207 except:
208     return None
209
210 return data
211
212# Custom fee model.
213class CustomFeeModel(FeeModel):
214def GetOrderFee(self, parameters: OrderFeeParameters) -> OrderFee:
215 fee: float = parameters.Security.Price * parameters.Order.AbsoluteQuantity * 0.00005
216 return OrderFee(CashAmount(fee, "USD"))