├── Backtest.py
├── GraphBacktest.py
├── README.md
├── charts.py
└── liquidity.py


/Backtest.py:
--------------------------------------------------------------------------------
  1 | import pandas as pd
  2 | import matplotlib.pyplot as plt
  3 | import matplotlib.cbook as cbook
  4 | import matplotlib.dates as mdates
  5 | import numpy as np
  6 | import liquidity
  7 | import GraphBacktest
  8 | import charts
  9 | 
 10 | # network 1 ETH, 2 ARB, 3 OPT
 11 | 
 12 | Adress= "0x93f267fd92b432bebf4da4e13b8615bb8eb2095c"#snx eth
 13 | Adress= "0xcb0c5d9d92f4f2f80cce7aa271a1e148c226e19d" # Rai Dai
 14 | Adress= "0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8" # ETH USDC Ethereum
 15 | Adress= "0x2e9c575206288f2219409289035facac0b670c2f" # ETH DAI Optimism
 16 | #Adress= "0x68f180fcce6836688e9084f035309e29bf0a2095" #  WBTC DAI
 17 | startfrom= 1632081600
 18 | network = 3
 19 | 
 20 | dpd=GraphBacktest.graph(network,Adress,startfrom)
 21 | 
 22 |        
 23 | decimal0=dpd.iloc[0]['pool.token0.decimals']
 24 | decimal1=dpd.iloc[0]['pool.token1.decimals']
 25 | decimal=decimal1-decimal0
 26 | dpd['fg0']=((dpd['feeGrowthGlobal0X128'])/(2**128))/(10**decimal0)
 27 | dpd['fg1']=((dpd['feeGrowthGlobal1X128'])/(2**128))/(10**decimal1)
 28 | 
 29 | mini = 3273.4 
 30 | maxi = 4038.3
 31 | target = 2711.53 #1 / dpd['close'].iloc[-1] 
 32 | base = 1
 33 | 
 34 | 
 35 | # mini = 1 / 3215    #optimism
 36 | # maxi = 1 / 2903.3 
 37 | # target = 1 #in base 0
 38 | # base = 0
 39 | 
 40 | # mini =  2892.9          #ethereum
 41 | # maxi =  3235  
 42 | # target = 5910 #in base 0
 43 | # base = 0
 44 | 
 45 | # mini =  1/4048         #ethereum
 46 | # maxi =  1/ 2892 
 47 | # target = 5910 / dpd['close'].iloc[0] #in base 0
 48 | # base = 1
 49 | 
 50 | 
 51 | 
 52 | #Calculate F0G and F1G (fee earned by an unbounded unit of liquidity in one period)
 53 | 
 54 | dpd['fg0shift']=dpd['fg0'].shift(-1)
 55 | dpd['fg1shift']=dpd['fg1'].shift(-1)
 56 | dpd['fee0token']=dpd['fg0']-dpd['fg0shift'] 
 57 | dpd['fee1token']=dpd['fg1']-dpd['fg1shift']
 58 | 
 59 | # calculate my liquidity
 60 | 
 61 | SMIN=np.sqrt(mini* 10 ** (decimal))   
 62 | SMAX=np.sqrt(maxi* 10 ** (decimal))  
 63 | 
 64 | if base == 0:
 65 | 
 66 |     sqrt0 = np.sqrt(dpd['close'].iloc[-1]* 10 ** (decimal))
 67 |     dpd['price0'] = dpd['close']
 68 | 
 69 | else:
 70 |     
 71 |     sqrt0= np.sqrt(1/dpd['close'].iloc[-1]* 10 ** (decimal))
 72 |     dpd['price0']= 1/dpd['close']
 73 |     
 74 | if sqrt0>SMIN and sqrt0<SMAX:
 75 | 
 76 |         deltaL = target / ((sqrt0 - SMIN)  + (((1 / sqrt0) - (1 / SMAX)) * (dpd['price0'].iloc[-1]* 10 ** (decimal))))
 77 |         amount1 = deltaL * (sqrt0-SMIN)
 78 |         amount0 = deltaL * ((1/sqrt0)-(1/SMAX))* 10 ** (decimal)
 79 |         
 80 | elif sqrt0<SMIN:
 81 | 
 82 |         deltaL = target / (((1 / SMIN) - (1 / SMAX)) * (dpd['price0'].iloc[-1]))
 83 |         amount1 = 0
 84 |         amount0 = deltaL * (( 1/SMIN ) - ( 1/SMAX ))
 85 | 
 86 | else:
 87 |         deltaL = target / (SMAX-SMIN) 
 88 |         amount1 = deltaL * (SMAX-SMIN)
 89 |         amount0 = 0
 90 | 
 91 | 
 92 | print("Amounts:",amount0,amount1)
 93 | 
 94 | #print(dpd['price0'].iloc[-1],mini,maxi)
 95 | #print((dpd['price0'].iloc[-1],mini,maxi,amount0,amount1,decimal0,decimal1))
 96 | myliquidity = liquidity.get_liquidity(dpd['price0'].iloc[-1],mini,maxi,amount0,amount1,decimal0,decimal1)
 97 | 
 98 | print("OK myliquidity",myliquidity)
 99 | 
