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