hermez-node/eth/wdelayer_test.go
eth/wdelayer_test.goRaw
1package eth
2
3import (
4 "math/big"
5 "testing"
6 "time"
7
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10)
11
12var wdelayerClient *WDelayerClient
13var wdelayerClientTest *WDelayerClient
14
15// var wdelayerClientKep *WDelayerClient
16
17var initWithdrawalDelay = big.NewInt(60)
18var newWithdrawalDelay = big.NewInt(79)
19var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
20var maxWithdrawalDelay = time.Hour * 24 * 7 * 2
21
22func TestWDelayerConstants(t *testing.T) {
23 wDelayerConstants, err := wdelayerClientTest.WDelayerConstants()
24 require.Nil(t, err)
25 assert.Equal(t, uint64(maxWithdrawalDelay.Seconds()), wDelayerConstants.MaxWithdrawalDelay)
26 assert.Equal(t, uint64(maxEmergencyModeTime.Seconds()), wDelayerConstants.MaxEmergencyModeTime)
27 assert.Equal(t, hermezRollupTestAddressConst, wDelayerConstants.HermezRollup)
28}
29
30func TestWDelayerGetHermezGovernanceDAOAddress(t *testing.T) {
31 governanceAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceDAOAddress()
32 require.Nil(t, err)
33 assert.Equal(t, &hermezGovernanceDAOAddressConst, governanceAddress)
34}
35
36func TestWDelayerSetHermezGovernanceDAOAddress(t *testing.T) {
37 wdelayerClientGov, err := NewWDelayerClient(ethereumClientGovDAO, wdelayerTestAddressConst)
38 require.Nil(t, err)
39 _, err = wdelayerClientGov.WDelayerSetHermezGovernanceDAOAddress(auxAddressConst)
40 require.Nil(t, err)
41 auxAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceDAOAddress()
42 require.Nil(t, err)
43 assert.Equal(t, &auxAddressConst, auxAddress)
44 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
45 require.Nil(t, err)
46 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
47 require.Nil(t, err)
48 assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceDAOAddress[0].NewHermezGovernanceDAOAddress)
49 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
50 require.Nil(t, err)
51 _, err = wdelayerClientAux.WDelayerSetHermezGovernanceDAOAddress(hermezGovernanceDAOAddressConst)
52 require.Nil(t, err)
53}
54
55func TestWDelayerGetHermezKeeperAddress(t *testing.T) {
56 keeperAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
57 require.Nil(t, err)
58 assert.Equal(t, &hermezKeeperAddressConst, keeperAddress)
59}
60
61func TestWDelayerSetHermezKeeperAddress(t *testing.T) {
62 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
63 require.Nil(t, err)
64 _, err = wdelayerClientKep.WDelayerSetHermezKeeperAddress(auxAddressConst)
65 require.Nil(t, err)
66 auxAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
67 require.Nil(t, err)
68 assert.Equal(t, &auxAddressConst, auxAddress)
69 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
70 require.Nil(t, err)
71 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
72 require.Nil(t, err)
73 assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezKeeperAddress[0].NewHermezKeeperAddress)
74 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
75 require.Nil(t, err)
76 _, err = wdelayerClientAux.WDelayerSetHermezKeeperAddress(hermezKeeperAddressConst)
77 require.Nil(t, err)
78}
79
80func TestWDelayerGetWhiteHackGroupAddress(t *testing.T) {
81 whiteHackGroupAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
82 require.Nil(t, err)
83 assert.Equal(t, &whiteHackGroupAddressConst, whiteHackGroupAddress)
84}
85
86func TestWDelayerSetWhiteHackGroupAddress(t *testing.T) {
87 wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
88 require.Nil(t, err)
89 _, err = wdelayerClientWhite.WDelayerSetWhiteHackGroupAddress(auxAddressConst)
90 require.Nil(t, err)
91 auxAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
92 require.Nil(t, err)
93 assert.Equal(t, &auxAddressConst, auxAddress)
94 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
95 require.Nil(t, err)
96 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
97 require.Nil(t, err)
98 assert.Equal(t, auxAddressConst, wdelayerEvents.NewWhiteHackGroupAddress[0].NewWhiteHackGroupAddress)
99 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
100 require.Nil(t, err)
101 _, err = wdelayerClientAux.WDelayerSetWhiteHackGroupAddress(whiteHackGroupAddressConst)
102 require.Nil(t, err)
103}
104
105func TestWDelayerIsEmergencyMode(t *testing.T) {
106 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
107 require.Nil(t, err)
108 assert.Equal(t, false, emergencyMode)
109}
110
111func TestWDelayerGetWithdrawalDelay(t *testing.T) {
112 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
113 require.Nil(t, err)
114 assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
115}
116
117func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
118 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
119 require.Nil(t, err)
120 _, err = wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
121 require.Nil(t, err)
122 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
123 require.Nil(t, err)
124 assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
125 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
126 require.Nil(t, err)
127 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
128 require.Nil(t, err)
129 assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
130}
131
132func TestWDelayerDeposit(t *testing.T) {
133 amount := new(big.Int)
134 amount.SetString("1100000000000000000", 10)
135 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
136 require.Nil(t, err)
137 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
138 require.Nil(t, err)
139 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
140 require.Nil(t, err)
141 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
142 require.Nil(t, err)
143 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
144 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
145 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
146}
147
148func TestWDelayerDepositInfo(t *testing.T) {
149 amount := new(big.Int)
150 amount.SetString("1100000000000000000", 10)
151 state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenHEZAddressConst)
152 require.Nil(t, err)
153 assert.Equal(t, state.Amount, amount)
154}
155
156func TestWDelayerWithdrawal(t *testing.T) {
157 amount := new(big.Int)
158 amount.SetString("1100000000000000000", 10)
159 _, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
160 require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
161 addTime(float64(newWithdrawalDelay.Int64()), ethClientDialURL)
162 addBlock(ethClientDialURL)
163 _, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
164 require.Nil(t, err)
165 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
166 require.Nil(t, err)
167 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
168 require.Nil(t, err)
169 assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
170 assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
171 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Withdraw[0].Token)
172}
173
174func TestWDelayerSecondDeposit(t *testing.T) {
175 amount := new(big.Int)
176 amount.SetString("1100000000000000000", 10)
177 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
178 require.Nil(t, err)
179 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
180 require.Nil(t, err)
181 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
182 require.Nil(t, err)
183 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
184 require.Nil(t, err)
185 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
186 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
187 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
188}
189
190func TestWDelayerEnableEmergencyMode(t *testing.T) {
191 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
192 require.Nil(t, err)
193 _, err = wdelayerClientKep.WDelayerEnableEmergencyMode()
194 require.Nil(t, err)
195 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
196 require.Nil(t, err)
197 assert.Equal(t, true, emergencyMode)
198 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
199 require.Nil(t, err)
200 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
201 require.Nil(t, err)
202 auxEvent := new(WDelayerEventEmergencyModeEnabled)
203 assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
204}
205
206func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
207 emergencyModeStartingTime, err := wdelayerClientTest.WDelayerGetEmergencyModeStartingTime()
208 require.Nil(t, err)
209 // `emergencyModeStartingTime` is initialized to 0 in the smart
210 // contract construction. Since we called WDelayerEnableEmergencyMode
211 // previously, `emergencyModeStartingTime` is set to the time when the
212 // call was made, so it's > 0.
213 assert.True(t, emergencyModeStartingTime.Cmp(big.NewInt(0)) == 1)
214}
215
216func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
217 amount := new(big.Int)
218 amount.SetString("10000000000000000", 10)
219 wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
220 require.Nil(t, err)
221 _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
222 require.Contains(t, err.Error(), "NO_MAX_EMERGENCY_MODE_TIME")
223 seconds := maxEmergencyModeTime.Seconds()
224 addTime(seconds, ethClientDialURL)
225 _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
226 require.Nil(t, err)
227 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
228 require.Nil(t, err)
229 wdelayerEvents, _, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
230 require.Nil(t, err)
231 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
232 assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
233 assert.Equal(t, whiteHackGroupAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
234 assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
235}