100 | # Calculate ActiveLiq
101 | 
102 | dpd['ActiveLiq'] = 0
103 | dpd['amount0'] = 0
104 | dpd['amount1'] = 0
105 | dpd['amount0unb'] = 0
106 | dpd['amount1unb'] = 0
107 | 
108 | if base == 0:
109 | 
110 |     for i, row in dpd.iterrows():
111 |         if dpd['high'].iloc[i]>mini and dpd['low'].iloc[i]<maxi:
112 |              dpd.iloc[i,dpd.columns.get_loc('ActiveLiq')] = (min(maxi,dpd['high'].iloc[i]) - max(dpd['low'].iloc[i],mini)) / (dpd['high'].iloc[i]-dpd['low'].iloc[i]) * 100
113 |         else:
114 |             dpd.iloc[i,dpd.columns.get_loc('ActiveLiq')] = 0
115 |        
116 |         amounts= liquidity.get_amounts(dpd['price0'].iloc[i],mini,maxi,myliquidity,decimal0,decimal1)
117 |         dpd.iloc[i,dpd.columns.get_loc('amount0')] = amounts[1]
118 |         dpd.iloc[i,dpd.columns.get_loc('amount1')]  = amounts[0]
119 |         
120 |         amountsunb= liquidity.get_amounts((dpd['price0'].iloc[i]),1.0001**(-887220),1.0001**887220,1,decimal0,decimal1)
121 |         dpd.iloc[i,dpd.columns.get_loc('amount0unb')] = amountsunb[1]
122 |         dpd.iloc[i,dpd.columns.get_loc('amount1unb')] = amountsunb[0]
123 | 
124 | 
125 | else:
126 | 
127 |     for i, row in dpd.iterrows():
128 | 
129 |         if (1/ dpd['low'].iloc[i])>mini and (1/dpd['high'].iloc[i])<maxi:
130 |             dpd.iloc[i,dpd.columns.get_loc('ActiveLiq')] = (min(maxi,1/dpd['low'].iloc[i]) - max(1/dpd['high'].iloc[i],mini)) / ((1/dpd['low'].iloc[i])-(1/dpd['high'].iloc[i])) * 100
131 |         else:
132 |             dpd.iloc[i,dpd.columns.get_loc('ActiveLiq')] = 0
133 | 
134 |         amounts= liquidity.get_amounts((dpd['price0'].iloc[i]*10**(decimal)),mini,maxi,myliquidity,decimal0,decimal1)
135 |         dpd.iloc[i,dpd.columns.get_loc('amount0')] = amounts[0]
136 |         dpd.iloc[i,dpd.columns.get_loc('amount1')] = amounts[1]
137 | 
138 |         amountsunb= liquidity.get_amounts((dpd['price0'].iloc[i]),1.0001**(-887220),1.0001**887220,1,decimal0,decimal1)
139 |         dpd.iloc[i,dpd.columns.get_loc('amount0unb')] = amountsunb[0]
140 |         dpd.iloc[i,dpd.columns.get_loc('amount1unb')] = amountsunb[1]
141 | 
142 | 
143 | 
144 | ## Final fee calculation
145 | 
146 | dpd['myfee0'] = dpd['fee0token'] * myliquidity * dpd['ActiveLiq'] / 100
147 | dpd['myfee1'] = dpd['fee1token'] * myliquidity * dpd['ActiveLiq'] / 100
148 | 
149 | #print(dpd)
150 | 
151 | a=charts.chart1(dpd,base,myliquidity)
152 | 
153 | 
154 | 


