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, _ := wdelayerClientTest.client.EthLastBlock()
45 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
46 assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezGovernanceDAOAddress[0].NewHermezGovernanceDAOAddress)
47 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
48 require.Nil(t, err)
49 _, err = wdelayerClientAux.WDelayerSetHermezGovernanceDAOAddress(hermezGovernanceDAOAddressConst)
50 require.Nil(t, err)
51}
52
53func TestWDelayerGetHermezKeeperAddress(t *testing.T) {
54 keeperAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
55 require.Nil(t, err)
56 assert.Equal(t, &hermezKeeperAddressConst, keeperAddress)
57}
58
59func TestWDelayerSetHermezKeeperAddress(t *testing.T) {
60 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
61 require.Nil(t, err)
62 _, err = wdelayerClientKep.WDelayerSetHermezKeeperAddress(auxAddressConst)
63 require.Nil(t, err)
64 auxAddress, err := wdelayerClientTest.WDelayerGetHermezKeeperAddress()
65 require.Nil(t, err)
66 assert.Equal(t, &auxAddressConst, auxAddress)
67 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
68 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
69 assert.Equal(t, auxAddressConst, wdelayerEvents.NewHermezKeeperAddress[0].NewHermezKeeperAddress)
70 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
71 require.Nil(t, err)
72 _, err = wdelayerClientAux.WDelayerSetHermezKeeperAddress(hermezKeeperAddressConst)
73 require.Nil(t, err)
74}
75
76func TestWDelayerGetWhiteHackGroupAddress(t *testing.T) {
77 whiteHackGroupAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
78 require.Nil(t, err)
79 assert.Equal(t, &whiteHackGroupAddressConst, whiteHackGroupAddress)
80}
81
82func TestWDelayerSetWhiteHackGroupAddress(t *testing.T) {
83 wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
84 require.Nil(t, err)
85 _, err = wdelayerClientWhite.WDelayerSetWhiteHackGroupAddress(auxAddressConst)
86 require.Nil(t, err)
87 auxAddress, err := wdelayerClientTest.WDelayerGetWhiteHackGroupAddress()
88 require.Nil(t, err)
89 assert.Equal(t, &auxAddressConst, auxAddress)
90 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
91 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
92 assert.Equal(t, auxAddressConst, wdelayerEvents.NewWhiteHackGroupAddress[0].NewWhiteHackGroupAddress)
93 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
94 require.Nil(t, err)
95 _, err = wdelayerClientAux.WDelayerSetWhiteHackGroupAddress(whiteHackGroupAddressConst)
96 require.Nil(t, err)
97}
98
99func TestWDelayerIsEmergencyMode(t *testing.T) {
100 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
101 require.Nil(t, err)
102 assert.Equal(t, false, emergencyMode)
103}
104
105func TestWDelayerGetWithdrawalDelay(t *testing.T) {
106 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
107 require.Nil(t, err)
108 assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
109}
110
111func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
112 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
113 require.Nil(t, err)
114 _, err = wdelayerClientKep.WDelayerChangeWithdrawalDelay(newWithdrawalDelay.Uint64())
115 require.Nil(t, err)
116 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
117 require.Nil(t, err)
118 assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
119 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
120 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
121 assert.Equal(t, newWithdrawalDelay.Uint64(), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
122}
123
124func TestWDelayerDeposit(t *testing.T) {
125 amount := new(big.Int)
126 amount.SetString("1100000000000000000", 10)
127 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
128 require.Nil(t, err)
129 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
130 require.Nil(t, err)
131 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
132 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
133 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
134 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
135 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
136}
137
138func TestWDelayerDepositInfo(t *testing.T) {
139 amount := new(big.Int)
140 amount.SetString("1100000000000000000", 10)
141 state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenHEZAddressConst)
142 require.Nil(t, err)
143 assert.Equal(t, state.Amount, amount)
144}
145
146func TestWDelayerWithdrawal(t *testing.T) {
147 amount := new(big.Int)
148 amount.SetString("1100000000000000000", 10)
149 _, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
150 require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
151 addTime(float64(newWithdrawalDelay.Int64()), ethClientDialURL)
152 addBlock(ethClientDialURL)
153 _, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
154 require.Nil(t, err)
155 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
156 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
157 assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
158 assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
159 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Withdraw[0].Token)
160}
161
162func TestWDelayerSecondDeposit(t *testing.T) {
163 amount := new(big.Int)
164 amount.SetString("1100000000000000000", 10)
165 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
166 require.Nil(t, err)
167 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
168 require.Nil(t, err)
169 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
170 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
171 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
172 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
173 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
174}
175
176func TestWDelayerEnableEmergencyMode(t *testing.T) {
177 wdelayerClientKep, err := NewWDelayerClient(ethereumClientKep, wdelayerTestAddressConst)
178 require.Nil(t, err)
179 _, err = wdelayerClientKep.WDelayerEnableEmergencyMode()
180 require.Nil(t, err)
181 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
182 require.Nil(t, err)
183 assert.Equal(t, true, emergencyMode)
184 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
185 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
186 auxEvent := new(WDelayerEventEmergencyModeEnabled)
187 assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
188}
189
190func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
191 emergencyModeStartingTime, err := wdelayerClientTest.WDelayerGetEmergencyModeStartingTime()
192 require.Nil(t, err)
193 // `emergencyModeStartingTime` is initialized to 0 in the smart
194 // contract construction. Since we called WDelayerEnableEmergencyMode
195 // previously, `emergencyModeStartingTime` is set to the time when the
196 // call was made, so it's > 0.
197 assert.True(t, emergencyModeStartingTime.Cmp(big.NewInt(0)) == 1)
198}
199
200func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
201 amount := new(big.Int)
202 amount.SetString("10000000000000000", 10)
203 wdelayerClientWhite, err := NewWDelayerClient(ethereumClientWhite, wdelayerTestAddressConst)
204 require.Nil(t, err)
205 _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
206 require.Contains(t, err.Error(), "NO_MAX_EMERGENCY_MODE_TIME")
207 seconds := maxEmergencyModeTime.Seconds()
208 addTime(seconds, ethClientDialURL)
209 _, err = wdelayerClientWhite.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
210 require.Nil(t, err)
211 currentBlockNum, _ := wdelayerClientTest.client.EthLastBlock()
212 wdelayerEvents, _, _ := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum)
213 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
214 assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
215 assert.Equal(t, whiteHackGroupAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
216 assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
217}