diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 00000000000..d41a52fa4c2
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,13 @@
+**/*_test.go
+**/*.a
+**/*.dylib
+**/*.o
+**/*.dSYM
+
+build
+tests/testdata
+cmd/prometheus
+vendor
+
+cache.db
+.git
diff --git a/.github/workflows/ci_zkevm.yml b/.github/workflows/ci_zkevm.yml
index ae760de484c..5a423e79ef1 100644
--- a/.github/workflows/ci_zkevm.yml
+++ b/.github/workflows/ci_zkevm.yml
@@ -138,7 +138,8 @@ jobs:
           cd bridge
           mkdir tmp
           cat <<EOF > ./tmp/test.toml
-          TestAddrPrivate= "0x12d7de8621a77640c9241b2595ba78ce443d05e94090365ab3bb5e19df82c625"
+          TestL1AddrPrivate="0x12d7de8621a77640c9241b2595ba78ce443d05e94090365ab3bb5e19df82c625"
+          TestL2AddrPrivate="0x12d7de8621a77640c9241b2595ba78ce443d05e94090365ab3bb5e19df82c625"
           [ConnectionConfig]
           L1NodeURL="${ETH_RPC_URL}"
           L2NodeURL="${L2_RPC_URL}"
diff --git a/.github/workflows/hourly-env-checker.yml b/.github/workflows/hourly-env-checker.yml
index e25edadbe71..3688c027ab4 100644
--- a/.github/workflows/hourly-env-checker.yml
+++ b/.github/workflows/hourly-env-checker.yml
@@ -6,21 +6,8 @@ on:
   workflow_dispatch:
 
 jobs:
-  test-node:
+  run-checks:
     runs-on: ubuntu-latest
-    continue-on-error: true
-    strategy:
-      matrix:
-        include:
-          - name: "Integration 5 - Legacy"
-            network: "integration-5"
-            rpc: "http://34.175.214.161:8505"
-          - name: "Integration 5 - Erigon RPC"
-            network: "integration-5"
-            rpc: "http://34.175.214.161:8500"
-          - name: "Integration 5 - Erigon Sequencer"
-            network: "integration-5"
-            rpc: "http://34.175.214.161:8005"
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
@@ -30,8 +17,6 @@ jobs:
         with:
           go-version: '1.20'
 
-      - name: Build Go application
-        run: go build -o check_node
-
-      - name: Run tests
-        run: ./check_node -rpcURL=${{ matrix.rpc }} -nodeName=${{ matrix.name }}
\ No newline at end of file
+      - name: Run checks
+        working-directory: ./zk/debug_tools/env-checker
+        run: go run main.go -envFile envs.json
\ No newline at end of file
diff --git a/.github/workflows/nightly-bridge-erc20.yml b/.github/workflows/nightly-bridge-erc20.yml
index 858bbc2de13..238c9c19c93 100644
--- a/.github/workflows/nightly-bridge-erc20.yml
+++ b/.github/workflows/nightly-bridge-erc20.yml
@@ -21,7 +21,7 @@ jobs:
             
     steps:
       - name: Clone bridge repository
-        run:  git clone --recurse-submodules -j8 https://github.com/0xPolygonHermez/zkevm-bridge-service.git -b feature/test_bridge_messages_real_netowrk  bridge
+        run:  git clone --recurse-submodules -j8 https://github.com/0xPolygonHermez/zkevm-bridge-service.git -b feature/test_bridge_messages_real_network-v2  bridge
         
       - name: Build docker image
         run: |
diff --git a/.github/workflows/nightly-bridge-msg.yml b/.github/workflows/nightly-bridge-msg.yml
index 7d41b63bde9..949874e1493 100644
--- a/.github/workflows/nightly-bridge-msg.yml
+++ b/.github/workflows/nightly-bridge-msg.yml
@@ -21,7 +21,7 @@ jobs:
             
     steps:
       - name: Clone bridge repository
-        run:  git clone --recurse-submodules -j8 https://github.com/0xPolygonHermez/zkevm-bridge-service.git -b feature/test_bridge_messages_real_netowrk  bridge
+        run:  git clone --recurse-submodules -j8 https://github.com/0xPolygonHermez/zkevm-bridge-service.git -b  develop  bridge
         
       - name: Build docker image
         run: |
diff --git a/cmd/hack/rpc_cache/main.go b/cmd/hack/rpc_cache/main.go
index 104ef310d90..91a3746ba39 100644
--- a/cmd/hack/rpc_cache/main.go
+++ b/cmd/hack/rpc_cache/main.go
@@ -180,7 +180,6 @@ func handleRequest(w http.ResponseWriter, r *http.Request) {
 	}
 
 	url, _ := url2.Parse(endpoint)
-	fmt.Println("Fetching from upstream", url.Host)
 
 	resp, err := http.Post(endpoint, "application/json", bytes.NewBuffer(body))
 	if err != nil {
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 80484a42f57..d8f4033572e 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -646,6 +646,11 @@ var (
 		Usage: "The URL of the data availability service",
 		Value: "",
 	}
+	DebugTimers = cli.BoolFlag{
+		Name:  "debug.timers",
+		Usage: "Enable debug timers",
+		Value: false,
+	}
 	DebugNoSync = cli.BoolFlag{
 		Name:  "debug.no-sync",
 		Usage: "Disable syncing",
diff --git a/core/blockchain_zkevm.go b/core/blockchain_zkevm.go
index a1a38f39ef4..e73bacc7eea 100644
--- a/core/blockchain_zkevm.go
+++ b/core/blockchain_zkevm.go
@@ -118,41 +118,8 @@ func ExecuteBlockEphemerallyZk(
 			vmConfig.Tracer = nil
 		}
 
-		//[hack]TODO: remove this after bug is fixed
-		localReceipt := *receipt
-		if !chainConfig.IsForkID8Elderberry(blockNum) && errors.Is(execResult.Err, vm.ErrUnsupportedPrecompile) {
-			localReceipt.Status = 1
-		}
-
-		// forkid8 the poststate is empty
-		// forkid8 also fixed the bugs with logs and cumulative gas used
-		if !chainConfig.IsForkID8Elderberry(blockNum) {
-			// the stateroot in the transactions that comes from the datastream
-			// is the one after smart contract writes so it can't be used
-			// but since pre forkid7 blocks have 1 tx only, we can use the block root
-			if chainConfig.IsForkID7Etrog(blockNum) {
-				// receipt root holds the intermediate stateroot after the tx
-				intermediateState, err := roHermezDb.GetIntermediateTxStateRoot(blockNum, tx.Hash())
-				if err != nil {
-					return nil, err
-				}
-				receipt.PostState = intermediateState.Bytes()
-			} else {
-				receipt.PostState = header.Root.Bytes()
-			}
-
-			//[hack] log0 pre forkid8 are not included in the rpc logs
-			// also pre forkid8 comulative gas used is same as gas used
-			var fixedLogs types.Logs
-			for _, l := range receipt.Logs {
-				if len(l.Topics) == 0 && len(l.Data) == 0 {
-					continue
-				}
-				fixedLogs = append(fixedLogs, l)
-			}
-			receipt.Logs = fixedLogs
-			receipt.CumulativeGasUsed = receipt.GasUsed
-		}
+		localReceipt := CreateReceiptForBlockInfoTree(receipt, chainConfig, blockNum, execResult)
+		ProcessReceiptForBlockExecution(receipt, roHermezDb, chainConfig, blockNum, header, tx)
 
 		if err != nil {
 			if !vmConfig.StatelessExec {
@@ -182,7 +149,7 @@ func ExecuteBlockEphemerallyZk(
 
 		txInfos = append(txInfos, blockinfo.ExecutedTxInfo{
 			Tx:                tx,
-			Receipt:           &localReceipt,
+			Receipt:           localReceipt,
 			EffectiveGasPrice: effectiveGasPricePercentage,
 			Signer:            &txSender,
 		})
@@ -361,3 +328,51 @@ func FinalizeBlockExecutionWithHistoryWrite(
 
 	return newBlock, newTxs, newReceipt, nil
 }
+
+func CreateReceiptForBlockInfoTree(receipt *types.Receipt, chainConfig *chain.Config, blockNum uint64, execResult *ExecutionResult) *types.Receipt {
+	// [hack]TODO: remove this after bug is fixed
+	localReceipt := receipt.Clone()
+	if !chainConfig.IsForkID8Elderberry(blockNum) && errors.Is(execResult.Err, vm.ErrUnsupportedPrecompile) {
+		localReceipt.Status = 1
+	}
+
+	return localReceipt
+}
+
+func ProcessReceiptForBlockExecution(receipt *types.Receipt, roHermezDb state.ReadOnlyHermezDb, chainConfig *chain.Config, blockNum uint64, header *types.Header, tx types.Transaction) error {
+	// forkid8 the poststate is empty
+	// forkid8 also fixed the bugs with logs and cumulative gas used
+	if !chainConfig.IsForkID8Elderberry(blockNum) {
+		// the stateroot in the transactions that comes from the datastream
+		// is the one after smart contract writes so it can't be used
+		// but since pre forkid7 blocks have 1 tx only, we can use the block root
+		if chainConfig.IsForkID7Etrog(blockNum) {
+			// receipt root holds the intermediate stateroot after the tx
+			intermediateState, err := roHermezDb.GetIntermediateTxStateRoot(blockNum, tx.Hash())
+			if err != nil {
+				return err
+			}
+			receipt.PostState = intermediateState.Bytes()
+		} else {
+			receipt.PostState = header.Root.Bytes()
+		}
+
+		//[hack] log0 pre forkid8 are not included in the rpc logs
+		// also pre forkid8 comulative gas used is same as gas used
+		var fixedLogs types.Logs
+		for _, l := range receipt.Logs {
+			if len(l.Topics) == 0 && len(l.Data) == 0 {
+				continue
+			}
+			fixedLogs = append(fixedLogs, l)
+		}
+		receipt.Logs = fixedLogs
+		receipt.CumulativeGasUsed = receipt.GasUsed
+	}
+
+	for _, l := range receipt.Logs {
+		l.ApplyPaddingToLogsData(chainConfig.IsForkID8Elderberry(blockNum), chainConfig.IsForkID12Banana(blockNum))
+	}
+
+	return nil
+}
diff --git a/core/types/log_zkevm.go b/core/types/log_zkevm.go
new file mode 100644
index 00000000000..7195fab257a
--- /dev/null
+++ b/core/types/log_zkevm.go
@@ -0,0 +1,123 @@
+package types
+
+import (
+	"encoding/hex"
+
+	libcommon "github.com/ledgerwatch/erigon-lib/common"
+)
+
+func (_this *Log) Clone() *Log {
+	address := libcommon.Address{}
+	copy(address[:], _this.Address[:])
+
+	topics := make([]libcommon.Hash, len(_this.Topics))
+	for i, t := range _this.Topics {
+		copy(topics[i][:], t[:])
+	}
+
+	data := make([]byte, len(_this.Data))
+	copy(data, _this.Data)
+
+	txHash := libcommon.Hash{}
+	copy(txHash[:], _this.TxHash[:])
+
+	blockHash := libcommon.Hash{}
+	copy(blockHash[:], _this.BlockHash[:])
+
+	return &Log{
+		Address:     address,
+		Topics:      topics,
+		Data:        data,
+		BlockNumber: _this.BlockNumber,
+		TxHash:      txHash,
+		TxIndex:     _this.TxIndex,
+		BlockHash:   blockHash,
+		Index:       _this.Index,
+		Removed:     _this.Removed,
+	}
+}
+
+func (_this *Log) ApplyPaddingToLogsData(isForkId8, isForkId12 bool) {
+	d := _this.Data
+	mSize := len(d)
+
+	if isForkId8 && !isForkId12 {
+		d = applyHexPadBug(d, mSize)
+	} else {
+		// [zkEvm] fill 0 at the end
+		lenMod32 := mSize & 31
+		if lenMod32 != 0 {
+			d = append(d, make([]byte, 32-lenMod32)...)
+		}
+	}
+
+	_this.Data = d
+}
+
+func applyHexPadBug(d []byte, msInt int) []byte {
+	fullMs := msInt
+
+	var dLastWord []byte
+	if len(d) <= 32 {
+		dLastWord = append(d, make([]byte, 32-len(d))...)
+		d = []byte{}
+	} else {
+		dLastWord, msInt = getLastWordBytes(d, fullMs)
+		d = d[:len(d)-len(dLastWord)]
+	}
+
+	dataHex := hex.EncodeToString(dLastWord)
+
+	dataHex = appendZeros(dataHex, 64)
+
+	for len(dataHex) > 0 && dataHex[0] == '0' {
+		dataHex = dataHex[1:]
+	}
+
+	if len(dataHex) < msInt*2 {
+		dataHex = prependZeros(dataHex, msInt*2)
+	}
+	outputStr := takeFirstN(dataHex, msInt*2)
+	op, _ := hex.DecodeString(outputStr) // there error is always nil here, because we prepare outputStr to have even length
+	d = append(d, op...)
+	d = d[:fullMs]
+
+	return d
+}
+
+func getLastWordBytes(data []byte, originalMsInt int) ([]byte, int) {
+	wordLength := 32
+	dataLength := len(data)
+
+	remainderLength := dataLength % wordLength
+	if remainderLength == 0 {
+		return data[dataLength-wordLength:], 32
+	}
+
+	toRemove := dataLength / wordLength
+
+	msInt := originalMsInt - (toRemove * wordLength)
+
+	return data[dataLength-remainderLength:], msInt
+}
+
+func prependZeros(data string, size int) string {
+	for len(data) < size {
+		data = "0" + data
+	}
+	return data
+}
+
+func takeFirstN(data string, n int) string {
+	if len(data) < n {
+		return data
+	}
+	return data[:n]
+}
+
+func appendZeros(dataHex string, targetLength int) string {
+	for len(dataHex) < targetLength {
+		dataHex += "0"
+	}
+	return dataHex
+}
diff --git a/core/types/log_zkevm_test.go b/core/types/log_zkevm_test.go
new file mode 100644
index 00000000000..e71b4aa9bab
--- /dev/null
+++ b/core/types/log_zkevm_test.go
@@ -0,0 +1,69 @@
+package types
+
+import (
+	"testing"
+
+	"encoding/hex"
+
+	"github.com/ledgerwatch/erigon/common"
+)
+
+func TestApplyHexPadBug(t *testing.T) {
+	type testScenario struct {
+		data     string
+		mSize    int
+		expected string
+	}
+
+	scenarios := map[string]testScenario{
+		"cardona-bug-block-3177498": {
+			data:     "0x010203",
+			mSize:    3,
+			expected: "102030",
+		},
+		"singleByteHexWithoutBug": {
+			data:     "0x11",
+			mSize:    1,
+			expected: "11",
+		},
+		"another": {
+			data:     "0x100000000000000000000000000000000000000000000000000000000000000",
+			mSize:    1,
+			expected: "10",
+		},
+		"another1": {
+			data:     "0x1020000000000000000000000000000000000000000000000000000000000",
+			mSize:    3,
+			expected: "102000",
+		},
+		"cardona-897048": {
+			data:     "0x0000000000000000000000000000000000000000000000000000000000000001",
+			mSize:    32,
+			expected: "0000000000000000000000000000000000000000000000000000000000000001",
+		},
+		"cardona-896194": {
+			data:     "0x0000000000000000000000000000000000000000000000010000000000001e44000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009af3049dd15616fd627a35563b5282bea5c32e2000000000000000000000000000000000000000000000000000005af3107a4000",
+			mSize:    160,
+			expected: "0000000000000000000000000000000000000000000000010000000000001e44000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009af3049dd15616fd627a35563b5282bea5c32e2000000000000000000000000000000000000000000000000000005af3107a4000",
+		},
+		"cardona-3816917": {
+			data:     "0x0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f",
+			mSize:    60,
+			expected: "0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f010230405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0",
+		},
+	}
+
+	for name, scenario := range scenarios {
+		t.Run(name, func(t *testing.T) {
+			d := common.FromHex(scenario.data)
+
+			result := applyHexPadBug(d, scenario.mSize)
+
+			resultHex := hex.EncodeToString(result)
+
+			if resultHex != scenario.expected {
+				t.Errorf("Expected %s but got %s", scenario.expected, resultHex)
+			}
+		})
+	}
+}
diff --git a/core/types/receipt_zkevm.go b/core/types/receipt_zkevm.go
index 5b9c3759b27..719748e6439 100644
--- a/core/types/receipt_zkevm.go
+++ b/core/types/receipt_zkevm.go
@@ -21,10 +21,49 @@ import (
 	"math/big"
 
 	"github.com/ledgerwatch/erigon-lib/common"
+	libcommon "github.com/ledgerwatch/erigon-lib/common"
 
 	"github.com/ledgerwatch/erigon/crypto"
 )
 
+func (_this *Receipt) Clone() *Receipt {
+	postState := make([]byte, len(_this.PostState))
+	copy(postState, _this.PostState)
+
+	bloom := Bloom{}
+	copy(bloom[:], _this.Bloom[:])
+
+	logs := make(Logs, len(_this.Logs))
+	for i, l := range _this.Logs {
+		logs[i] = l.Clone()
+	}
+
+	txHash := libcommon.Hash{}
+	copy(txHash[:], _this.TxHash[:])
+
+	contractAddress := libcommon.Address{}
+	copy(contractAddress[:], _this.ContractAddress[:])
+
+	blockHash := libcommon.Hash{}
+	copy(blockHash[:], _this.BlockHash[:])
+
+	BlockNumber := big.NewInt(0).Set(_this.BlockNumber)
+
+	return &Receipt{
+		Type:              _this.Type,
+		PostState:         postState,
+		Status:            _this.Status,
+		CumulativeGasUsed: _this.CumulativeGasUsed,
+		Bloom:             bloom,
+		Logs:              logs,
+		TxHash:            txHash,
+		ContractAddress:   contractAddress,
+		BlockHash:         blockHash,
+		BlockNumber:       BlockNumber,
+		TransactionIndex:  _this.TransactionIndex,
+	}
+}
+
 // DeriveFields fills the receipts with their computed fields based on consensus
 // data and contextual infos like containing block and transactions.
 func (r Receipts) DeriveFields_zkEvm(forkId8BlockNum uint64, hash common.Hash, number uint64, txs Transactions, senders []common.Address) error {
diff --git a/core/vm/instructions_zkevm.go b/core/vm/instructions_zkevm.go
index 63b0e86b547..dae26a2b685 100644
--- a/core/vm/instructions_zkevm.go
+++ b/core/vm/instructions_zkevm.go
@@ -1,7 +1,6 @@
 package vm
 
 import (
-	"encoding/hex"
 	"math/big"
 
 	"github.com/holiman/uint256"
@@ -169,47 +168,6 @@ func makeLog_zkevm(size int, logIndexPerTx bool) executionFunc {
 
 		d := scope.Memory.GetCopy(int64(mStart.Uint64()), int64(mSize.Uint64()))
 
-		forkBlock := uint64(0)
-		if interpreter.evm.ChainConfig().ForkID88ElderberryBlock != nil {
-			forkBlock = interpreter.VM.evm.ChainConfig().ForkID88ElderberryBlock.Uint64()
-		}
-		blockNo := interpreter.VM.evm.Context.BlockNumber
-
-		// [hack] APPLY BUG ONLY ABOVE FORKID9
-		if forkBlock == 0 || blockNo < forkBlock {
-			// [zkEvm] fill 0 at the end
-			dataLen := len(d)
-			lenMod32 := dataLen & 31
-			if lenMod32 != 0 {
-				d = append(d, make([]byte, 32-lenMod32)...)
-			}
-		} else {
-			// bug start
-			/*
-			  \  /
-			 (o)(o)
-			 /    \
-			 \    /
-			  \  /
-			   \/
-			*/
-			var err error
-
-			d, err = applyHexPadBug(d, int(mSize.Uint64()), blockNo)
-			if err != nil {
-				return nil, err
-			}
-			/*
-			  \  /
-			 (o)(o)
-			 /    \
-			 \    /
-			  \  /
-			   \/
-			*/
-			// bug end
-		}
-
 		log := types.Log{
 			Address: scope.Contract.Address(),
 			Topics:  topics,
@@ -228,86 +186,6 @@ func makeLog_zkevm(size int, logIndexPerTx bool) executionFunc {
 	}
 }
 
