chore: cleanup chainid duplicate (#2510)

<!--
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 pr removes chainid from the config making the chainid in the
genesis file the single source of truth, since the genesis file is small
and wont hold much data then it makes sense to require it when starting
a node

---------

Co-authored-by: tac0turtle <[email protected]>
Co-authored-by: Manav Aggarwal <[email protected]>

Author: 3 people

apps/evm/single/cmd/init.go

@@ -55,11 +55,10 @@ func InitCmd() *cobra.Command {
 			}
 
 			// get chain ID or use default
-			chainID, _ := cmd.Flags().GetString(rollconf.FlagChainID)
-			if chainID == "" {
-				chainID = "evolve-test"
+			chainID, err := cmd.Flags().GetString(rollgenesis.ChainIDFlag)
+			if err != nil {
+				return fmt.Errorf("error reading chain ID flag: %w", err)
 			}
-
 			// Initialize genesis without app state
 			err = rollgenesis.CreateGenesis(homePath, chainID, 1, proposerAddress)
 			genesisPath := rollgenesis.GenesisPath(homePath)
@@ -85,6 +84,7 @@ func InitCmd() *cobra.Command {
 
 	// Add flags to the command
 	rollconf.AddFlags(initCmd)
+	initCmd.Flags().String(rollgenesis.ChainIDFlag, "rollkit-test", "chain ID")
 
 	return initCmd
 }

apps/evm/single/cmd/run.go

@@ -17,6 +17,7 @@ import (
 	"github.com/evstack/ev-node/core/execution"
 	rollcmd "github.com/evstack/ev-node/pkg/cmd"
 	"github.com/evstack/ev-node/pkg/config"
+	genesispkg "github.com/evstack/ev-node/pkg/genesis"
 	"github.com/evstack/ev-node/pkg/p2p"
 	"github.com/evstack/ev-node/pkg/p2p/key"
 	"github.com/evstack/ev-node/pkg/store"
@@ -49,7 +50,13 @@ var RunCmd = &cobra.Command{
 			return err
 		}
 
-		singleMetrics, err := single.DefaultMetricsProvider(nodeConfig.Instrumentation.IsPrometheusEnabled())(nodeConfig.ChainID)
+		genesisPath := filepath.Join(filepath.Dir(nodeConfig.ConfigPath()), "genesis.json")
+		genesis, err := genesispkg.LoadGenesis(genesisPath)
+		if err != nil {
+			return fmt.Errorf("failed to load genesis: %w", err)
+		}
+
+		singleMetrics, err := single.DefaultMetricsProvider(nodeConfig.Instrumentation.IsPrometheusEnabled())(genesis.ChainID)
 		if err != nil {
 			return err
 		}
@@ -59,7 +66,7 @@ var RunCmd = &cobra.Command{
 			logger,
 			datastore,
 			&daJrpc.DA,
-			[]byte(nodeConfig.ChainID),
+			[]byte(genesis.ChainID),
 			nodeConfig.Node.BlockTime.Duration,
 			singleMetrics,
 			nodeConfig.Node.Aggregator,
@@ -73,12 +80,12 @@ var RunCmd = &cobra.Command{
 			return err
 		}
 
-		p2pClient, err := p2p.NewClient(nodeConfig, nodeKey, datastore, logger, nil)
+		p2pClient, err := p2p.NewClient(nodeConfig.P2P, nodeKey.PrivKey, datastore, genesis.ChainID, logger, nil)
 		if err != nil {
 			return err
 		}
 
-		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, node.NodeOptions{})
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, genesis, node.NodeOptions{})
 	},
 }
 

apps/grpc/single/cmd/init.go

@@ -57,9 +57,9 @@ This will create the necessary configuration structure in the specified root dir
 			}
 
 			// get chain ID or use default
-			chainID, _ := cmd.Flags().GetString(rollconf.FlagChainID)
-			if chainID == "" {
-				chainID = "grpc-test-chain"
+			chainID, err := cmd.Flags().GetString(rollgenesis.ChainIDFlag)
+			if err != nil {
+				return err
 			}
 
 			// Initialize genesis without app state
@@ -87,6 +87,7 @@ This will create the necessary configuration structure in the specified root dir
 
 	// Add configuration flags
 	rollconf.AddFlags(initCmd)
+	initCmd.Flags().String(rollgenesis.ChainIDFlag, "grpc-test-chain", "chain ID")
 
 	return initCmd
 }

