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