feat: create grpc execution environemnt (#2490)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

this creats a grpc execution runner. the idea here is to support
different execution environments. this one is done to integrate ev-rs

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->

---------

Co-authored-by: tac0turtle <you@example.com>

Author: tac0turtle

CHANGELOG.md

@@ -13,7 +13,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 <!-- New features or capabilities -->
--
+- Added gRPC execution client implementation for remote execution services using Connect-RPC protocol ([#2490](https://github.com/evstack/ev-node/pull/2490))
+- Added `ExecutorService` protobuf definition with InitChain, GetTxs, ExecuteTxs, and SetFinal RPCs ([#2490](https://github.com/evstack/ev-node/pull/2490))
+- Added new `grpc` app for running EVNode with a remote execution layer via gRPC ([#2490](https://github.com/evstack/ev-node/pull/2490))
 
 ### Changed
 

apps/grpc/single/Dockerfile

@@ -0,0 +1,63 @@
+# Build stage
+FROM golang:1.24-alpine AS builder
+
+# Install build dependencies
+RUN apk add --no-cache git make gcc musl-dev linux-headers
+
+# Set working directory
+WORKDIR /rollkit
+
+# Copy go mod files
+COPY go.mod go.sum ./
+COPY apps/grpc/single/go.mod apps/grpc/single/go.sum ./apps/grpc/single/
+COPY core/go.mod core/go.sum ./core/
+COPY execution/grpc/go.mod execution/grpc/go.sum ./execution/grpc/
+COPY pkg/go.mod pkg/go.sum ./pkg/
+COPY sequencers/single/go.mod sequencers/single/go.sum ./sequencers/single/
+
+# Download dependencies
+RUN go mod download
+
+# Copy source code
+COPY . .
+
+# Build the application
+WORKDIR /rollkit/apps/grpc/single
+RUN go build -o grpc-single .
+
+# Runtime stage
+FROM alpine:3.19
+
+# Install runtime dependencies
+RUN apk add --no-cache ca-certificates
+
+# Create non-root user
+RUN addgroup -g 1000 rollkit && \
+    adduser -u 1000 -G rollkit -s /bin/sh -D rollkit
+
+# Set working directory
+WORKDIR /home/rollkit
+
+# Copy binary from builder
+COPY --from=builder /rollkit/apps/grpc/single/grpc-single /usr/local/bin/
+
+# Create necessary directories
+RUN mkdir -p /home/rollkit/.grpc-single && \
+    chown -R rollkit:rollkit /home/rollkit
+
+# Switch to non-root user
+USER rollkit
+
+# Expose ports
+# P2P port
+EXPOSE 26656
+# RPC port
+EXPOSE 26657
+# Prometheus metrics
+EXPOSE 26660
+
+# Set entrypoint
+ENTRYPOINT ["grpc-single"]
+
+# Default command
+CMD ["start"]

apps/grpc/single/README.md

@@ -0,0 +1,156 @@
+# gRPC Single Sequencer App
+
+This application runs a Rollkit node with a single sequencer that connects to a remote execution client via gRPC. It allows you to use any execution layer that implements the Rollkit execution gRPC interface.
+
+## Overview
+
+The gRPC single sequencer app provides:
+
+- A Rollkit consensus node with single sequencer
+- Connection to remote execution clients via gRPC
+- Full data availability layer integration
+- P2P networking capabilities
+
+## Prerequisites
+
+1. A running execution client that implements the Rollkit gRPC execution interface
+2. Access to a data availability layer (e.g., local DA, Celestia)
+3. Go 1.22 or higher
+
+## Installation
+
+From the repository root:
+
+```bash
+cd apps/grpc/single
+go build -o grpc-single
+```
+
+## Usage
+
+### 1. Initialize the Node
+
+First, initialize the node configuration:
+
+```bash
+./grpc-single init --root-dir ~/.grpc-single
+```
+
+This creates the necessary configuration files and directories.
+
+### 2. Configure the Node
+
+Edit the configuration file at `~/.grpc-single/config/config.toml` to set your preferred parameters, or use command-line flags.
+
+### 3. Start the Execution Service
+
+Before starting the Rollkit node, ensure your gRPC execution service is running.
+
+### 4. Run the Node
+
+Start the Rollkit node with:
+
+```bash
+./grpc-single start \
+  --root-dir ~/.grpc-single \
+  --grpc-executor-url http://localhost:50051 \
+  --da.address http://localhost:7980 \
+  --da.auth-token your-da-token \
+  --chain-id your-chain-id
+```
+
+## Command-Line Flags
+
+### gRPC-specific Flags
+
+- `--grpc-executor-url`: URL of the gRPC execution service (default: `http://localhost:50051`)
+
+### Common Rollkit Flags
+
+- `--root-dir`: Root directory for config and data (default: `~/.grpc-single`)
+- `--chain-id`: The chain ID for your rollup
+- `--da.address`: Data availability layer address
+- `--da.auth-token`: Authentication token for DA layer
+- `--da.namespace`: Namespace for DA layer (optional)
+- `--p2p.listen-address`: P2P listen address (default: `/ip4/0.0.0.0/tcp/26656`)
+- `--block-time`: Time between blocks (default: `1s`)
+
+## Example: Running with Local DA
+
+1. Start the local DA service:
+
+    ```bash
+    cd da/cmd/local-da
+    go run main.go
+    ```
+
+2. Start your gRPC execution service:
+
+    ```bash
+    # Your execution service implementation
+    ```
+
+3. Initialize and run the node:
+
+    ```bash
+    ./grpc-single init --root-dir ~/.grpc-single
+    ./grpc-single start \
+      --root-dir ~/.grpc-single \
+      --grpc-executor-url http://localhost:50051 \
+      --da.address http://localhost:7980 \
+      --chain-id test-chain
+    ```
+
+## Architecture
+
+```text
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────┐
+│   Rollkit Node  │────▶│ gRPC Execution   │────▶│  Execution  │
+│ (Single Seqr)   │◀────│     Client       │◀────│   Service   │
+└─────────────────┘     └──────────────────┘     └─────────────┘
+         │                                                │
+         │                                                │
+         ▼                                                ▼
+┌─────────────────┐                              ┌─────────────┐
+│       DA        │                              │    State    │
+│     Layer       │                              │   Storage   │
+└─────────────────┘                              └─────────────┘
+```
+
+## Development
+
+### Building from Source
+
+```bash
+go build -o grpc-single
+```
+
+### Running Tests
+
+```bash
+go test ./...
+```
+
+## Troubleshooting
+
+### Connection Refused
+
+If you see "connection refused" errors, ensure:
+
+1. Your gRPC execution service is running
+2. The execution service URL is correct
+3. No firewall is blocking the connection
+
+### DA Layer Issues
+
+If you have issues connecting to the DA layer:
+
+1. Verify the DA service is running
+2. Check the authentication token
+3. Ensure the namespace exists (if using Celestia)
+
+## See Also
+
+- [Rollkit Documentation](https://rollkit.dev)
+- [gRPC Execution Interface](../../../execution/grpc/README.md)
+- [Single Sequencer Documentation](../../../sequencers/single/README.md)

apps/grpc/single/cmd/init.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	rollcmd "github.com/evstack/ev-node/pkg/cmd"
+	rollconf "github.com/evstack/ev-node/pkg/config"
+	rollgenesis "github.com/evstack/ev-node/pkg/genesis"
+)
+
+// InitCmd returns the init command for initializing the gRPC single sequencer node
+func InitCmd() *cobra.Command {
+	initCmd := &cobra.Command{
+		Use:   "init",
+		Short: "Initialize rollkit configuration files",
+		Long: `Initialize configuration files for a Rollkit node with gRPC execution client.
+This will create the necessary configuration structure in the specified root directory.`,
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			homePath, err := cmd.Flags().GetString(rollconf.FlagRootDir)
+			if err != nil {
+				return fmt.Errorf("error reading home flag: %w", err)
+			}
+
+			aggregator, err := cmd.Flags().GetBool(rollconf.FlagAggregator)
+			if err != nil {
+				return fmt.Errorf("error reading aggregator flag: %w", err)
+			}
+
+			// ignore error, as we are creating a new config
+			// we use load in order to parse all the flags
+			cfg, _ := rollconf.Load(cmd)
+			cfg.Node.Aggregator = aggregator
+			if err := cfg.Validate(); err != nil {
+				return fmt.Errorf("error validating config: %w", err)
+			}
+
+			passphrase, err := cmd.Flags().GetString(rollconf.FlagSignerPassphrase)
+			if err != nil {
+				return fmt.Errorf("error reading passphrase flag: %w", err)
+			}
+
+			proposerAddress, err := rollcmd.CreateSigner(&cfg, homePath, passphrase)
+			if err != nil {
+				return err
+			}
+
+			if err := cfg.SaveAsYaml(); err != nil {
+				return fmt.Errorf("error writing rollkit.yaml file: %w", err)
+			}
+
+			if err := rollcmd.LoadOrGenNodeKey(homePath); err != nil {
+				return err
+			}
+
+			// get chain ID or use default
+			chainID, _ := cmd.Flags().GetString(rollconf.FlagChainID)
+			if chainID == "" {
+				chainID = "grpc-test-chain"
+			}
+
+			// Initialize genesis without app state
+			err = rollgenesis.CreateGenesis(homePath, chainID, 1, proposerAddress)
+			genesisPath := rollgenesis.GenesisPath(homePath)
+			if errors.Is(err, rollgenesis.ErrGenesisExists) {
+				// check if existing genesis file is valid
+				if genesis, err := rollgenesis.LoadGenesis(genesisPath); err == nil {
+					if err := genesis.Validate(); err != nil {
+						return fmt.Errorf("existing genesis file is invalid: %w", err)
+					}
+				} else {
+					return fmt.Errorf("error loading existing genesis file: %w", err)
+				}
+
+				cmd.Printf("Genesis file already exists at %s, skipping creation.\n", genesisPath)
+			} else if err != nil {
+				return fmt.Errorf("error initializing genesis file: %w", err)
+			}
+
+			cmd.Printf("Successfully initialized config file at %s\n", cfg.ConfigPath())
+			return nil
+		},
+	}
+
+	// Add configuration flags
+	rollconf.AddFlags(initCmd)
+
+	return initCmd
+}