-func applyHexPadBug(d []byte, msInt int, blockNo uint64) ([]byte, error) {
-	fullMs := msInt
-
-	var dLastWord []byte
-	if len(d) <= 32 {
-		dLastWord = append(d, make([]byte, 32-len(d))...)
-		d = []byte{}
-	} else {
-		dLastWord, msInt = getLastWordBytes(d, fullMs)
-		d = d[:len(d)-len(dLastWord)]
-	}
-
-	dataHex := hex.EncodeToString(dLastWord)
-
-	dataHex = appendZeros(dataHex, 64)
-
-	for len(dataHex) > 0 && dataHex[0] == '0' {
-		dataHex = dataHex[1:]
-	}
-
-	if len(dataHex) < msInt*2 {
-		dataHex = prependZeros(dataHex, msInt*2)
-	}
-	outputStr := takeFirstN(dataHex, msInt*2)
-
-	op, err := hex.DecodeString(outputStr)
-	if err != nil {
-		return nil, err
-	}
-	d = append(d, op...)
-
-	d = d[:fullMs]
-
-	return d, nil
-}
-
-func min(a, b uint64) uint64 {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func getLastWordBytes(data []byte, originalMsInt int) ([]byte, int) {
-	wordLength := 32
-	dataLength := len(data)
-
-	remainderLength := dataLength % wordLength
-	if remainderLength == 0 {
-		return data[dataLength-wordLength:], 32
-	}
-
-	toRemove := dataLength / wordLength
-
-	msInt := originalMsInt - (toRemove * wordLength)
-
-	return data[dataLength-remainderLength:], msInt
-}
-
-func prependZeros(data string, size int) string {
-	for len(data) < size {
-		data = "0" + data
-	}
-	return data
-}
-
-func takeFirstN(data string, n int) string {
-	if len(data) < n {
-		return data
-	}
-	return data[:n]
-}
-
-func appendZeros(dataHex string, targetLength int) string {
-	for len(dataHex) < targetLength {
-		dataHex += "0"
-	}
-	return dataHex
-}
-
 func opCreate_zkevm(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
 	if interpreter.readOnly {
 		return nil, ErrWriteProtection
diff --git a/core/vm/instructions_zkevm_test.go b/core/vm/instructions_zkevm_test.go
index 01642e841e1..3f28ade4240 100644
--- a/core/vm/instructions_zkevm_test.go
+++ b/core/vm/instructions_zkevm_test.go
@@ -5,8 +5,6 @@ import (
 	"math/big"
 	"testing"
 
-	"encoding/hex"
-
 	"github.com/holiman/uint256"
 	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon-lib/common"
@@ -18,69 +16,6 @@ import (
 	"github.com/ledgerwatch/erigon/params"
 )
 
-func TestApplyHexPadBug(t *testing.T) {
-	type testScenario struct {
-		data     string
-		mSize    int
-		expected string
-	}
-
-	scenarios := map[string]testScenario{
-		"cardona-bug-block-3177498": {
-			data:     "0x010203",
-			mSize:    3,
-			expected: "102030",
-		},
-		"singleByteHexWithoutBug": {
-			data:     "0x11",
-			mSize:    1,
-			expected: "11",
-		},
-		"another": {
-			data:     "0x100000000000000000000000000000000000000000000000000000000000000",
-			mSize:    1,
-			expected: "10",
-		},
-		"another1": {
-			data:     "0x1020000000000000000000000000000000000000000000000000000000000",
-			mSize:    3,
-			expected: "102000",
-		},
-		"cardona-897048": {
-			data:     "0x0000000000000000000000000000000000000000000000000000000000000001",
-			mSize:    32,
-			expected: "0000000000000000000000000000000000000000000000000000000000000001",
-		},
-		"cardona-896194": {
-			data:     "0x0000000000000000000000000000000000000000000000010000000000001e44000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009af3049dd15616fd627a35563b5282bea5c32e2000000000000000000000000000000000000000000000000000005af3107a4000",
-			mSize:    160,
-			expected: "0000000000000000000000000000000000000000000000010000000000001e44000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009af3049dd15616fd627a35563b5282bea5c32e2000000000000000000000000000000000000000000000000000005af3107a4000",
-		},
-		"cardona-3816917": {
-			data:     "0x0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f",
-			mSize:    60,
-			expected: "0102030405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f010230405060708090a0b0c0d0e0f0102030405060708090a0b0c0d0e0f0",
-		},
-	}
-
-	for name, scenario := range scenarios {
-		t.Run(name, func(t *testing.T) {
-			d := common.FromHex(scenario.data)
-
-			result, err := applyHexPadBug(d, scenario.mSize, 0)
-			if err != nil {
-				t.Fatalf("Error in applyHexPadBug: %v", err)
-			}
-
-			resultHex := hex.EncodeToString(result)
-
-			if resultHex != scenario.expected {
-				t.Errorf("Expected %s but got %s", scenario.expected, resultHex)
-			}
-		})
-	}
-}
-
 func TestBlockhashV2(t *testing.T) {
 
 	gethashFn := func(bn uint64) libcommon.Hash {
diff --git a/core/vm/zk_batch_counters.go b/core/vm/zk_batch_counters.go
index 6a30d899ab6..5640ef2c93a 100644
--- a/core/vm/zk_batch_counters.go
+++ b/core/vm/zk_batch_counters.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/ledgerwatch/erigon/zk/tx"
 	"github.com/ledgerwatch/log/v3"
 )
 
@@ -89,11 +88,12 @@ func (bcc *BatchCounterCollector) StartNewBlock(verifyMerkleProof bool) (bool, e
 func (bcc *BatchCounterCollector) processBatchLevelData() error {
 	totalEncodedTxLength := 0
 	for _, t := range bcc.transactions {
-		encoded, err := tx.TransactionToL2Data(t.transaction, bcc.forkId, tx.MaxEffectivePercentage)
+		l2Data, err := t.GetL2DataCache()
 		if err != nil {
 			return err
 		}
-		totalEncodedTxLength += len(encoded)
+
+		totalEncodedTxLength += len(l2Data)
 	}
 
 	// simulate adding in the changeL2Block transactions
diff --git a/core/vm/zk_counters_limits.go b/core/vm/zk_counters_limits.go
index 70b64d6d6be..fa04353c173 100644
--- a/core/vm/zk_counters_limits.go
+++ b/core/vm/zk_counters_limits.go
@@ -6,6 +6,9 @@ import (
 	zk_consts "github.com/ledgerwatch/erigon-lib/chain"
 )
 
+const stepDeduction = 200
+const baseSafetyPercentage float64 = 0.05
+
 var (
 	defaultTotalSteps  = 1 << 23
 	forkId10TotalSteps = 1 << 24
@@ -21,6 +24,11 @@ var (
 		poseidon:   math.MaxInt32,
 		sha256:     math.MaxInt32,
 	}
+
+	safetyPercentages = map[uint16]float64{
+		uint16(zk_consts.ForkID10): 0.025,
+		uint16(zk_consts.ForkID11): 0.0125,
+	}
 )
 
 type counterLimits struct {
@@ -77,14 +85,14 @@ func getCounterLimits(forkId uint16) *Counters {
 	totalSteps := getTotalSteps(forkId)
 
 	counterLimits := counterLimits{
-		totalSteps: totalSteps,
-		arith:      totalSteps >> 5,
-		binary:     totalSteps >> 4,
-		memAlign:   totalSteps >> 5,
-		keccaks:    int(math.Floor(float64(totalSteps)/155286) * 44),
-		padding:    int(math.Floor(float64(totalSteps) / 56)),
-		poseidon:   int(math.Floor(float64(totalSteps) / 30)),
-		sha256:     int(math.Floor(float64(totalSteps-1)/31488)) * 7,
+		totalSteps: applyDeduction(forkId, totalSteps),
+		arith:      applyDeduction(forkId, totalSteps>>5),
+		binary:     applyDeduction(forkId, totalSteps>>4),
+		memAlign:   applyDeduction(forkId, totalSteps>>5),
+		keccaks:    applyDeduction(forkId, int(math.Floor(float64(totalSteps)/155286)*44)),
+		padding:    applyDeduction(forkId, int(math.Floor(float64(totalSteps)/56))),
+		poseidon:   applyDeduction(forkId, int(math.Floor(float64(totalSteps)/30))),
+		sha256:     applyDeduction(forkId, int(math.Floor(float64(totalSteps-1)/31488))*7),
 	}
 
 	return createCountrsByLimits(counterLimits)
@@ -102,5 +110,19 @@ func getTotalSteps(forkId uint16) int {
 		totalSteps = defaultTotalSteps
 	}
 
+	// we need to remove some steps as these will always be used during batch execution
+	totalSteps -= stepDeduction
+
 	return totalSteps
 }
+
+func applyDeduction(fork uint16, input int) int {
+	deduction, found := safetyPercentages[fork]
+	if !found {
+		deduction = baseSafetyPercentage
+	}
+	asFloat := float64(input)
+	reduction := asFloat * deduction
+	newValue := asFloat - reduction
+	return int(math.Ceil(newValue))
+}
diff --git a/core/vm/zk_transaction_counters.go b/core/vm/zk_transaction_counters.go
index 34fd8b0155b..468e4e8fbb1 100644
--- a/core/vm/zk_transaction_counters.go
+++ b/core/vm/zk_transaction_counters.go
@@ -17,6 +17,7 @@ type TransactionCounter struct {
 	processingCounters *CounterCollector
 	smtLevels          int
 	forkId             uint16
+	l2DataCache        []byte
 }
 
 func NewTransactionCounter(transaction types.Transaction, smtMaxLevel int, forkId uint16, mcpReduction float64, shouldCountersBeUnlimited bool) *TransactionCounter {
@@ -49,17 +50,36 @@ func NewTransactionCounter(transaction types.Transaction, smtMaxLevel int, forkI
 }
 
 func (tc *TransactionCounter) Clone() *TransactionCounter {
+	var l2DataCacheCopy []byte
+	if tc.l2DataCache != nil {
+		l2DataCacheCopy = make([]byte, len(tc.l2DataCache))
+		copy(l2DataCacheCopy, tc.l2DataCache)
+	}
+
 	return &TransactionCounter{
 		transaction:        tc.transaction,
 		rlpCounters:        tc.rlpCounters.Clone(),
 		executionCounters:  tc.executionCounters.Clone(),
 		processingCounters: tc.processingCounters.Clone(),
 		smtLevels:          tc.smtLevels,
+		l2DataCache:        l2DataCacheCopy,
+	}
+}
+
+func (tc *TransactionCounter) GetL2DataCache() ([]byte, error) {
+	if tc.l2DataCache == nil {
+		data, err := tx.TransactionToL2Data(tc.transaction, 8, tx.MaxEffectivePercentage)
+		if err != nil {
+			return data, err
+		}
+
+		tc.l2DataCache = data
 	}
+	return tc.l2DataCache, nil
 }
 
 func (tc *TransactionCounter) CalculateRlp() error {
-	raw, err := tx.TransactionToL2Data(tc.transaction, 8, tx.MaxEffectivePercentage)
+	raw, err := tc.GetL2DataCache()
 	if err != nil {
 		return err
 	}
@@ -128,8 +148,7 @@ func (tc *TransactionCounter) CalculateRlp() error {
 
 	v, r, s := tc.transaction.RawSignatureValues()
 	v = tx.GetDecodedV(tc.transaction, v)
-	err = collector.ecRecover(v, r, s, false)
-	if err != nil {
+	if err := collector.ecRecover(v, r, s, false); err != nil {
 		return err
 	}
 
diff --git a/docs/nightly.html b/docs/nightly.html
index f17ad5f27d1..6d0244c7bf8 100644
--- a/docs/nightly.html
+++ b/docs/nightly.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Nightly GitHub Actions Status</title>
+    <title>Actions Status</title>
     <style>
         body {
             font-family: 'Arial', sans-serif;
@@ -15,96 +15,249 @@
             text-align: center;
             color: #333;
         }
-        .status-container {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 20px;
-            justify-content: center;
-        }
-        .status {
-            background: rgba(255, 255, 255, 0.7);
-            border-radius: 10px;
-            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
-            width: 300px;
-            padding: 20px;
-            position: relative;
-            backdrop-filter: blur(10px);
+        button {
+            display: block;
+            margin: 20px auto;
+            padding: 10px 20px;
+            font-size: 16px;
+            cursor: pointer;
+        }
+        .banner {
+            background-color: #ffcc00;
+            color: #333;
+            padding: 10px;
+            text-align: center;
+            display: none;
+            margin-bottom: 20px;
         }
-        .status h2 {
-            margin-top: 0;
+        .data-age {
+            text-align: center;
             margin-bottom: 10px;
-            font-size: 1.5em;
-            color: #555;
         }
-        .status p {
-            margin: 5px 0;
-            color: #666;
+        table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 20px;
         }
-        .status a {
-            text-decoration: none;
-            color: #007bff;
+        th, td {
+            padding: 12px;
+            border: 1px solid #ccc;
+            text-align: left;
+            cursor: pointer;
         }
-        .status.success {
-            background: rgba(144, 238, 144, 0.7); /* Light green */
+        th {
+            background-color: #f9f9f9;
+            position: relative;
+        }
+        th.sort-asc::after {
+            content: '▲';
+            position: absolute;
+            right: 8px;
+        }
+        th.sort-desc::after {
+            content: '▼';
+            position: absolute;
+            right: 8px;
         }
-        .status.failure {
-            background: rgba(255, 99, 71, 0.7); /* Light red */
+        .success {
+            background-color: rgba(144, 238, 144, 0.3);
         }
-        .status.in_progress {
-            background: rgba(173, 216, 230, 0.7); /* Light blue */
+        .failure {
+            background-color: rgba(255, 99, 71, 0.3);
+        }
+        .in_progress {
+            background-color: rgba(173, 216, 230, 0.3);
         }
         .conclusion {
             font-weight: bold;
         }
+        .spinner {
+            border: 4px solid rgba(0, 0, 0, 0.1);
+            width: 36px;
+            height: 36px;
+            border-radius: 50%;
+            border-left-color: #333;
+            animation: spin 1s ease infinite;
+            margin: 20px auto;
+        }
+        @keyframes spin {
+            0% {
+                transform: rotate(0deg);
+            }
+            100% {
+                transform: rotate(360deg);
+            }
+        }
     </style>
 </head>
 <body>
-<h1>Nightly GitHub Actions Status</h1>
-<div id="status-container" class="status-container"></div>
+<h1>Actions Status</h1>
+<div id="rate-limit-banner" class="banner">You have been rate limited. Please try again later.</div>
+<button id="refresh-button">Refresh</button>
+<div class="data-age" id="data-age">Data Age: Calculating...</div>
+<div class="spinner" id="spinner"></div>
+<table style="display:none;">
+    <thead>
+    <tr>
+        <th data-column="workflow" data-order="desc">Workflow</th>
+        <th data-column="status" data-order="desc">Status</th>
+        <th data-column="conclusion" data-order="desc">Conclusion</th>
+        <th data-column="runTime" data-order="desc">Run Time (min)</th>
+        <th data-column="startedAt" data-order="desc">Started At</th>
+        <th data-column="updatedAt" data-order="desc">Updated At</th>
+        <th data-column="link" data-order="desc">Link</th>
+    </tr>
+    </thead>
+    <tbody id="status-container"></tbody>
+</table>
 
 <script>
     const workflows = [
+        'hourly-env-checker.yml',
         'nightly_zkevm.yml',
         'nightly-ansible.yml',
         'nightly-bridge-erc20.yml',
         'nightly-eth-bench.yml',
         'nightly-node-compare.yml',
-        'nightly-l1-recovery.yml'
+        'nightly-l1-recovery.yml',
+        'nightly-rpc-batch-compare.yml'
     ];
 
     const owner = '0xPolygonHermez';
     const repo = 'cdk-erigon';
 
     async function fetchWorkflowRun(workflow) {
-        const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/actions/workflows/${workflow}/runs`);
-        const data = await response.json();
-        return data.workflow_runs[0];
+        try {
+            const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/actions/workflows/${workflow}/runs`);
+            if (response.status === 403 && response.headers.get('X-RateLimit-Remaining') === '0') {
+                document.getElementById('rate-limit-banner').style.display = 'block';
+                throw new Error(`Rate limit exceeded for workflow: ${workflow}`);
+            }
+            if (!response.ok) {
+                throw new Error(`Error fetching workflow: ${workflow}`);
+            }
+            const data = await response.json();
+            return data.workflow_runs[0];
+        } catch (error) {
+            console.error(error);
+            return null;
+        }
     }
 
     function displayWorkflowRun(run, workflowName) {
         const container = document.getElementById('status-container');
-        const div = document.createElement('div');
-        div.className = 'status ' + (run.conclusion || 'in_progress');
-        const runTime = (new Date(run.updated_at) - new Date(run.created_at)) / 1000 / 60;
-        div.innerHTML = `
-                <h2>${run.name}</h2>
-                <p><strong>Workflow:</strong> ${workflowName}</p>
-                <p><strong>Status:</strong> ${run.status}</p>
-                <p><strong>Conclusion:</strong> <span class="conclusion">${run.conclusion || 'in progress'}</span></p>
-                <p><strong>Run Time:</strong> ${runTime.toFixed(2)} minutes</p>
-                <p><strong>Started At:</strong> ${new Date(run.created_at).toLocaleString()}</p>
-                <p><strong>Updated At:</strong> ${new Date(run.updated_at).toLocaleString()}</p>
-                <p><a href="${run.html_url}" target="_blank">View Job Run</a></p>
+        const row = document.createElement('tr');
+        if (run) {
+            row.className = run.conclusion || 'in_progress';
+            const runTime = (new Date(run.updated_at) - new Date(run.created_at)) / 1000 / 60;
+            row.innerHTML = `
+                <td>${workflowName}</td>
+                <td>${run.status}</td>
+                <td><span class="conclusion">${run.conclusion || 'in progress'}</span></td>
+                <td>${runTime.toFixed(2)}</td>
+                <td>${new Date(run.created_at).toLocaleString()}</td>
+                <td>${new Date(run.updated_at).toLocaleString()}</td>
+                <td><a href="${run.html_url}" target="_blank">View Job Run</a></td>
+            `;
+        } else {
+            row.innerHTML = `
+                <td>${workflowName}</td>
+                <td>N/A</td>
+                <td><span class="conclusion">No runs found</span></td>
+                <td>N/A</td>
+                <td>N/A</td>
+                <td>N/A</td>
+                <td>N/A</td>
             `;
-        container.appendChild(div);
+        }
+        container.appendChild(row);
     }
 
-    async function main() {
+    function sortTable(columnIndex, order) {
+        const container = document.getElementById('status-container');
+        const rows = Array.from(container.querySelectorAll('tr'));
+        const getValue = (row, index) => row.querySelector(`td:nth-child(${index + 1})`).innerText;
+
+        rows.sort((a, b) => {
+            const aValue = getValue(a, columnIndex);
+            const bValue = getValue(b, columnIndex);
+            if (aValue < bValue) {
+                return order === 'asc' ? -1 : 1;
+            }
+            if (aValue > bValue) {
+                return order === 'asc' ? 1 : -1;
+            }
+            return 0;
+        });
+
+        container.innerHTML = '';
+        rows.forEach(row => container.appendChild(row));
+    }
+
+    function attachSortHandlers() {
+        const headers = document.querySelectorAll('th');
+        headers.forEach((header, index) => {
+            header.addEventListener('click', () => {
+                const order = header.getAttribute('data-order') === 'desc' ? 'asc' : 'desc';
+                headers.forEach(h => h.classList.remove('sort-asc', 'sort-desc'));
+                header.classList.add(order === 'asc' ? 'sort-asc' : 'sort-desc');
+                header.setAttribute('data-order', order);
+                sortTable(index, order);
+            });
+        });
+    }
+
+    async function fetchData() {
+        const runs = [];
         for (const workflow of workflows) {
             const run = await fetchWorkflowRun(workflow);
-            if (run) {
-                displayWorkflowRun(run, workflow);
-            }
+            runs.push({ run, workflow });
+        }
+        const lastRequestTime = new Date().toISOString();
+        localStorage.setItem('workflowRuns', JSON.stringify(runs));
+        localStorage.setItem('lastRequestTime', lastRequestTime);
+        displayData(runs, lastRequestTime);
+    }
+
+    function displayData(runs, lastRequestTime) {
+        const container = document.getElementById('status-container');
+        container.innerHTML = '';
+        runs.sort((a, b) => new Date(b.run?.updated_at || 0) - new Date(a.run?.updated_at || 0));
+        runs.forEach(({ run, workflow }) => displayWorkflowRun(run, workflow));
+
+        const updatedAtHeader = document.querySelector('th[data-column="updatedAt"]');
+        updatedAtHeader.setAttribute('data-order', 'desc');
+        updatedAtHeader.classList.add('sort-desc');
+
+        document.querySelector('table').style.display = 'table';
+        document.getElementById('spinner').style.display = 'none';
+        attachSortHandlers();
+
+        updateDataAge(lastRequestTime);
+    }
+
+    function updateDataAge(lastRequestTime) {
+        const dataAgeElement = document.getElementById('data-age');
+        const lastRequestDate = new Date(lastRequestTime);
+        const now = new Date();
+        const ageInMinutes = Math.floor((now - lastRequestDate) / 1000 / 60);
+        dataAgeElement.textContent = `Data Age: ${ageInMinutes} minute(s) ago`;
+    }
+
+    document.getElementById('refresh-button').addEventListener('click', () => {
+        document.getElementById('spinner').style.display = 'block';
+        document.querySelector('table').style.display = 'none';
+        document.getElementById('rate-limit-banner').style.display = 'none';
+        fetchData();
+    });
+
+    function main() {
+        const savedRuns = localStorage.getItem('workflowRuns');
+        const lastRequestTime = localStorage.getItem('lastRequestTime');
+        if (savedRuns && lastRequestTime) {
+            displayData(JSON.parse(savedRuns), lastRequestTime);
+        } else {
+            fetchData();
         }
     }
 
diff --git a/erigon-lib/chain/chain_config.go b/erigon-lib/chain/chain_config.go
index b9fc1cdf600..919d46d2531 100644
--- a/erigon-lib/chain/chain_config.go
+++ b/erigon-lib/chain/chain_config.go
@@ -109,6 +109,7 @@ type Config struct {
 	ForkID7EtrogBlock       *big.Int `json:"forkID7EtrogBlock,omitempty"`
 	ForkID88ElderberryBlock *big.Int `json:"forkID88ElderberryBlock,omitempty"`
 	ForkID9Elderberry2Block *big.Int `json:"forkID9FeijoaBlock,omitempty"`
+	ForkID12BananaBlock     *big.Int `json:"forkID12BananaBlock,omitempty"`
 	NormalcyBlock           *big.Int `json:"normalcyBlock,omitempty"`
 
 	SupportGasless bool `json:"supportGasless,omitempty"`
@@ -166,6 +167,8 @@ func (c *Config) SetForkIdBlock(forkIdNumber ForkId, blockNum uint64) error {
 		c.ForkID88ElderberryBlock = new(big.Int).SetUint64(blockNum)
 	case ForkID9Elderberry2:
 		c.ForkID9Elderberry2Block = new(big.Int).SetUint64(blockNum)
+	case ForkID12Banana:
+		c.ForkID12BananaBlock = new(big.Int).SetUint64(blockNum)
 	default:
 		return fmt.Errorf("unknown fork id number %d", forkIdNumber)
 	}
@@ -356,6 +359,10 @@ func (c *Config) IsForkId9Elderberry2(num uint64) bool {
 	return isForked(c.ForkID9Elderberry2Block, num)
 }
 
+func (c *Config) IsForkID12Banana(num uint64) bool {
+	return isForked(c.ForkID12BananaBlock, num)
+}
+
 // CheckCompatible checks whether scheduled fork transitions have been imported
 // with a mismatching chain configuration.
 func (c *Config) CheckCompatible(newcfg *Config, height uint64) *ConfigCompatError {
diff --git a/erigon-lib/chain/zk_constants.go b/erigon-lib/chain/zk_constants.go
index 871db900de4..661296a61ea 100644
--- a/erigon-lib/chain/zk_constants.go
+++ b/erigon-lib/chain/zk_constants.go
@@ -11,4 +11,5 @@ const (
 	ForkID9Elderberry2 ForkId = 9
 	ForkID10           ForkId = 10
 	ForkID11           ForkId = 11
+	ForkID12Banana     ForkId = 12
 )
diff --git a/eth/backend.go b/eth/backend.go
index e6bcc91420c..60f8681cd91 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -1335,7 +1335,7 @@ func (s *Ethereum) PreStart() error {
 		// so here we loop and take a brief pause waiting for it to be ready
 		attempts := 0
 		for {
-			_, err = zkStages.CatchupDatastream("stream-catchup", tx, s.dataStream, s.chainConfig.ChainID.Uint64(), s.config.DatastreamVersion)
+			_, err = zkStages.CatchupDatastream("stream-catchup", tx, s.dataStream, s.chainConfig.ChainID.Uint64(), s.config.DatastreamVersion, s.config.HasExecutors())
 			if err != nil {
 				if errors.Is(err, datastreamer.ErrAtomicOpNotAllowed) {
 					attempts++
diff --git a/eth/ethconfig/config_zkevm.go b/eth/ethconfig/config_zkevm.go
index d562f4ada86..669100c581b 100644
--- a/eth/ethconfig/config_zkevm.go
+++ b/eth/ethconfig/config_zkevm.go
@@ -57,6 +57,7 @@ type Zk struct {
 	SyncLimit             uint64
 	Gasless               bool
 
+	DebugTimers    bool
 	DebugNoSync    bool
 	DebugLimit     uint64
 	DebugStep      uint64
diff --git a/hermezconfig-bali.yaml.example b/hermezconfig-bali.yaml.example
index 34a16a13dc3..19a0bfa4476 100644
--- a/hermezconfig-bali.yaml.example
+++ b/hermezconfig-bali.yaml.example
@@ -14,7 +14,7 @@ zkevm.address-admin: "0x229A5bDBb09d8555f9214F7a6784804999BA4E0D"
 zkevm.address-rollup: "0xE2EF6215aDc132Df6913C8DD16487aBF118d1764"
 zkevm.address-ger-manager: "0x2968D6d736178f8FE7393CC33C87f29D9C287e78"
 
-zkevm.default-gas-price: 10000000
+zkevm.default-gas-price: 1000000000
 zkevm.max-gas-price: 0
 zkevm.gas-price-factor: 0.12
 
diff --git a/hermezconfig-cardona.yaml.example b/hermezconfig-cardona.yaml.example
index 5586858710d..fff8fbd0beb 100644
--- a/hermezconfig-cardona.yaml.example
+++ b/hermezconfig-cardona.yaml.example
@@ -14,7 +14,7 @@ zkevm.address-admin: "0xff6250d0e86a2465b0c1bf8e36409503d6a26963"
 zkevm.address-rollup: "0x32d33d5137a7cffb54c5bf8371172bcec5f310ff"
 zkevm.address-ger-manager: "0xAd1490c248c5d3CbAE399Fd529b79B42984277DF"
 
-zkevm.default-gas-price: 1
+zkevm.default-gas-price: 1000000000
 zkevm.max-gas-price: 0
 zkevm.gas-price-factor: 0.12
 
diff --git a/hermezconfig-mainnet.yaml.example b/hermezconfig-mainnet.yaml.example
index 069bade683b..f46262310be 100644
--- a/hermezconfig-mainnet.yaml.example
+++ b/hermezconfig-mainnet.yaml.example
@@ -14,7 +14,7 @@ zkevm.address-admin: "0x242daE44F5d8fb54B198D03a94dA45B5a4413e21"
 zkevm.address-rollup: "0x5132A183E9F3CB7C848b0AAC5Ae0c4f0491B7aB2"
 zkevm.address-ger-manager: "0x580bda1e7A0CFAe92Fa7F6c20A3794F169CE3CFb"
 
-zkevm.default-gas-price: 1
+zkevm.default-gas-price: 1000000000
 zkevm.max-gas-price: 0
 zkevm.gas-price-factor: 0.0375
 
diff --git a/smt/pkg/blockinfo/block_info.go b/smt/pkg/blockinfo/block_info.go
index ccd066c67fa..24f77994367 100644
--- a/smt/pkg/blockinfo/block_info.go
+++ b/smt/pkg/blockinfo/block_info.go
@@ -1,6 +1,7 @@
 package blockinfo
 
 import (
+	"context"
 	"fmt"
 	"math/big"
 
@@ -47,6 +48,8 @@ func BuildBlockInfoTree(
 	)
 	var err error
 	var logIndex int64 = 0
+	var keys []*utils.NodeKey
+	var vals []*utils.NodeValue8
 	for i, txInfo := range *transactionInfos {
 		receipt := txInfo.Receipt
 		t := txInfo.Tx
@@ -67,19 +70,28 @@ func BuildBlockInfoTree(
 
 		log.Trace("info-tree-tx", "block", blockNumber, "idx", i, "hash", l2TxHash.String())
 
-		_, err = infoTree.SetBlockTx(&l2TxHash, i, receipt, logIndex, receipt.CumulativeGasUsed, txInfo.EffectiveGasPrice)
+		genKeys, genVals, err := infoTree.GenerateBlockTxKeysVals(&l2TxHash, i, receipt, logIndex, receipt.CumulativeGasUsed, txInfo.EffectiveGasPrice)
 		if err != nil {
 			return nil, err
 		}
+		keys = append(keys, genKeys...)
+		vals = append(vals, genVals...)
+
 		logIndex += int64(len(receipt.Logs))
 	}
 
-	root, err := infoTree.SetBlockGasUsed(blockGasUsed)
+	key, val, err := generateBlockGasUsed(blockGasUsed)
 	if err != nil {
 		return nil, err
 	}
+	keys = append(keys, key)
+	vals = append(vals, val)
 
-	rootHash := common.BigToHash(root)
+	root, err := infoTree.smt.InsertBatch(context.Background(), "", keys, vals, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	rootHash := common.BigToHash(root.NewRootScalar.ToBigInt())
 
 	log.Trace("info-tree-root", "block", blockNumber, "root", rootHash.String())
 
@@ -381,3 +393,175 @@ func setL1BlockHash(smt *smt.SMT, blockHash *common.Hash) (*big.Int, error) {
 
 	return resp.NewRootScalar.ToBigInt(), nil
 }
+
+func bigInt2NodeVal8(val *big.Int) (*utils.NodeValue8, error) {
+	x := utils.ScalarToArrayBig(val)
+	v, err := utils.NodeValue8FromBigIntArray(x)
+	if err != nil {
+		return nil, err
+	}
+
+	return v, nil
+}
+
+func generateL2TxHash(txIndex *big.Int, l2TxHash *big.Int) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyTxHash(txIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	val, err := bigInt2NodeVal8(l2TxHash)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &key, val, nil
+}
+
+func generateTxStatus(txIndex *big.Int, status *big.Int) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyTxStatus(txIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	val, err := bigInt2NodeVal8(status)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &key, val, nil
+}
+
+func generateCumulativeGasUsed(txIndex, cumulativeGasUsed *big.Int) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyCumulativeGasUsed(txIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	val, err := bigInt2NodeVal8(cumulativeGasUsed)
+	if err != nil {
+		return nil, nil, err
+	}
+	return &key, val, nil
+}
+
+func generateTxLog(txIndex *big.Int, logIndex *big.Int, log *big.Int) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyTxLogs(txIndex, logIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	val, err := bigInt2NodeVal8(log)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &key, val, nil
+}
+
+func generateTxEffectivePercentage(txIndex, effectivePercentage *big.Int) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyEffectivePercentage(txIndex)
+	if err != nil {
+		return nil, nil, err
+	}
+	val, err := bigInt2NodeVal8(effectivePercentage)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &key, val, nil
+}
+
+func generateBlockGasUsed(gasUsed uint64) (*utils.NodeKey, *utils.NodeValue8, error) {
+	key, err := KeyBlockHeaderParams(big.NewInt(IndexBlockHeaderParamGasUsed))
+	if err != nil {
+		return nil, nil, err
+	}
+	gasUsedBig := big.NewInt(0).SetUint64(gasUsed)
+	val, err := bigInt2NodeVal8(gasUsedBig)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return &key, val, nil
+}
+
+func (b *BlockInfoTree) GenerateBlockTxKeysVals(
+	l2TxHash *common.Hash,
+	txIndex int,
+	receipt *ethTypes.Receipt,
+	logIndex int64,
+	cumulativeGasUsed uint64,
+	effectivePercentage uint8,
+) ([]*utils.NodeKey, []*utils.NodeValue8, error) {
+	var keys []*utils.NodeKey
+	var vals []*utils.NodeValue8
+	txIndexBig := big.NewInt(int64(txIndex))
+
+	key, val, err := generateL2TxHash(txIndexBig, l2TxHash.Big())
+	if err != nil {
+		return nil, nil, err
+	}
+	keys = append(keys, key)
+	vals = append(vals, val)
+
+	bigStatus := big.NewInt(0).SetUint64(receipt.Status)
+	key, val, err = generateTxStatus(txIndexBig, bigStatus)
+	if err != nil {
+		return nil, nil, err
+	}
+	keys = append(keys, key)
+	vals = append(vals, val)
+
+	bigCumulativeGasUsed := big.NewInt(0).SetUint64(cumulativeGasUsed)
+	key, val, err = generateCumulativeGasUsed(txIndexBig, bigCumulativeGasUsed)
+	if err != nil {
+		return nil, nil, err
+	}
+	keys = append(keys, key)
+	vals = append(vals, val)
+
+	log.Trace("info-tree-tx-inner",
+		"tx-index", txIndex,
+		"log-index", logIndex,
+		"cumulativeGasUsed", cumulativeGasUsed,
+		"effective-percentage", effectivePercentage,
+		"receipt-status", receipt.Status,
+	)
+
+	// now encode the logs
+	for _, rLog := range receipt.Logs {
+		reducedTopics := ""
+		for _, topic := range rLog.Topics {
+			reducedTopics += fmt.Sprintf("%x", topic)
+		}
+
+		logToEncode := fmt.Sprintf("0x%x%s", rLog.Data, reducedTopics)
+
+		hash, err := utils.HashContractBytecode(logToEncode)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		logEncodedBig := utils.ConvertHexToBigInt(hash)
+		key, val, err = generateTxLog(txIndexBig, big.NewInt(logIndex), logEncodedBig)
+		keys = append(keys, key)
+		vals = append(vals, val)
+
+		log.Trace("info-tree-tx-receipt-log",
+			"topics", reducedTopics,
+			"to-encode", logToEncode,
+			"log-index", logIndex,
+		)
+
+		// increment log index
+		logIndex += 1
+	}
+
+	// setTxEffectivePercentage
+	bigEffectivePercentage := big.NewInt(0).SetUint64(uint64(effectivePercentage))
+	key, val, err = generateTxEffectivePercentage(txIndexBig, bigEffectivePercentage)
+	if err != nil {
+		return nil, nil, err
+	}
+	keys = append(keys, key)
+	vals = append(vals, val)
+
+	return keys, vals, nil
+}
diff --git a/smt/pkg/blockinfo/block_info_test.go b/smt/pkg/blockinfo/block_info_test.go
index 1c2493c6784..7fc8a196e9d 100644
--- a/smt/pkg/blockinfo/block_info_test.go
+++ b/smt/pkg/blockinfo/block_info_test.go
@@ -1,6 +1,7 @@
 package blockinfo
 
 import (
+	"context"
 	"math/big"
 	"testing"
 
@@ -210,6 +211,29 @@ func TestSetBlockTx(t *testing.T) {
 		}
 		rootHex := common.BigToHash(root).Hex()
 
+		infoTree2 := NewBlockInfoTree()
+		keys, vals, err := infoTree2.GenerateBlockTxKeysVals(
+			&test.l2TxHash,
+			test.txIndex,
+			&test.receipt,
+			test.logIndex,
+			test.cumulativeGasUsed,
+			test.effectivePercentage,
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		root2, err2 := infoTree2.smt.InsertBatch(context.Background(), "", keys, vals, nil, nil)
+		if err2 != nil {
+			t.Fatal(err2)
+		}
+
+		rootHex2 := common.BigToHash(root2.NewRootScalar.ToBigInt()).Hex()
+		if rootHex != rootHex2 {
+			t.Fatalf("generate different root, raw method root is %s, new method root %s", rootHex, rootHex2)
+		}
+
 		if rootHex != test.finalBlockInfoRoot {
 			t.Fatalf("expected root %s, got %s", test.finalBlockInfoRoot, rootHex)
 		}
diff --git a/smt/pkg/smt/smt_batch_test.go b/smt/pkg/smt/smt_batch_test.go
index fc59ec7a446..b3c74655e66 100644
--- a/smt/pkg/smt/smt_batch_test.go
+++ b/smt/pkg/smt/smt_batch_test.go
@@ -86,6 +86,86 @@ func TestBatchSimpleInsert(t *testing.T) {
 	assertSmtDbStructure(t, smtBatch, false)
 }
 
+func incrementalInsert(tree *smt.SMT, key, val []*big.Int) {
+	for i := range key {
+		k := utils.ScalarToNodeKey(key[i])
+		tree.InsertKA(k, val[i])
+	}
+}
+
+func batchInsert(tree *smt.SMT, key, val []*big.Int) {
+	keyPointers := []*utils.NodeKey{}
+	valuePointers := []*utils.NodeValue8{}
+
+	for i := range key {
+		k := utils.ScalarToNodeKey(key[i])
+		vArray := utils.ScalarToArrayBig(val[i])
+		v, _ := utils.NodeValue8FromBigIntArray(vArray)
+
+		keyPointers = append(keyPointers, &k)
+		valuePointers = append(valuePointers, v)
+	}
+	tree.InsertBatch(context.Background(), "", keyPointers, valuePointers, nil, nil)
+}
+
+func BenchmarkIncrementalInsert(b *testing.B) {
+	keys := []*big.Int{}
+	vals := []*big.Int{}
+	for i := 0; i < 1000; i++ {
+		rand.Seed(time.Now().UnixNano())
+		keys = append(keys, big.NewInt(int64(rand.Intn(10000))))
+
+		rand.Seed(time.Now().UnixNano())
+		vals = append(vals, big.NewInt(int64(rand.Intn(10000))))
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		smtIncremental := smt.NewSMT(nil)
+		incrementalInsert(smtIncremental, keys, vals)
+	}
+}
+
+func BenchmarkBatchInsert(b *testing.B) {
+	keys := []*big.Int{}
+	vals := []*big.Int{}
+	for i := 0; i < 1000; i++ {
+		rand.Seed(time.Now().UnixNano())
+		keys = append(keys, big.NewInt(int64(rand.Intn(10000))))
+
+		rand.Seed(time.Now().UnixNano())
+		vals = append(vals, big.NewInt(int64(rand.Intn(10000))))
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		smtBatch := smt.NewSMT(nil)
+		batchInsert(smtBatch, keys, vals)
+	}
+}
+
+func TestBatchSimpleInsert2(t *testing.T) {
+	keys := []*big.Int{}
+	vals := []*big.Int{}
+	for i := 0; i < 1000; i++ {
+		rand.Seed(time.Now().UnixNano())
+		keys = append(keys, big.NewInt(int64(rand.Intn(10000))))
+
+		rand.Seed(time.Now().UnixNano())
+		vals = append(vals, big.NewInt(int64(rand.Intn(10000))))
+	}
+
+	smtIncremental := smt.NewSMT(nil)
+	incrementalInsert(smtIncremental, keys, vals)
+
+	smtBatch := smt.NewSMT(nil)
+	batchInsert(smtBatch, keys, vals)
+
+	smtIncrementalRootHash, _ := smtIncremental.Db.GetLastRoot()
+	smtBatchRootHash, _ := smtBatch.Db.GetLastRoot()
+	assert.Equal(t, utils.ConvertBigIntToHex(smtBatchRootHash), utils.ConvertBigIntToHex(smtIncrementalRootHash))
+}
+
 func TestBatchWitness(t *testing.T) {
 	keys := []utils.NodeKey{
 		utils.NodeKey{17822804428864912231, 4683868963463720294, 2947512351908939790, 2330225637707749973},
diff --git a/turbo/cli/default_flags.go b/turbo/cli/default_flags.go
index d99e2be1d5f..9b935a6e8eb 100644
--- a/turbo/cli/default_flags.go
+++ b/turbo/cli/default_flags.go
@@ -216,6 +216,7 @@ var DefaultFlags = []cli.Flag{
 	&utils.SyncLimit,
 	&utils.SupportGasless,
 	&utils.ExecutorPayloadOutput,
+	&utils.DebugTimers,
 	&utils.DebugNoSync,
 	&utils.DebugLimit,
 	&utils.DebugStep,
diff --git a/turbo/cli/flags_zkevm.go b/turbo/cli/flags_zkevm.go
index 53472815cf3..a5879dc87b1 100644
--- a/turbo/cli/flags_zkevm.go
+++ b/turbo/cli/flags_zkevm.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ledgerwatch/erigon/cmd/utils"
 	"github.com/ledgerwatch/erigon/eth/ethconfig"
 	"github.com/ledgerwatch/erigon/zk/sequencer"
+	utils2 "github.com/ledgerwatch/erigon/zk/utils"
 	"github.com/urfave/cli/v2"
 )
 
@@ -144,6 +145,7 @@ func ApplyFlagsForZkConfig(ctx *cli.Context, cfg *ethconfig.Config) {
 		WitnessFull:                            ctx.Bool(utils.WitnessFullFlag.Name),
 		SyncLimit:                              ctx.Uint64(utils.SyncLimit.Name),
 		Gasless:                                ctx.Bool(utils.SupportGasless.Name),
+		DebugTimers:                            ctx.Bool(utils.DebugTimers.Name),
 		DebugNoSync:                            ctx.Bool(utils.DebugNoSync.Name),
 		DebugLimit:                             ctx.Uint64(utils.DebugLimit.Name),
 		DebugStep:                              ctx.Uint64(utils.DebugStep.Name),
@@ -156,7 +158,9 @@ func ApplyFlagsForZkConfig(ctx *cli.Context, cfg *ethconfig.Config) {
 		DataStreamPort:                         ctx.Uint(utils.DataStreamPort.Name),
 	}
 
-	checkFlag(utils.L2ChainIdFlag.Name, cfg.Zk.L2ChainId)
+	utils2.EnableTimer(cfg.DebugTimers)
+
+	checkFlag(utils.L2ChainIdFlag.Name, cfg.L2ChainId)
 	if !sequencer.IsSequencer() {
 		checkFlag(utils.L2RpcUrlFlag.Name, cfg.Zk.L2RpcUrl)
 		checkFlag(utils.L2DataStreamerUrlFlag.Name, cfg.L2DataStreamerUrl)
diff --git a/turbo/jsonrpc/eth_api.go b/turbo/jsonrpc/eth_api.go
index 77215d2a019..10539715266 100644
--- a/turbo/jsonrpc/eth_api.go
+++ b/turbo/jsonrpc/eth_api.go
@@ -584,12 +584,10 @@ func NewGasPriceCache() *GasPriceCache {
 }
 
 func (c *GasPriceCache) GetLatest() (common.Hash, *big.Int) {
-	var hash common.Hash
-	var price *big.Int
 	c.mtx.Lock()
-	hash = c.latestHash
-	price = c.latestPrice
-	c.mtx.Unlock()
+	defer c.mtx.Unlock()
+	hash := c.latestHash
+	price := new(big.Int).Set(c.latestPrice) // deep copy
 	return hash, price
 }
 
diff --git a/turbo/jsonrpc/eth_system_zk.go b/turbo/jsonrpc/eth_system_zk.go
index 9e85f098e9d..d50f8d7016b 100644
--- a/turbo/jsonrpc/eth_system_zk.go
+++ b/turbo/jsonrpc/eth_system_zk.go
@@ -44,9 +44,6 @@ func (api *APIImpl) GasPrice(ctx context.Context) (*hexutil.Big, error) {
 		return nil, err
 	}
 
-	if res.Error != nil {
-		return nil, fmt.Errorf("RPC error response: %s", res.Error.Message)
-	}
 	if res.Error != nil {
 		return nil, fmt.Errorf("RPC error response: %s", res.Error.Message)
 	}
@@ -126,9 +123,6 @@ func (api *APIImpl) l1GasPrice() (*big.Int, error) {
 		return nil, err
 	}
 
-	if res.Error != nil {
-		return nil, fmt.Errorf("RPC error response: %s", res.Error.Message)
-	}
 	if res.Error != nil {
 		return nil, fmt.Errorf("RPC error response: %s", res.Error.Message)
 	}
diff --git a/turbo/jsonrpc/send_transaction.go b/turbo/jsonrpc/send_transaction.go
index 1ce8293f0dd..a899a471dda 100644
--- a/turbo/jsonrpc/send_transaction.go
+++ b/turbo/jsonrpc/send_transaction.go
@@ -15,10 +15,14 @@ import (
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/crypto"
 	"github.com/ledgerwatch/erigon/params"
+	"github.com/ledgerwatch/erigon/zk/utils"
 )
 
 // SendRawTransaction implements eth_sendRawTransaction. Creates new message call transaction or a contract creation for previously-signed transactions.
 func (api *APIImpl) SendRawTransaction(ctx context.Context, encodedTx hexutility.Bytes) (common.Hash, error) {
+	t := utils.StartTimer("rpc", "sendrawtransaction")
+	defer t.LogTimer()
+
 	tx, err := api.db.BeginRo(ctx)
 	if err != nil {
 		return common.Hash{}, err
diff --git a/turbo/jsonrpc/zkevm_api.go b/turbo/jsonrpc/zkevm_api.go
index ea396e8c773..2c28a10d196 100644
--- a/turbo/jsonrpc/zkevm_api.go
+++ b/turbo/jsonrpc/zkevm_api.go
@@ -645,15 +645,17 @@ func (api *ZkEvmAPIImpl) GetBatchByNumber(ctx context.Context, batchNumber rpc.B
 			return nil, err
 		}
 
-		itu, err := hermezDb.GetL1InfoTreeUpdateByGer(prevBatchGer.GlobalExitRoot)
-		if err != nil {
-			return nil, err
-		}
+		if prevBatchGer != nil {
+			itu, err := hermezDb.GetL1InfoTreeUpdateByGer(prevBatchGer.GlobalExitRoot)
+			if err != nil {
+				return nil, err
+			}
 
-		if itu == nil || batch.MainnetExitRoot == itu.MainnetExitRoot {
-			batch.MainnetExitRoot = common.Hash{}
-			batch.RollupExitRoot = common.Hash{}
-			batch.GlobalExitRoot = common.Hash{}
+			if itu == nil || batch.MainnetExitRoot == itu.MainnetExitRoot {
+				batch.MainnetExitRoot = common.Hash{}
+				batch.RollupExitRoot = common.Hash{}
+				batch.GlobalExitRoot = common.Hash{}
+			}
 		}
 	}
 
@@ -1109,10 +1111,17 @@ func convertTransactionsReceipts(
 			BlockHash:   &bh,
 			BlockNumber: types.ArgUint64Ptr(types.ArgUint64(blockNumber)),
 			TxIndex:     types.ArgUint64Ptr(types.ArgUint64(idx)),
-			ChainID:     types.ArgBig(*tx.GetChainID().ToBig()),
 			Type:        types.ArgUint64(tx.Type()),
 			Receipt:     receipt,
 		}
+
+		cid := tx.GetChainID()
+		var cidAB *types.ArgBig
+		if cid.Cmp(uint256.NewInt(0)) != 0 {
+			cidAB = (*types.ArgBig)(cid.ToBig())
+			tran.ChainID = cidAB
+		}
+
 		result = append(result, tran)
 	}
 
@@ -1195,10 +1204,15 @@ func convertBlockToRpcBlock(
 				BlockHash:   &blockHash,
 				BlockNumber: types.ArgUint64Ptr(types.ArgUint64(blockNumber)),
 				TxIndex:     types.ArgUint64Ptr(types.ArgUint64(idx)),
-				ChainID:     types.ArgBig(*tx.GetChainID().ToBig()),
 				Type:        types.ArgUint64(tx.Type()),
 				Receipt:     receipt,
 			}
+
+			cid := tx.GetChainID()
+			if cid.Cmp(uint256.NewInt(0)) != 0 {
+				tran.ChainID = (*types.ArgBig)(cid.ToBig())
+			}
+
 			t := types.TransactionOrHash{Tx: &tran}
 			result.Transactions = append(result.Transactions, t)
 		}
diff --git a/turbo/stages/zk_stages.go b/turbo/stages/zk_stages.go
index d11ec5a6be4..b5fd642d16c 100644
--- a/turbo/stages/zk_stages.go
+++ b/turbo/stages/zk_stages.go
@@ -53,7 +53,7 @@ func NewDefaultZkStages(ctx context.Context,
 		zkStages.StageL1SyncerCfg(db, l1Syncer, cfg.Zk),
 		zkStages.StageL1InfoTreeCfg(db, cfg.Zk, l1InfoTreeSyncer),
 		zkStages.StageBatchesCfg(db, datastreamClient, cfg.Zk),
-		zkStages.StageDataStreamCatchupCfg(datastreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion),
+		zkStages.StageDataStreamCatchupCfg(datastreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion, cfg.HasExecutors()),
 		stagedsync.StageBlockHashesCfg(db, dirs.Tmp, controlServer.ChainConfig, blockWriter),
 		stagedsync.StageSendersCfg(db, controlServer.ChainConfig, false, dirs.Tmp, cfg.Prune, blockReader, controlServer.Hd, nil),
 		stagedsync.StageExecuteBlocksCfg(
@@ -119,7 +119,7 @@ func NewSequencerZkStages(ctx context.Context,
 		zkStages.StageL1SequencerSyncCfg(db, cfg.Zk, sequencerStageSyncer),
 		zkStages.StageL1InfoTreeCfg(db, cfg.Zk, l1InfoTreeSyncer),
 		zkStages.StageSequencerL1BlockSyncCfg(db, cfg.Zk, l1BlockSyncer),
-		zkStages.StageDataStreamCatchupCfg(datastreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion),
+		zkStages.StageDataStreamCatchupCfg(datastreamServer, db, cfg.Genesis.Config.ChainID.Uint64(), cfg.DatastreamVersion, cfg.HasExecutors()),
 		zkStages.StageSequencerInterhashesCfg(db, notifications.Accumulator),
 		zkStages.StageSequenceBlocksCfg(
 			db,
diff --git a/xlayerconfig-mainnet.yaml.example b/xlayerconfig-mainnet.yaml.example
index 9e26a915ab4..2560bcb1ef2 100644
--- a/xlayerconfig-mainnet.yaml.example
+++ b/xlayerconfig-mainnet.yaml.example
@@ -8,10 +8,10 @@ zkevm.l2-datastreamer-url: stream.xlayer.tech:8800
 zkevm.l1-chain-id: 1
 zkevm.l1-rpc-url: https://rpc.ankr.com/eth/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-zkevm.address-sequencer: ""
-zkevm.address-zkevm: ""
-zkevm.address-admin: "0x5132a183e9f3cb7c848b0aac5ae0c4f0491b7ab2"
-zkevm.address-rollup: "0x2B0ee28D4D51bC9aDde5E58E295873F61F4a0507"
+zkevm.address-sequencer: "0xAF9d27ffe4d51eD54AC8eEc78f2785D7E11E5ab1"
+zkevm.address-zkevm: "0x2B0ee28D4D51bC9aDde5E58E295873F61F4a0507"
+zkevm.address-admin: "0x491619874b866c3cDB7C8553877da223525ead01"
+zkevm.address-rollup: "0x5132A183E9F3CB7C848b0AAC5Ae0c4f0491B7aB2"
 zkevm.address-ger-manager: "0x580bda1e7A0CFAe92Fa7F6c20A3794F169CE3CFb"
 
 zkevm.l1-rollup-id: 3
@@ -19,7 +19,7 @@ zkevm.l1-first-block: 19218658
 zkevm.l1-block-range: 2000
 zkevm.l1-query-delay: 1000
 zkevm.rpc-ratelimit: 250
-zkevm.datastream-version: 2
+zkevm.datastream-version: 3
 
 http.api: [eth, debug, net, trace, web3, erigon, zkevm]
 http.addr: 0.0.0.0
diff --git a/xlayerconfig-testnet.yaml.example b/xlayerconfig-testnet.yaml.example
index 4be7bf13e69..ee46ae08090 100644
--- a/xlayerconfig-testnet.yaml.example
+++ b/xlayerconfig-testnet.yaml.example
@@ -8,10 +8,10 @@ zkevm.l2-datastreamer-url: teststream.xlayer.tech:8800
 zkevm.l1-chain-id: 11155111
 zkevm.l1-rpc-url: https://rpc.ankr.com/eth_sepolia/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-zkevm.address-sequencer: ""
-zkevm.address-zkevm: ""
-zkevm.address-admin: "0x6662621411A8DACC3cA7049C8BddABaa9a999ce3"
-zkevm.address-rollup: "0x01469dACfDDA885D68Ff0f8628F2629c14F95a20"
+zkevm.address-sequencer: "0xD6DdA5AA7749142B7fDa3Fe4662C9f346101B8A6"
+zkevm.address-zkevm: "0x01469dACfDDA885D68Ff0f8628F2629c14F95a20"
+zkevm.address-admin: "0x14509f825e550745CFF827a9bDCCB4C3ad3FFd36"
+zkevm.address-rollup: "0x6662621411A8DACC3cA7049C8BddABaa9a999ce3"
 zkevm.address-ger-manager: "0x66E61bA00F58b857A9DD2C500F3aBc424A46BD20"
 
 zkevm.l1-rollup-id: 1
@@ -19,7 +19,7 @@ zkevm.l1-first-block: 4648290
 zkevm.l1-block-range: 2000
 zkevm.l1-query-delay: 1000
 zkevm.rpc-ratelimit: 250
-zkevm.datastream-version: 2
+zkevm.datastream-version: 3
 
 http.api: [eth, debug, net, trace, web3, erigon, zkevm]
 http.addr: 0.0.0.0
diff --git a/zk/datastream/client/stream_client.go b/zk/datastream/client/stream_client.go
index 17c0947b1f2..becca1a5721 100644
--- a/zk/datastream/client/stream_client.go
+++ b/zk/datastream/client/stream_client.go
@@ -37,6 +37,7 @@ type StreamClient struct {
 	// atomic
 	lastWrittenTime atomic.Int64
 	streaming       atomic.Bool
+	progress        atomic.Uint64
 
 	// Channels
 	batchStartChan chan types.BatchStart
@@ -92,6 +93,9 @@ func (c *StreamClient) GetLastWrittenTimeAtomic() *atomic.Int64 {
 func (c *StreamClient) GetStreamingAtomic() *atomic.Bool {
 	return &c.streaming
 }
+func (c *StreamClient) GetProgressAtomic() *atomic.Uint64 {
+	return &c.progress
+}
 
 // Opens a TCP connection to the server
 func (c *StreamClient) Start() error {
@@ -179,7 +183,7 @@ func (c *StreamClient) ReadEntries(bookmark *types.BookmarkProto, l2BlocksAmount
 
 // reads entries to the end of the stream
 // at end will wait for new entries to arrive
-func (c *StreamClient) ReadAllEntriesToChannel(bookmark *types.BookmarkProto) error {
+func (c *StreamClient) ReadAllEntriesToChannel() error {
 	c.streaming.Store(true)
 	defer c.streaming.Store(false)
 
@@ -189,6 +193,15 @@ func (c *StreamClient) ReadAllEntriesToChannel(bookmark *types.BookmarkProto) er
 		if err := c.tryReConnect(); err != nil {
 			return fmt.Errorf("failed to reconnect the datastream client: %W", err)
 		}
+		log.Info("[datastream_client] Datastream client connected.")
+	}
+
+	var bookmark *types.BookmarkProto
+	progress := c.progress.Load()
+	if progress == 0 {
+		bookmark = types.NewBookmarkProto(0, datastream.BookmarkType_BOOKMARK_TYPE_BATCH)
+	} else {
+		bookmark = types.NewBookmarkProto(progress, datastream.BookmarkType_BOOKMARK_TYPE_L2_BLOCK)
 	}
 
 	protoBookmark, err := bookmark.Marshal()
@@ -303,6 +316,10 @@ LOOP:
 		}
 
 		if batchEnd != nil {
+			// this check was inside c.readFullBlockProto() but it is better to move it here
+			if fullBlock == nil {
+				fullBlock = &types.FullL2Block{}
+			}
 			fullBlock.BatchEnd = true
 			fullBlock.LocalExitRoot = batchEnd.LocalExitRoot
 		}
@@ -442,8 +459,6 @@ func (c *StreamClient) readFullBlockProto() (*types.FullL2Block, *types.BatchSta
 		entriesRead++
 	}
 
-	var l2Block *types.FullL2Block
-
 	// If starting with a batch, return so it can be held whilst blocks are added to it
 	if file.IsBatchStart() {
 		batchStart, err = types.UnmarshalBatchStart(file.Data)
@@ -461,13 +476,11 @@ func (c *StreamClient) readFullBlockProto() (*types.FullL2Block, *types.BatchSta
 		}
 		log.Trace("batch end", "batchEnd", batchEnd)
 		// we might not have a block here if the batch end was immediately after the batch start
-		if l2Block == nil {
-			l2Block = &types.FullL2Block{}
-		}
-		return l2Block, nil, batchEnd, &gerUpdates, nil, nil, fromEntry, entriesRead, nil
+		return nil, nil, batchEnd, &gerUpdates, nil, nil, fromEntry, entriesRead, nil
 	}
 
 	// Now handle the L2 block
+	var l2Block *types.FullL2Block
 	if file.IsL2Block() {
 		l2Block, err = types.UnmarshalL2Block(file.Data)
 		if err != nil {
@@ -592,8 +605,7 @@ func (c *StreamClient) readHeaderEntry() (*types.HeaderEntry, error) {
 		return &types.HeaderEntry{}, fmt.Errorf("failed to read header bytes %v", err)
 	}
 
-	var headLength uint32
-	headLength = binary.BigEndian.Uint32(binaryHeader[1:5])
+	headLength := binary.BigEndian.Uint32(binaryHeader[1:5])
 	if headLength == types.HeaderSize {
 		// Read the rest of fixed size fields
 		buffer, err := readBuffer(c.conn, types.HeaderSize-types.HeaderSizePreEtrog)
diff --git a/zk/datastream/server/data_stream_server.go b/zk/datastream/server/data_stream_server.go
index 887c4dcfcf5..df14a385576 100644
--- a/zk/datastream/server/data_stream_server.go
+++ b/zk/datastream/server/data_stream_server.go
@@ -37,6 +37,8 @@ const (
 type DataStreamServer struct {
 	stream  *datastreamer.StreamServer
 	chainId uint64
+	highestBlockWritten,
+	highestBatchWritten *uint64
 }
 
 type DataStreamEntry interface {
@@ -51,8 +53,10 @@ type DataStreamEntryProto interface {
 
 func NewDataStreamServer(stream *datastreamer.StreamServer, chainId uint64) *DataStreamServer {
 	return &DataStreamServer{
-		stream:  stream,
-		chainId: chainId,
+		stream:              stream,
+		chainId:             chainId,
+		highestBlockWritten: nil,
+		highestBatchWritten: nil,
 	}
 }
 
@@ -86,7 +90,7 @@ func NewDataStreamEntries(size int) *DataStreamEntries {
 	}
 }
 
-func (srv *DataStreamServer) CommitEntriesToStreamProto(entries []DataStreamEntryProto) error {
+func (srv *DataStreamServer) CommitEntriesToStreamProto(entries []DataStreamEntryProto, latestBlockNum, latestBatchNum *uint64) error {
 	for _, entry := range entries {
 		entryType := entry.Type()
 
@@ -96,17 +100,23 @@ func (srv *DataStreamServer) CommitEntriesToStreamProto(entries []DataStreamEntr
 		}
 
 		if entryType == types.BookmarkEntryType {
-			_, err = srv.stream.AddStreamBookmark(em)
-			if err != nil {
+			if _, err = srv.stream.AddStreamBookmark(em); err != nil {
 				return err
 			}
 		} else {
-			_, err = srv.stream.AddStreamEntry(datastreamer.EntryType(entryType), em)
-			if err != nil {
+			if _, err = srv.stream.AddStreamEntry(datastreamer.EntryType(entryType), em); err != nil {
 				return err
 			}
 		}
 	}
+
+	if latestBlockNum != nil {
+		srv.highestBlockWritten = latestBlockNum
+	}
+
+	if latestBatchNum != nil {
+		srv.highestBatchWritten = latestBatchNum
+	}
 	return nil
 }
 
@@ -123,6 +133,7 @@ func createBlockWithBatchCheckStreamEntriesProto(
 	transactionsToIncludeByIndex []int, // passing nil here will include all transactions in the blocks
 ) ([]DataStreamEntryProto, error) {
 	var err error
+	var startEntriesProto, blockEntriesProto, endEntriesProto []DataStreamEntryProto
 
 	gers, err := reader.GetBatchGlobalExitRootsProto(lastBatchNumber, batchNumber)
 	if err != nil {
@@ -138,33 +149,12 @@ func createBlockWithBatchCheckStreamEntriesProto(
 
 	blockNum := block.NumberU64()
 
-	entryCount := 2                         // l2 block bookmark + l2 block
-	entryCount += len(filteredTransactions) // transactions
-	entryCount += len(gers)
-
-	if isBatchStart {
-		// we will add in a batch bookmark and a batch start entry
-		entryCount += 2
-
-		// a gap of 1 is normal but if greater than we need to account for the empty batches which will each
-		// have a batch bookmark, batch start and batch end
-		entryCount += int(3 * (batchGap - 1))
-	}
-
-	if isBatchEnd {
-		entryCount++
-	}
-
-	entries := NewDataStreamEntries(entryCount)
-
 	// batch start
 	// BATCH BOOKMARK
 	if isBatchStart {
-		var entriesProto []DataStreamEntryProto
-		if entriesProto, err = createBatchStartEntriesProto(reader, tx, batchNumber, lastBatchNumber, batchGap, chainId, block.Root(), gers); err != nil {
+		if startEntriesProto, err = createBatchStartEntriesProto(reader, tx, batchNumber, lastBatchNumber, batchGap, chainId, block.Root(), gers); err != nil {
 			return nil, err
 		}
-		entries.AddMany(entriesProto)
 	}
 
 	forkId, err := reader.GetForkId(batchNumber)
@@ -182,16 +172,19 @@ func createBlockWithBatchCheckStreamEntriesProto(
 	if err != nil {
 		return nil, err
 	}
-	entries.AddMany(blockEntries.Entries())
+	blockEntriesProto = blockEntries.Entries()
 
 	if isBatchEnd {
-		var batchEndEntries []DataStreamEntryProto
-		if batchEndEntries, err = addBatchEndEntriesProto(reader, tx, batchNumber, lastBatchNumber, block.Root(), gers); err != nil {
+		if endEntriesProto, err = addBatchEndEntriesProto(reader, tx, batchNumber, lastBatchNumber, block.Root(), gers); err != nil {
 			return nil, err
 		}
-		entries.AddMany(batchEndEntries)
 	}
 
+	entries := NewDataStreamEntries(len(startEntriesProto) + len(blockEntriesProto) + len(endEntriesProto))
+	entries.AddMany(startEntriesProto)
+	entries.AddMany(blockEntriesProto)
+	entries.AddMany(endEntriesProto)
+
 	return entries.Entries(), nil
 }
 
@@ -260,7 +253,7 @@ func createTransactionEntryProto(
 	tx eritypes.Transaction,
 	blockNum uint64,
 	isEtrog bool,
-) (DataStreamEntryProto, error) {
+) (txProto DataStreamEntryProto, err error) {
 	effectiveGasPricePercentage, err := reader.GetEffectiveGasPricePercentage(tx.Hash())
 	if err != nil {
 		return nil, err
@@ -268,16 +261,14 @@ func createTransactionEntryProto(
 
 	var intermediateRoot libcommon.Hash
 	if isEtrog {
-		intermediateRoot, err = reader.GetIntermediateTxStateRoot(blockNum, tx.Hash())
-		if err != nil {
+		if intermediateRoot, err = reader.GetIntermediateTxStateRoot(blockNum, tx.Hash()); err != nil {
 			return nil, err
 		}
 	}
 
 	// TRANSACTION
 
-	txProto, err := newTransactionProto(effectiveGasPricePercentage, intermediateRoot, tx, blockNum)
-	if err != nil {
+	if txProto, err = newTransactionProto(effectiveGasPricePercentage, intermediateRoot, tx, blockNum); err != nil {
 		return nil, err
 	}
 
@@ -295,13 +286,12 @@ func CreateAndBuildStreamEntryBytesProto(
 	l1InfoTreeMinTimestamps map[uint64]uint64,
 	isBatchEnd bool,
 	transactionsToIncludeByIndex []int, // passing nil here will include all transactions in the blocks
-) ([]byte, error) {
+) (result []byte, err error) {
 	entries, err := createBlockWithBatchCheckStreamEntriesProto(chainId, reader, tx, block, lastBlock, batchNumber, lastBatchNumber, l1InfoTreeMinTimestamps, isBatchEnd, transactionsToIncludeByIndex)
 	if err != nil {
 		return nil, err
 	}
 
-	var result []byte
 	for _, entry := range entries {
 		b, err := encodeEntryToBytesProto(entry)
 		if err != nil {
@@ -314,6 +304,10 @@ func CreateAndBuildStreamEntryBytesProto(
 }
 
 func (srv *DataStreamServer) GetHighestBlockNumber() (uint64, error) {
+	if srv.highestBlockWritten != nil {
+		return *srv.highestBlockWritten, nil
+	}
+
 	header := srv.stream.GetHeader()
 
 	if header.TotalEntries == 0 {
@@ -340,9 +334,46 @@ func (srv *DataStreamServer) GetHighestBlockNumber() (uint64, error) {
 		return 0, err
 	}
 
+	srv.highestBlockWritten = &l2Block.L2BlockNumber
+
 	return l2Block.L2BlockNumber, nil
 }
 
+func (srv *DataStreamServer) GetHighestBatchNumber() (uint64, error) {
+	if srv.highestBatchWritten != nil {
+		return *srv.highestBatchWritten, nil
+	}
+
+	header := srv.stream.GetHeader()
+
+	if header.TotalEntries == 0 {
+		return 0, nil
+	}
+
+	entryNum := header.TotalEntries - 1
+	var err error
+	var entry datastreamer.FileEntry
+	for {
+		entry, err = srv.stream.GetEntry(entryNum)
+		if err != nil {
+			return 0, err
+		}
+		if entry.Type == datastreamer.EntryType(1) {
+			break
+		}
+		entryNum -= 1
+	}
+
+	batch, err := types.UnmarshalBatchStart(entry.Data)
+	if err != nil {
+		return 0, err
+	}
+
+	srv.highestBatchWritten = &batch.Number
+
+	return batch.Number, nil
+}
+
 // must be done on offline server
 // finds the position of the block bookmark entry and deletes from it onward
 // blockNumber 10 would return the stream to before block 10 bookmark
diff --git a/zk/datastream/server/data_stream_server_utils.go b/zk/datastream/server/data_stream_server_utils.go
index 05e37dc58a6..399e09fbd0f 100644
--- a/zk/datastream/server/data_stream_server_utils.go
+++ b/zk/datastream/server/data_stream_server_utils.go
@@ -134,9 +134,12 @@ func createBatchStartEntriesProto(
 	batchNumber, lastBatchNumber, batchGap, chainId uint64,
 	root libcommon.Hash,
 	gers []types.GerUpdateProto,
-) (entries []DataStreamEntryProto, err error) {
+) ([]DataStreamEntryProto, error) {
+	var err error
 	var batchStartEntries []DataStreamEntryProto
 
+	entries := make([]DataStreamEntryProto, 0, 2+int(3*(batchGap-1))+len(gers))
+
 	// if we have a gap of more than 1 batch then we need to write in the batch start and ends for these empty batches
 	if batchGap > 1 {
 		var localExitRoot libcommon.Hash
@@ -183,13 +186,13 @@ func addBatchEndEntriesProto(
 	root libcommon.Hash,
 	gers []types.GerUpdateProto,
 ) ([]DataStreamEntryProto, error) {
-	entries := make([]DataStreamEntryProto, len(gers)+1)
+	entries := make([]DataStreamEntryProto, 0, len(gers)+1)
 
 	// see if we have any gers to handle
-	for i, ger := range gers {
+	for _, ger := range gers {
 		upd := ger.UpdateGER
 		if upd.BatchNumber == batchNumber {
-			entries[i] = newGerUpdateProto(upd.BatchNumber, upd.Timestamp, libcommon.BytesToHash(upd.GlobalExitRoot), libcommon.BytesToAddress(upd.Coinbase), upd.ForkId, upd.ChainId, libcommon.BytesToHash(upd.StateRoot))
+			entries = append(entries, newGerUpdateProto(upd.BatchNumber, upd.Timestamp, libcommon.BytesToHash(upd.GlobalExitRoot), libcommon.BytesToAddress(upd.Coinbase), upd.ForkId, upd.ChainId, libcommon.BytesToHash(upd.StateRoot)))
 		}
 	}
 
@@ -198,7 +201,7 @@ func addBatchEndEntriesProto(
 		return nil, err
 	}
 	// seal off the last batch
-	entries[len(gers)] = newBatchEndProto(localExitRoot, root, batchNumber)
+	entries = append(entries, newBatchEndProto(localExitRoot, root, batchNumber))
 
 	return entries, nil
 }
diff --git a/zk/datastream/server/datastream_populate.go b/zk/datastream/server/datastream_populate.go
index 90f0b37ef66..bf128fa4843 100644
--- a/zk/datastream/server/datastream_populate.go
+++ b/zk/datastream/server/datastream_populate.go
@@ -22,6 +22,9 @@ func (srv *DataStreamServer) WriteBlocksToStream(
 	from, to uint64,
 	logPrefix string,
 ) error {
+	t := utils.StartTimer("write-stream", "writeblockstostream")
+	defer t.LogTimer()
+
 	var err error
 
 	logTicker := time.NewTicker(10 * time.Second)
@@ -34,6 +37,7 @@ func (srv *DataStreamServer) WriteBlocksToStream(
 	entries := make([]DataStreamEntryProto, insertEntryCount)
 	index := 0
 	copyFrom := from
+	var latestbatchNum uint64
 	for currentBlockNumber := from; currentBlockNumber <= to; currentBlockNumber++ {
 		select {
 		case <-logTicker.C:
@@ -50,20 +54,21 @@ func (srv *DataStreamServer) WriteBlocksToStream(
 			}
 		}
 
-		block, blockEntries, err := srv.createBlockStreamEntriesWithBatchCheck(logPrefix, tx, reader, lastBlock, currentBlockNumber)
+		block, blockEntries, batchNum, err := srv.createBlockStreamEntriesWithBatchCheck(logPrefix, tx, reader, lastBlock, currentBlockNumber)
 		if err != nil {
 			return err
 		}
+		latestbatchNum = batchNum
 
 		for _, entry := range blockEntries {
 			entries[index] = entry
 			index++
 		}
 
-		// basically commit onece 80% of the entries array is filled
+		// basically commit once 80% of the entries array is filled
 		if index+1 >= insertEntryCount*4/5 {
 			log.Info(fmt.Sprintf("[%s] Commit count reached, committing entries", logPrefix), "block", currentBlockNumber)
-			if err = srv.CommitEntriesToStreamProto(entries[:index]); err != nil {
+			if err = srv.CommitEntriesToStreamProto(entries[:index], &currentBlockNumber, &batchNum); err != nil {
 				return err
 			}
 			entries = make([]DataStreamEntryProto, insertEntryCount)
@@ -73,7 +78,7 @@ func (srv *DataStreamServer) WriteBlocksToStream(
 		lastBlock = block
 	}
 
-	if err = srv.CommitEntriesToStreamProto(entries[:index]); err != nil {
+	if err = srv.CommitEntriesToStreamProto(entries[:index], &to, &latestbatchNum); err != nil {
 		return err
 	}
 
@@ -91,6 +96,9 @@ func (srv *DataStreamServer) WriteBlockToStream(
 	batchNum, prevBatchNum,
 	blockNum uint64,
 ) error {
+	t := utils.StartTimer("write-stream", "writeblockstostream")
+	defer t.LogTimer()
+
 	var err error
 
 	if err = srv.UnwindIfNecessary(logPrefix, reader, blockNum, prevBatchNum, batchNum); err != nil {
@@ -115,7 +123,7 @@ func (srv *DataStreamServer) WriteBlockToStream(
 		return err
 	}
 
-	if err = srv.CommitEntriesToStreamProto(entries); err != nil {
+	if err = srv.CommitEntriesToStreamProto(entries, &blockNum, &batchNum); err != nil {
 		return err
 	}
 
@@ -186,7 +194,7 @@ func (srv *DataStreamServer) WriteBatchEnd(
 		return err
 	}
 
-	if err = srv.CommitEntriesToStreamProto(batchEndEntries); err != nil {
+	if err = srv.CommitEntriesToStreamProto(batchEndEntries, nil, nil); err != nil {
 		return err
 	}
 
@@ -203,29 +211,29 @@ func (srv *DataStreamServer) createBlockStreamEntriesWithBatchCheck(
 	reader DbReader,
 	lastBlock *eritypes.Block,
 	blockNumber uint64,
-) (*eritypes.Block, []DataStreamEntryProto, error) {
+) (*eritypes.Block, []DataStreamEntryProto, uint64, error) {
 	block, err := rawdb.ReadBlockByNumber(tx, blockNumber)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	batchNum, err := reader.GetBatchNoByL2Block(blockNumber)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	prevBatchNum, err := reader.GetBatchNoByL2Block(blockNumber - 1)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	if err = srv.UnwindIfNecessary(logPrefix, reader, blockNumber, prevBatchNum, batchNum); err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	nextBatchNum, nextBatchExists, err := reader.CheckBatchNoByL2Block(blockNumber + 1)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	// a 0 next batch num here would mean we don't know about the next batch so must be at the end of the batch
@@ -233,10 +241,10 @@ func (srv *DataStreamServer) createBlockStreamEntriesWithBatchCheck(
 
 	entries, err := createBlockWithBatchCheckStreamEntriesProto(srv.chainId, reader, tx, block, lastBlock, batchNum, prevBatchNum, make(map[uint64]uint64), isBatchEnd, nil)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
-	return block, entries, nil
+	return block, entries, batchNum, nil
 }
 
 func (srv *DataStreamServer) WriteGenesisToStream(
@@ -271,7 +279,8 @@ func (srv *DataStreamServer) WriteGenesisToStream(
 	}
 	batchEnd := newBatchEndProto(ler, genesis.Root(), 0)
 
-	if err = srv.CommitEntriesToStreamProto([]DataStreamEntryProto{batchBookmark, batchStart, l2BlockBookmark, l2Block, batchEnd}); err != nil {
+	blockNum := uint64(0)
+	if err = srv.CommitEntriesToStreamProto([]DataStreamEntryProto{batchBookmark, batchStart, l2BlockBookmark, l2Block, batchEnd}, &blockNum, &batchNo); err != nil {
 		return err
 	}
 
diff --git a/zk/datastream/test/data_stream_compare/test_datastream_compare.go b/zk/datastream/test/data_stream_compare/test_datastream_compare.go
index 59dd89d379e..9647bc8a8d0 100644
--- a/zk/datastream/test/data_stream_compare/test_datastream_compare.go
+++ b/zk/datastream/test/data_stream_compare/test_datastream_compare.go
@@ -8,8 +8,6 @@ import (
 	"reflect"
 
 	"github.com/ledgerwatch/erigon/zk/datastream/client"
-	"github.com/ledgerwatch/erigon/zk/datastream/proto/github.com/0xPolygonHermez/zkevm-node/state/datastream"
-	"github.com/ledgerwatch/erigon/zk/datastream/types"
 	"github.com/nsf/jsondiff"
 )
 
@@ -41,14 +39,14 @@ func main() {
 		return
 	}
 
-	initialBookmark := types.NewBookmarkProto(0, datastream.BookmarkType_BOOKMARK_TYPE_L2_BLOCK)
+	client1.GetProgressAtomic().Store(0)
 
-	data1, err := readFromClient(client1, initialBookmark, 5000)
+	data1, err := readFromClient(client1, 5000)
 	if err != nil {
 		fmt.Printf("error: %v", err)
 	}
 
-	data2, err := readFromClient(client2, initialBookmark, 5000)
+	data2, err := readFromClient(client2, 5000)
 	if err != nil {
 		fmt.Printf("error: %v", err)
 	}
@@ -68,9 +66,9 @@ func main() {
 	fmt.Println("test complete...")
 }
 
-func readFromClient(client *client.StreamClient, bookmark *types.BookmarkProto, total int) ([]interface{}, error) {
+func readFromClient(client *client.StreamClient, total int) ([]interface{}, error) {
 	go func() {
-		err := client.ReadAllEntriesToChannel(bookmark)
+		err := client.ReadAllEntriesToChannel()
 		if err != nil {
 			fmt.Printf("error: %v", err)
 			return
diff --git a/zk/datastream/test/test.go b/zk/datastream/test/test.go
index 31a7c78f3f2..c1e2807dfa8 100644
--- a/zk/datastream/test/test.go
+++ b/zk/datastream/test/test.go
@@ -17,11 +17,12 @@ const dataStreamCardona = "datastream.cardona.zkevm-rpc.com:6900"
 const dataStreamBali = "datastream.internal.zkevm-rpc.com:6900"
 const datastreamMainnet = "stream.zkevm-rpc.com:6900"
 const estest = "34.175.214.161:6900"
+const local = "localhost:6910"
 
 // This code downloads headers and blocks from a datastream server.
 func main() {
 	// Create client
-	c := client.NewClient(context.Background(), dataStreamBali, 0, 0, 0)
+	c := client.NewClient(context.Background(), local, 0, 0, 0)
 
 	// Start client (connect to the server)
 	defer c.Stop()
@@ -30,10 +31,10 @@ func main() {
 	}
 
 	// create bookmark
-	bookmark := types.NewBookmarkProto(3773275, datastream.BookmarkType_BOOKMARK_TYPE_L2_BLOCK)
+	bookmark := types.NewBookmarkProto(9756, datastream.BookmarkType_BOOKMARK_TYPE_BATCH)
 
 	// Read all entries from server
-	blocksRead, _, _, entriesReadAmount, _, err := c.ReadEntries(bookmark, 2)
+	blocksRead, _, _, entriesReadAmount, _, err := c.ReadEntries(bookmark, 100)
 	if err != nil {
 		panic(err)
 	}
@@ -42,7 +43,7 @@ func main() {
 
 	// forkId := uint16(0)
 	for _, dsBlock := range *blocksRead {
-		fmt.Println(dsBlock.ForkId)
+		fmt.Println(dsBlock.BatchNumber)
 	}
 }
 
diff --git a/zk/debug_tools/env-checker/envs.json b/zk/debug_tools/env-checker/envs.json
new file mode 100644
index 00000000000..31ffb4d4182
--- /dev/null
+++ b/zk/debug_tools/env-checker/envs.json
@@ -0,0 +1,21 @@
+{
+  "groups": [
+    {
+      "groupName": "Integration 5",
+      "nodes": [
+        {
+          "nodeName": "Integration 5 - Legacy",
+          "rpcURL": "http://34.175.214.161:8505"
+        },
+        {
+          "nodeName": "Integration 5 - Erigon RPC",
+          "rpcURL": "http://34.175.214.161:8500"
+        },
+        {
+          "nodeName": "Integration 5 - Erigon Sequencer",
+          "rpcURL": "http://34.175.214.161:8005"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/zk/debug_tools/env-checker/main.go b/zk/debug_tools/env-checker/main.go
index 2c98363b83e..8688d2bc899 100644
--- a/zk/debug_tools/env-checker/main.go
+++ b/zk/debug_tools/env-checker/main.go
@@ -3,12 +3,12 @@ package main
 import (
 	"bytes"
 	"encoding/json"
+	"flag"
 	"fmt"
+	"io"
 	"log"
 	"net/http"
-	"flag"
 	"os"
-	"io"
 )
 
 type JSONRPCRequest struct {
@@ -24,37 +24,86 @@ type JSONRPCResponse struct {
 	Result  interface{} `json:"result"`
 }
 
+type Node struct {
+	NodeName string `json:"nodeName"`
+	RPCURL   string `json:"rpcURL"`
+}
+
+type NodeGroup struct {
+	GroupName string `json:"groupName"`
+	Nodes     []Node `json:"nodes"`
+}
+
+type EnvConfig struct {
+	Groups []NodeGroup `json:"groups"`
+}
+
 func main() {
-	rpcURL := flag.String("rpcURL", "", "RPC URL")
-	nodeName := flag.String("nodeName", "", "Node name")
+	envFile := flag.String("envFile", "", "JSON file containing environments")
 	flag.Parse()
 
-	if *rpcURL == "" {
-		log.Fatal("rpcURL flag not set")
+	if *envFile == "" {
+		log.Fatal("envFile flag not set")
 	}
-	if *nodeName == "" {
-		log.Fatal("nodeName flag not set")
+
+	file, err := os.Open(*envFile)
+	if err != nil {
+		log.Fatalf("Failed to open environment file: %v", err)
 	}
+	defer file.Close()
 
-	fmt.Printf("Checking node: %s\n", *nodeName)
-	err := checkClientVersion(*rpcURL)
+	var config EnvConfig
+	decoder := json.NewDecoder(file)
+	err = decoder.Decode(&config)
 	if err != nil {
-		fmt.Printf("Node is down: %s\n", *nodeName)
+		log.Fatalf("Failed to parse environment file: %v", err)
+	}
+
+	allSuccess := true
+	for _, group := range config.Groups {
+		fmt.Printf("\n========== Checking group: %s ==========\n", group.GroupName)
+		groupSuccess := true
+		for _, node := range group.Nodes {
+			fmt.Printf("\n--- Checking node: %s ---\n", node.NodeName)
+			if !checkNode(node) {
+				groupSuccess = false
+				allSuccess = false
+			}
+		}
+		if groupSuccess {
+			fmt.Printf("\n***** Group is up: %s *****\n", group.GroupName)
+		} else {
+			fmt.Printf("\n***** Group is down: %s *****\n", group.GroupName)
+		}
+	}
+
+	if allSuccess {
+		fmt.Println("\n===== All groups are up =====")
+		os.Exit(0)
+	} else {
+		fmt.Println("\n===== One or more groups are down =====")
 		os.Exit(1)
 	}
-	err = checkBlockHeight(*rpcURL)
+}
+
+func checkNode(node Node) bool {
+	err := checkClientVersion(node.RPCURL)
+	if err != nil {
+		fmt.Printf("Node is down: %s\n", node.NodeName)
+		return false
+	}
+	err = checkBlockHeight(node.RPCURL)
 	if err != nil {
-		fmt.Printf("Node is down: %s\n", *nodeName)
-		os.Exit(1)
+		fmt.Printf("Node is down: %s\n", node.NodeName)
+		return false
 	}
-	err = checkBatchNumber(*rpcURL)
+	err = checkBatchNumber(node.RPCURL)
 	if err != nil {
-		fmt.Printf("Node is down: %s\n", *nodeName)
-		os.Exit(1)
+		fmt.Printf("Node is down: %s\n", node.NodeName)
+		return false
 	}
-
-	fmt.Printf("Node is up: %s\n", *nodeName)
-	os.Exit(0)
+	fmt.Printf("Node is up: %s\n", node.NodeName)
+	return true
 }
 
 func makeRequest(rpcURL, method string) (*JSONRPCResponse, error) {
@@ -104,6 +153,7 @@ func checkBlockHeight(rpcURL string) error {
 	resp, err := makeRequest(rpcURL, "eth_blockNumber")
 	if err != nil {
 		fmt.Println("Block height retrieval failed")
+		return err
 	}
 	fmt.Printf("Block height: %v\n", resp.Result)
 	return nil
diff --git a/zk/debug_tools/nightly-block-compare-wait/main.go b/zk/debug_tools/nightly-block-compare-wait/main.go
index a63510ce33f..43ada1d37ce 100644
--- a/zk/debug_tools/nightly-block-compare-wait/main.go
+++ b/zk/debug_tools/nightly-block-compare-wait/main.go
@@ -9,11 +9,12 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"strconv"
 	"time"
 )
 
 const (
-	defaultCheckInterval = 30 * time.Second
+	defaultCheckInterval = 2 * time.Minute
 	defaultRunDuration   = 20 * time.Minute
 	defaultMaxBlockDiff  = 1000
 )
@@ -60,7 +61,7 @@ func getBlockHeight(url string) (*BlockNumberResponse, error) {
 	return &jsonResp, nil
 }
 
-func getBlockByNumber(url, blockNumber string) (*BlockResponse, error) {
+func getBlockByNumber(url string, blockNumber string) (*BlockResponse, error) {
 	reqBody := []byte(fmt.Sprintf(`{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["%s", true],"id":1}`, blockNumber))
 	req, err := http.NewRequest("POST", url, bytes.NewBuffer(reqBody))
 	if err != nil {
@@ -89,21 +90,28 @@ func getBlockByNumber(url, blockNumber string) (*BlockResponse, error) {
 	return &jsonResp, nil
 }
 
-func compareBlocks(erigonBlock, compareBlock *BlockResponse) bool {
-	if erigonBlock.Error != nil || compareBlock.Error != nil {
+func compareBlocks(block1, block2 *BlockResponse) bool {
+	if block1.Error != nil || block2.Error != nil {
 		log.Println("Error in block responses:")
-		if erigonBlock.Error != nil {
-			log.Println("Erigon error:", erigonBlock.Error)
+		if block1.Error != nil {
+			log.Println("Erigon error:", block1.Error)
 			return false
 		}
-		if compareBlock.Error != nil {
-			log.Println("Compare node error:", compareBlock.Error)
+		if block2.Error != nil {
+			log.Println("Compare node error:", block2.Error)
 			return false
 		}
 	}
 
-	erigonJSON, _ := json.MarshalIndent(erigonBlock.Result, "", "  ")
-	compareJSON, _ := json.MarshalIndent(compareBlock.Result, "", "  ")
+	for _, tx := range block1.Result.(map[string]interface{})["transactions"].([]interface{}) {
+		tx.(map[string]interface{})["chainId"] = "0x00"
+	}
+	for _, tx := range block2.Result.(map[string]interface{})["transactions"].([]interface{}) {
+		tx.(map[string]interface{})["chainId"] = "0x00"
+	}
+
+	erigonJSON, _ := json.MarshalIndent(block1.Result, "", "  ")
+	compareJSON, _ := json.MarshalIndent(block2.Result, "", "  ")
 
 	if bytes.Equal(erigonJSON, compareJSON) {
 		log.Println("Blocks match:", string(erigonJSON))
@@ -116,76 +124,123 @@ func compareBlocks(erigonBlock, compareBlock *BlockResponse) bool {
 	}
 }
 
+func checkBlocks(erigonNodeURL, compareNodeURL string, maxBlockDiff int) (int64, bool) {
+	erigonHeight, err := getBlockHeight(erigonNodeURL)
+	if err != nil {
+		log.Println("Error fetching block height from Erigon:", err)
+		return 0, false
+	}
+
+	compareHeight, err := getBlockHeight(compareNodeURL)
+	if err != nil {
+		log.Println("Error fetching block height from compare node:", err)
+		return 0, false
+	}
+
+	erigonBlockNumber, err := strconv.ParseInt(erigonHeight.Result[2:], 16, 64)
+	if err != nil {
+		log.Println("Error converting Erigon block number:", err)
+		return 0, false
+	}
+	compareBlockNumber, err := strconv.ParseInt(compareHeight.Result[2:], 16, 64)
+	if err != nil {
+		log.Println("Error converting compare block number:", err)
+		return 0, false
+	}
+
+	if erigonBlockNumber > 0 && compareBlockNumber > 0 {
+		if abs(erigonBlockNumber-compareBlockNumber) > int64(maxBlockDiff) {
+			log.Println("Block heights are not within the allowed difference (erigon, compare):", erigonBlockNumber, compareBlockNumber)
+		}
+
+		log.Println("Erigon height:", erigonBlockNumber, "Compare height:", compareBlockNumber)
+
+		lowestBlockNumber := erigonBlockNumber
+		if erigonBlockNumber > compareBlockNumber {
+			lowestBlockNumber = compareBlockNumber
+		}
+		log.Println("Lowest block number:", lowestBlockNumber)
+
+		if lowestBlockNumber == 0 {
+			return 0, false
+		}
+
+		lowestBlockHex := fmt.Sprintf("0x%x", lowestBlockNumber)
+
+		erigonBlock, err := getBlockByNumber(erigonNodeURL, lowestBlockHex)
+		if err != nil {
+			log.Println("Error fetching block from Erigon:", err)
+			return 0, false
+		}
+
+		compareBlock, err := getBlockByNumber(compareNodeURL, lowestBlockHex)
+		if err != nil {
+			log.Println("Error fetching block from compare node:", err)
+			return 0, false
+		}
+
+		ok := compareBlocks(erigonBlock, compareBlock)
+		if !ok {
+			log.Println("Block mismatch detected at height:", erigonBlock.Result.(map[string]interface{})["number"])
+			return 0, false
+		}
+
+		return lowestBlockNumber, true
+	}
+
+	return 0, false
+}
+
 func main() {
 	erigonNodeURL := flag.String("erigon", "http://erigon:8123", "URL for the Erigon node")
 	compareNodeURL := flag.String("compare", "http://other-node:8545", "URL for the compare node")
+	compareNode2URL := flag.String("compare2", "http://other-node2:8545", "URL for the second compare node")
 	checkInterval := flag.Duration("interval", defaultCheckInterval, "Interval to check the block height")
 	runDuration := flag.Duration("duration", defaultRunDuration, "Total duration to run the checks")
 	maxBlockDiff := flag.Int("max-block-diff", defaultMaxBlockDiff, "Maximum allowed block difference")
+	exitOnFirstCheck := flag.Bool("exit-on-first-check", true, "Exit after the first check")
 	flag.Parse()
 
+	log.Println("Starting block comparison")
+
 	ctx, cancel := context.WithTimeout(context.Background(), *runDuration)
 	defer cancel()
 
-	ticker := time.NewTicker(*checkInterval)
-	defer ticker.Stop()
+	ticker1 := time.NewTicker(*checkInterval)
+	defer ticker1.Stop()
+
+	ticker2 := time.NewTicker(*checkInterval)
+	defer ticker2.Stop()
 
 	for {
 		select {
 		case <-ctx.Done():
 			log.Println("Block checking exceeded timeout.")
 			os.Exit(1)
-		case <-ticker.C:
-			erigonHeight, err := getBlockHeight(*erigonNodeURL)
-			if err != nil {
-				log.Println("Error fetching block height from Erigon:", err)
-				continue
-			}
-
-			compareHeight, err := getBlockHeight(*compareNodeURL)
-			if err != nil {
-				log.Println("Error fetching block height from compare node:", err)
-				continue
-			}
-
-			erigonBlockNumber := erigonHeight.Result
-			compareBlockNumber := compareHeight.Result
-
-			if absDiff(erigonBlockNumber, compareBlockNumber) > *maxBlockDiff {
-				log.Println("Block heights are not within the allowed difference.")
-				continue
-			}
-
-			erigonBlock, err := getBlockByNumber(*erigonNodeURL, erigonBlockNumber)
-			if err != nil {
-				log.Println("Error fetching block from Erigon:", err)
-				continue
-			}
-
-			compareBlock, err := getBlockByNumber(*compareNodeURL, erigonBlockNumber)
-			if err != nil {
-				log.Println("Error fetching block from compare node:", err)
-				continue
-			}
-
-			ok := compareBlocks(erigonBlock, compareBlock)
-			if !ok {
-				// terminate on mismatch
-				log.Println("Block mismatch detected at height:", erigonBlock.Result.(map[string]interface{})["number"])
-				os.Exit(1)
+		case <-ticker1.C:
+			blockNumber, ok := checkBlocks(*erigonNodeURL, *compareNodeURL, *maxBlockDiff)
+			if ok {
+				log.Println("Waiting for second node to match the block height:", blockNumber)
+				for {
+					select {
+					case <-ctx.Done():
+						log.Println("Block checking exceeded timeout.")
+						os.Exit(1)
+					case <-ticker2.C:
+						_, compare2Ok := checkBlocks(*erigonNodeURL, *compareNode2URL, *maxBlockDiff)
+						if compare2Ok {
+							if *exitOnFirstCheck {
+								os.Exit(0)
+							}
+						}
+					}
+				}
 			}
 		}
 	}
 }
 
-func absDiff(a, b string) int {
-	var ia, ib int
-	fmt.Sscanf(a, "0x%x", &ia)
-	fmt.Sscanf(b, "0x%x", &ib)
-	return abs(ia - ib)
-}
-
-func abs(x int) int {
+func abs(x int64) int64 {
 	if x < 0 {
 		return -x
 	}
diff --git a/zk/hermez_db/db.go b/zk/hermez_db/db.go
index cddb99f4d4a..f3f91a872d1 100644
--- a/zk/hermez_db/db.go
+++ b/zk/hermez_db/db.go
@@ -45,7 +45,7 @@ const SMT_DEPTHS = "smt_depths"                                        // block
 const L1_INFO_LEAVES = "l1_info_leaves"                                // l1 info tree index -> l1 info tree leaf
 const L1_INFO_ROOTS = "l1_info_roots"                                  // root hash -> l1 info tree index
 const INVALID_BATCHES = "invalid_batches"                              // batch number -> true
-const BATCH_FULLY_PROCESSED = "batch_fully_processed"                  // batch number -> true
+const BATCH_PARTIALLY_PROCESSED = "batch_partially_processed"          // batch number -> true
 const LOCAL_EXIT_ROOTS = "local_exit_roots"                            // l2 block number -> local exit root
 const ROllUP_TYPES_FORKS = "rollup_types_forks"                        // rollup type id -> fork id
 const FORK_HISTORY = "fork_history"                                    // index -> fork id + last verified batch
@@ -104,7 +104,7 @@ func CreateHermezBuckets(tx kv.RwTx) error {
 		L1_INFO_LEAVES,
 		L1_INFO_ROOTS,
 		INVALID_BATCHES,
-		BATCH_FULLY_PROCESSED,
+		BATCH_PARTIALLY_PROCESSED,
 		LOCAL_EXIT_ROOTS,
 		ROllUP_TYPES_FORKS,
 		FORK_HISTORY,
@@ -1503,12 +1503,16 @@ func (db *HermezDbReader) GetInvalidBatch(batchNo uint64) (bool, error) {
 	return len(v) > 0, nil
 }
 
-func (db *HermezDb) WriteIsBatchFullyProcessed(batchNo uint64) error {
-	return db.tx.Put(BATCH_FULLY_PROCESSED, Uint64ToBytes(batchNo), []byte{1})
+func (db *HermezDb) WriteIsBatchPartiallyProcessed(batchNo uint64) error {
+	return db.tx.Put(BATCH_PARTIALLY_PROCESSED, Uint64ToBytes(batchNo), []byte{1})
 }
 
-func (db *HermezDbReader) GetIsBatchFullyProcessed(batchNo uint64) (bool, error) {
-	v, err := db.tx.GetOne(BATCH_FULLY_PROCESSED, Uint64ToBytes(batchNo))
+func (db *HermezDb) DeleteIsBatchPartiallyProcessed(batchNo uint64) error {
+	return db.tx.Delete(BATCH_PARTIALLY_PROCESSED, Uint64ToBytes(batchNo))
+}
+
+func (db *HermezDbReader) GetIsBatchPartiallyProcessed(batchNo uint64) (bool, error) {
+	v, err := db.tx.GetOne(BATCH_PARTIALLY_PROCESSED, Uint64ToBytes(batchNo))
 	if err != nil {
 		return false, err
 	}
diff --git a/zk/legacy_executor_verifier/legacy_executor_verifier.go b/zk/legacy_executor_verifier/legacy_executor_verifier.go
index b40f6d7389b..4b8455cb7a8 100644
--- a/zk/legacy_executor_verifier/legacy_executor_verifier.go
+++ b/zk/legacy_executor_verifier/legacy_executor_verifier.go
@@ -21,6 +21,7 @@ import (
 	"github.com/ledgerwatch/erigon/zk/legacy_executor_verifier/proto/github.com/0xPolygonHermez/zkevm-node/state/runtime/executor"
 	"github.com/ledgerwatch/erigon/zk/syncer"
 	"github.com/ledgerwatch/log/v3"
+	"sync"
 )
 
 var ErrNoExecutorAvailable = fmt.Errorf("no executor available")
@@ -95,6 +96,13 @@ type LegacyExecutorVerifier struct {
 
 	promises     []*Promise[*VerifierBundle]
 	addedBatches map[uint64]struct{}
+
+	// these three items are used to keep track of where the datastream is at
+	// compared with the executor checks.  It allows for data to arrive in strange
+	// orders and will backfill the stream as needed.
+	lowestWrittenBatch uint64
+	responsesToWrite   map[uint64]struct{}
+	responsesMtx       *sync.Mutex
 }
 
 func NewLegacyExecutorVerifier(
@@ -120,6 +128,8 @@ func NewLegacyExecutorVerifier(
 		l1Syncer:               l1Syncer,
 		promises:               make([]*Promise[*VerifierBundle], 0),
 		addedBatches:           make(map[uint64]struct{}),
+		responsesToWrite:       map[uint64]struct{}{},
+		responsesMtx:           &sync.Mutex{},
 	}
 }
 
@@ -262,6 +272,10 @@ func (v *LegacyExecutorVerifier) AddRequestUnsafe(request *VerifierRequest, sequ
 			}
 		}
 
+		if err = v.checkAndWriteToStream(tx, hermezDb, request.BatchNumber); err != nil {
+			log.Error("error writing data to stream", "err", err)
+		}
+
 		verifierBundle.response = &VerifierResponse{
 			BatchNumber:      request.BatchNumber,
 			Valid:            ok,
@@ -280,10 +294,54 @@ func (v *LegacyExecutorVerifier) AddRequestUnsafe(request *VerifierRequest, sequ
 	return promise
 }
 
+func (v *LegacyExecutorVerifier) checkAndWriteToStream(tx kv.Tx, hdb *hermez_db.HermezDbReader, newBatch uint64) error {
+	v.responsesMtx.Lock()
+	defer v.responsesMtx.Unlock()
+
+	v.responsesToWrite[newBatch] = struct{}{}
+
+	// if we haven't written anything yet - cold start of the node
+	if v.lowestWrittenBatch == 0 {
+		// we haven't written anything yet so lets make sure there is no gap
+		// in the stream for this batch
+		latestBatch, err := v.streamServer.GetHighestBatchNumber()
+		if err != nil {
+			return err
+		}
+		log.Info("[Verifier] Initialising on cold start", "latestBatch", latestBatch, "newBatch", newBatch)
+
+		v.lowestWrittenBatch = latestBatch
+
+		// check if we have the next batch we're waiting for
+		if latestBatch == newBatch-1 {
+			v.lowestWrittenBatch = newBatch
+			if err := v.WriteBatchToStream(newBatch, hdb, tx); err != nil {
+				return err
+			}
+			delete(v.responsesToWrite, newBatch)
+		}
+	}
+
+	// now check if the batch we want next is good
+	for {
+		// check if we have the next batch to write
+		nextBatch := v.lowestWrittenBatch + 1
+		if _, ok := v.responsesToWrite[nextBatch]; !ok {
+			break
+		}
+
+		if err := v.WriteBatchToStream(nextBatch, hdb, tx); err != nil {
+			return err
+		}
+		delete(v.responsesToWrite, nextBatch)
+		v.lowestWrittenBatch = nextBatch
+	}
+
+	return nil
+}
+
 // Unsafe is not thread-safe so it MUST be invoked only from a single thread
 func (v *LegacyExecutorVerifier) ProcessResultsSequentiallyUnsafe(tx kv.RwTx) ([]*VerifierResponse, error) {
-	hdb := hermez_db.NewHermezDbReader(tx)
-
 	results := make([]*VerifierResponse, 0, len(v.promises))
 	for i := 0; i < len(v.promises); i++ {
 		verifierBundle, err := v.promises[i].TryGet()
@@ -309,12 +367,6 @@ func (v *LegacyExecutorVerifier) ProcessResultsSequentiallyUnsafe(tx kv.RwTx) ([
 		}
 
 		verifierResponse := verifierBundle.response
-		if verifierResponse.Valid {
-			if err = v.WriteBatchToStream(verifierResponse.BatchNumber, hdb, tx); err != nil {
-				log.Error("error getting verifier result", "err", err)
-			}
-		}
-
 		results = append(results, verifierResponse)
 		delete(v.addedBatches, verifierResponse.BatchNumber)
 
@@ -348,7 +400,7 @@ func (v *LegacyExecutorVerifier) CancelAllRequestsUnsafe() {
 	v.cancelAllVerifications.Store(true)
 
 	for _, e := range v.executors {
-		// lets wait for all threads that are waiting to add to v.openRequests to finish
+		// let's wait for all threads that are waiting to add to v.openRequests to finish
 		for e.QueueLength() > 0 {
 			time.Sleep(1 * time.Millisecond)
 		}
@@ -372,6 +424,7 @@ func (v *LegacyExecutorVerifier) IsRequestAddedUnsafe(batch uint64) bool {
 }
 
 func (v *LegacyExecutorVerifier) WriteBatchToStream(batchNumber uint64, hdb *hermez_db.HermezDbReader, roTx kv.Tx) error {
+	log.Info("[Verifier] Writing batch to stream", "batch", batchNumber)
 	blks, err := hdb.GetL2BlockNosByBatch(batchNumber)
 	if err != nil {
 		return err
diff --git a/zk/rpcdaemon/types.go b/zk/rpcdaemon/types.go
index a6fcbb3b423..182959cf434 100644
--- a/zk/rpcdaemon/types.go
+++ b/zk/rpcdaemon/types.go
@@ -7,6 +7,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/holiman/uint256"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/params"
 	"github.com/ledgerwatch/erigon/zkevm/hex"
@@ -404,7 +405,7 @@ type Transaction struct {
 	BlockHash   *common.Hash    `json:"blockHash"`
 	BlockNumber *ArgUint64      `json:"blockNumber"`
 	TxIndex     *ArgUint64      `json:"transactionIndex"`
-	ChainID     ArgBig          `json:"chainId"`
+	ChainID     *ArgBig         `json:"chainId,omitempty"`
 	Type        ArgUint64       `json:"type"`
 	Receipt     *Receipt        `json:"receipt,omitempty"`
 	L2Hash      common.Hash     `json:"l2Hash,omitempty"`
@@ -432,6 +433,11 @@ func NewTransaction(
 
 	from, _ := GetSender(tx)
 	hash := common.HexToHash(tx.Hash().Hex())
+	cid := tx.GetChainID()
+	var cidAB *ArgBig
+	if cid.Cmp(uint256.NewInt(0)) != 0 {
+		cidAB = (*ArgBig)(cid.ToBig())
+	}
 	res := &Transaction{
 		Nonce:    ArgUint64(tx.GetNonce()),
 		GasPrice: ArgBig(*tx.GetPrice().ToBig()),
@@ -444,7 +450,7 @@ func NewTransaction(
 		S:        ArgBig(*s.ToBig()),
 		Hash:     hash,
 		From:     from,
-		ChainID:  ArgBig(*tx.GetChainID().ToBig()),
+		ChainID:  cidAB,
 		Type:     ArgUint64(tx.Type()),
 	}
 
diff --git a/zk/stages/stage_batches.go b/zk/stages/stage_batches.go
index 878068480c6..7215250ecd9 100644
--- a/zk/stages/stage_batches.go
+++ b/zk/stages/stage_batches.go
@@ -23,13 +23,12 @@ import (
 
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/eth/ethconfig"
-	"github.com/ledgerwatch/erigon/zk/datastream/proto/github.com/0xPolygonHermez/zkevm-node/state/datastream"
 	"github.com/ledgerwatch/erigon/zk/utils"
 	"github.com/ledgerwatch/log/v3"
 )
 
 const (
-	HIGHEST_KNOWN_FORK  = 9
+	HIGHEST_KNOWN_FORK  = 11
 	STAGE_PROGRESS_SAVE = 3000000
 )
 
@@ -73,12 +72,13 @@ type HermezDb interface {
 }
 
 type DatastreamClient interface {
-	ReadAllEntriesToChannel(bookmark *types.BookmarkProto) error
+	ReadAllEntriesToChannel() error
 	GetL2BlockChan() chan types.FullL2Block
 	GetBatchStartChan() chan types.BatchStart
 	GetGerUpdatesChan() chan types.GerUpdate
 	GetLastWrittenTimeAtomic() *atomic.Int64
 	GetStreamingAtomic() *atomic.Bool
+	GetProgressAtomic() *atomic.Uint64
 }
 
 type BatchesCfg struct {
@@ -152,27 +152,26 @@ func SpawnStageBatches(
 	}
 
 	startSyncTime := time.Now()
-	stopChan := make(chan struct{}, 1)
+	dsClientProgress := cfg.dsClient.GetProgressAtomic()
+	dsClientProgress.Store(stageProgressBlockNo)
 	// start routine to download blocks and push them in a channel
 	if !cfg.dsClient.GetStreamingAtomic().Load() {
 		log.Info(fmt.Sprintf("[%s] Starting stream", logPrefix), "startBlock", stageProgressBlockNo)
 		// this will download all blocks from datastream and push them in a channel
 		// if no error, break, else continue trying to get them
 		// Create bookmark
-		var bookmark *types.BookmarkProto
-		if stageProgressBlockNo == 0 {
-			bookmark = types.NewBookmarkProto(0, datastream.BookmarkType_BOOKMARK_TYPE_BATCH)
-		} else {
-			bookmark = types.NewBookmarkProto(stageProgressBlockNo, datastream.BookmarkType_BOOKMARK_TYPE_L2_BLOCK)
-		}
 
 		go func() {
 			log.Info(fmt.Sprintf("[%s] Started downloading L2Blocks routine", logPrefix))
 			defer log.Info(fmt.Sprintf("[%s] Finished downloading L2Blocks routine", logPrefix))
 
-			if err := cfg.dsClient.ReadAllEntriesToChannel(bookmark); err != nil {
-				log.Error(fmt.Sprintf("[%s] Error downloading blocks from datastream", logPrefix), "error", err)
-				stopChan <- struct{}{}
+			for i := 0; i < 5; i++ {
+				if err := cfg.dsClient.ReadAllEntriesToChannel(); err != nil {
+					log.Error("[datastream_client] Error downloading blocks from datastream", "error", err)
+					continue
+				}
+				// if it was overnot because of an error, don't try to reconnect
+				break
 			}
 		}()
 	}
@@ -229,8 +228,6 @@ LOOP:
 		// if download routine finished, should continue to read from channel until it's empty
 		// if both download routine stopped and channel empty - stop loop
 		select {
-		case <-stopChan:
-			break LOOP
 		case batchStart := <-batchStartChan:
 			// check if the batch is invalid so that we can replicate this over in the stream
 			// when we re-populate it
@@ -346,6 +343,7 @@ LOOP:
 			if err := writeL2Block(eriDb, hermezDb, &l2Block, highestL1InfoTreeIndex); err != nil {
 				return fmt.Errorf("writeL2Block error: %v", err)
 			}
+			dsClientProgress.Store(l2Block.L2BlockNumber)
 
 			// make sure to capture the l1 info tree index changes so we can store progress
 			if uint64(l2Block.L1InfoTreeIndex) > highestL1InfoTreeIndex {
@@ -383,7 +381,7 @@ LOOP:
 				// stop the current iteration of the stage
 				lastWrittenTs := lastWrittenTimeAtomic.Load()
 				timePassedAfterlastBlock := time.Since(time.Unix(0, lastWrittenTs))
-				if streamingAtomic.Load() && timePassedAfterlastBlock > cfg.zkCfg.DatastreamNewBlockTimeout {
+				if timePassedAfterlastBlock > cfg.zkCfg.DatastreamNewBlockTimeout {
 					log.Info(fmt.Sprintf("[%s] No new blocks in %d miliseconds. Ending the stage.", logPrefix, timePassedAfterlastBlock.Milliseconds()), "lastBlockHeight", lastBlockHeight)
 					endLoop = true
 				}
@@ -397,7 +395,7 @@ LOOP:
 					// 	break
 					// }
 
-					if !cfg.dsClient.GetStreamingAtomic().Load() {
+					if !streamingAtomic.Load() {
 						log.Info(fmt.Sprintf("[%s] Datastream disconnected. Ending the stage.", logPrefix))
 						break LOOP
 					}
diff --git a/zk/stages/stage_dataStreamCatchup.go b/zk/stages/stage_dataStreamCatchup.go
index 6d5c3b183d0..0e25e858780 100644
--- a/zk/stages/stage_dataStreamCatchup.go
+++ b/zk/stages/stage_dataStreamCatchup.go
@@ -20,14 +20,16 @@ type DataStreamCatchupCfg struct {
 	stream        *datastreamer.StreamServer
 	chainId       uint64
 	streamVersion int
+	hasExecutors  bool
 }
 
-func StageDataStreamCatchupCfg(stream *datastreamer.StreamServer, db kv.RwDB, chainId uint64, streamVersion int) DataStreamCatchupCfg {
+func StageDataStreamCatchupCfg(stream *datastreamer.StreamServer, db kv.RwDB, chainId uint64, streamVersion int, hasExecutors bool) DataStreamCatchupCfg {
 	return DataStreamCatchupCfg{
 		stream:        stream,
 		db:            db,
 		chainId:       chainId,
 		streamVersion: streamVersion,
+		hasExecutors:  hasExecutors,
 	}
 }
 
@@ -59,7 +61,7 @@ func SpawnStageDataStreamCatchup(
 		createdTx = true
 	}
 
-	finalBlockNumber, err := CatchupDatastream(logPrefix, tx, stream, cfg.chainId, cfg.streamVersion)
+	finalBlockNumber, err := CatchupDatastream(logPrefix, tx, stream, cfg.chainId, cfg.streamVersion, cfg.hasExecutors)
 	if err != nil {
 		return err
 	}
@@ -75,7 +77,7 @@ func SpawnStageDataStreamCatchup(
 	return err
 }
 
-func CatchupDatastream(logPrefix string, tx kv.RwTx, stream *datastreamer.StreamServer, chainId uint64, streamVersion int) (uint64, error) {
+func CatchupDatastream(logPrefix string, tx kv.RwTx, stream *datastreamer.StreamServer, chainId uint64, streamVersion int, hasExecutors bool) (uint64, error) {
 	srv := server.NewDataStreamServer(stream, chainId)
 	reader := hermez_db.NewHermezDbReader(tx)
 
@@ -84,13 +86,28 @@ func CatchupDatastream(logPrefix string, tx kv.RwTx, stream *datastreamer.Stream
 	var latestBatch uint64
 	var finalBlockNumber uint64
 	if sequencer.IsSequencer() {
-		latestBatch, err = stages.GetStageProgress(tx, stages.SequenceExecutorVerify)
-		if err != nil {
-			return 0, err
-		}
-		finalBlockNumber, err = reader.GetHighestBlockInBatch(latestBatch)
-		if err != nil {
-			return 0, err
+		if hasExecutors {
+			latestBatch, err = stages.GetStageProgress(tx, stages.SequenceExecutorVerify)
+			if err != nil {
+				return 0, err
+			}
+			finalBlockNumber, err = reader.GetHighestBlockInBatch(latestBatch)
+			if err != nil {
+				return 0, err
+			}
+		} else {
+			// without execution we save progress block by block and can populate an unfinished batch to stream
+			// otherwise we get a batch gap in the stream because a few blocks don't get written to the stream
+			// and then execution continues from the middle of the batch
+			latestBatch, err = stages.GetStageProgress(tx, stages.HighestSeenBatchNumber)
+			if err != nil {
+				return 0, err
+			}
+			finalBlockNumber, err = stages.GetStageProgress(tx, stages.Execution)
+			if err != nil {
+				return 0, err
+			}
+
 		}
 	} else {
 		finalBlockNumber, err = stages.GetStageProgress(tx, stages.Execution)
diff --git a/zk/stages/stage_l1_info_tree.go b/zk/stages/stage_l1_info_tree.go
index eabd09a5632..083bffa783b 100644
--- a/zk/stages/stage_l1_info_tree.go
+++ b/zk/stages/stage_l1_info_tree.go
@@ -95,12 +95,14 @@ LOOP:
 	sort.Slice(allLogs, func(i, j int) bool {
 		l1 := allLogs[i]
 		l2 := allLogs[j]
-		if l1.BlockNumber == l2.BlockNumber {
-			// sort by index in the case of a matching block number
+		// first sort by block number and if equal then by tx index
+		if l1.BlockNumber != l2.BlockNumber {
+			return l1.BlockNumber < l2.BlockNumber
+		}
+		if l1.TxIndex != l2.TxIndex {
 			return l1.TxIndex < l2.TxIndex
 		}
-		// otherwise sort by block number
-		return l1.BlockNumber < l2.BlockNumber
+		return l1.Index < l2.Index
 	})
 
 	// chunk the logs into batches, so we don't overload the RPC endpoints too much at once
@@ -155,7 +157,14 @@ LOOP:
 				if err != nil {
 					return err
 				}
-				log.Trace("New L1 Index", "index", latestUpdate.Index, "root", newRoot.String())
+				log.Debug("New L1 Index",
+					"index", latestUpdate.Index,
+					"root", newRoot.String(),
+					"mainnet", latestUpdate.MainnetExitRoot.String(),
+					"rollup", latestUpdate.RollupExitRoot.String(),
+					"ger", latestUpdate.GER.String(),
+					"parent", latestUpdate.ParentHash.String(),
+				)
 
 				err = hermezDb.WriteL1InfoTreeRoot(common.BytesToHash(newRoot[:]), latestUpdate.Index)
 				if err != nil {
diff --git a/zk/stages/stage_l1_sequencer_sync.go b/zk/stages/stage_l1_sequencer_sync.go
index da29d9778c3..4b821cc9491 100644
--- a/zk/stages/stage_l1_sequencer_sync.go
+++ b/zk/stages/stage_l1_sequencer_sync.go
@@ -100,7 +100,7 @@ Loop:
 				case contracts.CreateNewRollupTopic:
 					rollupId := l.Topics[1].Big().Uint64()
 					if rollupId != cfg.zkCfg.L1RollupId {
-						return fmt.Errorf("received CreateNewRollupTopic for unknown rollup id: %v", rollupId)
+						continue
 					}
 					rollupTypeBytes := l.Data[0:32]
 					rollupType := new(big.Int).SetBytes(rollupTypeBytes).Uint64()
@@ -117,7 +117,6 @@ Loop:
 				case contracts.UpdateRollupTopic:
 					rollupId := l.Topics[1].Big().Uint64()
 					if rollupId != cfg.zkCfg.L1RollupId {
-						log.Warn("received UpdateRollupTopic for unknown rollup id", "rollupId", rollupId)
 						continue
 					}
 					newRollupBytes := l.Data[0:32]
diff --git a/zk/stages/stage_sequence_execute.go b/zk/stages/stage_sequence_execute.go
index b83741fd857..51caec5ceae 100644
--- a/zk/stages/stage_sequence_execute.go
+++ b/zk/stages/stage_sequence_execute.go
@@ -19,7 +19,6 @@ import (
 	"github.com/ledgerwatch/erigon/eth/stagedsync"
 	"github.com/ledgerwatch/erigon/eth/stagedsync/stages"
 	"github.com/ledgerwatch/erigon/zk"
-	"github.com/ledgerwatch/erigon/zk/datastream/server"
 	"github.com/ledgerwatch/erigon/zk/l1_data"
 	zktx "github.com/ledgerwatch/erigon/zk/tx"
 	"github.com/ledgerwatch/erigon/zk/utils"
@@ -61,7 +60,7 @@ func SpawnSequencingStage(
 		return err
 	}
 
-	isLastBatchFinished, err := sdb.hermezDb.GetIsBatchFullyProcessed(lastBatch)
+	isLastBatchPariallyProcessed, err := sdb.hermezDb.GetIsBatchPartiallyProcessed(lastBatch)
 	if err != nil {
 		return err
 	}
@@ -72,8 +71,7 @@ func SpawnSequencingStage(
 	}
 
 	getHeader := func(hash common.Hash, number uint64) *types.Header { return rawdb.ReadHeader(sdb.tx, hash, number) }
-	hasExecutorForThisBatch := isLastBatchFinished && cfg.zk.HasExecutors()
-	datastreamServer := server.NewDataStreamServer(cfg.stream, cfg.chainConfig.ChainID.Uint64())
+	hasExecutorForThisBatch := !isLastBatchPariallyProcessed && cfg.zk.HasExecutors()
 
 	// injected batch
 	if executionAt == 0 {
@@ -90,16 +88,12 @@ func SpawnSequencingStage(
 		getHashFn := core.GetHashFn(header, getHeader)
 		blockContext := core.NewEVMBlockContext(header, getHashFn, cfg.engine, &cfg.zk.AddressSequencer)
 
-		if err = processInjectedInitialBatch(ctx, cfg, s, sdb, forkId, header, parentBlock, &blockContext); err != nil {
+		if err = processInjectedInitialBatch(ctx, cfg, s, sdb, forkId, header, parentBlock, &blockContext, l1Recovery); err != nil {
 			return err
 		}
 
 		// write the batch directly to the stream
-		if err = datastreamServer.WriteBlocksToStream(tx, sdb.hermezDb.HermezDbReader, injectedBatchBlockNumber, injectedBatchBlockNumber, logPrefix); err != nil {
-			return err
-		}
-
-		if err = sdb.hermezDb.WriteIsBatchFullyProcessed(injectedBatchBatchNumber); err != nil {
+		if err = cfg.datastreamServer.WriteBlocksToStream(tx, sdb.hermezDb.HermezDbReader, injectedBatchBlockNumber, injectedBatchBlockNumber, logPrefix); err != nil {
 			return err
 		}
 
@@ -121,6 +115,7 @@ func SpawnSequencingStage(
 
 	var addedTransactions []types.Transaction
 	var addedReceipts []*types.Receipt
+	var addedExecutionResults []*core.ExecutionResult
 	var clonedBatchCounters *vm.BatchCounterCollector
 
 	var decodedBlock zktx.DecodedBatchL2Data
@@ -137,12 +132,12 @@ func SpawnSequencingStage(
 
 	thisBatch := lastBatch
 	// if last batch finished - start a new one
-	if isLastBatchFinished {
+	if !isLastBatchPariallyProcessed {
 		thisBatch++
 	}
 
 	var intermediateUsedCounters *vm.Counters
-	if !isLastBatchFinished {
+	if isLastBatchPariallyProcessed {
 		intermediateCountersMap, found, err := sdb.hermezDb.GetBatchCounters(lastBatch)
 		if err != nil {
 			return err
@@ -225,6 +220,12 @@ func SpawnSequencingStage(
 			if err = sdb.hermezDb.WriteInvalidBatch(thisBatch); err != nil {
 				return err
 			}
+			if err = sdb.hermezDb.WriteBatchCounters(thisBatch, map[string]int{}); err != nil {
+				return err
+			}
+			if err = sdb.hermezDb.DeleteIsBatchPartiallyProcessed(thisBatch); err != nil {
+				return err
+			}
 			if err = stages.SaveStageProgress(tx, stages.HighestSeenBatchNumber, thisBatch); err != nil {
 				return err
 			}
@@ -240,7 +241,7 @@ func SpawnSequencingStage(
 		}
 	}
 
-	if isLastBatchFinished {
+	if !isLastBatchPariallyProcessed {
 		log.Info(fmt.Sprintf("[%s] Starting batch %d...", logPrefix, thisBatch))
 	} else {
 		log.Info(fmt.Sprintf("[%s] Continuing unfinished batch %d from block %d", logPrefix, thisBatch, executionAt))
@@ -272,7 +273,7 @@ func SpawnSequencingStage(
 			return err
 		}
 
-		log.Info(fmt.Sprintf("[%s] Starting block %d...", logPrefix, blockNumber+1))
+		log.Info(fmt.Sprintf("[%s] Starting block %d (forkid %v)...", logPrefix, blockNumber+1, forkId))
 
 		reRunBlockAfterOverflow := blockNumber == lastStartedBn
 		lastStartedBn = blockNumber
@@ -281,6 +282,7 @@ func SpawnSequencingStage(
 			clonedBatchCounters = batchCounters.Clone()
 			addedTransactions = []types.Transaction{}
 			addedReceipts = []*types.Receipt{}
+			addedExecutionResults = []*core.ExecutionResult{}
 			effectiveGases = []uint8{}
 			header, parentBlock, err = prepareHeader(tx, blockNumber, deltaTimestamp, limboHeaderTimestamp, forkId, nextBatchData.Coinbase)
 			if err != nil {
@@ -288,7 +290,7 @@ func SpawnSequencingStage(
 			}
 
 			// run this only once the first time, do not add it on rerun
-			if batchDataOverflow = blockDataSizeChecker.AddBlockStartData(uint16(forkId), uint32(prevHeader.Time-header.Time), uint32(l1InfoIndex)); batchDataOverflow {
+			if batchDataOverflow = blockDataSizeChecker.AddBlockStartData(uint32(prevHeader.Time-header.Time), uint32(l1InfoIndex)); batchDataOverflow {
 				log.Info(fmt.Sprintf("[%s] BatchL2Data limit reached. Stopping.", logPrefix), "blockNumber", blockNumber)
 				break
 			}
@@ -398,6 +400,7 @@ func SpawnSequencingStage(
 					}
 
 					var receipt *types.Receipt
+					var execResult *core.ExecutionResult
 					for i, transaction := range blockTransactions {
 						var effectiveGas uint8
 
@@ -407,13 +410,8 @@ func SpawnSequencingStage(
 							effectiveGas = DeriveEffectiveGasPrice(cfg, transaction)
 						}
 
-						// run this only once the first time, do not add it on rerun
-						if batchDataOverflow, err = blockDataSizeChecker.AddTransactionData(transaction, uint16(forkId), effectiveGas); err != nil {
-							return err
-						}
-
 						if !batchDataOverflow {
-							receipt, overflow, err = attemptAddTransaction(cfg, sdb, ibs, batchCounters, &blockContext, header, transaction, effectiveGas, l1Recovery, forkId, l1InfoIndex)
+							receipt, execResult, overflow, err = attemptAddTransaction(cfg, sdb, ibs, batchCounters, &blockContext, header, transaction, effectiveGas, l1Recovery, forkId, l1InfoIndex, blockDataSizeChecker)
 							if err != nil {
 								if limboRecovery {
 									panic("limbo transaction has already been executed once so they must not fail while re-executing")
@@ -475,6 +473,7 @@ func SpawnSequencingStage(
 
 						addedTransactions = append(addedTransactions, transaction)
 						addedReceipts = append(addedReceipts, receipt)
+						addedExecutionResults = append(addedExecutionResults, execResult)
 						effectiveGases = append(effectiveGases, effectiveGas)
 
 						hasAnyTransactionsInThisBatch = true
@@ -504,7 +503,7 @@ func SpawnSequencingStage(
 		} else {
 			for idx, transaction := range addedTransactions {
 				effectiveGas := effectiveGases[idx]
-				receipt, innerOverflow, err := attemptAddTransaction(cfg, sdb, ibs, batchCounters, &blockContext, header, transaction, effectiveGas, false, forkId, l1InfoIndex)
+				receipt, execResult, innerOverflow, err := attemptAddTransaction(cfg, sdb, ibs, batchCounters, &blockContext, header, transaction, effectiveGas, false, forkId, l1InfoIndex, blockDataSizeChecker)
 				if err != nil {
 					return err
 				}
@@ -513,6 +512,7 @@ func SpawnSequencingStage(
 					panic(fmt.Sprintf("overflowed twice during execution while adding tx with index %d", idx))
 				}
 				addedReceipts[idx] = receipt
+				addedExecutionResults[idx] = execResult
 			}
 			runLoopBlocks = false // close the batch because there are no counters left
 		}
@@ -521,7 +521,7 @@ func SpawnSequencingStage(
 			return err
 		}
 
-		block, err = doFinishBlockAndUpdateState(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, thisBatch, ger, l1BlockHash, addedTransactions, addedReceipts, effectiveGases, infoTreeIndexProgress)
+		block, err = doFinishBlockAndUpdateState(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, thisBatch, ger, l1BlockHash, addedTransactions, addedReceipts, addedExecutionResults, effectiveGases, infoTreeIndexProgress, l1Recovery)
 		if err != nil {
 			return err
 		}
@@ -551,7 +551,12 @@ func SpawnSequencingStage(
 				return err
 			}
 
-			if err = datastreamServer.WriteBlockToStream(logPrefix, tx, sdb.hermezDb, thisBatch, lastBatch, thisBlockNumber); err != nil {
+			err = sdb.hermezDb.WriteIsBatchPartiallyProcessed(thisBatch)
+			if err != nil {
+				return err
+			}
+
+			if err = cfg.datastreamServer.WriteBlockToStream(logPrefix, tx, sdb.hermezDb, thisBatch, lastBatch, thisBlockNumber); err != nil {
 				return err
 			}
 
@@ -585,7 +590,7 @@ func SpawnSequencingStage(
 		return err
 	}
 
-	if err = sdb.hermezDb.WriteIsBatchFullyProcessed(thisBatch); err != nil {
+	if err = sdb.hermezDb.DeleteIsBatchPartiallyProcessed(thisBatch); err != nil {
 		return err
 	}
 
@@ -602,7 +607,7 @@ func SpawnSequencingStage(
 	log.Info(fmt.Sprintf("[%s] Finish batch %d...", logPrefix, thisBatch))
 
 	if !hasExecutorForThisBatch {
-		if err = datastreamServer.WriteBatchEnd(logPrefix, tx, sdb.hermezDb, thisBatch, lastBatch, block.Root()); err != nil {
+		if err = cfg.datastreamServer.WriteBatchEnd(logPrefix, tx, sdb.hermezDb, thisBatch, lastBatch, block.Root()); err != nil {
 			return err
 		}
 	}
diff --git a/zk/stages/stage_sequence_execute_blocks.go b/zk/stages/stage_sequence_execute_blocks.go
index 2570a075e15..7719c0a0350 100644
--- a/zk/stages/stage_sequence_execute_blocks.go
+++ b/zk/stages/stage_sequence_execute_blocks.go
@@ -20,8 +20,8 @@ import (
 	"github.com/ledgerwatch/erigon/zk/erigon_db"
 	"github.com/ledgerwatch/erigon/zk/hermez_db"
 	zktypes "github.com/ledgerwatch/erigon/zk/types"
-	"github.com/ledgerwatch/secp256k1"
 	"github.com/ledgerwatch/erigon/zk/utils"
+	"github.com/ledgerwatch/secp256k1"
 )
 
 func handleStateForNewBlockStarting(
@@ -81,7 +81,9 @@ func finaliseBlock(
 	l1BlockHash common.Hash,
 	transactions []types.Transaction,
 	receipts types.Receipts,
+	execResults []*core.ExecutionResult,
 	effectiveGases []uint8,
+	l1Recovery bool,
 ) (*types.Block, error) {
 	stateWriter := state.NewPlainStateWriter(sdb.tx, sdb.tx, newHeader.Number.Uint64()).SetAccumulator(accumulator)
 	chainReader := stagedsync.ChainReader{
@@ -108,17 +110,25 @@ func finaliseBlock(
 				return nil, err
 			}
 		}
+		localReceipt := core.CreateReceiptForBlockInfoTree(receipts[i], cfg.chainConfig, newHeader.Number.Uint64(), execResults[i])
 		txInfos = append(txInfos, blockinfo.ExecutedTxInfo{
 			Tx:                tx,
 			EffectiveGasPrice: effectiveGases[i],
-			Receipt:           receipts[i],
+			Receipt:           localReceipt,
 			Signer:            &from,
 		})
 	}
+
 	if err := postBlockStateHandling(cfg, ibs, sdb.hermezDb, newHeader, ger, l1BlockHash, parentBlock.Root(), txInfos); err != nil {
 		return nil, err
 	}
 
+	if l1Recovery {
+		for i, receipt := range receipts {
+			core.ProcessReceiptForBlockExecution(receipt, sdb.hermezDb.HermezDbReader, cfg.chainConfig, newHeader.Number.Uint64(), newHeader, transactions[i])
+		}
+	}
+
 	finalBlock, finalTransactions, finalReceipts, err := core.FinalizeBlockExecutionWithHistoryWrite(
 		cfg.engine,
 		sdb.stateReader,
diff --git a/zk/stages/stage_sequence_execute_injected_batch.go b/zk/stages/stage_sequence_execute_injected_batch.go
index bc55f5460e6..852ecfd5b9b 100644
--- a/zk/stages/stage_sequence_execute_injected_batch.go
+++ b/zk/stages/stage_sequence_execute_injected_batch.go
@@ -5,6 +5,7 @@ import (
 
 	"errors"
 
+	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/state"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/core/vm"
@@ -29,6 +30,7 @@ func processInjectedInitialBatch(
 	header *types.Header,
 	parentBlock *types.Block,
 	blockContext *evmtypes.BlockContext,
+	l1Recovery bool,
 ) error {
 	injected, err := sdb.hermezDb.GetL1InjectedBatch(0)
 	if err != nil {
@@ -61,16 +63,17 @@ func processInjectedInitialBatch(
 		return err
 	}
 
-	txn, receipt, effectiveGas, err := handleInjectedBatch(cfg, sdb, ibs, blockContext, injected, header, parentBlock, forkId)
+	txn, receipt, execResult, effectiveGas, err := handleInjectedBatch(cfg, sdb, ibs, blockContext, injected, header, parentBlock, forkId)
 	if err != nil {
 		return err
 	}
 
 	txns := types.Transactions{*txn}
 	receipts := types.Receipts{receipt}
+	execResults := []*core.ExecutionResult{execResult}
 	effectiveGases := []uint8{effectiveGas}
 
-	_, err = doFinishBlockAndUpdateState(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, injectedBatchNumber, injected.LastGlobalExitRoot, injected.L1ParentHash, txns, receipts, effectiveGases, 0)
+	_, err = doFinishBlockAndUpdateState(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, injectedBatchNumber, injected.LastGlobalExitRoot, injected.L1ParentHash, txns, receipts, execResults, effectiveGases, 0, l1Recovery)
 	return err
 }
 
@@ -83,26 +86,26 @@ func handleInjectedBatch(
 	header *types.Header,
 	parentBlock *types.Block,
 	forkId uint64,
-) (*types.Transaction, *types.Receipt, uint8, error) {
+) (*types.Transaction, *types.Receipt, *core.ExecutionResult, uint8, error) {
 	decodedBlocks, err := zktx.DecodeBatchL2Blocks(injected.Transaction, forkId)
 	if err != nil {
-		return nil, nil, 0, err
+		return nil, nil, nil, 0, err
 	}
 	if len(decodedBlocks) == 0 || len(decodedBlocks) > 1 {
-		return nil, nil, 0, errors.New("expected 1 block for the injected batch")
+		return nil, nil, nil, 0, errors.New("expected 1 block for the injected batch")
 	}
 	if len(decodedBlocks[0].Transactions) == 0 {
-		return nil, nil, 0, errors.New("expected 1 transaction in the injected batch")
+		return nil, nil, nil, 0, errors.New("expected 1 transaction in the injected batch")
 	}
 
 	batchCounters := vm.NewBatchCounterCollector(sdb.smt.GetDepth(), uint16(forkId), cfg.zk.VirtualCountersSmtReduction, cfg.zk.ShouldCountersBeUnlimited(false), nil)
 
 	// process the tx and we can ignore the counters as an overflow at this stage means no network anyway
 	effectiveGas := DeriveEffectiveGasPrice(cfg, decodedBlocks[0].Transactions[0])
-	receipt, _, err := attemptAddTransaction(cfg, sdb, ibs, batchCounters, blockContext, header, decodedBlocks[0].Transactions[0], effectiveGas, false, forkId, 0 /* use 0 for l1InfoIndex in injected batch */)
+	receipt, execResult, _, err := attemptAddTransaction(cfg, sdb, ibs, batchCounters, blockContext, header, decodedBlocks[0].Transactions[0], effectiveGas, false, forkId, 0 /* use 0 for l1InfoIndex in injected batch */, nil)
 	if err != nil {
-		return nil, nil, 0, err
+		return nil, nil, nil, 0, err
 	}
 
-	return &decodedBlocks[0].Transactions[0], receipt, effectiveGas, nil
+	return &decodedBlocks[0].Transactions[0], receipt, execResult, effectiveGas, nil
 }
diff --git a/zk/stages/stage_sequence_execute_transactions.go b/zk/stages/stage_sequence_execute_transactions.go
index 3115f45ec45..3d160034eb8 100644
--- a/zk/stages/stage_sequence_execute_transactions.go
+++ b/zk/stages/stage_sequence_execute_transactions.go
@@ -10,11 +10,9 @@ import (
 	"github.com/ledgerwatch/erigon-lib/kv"
 
 	"bytes"
-	"errors"
 	"io"
 
 	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/ledgerwatch/erigon-lib/chain"
 	types2 "github.com/ledgerwatch/erigon-lib/types"
 	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/state"
@@ -25,6 +23,7 @@ import (
 	"github.com/ledgerwatch/erigon/zk/hermez_db"
 	zktx "github.com/ledgerwatch/erigon/zk/tx"
 	"github.com/ledgerwatch/erigon/zk/utils"
+	"github.com/ledgerwatch/log/v3"
 )
 
 func getNextPoolTransactions(cfg SequenceBlockCfg, executionAt, forkId uint64, alreadyYielded mapset.Set[[32]byte]) ([]types.Transaction, error) {
@@ -184,14 +183,29 @@ func attemptAddTransaction(
 	effectiveGasPrice uint8,
 	l1Recovery bool,
 	forkId, l1InfoIndex uint64,
-) (*types.Receipt, bool, error) {
+	blockDataSizeChecker *BlockDataChecker,
+) (*types.Receipt, *core.ExecutionResult, bool, error) {
 	txCounters := vm.NewTransactionCounter(transaction, sdb.smt.GetDepth(), uint16(forkId), cfg.zk.VirtualCountersSmtReduction, cfg.zk.ShouldCountersBeUnlimited(l1Recovery))
 	overflow, err := batchCounters.AddNewTransactionCounters(txCounters)
+
+	// run this only once the first time, do not add it on rerun
+	var batchDataOverflow bool
+	if blockDataSizeChecker != nil {
+		txL2Data, err := txCounters.GetL2DataCache()
+		if err != nil {
+			return nil, nil, false, err
+		}
+		batchDataOverflow = blockDataSizeChecker.AddTransactionData(txL2Data)
+		if batchDataOverflow {
+			log.Info("BatchL2Data limit reached. Not adding last transaction", "txHash", transaction.Hash())
+		}
+	}
 	if err != nil {
-		return nil, false, err
+		return nil, nil, false, err
 	}
-	if overflow && !l1Recovery {
-		return nil, true, nil
+	anyOverflow := overflow || batchDataOverflow
+	if anyOverflow && !l1Recovery {
+		return nil, nil, true, nil
 	}
 
 	gasPool := new(core.GasPool).AddGas(transactionGasLimit)
@@ -218,26 +232,22 @@ func attemptAddTransaction(
 	)
 
 	if err != nil {
-		return nil, false, err
-	}
-
-	if forkId <= uint64(chain.ForkID7Etrog) && errors.Is(execResult.Err, vm.ErrUnsupportedPrecompile) {
-		receipt.Status = 1
+		return nil, nil, false, err
 	}
 
 	// we need to keep hold of the effective percentage used
 	// todo [zkevm] for now we're hard coding to the max value but we need to calc this properly
 	if err = sdb.hermezDb.WriteEffectiveGasPricePercentage(transaction.Hash(), effectiveGasPrice); err != nil {
-		return nil, false, err
+		return nil, nil, false, err
 	}
 
 	err = txCounters.ProcessTx(ibs, execResult.ReturnData)
 	if err != nil {
-		return nil, false, err
+		return nil, nil, false, err
 	}
 
 	// now that we have executed we can check again for an overflow
 	overflow, err = batchCounters.CheckForOverflow(l1InfoIndex != 0)
 
-	return receipt, overflow, err
+	return receipt, execResult, overflow, err
 }
diff --git a/zk/stages/stage_sequence_execute_utils.go b/zk/stages/stage_sequence_execute_utils.go
index 8db121cc9af..bf9343c4080 100644
--- a/zk/stages/stage_sequence_execute_utils.go
+++ b/zk/stages/stage_sequence_execute_utils.go
@@ -18,6 +18,7 @@ import (
 	"github.com/ledgerwatch/erigon-lib/chain"
 	"github.com/ledgerwatch/erigon/common/math"
 	"github.com/ledgerwatch/erigon/consensus"
+	"github.com/ledgerwatch/erigon/core"
 	"github.com/ledgerwatch/erigon/core/rawdb"
 	"github.com/ledgerwatch/erigon/core/state"
 	"github.com/ledgerwatch/erigon/core/types"
@@ -31,6 +32,7 @@ import (
 	"github.com/ledgerwatch/erigon/turbo/services"
 	"github.com/ledgerwatch/erigon/turbo/shards"
 	"github.com/ledgerwatch/erigon/turbo/stages/headerdownload"
+	"github.com/ledgerwatch/erigon/zk/datastream/server"
 	"github.com/ledgerwatch/erigon/zk/hermez_db"
 	"github.com/ledgerwatch/erigon/zk/tx"
 	zktx "github.com/ledgerwatch/erigon/zk/tx"
@@ -73,13 +75,14 @@ type SequenceBlockCfg struct {
 	accumulator   *shards.Accumulator
 	blockReader   services.FullBlockReader
 
-	dirs      datadir.Dirs
-	historyV3 bool
-	syncCfg   ethconfig.Sync
-	genesis   *types.Genesis
-	agg       *libstate.Aggregator
-	stream    *datastreamer.StreamServer
-	zk        *ethconfig.Zk
+	dirs             datadir.Dirs
+	historyV3        bool
+	syncCfg          ethconfig.Sync
+	genesis          *types.Genesis
+	agg              *libstate.Aggregator
+	stream           *datastreamer.StreamServer
+	datastreamServer *server.DataStreamServer
+	zk               *ethconfig.Zk
 
 	txPool   *txpool.TxPool
 	txPoolDb kv.RwDB
@@ -109,27 +112,29 @@ func StageSequenceBlocksCfg(
 	txPool *txpool.TxPool,
 	txPoolDb kv.RwDB,
 ) SequenceBlockCfg {
+
 	return SequenceBlockCfg{
-		db:            db,
-		prune:         pm,
-		batchSize:     batchSize,
-		changeSetHook: changeSetHook,
-		chainConfig:   chainConfig,
-		engine:        engine,
-		zkVmConfig:    vmConfig,
-		dirs:          dirs,
-		accumulator:   accumulator,
-		stateStream:   stateStream,
-		badBlockHalt:  badBlockHalt,
-		blockReader:   blockReader,
-		genesis:       genesis,
-		historyV3:     historyV3,
-		syncCfg:       syncCfg,
-		agg:           agg,
-		stream:        stream,
-		zk:            zk,
-		txPool:        txPool,
-		txPoolDb:      txPoolDb,
+		db:               db,
+		prune:            pm,
+		batchSize:        batchSize,
+		changeSetHook:    changeSetHook,
+		chainConfig:      chainConfig,
+		engine:           engine,
+		zkVmConfig:       vmConfig,
+		dirs:             dirs,
+		accumulator:      accumulator,
+		stateStream:      stateStream,
+		badBlockHalt:     badBlockHalt,
+		blockReader:      blockReader,
+		genesis:          genesis,
+		historyV3:        historyV3,
+		syncCfg:          syncCfg,
+		agg:              agg,
+		stream:           stream,
+		datastreamServer: server.NewDataStreamServer(stream, chainConfig.ChainID.Uint64()),
+		zk:               zk,
+		txPool:           txPool,
+		txPoolDb:         txPoolDb,
 	}
 }
 
@@ -366,8 +371,10 @@ func doFinishBlockAndUpdateState(
 	l1BlockHash common.Hash,
 	transactions []types.Transaction,
 	receipts types.Receipts,
+	execResults []*core.ExecutionResult,
 	effectiveGases []uint8,
 	l1InfoIndex uint64,
+	l1Recovery bool,
 ) (*types.Block, error) {
 	thisBlockNumber := header.Number.Uint64()
 
@@ -375,7 +382,7 @@ func doFinishBlockAndUpdateState(
 		cfg.accumulator.StartChange(thisBlockNumber, header.Hash(), nil, false)
 	}
 
-	block, err := finaliseBlock(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, thisBatch, cfg.accumulator, ger, l1BlockHash, transactions, receipts, effectiveGases)
+	block, err := finaliseBlock(ctx, cfg, s, sdb, ibs, header, parentBlock, forkId, thisBatch, cfg.accumulator, ger, l1BlockHash, transactions, receipts, execResults, effectiveGases, l1Recovery)
 	if err != nil {
 		return nil, err
 	}
@@ -447,44 +454,43 @@ func checkForBadBatch(
 	return false, nil
 }
 
-var (
-	LIMIT_128_KB = uint64(128 * 1024)
-)
+// hard coded to match in with the smart contract
+// https://github.com/0xPolygonHermez/zkevm-contracts/blob/73758334f8568b74e9493fcc530b442bd73325dc/contracts/PolygonZkEVM.sol#L119C63-L119C69
+const LIMIT_120_KB = 120_000
 
 type BlockDataChecker struct {
-	limit uint64 // amount of bytes
-	bytes []byte
+	limit   uint64 // limit amount of bytes
+	counter uint64 // counter amount of bytes
 }
 
 func NewBlockDataChecker() *BlockDataChecker {
 	return &BlockDataChecker{
-		limit: LIMIT_128_KB,
-		bytes: make([]byte, 0),
+		limit:   LIMIT_120_KB,
+		counter: 0,
 	}
 }
 
 // adds bytes amounting to the block data and checks if the limit is reached
 // if the limit is reached, the data is not added, so this can be reused again for next check
-func (bdc *BlockDataChecker) AddBlockStartData(forkId uint16, deltaTimestamp, l1InfoTreeIndex uint32) bool {
-	newBytes := tx.GenerateStartBlockBatchL2Data(forkId, deltaTimestamp, l1InfoTreeIndex)
-
-	if uint64(len(bdc.bytes)+len(newBytes)) > bdc.limit {
+func (bdc *BlockDataChecker) AddBlockStartData(deltaTimestamp, l1InfoTreeIndex uint32) bool {
+	blockStartBytesAmount := tx.START_BLOCK_BATCH_L2_DATA_SIZE // tx.GenerateStartBlockBatchL2Data(deltaTimestamp, l1InfoTreeIndex) returns 65 long byte array
+	// add in the changeL2Block transaction
+	if bdc.counter+blockStartBytesAmount > bdc.limit {
 		return true
 	}
 
-	bdc.bytes = append(bdc.bytes, newBytes...)
+	bdc.counter += blockStartBytesAmount
+
 	return false
 }
 
-func (bdc *BlockDataChecker) AddTransactionData(transaction types.Transaction, forkId uint16, effectiveGasPrice uint8) (bool, error) {
-	encoded, err := tx.TransactionToL2Data(transaction, forkId, effectiveGasPrice)
-	if err != nil {
-		return false, err
-	}
-	if uint64(len(bdc.bytes)+len(encoded)) > bdc.limit {
-		return true, nil
+func (bdc *BlockDataChecker) AddTransactionData(txL2Data []byte) bool {
+	encodedLen := uint64(len(txL2Data))
+	if bdc.counter+uint64(encodedLen) > bdc.limit {
+		return true
 	}
 
-	bdc.bytes = append(bdc.bytes, encoded...)
-	return false, nil
+	bdc.counter += encodedLen
+
+	return false
 }
diff --git a/zk/stages/stage_sequencer_executor_verify.go b/zk/stages/stage_sequencer_executor_verify.go
index 6500b128a7a..4bed70e9e1c 100644
--- a/zk/stages/stage_sequencer_executor_verify.go
+++ b/zk/stages/stage_sequencer_executor_verify.go
@@ -90,7 +90,7 @@ func SpawnSequencerExecutorVerifyStage(
 		return err
 	}
 
-	isBatchFinished, err := hermezDb.GetIsBatchFullyProcessed(latestBatch)
+	isBatchPartial, err := hermezDb.GetIsBatchPartiallyProcessed(latestBatch)
 	if err != nil {
 		return err
 	}
@@ -102,7 +102,7 @@ func SpawnSequencerExecutorVerifyStage(
 	// if batch was stopped intermediate and is not finished - we need to finish it first
 	// this shouldn't occur since exec stage is before that and should finish the batch
 	// but just in case something unexpected happens
-	if !isBatchFinished {
+	if isBatchPartial {
 		log.Error(fmt.Sprintf("[%s] batch %d is not fully processed in stage_execute", logPrefix, latestBatch))
 		canVerify = false
 	}
diff --git a/zk/stages/test_utils.go b/zk/stages/test_utils.go
index cba02721a0c..8e4d843eb76 100644
--- a/zk/stages/test_utils.go
+++ b/zk/stages/test_utils.go
@@ -11,6 +11,7 @@ type TestDatastreamClient struct {
 	gerUpdates            []types.GerUpdate
 	lastWrittenTimeAtomic atomic.Int64
 	streamingAtomic       atomic.Bool
+	progress              atomic.Uint64
 	l2BlockChan           chan types.FullL2Block
 	gerUpdatesChan        chan types.GerUpdate
 	errChan               chan error
@@ -30,7 +31,7 @@ func NewTestDatastreamClient(fullL2Blocks []types.FullL2Block, gerUpdates []type
 	return client
 }
 
-func (c *TestDatastreamClient) ReadAllEntriesToChannel(bookmark *types.BookmarkProto) error {
+func (c *TestDatastreamClient) ReadAllEntriesToChannel() error {
 	c.streamingAtomic.Store(true)
 
 	for _, block := range c.fullL2Blocks {
@@ -65,3 +66,6 @@ func (c *TestDatastreamClient) GetLastWrittenTimeAtomic() *atomic.Int64 {
 func (c *TestDatastreamClient) GetStreamingAtomic() *atomic.Bool {
 	return &c.streamingAtomic
 }
+func (c *TestDatastreamClient) GetProgressAtomic() *atomic.Uint64 {
+	return &c.progress
+}
diff --git a/zk/tests/nightly-l1-recovery/.dockerignore b/zk/tests/nightly-l1-recovery/.dockerignore
new file mode 100644
index 00000000000..d41a52fa4c2
--- /dev/null
+++ b/zk/tests/nightly-l1-recovery/.dockerignore
@@ -0,0 +1,13 @@
+**/*_test.go
+**/*.a
+**/*.dylib
+**/*.o
+**/*.dSYM
+
+build
+tests/testdata
+cmd/prometheus
+vendor
+
+cache.db
+.git
diff --git a/zk/tests/nightly-l1-recovery/docker-compose.yml b/zk/tests/nightly-l1-recovery/docker-compose.yml
index 69b78a20452..4bbec6a64eb 100644
--- a/zk/tests/nightly-l1-recovery/docker-compose.yml
+++ b/zk/tests/nightly-l1-recovery/docker-compose.yml
@@ -1,9 +1,10 @@
 services:
   cache:
     image: golang:1.19
-    command: ["go", "run", "cmd/hack/rpc_cache/main.go", "-file", "zk/tests/nightly-l1-recovery/network5-cache.db"]
+    command: ["go", "run", "cmd/hack/rpc_cache/main.go", "-file", "/cache/network5-cache.db"]
     volumes:
       - ../../../:/repo
+      - l1-cache:/cache
     working_dir: /repo
     networks:
       - erigon-net
@@ -12,7 +13,7 @@ services:
     build:
       context: ../../../
       dockerfile: Dockerfile
-    command: ["--config", "/config/network5-config.yaml"]
+    command: ["--config", "/config/network5-config.yaml", "--zkevm.l1-sync-stop-batch", "100"]
     environment:
       - CDK_ERIGON_SEQUENCER=1
     volumes:
@@ -23,9 +24,23 @@ services:
     depends_on:
       - cache
 
+  erigon-sync:
+    build:
+        context: ../../../
+        dockerfile: Dockerfile
+    command: [ "--config", "/config/network5-sync-config.yaml" ]
+    volumes:
+      - ./:/config
+      - datadir-syncer:/datadir
+    networks:
+      - erigon-net
+    depends_on:
+      - cache
+      - erigon
+
   block-checker:
     image: golang:1.19
-    command: ["go", "run", "/repo/zk/debug_tools/nightly-block-compare-wait/main.go", "--compare=http://34.175.214.161:8505"]
+    command: ["go", "run", "/repo/zk/debug_tools/nightly-block-compare-wait/main.go", "--compare=http://34.175.214.161:8505", "--compare2=http://erigon-sync:8123", "--duration=1h", "--interval=10s"]
     volumes:
       - ../../../:/repo
     working_dir: /repo
@@ -33,6 +48,8 @@ services:
       - erigon-net
     depends_on:
       - erigon
+      - cache
+      - erigon-sync
 
 networks:
   erigon-net:
@@ -40,3 +57,5 @@ networks:
 
 volumes:
   datadir:
+  datadir-syncer:
+  l1-cache:
diff --git a/zk/tests/nightly-l1-recovery/network5-config.yaml b/zk/tests/nightly-l1-recovery/network5-config.yaml
index 9c89a32f355..5078674c4a1 100644
--- a/zk/tests/nightly-l1-recovery/network5-config.yaml
+++ b/zk/tests/nightly-l1-recovery/network5-config.yaml
@@ -8,6 +8,7 @@ zkevm.l2-datastreamer-url: "34.175.214.161:6915"
 zkevm.l1-chain-id: 11155111
 zkevm.l1-rpc-url: "http://cache:6969?endpoint=https://rpc.sepolia.org&chainid=8282"
 
+
 zkevm.address-sequencer: "0xC9c0DDBAD778A58ac078975Cc7847dD1DEaF2B0A"
 zkevm.address-zkevm: "0x1FAC2D008A7987ED9Eb3eBCd2d95791cC341AB6f"
 zkevm.address-admin: "0x406C6e412895f32573442365d0BA5027ae369cC7"
@@ -22,7 +23,6 @@ zkevm.rpc-ratelimit: 250
 zkevm.data-stream-port: 6900
 zkevm.datastream-version: 2
 zkevm.data-stream-host: "127.0.0.1"
-zkevm.sequencer-initial-fork-id: 9
 zkevm.executor-strict: false
 # zkevm.executor-urls: "zkevm2-stateless-executor:50071"
 zkevm.witness-full: false
@@ -30,6 +30,12 @@ zkevm.sequencer-block-seal-time: "5s"
 zkevm.sequencer-batch-seal-time: "15m"
 zkevm.allow-pre-eip155-transactions: true
 
+zkevm.default-gas-price: 1000000000
+zkevm.max-gas-price: 0
+zkevm.gas-price-factor: 0.12
+
+log.console.verbosity: warn
+
 zkevm.l1-sync-start-block: 6032365
 
 externalcl: true
diff --git a/zk/tests/nightly-l1-recovery/network5-sync-config.yaml b/zk/tests/nightly-l1-recovery/network5-sync-config.yaml
new file mode 100644
index 00000000000..602d435bca2
--- /dev/null
+++ b/zk/tests/nightly-l1-recovery/network5-sync-config.yaml
@@ -0,0 +1,43 @@
+datadir : './datadir'
+chain : "dynamic-integration"
+http : true
+private.api.addr : "localhost:9096"
+zkevm.l2-chain-id: 8282
+zkevm.l2-sequencer-rpc-url: "http://erigon:8545"
+zkevm.l2-datastreamer-url: "erigon:6900"
+zkevm.l1-chain-id: 11155111
+zkevm.l1-rpc-url: "http://cache:6969?endpoint=https://rpc.sepolia.org&chainid=8282"
+
+zkevm.address-sequencer: "0xC9c0DDBAD778A58ac078975Cc7847dD1DEaF2B0A"
+zkevm.address-zkevm: "0x1FAC2D008A7987ED9Eb3eBCd2d95791cC341AB6f"
+zkevm.address-admin: "0x406C6e412895f32573442365d0BA5027ae369cC7"
+zkevm.address-rollup: "0xBFA50869D87f5Fdee35F60ab31Dc5a347ab6d7f4"
+zkevm.address-ger-manager: "0x3134D060b2b2B47477e8f75537B2047606c5a8cc"
+
+zkevm.l1-matic-contract-address: "0x0f25eE4CA85Db4362a9749782872c558873566e4"
+zkevm.l1-block-range: 20000
+zkevm.l1-query-delay: 6000
+zkevm.l1-first-block: 6032365
+zkevm.rpc-ratelimit: 250
+zkevm.executor-strict: false
+# zkevm.executor-urls: "zkevm2-stateless-executor:50071"
+zkevm.witness-full: false
+zkevm.sequencer-block-seal-time: "5s"
+zkevm.sequencer-batch-seal-time: "15m"
+zkevm.allow-pre-eip155-transactions: true
+
+zkevm.default-gas-price: 1000000000
+zkevm.max-gas-price: 0
+zkevm.gas-price-factor: 0.12
+
+txpool.disable: true
+
+externalcl: true
+http.api : ["eth","debug","net","trace","web3","erigon","txpool","zkevm"]
+http.addr: "0.0.0.0"
+http.port: 8123
+http.vhosts: '*'
+http.corsdomain: '*'
+
+ws: true
+rpc.batch.limit: 500
diff --git a/zk/tx/tx.go b/zk/tx/tx.go
index 506ff31c86e..01978c06001 100644
--- a/zk/tx/tx.go
+++ b/zk/tx/tx.go
@@ -386,7 +386,7 @@ func GetDecodedV(tx types.Transaction, v *uint256.Int) *uint256.Int {
 
 func GenerateBlockBatchL2Data(forkId uint16, deltaTimestamp uint32, l1InfoTreeIndex uint32, transactions []types.Transaction, egTx map[common.Hash]uint8) ([]byte, error) {
 	// add in the changeL2Block transaction
-	result := GenerateStartBlockBatchL2Data(forkId, deltaTimestamp, l1InfoTreeIndex)
+	result := GenerateStartBlockBatchL2Data(deltaTimestamp, l1InfoTreeIndex)
 
 	for _, transaction := range transactions {
 		encoded, err := TransactionToL2Data(transaction, forkId, egTx[transaction.Hash()])
@@ -399,7 +399,11 @@ func GenerateBlockBatchL2Data(forkId uint16, deltaTimestamp uint32, l1InfoTreeIn
 	return result, nil
 }
 
-func GenerateStartBlockBatchL2Data(forkId uint16, deltaTimestamp uint32, l1InfoTreeIndex uint32) []byte {
+var (
+	START_BLOCK_BATCH_L2_DATA_SIZE = uint64(65) // change this if GenerateStartBlockBatchL2Data changes
+)
+
+func GenerateStartBlockBatchL2Data(deltaTimestamp uint32, l1InfoTreeIndex uint32) []byte {
 	var result []byte
 
 	// add in the changeL2Block transaction
diff --git a/zk/utils/debug_timer.go b/zk/utils/debug_timer.go
new file mode 100644
index 00000000000..0b31e7369fc
--- /dev/null
+++ b/zk/utils/debug_timer.go
@@ -0,0 +1,44 @@
+package utils
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/ledgerwatch/log/v3"
+)
+
+var timerEnabled bool
+
+type Timer struct {
+	start     time.Time
+	taskNames []string
+}
+
+func EnableTimer(enable bool) {
+	timerEnabled = enable
+}
+
+func StartTimer(taskNames ...string) *Timer {
+	if !timerEnabled {
+		return nil
+	}
+	return &Timer{
+		start:     time.Now(),
+		taskNames: taskNames,
+	}
+}
+
+func (t *Timer) LogTimer() {
+	if !timerEnabled || t == nil {
+		return
+	}
+
+	elapsed := time.Since(t.start)
+	logArgs := []interface{}{"duration", elapsed, "task", t.taskNames[0]}
+
+	for i, task := range t.taskNames[1:] {
+		logArgs = append(logArgs, fmt.Sprintf("subtask%d", i+1), task)
+	}
+
+	log.Info("[cdk-metric]", logArgs...)
+}
diff --git a/zk/witness/witness.go b/zk/witness/witness.go
index 95360f9b904..8adc339799b 100644
--- a/zk/witness/witness.go
+++ b/zk/witness/witness.go
@@ -70,6 +70,9 @@ func NewGenerator(
 }
 
 func (g *Generator) GetWitnessByBatch(tx kv.Tx, ctx context.Context, batchNum uint64, debug, witnessFull bool) ([]byte, error) {
+	t := zkUtils.StartTimer("witness", "getwitnessbybatch")
+	defer t.LogTimer()
+
 	reader := hermez_db.NewHermezDbReader(tx)
 	badBatch, err := reader.GetInvalidBatch(batchNum)
 	if err != nil {
@@ -144,6 +147,9 @@ func (g *Generator) GetWitnessByBatch(tx kv.Tx, ctx context.Context, batchNum ui
 }
 
 func (g *Generator) GetWitnessByBlockRange(tx kv.Tx, ctx context.Context, startBlock, endBlock uint64, debug, witnessFull bool) ([]byte, error) {
+	t := zkUtils.StartTimer("witness", "getwitnessbyblockrange")
+	defer t.LogTimer()
+
 	if startBlock > endBlock {
 		return nil, ErrEndBeforeStart
 	}
@@ -166,6 +172,9 @@ func (g *Generator) GetWitnessByBlockRange(tx kv.Tx, ctx context.Context, startB
 }
 
 func (g *Generator) generateWitness(tx kv.Tx, ctx context.Context, blocks []*eritypes.Block, debug, witnessFull bool) ([]byte, error) {
+	t := zkUtils.StartTimer("witness", "generatewitness")
+	defer t.LogTimer()
+
 	endBlock := blocks[len(blocks)-1].NumberU64()
 	startBlock := blocks[0].NumberU64()