hermez-node/eth/rollup.go
eth/rollup.goRaw
1package eth
2
3import (
4 "context"
5 "fmt"
6 "math/big"
7 "strings"
8
9 "github.com/ethereum/go-ethereum"
10 "github.com/ethereum/go-ethereum/accounts/abi"
11 "github.com/ethereum/go-ethereum/accounts/abi/bind"
12 ethCommon "github.com/ethereum/go-ethereum/common"
13 "github.com/ethereum/go-ethereum/core/types"
14 "github.com/ethereum/go-ethereum/crypto"
15 "github.com/ethereum/go-ethereum/ethclient"
16 "github.com/hermeznetwork/hermez-node/common"
17 ERC777 "github.com/hermeznetwork/hermez-node/eth/contracts/erc777"
18 Hermez "github.com/hermeznetwork/hermez-node/eth/contracts/hermez"
19 "github.com/hermeznetwork/hermez-node/log"
20 "github.com/iden3/go-iden3-crypto/babyjub"
21 "golang.org/x/crypto/sha3"
22)
23
24const (
25 // RollupConstMaxFeeIdxCoordinator is the maximum number of tokens the
26 // coordinator can use to collect fees (determines the number of tokens
27 // that the coordinator can collect fees from). This value is
28 // determined by the circuit.
29 RollupConstMaxFeeIdxCoordinator = 64
30 // RollupConstReservedIDx First 256 indexes reserved, first user index will be the 256
31 RollupConstReservedIDx = 255
32 // RollupConstExitIDx IDX 1 is reserved for exits
33 RollupConstExitIDx = 1
34 // RollupConstLimitLoadAmount Max load amount allowed (loadAmount: L1 --> L2)
35 RollupConstLimitLoadAmount = (1 << 128)
36 // RollupConstLimitL2TransferAmount Max amount allowed (amount L2 --> L2)
37 RollupConstLimitL2TransferAmount = (1 << 192)
38 // RollupConstLimitTokens Max number of tokens allowed to be registered inside the rollup
39 RollupConstLimitTokens = (1 << 32)
40 // RollupConstL1CoordinatorTotalBytes [4 bytes] token + [32 bytes] babyjub + [65 bytes] compressedSignature
41 RollupConstL1CoordinatorTotalBytes = 101
42 // RollupConstL1UserTotalBytes [20 bytes] fromEthAddr + [32 bytes] fromBjj-compressed + [6 bytes] fromIdx +
43 // [2 bytes] loadAmountFloat16 + [2 bytes] amountFloat16 + [4 bytes] tokenId + [6 bytes] toIdx
44 RollupConstL1UserTotalBytes = 72
45 // RollupConstMaxL1UserTx Maximum L1-user transactions allowed to be queued in a batch
46 RollupConstMaxL1UserTx = 128
47 // RollupConstMaxL1Tx Maximum L1 transactions allowed to be queued in a batch
48 RollupConstMaxL1Tx = 256
49 // RollupConstInputSHAConstantBytes [6 bytes] lastIdx + [6 bytes] newLastIdx + [32 bytes] stateRoot + [32 bytes] newStRoot + [32 bytes] newExitRoot +
50 // [_MAX_L1_TX * _L1_USER_TOTALBYTES bytes] l1TxsData + totalL2TxsDataLength + feeIdxCoordinatorLength + [2 bytes] chainID =
51 // 18542 bytes + totalL2TxsDataLength + feeIdxCoordinatorLength
52 RollupConstInputSHAConstantBytes = 18542
53 // RollupConstNumBuckets Number of buckets
54 RollupConstNumBuckets = 5
55 // RollupConstMaxWithdrawalDelay max withdrawal delay in seconds
56 RollupConstMaxWithdrawalDelay = 2 * 7 * 24 * 60 * 60
57 // RollupConstExchangeMultiplier exchange multiplier
58 RollupConstExchangeMultiplier = 1e14
59 // LenVerifiers number of Rollup Smart Contract Verifiers
60 LenVerifiers = 1
61)
62
63var (
64 // RollupConstEthAddressInternalOnly This ethereum address is used internally for rollup accounts that don't have ethereum address, only Babyjubjub
65 // This non-ethereum accounts can be created by the coordinator and allow users to have a rollup
66 // account without needing an ethereum address
67 RollupConstEthAddressInternalOnly = ethCommon.HexToAddress("0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
68 // RollupConstRfield Modulus zkSNARK
69 RollupConstRfield, _ = new(big.Int).SetString(
70 "21888242871839275222246405745257275088548364400416034343698204186575808495617", 10)
71
72 // RollupConstERC1820 ERC1820Registry address
73 RollupConstERC1820 = ethCommon.HexToAddress("0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24")
74
75 // ERC777 tokens signatures
76
77 // RollupConstRecipientInterfaceHash ERC777 recipient interface hash
78 RollupConstRecipientInterfaceHash = crypto.Keccak256([]byte("ERC777TokensRecipient"))
79 // RollupConstPerformL1UserTxSignature the signature of the function that can be called thru an ERC777 `send`
80 RollupConstPerformL1UserTxSignature = crypto.Keccak256([]byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)"))
81 // RollupConstAddTokenSignature the signature of the function that can be called thru an ERC777 `send`
82 RollupConstAddTokenSignature = crypto.Keccak256([]byte("addToken(address)"))
83 // RollupConstSendSignature ERC777 Signature
84 RollupConstSendSignature = crypto.Keccak256([]byte("send(address,uint256,bytes)"))
85 // RollupConstERC777Granularity ERC777 Signature
86 RollupConstERC777Granularity = crypto.Keccak256([]byte("granularity()"))
87 // RollupConstWithdrawalDelayerDeposit This constant are used to deposit tokens from ERC77 tokens into withdrawal delayer
88 RollupConstWithdrawalDelayerDeposit = crypto.Keccak256([]byte("deposit(address,address,uint192)"))
89
90 // ERC20 signature
91
92 // RollupConstTransferSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
93 RollupConstTransferSignature = crypto.Keccak256([]byte("transfer(address,uint256)"))
94 // RollupConstTransferFromSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
95 RollupConstTransferFromSignature = crypto.Keccak256([]byte("transferFrom(address,address,uint256)"))
96 // RollupConstApproveSignature This constant is used in the _safeTransfer internal method in order to safe GAS.
97 RollupConstApproveSignature = crypto.Keccak256([]byte("approve(address,uint256)"))
98 // RollupConstERC20Signature ERC20 decimals signature
99 RollupConstERC20Signature = crypto.Keccak256([]byte("decimals()"))
100)
101
102// RollupPublicConstants are the constants of the Rollup Smart Contract
103type RollupPublicConstants struct {
104 AbsoluteMaxL1L2BatchTimeout int64
105 TokenHEZ ethCommon.Address
106 Verifiers []RollupVerifierStruct
107 HermezAuctionContract ethCommon.Address
108 HermezGovernanceDAOAddress ethCommon.Address
109 SafetyAddress ethCommon.Address
110 WithdrawDelayerContract ethCommon.Address
111}
112
113// RollupVariables are the variables of the Rollup Smart Contract
114type RollupVariables struct {
115 FeeAddToken *big.Int
116 ForgeL1L2BatchTimeout int64
117 WithdrawalDelay uint64
118}
119
120// QueueStruct is the queue of L1Txs for a batch
121type QueueStruct struct {
122 L1TxQueue []common.L1Tx
123 TotalL1TxFee *big.Int
124}
125
126// NewQueueStruct creates a new clear QueueStruct.
127func NewQueueStruct() *QueueStruct {
128 return &QueueStruct{
129 L1TxQueue: make([]common.L1Tx, 0),
130 TotalL1TxFee: big.NewInt(0),
131 }
132}
133
134// RollupVerifierStruct is the information about verifiers of the Rollup Smart Contract
135type RollupVerifierStruct struct {
136 MaxTx int64
137 NLevels int64
138}
139
140// RollupState represents the state of the Rollup in the Smart Contract
141type RollupState struct {
142 StateRoot *big.Int
143 ExitRoots []*big.Int
144 ExitNullifierMap map[[256 / 8]byte]bool
145 TokenList []ethCommon.Address
146 TokenMap map[ethCommon.Address]bool
147 MapL1TxQueue map[int64]*QueueStruct
148 LastL1L2Batch int64
149 CurrentToForgeL1TxsNum int64
150 LastToForgeL1TxsNum int64
151 CurrentIdx int64
152}
153
154// RollupEventL1UserTx is an event of the Rollup Smart Contract
155type RollupEventL1UserTx struct {
156 ToForgeL1TxsNum int64 // QueueIndex *big.Int
157 Position int // TransactionIndex *big.Int
158 L1UserTx common.L1Tx
159}
160
161// RollupEventL1UserTxAux is an event of the Rollup Smart Contract
162type RollupEventL1UserTxAux struct {
163 ToForgeL1TxsNum uint64 // QueueIndex *big.Int
164 Position uint8 // TransactionIndex *big.Int
165 L1UserTx []byte
166}
167
168// RollupEventAddToken is an event of the Rollup Smart Contract
169type RollupEventAddToken struct {
170 TokenAddress ethCommon.Address
171 TokenID uint32
172}
173
174// RollupEventForgeBatch is an event of the Rollup Smart Contract
175type RollupEventForgeBatch struct {
176 BatchNum int64
177 EthTxHash ethCommon.Hash
178}
179
180// RollupEventUpdateForgeL1L2BatchTimeout is an event of the Rollup Smart Contract
181type RollupEventUpdateForgeL1L2BatchTimeout struct {
182 NewForgeL1L2BatchTimeout int64
183}
184
185// RollupEventUpdateFeeAddToken is an event of the Rollup Smart Contract
186type RollupEventUpdateFeeAddToken struct {
187 NewFeeAddToken *big.Int
188}
189
190// RollupEventWithdrawEvent is an event of the Rollup Smart Contract
191type RollupEventWithdrawEvent struct {
192 Idx uint64
193 NumExitRoot uint64
194 InstantWithdraw bool
195}
196
197// RollupEvents is the list of events in a block of the Rollup Smart Contract
198type RollupEvents struct {
199 L1UserTx []RollupEventL1UserTx
200 AddToken []RollupEventAddToken
201 ForgeBatch []RollupEventForgeBatch
202 UpdateForgeL1L2BatchTimeout []RollupEventUpdateForgeL1L2BatchTimeout
203 UpdateFeeAddToken []RollupEventUpdateFeeAddToken
204 WithdrawEvent []RollupEventWithdrawEvent
205}
206
207// NewRollupEvents creates an empty RollupEvents with the slices initialized.
208func NewRollupEvents() RollupEvents {
209 return RollupEvents{
210 L1UserTx: make([]RollupEventL1UserTx, 0),
211 AddToken: make([]RollupEventAddToken, 0),
212 ForgeBatch: make([]RollupEventForgeBatch, 0),
213 UpdateForgeL1L2BatchTimeout: make([]RollupEventUpdateForgeL1L2BatchTimeout, 0),
214 UpdateFeeAddToken: make([]RollupEventUpdateFeeAddToken, 0),
215 WithdrawEvent: make([]RollupEventWithdrawEvent, 0),
216 }
217}
218
219// RollupForgeBatchArgs are the arguments to the ForgeBatch function in the Rollup Smart Contract
220type RollupForgeBatchArgs struct {
221 NewLastIdx int64
222 NewStRoot *big.Int
223 NewExitRoot *big.Int
224 L1CoordinatorTxs []common.L1Tx
225 L1CoordinatorTxsAuths [][]byte // Authorization for accountCreations for each L1CoordinatorTx
226 L2TxsData []common.L2Tx
227 FeeIdxCoordinator []common.Idx
228 // Circuit selector
229 VerifierIdx uint8
230 L1Batch bool
231 ProofA [2]*big.Int
232 ProofB [2][2]*big.Int
233 ProofC [2]*big.Int
234}
235
236// RollupForgeBatchArgsAux are the arguments to the ForgeBatch function in the Rollup Smart Contract
237type RollupForgeBatchArgsAux struct {
238 NewLastIdx *big.Int
239 NewStRoot *big.Int
240 NewExitRoot *big.Int
241 EncodedL1CoordinatorTx []byte
242 L2TxsData []byte
243 FeeIdxCoordinator []byte
244 // Circuit selector
245 VerifierIdx uint8
246 L1Batch bool
247 ProofA [2]*big.Int
248 ProofB [2][2]*big.Int
249 ProofC [2]*big.Int
250}
251
252// RollupInterface is the inteface to to Rollup Smart Contract
253type RollupInterface interface {
254 //
255 // Smart Contract Methods
256 //
257
258 // Public Functions
259
260 RollupForgeBatch(*RollupForgeBatchArgs) (*types.Transaction, error)
261 RollupAddToken(tokenAddress ethCommon.Address, feeAddToken *big.Int) (*types.Transaction, error)
262
263 RollupWithdrawMerkleProof(babyPubKey *babyjub.PublicKey, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction, error)
264 RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error)
265
266 RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
267 RollupL1UserTxERC777(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
268
269 // Governance Public Functions
270 RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (*types.Transaction, error)
271 RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (*types.Transaction, error)
272
273 // Viewers
274 RollupRegisterTokensCount() (*big.Int, error)
275
276 //
277 // Smart Contract Status
278 //
279
280 RollupConstants() (*RollupPublicConstants, error)
281 RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error)
282 RollupForgeBatchArgs(ethCommon.Hash) (*RollupForgeBatchArgs, error)
283}
284
285//
286// Implementation
287//
288
289// RollupClient is the implementation of the interface to the Rollup Smart Contract in ethereum.
290type RollupClient struct {
291 client *EthereumClient
292 address ethCommon.Address
293 tokenHEZAddress ethCommon.Address
294 gasLimit uint64
295 contractAbi abi.ABI
296}
297
298// NewRollupClient creates a new RollupClient
299func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZAddress ethCommon.Address) (*RollupClient, error) {
300 contractAbi, err := abi.JSON(strings.NewReader(string(Hermez.HermezABI)))
301 if err != nil {
302 return nil, err
303 }
304 return &RollupClient{
305 client: client,
306 address: address,
307 tokenHEZAddress: tokenHEZAddress,
308 gasLimit: 1000000, //nolint:gomnd
309 contractAbi: contractAbi,
310 }, nil
311}
312
313// RollupForgeBatch is the interface to call the smart contract function
314func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs) (*types.Transaction, error) {
315 var tx *types.Transaction
316 var err error
317 if tx, err = c.client.CallAuth(
318 c.gasLimit,
319 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
320 hermez, err := Hermez.NewHermez(c.address, ec)
321 if err != nil {
322 return nil, err
323 }
324 rollupConst, err := c.RollupConstants()
325 if err != nil {
326 return nil, err
327 }
328 nLevels := rollupConst.Verifiers[args.VerifierIdx].NLevels
329 lenBytes := nLevels / 8 //nolint:gomnd
330 newLastIdx := big.NewInt(int64(args.NewLastIdx))
331 var l1CoordinatorBytes []byte
332 for i := 0; i < len(args.L1CoordinatorTxs); i++ {
333 l1 := args.L1CoordinatorTxs[i]
334 bytesl1, err := l1.BytesCoordinatorTx(args.L1CoordinatorTxsAuths[i])
335 if err != nil {
336 return nil, err
337 }
338 l1CoordinatorBytes = append(l1CoordinatorBytes, bytesl1[:]...)
339 }
340 var l2DataBytes []byte
341 for i := 0; i < len(args.L2TxsData); i++ {
342 l2 := args.L2TxsData[i]
343 bytesl2, err := l2.Bytes(int(nLevels))
344 if err != nil {
345 return nil, err
346 }
347 l2DataBytes = append(l2DataBytes, bytesl2[:]...)
348 }
349 var feeIdxCoordinator []byte
350 if len(args.FeeIdxCoordinator) > RollupConstMaxFeeIdxCoordinator {
351 return nil, fmt.Errorf("len(args.FeeIdxCoordinator) > %v",
352 RollupConstMaxFeeIdxCoordinator)
353 }
354 for i := 0; i < RollupConstMaxFeeIdxCoordinator; i++ {
355 feeIdx := common.Idx(0)
356 if i < len(args.FeeIdxCoordinator) {
357 feeIdx = args.FeeIdxCoordinator[i]
358 }
359 bytesFeeIdx, err := feeIdx.Bytes()
360 if err != nil {
361 return nil, err
362 }
363 feeIdxCoordinator = append(feeIdxCoordinator, bytesFeeIdx[len(bytesFeeIdx)-int(lenBytes):]...)
364 }
365 return hermez.ForgeBatch(auth, newLastIdx, args.NewStRoot, args.NewExitRoot, l1CoordinatorBytes, l2DataBytes, feeIdxCoordinator, args.VerifierIdx, args.L1Batch, args.ProofA, args.ProofB, args.ProofC)
366 },
367 ); err != nil {
368 return nil, fmt.Errorf("Failed forge batch: %w", err)
369 }
370 return tx, nil
371}
372
373// RollupAddToken is the interface to call the smart contract function.
374// `feeAddToken` is the amount of HEZ tokens that will be paid to add the
375// token. `feeAddToken` must match the public value of the smart contract.
376func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToken *big.Int) (*types.Transaction, error) {
377 var tx *types.Transaction
378 var err error
379 if tx, err = c.client.CallAuth(
380 c.gasLimit,
381 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
382 tokens, err := ERC777.NewERC777(c.tokenHEZAddress, ec)
383 if err != nil {
384 return nil, err
385 }
386 addTokenFnSignature := []byte("addToken(address)")
387 hash := sha3.NewLegacyKeccak256()
388 _, err = hash.Write(addTokenFnSignature)
389 if err != nil {
390 return nil, err
391 }
392 methodID := hash.Sum(nil)[:4]
393 var data []byte
394 data = append(data, methodID...)
395 paddedAddress := ethCommon.LeftPadBytes(tokenAddress.Bytes(), 32)
396 data = append(data, paddedAddress[:]...)
397 return tokens.Send(auth, c.address, feeAddToken, data)
398 },
399 ); err != nil {
400 return nil, fmt.Errorf("Failed add Token %w", err)
401 }
402 return tx, nil
403}
404
405// RollupWithdrawMerkleProof is the interface to call the smart contract function
406func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ *babyjub.PublicKey, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction, error) {
407 var tx *types.Transaction
408 var err error
409 if tx, err = c.client.CallAuth(
410 c.gasLimit,
411 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
412 hermez, err := Hermez.NewHermez(c.address, ec)
413 if err != nil {
414 return nil, err
415 }
416 pkCompL := fromBJJ.Compress()
417 pkCompB := common.SwapEndianness(pkCompL[:])
418 babyPubKey := new(big.Int).SetBytes(pkCompB)
419 numExitRootB := big.NewInt(numExitRoot)
420 idxBig := big.NewInt(idx)
421 return hermez.WithdrawMerkleProof(auth, tokenID, amount, babyPubKey, numExitRootB, siblings, idxBig, instantWithdraw)
422 },
423 ); err != nil {
424 return nil, fmt.Errorf("Failed update WithdrawMerkleProof: %w", err)
425 }
426 return tx, nil
427}
428
429// RollupWithdrawCircuit is the interface to call the smart contract function
430func (c *RollupClient) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error) {
431 log.Error("TODO")
432 return nil, errTODO
433}
434
435// RollupL1UserTxERC20ETH is the interface to call the smart contract function
436func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error) {
437 var tx *types.Transaction
438 var err error
439 if tx, err = c.client.CallAuth(
440 c.gasLimit,
441 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
442 hermez, err := Hermez.NewHermez(c.address, ec)
443 if err != nil {
444 return nil, err
445 }
446 pkCompL := fromBJJ.Compress()
447 pkCompB := common.SwapEndianness(pkCompL[:])
448 babyPubKey := new(big.Int).SetBytes(pkCompB)
449 fromIdxBig := big.NewInt(fromIdx)
450 toIdxBig := big.NewInt(toIdx)
451 tokenIDBig := uint32(tokenID)
452 loadAmountF, err := common.NewFloat16(loadAmount)
453 if err != nil {
454 return nil, err
455 }
456 amountF, err := common.NewFloat16(amount)
457 if err != nil {
458 return nil, err
459 }
460 if tokenID == 0 {
461 auth.Value = loadAmount
462 }
463 return hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(loadAmountF), uint16(amountF), tokenIDBig, toIdxBig)
464 },
465 ); err != nil {
466 return nil, fmt.Errorf("Failed add L1 Tx ERC20/ETH: %w", err)
467 }
468 return tx, nil
469}
470
471// RollupL1UserTxERC777 is the interface to call the smart contract function
472func (c *RollupClient) RollupL1UserTxERC777(fromBJJ *babyjub.PublicKey, fromIdx int64, loadAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error) {
473 var tx *types.Transaction
474 var err error
475 if tx, err = c.client.CallAuth(
476 c.gasLimit,
477 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
478 tokens, err := ERC777.NewERC777(c.tokenHEZAddress, ec)
479 if err != nil {
480 return nil, err
481 }
482 addL1TxFnSignature := []byte("addL1Transaction(uint256,uint48,uint16,uint16,uint32,uint48)")
483 hash := sha3.NewLegacyKeccak256()
484 _, err = hash.Write(addL1TxFnSignature)
485 if err != nil {
486 return nil, err
487 }
488 methodID := hash.Sum(nil)[:4]
489 pkCompL := fromBJJ.Compress()
490 pkCompB := common.SwapEndianness(pkCompL[:])
491 paddedAddress := ethCommon.LeftPadBytes(pkCompB, 32)
492 fromIdxB, err := common.Idx(fromIdx).Bytes()
493 if err != nil {
494 return nil, err
495 }
496 paddedFromIdx := ethCommon.LeftPadBytes(fromIdxB[:], 32)
497 loadAmountF, err := common.NewFloat16(loadAmount)
498 if err != nil {
499 return nil, err
500 }
501 paddedLoadAmount := ethCommon.LeftPadBytes(loadAmountF.Bytes(), 32)
502 amountF, err := common.NewFloat16(amount)
503 if err != nil {
504 return nil, err
505 }
506 paddedAmount := ethCommon.LeftPadBytes(amountF.Bytes(), 32)
507 tokenIDB := common.TokenID(tokenID).Bytes()
508 paddedTokenID := ethCommon.LeftPadBytes(tokenIDB, 32)
509 toIdxB, err := common.Idx(toIdx).Bytes()
510 if err != nil {
511 return nil, err
512 }
513 paddedToIdx := ethCommon.LeftPadBytes(toIdxB[:], 32)
514 var data []byte
515 data = append(data, methodID...)
516 data = append(data, paddedAddress[:]...)
517 data = append(data, paddedFromIdx[:]...)
518 data = append(data, paddedLoadAmount[:]...)
519 data = append(data, paddedAmount[:]...)
520 data = append(data, paddedTokenID[:]...)
521 data = append(data, paddedToIdx[:]...)
522 return tokens.Send(auth, c.address, loadAmount, data)
523 },
524 ); err != nil {
525 return nil, fmt.Errorf("Failed add L1 Tx ERC777: %w", err)
526 }
527 return tx, nil
528}
529
530// RollupRegisterTokensCount is the interface to call the smart contract function
531func (c *RollupClient) RollupRegisterTokensCount() (*big.Int, error) {
532 var registerTokensCount *big.Int
533 if err := c.client.Call(func(ec *ethclient.Client) error {
534 hermez, err := Hermez.NewHermez(c.address, ec)
535 if err != nil {
536 return err
537 }
538 registerTokensCount, err = hermez.RegisterTokensCount(nil)
539 return err
540 }); err != nil {
541 return nil, err
542 }
543 return registerTokensCount, nil
544}
545
546// RollupUpdateForgeL1L2BatchTimeout is the interface to call the smart contract function
547func (c *RollupClient) RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (*types.Transaction, error) {
548 var tx *types.Transaction
549 var err error
550 if tx, err = c.client.CallAuth(
551 c.gasLimit,
552 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
553 hermez, err := Hermez.NewHermez(c.address, ec)
554 if err != nil {
555 return nil, err
556 }
557 return hermez.UpdateForgeL1L2BatchTimeout(auth, uint8(newForgeL1L2BatchTimeout))
558 },
559 ); err != nil {
560 return nil, fmt.Errorf("Failed update ForgeL1L2BatchTimeout: %w", err)
561 }
562 return tx, nil
563}
564
565// RollupUpdateFeeAddToken is the interface to call the smart contract function
566func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (*types.Transaction, error) {
567 var tx *types.Transaction
568 var err error
569 if tx, err = c.client.CallAuth(
570 c.gasLimit,
571 func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
572 hermez, err := Hermez.NewHermez(c.address, ec)
573 if err != nil {
574 return nil, err
575 }
576 return hermez.UpdateFeeAddToken(auth, newFeeAddToken)
577 },
578 ); err != nil {
579 return nil, fmt.Errorf("Failed update FeeAddToken: %w", err)
580 }
581 return tx, nil
582}
583
584// RollupConstants returns the Constants of the Rollup Smart Contract
585func (c *RollupClient) RollupConstants() (*RollupPublicConstants, error) {
586 rollupConstants := new(RollupPublicConstants)
587 if err := c.client.Call(func(ec *ethclient.Client) error {
588 hermez, err := Hermez.NewHermez(c.address, ec)
589 if err != nil {
590 return err
591 }
592 absoluteMaxL1L2BatchTimeout, err := hermez.ABSOLUTEMAXL1L2BATCHTIMEOUT(nil)
593 if err != nil {
594 return err
595 }
596 rollupConstants.AbsoluteMaxL1L2BatchTimeout = int64(absoluteMaxL1L2BatchTimeout)
597 rollupConstants.TokenHEZ, err = hermez.TokenHEZ(nil)
598 if err != nil {
599 return err
600 }
601 for i := int64(0); i < int64(LenVerifiers); i++ {
602 var newRollupVerifier RollupVerifierStruct
603 rollupVerifier, err := hermez.RollupVerifiers(nil, big.NewInt(i))
604 if err != nil {
605 return err
606 }
607 newRollupVerifier.MaxTx = rollupVerifier.MaxTx.Int64()
608 newRollupVerifier.NLevels = rollupVerifier.NLevels.Int64()
609 rollupConstants.Verifiers = append(rollupConstants.Verifiers, newRollupVerifier)
610 }
611 rollupConstants.HermezAuctionContract, err = hermez.HermezAuctionContract(nil)
612 if err != nil {
613 return err
614 }
615 rollupConstants.HermezGovernanceDAOAddress, err = hermez.HermezGovernanceDAOAddress(nil)
616 if err != nil {
617 return err
618 }
619 rollupConstants.SafetyAddress, err = hermez.SafetyAddress(nil)
620 if err != nil {
621 return err
622 }
623 rollupConstants.WithdrawDelayerContract, err = hermez.WithdrawDelayerContract(nil)
624 return err
625 }); err != nil {
626 return nil, err
627 }
628 return rollupConstants, nil
629}
630
631var (
632 logHermezL1UserTxEvent = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint64,uint8,bytes)"))
633 logHermezAddToken = crypto.Keccak256Hash([]byte("AddToken(address,uint32)"))
634 logHermezForgeBatch = crypto.Keccak256Hash([]byte("ForgeBatch(uint64)"))
635 logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)"))
636 logHermezUpdateFeeAddToken = crypto.Keccak256Hash([]byte("UpdateFeeAddToken(uint256)"))
637 logHermezWithdrawEvent = crypto.Keccak256Hash([]byte("WithdrawEvent(uint48,uint48,bool)"))
638)
639
640// RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
641func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) {
642 var rollupEvents RollupEvents
643 var blockHash ethCommon.Hash
644
645 query := ethereum.FilterQuery{
646 FromBlock: big.NewInt(blockNum),
647 ToBlock: big.NewInt(blockNum),
648 Addresses: []ethCommon.Address{
649 c.address,
650 },
651 BlockHash: nil,
652 Topics: [][]ethCommon.Hash{},
653 }
654 logs, err := c.client.client.FilterLogs(context.Background(), query)
655 if err != nil {
656 return nil, nil, err
657 }
658 if len(logs) > 0 {
659 blockHash = logs[0].BlockHash
660 }
661 for _, vLog := range logs {
662 if vLog.BlockHash != blockHash {
663 return nil, nil, ErrBlockHashMismatchEvent
664 }
665 switch vLog.Topics[0] {
666 case logHermezL1UserTxEvent:
667 var L1UserTxAux RollupEventL1UserTxAux
668 var L1UserTx RollupEventL1UserTx
669 err := c.contractAbi.Unpack(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
670 if err != nil {
671 return nil, nil, err
672 }
673 L1Tx, err := common.L1TxFromBytes(L1UserTxAux.L1UserTx)
674 if err != nil {
675 return nil, nil, err
676 }
677 L1UserTx.ToForgeL1TxsNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
678 L1UserTx.Position = int(new(big.Int).SetBytes(vLog.Topics[2][:]).Int64())
679 L1UserTx.L1UserTx = *L1Tx
680 rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx)
681 case logHermezAddToken:
682 var addToken RollupEventAddToken
683 err := c.contractAbi.Unpack(&addToken, "AddToken", vLog.Data)
684 if err != nil {
685 return nil, nil, err
686 }
687 addToken.TokenAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
688 rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)
689 case logHermezForgeBatch:
690 var forgeBatch RollupEventForgeBatch
691 forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
692 forgeBatch.EthTxHash = vLog.TxHash
693 rollupEvents.ForgeBatch = append(rollupEvents.ForgeBatch, forgeBatch)
694 case logHermezUpdateForgeL1L2BatchTimeout:
695 var updateForgeL1L2BatchTimeout struct {
696 NewForgeL1L2BatchTimeout uint8
697 }
698 err := c.contractAbi.Unpack(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
699 if err != nil {
700 return nil, nil, err
701 }
702 rollupEvents.UpdateForgeL1L2BatchTimeout = append(rollupEvents.UpdateForgeL1L2BatchTimeout,
703 RollupEventUpdateForgeL1L2BatchTimeout{
704 NewForgeL1L2BatchTimeout: int64(updateForgeL1L2BatchTimeout.NewForgeL1L2BatchTimeout),
705 })
706 case logHermezUpdateFeeAddToken:
707 var updateFeeAddToken RollupEventUpdateFeeAddToken
708 err := c.contractAbi.Unpack(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
709 if err != nil {
710 return nil, nil, err
711 }
712 rollupEvents.UpdateFeeAddToken = append(rollupEvents.UpdateFeeAddToken, updateFeeAddToken)
713 case logHermezWithdrawEvent:
714 var withdraw RollupEventWithdrawEvent
715 withdraw.Idx = new(big.Int).SetBytes(vLog.Topics[1][:]).Uint64()
716 withdraw.NumExitRoot = new(big.Int).SetBytes(vLog.Topics[2][:]).Uint64()
717 instantWithdraw := new(big.Int).SetBytes(vLog.Topics[3][:]).Uint64()
718 if instantWithdraw == 1 {
719 withdraw.InstantWithdraw = true
720 }
721 rollupEvents.WithdrawEvent = append(rollupEvents.WithdrawEvent, withdraw)
722 }
723 }
724 return &rollupEvents, &blockHash, nil
725}
726
727// RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the Rollup Smart Contract in the given transaction
728func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash) (*RollupForgeBatchArgs, error) {
729 tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash)
730 if err != nil {
731 return nil, err
732 }
733 txData := tx.Data()
734 method, err := c.contractAbi.MethodById(txData[:4])
735 if err != nil {
736 return nil, err
737 }
738 var aux RollupForgeBatchArgsAux
739 if err := method.Inputs.Unpack(&aux, txData[4:]); err != nil {
740 return nil, err
741 }
742 rollupForgeBatchArgs := RollupForgeBatchArgs{
743 L1Batch: aux.L1Batch,
744 NewExitRoot: aux.NewExitRoot,
745 NewLastIdx: aux.NewLastIdx.Int64(),
746 NewStRoot: aux.NewStRoot,
747 ProofA: aux.ProofA,
748 ProofB: aux.ProofB,
749 ProofC: aux.ProofC,
750 VerifierIdx: aux.VerifierIdx,
751 L1CoordinatorTxs: []common.L1Tx{},
752 L1CoordinatorTxsAuths: [][]byte{},
753 L2TxsData: []common.L2Tx{},
754 FeeIdxCoordinator: []common.Idx{},
755 }
756 numTxsL1 := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen
757 for i := 0; i < numTxsL1; i++ {
758 bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
759 var signature []byte
760 v := bytesL1Coordinator[0]
761 s := bytesL1Coordinator[1:33]
762 r := bytesL1Coordinator[33:65]
763 signature = append(signature, r[:]...)
764 signature = append(signature, s[:]...)
765 signature = append(signature, v)
766 l1Tx, err := common.L1TxFromCoordinatorBytes(bytesL1Coordinator)
767 if err != nil {
768 return nil, err
769 }
770 rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, *l1Tx)
771 rollupForgeBatchArgs.L1CoordinatorTxsAuths = append(rollupForgeBatchArgs.L1CoordinatorTxsAuths, signature)
772 }
773 rollupConsts, err := c.RollupConstants()
774 if err != nil {
775 return nil, err
776 }
777 nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
778 lenL2TxsBytes := int((nLevels/8)*2 + 2 + 1)
779 numTxsL2 := len(aux.L2TxsData) / lenL2TxsBytes
780 for i := 0; i < numTxsL2; i++ {
781 l2Tx, err := common.L2TxFromBytes(aux.L2TxsData[i*lenL2TxsBytes:(i+1)*lenL2TxsBytes], int(nLevels))
782 if err != nil {
783 return nil, err
784 }
785 rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, *l2Tx)
786 }
787 lenFeeIdxCoordinatorBytes := int(nLevels / 8) //nolint:gomnd
788 numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes
789 for i := 0; i < numFeeIdxCoordinator; i++ {
790 var paddedFeeIdx [6]byte
791 // TODO: This check is not necessary: the first case will always work. Test it before removing the if.
792 if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
793 copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
794 } else {
795 copy(paddedFeeIdx[:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
796 }
797 feeIdxCoordinator, err := common.IdxFromBytes(paddedFeeIdx[:])
798 if err != nil {
799 return nil, err
800 }
801 if feeIdxCoordinator != common.Idx(0) {
802 rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, feeIdxCoordinator)
803 }
804 }
805 return &rollupForgeBatchArgs, nil
806}