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