hermez-node/eth/rollup_test.go
eth/rollup_test.goRaw
1package eth
2
3import (
4 "context"
5 "crypto/ecdsa"
6 "encoding/binary"
7 "encoding/hex"
8 "math/big"
9 "testing"
10
11 ethCommon "github.com/ethereum/go-ethereum/common"
12 ethCrypto "github.com/ethereum/go-ethereum/crypto"
13 "github.com/hermeznetwork/hermez-node/common"
14 "github.com/iden3/go-iden3-crypto/babyjub"
15 "github.com/stretchr/testify/assert"
16 "github.com/stretchr/testify/require"
17)
18
19var rollupClient *RollupClient
20var auctionClient *AuctionClient
21
22var ethHashForge ethCommon.Hash
23var argsForge *RollupForgeBatchArgs
24
25var absoluteMaxL1L2BatchTimeout = int64(240)
26var maxTx = int64(512)
27var nLevels = int64(32)
28
29var tokenIDERC777 uint32
30var tokenHEZID uint32
31
32var L1UserTxs []common.L1Tx
33var blockStampBucket int64
34
35type keys struct {
36 BJJSecretKey *babyjub.PrivateKey
37 BJJPublicKey *babyjub.PublicKey
38 Addr ethCommon.Address
39}
40
41func genKeysBjj(i int64) *keys {
42 i++ // i = 0 doesn't work for the ecdsa key generation
43 var sk babyjub.PrivateKey
44 binary.LittleEndian.PutUint64(sk[:], uint64(i))
45
46 // eth address
47 var key ecdsa.PrivateKey
48 key.D = big.NewInt(i) // only for testing
49 key.PublicKey.X, key.PublicKey.Y = ethCrypto.S256().ScalarBaseMult(key.D.Bytes())
50 key.Curve = ethCrypto.S256()
51
52 return &keys{
53 BJJSecretKey: &sk,
54 BJJPublicKey: sk.Public(),
55 }
56}
57
58func TestRollupConstants(t *testing.T) {
59 rollupConstants, err := rollupClient.RollupConstants()
60 require.NoError(t, err)
61 assert.Equal(t, absoluteMaxL1L2BatchTimeout, rollupConstants.AbsoluteMaxL1L2BatchTimeout)
62 assert.Equal(t, auctionAddressConst, rollupConstants.HermezAuctionContract)
63 assert.Equal(t, tokenHEZAddressConst, rollupConstants.TokenHEZ)
64 assert.Equal(t, maxTx, rollupConstants.Verifiers[0].MaxTx)
65 assert.Equal(t, nLevels, rollupConstants.Verifiers[0].NLevels)
66 assert.Equal(t, governanceAddressConst, rollupConstants.HermezGovernanceAddress)
67 assert.Equal(t, wdelayerAddressConst, rollupConstants.WithdrawDelayerContract)
68}
69
70func TestRollupRegisterTokensCount(t *testing.T) {
71 registerTokensCount, err := rollupClient.RollupRegisterTokensCount()
72 require.NoError(t, err)
73 assert.Equal(t, big.NewInt(1), registerTokensCount)
74}
75
76func TestRollupAddToken(t *testing.T) {
77 feeAddToken := big.NewInt(10)
78 // Addtoken ERC20Permit
79 registerTokensCount, err := rollupClient.RollupRegisterTokensCount()
80 require.NoError(t, err)
81 _, err = rollupClient.RollupAddToken(tokenHEZAddressConst, feeAddToken, deadline)
82 require.NoError(t, err)
83 currentBlockNum, err := rollupClient.client.EthLastBlock()
84 require.NoError(t, err)
85 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
86 require.NoError(t, err)
87
88 assert.Equal(t, tokenHEZAddressConst, rollupEvents.AddToken[0].TokenAddress)
89 assert.Equal(t, registerTokensCount, common.TokenID(rollupEvents.AddToken[0].TokenID).BigInt())
90 tokenHEZID = rollupEvents.AddToken[0].TokenID
91}
92
93func TestRollupForgeBatch(t *testing.T) {
94 chainid, _ := auctionClient.client.Client().ChainID(context.Background())
95 // Register Coordinator
96 forgerAddress := governanceAddressConst
97 _, err := auctionClient.AuctionSetCoordinator(forgerAddress, URL)
98 require.NoError(t, err)
99
100 // MultiBid
101 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
102 require.NoError(t, err)
103 slotSet := [6]bool{true, false, true, false, true, false}
104 maxBid := new(big.Int)
105 maxBid.SetString("15000000000000000000", 10)
106 minBid := new(big.Int)
107 minBid.SetString("11000000000000000000", 10)
108 budget := new(big.Int)
109 budget.SetString("45200000000000000000", 10)
110 _, err = auctionClient.AuctionMultiBid(budget, currentSlot+4, currentSlot+10, slotSet, maxBid, minBid, deadline)
111 require.NoError(t, err)
112
113 // Add Blocks
114 blockNum := int64(int(blocksPerSlot)*int(currentSlot+4) + int(genesisBlock))
115 currentBlockNum, err := auctionClient.client.EthLastBlock()
116 require.NoError(t, err)
117 blocksToAdd := blockNum - currentBlockNum
118 addBlocks(blocksToAdd, ethClientDialURL)
119
120 // Forge Batch 1
121 args := new(RollupForgeBatchArgs)
122 args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
123 l1CoordinatorBytes, err := hex.DecodeString("1c660323607bb113e586183609964a333d07ebe4bef3be82ec13af453bae9590bd7711cdb6abf42f176eadfbe5506fbef5e092e5543733f91b0061d9a7747fa10694a915a6470fa230de387b51e6f4db0b09787867778687b55197ad6d6a86eac000000001")
124 require.NoError(t, err)
125 numTxsL1 := len(l1CoordinatorBytes) / common.L1CoordinatorTxBytesLen
126 for i := 0; i < numTxsL1; i++ {
127 bytesL1Coordinator := l1CoordinatorBytes[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
128 var signature []byte
129 v := bytesL1Coordinator[0]
130 s := bytesL1Coordinator[1:33]
131 r := bytesL1Coordinator[33:65]
132 signature = append(signature, r[:]...)
133 signature = append(signature, s[:]...)
134 signature = append(signature, v)
135 l1Tx, err := common.L1CoordinatorTxFromBytes(bytesL1Coordinator, chainid, rollupClient.address)
136 require.NoError(t, err)
137 args.L1CoordinatorTxs = append(args.L1CoordinatorTxs, *l1Tx)
138 args.L1CoordinatorTxsAuths = append(args.L1CoordinatorTxsAuths, signature)
139 }
140 args.L1UserTxs = []common.L1Tx{}
141 args.L2TxsData = []common.L2Tx{}
142 newStateRoot := new(big.Int)
143 newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
144 newExitRoot := new(big.Int)
145 bytesNumExitRoot, err := hex.DecodeString("10a89d5fe8d488eda1ba371d633515739933c706c210c604f5bd209180daa43b")
146 require.NoError(t, err)
147 newExitRoot.SetBytes(bytesNumExitRoot)
148 args.NewLastIdx = int64(300)
149 args.NewStRoot = newStateRoot
150 args.NewExitRoot = newExitRoot
151 args.L1Batch = true
152 args.VerifierIdx = 0
153 args.ProofA[0] = big.NewInt(0)
154 args.ProofA[1] = big.NewInt(0)
155 args.ProofB[0][0] = big.NewInt(0)
156 args.ProofB[0][1] = big.NewInt(0)
157 args.ProofB[1][0] = big.NewInt(0)
158 args.ProofB[1][1] = big.NewInt(0)
159 args.ProofC[0] = big.NewInt(0)
160 args.ProofC[1] = big.NewInt(0)
161
162 argsForge = args
163 _, err = rollupClient.RollupForgeBatch(argsForge)
164 require.NoError(t, err)
165
166 currentBlockNum, err = rollupClient.client.EthLastBlock()
167 require.NoError(t, err)
168 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
169 require.NoError(t, err)
170
171 assert.Equal(t, int64(1), rollupEvents.ForgeBatch[0].BatchNum)
172 assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen)
173 ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash
174}
175
176func TestRollupForgeBatchArgs(t *testing.T) {
177 args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs)))
178 require.NoError(t, err)
179 assert.Equal(t, *sender, rollupClient.client.account.Address)
180 assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator)
181 assert.Equal(t, argsForge.L1Batch, args.L1Batch)
182 assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs)
183 assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths)
184 assert.Equal(t, argsForge.L2TxsData, args.L2TxsData)
185 assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx)
186 assert.Equal(t, argsForge.NewStRoot, args.NewStRoot)
187 assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx)
188}
189
190func TestRollupUpdateForgeL1L2BatchTimeout(t *testing.T) {
191 newForgeL1L2BatchTimeout := int64(222)
192 _, err := rollupClient.RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout)
193 require.NoError(t, err)
194
195 currentBlockNum, err := rollupClient.client.EthLastBlock()
196 require.NoError(t, err)
197 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
198 require.NoError(t, err)
199
200 assert.Equal(t, newForgeL1L2BatchTimeout, rollupEvents.UpdateForgeL1L2BatchTimeout[0].NewForgeL1L2BatchTimeout)
201}
202
203func TestRollupUpdateFeeAddToken(t *testing.T) {
204 newFeeAddToken := big.NewInt(12)
205 _, err := rollupClient.RollupUpdateFeeAddToken(newFeeAddToken)
206 require.NoError(t, err)
207
208 currentBlockNum, err := rollupClient.client.EthLastBlock()
209 require.NoError(t, err)
210 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
211 require.NoError(t, err)
212
213 assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken)
214}
215
216func TestRollupUpdateBucketsParameters(t *testing.T) {
217 var bucketsParameters [common.RollupConstNumBuckets]RollupUpdateBucketsParameters
218 for i := range bucketsParameters {
219 bucketsParameters[i].CeilUSD = big.NewInt(int64((i + 1) * 100))
220 bucketsParameters[i].Withdrawals = big.NewInt(int64(i + 1))
221 bucketsParameters[i].BlockWithdrawalRate = big.NewInt(int64(i+1) * 100)
222 bucketsParameters[i].MaxWithdrawals = big.NewInt(int64(100000000000))
223 }
224 _, err := rollupClient.RollupUpdateBucketsParameters(bucketsParameters)
225 require.NoError(t, err)
226 currentBlockNum, err := rollupClient.client.EthLastBlock()
227 require.NoError(t, err)
228 blockStampBucket = currentBlockNum
229 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
230 require.NoError(t, err)
231 assert.Equal(t, bucketsParameters, rollupEvents.UpdateBucketsParameters[0].ArrayBuckets)
232}
233
234func TestRollupUpdateWithdrawalDelay(t *testing.T) {
235 newWithdrawalDelay := int64(100000)
236 _, err := rollupClient.RollupUpdateWithdrawalDelay(newWithdrawalDelay)
237 require.NoError(t, err)
238 currentBlockNum, err := rollupClient.client.EthLastBlock()
239 require.NoError(t, err)
240 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
241 require.NoError(t, err)
242 assert.Equal(t, newWithdrawalDelay, int64(rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay))
243}
244
245func TestRollupUpdateTokenExchange(t *testing.T) {
246 var addressArray []ethCommon.Address
247 var valueArray []uint64
248 addressToken1, err := rollupClient.hermez.TokenList(nil, big.NewInt(1))
249 addressArray = append(addressArray, addressToken1)
250 tokenPrice := 10
251 valueArray = append(valueArray, uint64(tokenPrice*1e14))
252 require.NoError(t, err)
253 _, err = rollupClient.RollupUpdateTokenExchange(addressArray, valueArray)
254 require.NoError(t, err)
255 currentBlockNum, err := rollupClient.client.EthLastBlock()
256 require.NoError(t, err)
257 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
258 require.NoError(t, err)
259 assert.Equal(t, addressArray, rollupEvents.UpdateTokenExchange[0].AddressArray)
260 assert.Equal(t, valueArray, rollupEvents.UpdateTokenExchange[0].ValueArray)
261}
262
263func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
264 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
265 require.NoError(t, err)
266 key := genKeysBjj(2)
267 fromIdxInt64 := int64(0)
268 toIdxInt64 := int64(0)
269 tokenIDUint32 := uint32(0)
270 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
271 l1Tx := common.L1Tx{
272 FromBJJ: key.BJJPublicKey,
273 FromIdx: common.Idx(fromIdxInt64),
274 ToIdx: common.Idx(toIdxInt64),
275 LoadAmount: loadAmount,
276 TokenID: common.TokenID(tokenIDUint32),
277 Amount: big.NewInt(0),
278 }
279 L1UserTxs = append(L1UserTxs, l1Tx)
280
281 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
282 require.NoError(t, err)
283
284 currentBlockNum, err := rollupClient.client.EthLastBlock()
285 require.NoError(t, err)
286 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
287 require.NoError(t, err)
288 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
289 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
290 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
291 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
292 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
293 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
294}
295
296func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
297 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
298 require.NoError(t, err)
299 key := genKeysBjj(1)
300 fromIdxInt64 := int64(0)
301 toIdxInt64 := int64(0)
302 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
303 l1Tx := common.L1Tx{
304 FromBJJ: key.BJJPublicKey,
305 FromIdx: common.Idx(fromIdxInt64),
306 ToIdx: common.Idx(toIdxInt64),
307 LoadAmount: loadAmount,
308 TokenID: common.TokenID(tokenHEZID),
309 Amount: big.NewInt(0),
310 }
311 L1UserTxs = append(L1UserTxs, l1Tx)
312
313 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
314 require.NoError(t, err)
315
316 currentBlockNum, err := rollupClient.client.EthLastBlock()
317 require.NoError(t, err)
318 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
319 require.NoError(t, err)
320 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
321 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
322 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
323 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
324 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
325 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
326}
327
328func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
329 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
330 require.NoError(t, err)
331 key := genKeysBjj(3)
332 fromIdxInt64 := int64(0)
333 toIdxInt64 := int64(0)
334 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
335 l1Tx := common.L1Tx{
336 FromBJJ: key.BJJPublicKey,
337 FromIdx: common.Idx(fromIdxInt64),
338 ToIdx: common.Idx(toIdxInt64),
339 LoadAmount: loadAmount,
340 TokenID: common.TokenID(tokenIDERC777),
341 Amount: big.NewInt(0),
342 }
343 L1UserTxs = append(L1UserTxs, l1Tx)
344
345 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
346 require.NoError(t, err)
347
348 currentBlockNum, err := rollupClient.client.EthLastBlock()
349 require.NoError(t, err)
350 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
351 require.NoError(t, err)
352 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
353 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
354 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
355 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
356 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
357 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
358}
359
360func TestRollupL1UserTxETHDeposit(t *testing.T) {
361 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
362 require.NoError(t, err)
363 fromIdxInt64 := int64(256)
364 toIdxInt64 := int64(0)
365 tokenIDUint32 := uint32(0)
366 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
367 l1Tx := common.L1Tx{
368 FromBJJ: nil,
369 FromIdx: common.Idx(fromIdxInt64),
370 ToIdx: common.Idx(toIdxInt64),
371 LoadAmount: loadAmount,
372 TokenID: common.TokenID(tokenIDUint32),
373 Amount: big.NewInt(0),
374 }
375 L1UserTxs = append(L1UserTxs, l1Tx)
376
377 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
378 require.NoError(t, err)
379
380 currentBlockNum, err := rollupClient.client.EthLastBlock()
381 require.NoError(t, err)
382 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
383 require.NoError(t, err)
384 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
385 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
386 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
387 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
388 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
389}
390
391func TestRollupL1UserTxERC20Deposit(t *testing.T) {
392 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
393 require.NoError(t, err)
394 fromIdxInt64 := int64(257)
395 toIdxInt64 := int64(0)
396 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
397 l1Tx := common.L1Tx{
398 FromBJJ: nil,
399 FromIdx: common.Idx(fromIdxInt64),
400 ToIdx: common.Idx(toIdxInt64),
401 LoadAmount: loadAmount,
402 TokenID: common.TokenID(tokenHEZID),
403 Amount: big.NewInt(0),
404 }
405 L1UserTxs = append(L1UserTxs, l1Tx)
406
407 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
408 require.NoError(t, err)
409
410 currentBlockNum, err := rollupClient.client.EthLastBlock()
411 require.NoError(t, err)
412 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
413 require.NoError(t, err)
414 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
415 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
416 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
417 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
418 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
419}
420
421func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
422 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
423 require.NoError(t, err)
424 fromIdxInt64 := int64(258)
425 toIdxInt64 := int64(0)
426 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
427 l1Tx := common.L1Tx{
428 FromIdx: common.Idx(fromIdxInt64),
429 ToIdx: common.Idx(toIdxInt64),
430 LoadAmount: loadAmount,
431 TokenID: common.TokenID(tokenIDERC777),
432 Amount: big.NewInt(0),
433 }
434 L1UserTxs = append(L1UserTxs, l1Tx)
435
436 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
437 require.NoError(t, err)
438
439 currentBlockNum, err := rollupClient.client.EthLastBlock()
440 require.NoError(t, err)
441 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
442 require.NoError(t, err)
443 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
444 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
445 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
446 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
447 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
448}
449
450func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
451 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
452 require.NoError(t, err)
453 fromIdxInt64 := int64(256)
454 toIdxInt64 := int64(257)
455 tokenIDUint32 := uint32(0)
456 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
457 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
458 l1Tx := common.L1Tx{
459 FromIdx: common.Idx(fromIdxInt64),
460 ToIdx: common.Idx(toIdxInt64),
461 LoadAmount: loadAmount,
462 TokenID: common.TokenID(tokenIDUint32),
463 Amount: amount,
464 }
465 L1UserTxs = append(L1UserTxs, l1Tx)
466
467 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
468 require.NoError(t, err)
469
470 currentBlockNum, err := rollupClient.client.EthLastBlock()
471 require.NoError(t, err)
472 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
473 require.NoError(t, err)
474 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
475 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
476 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
477 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
478 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
479}
480
481func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
482 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
483 require.NoError(t, err)
484 fromIdxInt64 := int64(257)
485 toIdxInt64 := int64(258)
486 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
487 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
488 l1Tx := common.L1Tx{
489 FromIdx: common.Idx(fromIdxInt64),
490 ToIdx: common.Idx(toIdxInt64),
491 LoadAmount: loadAmount,
492 TokenID: common.TokenID(tokenHEZID),
493 Amount: amount,
494 }
495 L1UserTxs = append(L1UserTxs, l1Tx)
496
497 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
498 require.NoError(t, err)
499
500 currentBlockNum, err := rollupClient.client.EthLastBlock()
501 require.NoError(t, err)
502 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
503 require.NoError(t, err)
504 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
505 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
506 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
507 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
508 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
509}
510
511func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
512 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
513 require.NoError(t, err)
514 fromIdxInt64 := int64(258)
515 toIdxInt64 := int64(259)
516 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
517 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
518 l1Tx := common.L1Tx{
519 FromIdx: common.Idx(fromIdxInt64),
520 ToIdx: common.Idx(toIdxInt64),
521 LoadAmount: loadAmount,
522 TokenID: common.TokenID(tokenIDERC777),
523 Amount: amount,
524 }
525 L1UserTxs = append(L1UserTxs, l1Tx)
526
527 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
528 require.NoError(t, err)
529
530 currentBlockNum, err := rollupClient.client.EthLastBlock()
531 require.NoError(t, err)
532 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
533 require.NoError(t, err)
534 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
535 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
536 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
537 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
538 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
539}
540
541func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
542 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
543 require.NoError(t, err)
544 fromIdxInt64 := int64(256)
545 toIdxInt64 := int64(257)
546 tokenIDUint32 := uint32(0)
547 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
548 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
549 l1Tx := common.L1Tx{
550 FromIdx: common.Idx(fromIdxInt64),
551 ToIdx: common.Idx(toIdxInt64),
552 LoadAmount: loadAmount,
553 TokenID: common.TokenID(tokenIDUint32),
554 Amount: amount,
555 }
556 L1UserTxs = append(L1UserTxs, l1Tx)
557
558 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
559 require.NoError(t, err)
560
561 currentBlockNum, err := rollupClient.client.EthLastBlock()
562 require.NoError(t, err)
563 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
564 require.NoError(t, err)
565 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
566 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
567 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
568 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
569 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
570}
571
572func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
573 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
574 require.NoError(t, err)
575 fromIdxInt64 := int64(257)
576 toIdxInt64 := int64(258)
577 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
578 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
579 l1Tx := common.L1Tx{
580 FromIdx: common.Idx(fromIdxInt64),
581 ToIdx: common.Idx(toIdxInt64),
582 LoadAmount: loadAmount,
583 TokenID: common.TokenID(tokenHEZID),
584 Amount: amount,
585 }
586 L1UserTxs = append(L1UserTxs, l1Tx)
587
588 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
589 require.NoError(t, err)
590
591 currentBlockNum, err := rollupClient.client.EthLastBlock()
592 require.NoError(t, err)
593 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
594 require.NoError(t, err)
595 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
596 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
597 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
598 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
599 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
600}
601
602func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
603 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
604 require.NoError(t, err)
605 fromIdxInt64 := int64(258)
606 toIdxInt64 := int64(259)
607 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
608 amount, _ := new(big.Int).SetString("40000000000000000000", 10)
609 l1Tx := common.L1Tx{
610 FromIdx: common.Idx(fromIdxInt64),
611 ToIdx: common.Idx(toIdxInt64),
612 LoadAmount: loadAmount,
613 TokenID: common.TokenID(tokenIDERC777),
614 Amount: amount,
615 }
616 L1UserTxs = append(L1UserTxs, l1Tx)
617
618 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
619 require.NoError(t, err)
620
621 currentBlockNum, err := rollupClient.client.EthLastBlock()
622 require.NoError(t, err)
623 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
624 require.NoError(t, err)
625 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
626 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
627 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
628 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
629 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
630}
631
632func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
633 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
634 require.NoError(t, err)
635 fromIdxInt64 := int64(256)
636 toIdxInt64 := int64(257)
637 tokenIDUint32 := uint32(0)
638 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
639 l1Tx := common.L1Tx{
640 FromIdx: common.Idx(fromIdxInt64),
641 ToIdx: common.Idx(toIdxInt64),
642 LoadAmount: big.NewInt(0),
643 TokenID: common.TokenID(tokenIDUint32),
644 Amount: amount,
645 }
646 L1UserTxs = append(L1UserTxs, l1Tx)
647
648 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
649 require.NoError(t, err)
650
651 currentBlockNum, err := rollupClient.client.EthLastBlock()
652 require.NoError(t, err)
653 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
654 require.NoError(t, err)
655 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
656 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
657 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
658 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
659 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
660}
661
662func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
663 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
664 require.NoError(t, err)
665 fromIdxInt64 := int64(257)
666 toIdxInt64 := int64(258)
667 amount, _ := new(big.Int).SetString("10000000000000000000", 10)
668 l1Tx := common.L1Tx{
669 FromIdx: common.Idx(fromIdxInt64),
670 ToIdx: common.Idx(toIdxInt64),
671 LoadAmount: big.NewInt(0),
672 TokenID: common.TokenID(tokenHEZID),
673 Amount: amount,
674 }
675 L1UserTxs = append(L1UserTxs, l1Tx)
676
677 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
678 require.NoError(t, err)
679
680 currentBlockNum, err := rollupClient.client.EthLastBlock()
681 require.NoError(t, err)
682 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
683 require.NoError(t, err)
684 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
685 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
686 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
687 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
688 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
689}
690
691func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
692 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
693 require.NoError(t, err)
694 fromIdxInt64 := int64(259)
695 toIdxInt64 := int64(260)
696 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
697 l1Tx := common.L1Tx{
698 FromIdx: common.Idx(fromIdxInt64),
699 ToIdx: common.Idx(toIdxInt64),
700 LoadAmount: big.NewInt(0),
701 TokenID: common.TokenID(tokenIDERC777),
702 Amount: amount,
703 }
704 L1UserTxs = append(L1UserTxs, l1Tx)
705
706 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
707 require.NoError(t, err)
708
709 currentBlockNum, err := rollupClient.client.EthLastBlock()
710 require.NoError(t, err)
711 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
712 require.NoError(t, err)
713 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
714 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
715 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
716 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
717 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
718}
719
720func TestRollupL1UserTxETHForceExit(t *testing.T) {
721 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
722 require.NoError(t, err)
723 fromIdxInt64 := int64(256)
724 toIdxInt64 := int64(1)
725 tokenIDUint32 := uint32(0)
726 amount, _ := new(big.Int).SetString("10000000000000000000", 10)
727 l1Tx := common.L1Tx{
728 FromIdx: common.Idx(fromIdxInt64),
729 ToIdx: common.Idx(toIdxInt64),
730 LoadAmount: big.NewInt(0),
731 TokenID: common.TokenID(tokenIDUint32),
732 Amount: amount,
733 }
734 L1UserTxs = append(L1UserTxs, l1Tx)
735
736 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
737 require.NoError(t, err)
738
739 currentBlockNum, err := rollupClient.client.EthLastBlock()
740 require.NoError(t, err)
741 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
742 require.NoError(t, err)
743 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
744 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
745 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
746 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
747 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
748}
749
750func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
751 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
752 require.NoError(t, err)
753 fromIdxInt64 := int64(257)
754 toIdxInt64 := int64(1)
755 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
756 l1Tx := common.L1Tx{
757 FromIdx: common.Idx(fromIdxInt64),
758 ToIdx: common.Idx(toIdxInt64),
759 LoadAmount: big.NewInt(0),
760 TokenID: common.TokenID(tokenHEZID),
761 Amount: amount,
762 }
763 L1UserTxs = append(L1UserTxs, l1Tx)
764
765 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
766 require.NoError(t, err)
767
768 currentBlockNum, err := rollupClient.client.EthLastBlock()
769 require.NoError(t, err)
770 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
771 require.NoError(t, err)
772 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
773 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
774 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
775 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
776 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
777}
778
779func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
780 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
781 require.NoError(t, err)
782 fromIdxInt64 := int64(258)
783 toIdxInt64 := int64(1)
784 fromIdx := new(common.Idx)
785 *fromIdx = 0
786 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
787 l1Tx := common.L1Tx{
788 FromIdx: common.Idx(fromIdxInt64),
789 ToIdx: common.Idx(toIdxInt64),
790 LoadAmount: big.NewInt(0),
791 TokenID: common.TokenID(tokenIDERC777),
792 Amount: amount,
793 }
794 L1UserTxs = append(L1UserTxs, l1Tx)
795
796 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
797 require.NoError(t, err)
798
799 currentBlockNum, err := rollupClient.client.EthLastBlock()
800 require.NoError(t, err)
801 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
802 require.NoError(t, err)
803 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
804 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
805 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
806 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
807 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
808}
809
810func TestRollupForgeBatch2(t *testing.T) {
811 // Forge Batch 2
812 _, err := rollupClient.RollupForgeBatch(argsForge)
813 require.NoError(t, err)
814 currentBlockNum, err := rollupClient.client.EthLastBlock()
815 require.NoError(t, err)
816 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
817 require.NoError(t, err)
818
819 assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum)
820
821 // Forge Batch 3
822 args := new(RollupForgeBatchArgs)
823 args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
824 args.L1CoordinatorTxs = argsForge.L1CoordinatorTxs
825 args.L1CoordinatorTxsAuths = argsForge.L1CoordinatorTxsAuths
826 for i := 0; i < len(L1UserTxs); i++ {
827 l1UserTx := L1UserTxs[i]
828 l1UserTx.EffectiveAmount = l1UserTx.Amount
829 l1Bytes, err := l1UserTx.BytesDataAvailability(uint32(nLevels))
830 require.NoError(t, err)
831 l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes, uint32(nLevels))
832 require.NoError(t, err)
833 args.L1UserTxs = append(args.L1UserTxs, *l1UserTxDataAvailability)
834 }
835 newStateRoot := new(big.Int)
836 newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
837 newExitRoot := new(big.Int)
838 newExitRoot.SetString("1114281409737474688393837964161044726766678436313681099613347372031079422302", 10)
839 amount := new(big.Int)
840 amount.SetString("79000000", 10)
841 l2Tx := common.L2Tx{
842 ToIdx: 256,
843 Amount: amount,
844 FromIdx: 257,
845 Fee: 201,
846 }
847 l2Txs := []common.L2Tx{}
848 l2Txs = append(l2Txs, l2Tx)
849 l2Txs = append(l2Txs, l2Tx)
850 args.L2TxsData = l2Txs
851 args.NewLastIdx = int64(1000)
852 args.NewStRoot = newStateRoot
853 args.NewExitRoot = newExitRoot
854 args.L1Batch = true
855 args.VerifierIdx = 0
856 args.ProofA[0] = big.NewInt(0)
857 args.ProofA[1] = big.NewInt(0)
858 args.ProofB[0] = [2]*big.Int{big.NewInt(0), big.NewInt(0)}
859 args.ProofB[1] = [2]*big.Int{big.NewInt(0), big.NewInt(0)}
860 args.ProofC[0] = big.NewInt(0)
861 args.ProofC[1] = big.NewInt(0)
862
863 argsForge = args
864
865 _, err = rollupClient.RollupForgeBatch(argsForge)
866 require.NoError(t, err)
867
868 currentBlockNum, err = rollupClient.client.EthLastBlock()
869 require.NoError(t, err)
870 rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum)
871 require.NoError(t, err)
872
873 assert.Equal(t, int64(3), rollupEvents.ForgeBatch[0].BatchNum)
874 assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen)
875 ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash
876}
877
878func TestRollupForgeBatchArgs2(t *testing.T) {
879 args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs)))
880 require.NoError(t, err)
881 assert.Equal(t, *sender, rollupClient.client.account.Address)
882 assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator)
883 assert.Equal(t, argsForge.L1Batch, args.L1Batch)
884 assert.Equal(t, argsForge.L1UserTxs, args.L1UserTxs)
885 assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs)
886 assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths)
887 assert.Equal(t, argsForge.L2TxsData, args.L2TxsData)
888 assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx)
889 assert.Equal(t, argsForge.NewStRoot, args.NewStRoot)
890 assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx)
891}
892
893func TestRollupWithdrawMerkleProof(t *testing.T) {
894 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
895 require.NoError(t, err)
896
897 var pkComp babyjub.PublicKeyComp
898 pkCompBE, err := hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2")
899 require.NoError(t, err)
900 pkCompLE := common.SwapEndianness(pkCompBE)
901 copy(pkComp[:], pkCompLE)
902
903 pk, err := pkComp.Decompress()
904 require.NoError(t, err)
905
906 require.NoError(t, err)
907 tokenID := uint32(tokenHEZID)
908 numExitRoot := int64(3)
909 fromIdx := int64(256)
910 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
911 // siblingBytes0, err := new(big.Int).SetString("19508838618377323910556678335932426220272947530531646682154552299216398748115", 10)
912 // require.NoError(t, err)
913 // siblingBytes1, err := new(big.Int).SetString("15198806719713909654457742294233381653226080862567104272457668857208564789571", 10)
914 // require.NoError(t, err)
915 var siblings []*big.Int
916 // siblings = append(siblings, siblingBytes0)
917 // siblings = append(siblings, siblingBytes1)
918 instantWithdraw := true
919
920 _, err = rollupClientAux.RollupWithdrawMerkleProof(pk, tokenID, numExitRoot, fromIdx, amount, siblings, instantWithdraw)
921 require.NoError(t, err)
922
923 currentBlockNum, err := rollupClient.client.EthLastBlock()
924 require.NoError(t, err)
925 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
926 require.NoError(t, err)
927
928 assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx)
929 assert.Equal(t, instantWithdraw, rollupEvents.Withdraw[0].InstantWithdraw)
930 assert.Equal(t, uint64(numExitRoot), rollupEvents.Withdraw[0].NumExitRoot)
931 // tokenAmount = 20
932 // amountUSD = tokenAmount * tokenPrice = 20 * 10 = 200
933 // Bucket[0].ceilUSD = 100, Bucket[1].ceilUSD = 200, ...
934 // Bucket 1
935 // Bucket[0].withdrawals = 1, Bucket[1].withdrawals = 2, ...
936 // Bucket[1].withdrawals - 1 = 1
937 assert.Equal(t, 1, rollupEvents.UpdateBucketWithdraw[0].NumBucket)
938 assert.Equal(t, blockStampBucket, rollupEvents.UpdateBucketWithdraw[0].BlockStamp)
939 assert.Equal(t, big.NewInt(1), rollupEvents.UpdateBucketWithdraw[0].Withdrawals)
940}
941
942func TestRollupSafeMode(t *testing.T) {
943 _, err := rollupClient.RollupSafeMode()
944 require.NoError(t, err)
945
946 currentBlockNum, err := rollupClient.client.EthLastBlock()
947 require.NoError(t, err)
948 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
949 require.NoError(t, err)
950 auxEvent := new(RollupEventSafeMode)
951 assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0])
952}