apps/grpc/single/cmd/run.go

@@ -12,6 +12,7 @@ import (
 	"github.com/evstack/ev-node/node"
 	rollcmd "github.com/evstack/ev-node/pkg/cmd"
 	"github.com/evstack/ev-node/pkg/config"
+	rollgenesis "github.com/evstack/ev-node/pkg/genesis"
 	"github.com/evstack/ev-node/pkg/p2p"
 	"github.com/evstack/ev-node/pkg/p2p/key"
 	"github.com/evstack/ev-node/pkg/store"
@@ -56,8 +57,14 @@ The execution client must implement the Evolve execution gRPC interface.`,
 			return err
 		}
 
+		// Load genesis
+		genesis, err := rollgenesis.LoadGenesis(rollgenesis.GenesisPath(nodeConfig.RootDir))
+		if err != nil {
+			return err
+		}
+
 		// Create metrics provider
-		singleMetrics, err := single.DefaultMetricsProvider(nodeConfig.Instrumentation.IsPrometheusEnabled())(nodeConfig.ChainID)
+		singleMetrics, err := single.DefaultMetricsProvider(nodeConfig.Instrumentation.IsPrometheusEnabled())(genesis.ChainID)
 		if err != nil {
 			return err
 		}
@@ -68,7 +75,7 @@ The execution client must implement the Evolve execution gRPC interface.`,
 			logger,
 			datastore,
 			&daJrpc.DA,
-			[]byte(nodeConfig.ChainID),
+			[]byte(genesis.ChainID),
 			nodeConfig.Node.BlockTime.Duration,
 			singleMetrics,
 			nodeConfig.Node.Aggregator,
@@ -84,13 +91,13 @@ The execution client must implement the Evolve execution gRPC interface.`,
 		}
 
 		// Create P2P client
-		p2pClient, err := p2p.NewClient(nodeConfig, nodeKey, datastore, logger, nil)
+		p2pClient, err := p2p.NewClient(nodeConfig.P2P, nodeKey.PrivKey, datastore, genesis.ChainID, logger, nil)
 		if err != nil {
 			return err
 		}
 
 		// Start the node
-		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, node.NodeOptions{})
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, genesis, node.NodeOptions{})
 	},
 }
 

apps/testapp/cmd/init.go

@@ -55,9 +55,9 @@ func InitCmd() *cobra.Command {
 			}
 
 			// get chain ID or use default
-			chainID, _ := cmd.Flags().GetString(rollconf.FlagChainID)
-			if chainID == "" {
-				chainID = "evolve-test"
+			chainID, err := cmd.Flags().GetString(rollgenesis.ChainIDFlag)
+			if err != nil {
+				return fmt.Errorf("error reading chain ID flag: %w", err)
 			}
 
 			// Initialize genesis without app state
@@ -85,6 +85,7 @@ func InitCmd() *cobra.Command {
 
 	// Add flags to the command
 	rollconf.AddFlags(initCmd)
+	initCmd.Flags().String(rollgenesis.ChainIDFlag, "rollkit-test", "chain ID")
 
 	return initCmd
 }

apps/testapp/cmd/run.go

@@ -11,6 +11,7 @@ import (
 	"github.com/evstack/ev-node/da/jsonrpc"
 	"github.com/evstack/ev-node/node"
 	rollcmd "github.com/evstack/ev-node/pkg/cmd"
+	genesispkg "github.com/evstack/ev-node/pkg/genesis"
 	"github.com/evstack/ev-node/pkg/p2p"
 	"github.com/evstack/ev-node/pkg/p2p/key"
 	"github.com/evstack/ev-node/pkg/store"
@@ -75,12 +76,18 @@ var RunCmd = &cobra.Command{
 			}
 		}
 
+		genesisPath := filepath.Join(filepath.Dir(nodeConfig.ConfigPath()), "genesis.json")
+		genesis, err := genesispkg.LoadGenesis(genesisPath)
+		if err != nil {
+			return fmt.Errorf("failed to load genesis: %w", err)
+		}
+
 		sequencer, err := single.NewSequencer(
 			ctx,
 			logger,
 			datastore,
 			&daJrpc.DA,
-			[]byte(nodeConfig.ChainID),
+			[]byte(genesis.ChainID),
 			nodeConfig.Node.BlockTime.Duration,
 			singleMetrics,
 			nodeConfig.Node.Aggregator,
@@ -89,11 +96,11 @@ var RunCmd = &cobra.Command{
 			return err
 		}
 
-		p2pClient, err := p2p.NewClient(nodeConfig, nodeKey, datastore, logger, p2p.NopMetrics())
+		p2pClient, err := p2p.NewClient(nodeConfig.P2P, nodeKey.PrivKey, datastore, genesis.ChainID, logger, p2p.NopMetrics())
 		if err != nil {
 			return err
 		}
 
-		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, node.NodeOptions{})
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, &daJrpc.DA, p2pClient, datastore, nodeConfig, genesis, node.NodeOptions{})
 	},
 }

apps/testapp/kv/kvexecutor.go

@@ -16,8 +16,16 @@ import (
 var (
 	genesisInitializedKey = ds.NewKey("/genesis/initialized")
 	genesisStateRootKey   = ds.NewKey("/genesis/stateroot")
+	finalizedHeightKey    = ds.NewKey("/finalizedHeight")
 	// Define a buffer size for the transaction channel
 	txChannelBufferSize = 10000
+	// reservedKeys defines the set of keys that should be excluded from state root calculation
+	// and protected from transaction modifications
+	reservedKeys = map[ds.Key]bool{
+		genesisInitializedKey: true,
+		genesisStateRootKey:   true,
+		finalizedHeightKey:    true,
+	}
 )
 
 // KVExecutor is a simple key-value store backed by go-datastore that implements the Executor interface
@@ -70,9 +78,9 @@ func (k *KVExecutor) computeStateRoot(ctx context.Context) ([]byte, error) {
 		if result.Error != nil {
 			return nil, fmt.Errorf("error iterating query results: %w", result.Error)
 		}
-		// Exclude reserved genesis keys from the state root calculation
+		// Exclude reserved keys from the state root calculation
 		dsKey := ds.NewKey(result.Key)
-		if dsKey.Equal(genesisInitializedKey) || dsKey.Equal(genesisStateRootKey) {
+		if reservedKeys[dsKey] {
 			continue
 		}
 		keys = append(keys, result.Key)
@@ -200,7 +208,7 @@ func (k *KVExecutor) ExecuteTxs(ctx context.Context, txs [][]byte, blockHeight u
 		}
 		dsKey := ds.NewKey(key)
 		// Prevent writing reserved keys via transactions
-		if dsKey.Equal(genesisInitializedKey) || dsKey.Equal(genesisStateRootKey) {
+		if reservedKeys[dsKey] {
 			return nil, 0, fmt.Errorf("transaction attempts to modify reserved key: %s", key)
 		}
 		err = batch.Put(ctx, dsKey, []byte(value))
@@ -240,7 +248,7 @@ func (k *KVExecutor) SetFinal(ctx context.Context, blockHeight uint64) error {
 		return errors.New("invalid blockHeight: cannot be zero")
 	}
 
-	return k.db.Put(ctx, ds.NewKey("/finalizedHeight"), []byte(fmt.Sprintf("%d", blockHeight)))
+	return k.db.Put(ctx, finalizedHeightKey, []byte(fmt.Sprintf("%d", blockHeight)))
 }
 
 // InjectTx adds a transaction to the mempool channel.

apps/testapp/kv/kvexecutor_test.go

@@ -172,3 +172,92 @@ func TestSetFinal(t *testing.T) {
 		t.Error("Expected error for blockHeight 0, got nil")
 	}
 }
+
+func TestReservedKeysExcludedFromAppHash(t *testing.T) {
+	exec, err := NewKVExecutor(t.TempDir(), "testdb")
+	if err != nil {
+		t.Fatalf("Failed to create KVExecutor: %v", err)
+	}
+	ctx := context.Background()
+
+	// Initialize chain to set up genesis state (this writes genesis reserved keys)
+	_, _, err = exec.InitChain(ctx, time.Now(), 1, "test-chain")
+	if err != nil {
+		t.Fatalf("Failed to initialize chain: %v", err)
+	}
+
+	// Add some application data
+	txs := [][]byte{
+		[]byte("user/key1=value1"),
+		[]byte("user/key2=value2"),
+	}
+	_, _, err = exec.ExecuteTxs(ctx, txs, 1, time.Now(), []byte(""))
+	if err != nil {
+		t.Fatalf("Failed to execute transactions: %v", err)
+	}
+
+	// Compute baseline state root
+	baselineStateRoot, err := exec.computeStateRoot(ctx)
+	if err != nil {
+		t.Fatalf("Failed to compute baseline state root: %v", err)
+	}
+
+	// Write to finalizedHeight (a reserved key)
+	err = exec.SetFinal(ctx, 5)
+	if err != nil {
+		t.Fatalf("Failed to set final height: %v", err)
+	}
+
+	// Verify finalizedHeight was written
+	finalizedHeightExists, err := exec.db.Has(ctx, finalizedHeightKey)
+	if err != nil {
+		t.Fatalf("Failed to check if finalizedHeight exists: %v", err)
+	}
+	if !finalizedHeightExists {
+		t.Error("Expected finalizedHeight to exist in database")
+	}
+
+	// State root should be unchanged (reserved keys excluded from calculation)
+	stateRootAfterReservedKeyWrite, err := exec.computeStateRoot(ctx)
+	if err != nil {
+		t.Fatalf("Failed to compute state root after writing reserved key: %v", err)
+	}
+
+	if string(baselineStateRoot) != string(stateRootAfterReservedKeyWrite) {
+		t.Errorf("State root changed after writing reserved key:\nBefore: %s\nAfter:  %s",
+			string(baselineStateRoot), string(stateRootAfterReservedKeyWrite))
+	}
+
+	// Verify state root contains only user data, not reserved keys
+	stateRootStr := string(stateRootAfterReservedKeyWrite)
+	if !strings.Contains(stateRootStr, "user/key1:value1") ||
+		!strings.Contains(stateRootStr, "user/key2:value2") {
+		t.Errorf("State root should contain user data: %s", stateRootStr)
+	}
+
+	// Verify reserved keys are NOT in state root
+	for key := range reservedKeys {
+		keyStr := key.String()
+		if strings.Contains(stateRootStr, keyStr) {
+			t.Errorf("State root should NOT contain reserved key %s: %s", keyStr, stateRootStr)
+		}
+	}
+
+	// Verify that adding user data DOES change the state root
+	moreTxs := [][]byte{
+		[]byte("user/key3=value3"),
+	}
+	_, _, err = exec.ExecuteTxs(ctx, moreTxs, 2, time.Now(), stateRootAfterReservedKeyWrite)
+	if err != nil {
+		t.Fatalf("Failed to execute more transactions: %v", err)
+	}
+
+	finalStateRoot, err := exec.computeStateRoot(ctx)
+	if err != nil {
+		t.Fatalf("Failed to compute final state root: %v", err)
+	}
+
+	if string(baselineStateRoot) == string(finalStateRoot) {
+		t.Error("Expected state root to change after adding user data")
+	}
+}

block/manager.go

@@ -818,7 +818,7 @@ func (m *Manager) execValidate(lastState types.State, header *types.SignedHeader
 
 	// AppHash should match the last state's AppHash
 	if !bytes.Equal(header.AppHash, lastState.AppHash) {
-		return fmt.Errorf("appHash mismatch in delayed execution mode: expected %x, got %x", lastState.AppHash, header.AppHash)
+		return fmt.Errorf("appHash mismatch in delayed execution mode: expected %x, got %x at height %d", lastState.AppHash, header.AppHash, header.Height())
 	}
 
 	return nil

block/publish_block_p2p_test.go

@@ -178,7 +178,7 @@ func setupBlockManager(t *testing.T, ctx context.Context, workDir string, mainKV
 	}
 
 	logger := zerolog.Nop()
-	p2pClient, err := p2p.NewClient(nodeConfig, nodeKey, mainKV, logger, p2p.NopMetrics())
+	p2pClient, err := p2p.NewClient(nodeConfig.P2P, nodeKey.PrivKey, mainKV, genesisDoc.ChainID, logger, p2p.NopMetrics())
 	require.NoError(t, err)
 
 	// Start p2p client before creating sync service