hermez-node/eth/wdelayer.go
eth/wdelayer.goRaw
1package eth
2
3import (
4 "fmt"
5 "math/big"
6
7 "github.com/ethereum/go-ethereum/accounts/abi/bind"
8 ethCommon "github.com/ethereum/go-ethereum/common"
9 "github.com/ethereum/go-ethereum/core/types"
10 "github.com/ethereum/go-ethereum/ethclient"
11 WithdrawalDelayer "github.com/hermeznetwork/hermez-node/eth/contracts/withdrawdelayer"
12)
13
14// WDelayerConstants are the constants of the Rollup Smart Contract
15type WDelayerConstants struct {
16 // Max Withdrawal Delay
17 MaxWithdrawalDelay uint64
18 // Max Emergency mode time
19 MaxEmergencyModeTime uint64
20 // HermezRollup smartcontract address
21 HermezRollup ethCommon.Address
22}
23
24// DepositState is the state of Deposit
25type DepositState struct {
26 Amount *big.Int
27 DepositTimestamp uint64
28}
29
30// WDelayerEventDeposit is an event of the WithdrawalDelayer Smart Contract
31type WDelayerEventDeposit struct {
32 Owner ethCommon.Address
33 Token ethCommon.Address
34 Amount *big.Int
35 DepositTimestamp uint64
36}
37
38// WDelayerEventWithdraw is an event of the WithdrawalDelayer Smart Contract
39type WDelayerEventWithdraw struct {
40 Owner ethCommon.Address
41 Token ethCommon.Address
42 Amount *big.Int
43}
44
45// WDelayerEventEmergencyModeEnabled an event of the WithdrawalDelayer Smart Contract
46type WDelayerEventEmergencyModeEnabled struct {
47}
48
49// WDelayerEventNewWithdrawalDelay an event of the WithdrawalDelayer Smart Contract
50type WDelayerEventNewWithdrawalDelay struct {
51 WithdrawalDelay uint64
52}
53
54// WDelayerEventEscapeHatchWithdrawal an event of the WithdrawalDelayer Smart Contract
55type WDelayerEventEscapeHatchWithdrawal struct {
56 Who ethCommon.Address
57 To ethCommon.Address
58 Token ethCommon.Address
59}
60
61// WDelayerEventNewHermezKeeperAddress an event of the WithdrawalDelayer Smart Contract
62type WDelayerEventNewHermezKeeperAddress struct {
63 NewHermezKeeperAddress ethCommon.Address
64}
65
66// WDelayerEventNewWhiteHackGroupAddress an event of the WithdrawalDelayer Smart Contract
67type WDelayerEventNewWhiteHackGroupAddress struct {
68 NewWhiteHackGroupAddress ethCommon.Address
69}
70
71// WDelayerEventNewHermezGovernanceDAOAddress an event of the WithdrawalDelayer Smart Contract
72type WDelayerEventNewHermezGovernanceDAOAddress struct {
73 NewHermezGovernanceDAOAddress ethCommon.Address
74}
75
76// WDelayerEvents is the lis of events in a block of the WithdrawalDelayer Smart Contract
77type WDelayerEvents struct { //nolint:structcheck
78 Deposit []WDelayerEventDeposit
79 Withdraw []WDelayerEventWithdraw
80 EmergencyModeEnabled []WDelayerEventEmergencyModeEnabled
81 NewWithdrawalDelay []WDelayerEventNewWithdrawalDelay
82 EscapeHatchWithdrawal []WDelayerEventEscapeHatchWithdrawal
83 NewHermezKeeperAddress []WDelayerEventNewHermezKeeperAddress
84 NewWhiteHackGroupAddress []WDelayerEventNewWhiteHackGroupAddress
85 NewHermezGovernanceDAOAddress []WDelayerEventNewHermezGovernanceDAOAddress
86}
87
88// NewWDelayerEvents creates an empty WDelayerEvents with the slices initialized.
89func NewWDelayerEvents() WDelayerEvents {
90 return WDelayerEvents{
91 Deposit: make([]WDelayerEventDeposit, 0),
92 Withdraw: make([]WDelayerEventWithdraw, 0),
93 EmergencyModeEnabled: make([]WDelayerEventEmergencyModeEnabled, 0),
94 NewWithdrawalDelay: make([]WDelayerEventNewWithdrawalDelay, 0),
95 EscapeHatchWithdrawal: make([]WDelayerEventEscapeHatchWithdrawal, 0),
96 NewHermezKeeperAddress: make([]WDelayerEventNewHermezKeeperAddress, 0),
97 NewWhiteHackGroupAddress: make([]WDelayerEventNewWhiteHackGroupAddress, 0),
98 NewHermezGovernanceDAOAddress: make([]WDelayerEventNewHermezGovernanceDAOAddress, 0),
99 }
100}
101
102// WDelayerInterface is the inteface to WithdrawalDelayer Smart Contract
103type WDelayerInterface interface {
104 //
105 // Smart Contract Methods
106 //
107
108 WDelayerGetHermezGovernanceDAOAddress() (*ethCommon.Address, error)
109 WDelayerSetHermezGovernanceDAOAddress(newAddress ethCommon.Address) (*types.Transaction, error)
110 WDelayerGetHermezKeeperAddress() (*ethCommon.Address, error)
111 WDelayerSetHermezKeeperAddress(newAddress ethCommon.Address) (*types.Transaction, error)
112 WDelayerGetWhiteHackGroupAddress() (*ethCommon.Address, error)
113 WDelayerSetWhiteHackGroupAddress(newAddress ethCommon.Address) (*types.Transaction, error)
114 WDelayerIsEmergencyMode() (bool, error)
115 WDelayerGetWithdrawalDelay() (*big.Int, error)
116 WDelayerGetEmergencyModeStartingTime() (*big.Int, error)
117 WDelayerEnableEmergencyMode() (*types.Transaction, error)
118 WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (*types.Transaction, error)
119 WDelayerDepositInfo(owner, token ethCommon.Address) (*big.Int, uint64)
120 WDelayerDeposit(onwer, token ethCommon.Address, amount *big.Int) (*types.Transaction, error)
121 WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error)
122 WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address) (*types.Transaction, error)
123}
124
125//
126// Implementation
127//
128
129// WDelayerClient is the implementation of the interface to the WithdrawDelayer Smart Contract in ethereum.
130type WDelayerClient struct {
131 client *EthereumClient
132 address ethCommon.Address
133 gasLimit uint64
134}
135
136// NewWDelayerClient creates a new WDelayerClient
137func NewWDelayerClient(client *EthereumClient, address ethCommon.Address) *WDelayerClient {
138 return &WDelayerClient{
139 client: client,
140 address: address,
141 gasLimit: 1000000, //nolint:gomnd
142 }
143}
144
145// WDelayerGetHermezGovernanceDAOAddress is the interface to call the smart contract function
146func (c *WDelayerClient) WDelayerGetHermezGovernanceDAOAddress() (*ethCommon.Address, error) {
147 var hermezGovernanceDAOAddress ethCommon.Address
148 if err := c.client.Call(func(ec *ethclient.Client) error {
149 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
150 if err != nil {
151 return err
152 }
153 hermezGovernanceDAOAddress, err = wdelayer.GetHermezGovernanceDAOAddress(nil)
154 return err
155 }); err != nil {
156 return nil, err
157 }
158 return &hermezGovernanceDAOAddress, nil
159}
160
161// WDelayerSetHermezGovernanceDAOAddress is the interface to call the smart contract function
162func (c *WDelayerClient) WDelayerSetHermezGovernanceDAOAddress(newAddress ethCommon.Address) (*types.Transaction, error) {
163 var tx *types.Transaction
164 var err error
165 if tx, err = c.client.CallAuth(
166 c.gasLimit,
167 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
168 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
169 if err != nil {
170 return nil, err
171 }
172 return wdelayer.SetHermezGovernanceDAOAddress(auth, newAddress)
173 },
174 ); err != nil {
175 return nil, fmt.Errorf("Failed setting hermezGovernanceDAOAddress: %w", err)
176 }
177 return tx, nil
178}
179
180// WDelayerGetHermezKeeperAddress is the interface to call the smart contract function
181func (c *WDelayerClient) WDelayerGetHermezKeeperAddress() (*ethCommon.Address, error) {
182 var hermezKeeperAddress ethCommon.Address
183 if err := c.client.Call(func(ec *ethclient.Client) error {
184 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
185 if err != nil {
186 return err
187 }
188 hermezKeeperAddress, err = wdelayer.GetHermezKeeperAddress(nil)
189 return err
190 }); err != nil {
191 return nil, err
192 }
193 return &hermezKeeperAddress, nil
194}
195
196// WDelayerSetHermezKeeperAddress is the interface to call the smart contract function
197func (c *WDelayerClient) WDelayerSetHermezKeeperAddress(newAddress ethCommon.Address) (*types.Transaction, error) {
198 var tx *types.Transaction
199 var err error
200 if tx, err = c.client.CallAuth(
201 c.gasLimit,
202 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
203 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
204 if err != nil {
205 return nil, err
206 }
207 return wdelayer.SetHermezKeeperAddress(auth, newAddress)
208 },
209 ); err != nil {
210 return nil, fmt.Errorf("Failed setting hermezKeeperAddress: %w", err)
211 }
212 return tx, nil
213}
214
215// WDelayerGetWhiteHackGroupAddress is the interface to call the smart contract function
216func (c *WDelayerClient) WDelayerGetWhiteHackGroupAddress() (*ethCommon.Address, error) {
217 var whiteHackGroupAddress ethCommon.Address
218 if err := c.client.Call(func(ec *ethclient.Client) error {
219 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
220 if err != nil {
221 return err
222 }
223 whiteHackGroupAddress, err = wdelayer.GetWhiteHackGroupAddress(nil)
224 return err
225 }); err != nil {
226 return nil, err
227 }
228 return &whiteHackGroupAddress, nil
229}
230
231// WDelayerSetWhiteHackGroupAddress is the interface to call the smart contract function
232func (c *WDelayerClient) WDelayerSetWhiteHackGroupAddress(newAddress ethCommon.Address) (*types.Transaction, error) {
233 var tx *types.Transaction
234 var err error
235 if tx, err = c.client.CallAuth(
236 c.gasLimit,
237 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
238 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
239 if err != nil {
240 return nil, err
241 }
242 return wdelayer.SetWhiteHackGroupAddress(auth, newAddress)
243 },
244 ); err != nil {
245 return nil, fmt.Errorf("Failed setting whiteHackGroupAddress: %w", err)
246 }
247 return tx, nil
248}
249
250// WDelayerIsEmergencyMode is the interface to call the smart contract function
251func (c *WDelayerClient) WDelayerIsEmergencyMode() (bool, error) {
252 var ermergencyMode bool
253 if err := c.client.Call(func(ec *ethclient.Client) error {
254 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
255 if err != nil {
256 return err
257 }
258 ermergencyMode, err = wdelayer.IsEmergencyMode(nil)
259 return err
260 }); err != nil {
261 return false, err
262 }
263 return ermergencyMode, nil
264}
265
266// WDelayerGetWithdrawalDelay is the interface to call the smart contract function
267func (c *WDelayerClient) WDelayerGetWithdrawalDelay() (*big.Int, error) {
268 var withdrawalDelay *big.Int
269 if err := c.client.Call(func(ec *ethclient.Client) error {
270 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
271 if err != nil {
272 return err
273 }
274 withdrawalDelay, err = wdelayer.GetWithdrawalDelay(nil)
275 return err
276 }); err != nil {
277 return nil, err
278 }
279 return withdrawalDelay, nil
280}
281
282// WDelayerGetEmergencyModeStartingTime is the interface to call the smart contract function
283func (c *WDelayerClient) WDelayerGetEmergencyModeStartingTime() (*big.Int, error) {
284 var emergencyModeStartingTime *big.Int
285 if err := c.client.Call(func(ec *ethclient.Client) error {
286 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
287 if err != nil {
288 return err
289 }
290 emergencyModeStartingTime, err = wdelayer.GetEmergencyModeStartingTime(nil)
291 return err
292 }); err != nil {
293 return nil, err
294 }
295 return emergencyModeStartingTime, nil
296}
297
298// WDelayerEnableEmergencyMode is the interface to call the smart contract function
299func (c *WDelayerClient) WDelayerEnableEmergencyMode() (*types.Transaction, error) {
300 var tx *types.Transaction
301 var err error
302 if tx, err = c.client.CallAuth(
303 c.gasLimit,
304 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
305 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
306 if err != nil {
307 return nil, err
308 }
309 return wdelayer.EnableEmergencyMode(auth)
310 },
311 ); err != nil {
312 return nil, fmt.Errorf("Failed setting enable emergency mode: %w", err)
313 }
314 return tx, nil
315}
316
317// WDelayerChangeWithdrawalDelay is the interface to call the smart contract function
318func (c *WDelayerClient) WDelayerChangeWithdrawalDelay(newWithdrawalDelay uint64) (*types.Transaction, error) {
319 var tx *types.Transaction
320 var err error
321 if tx, err = c.client.CallAuth(
322 c.gasLimit,
323 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
324 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
325 if err != nil {
326 return nil, err
327 }
328 return wdelayer.ChangeWithdrawalDelay(auth, newWithdrawalDelay)
329 },
330 ); err != nil {
331 return nil, fmt.Errorf("Failed setting withdrawal delay: %w", err)
332 }
333 return tx, nil
334}
335
336// WDelayerDepositInfo is the interface to call the smart contract function
337func (c *WDelayerClient) WDelayerDepositInfo(owner, token ethCommon.Address) (DepositState, error) {
338 var depositInfo DepositState
339 if err := c.client.Call(func(ec *ethclient.Client) error {
340 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
341 if err != nil {
342 return err
343 }
344 amount, depositTimestamp, err := wdelayer.DepositInfo(nil, owner, token)
345 depositInfo.Amount = amount
346 depositInfo.DepositTimestamp = depositTimestamp
347 return err
348 }); err != nil {
349 return depositInfo, err
350 }
351 return depositInfo, nil
352}
353
354// WDelayerDeposit is the interface to call the smart contract function
355func (c *WDelayerClient) WDelayerDeposit(owner, token ethCommon.Address, amount *big.Int) (*types.Transaction, error) {
356 var tx *types.Transaction
357 var err error
358 if tx, err = c.client.CallAuth(
359 c.gasLimit,
360 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
361 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
362 if err != nil {
363 return nil, err
364 }
365 return wdelayer.Deposit(auth, owner, token, amount)
366 },
367 ); err != nil {
368 return nil, fmt.Errorf("Failed deposit: %w", err)
369 }
370 return tx, nil
371}
372
373// WDelayerWithdrawal is the interface to call the smart contract function
374func (c *WDelayerClient) WDelayerWithdrawal(owner, token ethCommon.Address) (*types.Transaction, error) {
375 var tx *types.Transaction
376 var err error
377 if tx, err = c.client.CallAuth(
378 c.gasLimit,
379 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
380 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
381 if err != nil {
382 return nil, err
383 }
384 return wdelayer.Withdrawal(auth, owner, token)
385 },
386 ); err != nil {
387 return nil, fmt.Errorf("Failed withdrawal: %w", err)
388 }
389 return tx, nil
390}
391
392// WDelayerEscapeHatchWithdrawal is the interface to call the smart contract function
393func (c *WDelayerClient) WDelayerEscapeHatchWithdrawal(to, token ethCommon.Address) (*types.Transaction, error) {
394 var tx *types.Transaction
395 var err error
396 if tx, err = c.client.CallAuth(
397 c.gasLimit,
398 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
399 wdelayer, err := WithdrawalDelayer.NewWithdrawalDelayer(c.address, ec)
400 if err != nil {
401 return nil, err
402 }
403 return wdelayer.EscapeHatchWithdrawal(auth, to, token)
404 },
405 ); err != nil {
406 return nil, fmt.Errorf("Failed escapeHatchWithdrawal: %w", err)
407 }
408 return tx, nil
409}