feat: Optimistic Execution

baseapp/abci.go

@@ -1,9 +1,11 @@
 package baseapp
 
 import (
+	"bytes"
 	"context"
 	"crypto/sha256"
 	"fmt"
+	"log"
 	"os"
 	"sort"
 	"strings"
@@ -532,6 +534,34 @@ func (app *BaseApp) ProcessProposal(req *abci.RequestProcessProposal) (resp *abc
 		return &abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_REJECT}, nil
 	}
 
+	if app.oeEnabled {
+		if app.oeInfo == nil {
+			completionSignal := make(chan struct{})
+			app.oeInfo = &OptimisticExecutionInfo{
+				Completion: completionSignal,
+				Request: &abci.RequestFinalizeBlock{
+					Txs:                req.Txs,
+					DecidedLastCommit:  req.ProposedLastCommit,
+					Misbehavior:        req.Misbehavior,
+					Hash:               req.Hash,
+					Height:             req.Height,
+					Time:               req.Time,
+					NextValidatorsHash: req.NextValidatorsHash,
+					ProposerAddress:    req.ProposerAddress,
+				},
+			}
+
+			go func() {
+				log.Println("Running OE ✅")
+				app.oeInfo.Response, app.oeInfo.Error = app.internalFinalizeBlock(app.oeInfo.Request)
+				app.oeInfo.Completion <- struct{}{}
+			}()
+
+		} else if !bytes.Equal(app.oeInfo.Request.Hash, req.Hash) {
+			app.oeInfo.Aborted = true
+		}
+	}
+
 	return resp, nil
 }
 
@@ -635,17 +665,7 @@ func (app *BaseApp) VerifyVoteExtension(req *abci.RequestVerifyVoteExtension) (r
 	return resp, err
 }
 
