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,40 @@ 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() {
+				defer func() {
+					if r := recover(); r != nil {
+						log.Println("⚡️⚡️⚡️ RECOVERED PANIC IN OE")
+						app.oeInfo.Panic = r
+					}
+				}()
+				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 +671,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 {
@@ -712,6 +738,7 @@ func (app *BaseApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.Respons
 	}
 
 	beginBlock := app.beginBlock(req)
+
 	events = append(events, beginBlock.Events...)
 
 	// Iterate over all raw transactions in the proposal and attempt to execute
@@ -747,6 +774,36 @@ 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 {
+		if app.oeInfo.Panic != nil {
+			panic(app.oeInfo.Panic)
+		}
+
+		<-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/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 {

baseapp/optimistic_execution.go

@@ -0,0 +1,12 @@
+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
+	Panic      interface{}
+}