Merge remote-tracking branch 'origin/develop' into release/v0.3.0

.gitignore

@@ -9,6 +9,8 @@ book/
 index.html
 tmp
 .vscode
+coverage.out
+coverage.html
 .idea
 .idea/*
 

aggoracle/e2e_test.go

@@ -8,15 +8,15 @@ import (
 
 	gerContractL1 "github.com/0xPolygon/cdk-contracts-tooling/contracts/manual/globalexitrootnopush0"
 	"github.com/0xPolygon/cdk/aggoracle"
-	"github.com/0xPolygon/cdk/test/helpers"
+	"github.com/0xPolygon/cdk/test/aggoraclehelpers"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/stretchr/testify/require"
 )
 
 func TestEVM(t *testing.T) {
-	env := helpers.SetupAggoracleWithEVMChain(t)
+	env := aggoraclehelpers.SetupAggoracleWithEVMChain(t)
 	runTest(t, env.GERL1Contract, env.AggOracleSender, env.L1Client, env.AuthL1)
 }
 

aggregator/agglayer_client.go → aggregator/agglayer/agglayer_client.go

@@ -1,4 +1,4 @@
-package aggregator
+package agglayer
 
 import (
 	"context"
@@ -13,6 +13,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+const errCodeAgglayerRateLimitExceeded int = -10007
+
+var ErrAgglayerRateLimitExceeded = fmt.Errorf("agglayer rate limit exceeded")
+
 // AgglayerClientInterface is the interface that defines the methods that the AggLayerClient will implement
 type AgglayerClientInterface interface {
 	SendTx(signedTx SignedTx) (common.Hash, error)
@@ -39,6 +43,9 @@ func (c *AggLayerClient) SendTx(signedTx SignedTx) (common.Hash, error) {
 	}
 
 	if response.Error != nil {
+		if response.Error.Code == errCodeAgglayerRateLimitExceeded {
+			return common.Hash{}, ErrAgglayerRateLimitExceeded
+		}
 		return common.Hash{}, fmt.Errorf("%v %v", response.Error.Code, response.Error.Message)
 	}
 

aggregator/agglayer_tx.go → aggregator/agglayer/agglayer_tx.go

@@ -1,4 +1,4 @@
-package aggregator
+package agglayer
 
 import (
 	"crypto/ecdsa"

aggregator/aggregator.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/0xPolygon/cdk-rpc/rpc"
 	cdkTypes "github.com/0xPolygon/cdk-rpc/types"
+	"github.com/0xPolygon/cdk/aggregator/agglayer"
 	ethmanTypes "github.com/0xPolygon/cdk/aggregator/ethmantypes"
 	"github.com/0xPolygon/cdk/aggregator/prover"
 	cdkcommon "github.com/0xPolygon/cdk/common"
@@ -66,10 +67,10 @@ type Aggregator struct {
 	cfg    Config
 	logger *log.Logger
 
-	state        stateInterface
-	etherman     etherman
-	ethTxManager *ethtxmanager.Client
-	streamClient *datastreamer.StreamClient
+	state        StateInterface
+	etherman     Etherman
+	ethTxManager EthTxManagerClient
+	streamClient StreamClient
 	l1Syncr      synchronizer.Synchronizer
 	halted       atomic.Bool
 
@@ -97,16 +98,16 @@ type Aggregator struct {
 	exit context.CancelFunc
 
 	sequencerPrivateKey *ecdsa.PrivateKey
-	aggLayerClient      AgglayerClientInterface
+	aggLayerClient      agglayer.AgglayerClientInterface
 }
 
 // New creates a new aggregator.
 func New(
 	ctx context.Context,
 	cfg Config,
 	logger *log.Logger,
-	stateInterface stateInterface,
-	etherman etherman) (*Aggregator, error) {
+	stateInterface StateInterface,
+	etherman Etherman) (*Aggregator, error) {
 	var profitabilityChecker aggregatorTxProfitabilityChecker
 
 	switch cfg.TxProfitabilityCheckerType {
@@ -167,12 +168,12 @@ func New(
 	}
 
 	var (
-		aggLayerClient      AgglayerClientInterface
+		aggLayerClient      agglayer.AgglayerClientInterface
 		sequencerPrivateKey *ecdsa.PrivateKey
 	)
 
 	if !cfg.SyncModeOnlyEnabled && cfg.SettlementBackend == AggLayer {
-		aggLayerClient = NewAggLayerClient(cfg.AggLayerURL)
+		aggLayerClient = agglayer.NewAggLayerClient(cfg.AggLayerURL)
 
 		sequencerPrivateKey, err = newKeyFromKeystore(cfg.SequencerPrivateKey)
 		if err != nil {
@@ -921,10 +922,11 @@ func (a *Aggregator) settleWithAggLayer(
 	inputs ethmanTypes.FinalProofInputs) bool {
 	proofStrNo0x := strings.TrimPrefix(inputs.FinalProof.Proof, "0x")
 	proofBytes := common.Hex2Bytes(proofStrNo0x)
-	tx := Tx{
+
+	tx := agglayer.Tx{
 		LastVerifiedBatch: cdkTypes.ArgUint64(proof.BatchNumber - 1),
 		NewVerifiedBatch:  cdkTypes.ArgUint64(proof.BatchNumberFinal),
-		ZKP: ZKP{
+		ZKP: agglayer.ZKP{
 			NewStateRoot:     common.BytesToHash(inputs.NewStateRoot),
 			NewLocalExitRoot: common.BytesToHash(inputs.NewLocalExitRoot),
 			Proof:            cdkTypes.ArgBytes(proofBytes),
@@ -943,9 +945,12 @@ func (a *Aggregator) settleWithAggLayer(
 	a.logger.Debug("final proof signedTx: ", signedTx.Tx.ZKP.Proof.Hex())
 	txHash, err := a.aggLayerClient.SendTx(*signedTx)
 	if err != nil {
-		a.logger.Errorf("failed to send tx to the agglayer: %v", err)
+		if errors.Is(err, agglayer.ErrAgglayerRateLimitExceeded) {
+			a.logger.Errorf("%s. Config param VerifyProofInterval should match the agglayer configured rate limit.", err)
+		} else {
+			a.logger.Errorf("failed to send tx to the agglayer: %v", err)
+		}
 		a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof)
-
 		return false
 	}
 
@@ -1013,7 +1018,7 @@ func (a *Aggregator) handleFailureToAddVerifyBatchToBeMonitored(ctx context.Cont
 
 // buildFinalProof builds and return the final proof for an aggregated/batch proof.
 func (a *Aggregator) buildFinalProof(
-	ctx context.Context, prover proverInterface, proof *state.Proof) (*prover.FinalProof, error) {
+	ctx context.Context, prover ProverInterface, proof *state.Proof) (*prover.FinalProof, error) {
 	tmpLogger := a.logger.WithFields(
 		"prover", prover.Name(),
 		"proverId", prover.ID(),
@@ -1059,7 +1064,7 @@ func (a *Aggregator) buildFinalProof(
 // build the final proof.  If no proof is provided it looks for a previously
 // generated proof.  If the proof is eligible, then the final proof generation
 // is triggered.
-func (a *Aggregator) tryBuildFinalProof(ctx context.Context, prover proverInterface, proof *state.Proof) (bool, error) {
+func (a *Aggregator) tryBuildFinalProof(ctx context.Context, prover ProverInterface, proof *state.Proof) (bool, error) {
 	proverName := prover.Name()
 	proverID := prover.ID()
 
@@ -1245,7 +1250,7 @@ func (a *Aggregator) unlockProofsToAggregate(ctx context.Context, proof1 *state.
 }
 
 func (a *Aggregator) getAndLockProofsToAggregate(
-	ctx context.Context, prover proverInterface) (*state.Proof, *state.Proof, error) {
+	ctx context.Context, prover ProverInterface) (*state.Proof, *state.Proof, error) {
 	tmpLogger := a.logger.WithFields(
 		"prover", prover.Name(),
 		"proverId", prover.ID(),
@@ -1293,7 +1298,7 @@ func (a *Aggregator) getAndLockProofsToAggregate(
 	return proof1, proof2, nil
 }
 
-func (a *Aggregator) tryAggregateProofs(ctx context.Context, prover proverInterface) (bool, error) {
+func (a *Aggregator) tryAggregateProofs(ctx context.Context, prover ProverInterface) (bool, error) {
 	proverName := prover.Name()
 	proverID := prover.ID()
 
@@ -1458,7 +1463,7 @@ func (a *Aggregator) getVerifiedBatchAccInputHash(ctx context.Context, batchNumb
 }
 
 func (a *Aggregator) getAndLockBatchToProve(
-	ctx context.Context, prover proverInterface,
+	ctx context.Context, prover ProverInterface,
 ) (*state.Batch, []byte, *state.Proof, error) {
 	proverID := prover.ID()
 	proverName := prover.Name()
@@ -1574,7 +1579,7 @@ func (a *Aggregator) getAndLockBatchToProve(
 	return &dbBatch.Batch, dbBatch.Witness, proof, nil
 }
 
-func (a *Aggregator) tryGenerateBatchProof(ctx context.Context, prover proverInterface) (bool, error) {
+func (a *Aggregator) tryGenerateBatchProof(ctx context.Context, prover ProverInterface) (bool, error) {
 	tmpLogger := a.logger.WithFields(
 		"prover", prover.Name(),
 		"proverId", prover.ID(),