Summary for 2021 and strategies in the future
2021 is coming to an end, and hotspots from DEFI to GAMEFI are emerging in an endless stream, and the overall market is still a bull market. Now look back and summarize, how much did you gain in 2021? What opportunities did you miss? What were some successful investments? Recently, I took a look at the historical market of the past year and found an unexpected simple profiteering strategy, which is a multi-currency index.
There are so many currencies on the exchange, many of which are destined to be unknown and may even be withdrawn from trading. Here we choose the currency of Binance perpetual contract that have been used in the market. They are generally tested and recognized as mainstream currencies, which are relatively safe. After simple screening, some index currencies were removed and 134 currencies were obtained finally.
In [1]:
import requests from datetime import date,datetime import time import pandas as pd import numpy as np import matplotlib.pyplot as plt %matplotlib inline
In [144]:
## Current trading pairs
Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
symbols = [s['symbol'] for s in Info.json()['symbols']]
In [154]:
symbols_f = list(set(filter(lambda x: x[-4:] == 'USDT', [s.split('_')[0] for s in symbols]))-
set(['1000SHIBUSDT','1000XECUSDT','BTCDOMUSDT','DEFIUSDT','BTCSTUSDT'])) + ['SHIBUSDT','XECUSDT']
print(symbols_f)
In [155]:
print(len(symbols_f))
Market in the past year
We then obtain their daily closing prices for the past year, noting that some currencies have been on the shelf for a short period of time, so we need to fill in the data. The index can be calculated by normalizing the data.
The final index return is about 12 times, that is to say, if you buy the 134 coins on January 1, 2021 on average, the final return of doing nothing will be 12 times. It is estimated that more than 90% of the traders do not outperform the average index. Among them, the currencies with the largest decline are: ICP fell by 93%, DODO fell by 85%, and LINA fell by 75%. While SOL, FTM, LUNA, MATIC, SAND and AXS have increased nearly 100 times. Among them, AXS rose 168 times, making it the largest dark horse. The median increased for 3 times, which was mainly driven by the public chain and games. In order to aviod the survivorship bias, we excluded the perpetual new currency during the period, and we also achieved nearly 11 times of the profit. It is 7 times of the profits for BTC.
This is a despairing rate of return. I have worked hard to make all kinds of strategies, but it was far from the profits of doing nothing in a year. However, it should be noted that some of the specific increases are too large and it was deviate from the index obviously. If these currencies are not selected at the beginning of the year, the profits will be close to the median, which is far less profitable.
In [157]:
#Obtain the function of K-line in any period
def GetKlines(symbol='BTCUSDT',start='2020-8-10',end='2021-8-10',period='1h',base='fapi',v = 'v1'):
Klines = []
start_time = int(time.mktime(datetime.strptime(start, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
end_time = int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
intervel_map = {'m':60*1000,'h':60*60*1000,'d':24*60*60*1000}
while start_time < end_time:
mid_time = min(start_time+1000*int(period[:-1])*intervel_map[period[-1]],end_time)
url = 'https://'+base+'.binance.com/'+base+'/'+v+'/klines?symbol=%s&interval=%s&startTime=%s&endTime=%s&limit=1000'%(symbol,period,start_time,mid_time)
res = requests.get(url)
res_list = res.json()
if type(res_list) == list and len(res_list) > 0:
start_time = res_list[-1][0]
Klines += res_list
elif type(res_list) == list:
start_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
else:
break
df = pd.DataFrame(Klines,columns=['time','open','high','low','close','amount','end_time','volume','count','buy_amount','buy_volume','null']).astype('float')
df.index = pd.to_datetime(df.time,unit='ms')
return df
In [164]:
df_all_s = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1d'),columns=symbols_s)
for i in range(len(symbols_f)):
#print(symbols_s[i])
symbol_s = symbols_f[i]
df_s = GetKlines(symbol=symbol_s,start='2021-1-1',end='2021-12-28',period='1d',base='api',v='v3')
df_all_s[symbol_s] = df_s[~df_s.index.duplicated(keep='first')].close
In [165]:
df_all_s.tail() #data structure
Out[165]:
In [174]:
df_all = df_all_s.fillna(method='bfill')#filled data df_norm = df_all/df_all.iloc[0] #normalization df_norm.mean(axis=1).plot(figsize=(12,4),grid=True); #The final index return chart
Out[174]:
In [175]:
#The median increase df_norm.median(axis=1).plot(figsize=(12,4),grid=True);
Out[175]:
In [168]:
#Ranking for increase/decrease print(df_norm.iloc[-1].round(2).sort_values().to_dict())
In [317]:
#Maximum rollback of current price compared with the highest point in the year print((1-df_norm.iloc[-1]/df_norm.max()).round(2).sort_values().to_dict())
In [177]:
df_all_f = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1d'),columns=symbols_s)
for i in range(len(symbols_f)):
#print(symbols_s[i])
symbol_f = symbols_f[i]
df_f = GetKlines(symbol=symbol_f,start='2021-1-1',end='2021-12-28',period='1d',base='fapi',v='v1')
df_all_f[symbol_f] = df_f[~df_f.index.duplicated(keep='first')].close
In [208]:
#Excluding new currency df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull()]] df = df.fillna(method='bfill') df = df/df.iloc[0] df.mean(axis=1).plot(figsize=(12,4),grid=True);
Out[208]:
In [212]:
#Compared with Bitcoin (df.mean(axis=1)/df.BTCUSDT).plot(figsize=(12,4),grid=True);
Out[212]:
In [213]:
#Use the original backtest engine
class Exchange:
def __init__(self, trade_symbols, fee=0.0004, initial_balance=10000):
self.initial_balance = initial_balance #Initial assets
self.fee = fee
self.trade_symbols = trade_symbols
self.account = {'USDT':{'realised_profit':0, 'unrealised_profit':0, 'total':initial_balance, 'fee':0}}
for symbol in trade_symbols:
self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0,'unrealised_profit':0,'fee':0}
def Trade(self, symbol, direction, price, amount):
cover_amount = 0 if direction*self.account[symbol]['amount'] >=0 else min(abs(self.account[symbol]['amount']), amount)
open_amount = amount - cover_amount
self.account['USDT']['realised_profit'] -= price*amount*self.fee #Deduct the handling fee
self.account['USDT']['fee'] += price*amount*self.fee
self.account[symbol]['fee'] += price*amount*self.fee
if cover_amount > 0: #Close the position first
self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount #Profits
self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
self.account[symbol]['amount'] -= -direction*cover_amount
self.account[symbol]['hold_price'] = 0 if self.account[symbol]['amount'] == 0 else self.account[symbol]['hold_price']
if open_amount > 0:
total_cost = self.account[symbol]['hold_price']*direction*self.account[symbol]['amount'] + price*open_amount
total_amount = direction*self.account[symbol]['amount']+open_amount
self.account[symbol]['hold_price'] = total_cost/total_amount
self.account[symbol]['amount'] += direction*open_amount
def Buy(self, symbol, price, amount):
self.Trade(symbol, 1, price, amount)
def Sell(self, symbol, price, amount):
self.Trade(symbol, -1, price, amount)
def Update(self, close_price): #Update the assets
self.account['USDT']['unrealised_profit'] = 0
for symbol in self.trade_symbols:
self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
self.account[symbol]['price'] = close_price[symbol]
self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*close_price[symbol]
self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)
In [418]:
#The hourly K-line was taken to make the backtest more accurate
df_all_s = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1h'),columns=symbols_s)
for i in range(len(symbols_f)):
#print(symbols_s[i])
symbol_s = symbols_f[i]
df_s = GetKlines(symbol=symbol_s,start='2021-1-1',end='2021-12-28',period='1h',base='api',v='v3')
df_all_s[symbol_s] = df_s[~df_s.index.duplicated(keep='first')].close
In [419]:
df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull()]] df = df.fillna(method='bfill') df = df/df.iloc[0] df.mean(axis=1).plot(figsize=(12,4),grid=True);
Out[419]:
Performance of the balanced strategies
In the backtest, all currencies of the online Binance perpetual contract on January 1, 2021 were selected. The K-line period was 1h. The parameter started scaling in positions when the position was 5% lower than the average, and sell them when the position was more than 5%. When the backtest is all currencies, the final strategic return is 7.7 times. It is obviously not so good as to the average return of 13 times. This is also expected. After all, several currencies that rose a hundred times are too special, and the balance strategy will sell them all.
If the 10 currencies with the highest increase are removed from the backtest, only the relatively mediocre currencies will be considered, and the final income will be 4.8 times, far exceeding the average performance of 3.4 times.
If only the 3 currencies with the highest increase are rotated, the final profits will be 373 times, which is far more than the average performance of 160 times. This shows that if the trend and increase of the selected rotated currency tend to be consistent, the result of rotated will be far better than that of doing nothing.
In [494]:
#Full currency backtest
symbols = list(df.iloc[-1].sort_values()[:].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
prices = row[1]
total = e.account['USDT']['total']
e.Update(prices)
for symbol in symbols:
pct = e.account[symbol]['value']/total
if pct < 0.95*avg_pct:
e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
if pct > 1.05*avg_pct:
e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)
In [495]:
e.account['USDT']
Out[495]:
In [496]:
# Backtest performance of full currencies (res.total/10000).plot(figsize=(12,4),grid = True); df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);
Out[496]:
In [498]:
#Remove currencies with huge growth
symbols = list(df.iloc[-1].sort_values()[:-10].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
prices = row[1]
total = e.account['USDT']['total']
e.Update(prices)
for symbol in symbols:
pct = e.account[symbol]['value']/total
if pct < 0.95*avg_pct:
e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
if pct > 1.05*avg_pct:
e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)
In [501]:
e.account['USDT']
Out[501]:
In [499]:
(res.total/10000).plot(figsize=(12,4),grid = True); df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);
Out[499]:
In [503]:
#Only the currency with the highest increase is tested
symbols = list(df.iloc[-1].sort_values()[-3:].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
prices = row[1]
total = e.account['USDT']['total']
e.Update(prices)
for symbol in symbols:
pct = e.account[symbol]['value']/total
if pct < 0.95*avg_pct:
e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
if pct > 1.05*avg_pct:
e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)
In [504]:
e.account['USDT']
Out[504]:
In [505]:
(res.total/10000).plot(figsize=(12,4),grid = True); df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);
Out[505]:
Summary
In general, 2021 will be a bull market for counterfeit coins and a downward year for Bitcoin. The market value of Bitcoin has fallen to 40% now from 70% at the beginning of the year, which is the lowest level in the history. Therefore, the average profits from buying and holding counterfeit goods in the past year are far higher than that from holding Bitcoin. Looking forward to 2022, if you deem there will still be several hundredfold currencis in the current market in the future, you can diversify your positions boldly and wait patiently. If you are particularly optimistic about a few currencies or the average market, you can use the rotated strategy to gain excess returns without thinking. If you think things will turn against each other when they reach the extreme, you can bargain-hunting Bitcoin to obtain better returns and security.