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