hermez-node/eth/rollup_test.go
eth/rollup_test.goRaw
1package eth
2
3import (
4 "encoding/hex"
5 "math/big"
6 "testing"
7
8 ethCommon "github.com/ethereum/go-ethereum/common"
9 "github.com/hermeznetwork/hermez-node/common"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12)
13
14var rollupClient *RollupClient
15var auctionClient *AuctionClient
16
17var ethHashForge ethCommon.Hash
18var argsForge *RollupForgeBatchArgs
19
20var absoluteMaxL1L2BatchTimeout = int64(240)
21var maxTx = int64(512)
22var nLevels = int64(32)
23
24func TestRollupConstants(t *testing.T) {
25 rollupConstants, err := rollupClient.RollupConstants()
26 require.Nil(t, err)
27 assert.Equal(t, absoluteMaxL1L2BatchTimeout, rollupConstants.AbsoluteMaxL1L2BatchTimeout)
28 assert.Equal(t, auctionAddressConst, rollupConstants.HermezAuctionContract)
29 assert.Equal(t, tokenERC777AddressConst, rollupConstants.TokenHEZ)
30 assert.Equal(t, maxTx, rollupConstants.Verifiers[0].MaxTx)
31 assert.Equal(t, nLevels, rollupConstants.Verifiers[0].NLevels)
32 assert.Equal(t, governanceAddressConst, rollupConstants.HermezGovernanceDAOAddress)
33 assert.Equal(t, safetyAddressConst, rollupConstants.SafetyAddress)
34 assert.Equal(t, wdelayerAddressConst, rollupConstants.WithdrawDelayerContract)
35}
36
37func TestAddToken(t *testing.T) {
38 var feeAddToken = new(big.Int)
39 feeAddToken = big.NewInt(10)
40 // Addtoken
41 _, err := rollupClient.RollupAddToken(tokenERC777AddressConst, feeAddToken)
42 require.Nil(t, err)
43}
44
45func TestRollupForgeBatch(t *testing.T) {
46 // Register Coordinator
47 forgerAddress := governanceAddressConst
48 _, err := auctionClient.AuctionSetCoordinator(forgerAddress, URL)
49 require.Nil(t, err)
50
51 // MultiBid
52 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
53 require.Nil(t, err)
54 slotSet := [6]bool{true, false, true, false, true, false}
55 maxBid := new(big.Int)
56 maxBid.SetString("15000000000000000000", 10)
57 minBid := new(big.Int)
58 minBid.SetString("11000000000000000000", 10)
59 budget := new(big.Int)
60 budget.SetString("45200000000000000000", 10)
61 _, err = auctionClient.AuctionMultiBid(currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, budget)
62 require.Nil(t, err)
63
64 // Add Blocks
65 blockNum := int64(int(BLOCKSPERSLOT)*int(currentSlot+4) + genesisBlock)
66 currentBlockNum, _ := auctionClient.client.EthCurrentBlock()
67 blocksToAdd := blockNum - currentBlockNum
68 addBlocks(blocksToAdd, ethClientDialURL)
69
70 // Forge
71 args := new(RollupForgeBatchArgs)
72 feeIdxCoordinatorBytes, err := hex.DecodeString("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
73 require.Nil(t, err)
74 lenFeeIdxCoordinatorBytes := int(4)
75 numFeeIdxCoordinator := len(feeIdxCoordinatorBytes) / lenFeeIdxCoordinatorBytes
76 for i := 0; i < numFeeIdxCoordinator; i++ {
77 var paddedFeeIdx [6]byte
78 if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
79 copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], feeIdxCoordinatorBytes[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
80 } else {
81 copy(paddedFeeIdx[:], feeIdxCoordinatorBytes[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
82 }
83 FeeIdxCoordinator, err := common.IdxFromBytes(paddedFeeIdx[:])
84 require.Nil(t, err)
85 args.FeeIdxCoordinator = append(args.FeeIdxCoordinator, FeeIdxCoordinator)
86 }
87 l1CoordinatorBytes, err := hex.DecodeString("1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001")
88 require.Nil(t, err)
89 numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen
90 for i := 0; i < numTxsL1; i++ {
91 bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
92 var signature []byte
93 v := bytesL1Coordinator[0]
94 s := bytesL1Coordinator[1:33]
95 r := bytesL1Coordinator[33:65]
96 signature = append(signature, r[:]...)
97 signature = append(signature, s[:]...)
98 signature = append(signature, v)
99 L1Tx, err := common.L1TxFromCoordinatorBytes(bytesL1Coordinator)
100 require.Nil(t, err)
101 args.L1CoordinatorTxs = append(args.L1CoordinatorTxs, L1Tx)
102 args.L1CoordinatorTxsAuths = append(args.L1CoordinatorTxsAuths, signature)
103 }
104 newStateRoot := new(big.Int)
105 newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
106 newExitRoot := big.NewInt(0)
107 args.NewLastIdx = int64(256)
108 args.NewStRoot = newStateRoot
109 args.NewExitRoot = newExitRoot
110 args.L1Batch = true
111 args.VerifierIdx = 0
112 args.ProofA[0] = big.NewInt(0)
113 args.ProofA[1] = big.NewInt(0)
114 args.ProofB[0][0] = big.NewInt(0)
115 args.ProofB[0][1] = big.NewInt(0)
116 args.ProofB[1][0] = big.NewInt(0)
117 args.ProofB[1][1] = big.NewInt(0)
118 args.ProofC[0] = big.NewInt(0)
119 args.ProofC[1] = big.NewInt(0)
120
121 argsForge = args
122 _, err = rollupClient.RollupForgeBatch(argsForge)
123 require.Nil(t, err)
124
125 currentBlockNum, _ = rollupClient.client.EthCurrentBlock()
126 rollupEvents, _, _ := rollupClient.RollupEventsByBlock(currentBlockNum)
127
128 assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum)
129 ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash
130}
131
132func TestRollupForgeBatchArgs(t *testing.T) {
133 args, err := rollupClient.RollupForgeBatchArgs(ethHashForge)
134 require.Nil(t, err)
135 assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator)
136 assert.Equal(t, argsForge.L1Batch, args.L1Batch)
137 assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs)
138 assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths)
139 assert.Equal(t, argsForge.L2TxsData, args.L2TxsData)
140 assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx)
141 assert.Equal(t, argsForge.NewStRoot, args.NewStRoot)
142 assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx)
143}