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