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