--------------------------------------------------------------------------------
/GraphBacktest.py:
--------------------------------------------------------------------------------
 1 | from gql import gql, Client
 2 | from gql.transport.requests import RequestsHTTPTransport
 3 | import pandas as pd
 4 | 
 5 | 
 6 | def graph(network,Adress,fromdate):
 7 | 
 8 |     if network == 1:
 9 | 
10 |         sample_transport=RequestsHTTPTransport(
11 |         url='https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3',
12 |         verify=True,
13 |         retries=5,
14 |         )
15 |         client = Client(
16 |         transport=sample_transport
17 |         )
18 | 
19 | 
20 |     elif network == 2:
21 |        
22 |         sample_transport=RequestsHTTPTransport(
23 |         url='https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-arbitrum-one',
24 |         verify=True,
25 |         retries=5,
26 |         )
27 |         client = Client(
28 |         transport=sample_transport
29 |         )
30 | 
31 |     elif network == 3:
32 |         sample_transport=RequestsHTTPTransport(
33 |         url='https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-optimism-dev',
34 |         verify=True,
35 |         retries=5,
36 |         )
37 |         client = Client(
38 |         transport=sample_transport
39 |         )
40 |     print(fromdate)
41 | 
42 |     query = gql('''
43 |     query ($fromdate: Int!)
44 |     {
45 |     poolHourDatas(where:{pool:"'''+str(Adress)+'''",periodStartUnix_gt:$fromdate},orderBy:periodStartUnix,orderDirection:desc,first:1000)
46 |     {
47 |     periodStartUnix
48 |     liquidity
49 |     high
50 |     low
51 |     pool{
52 |         
53 |         totalValueLockedUSD
54 |         totalValueLockedToken1
55 |         totalValueLockedToken0
56 |         token0
57 |             {decimals
58 |             }
59 |         token1
60 |             {decimals
61 |             }
62 |         }
63 |     close
64 |     feeGrowthGlobal0X128
65 |     feeGrowthGlobal1X128
66 |     }
67 |  
68 |     }
69 |     ''')
70 |     params = {
71 |     "fromdate": fromdate
72 |     }
73 | 
74 |     response = client.execute(query,variable_values=params)
75 |     dpd =pd.json_normalize(response['poolHourDatas'])
76 |     dpd=dpd.astype(float)
77 |     return dpd
78 | 
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # uniswap-v3-backtest-python


