Review of Digital Currency Market in 2021 and the Simplest 10 times Strategy Missed
Tags: strategy, cryptocurrency, fmzquant, market
Published: 2024-04-30 05:24:10

### 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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7bd9f5p7v2n4p5oxxmva.png)

In [175]:
```
#The median increase
df_norm.median(axis=1).plot(figsize=(12,4),grid=True);
```
Out[175]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ouxgr7lbw2box9wevvhc.png)

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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j1n354s90dookt6s0raq.png)

In [212]:
```
#Compared with Bitcoin
(df.mean(axis=1)/df.BTCUSDT).plot(figsize=(12,4),grid=True);
```
Out[212]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/z11tlntbeg9bmiw4ghnz.png)

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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wj7m9v9a6ndyo6pnhco3.png)

### 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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kcbgdy77228utoyta14j.png)

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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ki3xpsqbybdqfqgpf9p4.png)

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]:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sailer75ecxggzw356af.png)

### 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.

From: https://blog.mathquant.com/2022/10/26/review-of-digital-currency-market-in-2021-and-the-simplest-10-times-strategy-missed.html