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
15var initWithdrawalDelay int64 = 60
16var newWithdrawalDelay int64 = 79
17var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
18var maxWithdrawalDelay = time.Hour * 24 * 7 * 2
19
20func TestWDelayerInit(t *testing.T) {
21 wDelayerInit, blockNum, err := wdelayerClientTest.WDelayerEventInit()
22 require.NoError(t, err)
23 assert.Equal(t, int64(16), blockNum)
24 assert.Equal(t, uint64(initWithdrawalDelay), wDelayerInit.InitialWithdrawalDelay)
25 assert.Equal(t, governanceAddressConst, wDelayerInit.InitialHermezGovernanceAddress)
26 assert.Equal(t, emergencyCouncilAddressConst, wDelayerInit.InitialEmergencyCouncil)
27}
28
29func TestWDelayerConstants(t *testing.T) {
30 wDelayerConstants, err := wdelayerClientTest.WDelayerConstants()
31 require.Nil(t, err)
32 assert.Equal(t, uint64(maxWithdrawalDelay.Seconds()), wDelayerConstants.MaxWithdrawalDelay)
33 assert.Equal(t, uint64(maxEmergencyModeTime.Seconds()), wDelayerConstants.MaxEmergencyModeTime)
34 assert.Equal(t, hermezRollupTestAddressConst, wDelayerConstants.HermezRollup)
35}
36
37func TestWDelayerGetHermezGovernanceAddress(t *testing.T) {
38 governanceAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceAddress()
39 require.Nil(t, err)
40 assert.Equal(t, &governanceAddressConst, governanceAddress)
41}
42
43func TestWDelayerSetHermezGovernanceAddress(t *testing.T) {
44 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
45 require.Nil(t, err)
46 _, err = wdelayerClientTest.WDelayerTransferGovernance(auxAddressConst)
47 require.Nil(t, err)
48 _, err = wdelayerClientAux.WDelayerClaimGovernance()
49 require.Nil(t, err)
50 auxAddress, err := wdelayerClientTest.WDelayerGetHermezGovernanceAddress()
51 require.Nil(t, err)
52 assert.Equal(t, &auxAddressConst, auxAddress)
53 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
54 require.Nil(t, err)
55 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
56 require.Nil(t, err)
57 assert.Equal(t, auxAddressConst,
58 wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
59 _, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)
60 require.Nil(t, err)
61 _, err = wdelayerClientTest.WDelayerClaimGovernance()
62 require.Nil(t, err)
63}
64
65func TestWDelayerGetEmergencyCouncil(t *testing.T) {
66 emergencyCouncil, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
67 require.Nil(t, err)
68 assert.Equal(t, &emergencyCouncilAddressConst, emergencyCouncil)
69}
70
71func TestWDelayerSetEmergencyCouncil(t *testing.T) {
72 wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil,
73 wdelayerTestAddressConst)
74 require.Nil(t, err)
75 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
76 require.Nil(t, err)
77 _, err = wdelayerClientEmergencyCouncil.WDelayerTransferEmergencyCouncil(auxAddressConst)
78 require.Nil(t, err)
79 _, err = wdelayerClientAux.WDelayerClaimEmergencyCouncil()
80 require.Nil(t, err)
81 auxAddress, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
82 require.Nil(t, err)
83 assert.Equal(t, &auxAddressConst, auxAddress)
84 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
85 require.Nil(t, err)
86 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
87 require.Nil(t, err)
88 assert.Equal(t, auxAddressConst, wdelayerEvents.NewEmergencyCouncil[0].NewEmergencyCouncil)
89 _, err = wdelayerClientAux.WDelayerTransferEmergencyCouncil(emergencyCouncilAddressConst)
90 require.Nil(t, err)
91 _, err = wdelayerClientEmergencyCouncil.WDelayerClaimEmergencyCouncil()
92 require.Nil(t, err)
93}
94
95func TestWDelayerIsEmergencyMode(t *testing.T) {
96 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
97 require.Nil(t, err)
98 assert.Equal(t, false, emergencyMode)
99}
100
101func TestWDelayerGetWithdrawalDelay(t *testing.T) {
102 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
103 require.Nil(t, err)
104 assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
105}
106
107func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
108 _, err := wdelayerClientTest.WDelayerChangeWithdrawalDelay(uint64(newWithdrawalDelay))
109 require.Nil(t, err)
110 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
111 require.Nil(t, err)
112 assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
113 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
114 require.Nil(t, err)
115 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
116 require.Nil(t, err)
117 assert.Equal(t, uint64(newWithdrawalDelay), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
118}
119
120func TestWDelayerDeposit(t *testing.T) {
121 amount := new(big.Int)
122 amount.SetString("1100000000000000000", 10)
123 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
124 require.Nil(t, err)
125 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
126 require.Nil(t, err)
127 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
128 require.Nil(t, err)
129 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
130 require.Nil(t, err)
131 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
132 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
133 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
134}
135
136func TestWDelayerDepositInfo(t *testing.T) {
137 amount := new(big.Int)
138 amount.SetString("1100000000000000000", 10)
139 state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenHEZAddressConst)
140 require.Nil(t, err)
141 assert.Equal(t, state.Amount, amount)
142}
143
144func TestWDelayerWithdrawal(t *testing.T) {
145 amount := new(big.Int)
146 amount.SetString("1100000000000000000", 10)
147 _, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
148 require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
149 addTime(float64(newWithdrawalDelay), ethClientDialURL)
150 addBlock(ethClientDialURL)
151 _, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
152 require.Nil(t, err)
153 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
154 require.Nil(t, err)
155 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
156 require.Nil(t, err)
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, err := wdelayerClientTest.client.EthLastBlock()
170 require.Nil(t, err)
171 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
172 require.Nil(t, err)
173 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
174 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
175 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
176}
177
178func TestWDelayerEnableEmergencyMode(t *testing.T) {
179 _, err := wdelayerClientTest.WDelayerEnableEmergencyMode()
180 require.Nil(t, err)
181 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
182 require.Nil(t, err)
183 assert.Equal(t, true, emergencyMode)
184 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
185 require.Nil(t, err)
186 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
187 require.Nil(t, err)
188 auxEvent := new(WDelayerEventEmergencyModeEnabled)
189 assert.Equal(t, auxEvent, &wdelayerEvents.EmergencyModeEnabled[0])
190}
191
192func TestWDelayerGetEmergencyModeStartingTime(t *testing.T) {
193 emergencyModeStartingTime, err := wdelayerClientTest.WDelayerGetEmergencyModeStartingTime()
194 require.Nil(t, err)
195 // `emergencyModeStartingTime` is initialized to 0 in the smart
196 // contract construction. Since we called WDelayerEnableEmergencyMode
197 // previously, `emergencyModeStartingTime` is set to the time when the
198 // call was made, so it's > 0.
199 assert.Greater(t, emergencyModeStartingTime, int64(0))
200}
201
202func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
203 amount := new(big.Int)
204 amount.SetString("10000000000000000", 10)
205 wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil,
206 wdelayerTestAddressConst)
207 require.Nil(t, err)
208 _, err =
209 wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst,
210 tokenHEZAddressConst, amount)
211 require.Contains(t, err.Error(), "NO_MAX_EMERGENCY_MODE_TIME")
212 seconds := maxEmergencyModeTime.Seconds()
213 addTime(seconds, ethClientDialURL)
214 _, err =
215 wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst,
216 tokenHEZAddressConst, amount)
217 require.Nil(t, err)
218 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
219 require.Nil(t, err)
220 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
221 require.Nil(t, err)
222 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
223 assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
224 assert.Equal(t, emergencyCouncilAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
225 assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
226}