You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

986 lines
38 KiB

4 years ago
  1. package eth
  2. import (
  3. "context"
  4. "fmt"
  5. "math/big"
  6. "strconv"
  7. "strings"
  8. "github.com/ethereum/go-ethereum"
  9. "github.com/ethereum/go-ethereum/accounts/abi"
  10. "github.com/ethereum/go-ethereum/accounts/abi/bind"
  11. ethCommon "github.com/ethereum/go-ethereum/common"
  12. "github.com/ethereum/go-ethereum/core/types"
  13. "github.com/ethereum/go-ethereum/crypto"
  14. "github.com/ethereum/go-ethereum/ethclient"
  15. "github.com/hermeznetwork/hermez-node/common"
  16. Hermez "github.com/hermeznetwork/hermez-node/eth/contracts/hermez"
  17. HEZ "github.com/hermeznetwork/hermez-node/eth/contracts/tokenHEZ"
  18. "github.com/hermeznetwork/hermez-node/log"
  19. "github.com/hermeznetwork/tracerr"
  20. "github.com/iden3/go-iden3-crypto/babyjub"
  21. )
  22. // QueueStruct is the queue of L1Txs for a batch
  23. type QueueStruct struct {
  24. L1TxQueue []common.L1Tx
  25. TotalL1TxFee *big.Int
  26. }
  27. // NewQueueStruct creates a new clear QueueStruct.
  28. func NewQueueStruct() *QueueStruct {
  29. return &QueueStruct{
  30. L1TxQueue: make([]common.L1Tx, 0),
  31. TotalL1TxFee: big.NewInt(0),
  32. }
  33. }
  34. // RollupState represents the state of the Rollup in the Smart Contract
  35. type RollupState struct {
  36. StateRoot *big.Int
  37. ExitRoots []*big.Int
  38. // ExitNullifierMap map[[256 / 8]byte]bool
  39. ExitNullifierMap map[int64]map[int64]bool // batchNum -> idx -> bool
  40. TokenList []ethCommon.Address
  41. TokenMap map[ethCommon.Address]bool
  42. MapL1TxQueue map[int64]*QueueStruct
  43. LastL1L2Batch int64
  44. CurrentToForgeL1TxsNum int64
  45. LastToForgeL1TxsNum int64
  46. CurrentIdx int64
  47. }
  48. // RollupEventInitialize is the InitializeHermezEvent event of the
  49. // Smart Contract
  50. type RollupEventInitialize struct {
  51. ForgeL1L2BatchTimeout uint8
  52. FeeAddToken *big.Int
  53. WithdrawalDelay uint64
  54. }
  55. // RollupVariables returns the RollupVariables from the initialize event
  56. func (ei *RollupEventInitialize) RollupVariables() *common.RollupVariables {
  57. var buckets [common.RollupConstNumBuckets]common.BucketParams
  58. for i := range buckets {
  59. buckets[i] = common.BucketParams{
  60. CeilUSD: big.NewInt(0),
  61. Withdrawals: big.NewInt(0),
  62. BlockWithdrawalRate: big.NewInt(0),
  63. MaxWithdrawals: big.NewInt(0),
  64. }
  65. }
  66. return &common.RollupVariables{
  67. EthBlockNum: 0,
  68. FeeAddToken: ei.FeeAddToken,
  69. ForgeL1L2BatchTimeout: int64(ei.ForgeL1L2BatchTimeout),
  70. WithdrawalDelay: ei.WithdrawalDelay,
  71. Buckets: buckets,
  72. SafeMode: false,
  73. }
  74. }
  75. // RollupEventL1UserTx is an event of the Rollup Smart Contract
  76. type RollupEventL1UserTx struct {
  77. // ToForgeL1TxsNum int64 // QueueIndex *big.Int
  78. // Position int // TransactionIndex *big.Int
  79. L1UserTx common.L1Tx
  80. }
  81. // RollupEventL1UserTxAux is an event of the Rollup Smart Contract
  82. type rollupEventL1UserTxAux struct {
  83. ToForgeL1TxsNum uint64 // QueueIndex *big.Int
  84. Position uint8 // TransactionIndex *big.Int
  85. L1UserTx []byte
  86. }
  87. // RollupEventAddToken is an event of the Rollup Smart Contract
  88. type RollupEventAddToken struct {
  89. TokenAddress ethCommon.Address
  90. TokenID uint32
  91. }
  92. // RollupEventForgeBatch is an event of the Rollup Smart Contract
  93. type RollupEventForgeBatch struct {
  94. BatchNum int64
  95. // Sender ethCommon.Address
  96. EthTxHash ethCommon.Hash
  97. L1UserTxsLen uint16
  98. }
  99. // RollupEventUpdateForgeL1L2BatchTimeout is an event of the Rollup Smart Contract
  100. type RollupEventUpdateForgeL1L2BatchTimeout struct {
  101. NewForgeL1L2BatchTimeout int64
  102. }
  103. // RollupEventUpdateFeeAddToken is an event of the Rollup Smart Contract
  104. type RollupEventUpdateFeeAddToken struct {
  105. NewFeeAddToken *big.Int
  106. }
  107. // RollupEventWithdraw is an event of the Rollup Smart Contract
  108. type RollupEventWithdraw struct {
  109. Idx uint64
  110. NumExitRoot uint64
  111. InstantWithdraw bool
  112. TxHash ethCommon.Hash // Hash of the transaction that generated this event
  113. }
  114. type rollupEventUpdateBucketWithdrawAux struct {
  115. NumBucket uint8
  116. BlockStamp *big.Int
  117. Withdrawals *big.Int
  118. }
  119. // RollupEventUpdateBucketWithdraw is an event of the Rollup Smart Contract
  120. type RollupEventUpdateBucketWithdraw struct {
  121. NumBucket int
  122. BlockStamp int64 // blockNum
  123. Withdrawals *big.Int
  124. }
  125. // RollupEventUpdateWithdrawalDelay is an event of the Rollup Smart Contract
  126. type RollupEventUpdateWithdrawalDelay struct {
  127. NewWithdrawalDelay uint64
  128. }
  129. // RollupUpdateBucketsParameters are the bucket parameters used in an update
  130. type RollupUpdateBucketsParameters struct {
  131. CeilUSD *big.Int
  132. Withdrawals *big.Int
  133. BlockWithdrawalRate *big.Int
  134. MaxWithdrawals *big.Int
  135. }
  136. type rollupEventUpdateBucketsParametersAux struct {
  137. ArrayBuckets [common.RollupConstNumBuckets][4]*big.Int
  138. }
  139. // RollupEventUpdateBucketsParameters is an event of the Rollup Smart Contract
  140. type RollupEventUpdateBucketsParameters struct {
  141. // ArrayBuckets [common.RollupConstNumBuckets][4]*big.Int
  142. ArrayBuckets [common.RollupConstNumBuckets]RollupUpdateBucketsParameters
  143. SafeMode bool
  144. }
  145. // RollupEventUpdateTokenExchange is an event of the Rollup Smart Contract
  146. type RollupEventUpdateTokenExchange struct {
  147. AddressArray []ethCommon.Address
  148. ValueArray []uint64
  149. }
  150. // RollupEventSafeMode is an event of the Rollup Smart Contract
  151. type RollupEventSafeMode struct {
  152. }
  153. // RollupEvents is the list of events in a block of the Rollup Smart Contract
  154. type RollupEvents struct {
  155. L1UserTx []RollupEventL1UserTx
  156. AddToken []RollupEventAddToken
  157. ForgeBatch []RollupEventForgeBatch
  158. UpdateForgeL1L2BatchTimeout []RollupEventUpdateForgeL1L2BatchTimeout
  159. UpdateFeeAddToken []RollupEventUpdateFeeAddToken
  160. Withdraw []RollupEventWithdraw
  161. UpdateWithdrawalDelay []RollupEventUpdateWithdrawalDelay
  162. UpdateBucketWithdraw []RollupEventUpdateBucketWithdraw
  163. UpdateBucketsParameters []RollupEventUpdateBucketsParameters
  164. UpdateTokenExchange []RollupEventUpdateTokenExchange
  165. SafeMode []RollupEventSafeMode
  166. }
  167. // NewRollupEvents creates an empty RollupEvents with the slices initialized.
  168. func NewRollupEvents() RollupEvents {
  169. return RollupEvents{
  170. L1UserTx: make([]RollupEventL1UserTx, 0),
  171. AddToken: make([]RollupEventAddToken, 0),
  172. ForgeBatch: make([]RollupEventForgeBatch, 0),
  173. UpdateForgeL1L2BatchTimeout: make([]RollupEventUpdateForgeL1L2BatchTimeout, 0),
  174. UpdateFeeAddToken: make([]RollupEventUpdateFeeAddToken, 0),
  175. Withdraw: make([]RollupEventWithdraw, 0),
  176. }
  177. }
  178. // RollupForgeBatchArgs are the arguments to the ForgeBatch function in the Rollup Smart Contract
  179. type RollupForgeBatchArgs struct {
  180. NewLastIdx int64
  181. NewStRoot *big.Int
  182. NewExitRoot *big.Int
  183. L1UserTxs []common.L1Tx
  184. L1CoordinatorTxs []common.L1Tx
  185. L1CoordinatorTxsAuths [][]byte // Authorization for accountCreations for each L1CoordinatorTx
  186. L2TxsData []common.L2Tx
  187. FeeIdxCoordinator []common.Idx
  188. // Circuit selector
  189. VerifierIdx uint8
  190. L1Batch bool
  191. ProofA [2]*big.Int
  192. ProofB [2][2]*big.Int
  193. ProofC [2]*big.Int
  194. }
  195. // RollupForgeBatchArgsAux are the arguments to the ForgeBatch function in the Rollup Smart Contract
  196. type rollupForgeBatchArgsAux struct {
  197. NewLastIdx *big.Int
  198. NewStRoot *big.Int
  199. NewExitRoot *big.Int
  200. EncodedL1CoordinatorTx []byte
  201. L1L2TxsData []byte
  202. FeeIdxCoordinator []byte
  203. // Circuit selector
  204. VerifierIdx uint8
  205. L1Batch bool
  206. ProofA [2]*big.Int
  207. ProofB [2][2]*big.Int
  208. ProofC [2]*big.Int
  209. }
  210. // RollupInterface is the inteface to to Rollup Smart Contract
  211. type RollupInterface interface {
  212. //
  213. // Smart Contract Methods
  214. //
  215. // Public Functions
  216. RollupForgeBatch(*RollupForgeBatchArgs) (*types.Transaction, error)
  217. RollupAddToken(tokenAddress ethCommon.Address, feeAddToken, deadline *big.Int) (*types.Transaction, error)
  218. RollupWithdrawMerkleProof(babyPubKey babyjub.PublicKeyComp, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (*types.Transaction, error)
  219. RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error)
  220. RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (*types.Transaction, error)
  221. RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error)
  222. // Governance Public Functions
  223. RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (*types.Transaction, error)
  224. RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (*types.Transaction, error)
  225. // Viewers
  226. RollupRegisterTokensCount() (*big.Int, error)
  227. RollupLastForgedBatch() (int64, error)
  228. //
  229. // Smart Contract Status
  230. //
  231. RollupConstants() (*common.RollupConstants, error)
  232. RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error)
  233. RollupForgeBatchArgs(ethCommon.Hash, uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error)
  234. RollupEventInit() (*RollupEventInitialize, int64, error)
  235. }
  236. //
  237. // Implementation
  238. //
  239. // RollupClient is the implementation of the interface to the Rollup Smart Contract in ethereum.
  240. type RollupClient struct {
  241. client *EthereumClient
  242. chainID *big.Int
  243. address ethCommon.Address
  244. tokenHEZCfg TokenConfig
  245. hermez *Hermez.Hermez
  246. tokenHEZ *HEZ.HEZ
  247. contractAbi abi.ABI
  248. opts *bind.CallOpts
  249. }
  250. // NewRollupClient creates a new RollupClient
  251. func NewRollupClient(client *EthereumClient, address ethCommon.Address, tokenHEZCfg TokenConfig) (*RollupClient, error) {
  252. contractAbi, err := abi.JSON(strings.NewReader(string(Hermez.HermezABI)))
  253. if err != nil {
  254. return nil, tracerr.Wrap(err)
  255. }
  256. hermez, err := Hermez.NewHermez(address, client.Client())
  257. if err != nil {
  258. return nil, tracerr.Wrap(err)
  259. }
  260. tokenHEZ, err := HEZ.NewHEZ(tokenHEZCfg.Address, client.Client())
  261. if err != nil {
  262. return nil, tracerr.Wrap(err)
  263. }
  264. chainID, err := client.client.ChainID(context.Background())
  265. if err != nil {
  266. return nil, tracerr.Wrap(err)
  267. }
  268. return &RollupClient{
  269. client: client,
  270. chainID: chainID,
  271. address: address,
  272. tokenHEZCfg: tokenHEZCfg,
  273. hermez: hermez,
  274. tokenHEZ: tokenHEZ,
  275. contractAbi: contractAbi,
  276. opts: newCallOpts(),
  277. }, nil
  278. }
  279. // RollupForgeBatch is the interface to call the smart contract function
  280. func (c *RollupClient) RollupForgeBatch(args *RollupForgeBatchArgs) (tx *types.Transaction, err error) {
  281. if tx, err = c.client.CallAuth(
  282. 1000000, //nolint:gomnd
  283. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  284. rollupConst, err := c.RollupConstants()
  285. if err != nil {
  286. return nil, tracerr.Wrap(err)
  287. }
  288. nLevels := rollupConst.Verifiers[args.VerifierIdx].NLevels
  289. lenBytes := nLevels / 8 //nolint:gomnd
  290. newLastIdx := big.NewInt(int64(args.NewLastIdx))
  291. // L1CoordinatorBytes
  292. var l1CoordinatorBytes []byte
  293. for i := 0; i < len(args.L1CoordinatorTxs); i++ {
  294. l1 := args.L1CoordinatorTxs[i]
  295. bytesl1, err := l1.BytesCoordinatorTx(args.L1CoordinatorTxsAuths[i])
  296. if err != nil {
  297. return nil, tracerr.Wrap(err)
  298. }
  299. l1CoordinatorBytes = append(l1CoordinatorBytes, bytesl1[:]...)
  300. }
  301. // L1L2TxData
  302. var l1l2TxData []byte
  303. for i := 0; i < len(args.L1UserTxs); i++ {
  304. l1User := args.L1UserTxs[i]
  305. bytesl1User, err := l1User.BytesDataAvailability(uint32(nLevels))
  306. if err != nil {
  307. return nil, tracerr.Wrap(err)
  308. }
  309. l1l2TxData = append(l1l2TxData, bytesl1User[:]...)
  310. }
  311. for i := 0; i < len(args.L1CoordinatorTxs); i++ {
  312. l1Coord := args.L1CoordinatorTxs[i]
  313. bytesl1Coord, err := l1Coord.BytesDataAvailability(uint32(nLevels))
  314. if err != nil {
  315. return nil, tracerr.Wrap(err)
  316. }
  317. l1l2TxData = append(l1l2TxData, bytesl1Coord[:]...)
  318. }
  319. for i := 0; i < len(args.L2TxsData); i++ {
  320. l2 := args.L2TxsData[i]
  321. bytesl2, err := l2.BytesDataAvailability(uint32(nLevels))
  322. if err != nil {
  323. return nil, tracerr.Wrap(err)
  324. }
  325. l1l2TxData = append(l1l2TxData, bytesl2[:]...)
  326. }
  327. // FeeIdxCoordinator
  328. var feeIdxCoordinator []byte
  329. if len(args.FeeIdxCoordinator) > common.RollupConstMaxFeeIdxCoordinator {
  330. return nil, tracerr.Wrap(fmt.Errorf("len(args.FeeIdxCoordinator) > %v",
  331. common.RollupConstMaxFeeIdxCoordinator))
  332. }
  333. for i := 0; i < common.RollupConstMaxFeeIdxCoordinator; i++ {
  334. feeIdx := common.Idx(0)
  335. if i < len(args.FeeIdxCoordinator) {
  336. feeIdx = args.FeeIdxCoordinator[i]
  337. }
  338. bytesFeeIdx, err := feeIdx.Bytes()
  339. if err != nil {
  340. return nil, tracerr.Wrap(err)
  341. }
  342. feeIdxCoordinator = append(feeIdxCoordinator, bytesFeeIdx[len(bytesFeeIdx)-int(lenBytes):]...)
  343. }
  344. return c.hermez.ForgeBatch(auth, newLastIdx, args.NewStRoot, args.NewExitRoot, l1CoordinatorBytes, l1l2TxData, feeIdxCoordinator, args.VerifierIdx, args.L1Batch, args.ProofA, args.ProofB, args.ProofC)
  345. },
  346. ); err != nil {
  347. return nil, tracerr.Wrap(fmt.Errorf("Failed forge batch: %w", err))
  348. }
  349. return tx, nil
  350. }
  351. // RollupAddToken is the interface to call the smart contract function.
  352. // `feeAddToken` is the amount of HEZ tokens that will be paid to add the
  353. // token. `feeAddToken` must match the public value of the smart contract.
  354. func (c *RollupClient) RollupAddToken(tokenAddress ethCommon.Address, feeAddToken, deadline *big.Int) (tx *types.Transaction, err error) {
  355. if tx, err = c.client.CallAuth(
  356. 0,
  357. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  358. owner := c.client.account.Address
  359. spender := c.address
  360. nonce, err := c.tokenHEZ.Nonces(c.opts, owner)
  361. if err != nil {
  362. return nil, tracerr.Wrap(err)
  363. }
  364. tokenName := c.tokenHEZCfg.Name
  365. tokenAddr := c.tokenHEZCfg.Address
  366. digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, feeAddToken, nonce, deadline, tokenName)
  367. signature, _ := c.client.ks.SignHash(*c.client.account, digest)
  368. permit := createPermit(owner, spender, feeAddToken, deadline, digest, signature)
  369. return c.hermez.AddToken(auth, tokenAddress, permit)
  370. },
  371. ); err != nil {
  372. return nil, tracerr.Wrap(fmt.Errorf("Failed add Token %w", err))
  373. }
  374. return tx, nil
  375. }
  376. // RollupWithdrawMerkleProof is the interface to call the smart contract function
  377. func (c *RollupClient) RollupWithdrawMerkleProof(fromBJJ babyjub.PublicKeyComp, tokenID uint32, numExitRoot, idx int64, amount *big.Int, siblings []*big.Int, instantWithdraw bool) (tx *types.Transaction, err error) {
  378. if tx, err = c.client.CallAuth(
  379. 0,
  380. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  381. pkCompB := common.SwapEndianness(fromBJJ[:])
  382. babyPubKey := new(big.Int).SetBytes(pkCompB)
  383. numExitRootB := uint32(numExitRoot)
  384. idxBig := big.NewInt(idx)
  385. return c.hermez.WithdrawMerkleProof(auth, tokenID, amount, babyPubKey, numExitRootB, siblings, idxBig, instantWithdraw)
  386. },
  387. ); err != nil {
  388. return nil, tracerr.Wrap(fmt.Errorf("Failed update WithdrawMerkleProof: %w", err))
  389. }
  390. return tx, nil
  391. }
  392. // RollupWithdrawCircuit is the interface to call the smart contract function
  393. func (c *RollupClient) RollupWithdrawCircuit(proofA, proofC [2]*big.Int, proofB [2][2]*big.Int, tokenID uint32, numExitRoot, idx int64, amount *big.Int, instantWithdraw bool) (*types.Transaction, error) {
  394. log.Error("TODO")
  395. return nil, tracerr.Wrap(errTODO)
  396. }
  397. // RollupL1UserTxERC20ETH is the interface to call the smart contract function
  398. func (c *RollupClient) RollupL1UserTxERC20ETH(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64) (tx *types.Transaction, err error) {
  399. if tx, err = c.client.CallAuth(
  400. 0,
  401. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  402. var babyPubKey *big.Int
  403. if fromBJJ != common.EmptyBJJComp {
  404. pkCompB := common.SwapEndianness(fromBJJ[:])
  405. babyPubKey = new(big.Int).SetBytes(pkCompB)
  406. } else {
  407. babyPubKey = big.NewInt(0)
  408. }
  409. fromIdxBig := big.NewInt(fromIdx)
  410. toIdxBig := big.NewInt(toIdx)
  411. depositAmountF, err := common.NewFloat16(depositAmount)
  412. if err != nil {
  413. return nil, tracerr.Wrap(err)
  414. }
  415. amountF, err := common.NewFloat16(amount)
  416. if err != nil {
  417. return nil, tracerr.Wrap(err)
  418. }
  419. if tokenID == 0 {
  420. auth.Value = depositAmount
  421. }
  422. var permit []byte
  423. return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(depositAmountF),
  424. uint16(amountF), tokenID, toIdxBig, permit)
  425. },
  426. ); err != nil {
  427. return nil, tracerr.Wrap(fmt.Errorf("Failed add L1 Tx ERC20/ETH: %w", err))
  428. }
  429. return tx, nil
  430. }
  431. // RollupL1UserTxERC20Permit is the interface to call the smart contract function
  432. func (c *RollupClient) RollupL1UserTxERC20Permit(fromBJJ babyjub.PublicKeyComp, fromIdx int64, depositAmount *big.Int, amount *big.Int, tokenID uint32, toIdx int64, deadline *big.Int) (tx *types.Transaction, err error) {
  433. if tx, err = c.client.CallAuth(
  434. 0,
  435. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  436. var babyPubKey *big.Int
  437. if fromBJJ != common.EmptyBJJComp {
  438. pkCompB := common.SwapEndianness(fromBJJ[:])
  439. babyPubKey = new(big.Int).SetBytes(pkCompB)
  440. } else {
  441. babyPubKey = big.NewInt(0)
  442. }
  443. fromIdxBig := big.NewInt(fromIdx)
  444. toIdxBig := big.NewInt(toIdx)
  445. depositAmountF, err := common.NewFloat16(depositAmount)
  446. if err != nil {
  447. return nil, tracerr.Wrap(err)
  448. }
  449. amountF, err := common.NewFloat16(amount)
  450. if err != nil {
  451. return nil, tracerr.Wrap(err)
  452. }
  453. if tokenID == 0 {
  454. auth.Value = depositAmount
  455. }
  456. owner := c.client.account.Address
  457. spender := c.address
  458. nonce, err := c.tokenHEZ.Nonces(c.opts, owner)
  459. if err != nil {
  460. return nil, tracerr.Wrap(err)
  461. }
  462. tokenName := c.tokenHEZCfg.Name
  463. tokenAddr := c.tokenHEZCfg.Address
  464. digest, _ := createPermitDigest(tokenAddr, owner, spender, c.chainID, amount, nonce, deadline, tokenName)
  465. signature, _ := c.client.ks.SignHash(*c.client.account, digest)
  466. permit := createPermit(owner, spender, amount, deadline, digest, signature)
  467. return c.hermez.AddL1Transaction(auth, babyPubKey, fromIdxBig, uint16(depositAmountF),
  468. uint16(amountF), tokenID, toIdxBig, permit)
  469. },
  470. ); err != nil {
  471. return nil, tracerr.Wrap(fmt.Errorf("Failed add L1 Tx ERC20Permit: %w", err))
  472. }
  473. return tx, nil
  474. }
  475. // RollupRegisterTokensCount is the interface to call the smart contract function
  476. func (c *RollupClient) RollupRegisterTokensCount() (registerTokensCount *big.Int, err error) {
  477. if err := c.client.Call(func(ec *ethclient.Client) error {
  478. registerTokensCount, err = c.hermez.RegisterTokensCount(c.opts)
  479. return tracerr.Wrap(err)
  480. }); err != nil {
  481. return nil, tracerr.Wrap(err)
  482. }
  483. return registerTokensCount, nil
  484. }
  485. // RollupLastForgedBatch is the interface to call the smart contract function
  486. func (c *RollupClient) RollupLastForgedBatch() (lastForgedBatch int64, err error) {
  487. if err := c.client.Call(func(ec *ethclient.Client) error {
  488. _lastForgedBatch, err := c.hermez.LastForgedBatch(c.opts)
  489. lastForgedBatch = int64(_lastForgedBatch)
  490. return tracerr.Wrap(err)
  491. }); err != nil {
  492. return 0, tracerr.Wrap(err)
  493. }
  494. return lastForgedBatch, nil
  495. }
  496. // RollupUpdateForgeL1L2BatchTimeout is the interface to call the smart contract function
  497. func (c *RollupClient) RollupUpdateForgeL1L2BatchTimeout(newForgeL1L2BatchTimeout int64) (tx *types.Transaction, err error) {
  498. if tx, err = c.client.CallAuth(
  499. 0,
  500. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  501. return c.hermez.UpdateForgeL1L2BatchTimeout(auth, uint8(newForgeL1L2BatchTimeout))
  502. },
  503. ); err != nil {
  504. return nil, tracerr.Wrap(fmt.Errorf("Failed update ForgeL1L2BatchTimeout: %w", err))
  505. }
  506. return tx, nil
  507. }
  508. // RollupUpdateFeeAddToken is the interface to call the smart contract function
  509. func (c *RollupClient) RollupUpdateFeeAddToken(newFeeAddToken *big.Int) (tx *types.Transaction, err error) {
  510. if tx, err = c.client.CallAuth(
  511. 0,
  512. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  513. return c.hermez.UpdateFeeAddToken(auth, newFeeAddToken)
  514. },
  515. ); err != nil {
  516. return nil, tracerr.Wrap(fmt.Errorf("Failed update FeeAddToken: %w", err))
  517. }
  518. return tx, nil
  519. }
  520. // RollupUpdateBucketsParameters is the interface to call the smart contract function
  521. func (c *RollupClient) RollupUpdateBucketsParameters(
  522. arrayBuckets [common.RollupConstNumBuckets]RollupUpdateBucketsParameters,
  523. ) (tx *types.Transaction, err error) {
  524. params := [common.RollupConstNumBuckets][4]*big.Int{}
  525. for i, bucket := range arrayBuckets {
  526. params[i][0] = bucket.CeilUSD
  527. params[i][1] = bucket.Withdrawals
  528. params[i][2] = bucket.BlockWithdrawalRate
  529. params[i][3] = bucket.MaxWithdrawals
  530. }
  531. if tx, err = c.client.CallAuth(
  532. 12500000, //nolint:gomnd
  533. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  534. return c.hermez.UpdateBucketsParameters(auth, params)
  535. },
  536. ); err != nil {
  537. return nil, tracerr.Wrap(fmt.Errorf("Failed update Buckets Parameters: %w", err))
  538. }
  539. return tx, nil
  540. }
  541. // RollupUpdateTokenExchange is the interface to call the smart contract function
  542. func (c *RollupClient) RollupUpdateTokenExchange(addressArray []ethCommon.Address, valueArray []uint64) (tx *types.Transaction, err error) {
  543. if tx, err = c.client.CallAuth(
  544. 0,
  545. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  546. return c.hermez.UpdateTokenExchange(auth, addressArray, valueArray)
  547. },
  548. ); err != nil {
  549. return nil, tracerr.Wrap(fmt.Errorf("Failed update Token Exchange: %w", err))
  550. }
  551. return tx, nil
  552. }
  553. // RollupUpdateWithdrawalDelay is the interface to call the smart contract function
  554. func (c *RollupClient) RollupUpdateWithdrawalDelay(newWithdrawalDelay int64) (tx *types.Transaction, err error) {
  555. if tx, err = c.client.CallAuth(
  556. 0,
  557. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  558. return c.hermez.UpdateWithdrawalDelay(auth, uint64(newWithdrawalDelay))
  559. },
  560. ); err != nil {
  561. return nil, tracerr.Wrap(fmt.Errorf("Failed update WithdrawalDelay: %w", err))
  562. }
  563. return tx, nil
  564. }
  565. // RollupSafeMode is the interface to call the smart contract function
  566. func (c *RollupClient) RollupSafeMode() (tx *types.Transaction, err error) {
  567. if tx, err = c.client.CallAuth(
  568. 0,
  569. func(ec *ethclient.Client, auth *bind.TransactOpts) (*types.Transaction, error) {
  570. return c.hermez.SafeMode(auth)
  571. },
  572. ); err != nil {
  573. return nil, tracerr.Wrap(fmt.Errorf("Failed update Safe Mode: %w", err))
  574. }
  575. return tx, nil
  576. }
  577. // RollupInstantWithdrawalViewer is the interface to call the smart contract function
  578. func (c *RollupClient) RollupInstantWithdrawalViewer(tokenAddress ethCommon.Address, amount *big.Int) (instantAllowed bool, err error) {
  579. if err := c.client.Call(func(ec *ethclient.Client) error {
  580. instantAllowed, err = c.hermez.InstantWithdrawalViewer(c.opts, tokenAddress, amount)
  581. return tracerr.Wrap(err)
  582. }); err != nil {
  583. return false, tracerr.Wrap(err)
  584. }
  585. return instantAllowed, nil
  586. }
  587. // RollupConstants returns the Constants of the Rollup Smart Contract
  588. func (c *RollupClient) RollupConstants() (rollupConstants *common.RollupConstants, err error) {
  589. rollupConstants = new(common.RollupConstants)
  590. if err := c.client.Call(func(ec *ethclient.Client) error {
  591. absoluteMaxL1L2BatchTimeout, err := c.hermez.ABSOLUTEMAXL1L2BATCHTIMEOUT(c.opts)
  592. if err != nil {
  593. return tracerr.Wrap(err)
  594. }
  595. rollupConstants.AbsoluteMaxL1L2BatchTimeout = int64(absoluteMaxL1L2BatchTimeout)
  596. rollupConstants.TokenHEZ, err = c.hermez.TokenHEZ(c.opts)
  597. if err != nil {
  598. return tracerr.Wrap(err)
  599. }
  600. for i := int64(0); i < int64(common.LenVerifiers); i++ {
  601. var newRollupVerifier common.RollupVerifierStruct
  602. rollupVerifier, err := c.hermez.RollupVerifiers(c.opts, big.NewInt(i))
  603. if err != nil {
  604. return tracerr.Wrap(err)
  605. }
  606. newRollupVerifier.MaxTx = rollupVerifier.MaxTx.Int64()
  607. newRollupVerifier.NLevels = rollupVerifier.NLevels.Int64()
  608. rollupConstants.Verifiers = append(rollupConstants.Verifiers, newRollupVerifier)
  609. }
  610. rollupConstants.HermezAuctionContract, err = c.hermez.HermezAuctionContract(c.opts)
  611. if err != nil {
  612. return tracerr.Wrap(err)
  613. }
  614. rollupConstants.HermezGovernanceAddress, err = c.hermez.HermezGovernanceAddress(c.opts)
  615. if err != nil {
  616. return tracerr.Wrap(err)
  617. }
  618. rollupConstants.WithdrawDelayerContract, err = c.hermez.WithdrawDelayerContract(c.opts)
  619. return tracerr.Wrap(err)
  620. }); err != nil {
  621. return nil, tracerr.Wrap(err)
  622. }
  623. return rollupConstants, nil
  624. }
  625. var (
  626. logHermezL1UserTxEvent = crypto.Keccak256Hash([]byte("L1UserTxEvent(uint32,uint8,bytes)"))
  627. logHermezAddToken = crypto.Keccak256Hash([]byte("AddToken(address,uint32)"))
  628. logHermezForgeBatch = crypto.Keccak256Hash([]byte("ForgeBatch(uint32,uint16)"))
  629. logHermezUpdateForgeL1L2BatchTimeout = crypto.Keccak256Hash([]byte("UpdateForgeL1L2BatchTimeout(uint8)"))
  630. logHermezUpdateFeeAddToken = crypto.Keccak256Hash([]byte("UpdateFeeAddToken(uint256)"))
  631. logHermezWithdrawEvent = crypto.Keccak256Hash([]byte("WithdrawEvent(uint48,uint32,bool)"))
  632. logHermezUpdateBucketWithdraw = crypto.Keccak256Hash([]byte("UpdateBucketWithdraw(uint8,uint256,uint256)"))
  633. logHermezUpdateWithdrawalDelay = crypto.Keccak256Hash([]byte("UpdateWithdrawalDelay(uint64)"))
  634. logHermezUpdateBucketsParameters = crypto.Keccak256Hash([]byte("UpdateBucketsParameters(uint256[4][" +
  635. strconv.Itoa(common.RollupConstNumBuckets) + "])"))
  636. logHermezUpdateTokenExchange = crypto.Keccak256Hash([]byte("UpdateTokenExchange(address[],uint64[])"))
  637. logHermezSafeMode = crypto.Keccak256Hash([]byte("SafeMode()"))
  638. logHermezInitialize = crypto.Keccak256Hash([]byte("InitializeHermezEvent(uint8,uint256,uint64)"))
  639. )
  640. // RollupEventInit returns the initialize event with its corresponding block number
  641. func (c *RollupClient) RollupEventInit() (*RollupEventInitialize, int64, error) {
  642. query := ethereum.FilterQuery{
  643. Addresses: []ethCommon.Address{
  644. c.address,
  645. },
  646. Topics: [][]ethCommon.Hash{{logHermezInitialize}},
  647. }
  648. logs, err := c.client.client.FilterLogs(context.Background(), query)
  649. if err != nil {
  650. return nil, 0, tracerr.Wrap(err)
  651. }
  652. if len(logs) != 1 {
  653. return nil, 0, tracerr.Wrap(fmt.Errorf("no event of type InitializeHermezEvent found"))
  654. }
  655. vLog := logs[0]
  656. if vLog.Topics[0] != logHermezInitialize {
  657. return nil, 0, tracerr.Wrap(fmt.Errorf("event is not InitializeHermezEvent"))
  658. }
  659. var rollupInit RollupEventInitialize
  660. if err := c.contractAbi.UnpackIntoInterface(&rollupInit, "InitializeHermezEvent", vLog.Data); err != nil {
  661. return nil, 0, tracerr.Wrap(err)
  662. }
  663. return &rollupInit, int64(vLog.BlockNumber), tracerr.Wrap(err)
  664. }
  665. // RollupEventsByBlock returns the events in a block that happened in the Rollup Smart Contract
  666. func (c *RollupClient) RollupEventsByBlock(blockNum int64) (*RollupEvents, *ethCommon.Hash, error) {
  667. var rollupEvents RollupEvents
  668. var blockHash *ethCommon.Hash
  669. query := ethereum.FilterQuery{
  670. FromBlock: big.NewInt(blockNum),
  671. ToBlock: big.NewInt(blockNum),
  672. Addresses: []ethCommon.Address{
  673. c.address,
  674. },
  675. BlockHash: nil,
  676. Topics: [][]ethCommon.Hash{},
  677. }
  678. logs, err := c.client.client.FilterLogs(context.Background(), query)
  679. if err != nil {
  680. return nil, nil, tracerr.Wrap(err)
  681. }
  682. if len(logs) > 0 {
  683. blockHash = &logs[0].BlockHash
  684. }
  685. for _, vLog := range logs {
  686. if vLog.BlockHash != *blockHash {
  687. log.Errorw("Block hash mismatch", "expected", blockHash.String(), "got", vLog.BlockHash.String())
  688. return nil, nil, tracerr.Wrap(ErrBlockHashMismatchEvent)
  689. }
  690. switch vLog.Topics[0] {
  691. case logHermezL1UserTxEvent:
  692. var L1UserTxAux rollupEventL1UserTxAux
  693. var L1UserTx RollupEventL1UserTx
  694. err := c.contractAbi.UnpackIntoInterface(&L1UserTxAux, "L1UserTxEvent", vLog.Data)
  695. if err != nil {
  696. return nil, nil, tracerr.Wrap(err)
  697. }
  698. L1Tx, err := common.L1UserTxFromBytes(L1UserTxAux.L1UserTx)
  699. if err != nil {
  700. return nil, nil, tracerr.Wrap(err)
  701. }
  702. toForgeL1TxsNum := new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
  703. L1Tx.ToForgeL1TxsNum = &toForgeL1TxsNum
  704. L1Tx.Position = int(new(big.Int).SetBytes(vLog.Topics[2][:]).Int64())
  705. L1Tx.UserOrigin = true
  706. L1UserTx.L1UserTx = *L1Tx
  707. rollupEvents.L1UserTx = append(rollupEvents.L1UserTx, L1UserTx)
  708. case logHermezAddToken:
  709. var addToken RollupEventAddToken
  710. err := c.contractAbi.UnpackIntoInterface(&addToken, "AddToken", vLog.Data)
  711. if err != nil {
  712. return nil, nil, tracerr.Wrap(err)
  713. }
  714. addToken.TokenAddress = ethCommon.BytesToAddress(vLog.Topics[1].Bytes())
  715. rollupEvents.AddToken = append(rollupEvents.AddToken, addToken)
  716. case logHermezForgeBatch:
  717. var forgeBatch RollupEventForgeBatch
  718. err := c.contractAbi.UnpackIntoInterface(&forgeBatch, "ForgeBatch", vLog.Data)
  719. if err != nil {
  720. return nil, nil, tracerr.Wrap(err)
  721. }
  722. forgeBatch.BatchNum = new(big.Int).SetBytes(vLog.Topics[1][:]).Int64()
  723. forgeBatch.EthTxHash = vLog.TxHash
  724. // forgeBatch.Sender = vLog.Address
  725. rollupEvents.ForgeBatch = append(rollupEvents.ForgeBatch, forgeBatch)
  726. case logHermezUpdateForgeL1L2BatchTimeout:
  727. var updateForgeL1L2BatchTimeout struct {
  728. NewForgeL1L2BatchTimeout uint8
  729. }
  730. err := c.contractAbi.UnpackIntoInterface(&updateForgeL1L2BatchTimeout, "UpdateForgeL1L2BatchTimeout", vLog.Data)
  731. if err != nil {
  732. return nil, nil, tracerr.Wrap(err)
  733. }
  734. rollupEvents.UpdateForgeL1L2BatchTimeout = append(rollupEvents.UpdateForgeL1L2BatchTimeout,
  735. RollupEventUpdateForgeL1L2BatchTimeout{
  736. NewForgeL1L2BatchTimeout: int64(updateForgeL1L2BatchTimeout.NewForgeL1L2BatchTimeout),
  737. })
  738. case logHermezUpdateFeeAddToken:
  739. var updateFeeAddToken RollupEventUpdateFeeAddToken
  740. err := c.contractAbi.UnpackIntoInterface(&updateFeeAddToken, "UpdateFeeAddToken", vLog.Data)
  741. if err != nil {
  742. return nil, nil, tracerr.Wrap(err)
  743. }
  744. rollupEvents.UpdateFeeAddToken = append(rollupEvents.UpdateFeeAddToken, updateFeeAddToken)
  745. case logHermezWithdrawEvent:
  746. var withdraw RollupEventWithdraw
  747. withdraw.Idx = new(big.Int).SetBytes(vLog.Topics[1][:]).Uint64()
  748. withdraw.NumExitRoot = new(big.Int).SetBytes(vLog.Topics[2][:]).Uint64()
  749. instantWithdraw := new(big.Int).SetBytes(vLog.Topics[3][:]).Uint64()
  750. if instantWithdraw == 1 {
  751. withdraw.InstantWithdraw = true
  752. }
  753. withdraw.TxHash = vLog.TxHash
  754. rollupEvents.Withdraw = append(rollupEvents.Withdraw, withdraw)
  755. case logHermezUpdateBucketWithdraw:
  756. var updateBucketWithdrawAux rollupEventUpdateBucketWithdrawAux
  757. var updateBucketWithdraw RollupEventUpdateBucketWithdraw
  758. err := c.contractAbi.UnpackIntoInterface(&updateBucketWithdrawAux, "UpdateBucketWithdraw", vLog.Data)
  759. if err != nil {
  760. return nil, nil, tracerr.Wrap(err)
  761. }
  762. updateBucketWithdraw.Withdrawals = updateBucketWithdrawAux.Withdrawals
  763. updateBucketWithdraw.NumBucket = int(new(big.Int).SetBytes(vLog.Topics[1][:]).Int64())
  764. updateBucketWithdraw.BlockStamp = new(big.Int).SetBytes(vLog.Topics[2][:]).Int64()
  765. rollupEvents.UpdateBucketWithdraw = append(rollupEvents.UpdateBucketWithdraw, updateBucketWithdraw)
  766. case logHermezUpdateWithdrawalDelay:
  767. var withdrawalDelay RollupEventUpdateWithdrawalDelay
  768. err := c.contractAbi.UnpackIntoInterface(&withdrawalDelay, "UpdateWithdrawalDelay", vLog.Data)
  769. if err != nil {
  770. return nil, nil, tracerr.Wrap(err)
  771. }
  772. rollupEvents.UpdateWithdrawalDelay = append(rollupEvents.UpdateWithdrawalDelay, withdrawalDelay)
  773. case logHermezUpdateBucketsParameters:
  774. var bucketsParametersAux rollupEventUpdateBucketsParametersAux
  775. var bucketsParameters RollupEventUpdateBucketsParameters
  776. err := c.contractAbi.UnpackIntoInterface(&bucketsParametersAux, "UpdateBucketsParameters", vLog.Data)
  777. if err != nil {
  778. return nil, nil, tracerr.Wrap(err)
  779. }
  780. for i, bucket := range bucketsParametersAux.ArrayBuckets {
  781. bucketsParameters.ArrayBuckets[i].CeilUSD = bucket[0]
  782. bucketsParameters.ArrayBuckets[i].Withdrawals = bucket[1]
  783. bucketsParameters.ArrayBuckets[i].BlockWithdrawalRate = bucket[2]
  784. bucketsParameters.ArrayBuckets[i].MaxWithdrawals = bucket[3]
  785. }
  786. rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters, bucketsParameters)
  787. case logHermezUpdateTokenExchange:
  788. var tokensExchange RollupEventUpdateTokenExchange
  789. err := c.contractAbi.UnpackIntoInterface(&tokensExchange, "UpdateTokenExchange", vLog.Data)
  790. if err != nil {
  791. return nil, nil, tracerr.Wrap(err)
  792. }
  793. rollupEvents.UpdateTokenExchange = append(rollupEvents.UpdateTokenExchange, tokensExchange)
  794. case logHermezSafeMode:
  795. var safeMode RollupEventSafeMode
  796. rollupEvents.SafeMode = append(rollupEvents.SafeMode, safeMode)
  797. // Also add an UpdateBucketsParameter with
  798. // SafeMode=true to keep the order between `safeMode`
  799. // and `UpdateBucketsParameters`
  800. bucketsParameters := RollupEventUpdateBucketsParameters{
  801. SafeMode: true,
  802. }
  803. for i := range bucketsParameters.ArrayBuckets {
  804. bucketsParameters.ArrayBuckets[i].CeilUSD = big.NewInt(0)
  805. bucketsParameters.ArrayBuckets[i].Withdrawals = big.NewInt(0)
  806. bucketsParameters.ArrayBuckets[i].BlockWithdrawalRate = big.NewInt(0)
  807. bucketsParameters.ArrayBuckets[i].MaxWithdrawals = big.NewInt(0)
  808. }
  809. rollupEvents.UpdateBucketsParameters = append(rollupEvents.UpdateBucketsParameters,
  810. bucketsParameters)
  811. }
  812. }
  813. return &rollupEvents, blockHash, nil
  814. }
  815. // RollupForgeBatchArgs returns the arguments used in a ForgeBatch call in the
  816. // Rollup Smart Contract in the given transaction, and the sender address.
  817. func (c *RollupClient) RollupForgeBatchArgs(ethTxHash ethCommon.Hash, l1UserTxsLen uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error) {
  818. tx, _, err := c.client.client.TransactionByHash(context.Background(), ethTxHash)
  819. if err != nil {
  820. return nil, nil, tracerr.Wrap(err)
  821. }
  822. txData := tx.Data()
  823. method, err := c.contractAbi.MethodById(txData[:4])
  824. if err != nil {
  825. return nil, nil, tracerr.Wrap(err)
  826. }
  827. receipt, err := c.client.client.TransactionReceipt(context.Background(), ethTxHash)
  828. if err != nil {
  829. return nil, nil, tracerr.Wrap(err)
  830. }
  831. sender, err := c.client.client.TransactionSender(context.Background(), tx, receipt.Logs[0].BlockHash, receipt.Logs[0].Index)
  832. if err != nil {
  833. return nil, nil, tracerr.Wrap(err)
  834. }
  835. var aux rollupForgeBatchArgsAux
  836. if values, err := method.Inputs.Unpack(txData[4:]); err != nil {
  837. return nil, nil, tracerr.Wrap(err)
  838. } else if err := method.Inputs.Copy(&aux, values); err != nil {
  839. return nil, nil, tracerr.Wrap(err)
  840. }
  841. rollupForgeBatchArgs := RollupForgeBatchArgs{
  842. L1Batch: aux.L1Batch,
  843. NewExitRoot: aux.NewExitRoot,
  844. NewLastIdx: aux.NewLastIdx.Int64(),
  845. NewStRoot: aux.NewStRoot,
  846. ProofA: aux.ProofA,
  847. ProofB: aux.ProofB,
  848. ProofC: aux.ProofC,
  849. VerifierIdx: aux.VerifierIdx,
  850. L1CoordinatorTxs: []common.L1Tx{},
  851. L1CoordinatorTxsAuths: [][]byte{},
  852. L2TxsData: []common.L2Tx{},
  853. FeeIdxCoordinator: []common.Idx{},
  854. }
  855. rollupConsts, err := c.RollupConstants()
  856. if err != nil {
  857. return nil, nil, tracerr.Wrap(err)
  858. }
  859. nLevels := rollupConsts.Verifiers[rollupForgeBatchArgs.VerifierIdx].NLevels
  860. lenL1L2TxsBytes := int((nLevels/8)*2 + 2 + 1)
  861. numBytesL1TxUser := int(l1UserTxsLen) * lenL1L2TxsBytes
  862. numTxsL1Coord := len(aux.EncodedL1CoordinatorTx) / common.L1CoordinatorTxBytesLen
  863. numBytesL1TxCoord := numTxsL1Coord * lenL1L2TxsBytes
  864. numBeginL2Tx := numBytesL1TxCoord + numBytesL1TxUser
  865. l1UserTxsData := []byte{}
  866. if l1UserTxsLen > 0 {
  867. l1UserTxsData = aux.L1L2TxsData[:numBytesL1TxUser]
  868. }
  869. for i := 0; i < int(l1UserTxsLen); i++ {
  870. l1Tx, err := common.L1TxFromDataAvailability(l1UserTxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes], uint32(nLevels))
  871. if err != nil {
  872. return nil, nil, tracerr.Wrap(err)
  873. }
  874. rollupForgeBatchArgs.L1UserTxs = append(rollupForgeBatchArgs.L1UserTxs, *l1Tx)
  875. }
  876. l2TxsData := []byte{}
  877. if numBeginL2Tx < len(aux.L1L2TxsData) {
  878. l2TxsData = aux.L1L2TxsData[numBeginL2Tx:]
  879. }
  880. numTxsL2 := len(l2TxsData) / lenL1L2TxsBytes
  881. for i := 0; i < numTxsL2; i++ {
  882. l2Tx, err := common.L2TxFromBytesDataAvailability(l2TxsData[i*lenL1L2TxsBytes:(i+1)*lenL1L2TxsBytes], int(nLevels))
  883. if err != nil {
  884. return nil, nil, tracerr.Wrap(err)
  885. }
  886. rollupForgeBatchArgs.L2TxsData = append(rollupForgeBatchArgs.L2TxsData, *l2Tx)
  887. }
  888. for i := 0; i < numTxsL1Coord; i++ {
  889. bytesL1Coordinator := aux.EncodedL1CoordinatorTx[i*common.L1CoordinatorTxBytesLen : (i+1)*common.L1CoordinatorTxBytesLen]
  890. var signature []byte
  891. v := bytesL1Coordinator[0]
  892. s := bytesL1Coordinator[1:33]
  893. r := bytesL1Coordinator[33:65]
  894. signature = append(signature, r[:]...)
  895. signature = append(signature, s[:]...)
  896. signature = append(signature, v)
  897. l1Tx, err := common.L1CoordinatorTxFromBytes(bytesL1Coordinator, c.chainID, c.address)
  898. if err != nil {
  899. return nil, nil, tracerr.Wrap(err)
  900. }
  901. rollupForgeBatchArgs.L1CoordinatorTxs = append(rollupForgeBatchArgs.L1CoordinatorTxs, *l1Tx)
  902. rollupForgeBatchArgs.L1CoordinatorTxsAuths = append(rollupForgeBatchArgs.L1CoordinatorTxsAuths, signature)
  903. }
  904. lenFeeIdxCoordinatorBytes := int(nLevels / 8) //nolint:gomnd
  905. numFeeIdxCoordinator := len(aux.FeeIdxCoordinator) / lenFeeIdxCoordinatorBytes
  906. for i := 0; i < numFeeIdxCoordinator; i++ {
  907. var paddedFeeIdx [6]byte
  908. // TODO: This check is not necessary: the first case will always work. Test it before removing the if.
  909. if lenFeeIdxCoordinatorBytes < common.IdxBytesLen {
  910. copy(paddedFeeIdx[6-lenFeeIdxCoordinatorBytes:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
  911. } else {
  912. copy(paddedFeeIdx[:], aux.FeeIdxCoordinator[i*lenFeeIdxCoordinatorBytes:(i+1)*lenFeeIdxCoordinatorBytes])
  913. }
  914. feeIdxCoordinator, err := common.IdxFromBytes(paddedFeeIdx[:])
  915. if err != nil {
  916. return nil, nil, tracerr.Wrap(err)
  917. }
  918. if feeIdxCoordinator != common.Idx(0) {
  919. rollupForgeBatchArgs.FeeIdxCoordinator = append(rollupForgeBatchArgs.FeeIdxCoordinator, feeIdxCoordinator)
  920. }
  921. }
  922. return &rollupForgeBatchArgs, &sender, nil
  923. }