--------------------------------------------------------------------------------
/charts.py:
--------------------------------------------------------------------------------
  1 | import pandas as pd
  2 | 
  3 | 
  4 | def chart1(dpd,base,myliquidity):
  5 | 
  6 |     if base==0:
  7 |         dpd['feeV']= (dpd['myfee0'] )+ (dpd['myfee1']* dpd['close'])
  8 |         dpd['amountV']= (dpd['amount0'] ) + (dpd['amount1']* dpd['close'])
  9 |         dpd['amountunb']= (dpd['amount0unb'] )+ (dpd['amount1unb']* dpd['close'])
 10 |         dpd['fgV']= (dpd['fee0token'])+ (dpd['fee1token']* dpd['close'])
 11 |         dpd['feeusd']= dpd['feeV'] * (dpd['pool.totalValueLockedUSD'].iloc[0] / (dpd['pool.totalValueLockedToken1'].iloc[0]* dpd['close'].iloc[0]+(dpd['pool.totalValueLockedToken0'].iloc[0])))
 12 | 
 13 | 
 14 |     else:
 15 | 
 16 |         dpd['feeV']= (dpd['myfee0'] / dpd['close']) + dpd['myfee1']
 17 |         dpd['amountV']= (dpd['amount0'] / dpd['close'])+ dpd['amount1']
 18 |         dpd['feeVbase0']= dpd['myfee0'] + (dpd['myfee1']* dpd['close'])
 19 |         dpd['amountunb']= (dpd['amount0unb'] / dpd['close'])+ dpd['amount1unb']
 20 |         dpd['fgV']=(dpd['fee0token'] / dpd['close'])+ dpd['fee1token']
 21 |         dpd['feeusd']= dpd['feeV'] * ( dpd['pool.totalValueLockedUSD'].iloc[0] / (dpd['pool.totalValueLockedToken1'].iloc[0] + (dpd['pool.totalValueLockedToken0'].iloc[0]/dpd['close'].iloc[0])))
 22 | 
 23 |     dpd['date']=pd.to_datetime(dpd['periodStartUnix'],unit='s')
 24 | 
 25 |     # 1 Chart
 26 |     
 27 |     #dpd['fgV']= (dpd['fg0'] / dpd['close'].iloc[0] + dpd['fg1'])
 28 |     #rint(dpd['fg1']/dpd['amount1unb'])
 29 | 
 30 |     data=dpd[['date','myfee0','myfee1','fgV','feeV','feeusd','amountV','ActiveLiq','amountunb','amount0','amount1','close']]
 31 |     data=data.fillna(0)
 32 | 
 33 |     temp =  data.resample('D',on='date').sum()
 34 |     final1=temp[['myfee0','myfee1','feeV','fgV','feeusd']].copy()
 35 | 
 36 |     temp2 = data.resample('D',on='date').mean()
 37 |     final1['ActiveLiq']=temp2['ActiveLiq'].copy()
 38 |     
 39 |     temp3 = data.resample('D',on='date').first()
 40 |     final1[['amountV','amountunb']]=temp3[['amountV','amountunb']].copy()
 41 |     temp4 = data.resample('D',on='date').last()
 42 |     final1[['amountVlast']]=temp4[['amountV']]
 43 | 
 44 |     final1['S1%']=final1['feeV']/final1['amountV']*100#*365
 45 |     final1['unb%']=final1['fgV']/final1['amountunb']*100#*365
 46 |     final1['multiplier']=final1['S1%']/final1['unb%']
 47 |     final1['feeunb'] = final1['amountV']*final1['unb%']/100
 48 |     final1.to_csv("chart1.csv",sep = ";")
 49 |     
 50 |     print(final1[['feeunb','feeV','feeusd','amountV','ActiveLiq','S1%','unb%','ActiveLiq']])
 51 | 
 52 |     print('------------------------------------------------------------------')
 53 |     print("this position returned", final1['feeV'].sum()/final1['amountV'].iloc[0]*100,"in ",len(final1.index)," days, for an apr of ",final1['feeV'].sum()/final1['amountV'].iloc[0]*365/len(final1.index)*100)
 54 |     print("a base  position returned", final1['feeunb'].sum()/final1['amountV'].iloc[0]*100,"in ",len(final1.index)," days, for an apr of ",final1['feeunb'].sum()/final1['amountV'].iloc[0]*365/len(final1.index)*100)
 55 |     
 56 |     print ("fee in token 1 and token 2",dpd['myfee0'].sum(),dpd['myfee1'].sum() )
 57 |     print("totalFee in USD", final1['feeusd'].sum())
 58 |     print ('Your liquidity was active for:',final1['ActiveLiq'].mean())
 59 |     forecast= (dpd['feeVbase0'].sum()*myliquidity*final1['ActiveLiq'].mean())
 60 |     print(dpd['feeVbase0'])
 61 |     print('forecast: ',forecast)
 62 |     print('------------------------------------------------------------------')
 63 |     # 1 chart e' completo
 64 |     
 65 |     # 2 chart
 66 | 
 67 |     
 68 |     final2=temp3[['amountV','amount0','amount1','close']].copy()
 69 |     final2['feeV']=temp['feeV'].copy()
 70 |     final2[['amountVlast']]=temp4[['amountV']]
 71 |     
 72 | 
 73 | 
 74 |     final2['HODL']=final2['amount0'].iloc[0] / final2['close'] + final2['amount1'].iloc[0]
 75 |     
 76 |     final2['IL']=final2['amountVlast']- final2['HODL']
 77 |     final2['ActiveLiq']=temp2['ActiveLiq'].copy()
 78 |     final2['feecumsum']=final2['feeV'].cumsum()
 79 |     final2 ['PNL']= final2['feecumsum'] + final2['IL']#-Bfinal['gas']
 80 | 
 81 |     final2['HODLnorm']=final2['HODL']/final2['amountV'].iloc[0]*100
 82 |     final2['ILnorm']=final2['IL']/final2['amountV'].iloc[0]*100
 83 |     final2['PNLnorm']=final2['PNL']/final2['amountV'].iloc[0]*100
 84 |     final2['feecumsumnorm'] = final2['feecumsum']/final2['amountV'].iloc[0]*100
 85 |     ch2=final2[['amountV','feecumsum']]
 86 |     ch3=final2[['ILnorm','PNLnorm','feecumsumnorm']]
 87 | 
 88 |     final2.to_csv("chart2.csv",sep = ";")
 89 |     print(ch2)
 90 |     print(ch3)
 91 | 
 92 |     #final3=data
 93 |     final3=pd.DataFrame()
 94 |     final3['amountV']=data['amountV']
 95 | 
 96 |     final3['amountVlast']=data['amountV'].shift(-1)
 97 |     final3['date']=data['date']
 98 |     final3['HODL']=data['amount0'].iloc[0] / data['close'] + data['amount1'].iloc[0]
 99 | 
