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