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.Nil(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.Nil(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.Nil(t, err)
81 _, err = rollupClient.RollupAddToken(tokenHEZAddressConst, feeAddToken, deadline)
82 require.Nil(t, err)
83 currentBlockNum, err := rollupClient.client.EthLastBlock()
84 require.Nil(t, err)
85 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
86 require.Nil(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.Nil(t, err)
99
100 // MultiBid
101 currentSlot, err := auctionClient.AuctionGetCurrentSlotNumber()
102 require.Nil(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.Nil(t, err)
112
113 // Add Blocks
114 blockNum := int64(int(blocksPerSlot)*int(currentSlot+4) + int(genesisBlock))
115 currentBlockNum, err := auctionClient.client.EthLastBlock()
116 require.Nil(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.Nil(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.Nil(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.Nil(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.Nil(t, err)
165
166 currentBlockNum, err = rollupClient.client.EthLastBlock()
167 require.Nil(t, err)
168 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
169 require.Nil(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.Nil(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.Nil(t, err)
194
195 currentBlockNum, err := rollupClient.client.EthLastBlock()
196 require.Nil(t, err)
197 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
198 require.Nil(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.Nil(t, err)
207
208 currentBlockNum, err := rollupClient.client.EthLastBlock()
209 require.Nil(t, err)
210 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
211 require.Nil(t, err)
212
213 assert.Equal(t, newFeeAddToken, rollupEvents.UpdateFeeAddToken[0].NewFeeAddToken)
214}
215
216func TestRollupUpdateBucketsParameters(t *testing.T) {
217 var bucketsParameters [common.RollupConstNumBuckets][4]*big.Int
218 for i := range bucketsParameters {
219 bucketsParameters[i][0] = big.NewInt(int64((i + 1) * 100)) // ceilUSD
220 bucketsParameters[i][1] = big.NewInt(int64(i + 1)) // withdrawals
221 bucketsParameters[i][2] = big.NewInt(int64(i+1) * 100) // blockWithdrawalRate
222 bucketsParameters[i][3] = big.NewInt(int64(100000000000)) // maxWithdrawals
223 }
224 _, err := rollupClient.RollupUpdateBucketsParameters(bucketsParameters)
225 require.Nil(t, err)
226 currentBlockNum, err := rollupClient.client.EthLastBlock()
227 require.Nil(t, err)
228 blockStampBucket = currentBlockNum
229 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
230 require.Nil(t, err)
231 for i := range bucketsParameters {
232 assert.Equal(t, bucketsParameters[i][0].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][0].String())
233 assert.Equal(t, bucketsParameters[i][1].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][1].String())
234 assert.Equal(t, bucketsParameters[i][2].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][2].String())
235 assert.Equal(t, bucketsParameters[i][3].String(), rollupEvents.UpdateBucketsParameters[0].ArrayBuckets[i][3].String())
236 }
237
238}
239
240func TestRollupUpdateWithdrawalDelay(t *testing.T) {
241 newWithdrawalDelay := uint64(100000)
242 _, err := rollupClient.RollupUpdateWithdrawalDelay(newWithdrawalDelay)
243 require.Nil(t, err)
244 currentBlockNum, err := rollupClient.client.EthLastBlock()
245 require.Nil(t, err)
246 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
247 require.Nil(t, err)
248 assert.Equal(t, newWithdrawalDelay, rollupEvents.UpdateWithdrawalDelay[0].NewWithdrawalDelay)
249}
250
251func TestRollupUpdateTokenExchange(t *testing.T) {
252 var addressArray []ethCommon.Address
253 var valueArray []uint64
254 addressToken1, err := rollupClient.hermez.TokenList(nil, big.NewInt(1))
255 addressArray = append(addressArray, addressToken1)
256 tokenPrice := 10
257 valueArray = append(valueArray, uint64(tokenPrice*1e14))
258 require.Nil(t, err)
259 _, err = rollupClient.RollupUpdateTokenExchange(addressArray, valueArray)
260 require.Nil(t, err)
261 currentBlockNum, err := rollupClient.client.EthLastBlock()
262 require.Nil(t, err)
263 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
264 require.Nil(t, err)
265 assert.Equal(t, addressArray, rollupEvents.UpdateTokenExchange[0].AddressArray)
266 assert.Equal(t, valueArray, rollupEvents.UpdateTokenExchange[0].ValueArray)
267}
268
269func TestRollupL1UserTxETHCreateAccountDeposit(t *testing.T) {
270 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
271 require.Nil(t, err)
272 key := genKeysBjj(2)
273 fromIdxInt64 := int64(0)
274 toIdxInt64 := int64(0)
275 tokenIDUint32 := uint32(0)
276 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
277 l1Tx := common.L1Tx{
278 FromBJJ: key.BJJPublicKey,
279 FromIdx: common.Idx(fromIdxInt64),
280 ToIdx: common.Idx(toIdxInt64),
281 LoadAmount: loadAmount,
282 TokenID: common.TokenID(tokenIDUint32),
283 Amount: big.NewInt(0),
284 }
285 L1UserTxs = append(L1UserTxs, l1Tx)
286
287 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
288 require.Nil(t, err)
289
290 currentBlockNum, err := rollupClient.client.EthLastBlock()
291 require.Nil(t, err)
292 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
293 require.Nil(t, err)
294 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
295 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
296 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
297 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
298 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
299 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
300}
301
302func TestRollupL1UserTxERC20CreateAccountDeposit(t *testing.T) {
303 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
304 require.Nil(t, err)
305 key := genKeysBjj(1)
306 fromIdxInt64 := int64(0)
307 toIdxInt64 := int64(0)
308 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
309 l1Tx := common.L1Tx{
310 FromBJJ: key.BJJPublicKey,
311 FromIdx: common.Idx(fromIdxInt64),
312 ToIdx: common.Idx(toIdxInt64),
313 LoadAmount: loadAmount,
314 TokenID: common.TokenID(tokenHEZID),
315 Amount: big.NewInt(0),
316 }
317 L1UserTxs = append(L1UserTxs, l1Tx)
318
319 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
320 require.Nil(t, err)
321
322 currentBlockNum, err := rollupClient.client.EthLastBlock()
323 require.Nil(t, err)
324 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
325 require.Nil(t, err)
326 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
327 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
328 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
329 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
330 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
331 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
332}
333
334func TestRollupL1UserTxERC20PermitCreateAccountDeposit(t *testing.T) {
335 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
336 require.Nil(t, err)
337 key := genKeysBjj(3)
338 fromIdxInt64 := int64(0)
339 toIdxInt64 := int64(0)
340 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
341 l1Tx := common.L1Tx{
342 FromBJJ: key.BJJPublicKey,
343 FromIdx: common.Idx(fromIdxInt64),
344 ToIdx: common.Idx(toIdxInt64),
345 LoadAmount: loadAmount,
346 TokenID: common.TokenID(tokenIDERC777),
347 Amount: big.NewInt(0),
348 }
349 L1UserTxs = append(L1UserTxs, l1Tx)
350
351 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
352 require.Nil(t, err)
353
354 currentBlockNum, err := rollupClient.client.EthLastBlock()
355 require.Nil(t, err)
356 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
357 require.Nil(t, err)
358 assert.Equal(t, l1Tx.FromBJJ, rollupEvents.L1UserTx[0].L1UserTx.FromBJJ)
359 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
360 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
361 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
362 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
363 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
364}
365
366func TestRollupL1UserTxETHDeposit(t *testing.T) {
367 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
368 require.Nil(t, err)
369 fromIdxInt64 := int64(256)
370 toIdxInt64 := int64(0)
371 tokenIDUint32 := uint32(0)
372 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
373 l1Tx := common.L1Tx{
374 FromBJJ: nil,
375 FromIdx: common.Idx(fromIdxInt64),
376 ToIdx: common.Idx(toIdxInt64),
377 LoadAmount: loadAmount,
378 TokenID: common.TokenID(tokenIDUint32),
379 Amount: big.NewInt(0),
380 }
381 L1UserTxs = append(L1UserTxs, l1Tx)
382
383 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
384 require.Nil(t, err)
385
386 currentBlockNum, err := rollupClient.client.EthLastBlock()
387 require.Nil(t, err)
388 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
389 require.Nil(t, err)
390 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
391 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
392 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
393 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
394 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
395}
396
397func TestRollupL1UserTxERC20Deposit(t *testing.T) {
398 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
399 require.Nil(t, err)
400 fromIdxInt64 := int64(257)
401 toIdxInt64 := int64(0)
402 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
403 l1Tx := common.L1Tx{
404 FromBJJ: nil,
405 FromIdx: common.Idx(fromIdxInt64),
406 ToIdx: common.Idx(toIdxInt64),
407 LoadAmount: loadAmount,
408 TokenID: common.TokenID(tokenHEZID),
409 Amount: big.NewInt(0),
410 }
411 L1UserTxs = append(L1UserTxs, l1Tx)
412
413 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
414 require.Nil(t, err)
415
416 currentBlockNum, err := rollupClient.client.EthLastBlock()
417 require.Nil(t, err)
418 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
419 require.Nil(t, err)
420 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
421 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
422 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
423 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
424 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
425}
426
427func TestRollupL1UserTxERC20PermitDeposit(t *testing.T) {
428 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
429 require.Nil(t, err)
430 fromIdxInt64 := int64(258)
431 toIdxInt64 := int64(0)
432 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
433 l1Tx := common.L1Tx{
434 FromIdx: common.Idx(fromIdxInt64),
435 ToIdx: common.Idx(toIdxInt64),
436 LoadAmount: loadAmount,
437 TokenID: common.TokenID(tokenIDERC777),
438 Amount: big.NewInt(0),
439 }
440 L1UserTxs = append(L1UserTxs, l1Tx)
441
442 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
443 require.Nil(t, err)
444
445 currentBlockNum, err := rollupClient.client.EthLastBlock()
446 require.Nil(t, err)
447 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
448 require.Nil(t, err)
449 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
450 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
451 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
452 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
453 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
454}
455
456func TestRollupL1UserTxETHDepositTransfer(t *testing.T) {
457 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
458 require.Nil(t, err)
459 fromIdxInt64 := int64(256)
460 toIdxInt64 := int64(257)
461 tokenIDUint32 := uint32(0)
462 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
463 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
464 l1Tx := common.L1Tx{
465 FromIdx: common.Idx(fromIdxInt64),
466 ToIdx: common.Idx(toIdxInt64),
467 LoadAmount: loadAmount,
468 TokenID: common.TokenID(tokenIDUint32),
469 Amount: amount,
470 }
471 L1UserTxs = append(L1UserTxs, l1Tx)
472
473 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
474 require.Nil(t, err)
475
476 currentBlockNum, err := rollupClient.client.EthLastBlock()
477 require.Nil(t, err)
478 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
479 require.Nil(t, err)
480 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
481 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
482 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
483 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
484 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
485}
486
487func TestRollupL1UserTxERC20DepositTransfer(t *testing.T) {
488 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
489 require.Nil(t, err)
490 fromIdxInt64 := int64(257)
491 toIdxInt64 := int64(258)
492 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
493 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
494 l1Tx := common.L1Tx{
495 FromIdx: common.Idx(fromIdxInt64),
496 ToIdx: common.Idx(toIdxInt64),
497 LoadAmount: loadAmount,
498 TokenID: common.TokenID(tokenHEZID),
499 Amount: amount,
500 }
501 L1UserTxs = append(L1UserTxs, l1Tx)
502
503 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
504 require.Nil(t, err)
505
506 currentBlockNum, err := rollupClient.client.EthLastBlock()
507 require.Nil(t, err)
508 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
509 require.Nil(t, err)
510 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
511 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
512 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
513 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
514 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
515}
516
517func TestRollupL1UserTxERC20PermitDepositTransfer(t *testing.T) {
518 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
519 require.Nil(t, err)
520 fromIdxInt64 := int64(258)
521 toIdxInt64 := int64(259)
522 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
523 amount, _ := new(big.Int).SetString("100000000000000000000", 10)
524 l1Tx := common.L1Tx{
525 FromIdx: common.Idx(fromIdxInt64),
526 ToIdx: common.Idx(toIdxInt64),
527 LoadAmount: loadAmount,
528 TokenID: common.TokenID(tokenIDERC777),
529 Amount: amount,
530 }
531 L1UserTxs = append(L1UserTxs, l1Tx)
532
533 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
534 require.Nil(t, err)
535
536 currentBlockNum, err := rollupClient.client.EthLastBlock()
537 require.Nil(t, err)
538 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
539 require.Nil(t, err)
540 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
541 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
542 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
543 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
544 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
545}
546
547func TestRollupL1UserTxETHCreateAccountDepositTransfer(t *testing.T) {
548 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
549 require.Nil(t, err)
550 fromIdxInt64 := int64(256)
551 toIdxInt64 := int64(257)
552 tokenIDUint32 := uint32(0)
553 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
554 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
555 l1Tx := common.L1Tx{
556 FromIdx: common.Idx(fromIdxInt64),
557 ToIdx: common.Idx(toIdxInt64),
558 LoadAmount: loadAmount,
559 TokenID: common.TokenID(tokenIDUint32),
560 Amount: amount,
561 }
562 L1UserTxs = append(L1UserTxs, l1Tx)
563
564 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
565 require.Nil(t, err)
566
567 currentBlockNum, err := rollupClient.client.EthLastBlock()
568 require.Nil(t, err)
569 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
570 require.Nil(t, err)
571 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
572 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
573 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
574 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
575 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
576}
577
578func TestRollupL1UserTxERC20CreateAccountDepositTransfer(t *testing.T) {
579 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
580 require.Nil(t, err)
581 fromIdxInt64 := int64(257)
582 toIdxInt64 := int64(258)
583 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
584 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
585 l1Tx := common.L1Tx{
586 FromIdx: common.Idx(fromIdxInt64),
587 ToIdx: common.Idx(toIdxInt64),
588 LoadAmount: loadAmount,
589 TokenID: common.TokenID(tokenHEZID),
590 Amount: amount,
591 }
592 L1UserTxs = append(L1UserTxs, l1Tx)
593
594 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
595 require.Nil(t, err)
596
597 currentBlockNum, err := rollupClient.client.EthLastBlock()
598 require.Nil(t, err)
599 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
600 require.Nil(t, err)
601 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
602 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
603 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
604 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
605 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
606}
607
608func TestRollupL1UserTxERC20PermitCreateAccountDepositTransfer(t *testing.T) {
609 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
610 require.Nil(t, err)
611 fromIdxInt64 := int64(258)
612 toIdxInt64 := int64(259)
613 loadAmount, _ := new(big.Int).SetString("1000000000000000000000", 10)
614 amount, _ := new(big.Int).SetString("40000000000000000000", 10)
615 l1Tx := common.L1Tx{
616 FromIdx: common.Idx(fromIdxInt64),
617 ToIdx: common.Idx(toIdxInt64),
618 LoadAmount: loadAmount,
619 TokenID: common.TokenID(tokenIDERC777),
620 Amount: amount,
621 }
622 L1UserTxs = append(L1UserTxs, l1Tx)
623
624 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
625 require.Nil(t, err)
626
627 currentBlockNum, err := rollupClient.client.EthLastBlock()
628 require.Nil(t, err)
629 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
630 require.Nil(t, err)
631 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
632 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
633 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
634 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
635 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
636}
637
638func TestRollupL1UserTxETHForceTransfer(t *testing.T) {
639 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
640 require.Nil(t, err)
641 fromIdxInt64 := int64(256)
642 toIdxInt64 := int64(257)
643 tokenIDUint32 := uint32(0)
644 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
645 l1Tx := common.L1Tx{
646 FromIdx: common.Idx(fromIdxInt64),
647 ToIdx: common.Idx(toIdxInt64),
648 LoadAmount: big.NewInt(0),
649 TokenID: common.TokenID(tokenIDUint32),
650 Amount: amount,
651 }
652 L1UserTxs = append(L1UserTxs, l1Tx)
653
654 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
655 require.Nil(t, err)
656
657 currentBlockNum, err := rollupClient.client.EthLastBlock()
658 require.Nil(t, err)
659 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
660 require.Nil(t, err)
661 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
662 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
663 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
664 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
665 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
666}
667
668func TestRollupL1UserTxERC20ForceTransfer(t *testing.T) {
669 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
670 require.Nil(t, err)
671 fromIdxInt64 := int64(257)
672 toIdxInt64 := int64(258)
673 amount, _ := new(big.Int).SetString("10000000000000000000", 10)
674 l1Tx := common.L1Tx{
675 FromIdx: common.Idx(fromIdxInt64),
676 ToIdx: common.Idx(toIdxInt64),
677 LoadAmount: big.NewInt(0),
678 TokenID: common.TokenID(tokenHEZID),
679 Amount: amount,
680 }
681 L1UserTxs = append(L1UserTxs, l1Tx)
682
683 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
684 require.Nil(t, err)
685
686 currentBlockNum, err := rollupClient.client.EthLastBlock()
687 require.Nil(t, err)
688 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
689 require.Nil(t, err)
690 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
691 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
692 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
693 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
694 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
695}
696
697func TestRollupL1UserTxERC20PermitForceTransfer(t *testing.T) {
698 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
699 require.Nil(t, err)
700 fromIdxInt64 := int64(259)
701 toIdxInt64 := int64(260)
702 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
703 l1Tx := common.L1Tx{
704 FromIdx: common.Idx(fromIdxInt64),
705 ToIdx: common.Idx(toIdxInt64),
706 LoadAmount: big.NewInt(0),
707 TokenID: common.TokenID(tokenIDERC777),
708 Amount: amount,
709 }
710 L1UserTxs = append(L1UserTxs, l1Tx)
711
712 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
713 require.Nil(t, err)
714
715 currentBlockNum, err := rollupClient.client.EthLastBlock()
716 require.Nil(t, err)
717 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
718 require.Nil(t, err)
719 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
720 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
721 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
722 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
723 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
724}
725
726func TestRollupL1UserTxETHForceExit(t *testing.T) {
727 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
728 require.Nil(t, err)
729 fromIdxInt64 := int64(256)
730 toIdxInt64 := int64(1)
731 tokenIDUint32 := uint32(0)
732 amount, _ := new(big.Int).SetString("10000000000000000000", 10)
733 l1Tx := common.L1Tx{
734 FromIdx: common.Idx(fromIdxInt64),
735 ToIdx: common.Idx(toIdxInt64),
736 LoadAmount: big.NewInt(0),
737 TokenID: common.TokenID(tokenIDUint32),
738 Amount: amount,
739 }
740 L1UserTxs = append(L1UserTxs, l1Tx)
741
742 _, err = rollupClientAux.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDUint32, toIdxInt64)
743 require.Nil(t, err)
744
745 currentBlockNum, err := rollupClient.client.EthLastBlock()
746 require.Nil(t, err)
747 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
748 require.Nil(t, err)
749 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
750 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
751 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
752 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
753 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
754}
755
756func TestRollupL1UserTxERC20ForceExit(t *testing.T) {
757 rollupClientAux2, err := NewRollupClient(ethereumClientAux2, hermezRollupAddressConst, tokenHEZ)
758 require.Nil(t, err)
759 fromIdxInt64 := int64(257)
760 toIdxInt64 := int64(1)
761 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
762 l1Tx := common.L1Tx{
763 FromIdx: common.Idx(fromIdxInt64),
764 ToIdx: common.Idx(toIdxInt64),
765 LoadAmount: big.NewInt(0),
766 TokenID: common.TokenID(tokenHEZID),
767 Amount: amount,
768 }
769 L1UserTxs = append(L1UserTxs, l1Tx)
770
771 _, err = rollupClientAux2.RollupL1UserTxERC20ETH(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenHEZID, toIdxInt64)
772 require.Nil(t, err)
773
774 currentBlockNum, err := rollupClient.client.EthLastBlock()
775 require.Nil(t, err)
776 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
777 require.Nil(t, err)
778 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
779 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
780 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
781 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
782 assert.Equal(t, rollupClientAux2.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
783}
784
785func TestRollupL1UserTxERC20PermitForceExit(t *testing.T) {
786 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
787 require.Nil(t, err)
788 fromIdxInt64 := int64(258)
789 toIdxInt64 := int64(1)
790 fromIdx := new(common.Idx)
791 *fromIdx = 0
792 amount, _ := new(big.Int).SetString("30000000000000000000", 10)
793 l1Tx := common.L1Tx{
794 FromIdx: common.Idx(fromIdxInt64),
795 ToIdx: common.Idx(toIdxInt64),
796 LoadAmount: big.NewInt(0),
797 TokenID: common.TokenID(tokenIDERC777),
798 Amount: amount,
799 }
800 L1UserTxs = append(L1UserTxs, l1Tx)
801
802 _, err = rollupClientAux.RollupL1UserTxERC20Permit(l1Tx.FromBJJ, fromIdxInt64, l1Tx.LoadAmount, l1Tx.Amount, tokenIDERC777, toIdxInt64, deadline)
803 require.Nil(t, err)
804
805 currentBlockNum, err := rollupClient.client.EthLastBlock()
806 require.Nil(t, err)
807 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
808 require.Nil(t, err)
809 assert.Equal(t, l1Tx.ToIdx, rollupEvents.L1UserTx[0].L1UserTx.ToIdx)
810 assert.Equal(t, l1Tx.LoadAmount, rollupEvents.L1UserTx[0].L1UserTx.LoadAmount)
811 assert.Equal(t, l1Tx.TokenID, rollupEvents.L1UserTx[0].L1UserTx.TokenID)
812 assert.Equal(t, l1Tx.Amount, rollupEvents.L1UserTx[0].L1UserTx.Amount)
813 assert.Equal(t, rollupClientAux.client.account.Address, rollupEvents.L1UserTx[0].L1UserTx.FromEthAddr)
814}
815
816func TestRollupForgeBatch2(t *testing.T) {
817 // Forge Batch 2
818 _, err := rollupClient.RollupForgeBatch(argsForge)
819 require.Nil(t, err)
820 currentBlockNum, err := rollupClient.client.EthLastBlock()
821 require.Nil(t, err)
822 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
823 require.Nil(t, err)
824
825 assert.Equal(t, int64(2), rollupEvents.ForgeBatch[0].BatchNum)
826
827 // Forge Batch 3
828 args := new(RollupForgeBatchArgs)
829 args.FeeIdxCoordinator = []common.Idx{} // When encoded, 64 times the 0 idx means that no idx to collect fees is specified.
830 args.L1CoordinatorTxs = argsForge.L1CoordinatorTxs
831 args.L1CoordinatorTxsAuths = argsForge.L1CoordinatorTxsAuths
832 for i := 0; i < len(L1UserTxs); i++ {
833 l1UserTx := L1UserTxs[i]
834 l1UserTx.EffectiveAmount = l1UserTx.Amount
835 l1Bytes, err := l1UserTx.BytesDataAvailability(uint32(nLevels))
836 require.Nil(t, err)
837 l1UserTxDataAvailability, err := common.L1TxFromDataAvailability(l1Bytes, uint32(nLevels))
838 require.Nil(t, err)
839 args.L1UserTxs = append(args.L1UserTxs, *l1UserTxDataAvailability)
840 }
841 newStateRoot := new(big.Int)
842 newStateRoot.SetString("18317824016047294649053625209337295956588174734569560016974612130063629505228", 10)
843 newExitRoot := new(big.Int)
844 newExitRoot.SetString("1114281409737474688393837964161044726766678436313681099613347372031079422302", 10)
845 amount := new(big.Int)
846 amount.SetString("79000000", 10)
847 l2Tx := common.L2Tx{
848 ToIdx: 256,
849 Amount: amount,
850 FromIdx: 257,
851 Fee: 201,
852 }
853 l2Txs := []common.L2Tx{}
854 l2Txs = append(l2Txs, l2Tx)
855 l2Txs = append(l2Txs, l2Tx)
856 args.L2TxsData = l2Txs
857 args.NewLastIdx = int64(1000)
858 args.NewStRoot = newStateRoot
859 args.NewExitRoot = newExitRoot
860 args.L1Batch = true
861 args.VerifierIdx = 0
862 args.ProofA[0] = big.NewInt(0)
863 args.ProofA[1] = big.NewInt(0)
864 args.ProofB[0] = [2]*big.Int{big.NewInt(0), big.NewInt(0)}
865 args.ProofB[1] = [2]*big.Int{big.NewInt(0), big.NewInt(0)}
866 args.ProofC[0] = big.NewInt(0)
867 args.ProofC[1] = big.NewInt(0)
868
869 argsForge = args
870
871 _, err = rollupClient.RollupForgeBatch(argsForge)
872 require.Nil(t, err)
873
874 currentBlockNum, err = rollupClient.client.EthLastBlock()
875 require.Nil(t, err)
876 rollupEvents, _, err = rollupClient.RollupEventsByBlock(currentBlockNum)
877 require.Nil(t, err)
878
879 assert.Equal(t, int64(3), rollupEvents.ForgeBatch[0].BatchNum)
880 assert.Equal(t, uint16(len(L1UserTxs)), rollupEvents.ForgeBatch[0].L1UserTxsLen)
881 ethHashForge = rollupEvents.ForgeBatch[0].EthTxHash
882
883}
884
885func TestRollupForgeBatchArgs2(t *testing.T) {
886 args, sender, err := rollupClient.RollupForgeBatchArgs(ethHashForge, uint16(len(L1UserTxs)))
887 require.Nil(t, err)
888 assert.Equal(t, *sender, rollupClient.client.account.Address)
889 assert.Equal(t, argsForge.FeeIdxCoordinator, args.FeeIdxCoordinator)
890 assert.Equal(t, argsForge.L1Batch, args.L1Batch)
891 assert.Equal(t, argsForge.L1UserTxs, args.L1UserTxs)
892 assert.Equal(t, argsForge.L1CoordinatorTxs, args.L1CoordinatorTxs)
893 assert.Equal(t, argsForge.L1CoordinatorTxsAuths, args.L1CoordinatorTxsAuths)
894 assert.Equal(t, argsForge.L2TxsData, args.L2TxsData)
895 assert.Equal(t, argsForge.NewLastIdx, args.NewLastIdx)
896 assert.Equal(t, argsForge.NewStRoot, args.NewStRoot)
897 assert.Equal(t, argsForge.VerifierIdx, args.VerifierIdx)
898}
899
900func TestRollupWithdrawMerkleProof(t *testing.T) {
901 rollupClientAux, err := NewRollupClient(ethereumClientAux, hermezRollupAddressConst, tokenHEZ)
902 require.Nil(t, err)
903
904 var pkComp babyjub.PublicKeyComp
905 pkCompBE, err := hex.DecodeString("adc3b754f8da621967b073a787bef8eec7052f2ba712b23af57d98f65beea8b2")
906 require.Nil(t, err)
907 pkCompLE := common.SwapEndianness(pkCompBE)
908 copy(pkComp[:], pkCompLE)
909
910 pk, err := pkComp.Decompress()
911 require.Nil(t, err)
912
913 require.Nil(t, err)
914 tokenID := uint32(tokenHEZID)
915 numExitRoot := int64(3)
916 fromIdx := int64(256)
917 amount, _ := new(big.Int).SetString("20000000000000000000", 10)
918 // siblingBytes0, err := new(big.Int).SetString("19508838618377323910556678335932426220272947530531646682154552299216398748115", 10)
919 // require.Nil(t, err)
920 // siblingBytes1, err := new(big.Int).SetString("15198806719713909654457742294233381653226080862567104272457668857208564789571", 10)
921 // require.Nil(t, err)
922 var siblings []*big.Int
923 // siblings = append(siblings, siblingBytes0)
924 // siblings = append(siblings, siblingBytes1)
925 instantWithdraw := true
926
927 _, err = rollupClientAux.RollupWithdrawMerkleProof(pk, tokenID, numExitRoot, fromIdx, amount, siblings, instantWithdraw)
928 require.Nil(t, err)
929
930 currentBlockNum, err := rollupClient.client.EthLastBlock()
931 require.Nil(t, err)
932 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
933 require.Nil(t, err)
934
935 assert.Equal(t, uint64(fromIdx), rollupEvents.Withdraw[0].Idx)
936 assert.Equal(t, instantWithdraw, rollupEvents.Withdraw[0].InstantWithdraw)
937 assert.Equal(t, uint64(numExitRoot), rollupEvents.Withdraw[0].NumExitRoot)
938 // tokenAmount = 20
939 // amountUSD = tokenAmount * tokenPrice = 20 * 10 = 200
940 // Bucket[0].ceilUSD = 100, Bucket[1].ceilUSD = 200, ...
941 // Bucket 1
942 // Bucket[0].withdrawals = 1, Bucket[1].withdrawals = 2, ...
943 // Bucket[1].withdrawals - 1 = 1
944 assert.Equal(t, uint8(1), rollupEvents.UpdateBucketWithdraw[0].NumBucket)
945 assert.Equal(t, big.NewInt(blockStampBucket), rollupEvents.UpdateBucketWithdraw[0].BlockStamp)
946 assert.Equal(t, big.NewInt(1), rollupEvents.UpdateBucketWithdraw[0].Withdrawals)
947}
948
949func TestRollupSafeMode(t *testing.T) {
950 _, err := rollupClient.RollupSafeMode()
951 require.Nil(t, err)
952
953 currentBlockNum, err := rollupClient.client.EthLastBlock()
954 require.Nil(t, err)
955 rollupEvents, _, err := rollupClient.RollupEventsByBlock(currentBlockNum)
956 require.Nil(t, err)
957 auxEvent := new(RollupEventSafeMode)
958 assert.Equal(t, auxEvent, &rollupEvents.SafeMode[0])
959}