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