-// FinalizeBlock will execute the block proposal provided by RequestFinalizeBlock.
-// Specifically, it will execute an application's BeginBlock (if defined), followed
-// by the transactions in the proposal, finally followed by the application's
-// EndBlock (if defined).
-//
-// For each raw transaction, i.e. a byte slice, BaseApp will only execute it if
-// it adheres to the sdk.Tx interface. Otherwise, the raw transaction will be
-// skipped. This is to support compatibility with proposers injecting vote
-// extensions into the proposal, which should not themselves be executed in cases
-// where they adhere to the sdk.Tx interface.
-func (app *BaseApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) {
+func (app *BaseApp) internalFinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) {
 	var events []abci.Event
 
 	if err := app.validateFinalizeBlockHeight(req); err != nil {
@@ -711,7 +731,11 @@ func (app *BaseApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.Respons
 			WithHeaderHash(req.Hash)
 	}
 
-	beginBlock := app.beginBlock(req)
+	beginBlock, err := app.beginBlock(req)
+	if err != nil {
+		return nil, err
+	}
+
 	events = append(events, beginBlock.Events...)
 
 	// Iterate over all raw transactions in the proposal and attempt to execute
@@ -747,6 +771,32 @@ func (app *BaseApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.Respons
 	}, nil
 }
 
+// FinalizeBlock will execute the block proposal provided by RequestFinalizeBlock.
+// Specifically, it will execute an application's BeginBlock (if defined), followed
+// by the transactions in the proposal, finally followed by the application's
+// EndBlock (if defined).
+//
+// For each raw transaction, i.e. a byte slice, BaseApp will only execute it if
+// it adheres to the sdk.Tx interface. Otherwise, the raw transaction will be
+// skipped. This is to support compatibility with proposers injecting vote
+// extensions into the proposal, which should not themselves be executed in cases
+// where they adhere to the sdk.Tx interface.
+func (app *BaseApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.ResponseFinalizeBlock, error) {
+	defer func() {
+		app.oeInfo = nil
+	}()
+
+	if app.oeInfo != nil && app.oeEnabled {
+		<-app.oeInfo.Completion
+		if !app.oeInfo.Aborted && bytes.Equal(app.oeInfo.Request.Hash, req.Hash) {
+			return app.oeInfo.Response, app.oeInfo.Error
+		}
+	}
+
+	log.Println("NOT running OE ❌")
+	return app.internalFinalizeBlock(req)
+}
+
 // Commit implements the ABCI interface. It will commit all state that exists in
 // the deliver state's multi-store and includes the resulting commit ID in the
 // returned abci.ResponseCommit. Commit will set the check state based on the

baseapp/abci_test.go

@@ -1171,11 +1171,11 @@ func TestABCI_Proposal_HappyPath(t *testing.T) {
 
 	res, err := suite.baseApp.FinalizeBlock(&abci.RequestFinalizeBlock{
 		Height: suite.baseApp.LastBlockHeight() + 1,
-		Txs:    [][]byte{txBytes},
+		Txs:    reqProposalTxBytes[:],
 	})
 	require.NoError(t, err)
 
-	require.Equal(t, 1, pool.CountTx())
+	require.Equal(t, 0, pool.CountTx())
 
 	require.NotEmpty(t, res.TxResults[0].Events)
 	require.True(t, res.TxResults[0].IsOK(), fmt.Sprintf("%v", res))

baseapp/baseapp.go

@@ -179,6 +179,9 @@ type BaseApp struct {
 	chainID string
 
 	cdc codec.Codec
+
+	oeInfo    *OptimisticExecutionInfo
+	oeEnabled bool
 }
 
 // NewBaseApp returns a reference to an initialized BaseApp. It accepts a
@@ -197,6 +200,7 @@ func NewBaseApp(
 		msgServiceRouter: NewMsgServiceRouter(),
 		txDecoder:        txDecoder,
 		fauxMerkleMode:   false,
+		oeEnabled:        true,
 	}
 
 	for _, option := range options {
@@ -679,7 +683,7 @@ func (app *BaseApp) cacheTxContext(ctx sdk.Context, txBytes []byte) (sdk.Context
 	return ctx.WithMultiStore(msCache), msCache
 }
 
-func (app *BaseApp) beginBlock(req *abci.RequestFinalizeBlock) sdk.BeginBlock {
+func (app *BaseApp) beginBlock(req *abci.RequestFinalizeBlock) (sdk.BeginBlock, error) {
 	var (
 		resp sdk.BeginBlock
 		err  error
@@ -688,7 +692,7 @@ func (app *BaseApp) beginBlock(req *abci.RequestFinalizeBlock) sdk.BeginBlock {
 	if app.beginBlocker != nil {
 		resp, err = app.beginBlocker(app.finalizeBlockState.ctx)
 		if err != nil {
-			panic(err)
+			return resp, err
 		}
 
 		// append BeginBlock attributes to all events in the EndBlock response
@@ -702,7 +706,7 @@ func (app *BaseApp) beginBlock(req *abci.RequestFinalizeBlock) sdk.BeginBlock {
 		resp.Events = sdk.MarkEventsToIndex(resp.Events, app.indexEvents)
 	}
 
-	return resp
+	return resp, nil
 }
 
 func (app *BaseApp) deliverTx(tx []byte) *abci.ExecTxResult {
@@ -750,7 +754,7 @@ func (app *BaseApp) endBlock(ctx context.Context) (sdk.EndBlock, error) {
 	if app.endBlocker != nil {
 		eb, err := app.endBlocker(app.finalizeBlockState.ctx)
 		if err != nil {
-			panic(err)
+			return endblock, err
 		}
 
 		// append EndBlock attributes to all events in the EndBlock response

baseapp/optimistic_execution.go

@@ -0,0 +1,11 @@
+package baseapp
+
+import abci "github.com/cometbft/cometbft/abci/types"
+
+type OptimisticExecutionInfo struct {
+	Aborted    bool
+	Completion chan struct{}
+	Request    *abci.RequestFinalizeBlock
+	Response   *abci.ResponseFinalizeBlock
+	Error      error
+}