Revert "feat: execution verification (#2377)"

This reverts commit 1ca8457.
Manav-Aggarwal · Jul 1, 2025 · Jun 25, 2025 · Jun 25, 2025 · Jun 25, 2025 · Jun 25, 2025
commit 0c8d343e12c44293fa3362304c159f6211a73f09
diff --git a/apps/testapp/go.mod b/apps/testapp/go.mod
@@ -12,7 +12,6 @@ replace (
 require (
 	github.com/ipfs/go-datastore v0.8.2
 	github.com/rollkit/rollkit v0.0.0-00010101000000-000000000000
-	github.com/rollkit/rollkit/core v0.0.0-20250312114929-104787ba1a4c
 	github.com/rollkit/rollkit/da v0.0.0-00010101000000-000000000000
 	github.com/rollkit/rollkit/sequencers/single v0.0.0-00010101000000-000000000000
 	github.com/spf13/cobra v1.9.1
@@ -142,6 +141,7 @@ require (
 	github.com/quic-go/quic-go v0.50.1 // indirect
 	github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66 // indirect
 	github.com/raulk/go-watchdog v1.3.0 // indirect
+	github.com/rollkit/rollkit/core v0.0.0-20250312114929-104787ba1a4c // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect

diff --git a/apps/testapp/kv/kvexecutor.go b/apps/testapp/kv/kvexecutor.go
@@ -10,7 +10,6 @@ import (
 
 	ds "github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/query"
-	"github.com/rollkit/rollkit/core/execution"
 	"github.com/rollkit/rollkit/pkg/store"
 )
 
@@ -244,12 +243,6 @@ func (k *KVExecutor) SetFinal(ctx context.Context, blockHeight uint64) error {
 	return k.db.Put(ctx, ds.NewKey("/finalizedHeight"), []byte(fmt.Sprintf("%d", blockHeight)))
 }
 
-// GetExecutionMode returns the execution mode for this executor.
-// KVExecutor uses delayed execution mode.
-func (k *KVExecutor) GetExecutionMode() execution.ExecutionMode {
-	return execution.ExecutionModeDelayed
-}
-
 // InjectTx adds a transaction to the mempool channel.
 // Uses a non-blocking send to avoid blocking the caller if the channel is full.
 func (k *KVExecutor) InjectTx(tx []byte) {

diff --git a/block/manager.go b/block/manager.go
@@ -147,8 +147,6 @@ type Manager struct {
 	metrics *Metrics
 
 	exec coreexecutor.Executor
-	// executionMode caches the execution mode from the executor
-	executionMode coreexecutor.ExecutionMode
 
 	// daIncludedHeight is rollkit height at which all blocks have been included
 	// in the DA
@@ -353,8 +351,6 @@ func NewManager(
 	daH := atomic.Uint64{}
 	daH.Store(s.DAHeight)
 
-	executionMode := exec.GetExecutionMode()
-
 	m := &Manager{
 		signer:            signer,
 		config:            config,
@@ -384,7 +380,6 @@ func NewManager(
 		metrics:                  seqMetrics,
 		sequencer:                sequencer,
 		exec:                     exec,
-		executionMode:            executionMode,
 		da:                       da,
 		gasPrice:                 gasPrice,
 		gasMultiplier:            gasMultiplier,
@@ -805,26 +800,22 @@ func (m *Manager) execValidate(lastState types.State, header *types.SignedHeader
 	}
 
 	// // Verify that the header's timestamp is strictly greater than the last block's time
-	headerTime := header.Time()
-	if header.Height() > 1 && lastState.LastBlockTime.After(headerTime) {
-		return fmt.Errorf("block time must be strictly increasing: got %v, last block time was %v",
-			headerTime.UnixNano(), lastState.LastBlockTime)
-	}
-
-	// Validate AppHash based on execution mode
-	if m.executionMode == coreexecutor.ExecutionModeDelayed {
-		// In delayed mode, AppHash should match the last state's AppHash
-		if !bytes.Equal(header.AppHash, lastState.AppHash) {
-			return fmt.Errorf("appHash mismatch in delayed mode: expected %x, got %x", lastState.AppHash, header.AppHash)
-		}
-	}
-	// Note: For immediate mode, we can't validate AppHash against lastState because
-	// it represents the state after executing the current block's transactions
+	// headerTime := header.Time()
+	// if header.Height() > 1 && lastState.LastBlockTime.After(headerTime) {
+	// 	return fmt.Errorf("block time must be strictly increasing: got %v, last block time was %v",
+	// 		headerTime.UnixNano(), lastState.LastBlockTime)
+	// }
+
+	// // Validate that the header's AppHash matches the lastState's AppHash
+	// // Note: Assumes deferred execution
+	// if !bytes.Equal(header.AppHash, lastState.AppHash) {
+	// 	return fmt.Errorf("app hash mismatch: expected %x, got %x", lastState.AppHash, header.AppHash)
+	// }
 
 	return nil
 }
 
-func (m *Manager) execCreateBlock(ctx context.Context, height uint64, lastSignature *types.Signature, lastHeaderHash types.Hash, lastState types.State, batchData *BatchData) (*types.SignedHeader, *types.Data, error) {
+func (m *Manager) execCreateBlock(_ context.Context, height uint64, lastSignature *types.Signature, lastHeaderHash types.Hash, _ types.State, batchData *BatchData) (*types.SignedHeader, *types.Data, error) {
 	// Use when batchData is set to data IDs from the DA layer
 	// batchDataIDs := convertBatchDataToBytes(batchData.Data)
 
@@ -849,54 +840,21 @@ func (m *Manager) execCreateBlock(ctx context.Context, height uint64, lastSignat
 	// Determine if this is an empty block
 	isEmpty := batchData.Batch == nil || len(batchData.Transactions) == 0
 
-	// Create block data with appropriate transactions
-	blockData := &types.Data{
-		Txs: make(types.Txs, 0), // Start with empty transaction list
-	}
-
-	// Only add transactions if this is not an empty block
-	if !isEmpty {
-		blockData.Txs = make(types.Txs, len(batchData.Transactions))
-		for i := range batchData.Transactions {
-			blockData.Txs[i] = types.Tx(batchData.Transactions[i])
-		}
-	}
-
-	// Determine AppHash based on execution mode
-	var appHash []byte
-	if m.executionMode == coreexecutor.ExecutionModeImmediate && !isEmpty {
-		// For immediate execution, execute transactions now to get the new state root
-		rawTxs := make([][]byte, len(blockData.Txs))
-		for i := range blockData.Txs {
-			rawTxs[i] = blockData.Txs[i]
-		}
-
-		// Execute transactions
-		newStateRoot, _, err := m.exec.ExecuteTxs(ctx, rawTxs, height, batchData.Time, lastState.AppHash)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to execute transactions for immediate mode: %w", err)
-		}
-		appHash = newStateRoot
-	} else {
-		// For delayed execution or empty blocks, use the app hash from last state
-		appHash = lastState.AppHash
-	}
-
 	header := &types.SignedHeader{
 		Header: types.Header{
 			Version: types.Version{
-				Block: lastState.Version.Block,
-				App:   lastState.Version.App,
+				Block: m.lastState.Version.Block,
+				App:   m.lastState.Version.App,
 			},
 			BaseHeader: types.BaseHeader{
-				ChainID: lastState.ChainID,
+				ChainID: m.lastState.ChainID,
 				Height:  height,
 				Time:    uint64(batchData.UnixNano()), //nolint:gosec // why is time unix? (tac0turtle)
 			},
 			LastHeaderHash: lastHeaderHash,
-			// DataHash is set below
+			// DataHash is set at the end of the function
 			ConsensusHash:   make(types.Hash, 32),
-			AppHash:         appHash,
+			AppHash:         m.lastState.AppHash,
 			ProposerAddress: m.genesis.ProposerAddress,
 		},
 		Signature: *lastSignature,
@@ -906,8 +864,17 @@ func (m *Manager) execCreateBlock(ctx context.Context, height uint64, lastSignat
 		},
 	}
 
-	// Set DataHash
+	// Create block data with appropriate transactions
+	blockData := &types.Data{
+		Txs: make(types.Txs, 0), // Start with empty transaction list
+	}
+
+	// Only add transactions if this is not an empty block
 	if !isEmpty {
+		blockData.Txs = make(types.Txs, len(batchData.Transactions))
+		for i := range batchData.Transactions {
+			blockData.Txs[i] = types.Tx(batchData.Transactions[i])
+		}
 		header.DataHash = blockData.DACommitment()
 	} else {
 		header.DataHash = dataHashForEmptyTxs
@@ -917,61 +884,15 @@ func (m *Manager) execCreateBlock(ctx context.Context, height uint64, lastSignat
 }
 
 func (m *Manager) execApplyBlock(ctx context.Context, lastState types.State, header *types.SignedHeader, data *types.Data) (types.State, error) {
-	var newStateRoot []byte
-
-	// Check if we need to execute transactions
-	if m.executionMode == coreexecutor.ExecutionModeImmediate {
-		// For immediate mode, the aggregator already executed during block creation
-		// But syncing nodes need to execute to verify the AppHash
-		// Check if we're the block creator by verifying we signed this block
-		isBlockCreator := false
-		if m.signer != nil {
-			myAddress, err := m.signer.GetAddress()
-			if err == nil && bytes.Equal(header.ProposerAddress, myAddress) {
-				// Also verify this is the current height we're producing
-				currentHeight, err := m.store.Height(ctx)
-				if err == nil && header.Height() == currentHeight+1 {
-					isBlockCreator = true
-				}
-			}
-		}
-
-		if isBlockCreator {
-			// We created this block, so we already executed transactions in execCreateBlock
-			// Just use the AppHash from the header
-			newStateRoot = header.AppHash
-		} else {
-			// We're syncing this block, need to execute to verify AppHash
-			rawTxs := make([][]byte, len(data.Txs))
-			for i := range data.Txs {
-				rawTxs[i] = data.Txs[i]
-			}
-
-			ctx = context.WithValue(ctx, types.SignedHeaderContextKey, header)
-			computedStateRoot, _, err := m.exec.ExecuteTxs(ctx, rawTxs, header.Height(), header.Time(), lastState.AppHash)
-			if err != nil {
-				return types.State{}, fmt.Errorf("failed to execute transactions: %w", err)
-			}
-
-			// Verify the AppHash matches
-			if !bytes.Equal(header.AppHash, computedStateRoot) {
-				return types.State{}, fmt.Errorf("AppHash mismatch in immediate mode: expected %x, got %x", computedStateRoot, header.AppHash)
-			}
-			newStateRoot = computedStateRoot
-		}
-	} else {
-		// For delayed mode, always execute transactions
-		rawTxs := make([][]byte, len(data.Txs))
-		for i := range data.Txs {
-			rawTxs[i] = data.Txs[i]
-		}
+	rawTxs := make([][]byte, len(data.Txs))
+	for i := range data.Txs {
+		rawTxs[i] = data.Txs[i]
+	}
 
-		ctx = context.WithValue(ctx, types.SignedHeaderContextKey, header)
-		var err error
-		newStateRoot, _, err = m.exec.ExecuteTxs(ctx, rawTxs, header.Height(), header.Time(), lastState.AppHash)
-		if err != nil {
-			return types.State{}, fmt.Errorf("failed to execute transactions: %w", err)
-		}
+	ctx = context.WithValue(ctx, types.SignedHeaderContextKey, header)
+	newStateRoot, _, err := m.exec.ExecuteTxs(ctx, rawTxs, header.Height(), header.Time(), lastState.AppHash)
+	if err != nil {
+		return types.State{}, fmt.Errorf("failed to execute transactions: %w", err)
 	}
 
 	s, err := lastState.NextState(header, newStateRoot)

diff --git a/block/manager_test.go b/block/manager_test.go
@@ -575,26 +575,28 @@ func TestManager_execValidate(t *testing.T) {
 		require.NoError(err)
 	})
 
-	t.Run("non-monotonic block time with height > 1", func(t *testing.T) {
-		state, header, data, privKey := makeValid()
-		state.LastBlockTime = time.Now().Add(time.Minute)
-		state.LastBlockHeight = 1
-		header.BaseHeader.Height = state.LastBlockHeight + 1
-		data.Metadata.Height = state.LastBlockHeight + 1
-		signer, err := noopsigner.NewNoopSigner(privKey)
-		require.NoError(err)
-		header.Signature, err = types.GetSignature(header.Header, signer)
-		require.NoError(err)
-		err = m.execValidate(state, header, data)
-		require.ErrorContains(err, "block time must be strictly increasing")
-	})
-
-	t.Run("app hash mismatch", func(t *testing.T) {
-		state, header, data, _ := makeValid()
-		state.AppHash = []byte("different")
-		err := m.execValidate(state, header, data)
-		require.ErrorContains(err, "appHash mismatch in delayed mode")
-	})
+	// TODO: https://github.com/rollkit/rollkit/issues/2250
+
+	// t.Run("non-monotonic block time with height > 1", func(t *testing.T) {
+	// 	state, header, data, privKey := makeValid()
+	// 	state.LastBlockTime = time.Now().Add(time.Minute)
+	// 	state.LastBlockHeight = 1
+	// 	header.BaseHeader.Height = state.LastBlockHeight + 1
+	// 	data.Metadata.Height = state.LastBlockHeight + 1
+	// 	signer, err := noopsigner.NewNoopSigner(privKey)
+	// 	require.NoError(err)
+	// 	header.Signature, err = types.GetSignature(header.Header, signer)
+	// 	require.NoError(err)
+	// 	err = m.execValidate(state, header, data)
+	// 	require.ErrorContains(err, "block time must be strictly increasing")
+	// })
+
+	// t.Run("app hash mismatch", func(t *testing.T) {
+	// 	state, header, data, _ := makeValid()
+	// 	state.AppHash = []byte("different")
+	// 	err := m.execValidate(state, header, data)
+	// 	require.ErrorContains(err, "app hash mismatch")
+	// })
 }
 
 // TestGetterMethods tests simple getter methods for the Manager

diff --git a/block/publish_block_p2p_test.go b/block/publish_block_p2p_test.go
@@ -19,7 +19,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	coreexecution "github.com/rollkit/rollkit/core/execution"
 	coresequencer "github.com/rollkit/rollkit/core/sequencer"
 	"github.com/rollkit/rollkit/pkg/config"
 	genesispkg "github.com/rollkit/rollkit/pkg/genesis"
@@ -242,10 +241,6 @@ func (m mockExecutor) SetFinal(ctx context.Context, blockHeight uint64) error {
 	return nil
 }
 
-func (m mockExecutor) GetExecutionMode() coreexecution.ExecutionMode {
-	return coreexecution.ExecutionModeDelayed
-}
-
 var rnd = rand.New(rand.NewSource(1)) //nolint:gosec // test code only
 
 func bytesN(n int) []byte {

diff --git a/core/execution/dummy.go b/core/execution/dummy.go
@@ -91,12 +91,6 @@ func (e *DummyExecutor) SetFinal(ctx context.Context, blockHeight uint64) error
 	return fmt.Errorf("cannot set finalized block at height %d", blockHeight)
 }
 
-// GetExecutionMode returns the execution mode for this executor.
-// DummyExecutor uses delayed execution mode.
-func (e *DummyExecutor) GetExecutionMode() ExecutionMode {
-	return ExecutionModeDelayed
-}
-
 func (e *DummyExecutor) removeExecutedTxs(txs [][]byte) {
 	e.injectedTxs = slices.DeleteFunc(e.injectedTxs, func(tx []byte) bool {
 		return slices.ContainsFunc(txs, func(t []byte) bool { return bytes.Equal(tx, t) })

diff --git a/core/execution/execution.go b/core/execution/execution.go
@@ -5,23 +5,6 @@ import (
 	"time"
 )
 
-// ExecutionMode defines when state transitions are applied relative to block creation
-type ExecutionMode int
-
-const (
-	// ExecutionModeDelayed means the AppHash in block N represents the state after executing block N-1
-	// This is the traditional approach used by CometBFT/Tendermint
-	ExecutionModeDelayed ExecutionMode = iota
-
-	// ExecutionModeImmediate means the AppHash in block N represents the state after executing block N
-	// Transactions are executed during block creation and the resulting state root is included
-	ExecutionModeImmediate
-
-	// ExecutionModeOptimistic means transactions are executed optimistically and finalized later
-	// This allows for faster block creation but requires a finalization step to confirm state
-	// ExecutionModeOptimistic
-)
-
 // Executor defines the interface that execution clients must implement to be compatible with Rollkit.
 // This interface enables the separation between consensus and execution layers, allowing for modular
 // and pluggable execution environments.
@@ -70,7 +53,6 @@ type Executor interface {
 	// - Must maintain deterministic execution
 	// - Must respect context cancellation/timeout
 	// - The rest of the rules are defined by the specific execution layer
-	// - Must verify state root after execution
 	//
 	// Parameters:
 	// - ctx: Context for timeout/cancellation control
@@ -100,17 +82,4 @@ type Executor interface {
 	// Returns:
 	// - error: Any errors during finalization
 	SetFinal(ctx context.Context, blockHeight uint64) error
-
-	// GetExecutionMode returns the execution mode supported by this executor.
-	// This determines when state transitions are applied:
-	// - Delayed: AppHash in block N represents state after executing block N-1
-	// - Immediate: AppHash in block N represents state after executing block N
-	//
-	// Requirements:
-	// - Must return consistent value across all calls
-	// - Mode cannot change after initialization
-	//
-	// Returns:
-	// - ExecutionMode: The execution mode supported by this executor
-	GetExecutionMode() ExecutionMode
 }
diff --git a/execution/evm/execution.go b/execution/evm/execution.go
@@ -307,13 +307,6 @@ func (c *EngineClient) SetFinal(ctx context.Context, blockHeight uint64) error {
 	return c.setFinal(ctx, blockHash, true)
 }
 
-// GetExecutionMode returns the execution mode for this executor.
-// EngineClient uses immediate execution mode since it calculates the state root
-// during transaction execution via engine_getPayloadV4.
-func (c *EngineClient) GetExecutionMode() execution.ExecutionMode {
-	return execution.ExecutionModeImmediate
-}
-
 func (c *EngineClient) derivePrevRandao(blockHeight uint64) common.Hash {
 	return common.BigToHash(new(big.Int).SetUint64(blockHeight))
 }