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