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