diff --git a/.github/release.config.js b/.github/release.config.js
index 266d1c3..d028a57 100644
--- a/.github/release.config.js
+++ b/.github/release.config.js
@@ -18,10 +18,10 @@ module.exports = {
         }],
         ['@semantic-release/github', {
             assets: [
-                { path: 'release/berachain-exporter-linux-amd64' },
-                { path: 'release/berachain-exporter-darwin-amd64' },
-                { path: 'release/berachain-exporter-darwin-arm64' },
-                { path: 'release/berachain-exporter-windows-amd64.exe' }
+                { path: 'release/evm-exporter-linux-amd64' },
+                { path: 'release/evm-exporter-darwin-amd64' },
+                { path: 'release/evm-exporter-darwin-arm64' },
+                { path: 'release/evm-exporter-windows-amd64.exe' }
             ],
         }],
         ['@semantic-release/git', {
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
index 2284f50..1a07da6 100644
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -1,37 +1,55 @@
-name: Build and Package
+name: Build
 
 on:
   pull_request:
-    paths:
-      - '**.go'
-      - 'go.mod'
-      - 'go.sum'
+    branches: [ main ]
 
 jobs:
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.21'
+
+      - name: Run tests
+        run: go test -v ./...
+
   build:
+    needs: test
+    name: Build and Publish
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
     steps:
-      - name: Checkout
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-      - name: Setup Go
+      - name: Set up Go
         uses: actions/setup-go@v4
         with:
-          go-version: '1.22.1'
+          go-version: '1.21'
+
+      - name: Get short SHA
+        id: sha
+        run: echo "sha=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
 
-      - name: Build Binaries
+      - name: Build binaries
         run: |
           mkdir -p release
-          GOOS=linux GOARCH=amd64 go build -o release/berachain-exporter-linux-amd64
-          GOOS=darwin GOARCH=amd64 go build -o release/berachain-exporter-darwin-amd64
-          GOOS=darwin GOARCH=arm64 go build -o release/berachain-exporter-darwin-arm64
-          GOOS=windows GOARCH=amd64 go build -o release/berachain-exporter-windows-amd64.exe
+          GOOS=linux GOARCH=amd64 go build -o release/evm-exporter-linux-amd64-${{ steps.sha.outputs.sha }}
+          GOOS=darwin GOARCH=amd64 go build -o release/evm-exporter-darwin-amd64-${{ steps.sha.outputs.sha }}
+          GOOS=darwin GOARCH=arm64 go build -o release/evm-exporter-darwin-arm64-${{ steps.sha.outputs.sha }}
+          GOOS=windows GOARCH=amd64 go build -o release/evm-exporter-windows-amd64-${{ steps.sha.outputs.sha }}.exe
 
-      - name: Upload to GitHub Packages
-        uses: actions/upload-artifact@v3
-        with:
-          name: binaries
-          path: release/*
+      - name: Publish to GitHub Packages
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          for file in release/*; do
+            gh release upload "commit-${{ steps.sha.outputs.sha }}" "$file" --clobber || gh release create "commit-${{ steps.sha.outputs.sha }}" "$file"
+          done
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 679d53b..f121214 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -10,7 +10,22 @@ on:
       - 'go.sum'
 
 jobs:
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.22.1'
+
+      - name: Run tests
+        run: go test -v ./...
+
   release:
+    needs: test
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -38,10 +53,10 @@ jobs:
       - name: Build Binaries
         run: |
           mkdir -p release
-          GOOS=linux GOARCH=amd64 go build -o release/berachain-exporter-linux-amd64
-          GOOS=darwin GOARCH=amd64 go build -o release/berachain-exporter-darwin-amd64
-          GOOS=darwin GOARCH=arm64 go build -o release/berachain-exporter-darwin-arm64
-          GOOS=windows GOARCH=amd64 go build -o release/berachain-exporter-windows-amd64.exe
+          GOOS=linux GOARCH=amd64 go build -o release/evm-exporter-linux-amd64
+          GOOS=darwin GOARCH=amd64 go build -o release/evm-exporter-darwin-amd64
+          GOOS=darwin GOARCH=arm64 go build -o release/evm-exporter-darwin-arm64
+          GOOS=windows GOARCH=amd64 go build -o release/evm-exporter-windows-amd64.exe
 
       - name: Install semantic-release
         run: npm install @semantic-release/git @semantic-release/changelog @semantic-release/exec conventional-changelog-conventionalcommits
diff --git a/README.md b/README.md
index d5f7caf..85de8bc 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# Berachain Block Exporter
+# Cosmos EVM Exporter
 
-A monitoring tool that tracks block production on Berachain's consensus and execution layers, specifically designed to monitor validator block proposals and their corresponding execution blocks.
+A monitoring tool that tracks block production on Cosmos EVM chains consensus and execution layers, specifically designed to monitor validator block proposals and their corresponding execution blocks.
 
 ## Features
 
@@ -46,10 +46,10 @@ enable_stdout = true # Enable console logging
 go run main.go --config=./config.toml
 
 # Build binary
-go build -o berachain-exporter
+go build -o evm-exporter
 
 # Run binary
-./berachain-exporter --config=./config.toml
+./evm-exporter --config=./config.toml
 ```
 
 ## Metrics Endpoint
@@ -59,7 +59,7 @@ Prometheus metrics are available at `http://localhost:2113/metrics`
 ## Requirements
 
 - Go 1.22.1 or later
-- Access to Berachain RPC endpoints
+- Access to Cosmos & Ethereum RPC endpoints
 
 ## Dependencies
 
@@ -79,7 +79,7 @@ git clone [repository-url]
 go mod download
 
 # Build
-go build -o berachain-exporter
+go build -o evm-exporter
 ```
 
 ## Example Output
diff --git a/go.mod b/go.mod
index c6e1456..328517d 100644
--- a/go.mod
+++ b/go.mod
@@ -1,4 +1,4 @@
-module blockchecker
+module evm-exporter
 
 go 1.22.1
 
diff --git a/main.go b/main.go
index 02e9a38..60db371 100755
--- a/main.go
+++ b/main.go
@@ -24,19 +24,21 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
+// Config defines the application's configuration parameters loaded from TOML
 type Config struct {
-	EVMAddress      string `toml:"evm_address"`
-	TargetValidator string `toml:"target_validator"`
-	RPCEndpoint     string `toml:"rpc_endpoint"`
-	LogFile         string `toml:"log_file"`
-	MetricsPort     string `toml:"metrics_port"`
-	EnableFileLog   bool   `toml:"enable_file_log"`
-	EnableStdout    bool   `toml:"enable_stdout"`
-	ETHEndpoint     string `toml:"eth_endpoint"`
+	EVMAddress      string `toml:"evm_address"`      // Address of the EVM contract
+	TargetValidator string `toml:"target_validator"` // Validator address to monitor
+	RPCEndpoint     string `toml:"rpc_endpoint"`     // Consensus layer RPC endpoint
+	LogFile         string `toml:"log_file"`         // Path to log file
+	MetricsPort     string `toml:"metrics_port"`     // Prometheus metrics port
+	EnableFileLog   bool   `toml:"enable_file_log"`  // Enable logging to file
+	EnableStdout    bool   `toml:"enable_stdout"`    // Enable logging to stdout
+	ETHEndpoint     string `toml:"eth_endpoint"`     // Execution layer endpoint
 }
 
 var config *Config
 
+// loadConfig reads and validates the configuration from the specified path
 func loadConfig(path string) (*Config, error) {
 	var cfg Config
 	if _, err := toml.DecodeFile(path, &cfg); err != nil {
@@ -63,16 +65,17 @@ func loadConfig(path string) (*Config, error) {
 	return &cfg, nil
 }
 
+// Prometheus metrics for monitoring validator performance and block processing
 var (
 	blockMetrics = struct {
-		totalProposed        prometheus.Counter
-		executionConfirmed   prometheus.Counter
-		executionMissed      prometheus.Counter
-		emptyConsensusBlocks prometheus.Counter
-		emptyExecutionBlocks prometheus.Counter
-		errors               prometheus.Counter
-		currentHeight        prometheus.Gauge
-		elToClGap            prometheus.Gauge // New metric to track the gap
+		totalProposed        prometheus.Counter // Total blocks proposed by validator
+		executionConfirmed   prometheus.Counter // Blocks confirmed on execution layer
+		executionMissed      prometheus.Counter // Blocks missed on execution layer
+		emptyConsensusBlocks prometheus.Counter // Blocks with no transactions
+		emptyExecutionBlocks prometheus.Counter // Empty blocks on execution layer
+		errors               prometheus.Counter // Block processing errors
+		currentHeight        prometheus.Gauge   // Current block height
+		elToClGap            prometheus.Gauge   // Gap between execution and consensus layers
 	}{
 		totalProposed: promauto.NewCounter(prometheus.CounterOpts{
 			Name: "validator_total_blocks_proposed",
@@ -109,7 +112,7 @@ var (
 	}
 )
 
-// Status response structures
+// StatusResponse defines the structure for consensus layer status API responses
 type StatusResponse struct {
 	Result struct {
 		SyncInfo struct {
@@ -118,7 +121,7 @@ type StatusResponse struct {
 	} `json:"result"`
 }
 
-// Block response structures
+// BlockResponse defines the structure for consensus layer block API responses
 type BlockResponse struct {
 	JsonRPC string `json:"jsonrpc"`
 	ID      int    `json:"id"`
@@ -183,8 +186,8 @@ type BlockResponse struct {
 	} `json:"result"`
 }
 
-// Add structure for parsing the transaction
-type BerachainTx struct {
+// EVMChainTx represents the structure for parsing transactions
+type EVMChainTx struct {
 	MsgType    uint32
 	DataLength uint32
 	Payload    []byte
@@ -196,8 +199,56 @@ var (
 	fileLogger   *log.Logger
 )
 
+// Add this struct for HTTP client configuration
+type httpClient struct {
+	client  *http.Client
+	retries int
+}
+
+// newHTTPClient creates an HTTP client with retry capabilities
+func newHTTPClient() *httpClient {
+	return &httpClient{
+		client: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+		retries: 3,
+	}
+}
+
+// doRequest executes an HTTP request with automatic retries on failure
+func (c *httpClient) doRequest(req *http.Request) (*http.Response, error) {
+	var lastErr error
+	for i := 0; i <= c.retries; i++ {
+		resp, err := c.client.Do(req)
+		if err != nil {
+			lastErr = err
+			if i < c.retries {
+				time.Sleep(time.Second * time.Duration(1<<uint(i)))
+				continue
+			}
+			return nil, err
+		}
+
+		if resp.StatusCode >= 500 && i < c.retries {
+			resp.Body.Close()
+			time.Sleep(time.Second * time.Duration(1<<uint(i)))
+			continue
+		}
+
+		return resp, nil
+	}
+	return nil, lastErr
+}
+
+// getCurrentHeight retrieves the latest block height from the consensus layer
 func getCurrentHeight(rpcEndpoint string) (int64, error) {
-	resp, err := http.Get(rpcEndpoint + "/status")
+	client := newHTTPClient()
+	req, err := http.NewRequest("GET", rpcEndpoint+"/status", nil)
+	if err != nil {
+		return 0, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := client.doRequest(req)
 	if err != nil {
 		return 0, fmt.Errorf("failed to fetch status: %w", err)
 	}
@@ -222,8 +273,17 @@ func getCurrentHeight(rpcEndpoint string) (int64, error) {
 	return height, nil
 }
 
+// getBlock fetches block details for a specific height from the consensus layer
 func getBlock(rpcEndpoint string, height int64) (*BlockResponse, error) {
-	resp, err := http.Get(fmt.Sprintf("%s/block?height=%d", rpcEndpoint, height))
+	client := newHTTPClient()
+	req, err := http.NewRequest("GET",
+		fmt.Sprintf("%s/block?height=%d", rpcEndpoint, height),
+		nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := client.doRequest(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch block: %w", err)
 	}
@@ -275,7 +335,7 @@ func setupLogger() (*log.Logger, *log.Logger) {
 }
 
 // Add this function to decode base64 transactions
-func decodeTx(txBase64 string) (*BerachainTx, error) {
+func decodeTx(txBase64 string) (*EVMChainTx, error) {
 	// Decode base64
 	txData, err := base64.StdEncoding.DecodeString(txBase64)
 	if err != nil {
@@ -288,8 +348,8 @@ func decodeTx(txBase64 string) (*BerachainTx, error) {
 		return nil, fmt.Errorf("tx data too short: %d bytes", len(txData))
 	}
 
-	// Create BerachainTx
-	tx := &BerachainTx{
+	// Create EVMChainTx
+	tx := &EVMChainTx{
 		MsgType:    binary.BigEndian.Uint32(txData[0:4]),
 		DataLength: binary.BigEndian.Uint32(txData[4:8]),
 	}
@@ -325,11 +385,11 @@ func dumpPayload(payload []byte) {
 	}
 }
 
+// getCurrentGap calculates the current block height difference between consensus and execution layers
 func getCurrentGap() (int64, error) {
-	// Get EL block height
-	var elResp struct {
-		Result string `json:"result"`
-	}
+	client := newHTTPClient()
+
+	// Get EL block height with retries
 	elReq := struct {
 		Jsonrpc string   `json:"jsonrpc"`
 		Id      string   `json:"id"`
@@ -347,21 +407,33 @@ func getCurrentGap() (int64, error) {
 		return 0, fmt.Errorf("failed to marshal EL request: %v", err)
 	}
 
-	resp, err := http.Post(config.ETHEndpoint, "application/json", bytes.NewBuffer(elBody))
+	req, err := http.NewRequest("POST", config.ETHEndpoint, bytes.NewBuffer(elBody))
 	if err != nil {
-		return 0, fmt.Errorf("failed to fetch EL height: %v", err)
+		return 0, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := client.doRequest(req)
+	if err != nil {
+		return 0, fmt.Errorf("failed to fetch EL height: %w", err)
 	}
 	defer resp.Body.Close()
 
+	// Define the response structure
+	elResp := struct {
+		Result string `json:"result"`
+	}{}
+
 	if err := json.NewDecoder(resp.Body).Decode(&elResp); err != nil {
 		return 0, fmt.Errorf("failed to decode EL response: %v", err)
 	}
 
-	elHeight, err := strconv.ParseInt(strings.TrimPrefix(elResp.Result, "0x"), 16, 64)
+	elHeight, err := strconv.ParseInt(elResp.Result[2:], 16, 64)
 	if err != nil {
 		return 0, fmt.Errorf("failed to parse EL height: %v", err)
 	}
 
+	// Get CL height
 	clHeight, err := getCurrentHeight(config.RPCEndpoint)
 	if err != nil {
 		return 0, fmt.Errorf("failed to get CL height: %v", err)
@@ -370,7 +442,7 @@ func getCurrentGap() (int64, error) {
 	return clHeight - elHeight, nil
 }
 
-// Remove the duplicate Block type and update processBlock to use BlockResponse
+// processBlock analyzes a block and updates metrics if it was proposed by our validator
 func processBlock(block *BlockResponse) error {
 	if block.Result.Block.Header.ProposerAddress != config.TargetValidator {
 		return nil // Not our validator
@@ -419,9 +491,6 @@ func processBlock(block *BlockResponse) error {
 }
 
 func getCurrentELHeight() (int64, error) {
-	var elResp struct {
-		Result string `json:"result"`
-	}
 	elReq := struct {
 		Jsonrpc string   `json:"jsonrpc"`
 		Id      string   `json:"id"`
@@ -436,31 +505,62 @@ func getCurrentELHeight() (int64, error) {
 
 	elBody, err := json.Marshal(elReq)
 	if err != nil {
-		return 0, fmt.Errorf("failed to marshal EL request: %v", err)
+		return 0, fmt.Errorf("failed to marshal EL request: %w", err)
+	}
+
+	client := newHTTPClient()
+	req, err := http.NewRequest("POST", config.ETHEndpoint, bytes.NewBuffer(elBody))
+	if err != nil {
+		return 0, fmt.Errorf("failed to create request: %w", err)
 	}
+	req.Header.Set("Content-Type", "application/json")
 
-	resp, err := http.Post(config.ETHEndpoint, "application/json", bytes.NewBuffer(elBody))
+	resp, err := client.doRequest(req)
 	if err != nil {
-		return 0, fmt.Errorf("failed to fetch EL height: %v", err)
+		return 0, fmt.Errorf("failed to fetch EL height: %w", err)
 	}
 	defer resp.Body.Close()
 
+	var elResp struct {
+		Result string `json:"result"`
+	}
 	if err := json.NewDecoder(resp.Body).Decode(&elResp); err != nil {
-		return 0, fmt.Errorf("failed to decode EL response: %v", err)
+		return 0, fmt.Errorf("failed to decode EL response: %w", err)
+	}
+
+	elHeight, err := strconv.ParseInt(strings.TrimPrefix(elResp.Result, "0x"), 16, 64)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse EL height: %w", err)
 	}
 
-	return strconv.ParseInt(strings.TrimPrefix(elResp.Result, "0x"), 16, 64)
+	return elHeight, nil
 }
 
 func main() {
-	// Check for config flag
-	if len(os.Args) != 3 || os.Args[1] != "--config" {
+	// Parse command line arguments for config path
+	if len(os.Args) < 2 {
+		log.Fatal("Usage: go run main.go --config=./config.toml")
+	}
+
+	var configPath string
+	for i := 1; i < len(os.Args); i++ {
+		arg := os.Args[i]
+		if strings.HasPrefix(arg, "--config=") {
+			configPath = strings.TrimPrefix(arg, "--config=")
+			break
+		} else if arg == "--config" && i+1 < len(os.Args) {
+			configPath = os.Args[i+1]
+			break
+		}
+	}
+
+	if configPath == "" {
 		log.Fatal("Usage: go run main.go --config=./config.toml")
 	}
 
 	// Load config
 	var err error
-	config, err = loadConfig(os.Args[2])
+	config, err = loadConfig(configPath)
 	if err != nil {
 		log.Fatalf("Failed to load config: %v", err)
 	}
diff --git a/main_bench_test.go b/main_bench_test.go
new file mode 100644
index 0000000..e98c8ce
--- /dev/null
+++ b/main_bench_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"testing"
+)
+
+func BenchmarkProcessBlock(b *testing.B) {
+	// Setup test config and block
+	config = &Config{
+		EVMAddress:      "0x1234",
+		TargetValidator: "ABCD",
+	}
+
+	block := &BlockResponse{}
+	block.Result.Block.Header.ProposerAddress = "ABCD"
+	block.Result.Block.Header.Height = "7368349"
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = processBlock(block)
+	}
+}
+
+func BenchmarkGetCurrentGap(b *testing.B) {
+	// Setup test config
+	config = &Config{
+		RPCEndpoint: "http://localhost:26657",
+		ETHEndpoint: "http://localhost:8545",
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = getCurrentGap()
+	}
+}
diff --git a/main_test.go b/main_test.go
new file mode 100644
index 0000000..f396b78
--- /dev/null
+++ b/main_test.go
@@ -0,0 +1,250 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+func TestLoadConfig(t *testing.T) {
+	// Create temporary config file
+	tmpfile, err := os.CreateTemp("", "config.*.toml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+
+	// Write test config
+	configContent := `
+evm_address = "0x1234567890123456789012345678901234567890"
+target_validator = "0xabcdef1234567890"
+rpc_endpoint = "http://localhost:26657"
+eth_endpoint = "http://localhost:8545"
+log_file = "test.log"
+metrics_port = ":2113"
+enable_file_log = true
+enable_stdout = true
+`
+	if _, err := tmpfile.Write([]byte(configContent)); err != nil {
+		t.Fatal(err)
+	}
+	tmpfile.Close()
+
+	// Test valid config
+	cfg, err := loadConfig(tmpfile.Name())
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+	if cfg.EVMAddress != "0x1234567890123456789012345678901234567890" {
+		t.Errorf("Wrong EVM address")
+	}
+
+	// Test missing required fields
+	tmpfile2, _ := os.CreateTemp("", "config.*.toml")
+	defer os.Remove(tmpfile2.Name())
+	tmpfile2.Write([]byte(`metrics_port = ":2113"`))
+	tmpfile2.Close()
+
+	_, err = loadConfig(tmpfile2.Name())
+	if err == nil {
+		t.Error("Expected error for missing required fields")
+	}
+}
+
+func TestHTTPClientRetries(t *testing.T) {
+	attempts := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempts++
+		if attempts <= 2 {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	}))
+	defer server.Close()
+
+	client := newHTTPClient()
+	client.retries = 2
+
+	req, _ := http.NewRequest("GET", server.URL, nil)
+	resp, err := client.doRequest(req)
+
+	if err != nil {
+		t.Errorf("Expected success after retries, got error: %v", err)
+	}
+	if attempts != 3 {
+		t.Errorf("Expected 3 attempts, got %d", attempts)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("Expected 200 status, got %d", resp.StatusCode)
+	}
+}
+
+func TestGetCurrentHeight(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/status" {
+			t.Errorf("Expected /status path, got %s", r.URL.Path)
+		}
+		resp := StatusResponse{}
+		resp.Result.SyncInfo.LatestBlockHeight = "123456"
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer server.Close()
+
+	height, err := getCurrentHeight(server.URL)
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+	if height != 123456 {
+		t.Errorf("Expected height 123456, got %d", height)
+	}
+}
+
+func TestProcessBlock(t *testing.T) {
+	// Setup mock servers
+	elServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "POST" {
+			var req struct {
+				Jsonrpc string      `json:"jsonrpc"`
+				Method  string      `json:"method"`
+				Params  interface{} `json:"params"`
+				Id      interface{} `json:"id"`
+			}
+			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+				t.Errorf("Failed to decode request: %v", err)
+				return
+			}
+
+			w.Header().Set("Content-Type", "application/json")
+			resp := struct {
+				Jsonrpc string      `json:"jsonrpc"`
+				Id      interface{} `json:"id"`
+				Result  string      `json:"result"`
+			}{
+				Jsonrpc: "2.0",
+				Id:      req.Id,
+				Result:  "0x67E1B5",
+			}
+			json.NewEncoder(w).Encode(resp)
+		}
+	}))
+	defer elServer.Close()
+
+	clServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		resp := StatusResponse{}
+		resp.Result.SyncInfo.LatestBlockHeight = "7368349"
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer clServer.Close()
+
+	// Setup test config
+	config = &Config{
+		EVMAddress:      "0x1234",
+		TargetValidator: "ABCD",
+		ETHEndpoint:     elServer.URL,
+		RPCEndpoint:     clServer.URL,
+	}
+
+	// Create test block
+	block := &BlockResponse{}
+	block.Result.Block.Header.ProposerAddress = "ABCD"
+	block.Result.Block.Header.Height = "7368349"
+
+	// Setup mock eth client
+	var err error
+	ethClient, err = ethclient.Dial(elServer.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Setup logger
+	stdoutLogger = log.New(io.Discard, "", 0) // Suppress logs during test
+
+	err = processBlock(block)
+	if err != nil {
+		t.Errorf("Expected no error, got %v", err)
+	}
+}
+
+func TestGetCurrentGap(t *testing.T) {
+	// Setup mock servers
+	clServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/status" {
+			t.Errorf("Expected /status path, got %s", r.URL.Path)
+		}
+		resp := StatusResponse{
+			Result: struct {
+				SyncInfo struct {
+					LatestBlockHeight string `json:"latest_block_height"`
+				} `json:"sync_info"`
+			}{
+				SyncInfo: struct {
+					LatestBlockHeight string `json:"latest_block_height"`
+				}{
+					LatestBlockHeight: "7368349",
+				},
+			},
+		}
+		json.NewEncoder(w).Encode(resp)
+	}))
+	defer clServer.Close()
+
+	elServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "POST" {
+			var req struct {
+				Jsonrpc string      `json:"jsonrpc"`
+				Method  string      `json:"method"`
+				Params  interface{} `json:"params"`
+				Id      interface{} `json:"id"`
+			}
+			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+				t.Errorf("Failed to decode request: %v", err)
+				return
+			}
+
+			if req.Method != "eth_blockNumber" {
+				t.Errorf("Expected eth_blockNumber method, got %s", req.Method)
+				return
+			}
+
+			w.Header().Set("Content-Type", "application/json")
+			resp := struct {
+				Jsonrpc string      `json:"jsonrpc"`
+				Id      interface{} `json:"id"`
+				Result  string      `json:"result"`
+			}{
+				Jsonrpc: "2.0",
+				Id:      req.Id,
+				Result:  "0x67e44b",
+			}
+			json.NewEncoder(w).Encode(resp)
+		}
+	}))
+	defer elServer.Close()
+
+	config = &Config{
+		RPCEndpoint: clServer.URL,
+		ETHEndpoint: elServer.URL,
+	}
+
+	gap, err := getCurrentGap()
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	clHeight := int64(7368349)
+	elHeight := int64(6808651) // 0x67E1B5 in decimal
+	expectedGap := clHeight - elHeight
+
+	if gap != expectedGap {
+		t.Errorf("Expected gap %d, got %d (CL: %d, EL: %d, EL hex: 0x%x)",
+			expectedGap, gap, clHeight, elHeight, elHeight)
+	}
+}