feat: block production misbehavior detection

.mockery.yaml

@@ -35,6 +35,13 @@ packages:
   github.com/dymensionxyz/dymint/p2p:
     interfaces:
      GetProposerI:
+  github.com/dymensionxyz/dymint/block:
+    interfaces:
+      ExecutorI:
+  github.com/dymensionxyz/dymint/fraud:
+    interfaces:
+      Handler:
+
 
 
 

block/block.go

@@ -1,13 +1,30 @@
 package block
 
 import (
+	"context"
+	"errors"
 	"fmt"
+	"github.com/dymensionxyz/dymint/fraud"
 
 	errorsmod "cosmossdk.io/errors"
 
 	"github.com/dymensionxyz/dymint/types"
 )
 
+// applyBlockWithFraudHandling calls applyBlock and handles fraud errors.
+// Contract: block and commit must be validated before calling this function!
+func (m *Manager) applyBlockWithFraudHandling(block *types.Block, commit *types.Commit, blockMetaData types.BlockMetaData) error {
+	err := m.applyBlock(block, commit, blockMetaData)
+	if errors.Is(err, fraud.ErrFraud) {
+		m.FraudHandler.HandleFault(context.Background(), err)
+		return fmt.Errorf("apply block: %w", err)
+	} else if err != nil {
+		return fmt.Errorf("apply block: %w", err)
+	}
+
+	return nil
+}
+
 // applyBlock applies the block to the store and the abci app.
 // Contract: block and commit must be validated before calling this function!
 // steps: save block -> execute block with app -> update state -> commit block to app -> update state's height and commit result.
@@ -152,12 +169,11 @@ func (m *Manager) attemptApplyCachedBlocks() error {
 			return fmt.Errorf("block not valid at height %d, dropping it: err:%w", cachedBlock.Block.Header.Height, err)
 		}
 
-		err := m.applyBlock(cachedBlock.Block, cachedBlock.Commit, types.BlockMetaData{Source: cachedBlock.Source})
+		err := m.applyBlockWithFraudHandling(cachedBlock.Block, cachedBlock.Commit, types.BlockMetaData{Source: cachedBlock.Source})
 		if err != nil {
 			return fmt.Errorf("apply cached block: expected height: %d: %w", expectedHeight, err)
 		}
 		m.logger.Info("Block applied", "height", expectedHeight)
-
 	}
 
 	return nil

block/executor.go

@@ -19,6 +19,18 @@ import (
 // default minimum block max size allowed. not specific reason to set it to 10K, but we need to avoid no transactions can be included in a block.
 const minBlockMaxBytes = 10000
 
+type ExecutorI interface {
+	InitChain(genesis *tmtypes.GenesisDoc, valset []*tmtypes.Validator) (*abci.ResponseInitChain, error)
+	CreateBlock(height uint64, lastCommit *types.Commit, lastHeaderHash, nextSeqHash [32]byte, state *types.State, maxBlockDataSizeBytes uint64) *types.Block
+	Commit(state *types.State, block *types.Block, resp *tmstate.ABCIResponses) ([]byte, int64, error)
+	GetAppInfo() (*abci.ResponseInfo, error)
+	ExecuteBlock(state *types.State, block *types.Block) (*tmstate.ABCIResponses, error)
+	UpdateStateAfterInitChain(s *types.State, res *abci.ResponseInitChain)
+	UpdateMempoolAfterInitChain(s *types.State)
+	UpdateStateAfterCommit(s *types.State, resp *tmstate.ABCIResponses, appHash []byte, height uint64)
+	UpdateProposerFromBlock(s *types.State, block *types.Block) bool
+}
+
 // Executor creates and applies blocks and maintains state.
 type Executor struct {
 	localAddress          []byte
@@ -34,7 +46,7 @@ type Executor struct {
 
 // NewExecutor creates new instance of BlockExecutor.
 // localAddress will be used in sequencer mode only.
-func NewExecutor(localAddress []byte, chainID string, mempool mempool.Mempool, proxyApp proxy.AppConns, eventBus *tmtypes.EventBus, logger types.Logger) (*Executor, error) {
+func NewExecutor(localAddress []byte, chainID string, mempool mempool.Mempool, proxyApp proxy.AppConns, eventBus *tmtypes.EventBus, logger types.Logger) (ExecutorI, error) {
 	be := Executor{
 		localAddress:          localAddress,
 		chainID:               chainID,

block/fraud.go

@@ -0,0 +1,21 @@
+package block
+
+import (
+	"context"
+	"github.com/dymensionxyz/dymint/node/events"
+	uevent "github.com/dymensionxyz/dymint/utils/event"
+)
+
+type FreezeHandler struct {
+	m *Manager
+}
+
+func (f FreezeHandler) HandleFault(ctx context.Context, fault error) {
+	uevent.MustPublish(context.TODO(), f.m.Pubsub, &events.DataHealthStatus{Error: fault}, events.HealthStatusList)
+}
+
+func NewFreezeHandler(manager *Manager) *FreezeHandler {
+	return &FreezeHandler{
+		m: manager,
+	}
+}

block/manager.go

@@ -4,6 +4,7 @@
 	"context"
 	"errors"
 	"fmt"
+	"github.com/dymensionxyz/dymint/fraud"
 	"sync"
 	"sync/atomic"
 
@@ -45,7 +46,7 @@
 	// Store and execution
 	Store    store.Store
 	State    *types.State
-	Executor *Executor
+	Executor ExecutorI
 
 	// Clients and servers
 	Pubsub    *pubsub.Server
@@ -77,6 +78,9 @@
 
 	// TargetHeight holds the value of the current highest block seen from either p2p (probably higher) or the DA
 	TargetHeight atomic.Uint64
+
+	// Fraud handler
+	FraudHandler fraud.Handler
 }
 
 // NewManager creates new block Manager.
@@ -116,6 +120,7 @@
 		blockCache: &Cache{
 			cache: make(map[uint64]types.CachedBlock),
 		},
+		FraudHandler: nil, // TODO: create a default handler
 	}
 
 	err = m.LoadStateOnInit(store, genesis, logger)
@@ -137,6 +142,10 @@
 	return m, nil
 }
 
+func (m *Manager) SetFraudHandler(handler fraud.Handler) {
+	m.FraudHandler = handler
+}
+
 // Start starts the block manager.
 func (m *Manager) Start(ctx context.Context) error {
 	// Check if InitChain flow is needed
@@ -171,8 +180,8 @@
 		}()
 
 		// P2P Sync. Subscribe to P2P received blocks events
-		go uevent.MustSubscribe(ctx, m.Pubsub, "applyGossipedBlocksLoop", p2p.EventQueryNewGossipedBlock, m.onReceivedBlock, m.logger)
-		go uevent.MustSubscribe(ctx, m.Pubsub, "applyBlockSyncBlocksLoop", p2p.EventQueryNewBlockSyncBlock, m.onReceivedBlock, m.logger)
+		go uevent.MustSubscribe(ctx, m.Pubsub, "applyGossipedBlocksLoop", p2p.EventQueryNewGossipedBlock, m.OnReceivedBlock, m.logger)
+		go uevent.MustSubscribe(ctx, m.Pubsub, "applyBlockSyncBlocksLoop", p2p.EventQueryNewBlockSyncBlock, m.OnReceivedBlock, m.logger)
 		return nil
 	}