100 |     final3['amountVlast'].iloc[-1]=final3['HODL'].iloc[-1]
101 |     final3['IL']=final3['amountVlast']- final3['HODL']
102 |     final3['feecumsum']=data['feeV'][::-1].cumsum()
103 |     final3 ['PNL']= final3['feecumsum'] + final3['IL']
104 |     final3['HODLnorm']=final3['HODL']/final3['amountV'].iloc[0]*100
105 |     final3['ILnorm']=final3['IL']/final3['amountV'].iloc[0]*100
106 |     final3['PNLnorm']=final3['PNL']/final3['amountV'].iloc[0]*100
107 |     final3['feecumsumnorm'] = final3['feecumsum']/final3['amountV'].iloc[0]*100
108 | 
109 |     ch2=final3[['amountV','feecumsum']]
110 |     ch3=final3[['ILnorm','PNLnorm','feecumsumnorm']]
111 | 
112 | 
113 |     print(ch2)
114 |     print(ch3)
115 | 
116 | 
117 | 
118 |    
119 |     
120 |    
121 | 
122 |     
123 | 
124 |     


--------------------------------------------------------------------------------
/liquidity.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | 
 3 | 
 4 | def get_amount0(sqrtA,sqrtB,liquidity,decimals):
 5 |     
 6 |     if (sqrtA > sqrtB):
 7 |           (sqrtA,sqrtB)=(sqrtB,sqrtA)
 8 |     
 9 |     amount0=((liquidity*2**96*(sqrtB-sqrtA)/sqrtB/sqrtA)/10**decimals)
