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