Feature/agglayer

.github/workflows/jsonschema.yml

@@ -19,14 +19,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 #v3
+      uses: actions/checkout@v4
       # https://github.com/actions/checkout#Checkout-pull-request-HEAD-commit-instead-of-merge-commit
       # Checkout pull request HEAD commit instead of merge commit
       with:
         ref: ${{ github.event.pull_request.head.sha }}
 
     - name: Install Go
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v5
       with:
         go-version: ${{ matrix.go-version }}
       env:

.github/workflows/lint.yml

@@ -13,11 +13,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Install Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
           go-version: 1.21.x
       - name: Checkout code
-        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+        uses: actions/checkout@v4
       - name: Lint
         run: |
           make install-linter

.github/workflows/release.yml

@@ -0,0 +1,75 @@
+name: release
+
+on:
+  push:
+    tags:
+    - 'v[0-9]+.[0-9]+.[0-9]+' # this action will only run on tags that follow semver
+jobs:
+  releaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.21
+
+      - name: Get packr
+        run: go install github.com/gobuffalo/packr/v2/packr2@v2.8.3
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v4
+        with:
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.TOKEN_RELEASE }}
+
+      - name: Get tag
+        uses: olegtarasov/get-tag@v2.1.2
+        id: tagName
+
+      - name: Put cardona, testnet and mainnet artifacts into a single zip
+        run: |
+          # CARDONA
+          mkdir -p cardona/config/environments/cardona
+          mkdir -p cardona/db/scripts
+          cp config/environments/cardona/* cardona/config/environments/cardona
+          cp docker-compose.yml cardona
+          sed -i 's/\/config\/environments\/${ZKEVM_NETWORK}/\/config\/environments\/cardona/g' cardona/docker-compose.yml
+          cp db/scripts/init_prover_db.sql cardona/db/scripts
+          mv cardona/config/environments/cardona/example.env cardona
+          sed -i -e "s/image: zkevm-node/image: hermeznetwork\/zkevm-node:$GIT_TAG_NAME/g" cardona/docker-compose.yml
+          zip -r cardona.zip cardona
+          # TESTNET
+          mkdir -p testnet/config/environments/testnet
+          mkdir -p testnet/db/scripts
+          cp config/environments/testnet/* testnet/config/environments/testnet
+          cp docker-compose.yml testnet
+          sed -i 's/\/config\/environments\/${ZKEVM_NETWORK}/\/config\/environments\/testnet/g' testnet/docker-compose.yml
+          cp db/scripts/init_prover_db.sql testnet/db/scripts
+          mv testnet/config/environments/testnet/example.env testnet
+          sed -i -e "s/image: zkevm-node/image: hermeznetwork\/zkevm-node:$GIT_TAG_NAME/g" testnet/docker-compose.yml
+          zip -r testnet.zip testnet
+          # MAINNET
+          mkdir -p mainnet/config/environments/mainnet
+          mkdir -p mainnet/db/scripts
+          cp config/environments/mainnet/* mainnet/config/environments/mainnet
+          cp docker-compose.yml mainnet
+          sed -i 's/\/config\/environments\/${ZKEVM_NETWORK}/\/config\/environments\/mainnet/g' mainnet/docker-compose.yml
+          cp db/scripts/init_prover_db.sql mainnet/db/scripts
+          mv mainnet/config/environments/mainnet/example.env mainnet
+          sed -i -e "s/image: zkevm-node/image: hermeznetwork\/zkevm-node:$GIT_TAG_NAME/g" mainnet/docker-compose.yml
+          zip -r mainnet.zip mainnet
+
+      - name: Publish cardona, testnet and mainnet  zip into release
+        uses: AButler/upload-release-assets@v2.0
+        with:
+          files: 'cardona.zip;testnet.zip;mainnet.zip'
+          repo-token: ${{ secrets.TOKEN_RELEASE }}
+          release-tag: ${{ steps.tagName.outputs.tag }}
+

.github/workflows/test-e2e.yml

@@ -21,10 +21,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744
+      uses: actions/checkout@v4
 
     - name: Install Go
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v5
       with:
         go-version: ${{ matrix.go-version }}
       env:

.github/workflows/test-full-non-e2e.yml

@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744
+      uses: actions/checkout@v4
 
     - name: Install Go
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v5
       with:
         go-version: ${{ matrix.go-version }}
       env:

aggregator/aggregator.go

@@ -2,6 +2,7 @@
 
 import (
 	"context"
+	"crypto/ecdsa"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -13,6 +14,10 @@
 	"time"
 	"unicode"
 
+	"github.com/0xPolygon/agglayer/tx"
+
+	"github.com/0xPolygon/agglayer/client"
+	agglayerTypes "github.com/0xPolygon/agglayer/rpc/types"
 	"github.com/0xPolygonHermez/zkevm-node/aggregator/metrics"
 	"github.com/0xPolygonHermez/zkevm-node/aggregator/prover"
 	"github.com/0xPolygonHermez/zkevm-node/config/types"
@@ -65,6 +70,9 @@
 	srv  *grpc.Server
 	ctx  context.Context
 	exit context.CancelFunc
+
+	AggLayerClient      client.ClientInterface
+	sequencerPrivateKey *ecdsa.PrivateKey
 }
 
 // New creates a new aggregator.
@@ -73,6 +81,8 @@
 	stateInterface stateInterface,
 	ethTxManager ethTxManager,
 	etherman etherman,
+	agglayerClient client.ClientInterface,
+	sequencerPrivateKey *ecdsa.PrivateKey,
 ) (Aggregator, error) {
 	var profitabilityChecker aggregatorTxProfitabilityChecker
 	switch cfg.TxProfitabilityCheckerType {
@@ -94,6 +104,9 @@
 		TimeCleanupLockedProofs: cfg.CleanupLockedProofsInterval,
 
 		finalProof: make(chan finalProofMsg),
+
+		AggLayerClient:      agglayerClient,
+		sequencerPrivateKey: sequencerPrivateKey,
 	}
 
 	return a, nil
@@ -267,34 +280,139 @@
 
 			log.Infof("Final proof inputs: NewLocalExitRoot [%#x], NewStateRoot [%#x]", inputs.NewLocalExitRoot, inputs.NewStateRoot)
 
-			// add batch verification to be monitored
-			sender := common.HexToAddress(a.cfg.SenderAddress)
-			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)
-				continue
-			}
-			monitoredTxID := buildMonitoredTxID(proof.BatchNumber, proof.BatchNumberFinal)
-			err = a.EthTxManager.Add(ctx, ethTxManagerOwner, monitoredTxID, sender, to, nil, data, a.cfg.GasOffset, nil)
-			if err != nil {
-				mTxLogger := ethtxmanager.CreateLogger(ethTxManagerOwner, monitoredTxID, sender, to)
-				mTxLogger.Errorf("Error to add batch verification tx to eth tx manager: %v", err)
-				a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof)
-				continue
+			switch a.cfg.SettlementBackend {
+			case AggLayer:
+				if success := a.settleWithAggLayer(ctx, proof, inputs); !success {
+					continue
+				}
+			default:
+				if success := a.settleDirect(ctx, proof, inputs); !success {
+					continue
+				}
 			}
 
-			// process monitored batch verifications before starting a next cycle
-			a.EthTxManager.ProcessPendingMonitoredTxs(ctx, ethTxManagerOwner, func(result ethtxmanager.MonitoredTxResult, dbTx pgx.Tx) {
-				a.handleMonitoredTxResult(result)
-			}, nil)
-
 			a.resetVerifyProofTime()
 			a.endProofVerification()
 		}
 	}
 }
 
+func (a *Aggregator) settleDirect(
+	ctx context.Context,
+	proof *state.Proof,
+	inputs ethmanTypes.FinalProofInputs,
+) (success bool) {
+	// add batch verification to be monitored
+	sender := common.HexToAddress(a.cfg.SenderAddress)
+
+	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)
+
+		return false
+	}
+
+	monitoredTxID := buildMonitoredTxID(proof.BatchNumber, proof.BatchNumberFinal)
+	err = a.EthTxManager.Add(
+		ctx,
+		ethTxManagerOwner,
+		monitoredTxID,
+		sender,
+		to,
+		nil,
+		data,
+		a.cfg.GasOffset,
+		nil,
+	)
+	if err != nil {
+		mTxLogger := ethtxmanager.CreateLogger(ethTxManagerOwner, monitoredTxID, sender, to)
+		mTxLogger.Errorf("Error to add batch verification tx to eth tx manager: %v", err)
+		a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof)
+
+		return false
+	}
+
+	// process monitored batch verifications before starting a next cycle
+	a.EthTxManager.ProcessPendingMonitoredTxs(
+		ctx,
+		ethTxManagerOwner,
+		func(result ethtxmanager.MonitoredTxResult, dbTx pgx.Tx) {
+			a.handleMonitoredTxResult(result)
+		},
+		nil,
+	)
+
+	return true
+}
+
+func (a *Aggregator) settleWithAggLayer(
+	ctx context.Context,
+	proof *state.Proof,
+	inputs ethmanTypes.FinalProofInputs,
+) (success bool) {
+	proofStrNo0x := strings.TrimPrefix(inputs.FinalProof.Proof, "0x")
+	proofBytes := common.Hex2Bytes(proofStrNo0x)
+	tx := tx.Tx{
+		LastVerifiedBatch: agglayerTypes.ArgUint64(proof.BatchNumber - 1),
+		NewVerifiedBatch:  agglayerTypes.ArgUint64(proof.BatchNumberFinal),
+		ZKP: tx.ZKP{
+			NewStateRoot:     common.BytesToHash(inputs.NewStateRoot),
+			NewLocalExitRoot: common.BytesToHash(inputs.NewLocalExitRoot),
+			Proof:            agglayerTypes.ArgBytes(proofBytes),
+		},
+		RollupID: a.Ethman.GetRollupId(),
+	}
+	signedTx, err := tx.Sign(a.sequencerPrivateKey)
+
+	if err != nil {
+		log.Errorf("failed to sign tx: %v", err)
+		a.handleFailureToSendToAggLayer(ctx, proof)
+
+		return false
+	}
+
+	log.Debug("final proof signedTx: ", signedTx.Tx.ZKP.Proof.Hex())
+	txHash, err := a.AggLayerClient.SendTx(*signedTx)
+	if err != nil {
+		log.Errorf("failed to send tx to the interop: %v", err)
+		a.handleFailureToSendToAggLayer(ctx, proof)
+
+		return false
+	}
+
+	log.Infof("tx %s sent to agglayer, waiting to be mined", txHash.Hex())
+	log.Debugf("Timeout set to %f seconds", a.cfg.AggLayerTxTimeout.Duration.Seconds())
+	waitCtx, cancelFunc := context.WithDeadline(ctx, time.Now().Add(a.cfg.AggLayerTxTimeout.Duration))
+	defer cancelFunc()
+	if err := a.AggLayerClient.WaitTxToBeMined(txHash, waitCtx); err != nil {
+		log.Errorf("interop didn't mine the tx: %v", err)
+		a.handleFailureToSendToAggLayer(ctx, proof)
+
+		return false
+	}
+
+	// TODO: wait for synchronizer to catch up
+	return true
+}
+
+func (a *Aggregator) handleFailureToSendToAggLayer(ctx context.Context, proof *state.Proof) {
+	log := log.WithFields("proofId", proof.ProofID, "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal))
+	proof.GeneratingSince = nil
+
+	err := a.State.UpdateGeneratedProof(ctx, proof, nil)
+	if err != nil {
+		log.Errorf("Failed updating proof state (false): %v", err)
+	}
+
+	a.endProofVerification()
+}
+
 func (a *Aggregator) handleFailureToAddVerifyBatchToBeMonitored(ctx context.Context, proof *state.Proof) {
 	log := log.WithFields("proofId", proof.ProofID, "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal))
 	proof.GeneratingSince = nil
@@ -1004,6 +1122,15 @@
 		if err != nil {
 			return nil, err
 		}
+		leaves, err := a.State.GetLeafsByL1InfoRoot(ctx, *l1InfoRoot, 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()))
+		}
 
 		for _, l2blockRaw := range batchRawData.Blocks {
 			_, contained := l1InfoTreeData[l2blockRaw.IndexL1InfoTree]
@@ -1013,20 +1140,25 @@
 					return nil, err
 				}
 
-				leaves, err := a.State.GetLeafsByL1InfoRoot(ctx, l1InfoTreeExitRootStorageEntry.L1InfoTreeRoot, nil)
+				// Calculate smt proof
+				smtProof, calculatedL1InfoRoot, err := tree.ComputeMerkleProof(l2blockRaw.IndexL1InfoTree, aLeaves)
 				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()))
+				if l1InfoRoot != nil && *l1InfoRoot != calculatedL1InfoRoot {
+					for i, l := range aLeaves {
+						log.Info("AllLeaves[%d]: %s", i, common.Bytes2Hex(l[:]))
+					}
+					for i, s := range smtProof {
+						log.Info("smtProof[%d]: %s", i, common.Bytes2Hex(s[:]))
+					}
+					return nil, fmt.Errorf("error: l1InfoRoot mismatch. L1InfoRoot: %s, calculatedL1InfoRoot: %s. l1InfoTreeIndex: %d", l1InfoRoot.String(), calculatedL1InfoRoot.String(), l2blockRaw.IndexL1InfoTree)
 				}
 
-				// Calculate smt proof
-				smtProof, _, err := tree.ComputeMerkleProof(l2blockRaw.IndexL1InfoTree, aLeaves)
-				if err != nil {
-					return nil, err
+				log.Debugf("L1InfoRoot: %s", l1InfoRoot.String())
+
+				for i, proof := range smtProof {
+					log.Debugf("smtProof[%d]: %s", i, common.Bytes2Hex(proof[:]))
 				}
 
 				protoProof := make([][]byte, len(smtProof))