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, wdelayerEvents.NewHermezGovernanceAddress[0].NewHermezGovernanceAddress)
58 _, err = wdelayerClientAux.WDelayerTransferGovernance(governanceAddressConst)
59 require.Nil(t, err)
60 _, err = wdelayerClientTest.WDelayerClaimGovernance()
61 require.Nil(t, err)
62}
63
64func TestWDelayerGetEmergencyCouncil(t *testing.T) {
65 emergencyCouncil, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
66 require.Nil(t, err)
67 assert.Equal(t, &emergencyCouncilAddressConst, emergencyCouncil)
68}
69
70func TestWDelayerSetEmergencyCouncil(t *testing.T) {
71 wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
72 require.Nil(t, err)
73 wdelayerClientAux, err := NewWDelayerClient(ethereumClientAux, wdelayerTestAddressConst)
74 require.Nil(t, err)
75 _, err = wdelayerClientEmergencyCouncil.WDelayerTransferEmergencyCouncil(auxAddressConst)
76 require.Nil(t, err)
77 _, err = wdelayerClientAux.WDelayerClaimEmergencyCouncil()
78 require.Nil(t, err)
79 auxAddress, err := wdelayerClientTest.WDelayerGetEmergencyCouncil()
80 require.Nil(t, err)
81 assert.Equal(t, &auxAddressConst, auxAddress)
82 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
83 require.Nil(t, err)
84 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
85 require.Nil(t, err)
86 assert.Equal(t, auxAddressConst, wdelayerEvents.NewEmergencyCouncil[0].NewEmergencyCouncil)
87 _, err = wdelayerClientAux.WDelayerTransferEmergencyCouncil(emergencyCouncilAddressConst)
88 require.Nil(t, err)
89 _, err = wdelayerClientEmergencyCouncil.WDelayerClaimEmergencyCouncil()
90 require.Nil(t, err)
91}
92
93func TestWDelayerIsEmergencyMode(t *testing.T) {
94 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
95 require.Nil(t, err)
96 assert.Equal(t, false, emergencyMode)
97}
98
99func TestWDelayerGetWithdrawalDelay(t *testing.T) {
100 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
101 require.Nil(t, err)
102 assert.Equal(t, initWithdrawalDelay, withdrawalDelay)
103}
104
105func TestWDelayerChangeWithdrawalDelay(t *testing.T) {
106 _, err := wdelayerClientTest.WDelayerChangeWithdrawalDelay(uint64(newWithdrawalDelay))
107 require.Nil(t, err)
108 withdrawalDelay, err := wdelayerClientTest.WDelayerGetWithdrawalDelay()
109 require.Nil(t, err)
110 assert.Equal(t, newWithdrawalDelay, withdrawalDelay)
111 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
112 require.Nil(t, err)
113 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
114 require.Nil(t, err)
115 assert.Equal(t, uint64(newWithdrawalDelay), wdelayerEvents.NewWithdrawalDelay[0].WithdrawalDelay)
116}
117
118func TestWDelayerDeposit(t *testing.T) {
119 amount := new(big.Int)
120 amount.SetString("1100000000000000000", 10)
121 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
122 require.Nil(t, err)
123 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
124 require.Nil(t, err)
125 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
126 require.Nil(t, err)
127 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
128 require.Nil(t, err)
129 assert.Equal(t, amount, wdelayerEvents.Deposit[0].Amount)
130 assert.Equal(t, auxAddressConst, wdelayerEvents.Deposit[0].Owner)
131 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Deposit[0].Token)
132}
133
134func TestWDelayerDepositInfo(t *testing.T) {
135 amount := new(big.Int)
136 amount.SetString("1100000000000000000", 10)
137 state, err := wdelayerClientTest.WDelayerDepositInfo(auxAddressConst, tokenHEZAddressConst)
138 require.Nil(t, err)
139 assert.Equal(t, state.Amount, amount)
140}
141
142func TestWDelayerWithdrawal(t *testing.T) {
143 amount := new(big.Int)
144 amount.SetString("1100000000000000000", 10)
145 _, err := wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
146 require.Contains(t, err.Error(), "WITHDRAWAL_NOT_ALLOWED")
147 addTime(float64(newWithdrawalDelay), ethClientDialURL)
148 addBlock(ethClientDialURL)
149 _, err = wdelayerClientTest.WDelayerWithdrawal(auxAddressConst, tokenHEZAddressConst)
150 require.Nil(t, err)
151 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
152 require.Nil(t, err)
153 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
154 require.Nil(t, err)
155 assert.Equal(t, amount, wdelayerEvents.Withdraw[0].Amount)
156 assert.Equal(t, auxAddressConst, wdelayerEvents.Withdraw[0].Owner)
157 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.Withdraw[0].Token)
158}
159
160func TestWDelayerSecondDeposit(t *testing.T) {
161 amount := new(big.Int)
162 amount.SetString("1100000000000000000", 10)
163 wdelayerClientHermez, err := NewWDelayerClient(ethereumClientHermez, wdelayerTestAddressConst)
164 require.Nil(t, err)
165 _, err = wdelayerClientHermez.WDelayerDeposit(auxAddressConst, tokenHEZAddressConst, amount)
166 require.Nil(t, err)
167 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
168 require.Nil(t, err)
169 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
170 require.Nil(t, err)
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 _, err := wdelayerClientTest.WDelayerEnableEmergencyMode()
178 require.Nil(t, err)
179 emergencyMode, err := wdelayerClientTest.WDelayerIsEmergencyMode()
180 require.Nil(t, err)
181 assert.Equal(t, true, emergencyMode)
182 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
183 require.Nil(t, err)
184 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
185 require.Nil(t, err)
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.Greater(t, emergencyModeStartingTime, int64(0))
198}
199
200func TestWDelayerEscapeHatchWithdrawal(t *testing.T) {
201 amount := new(big.Int)
202 amount.SetString("10000000000000000", 10)
203 wdelayerClientEmergencyCouncil, err := NewWDelayerClient(ethereumClientEmergencyCouncil, wdelayerTestAddressConst)
204 require.Nil(t, err)
205 _, err = wdelayerClientEmergencyCouncil.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 = wdelayerClientEmergencyCouncil.WDelayerEscapeHatchWithdrawal(governanceAddressConst, tokenHEZAddressConst, amount)
210 require.Nil(t, err)
211 currentBlockNum, err := wdelayerClientTest.client.EthLastBlock()
212 require.Nil(t, err)
213 wdelayerEvents, err := wdelayerClientTest.WDelayerEventsByBlock(currentBlockNum, nil)
214 require.Nil(t, err)
215 assert.Equal(t, tokenHEZAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Token)
216 assert.Equal(t, governanceAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].To)
217 assert.Equal(t, emergencyCouncilAddressConst, wdelayerEvents.EscapeHatchWithdrawal[0].Who)
218 assert.Equal(t, amount, wdelayerEvents.EscapeHatchWithdrawal[0].Amount)
219}