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