Pullupstream/v0.5.0 rc4

.golangci.yml

@@ -17,6 +17,7 @@ linters:
   - gofmt
   - goimports
   - revive
+  - unconvert
 
 linters-settings:
   revive:

Dockerfile

@@ -12,7 +12,7 @@ RUN cd /src/db && packr2
 RUN cd /src && make build
 
 # CONTAINER FOR RUNNING BINARY
-FROM alpine:3.18.0
+FROM alpine:3.18.4
 COPY --from=build /src/dist/zkevm-node /app/zkevm-node
 COPY --from=build /src/config/environments/testnet/node.config.toml /app/example.config.toml
 RUN apk update && apk add postgresql15-client

README.md

@@ -19,7 +19,7 @@ For an in-depth understanding of the protocol’s specifications, please refer t
 
 ## Run a CDK Validium
 
-> This repo is a fork of the [zkevm-node](https://github.com/0xPolygonHermez/zkevm-node)
+> This repo is a fork of the [zkevm-node](https://github.com/0xPolygonHermez/zkevm-node), more information and code diff explained [here](./docs/diff/diff.md)
 
 ### Development
 

aggregator/aggregator.go

@@ -19,6 +19,7 @@ import (
 	"github.com/0xPolygonHermez/zkevm-node/encoding"
 	ethmanTypes "github.com/0xPolygonHermez/zkevm-node/etherman/types"
 	"github.com/0xPolygonHermez/zkevm-node/ethtxmanager"
+	"github.com/0xPolygonHermez/zkevm-node/l1infotree"
 	"github.com/0xPolygonHermez/zkevm-node/log"
 	"github.com/0xPolygonHermez/zkevm-node/state"
 	"github.com/ethereum/go-ethereum/common"
@@ -268,7 +269,7 @@ func (a *Aggregator) sendFinalProof() {
 
 			// add batch verification to be monitored
 			sender := common.HexToAddress(a.cfg.SenderAddress)
-			to, data, err := a.Ethman.BuildTrustedVerifyBatchesTxData(proof.BatchNumber-1, proof.BatchNumberFinal, &inputs)
+			to, data, err := a.Ethman.BuildTrustedVerifyBatchesTxData(proof.BatchNumber-1, proof.BatchNumberFinal, &inputs, sender)
 			if err != nil {
 				log.Errorf("Error estimating batch verification to add to eth tx manager: %v", err)
 				a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof)
@@ -766,15 +767,15 @@ func (a *Aggregator) getAndLockBatchToProve(ctx context.Context, prover proverIn
 
 	log.Info("Checking profitability to aggregate batch")
 
-	// pass matic collateral as zero here, bcs in smart contract fee for aggregator is not defined yet
+	// pass pol collateral as zero here, bcs in smart contract fee for aggregator is not defined yet
 	isProfitable, err := a.ProfitabilityChecker.IsProfitable(ctx, big.NewInt(0))
 	if err != nil {
 		log.Errorf("Failed to check aggregator profitability, err: %v", err)
 		return nil, nil, err
 	}
 
 	if !isProfitable {
-		log.Infof("Batch is not profitable, matic collateral %d", big.NewInt(0))
+		log.Infof("Batch is not profitable, pol collateral %d", big.NewInt(0))
 		return nil, nil, err
 	}
 
@@ -977,18 +978,98 @@ func (a *Aggregator) buildInputProver(ctx context.Context, batchToVerify *state.
 		return nil, fmt.Errorf("failed to get previous batch, err: %v", err)
 	}
 
+	isForcedBatch := false
+	batchRawData := &state.BatchRawV2{}
+
+	if batchToVerify.BatchNumber == 1 || batchToVerify.ForcedBatchNum != nil {
+		isForcedBatch = true
+	} else {
+		batchRawData, err = state.DecodeBatchV2(batchToVerify.BatchL2Data)
+		if err != nil {
+			log.Errorf("Failed to decode batch data, err: %v", err)
+			return nil, err
+		}
+	}
+
+	l1InfoTreeData := map[uint32]*prover.L1Data{}
+	l1InfoRoot := common.Hash{}
+	forcedBlockhashL1 := common.Hash{}
+
+	if !isForcedBatch {
+		tree, err := l1infotree.NewL1InfoTree(32, [][32]byte{}) // nolint:gomnd
+		if err != nil {
+			return nil, err
+		}
+
+		for _, l2blockRaw := range batchRawData.Blocks {
+			_, contained := l1InfoTreeData[l2blockRaw.IndexL1InfoTree]
+			if !contained && l2blockRaw.IndexL1InfoTree != 0 {
+				if l2blockRaw.IndexL1InfoTree != 0 {
+					l1InfoTreeExitRootStorageEntry, err := a.State.GetL1InfoRootLeafByIndex(ctx, l2blockRaw.IndexL1InfoTree, nil)
+					if err != nil {
+						return nil, err
+					}
+
+					leaves, err := a.State.GetLeafsByL1InfoRoot(ctx, l1InfoTreeExitRootStorageEntry.L1InfoTreeRoot, nil)
+					if err != nil {
+						return nil, err
+					}
+
+					aLeaves := make([][32]byte, len(leaves))
+					for i, leaf := range leaves {
+						aLeaves[i] = l1infotree.HashLeafData(leaf.GlobalExitRoot.GlobalExitRoot, leaf.PreviousBlockHash, uint64(leaf.Timestamp.Unix()))
+					}
+
+					// Calculate smt proof
+					smtProof, _, err := tree.ComputeMerkleProof(l2blockRaw.IndexL1InfoTree, aLeaves)
+					if err != nil {
+						return nil, err
+					}
+
+					protoProof := make([][]byte, len(smtProof))
+					for i, proof := range smtProof {
+						protoProof[i] = proof[:]
+					}
+
+					l1InfoTreeData[l2blockRaw.IndexL1InfoTree] = &prover.L1Data{
+						GlobalExitRoot: l1InfoTreeExitRootStorageEntry.L1InfoTreeLeaf.GlobalExitRoot.GlobalExitRoot.Bytes(),
+						BlockhashL1:    l1InfoTreeExitRootStorageEntry.L1InfoTreeLeaf.PreviousBlockHash.Bytes(),
+						MinTimestamp:   uint32(l1InfoTreeExitRootStorageEntry.L1InfoTreeLeaf.GlobalExitRoot.Timestamp.Unix()),
+						SmtProof:       protoProof,
+					}
+				}
+			}
+		}
+	} else {
+		// Initial batch must be handled differently
+		if batchToVerify.BatchNumber == 1 {
+			forcedBlockhashL1, err = a.State.GetVirtualBatchParentHash(ctx, batchToVerify.BatchNumber, nil)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			l1InfoRoot = batchToVerify.GlobalExitRoot
+			forcedBlockhashL1, err = a.State.GetForcedBatchParentHash(ctx, *batchToVerify.ForcedBatchNum, nil)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	inputProver := &prover.InputProver{
 		PublicInputs: &prover.PublicInputs{
-			OldStateRoot:    previousBatch.StateRoot.Bytes(),
-			OldAccInputHash: previousBatch.AccInputHash.Bytes(),
-			OldBatchNum:     previousBatch.BatchNumber,
-			ChainId:         a.cfg.ChainID,
-			ForkId:          a.cfg.ForkId,
-			BatchL2Data:     batchToVerify.BatchL2Data,
-			GlobalExitRoot:  batchToVerify.GlobalExitRoot.Bytes(),
-			EthTimestamp:    uint64(batchToVerify.Timestamp.Unix()),
-			SequencerAddr:   batchToVerify.Coinbase.String(),
-			AggregatorAddr:  a.cfg.SenderAddress,
+			OldStateRoot:      previousBatch.StateRoot.Bytes(),
+			OldAccInputHash:   previousBatch.AccInputHash.Bytes(),
+			OldBatchNum:       previousBatch.BatchNumber,
+			ChainId:           a.cfg.ChainID,
+			ForkId:            a.cfg.ForkId,
+			BatchL2Data:       batchToVerify.BatchL2Data,
+			L1InfoRoot:        l1InfoRoot.Bytes(),
+			TimestampLimit:    uint64(batchToVerify.Timestamp.Unix()),
+			SequencerAddr:     batchToVerify.Coinbase.String(),
+			AggregatorAddr:    a.cfg.SenderAddress,
+			L1InfoTreeData:    l1InfoTreeData,
+			ForcedBlockhashL1: forcedBlockhashL1.Bytes(),
 		},
 		Db:                map[string]string{},
 		ContractsBytecode: map[string]string{},

aggregator/aggregator_test.go

@@ -85,7 +85,7 @@ func TestSendFinalProof(t *testing.T) {
 					NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(),
 					NewStateRoot:     finalBatch.StateRoot.Bytes(),
 				}
-				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs).Run(func(args mock.Arguments) {
+				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs, common.HexToAddress(cfg.SenderAddress)).Run(func(args mock.Arguments) {
 					assert.True(a.verifyingProof)
 				}).Return(nil, nil, errBanana).Once()
 				m.stateMock.On("UpdateGeneratedProof", mock.Anything, recursiveProof, nil).Run(func(args mock.Arguments) {
@@ -108,7 +108,7 @@ func TestSendFinalProof(t *testing.T) {
 					NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(),
 					NewStateRoot:     finalBatch.StateRoot.Bytes(),
 				}
-				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs).Run(func(args mock.Arguments) {
+				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs, common.HexToAddress(cfg.SenderAddress)).Run(func(args mock.Arguments) {
 					assert.True(a.verifyingProof)
 				}).Return(nil, nil, errBanana).Once()
 				m.stateMock.On("UpdateGeneratedProof", mock.Anything, recursiveProof, nil).Run(func(args mock.Arguments) {
@@ -131,7 +131,7 @@ func TestSendFinalProof(t *testing.T) {
 					NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(),
 					NewStateRoot:     finalBatch.StateRoot.Bytes(),
 				}
-				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs).Run(func(args mock.Arguments) {
+				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs, common.HexToAddress(cfg.SenderAddress)).Run(func(args mock.Arguments) {
 					assert.True(a.verifyingProof)
 				}).Return(&to, data, nil).Once()
 				monitoredTxID := buildMonitoredTxID(batchNum, batchNumFinal)
@@ -156,7 +156,7 @@ func TestSendFinalProof(t *testing.T) {
 					NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(),
 					NewStateRoot:     finalBatch.StateRoot.Bytes(),
 				}
-				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs).Run(func(args mock.Arguments) {
+				m.etherman.On("BuildTrustedVerifyBatchesTxData", batchNum-1, batchNumFinal, &expectedInputs, common.HexToAddress(cfg.SenderAddress)).Run(func(args mock.Arguments) {
 					assert.True(a.verifyingProof)
 				}).Return(&to, data, nil).Once()
 				monitoredTxID := buildMonitoredTxID(batchNum, batchNumFinal)

aggregator/interfaces.go

@@ -38,7 +38,7 @@ type ethTxManager interface {
 // etherman contains the methods required to interact with ethereum
 type etherman interface {
 	GetLatestVerifiedBatchNum() (uint64, error)
-	BuildTrustedVerifyBatchesTxData(lastVerifiedBatch, newVerifiedBatch uint64, inputs *ethmanTypes.FinalProofInputs) (to *common.Address, data []byte, err error)
+	BuildTrustedVerifyBatchesTxData(lastVerifiedBatch, newVerifiedBatch uint64, inputs *ethmanTypes.FinalProofInputs, beneficiary common.Address) (to *common.Address, data []byte, err error)
 }
 
 // aggregatorTxProfitabilityChecker interface for different profitability
@@ -62,4 +62,8 @@ type stateInterface interface {
 	DeleteUngeneratedProofs(ctx context.Context, dbTx pgx.Tx) error
 	CleanupGeneratedProofs(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error
 	CleanupLockedProofs(ctx context.Context, duration string, dbTx pgx.Tx) (int64, error)
+	GetL1InfoRootLeafByIndex(ctx context.Context, l1InfoTreeIndex uint32, dbTx pgx.Tx) (state.L1InfoTreeExitRootStorageEntry, error)
+	GetLeafsByL1InfoRoot(ctx context.Context, l1InfoRoot common.Hash, dbTx pgx.Tx) ([]state.L1InfoTreeExitRootStorageEntry, error)
+	GetVirtualBatchParentHash(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (common.Hash, error)
+	GetForcedBatchParentHash(ctx context.Context, forcedBatchNumber uint64, dbTx pgx.Tx) (common.Hash, error)
 }