10 |     
11 |     return amount0
12 | 
13 | def get_amount1(sqrtA,sqrtB,liquidity,decimals):
14 |     
15 |     if (sqrtA > sqrtB):
16 |         (sqrtA,sqrtB)=(sqrtB,sqrtA)
17 |     
18 |     amount1=liquidity*(sqrtB-sqrtA)/2**96/10**decimals
19 |     
20 |     return amount1
21 | 
22 | def get_amounts(asqrt,asqrtA,asqrtB,liquidity,decimal0,decimal1):
23 | 
24 |     sqrt=(np.sqrt(asqrt*10**(decimal1-decimal0)))*(2**96)
25 |     sqrtA=np.sqrt(asqrtA*10**(decimal1-decimal0))*(2**96)
26 |     sqrtB=np.sqrt(asqrtB*10**(decimal1-decimal0))*(2**96)
27 | 
28 |     if (sqrtA > sqrtB):
29 |         (sqrtA,sqrtB)=(sqrtB,sqrtA)
30 | 
31 |     if sqrt<=sqrtA:
32 | 
33 |         amount0=get_amount0(sqrtA,sqrtB,liquidity,decimal0)
34 |         return amount0,0
35 |    
36 |     elif sqrt<sqrtB and sqrt>sqrtA:
37 |         amount0=get_amount0(sqrt,sqrtB,liquidity,decimal0)
38 |    
39 |         amount1=get_amount1(sqrtA,sqrt,liquidity,decimal1)
40 |        
41 |         return amount0,amount1
42 |     
43 |     else:
44 |         amount1=get_amount1(sqrtA,sqrtB,liquidity,decimal1)
45 |         return 0,amount1      
46 | 
47 | 
48 | 
49 | '''get_liquidity function'''
50 | #Use 'get_liquidity' function to calculate liquidity as a function of amounts and price range
51 | def get_liquidity0(sqrtA,sqrtB,amount0,decimals):
52 |     if (sqrtA > sqrtB):
53 |           (sqrtA,sqrtB)=(sqrtB,sqrtA)
54 |     
55 |     liquidity=amount0/((2**96*(sqrtB-sqrtA)/sqrtB/sqrtA)/10**decimals)
56 |     return liquidity
57 | 
58 | def get_liquidity1(sqrtA,sqrtB,amount1,decimals):
59 |     
60 |     if (sqrtA > sqrtB):
61 |         (sqrtA,sqrtB)=(sqrtB,sqrtA)
62 |     
63 |     liquidity=amount1/((sqrtB-sqrtA)/2**96/10**decimals)
64 |     return liquidity
65 | 
66 | def get_liquidity(asqrt,asqrtA,asqrtB,amount0,amount1,decimal0,decimal1):
67 |     
68 |         sqrt=(np.sqrt(asqrt*10**(decimal1-decimal0)))*(2**96)
69 |         sqrtA=np.sqrt(asqrtA*10**(decimal1-decimal0))*(2**96)
70 |         sqrtB=np.sqrt(asqrtB*10**(decimal1-decimal0))*(2**96)
71 | 
72 |         
73 |         if (sqrtA > sqrtB):
74 |             (sqrtA,sqrtB)=(sqrtB,sqrtA)
75 |     
76 |         if sqrt<=sqrtA:
77 |             
78 |             liquidity0=get_liquidity0(sqrtA,sqrtB,amount0,decimal0)
79 |             return liquidity0
80 |         elif sqrt<sqrtB and sqrt>sqrtA:
81 |            
82 |             liquidity0=get_liquidity0(sqrt,sqrtB,amount0,decimal0)
83 |             liquidity1=get_liquidity1(sqrtA,sqrt,amount1,decimal1)
84 |             liquidity=liquidity0 if liquidity0<liquidity1 else liquidity1
85 |             return liquidity
86 |         
87 |         else:
88 |             liquidity1=get_liquidity1(sqrtA,sqrtB,amount1,decimal1)
89 |             return liquidity1


--------------------------------------------------------------------------------