[Mempool] Implement custom mempool

app/ante.go

@@ -11,6 +11,7 @@ import (
 	authzkeeper "github.com/cosmos/cosmos-sdk/x/authz/keeper"
 	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
 
+	"github.com/bandprotocol/chain/v3/app/mempool"
 	bandtsskeeper "github.com/bandprotocol/chain/v3/x/bandtss/keeper"
 	feedskeeper "github.com/bandprotocol/chain/v3/x/feeds/keeper"
 	"github.com/bandprotocol/chain/v3/x/globalfee/feechecker"
@@ -23,15 +24,16 @@ import (
 // channel keeper.
 type HandlerOptions struct {
 	ante.HandlerOptions
-	Cdc             codec.Codec
-	AuthzKeeper     *authzkeeper.Keeper
-	OracleKeeper    *oraclekeeper.Keeper
-	IBCKeeper       *ibckeeper.Keeper
-	StakingKeeper   *stakingkeeper.Keeper
-	GlobalfeeKeeper *globalfeekeeper.Keeper
-	TSSKeeper       *tsskeeper.Keeper
-	BandtssKeeper   *bandtsskeeper.Keeper
-	FeedsKeeper     *feedskeeper.Keeper
+	Cdc                     codec.Codec
+	AuthzKeeper             *authzkeeper.Keeper
+	OracleKeeper            *oraclekeeper.Keeper
+	IBCKeeper               *ibckeeper.Keeper
+	StakingKeeper           *stakingkeeper.Keeper
+	GlobalfeeKeeper         *globalfeekeeper.Keeper
+	TSSKeeper               *tsskeeper.Keeper
+	BandtssKeeper           *bandtsskeeper.Keeper
+	FeedsKeeper             *feedskeeper.Keeper
+	IgnoreDecoratorMatchFns []mempool.TxMatchFn
 }
 
 func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
@@ -79,14 +81,8 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 
 	if options.TxFeeChecker == nil {
 		feeChecker := feechecker.NewFeeChecker(
-			options.Cdc,
-			options.AuthzKeeper,
-			options.OracleKeeper,
 			options.GlobalfeeKeeper,
 			options.StakingKeeper,
-			options.TSSKeeper,
-			options.BandtssKeeper,
-			options.FeedsKeeper,
 		)
 		options.TxFeeChecker = feeChecker.CheckTxFee
 	}
@@ -98,11 +94,14 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 		ante.NewTxTimeoutHeightDecorator(),
 		ante.NewValidateMemoDecorator(options.AccountKeeper),
 		ante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
-		ante.NewDeductFeeDecorator(
-			options.AccountKeeper,
-			options.BankKeeper,
-			options.FeegrantKeeper,
-			options.TxFeeChecker,
+		NewIgnoreDecorator(
+			ante.NewDeductFeeDecorator(
+				options.AccountKeeper,
+				options.BankKeeper,
+				options.FeegrantKeeper,
+				options.TxFeeChecker,
+			),
+			options.IgnoreDecoratorMatchFns...,
 		),
 		// SetPubKeyDecorator must be called before all signature verification decorators
 		ante.NewSetPubKeyDecorator(options.AccountKeeper),
@@ -115,3 +114,41 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 
 	return sdk.ChainAnteDecorators(anteDecorators...), nil
 }
+
+// IgnoreDecorator is an AnteDecorator that wraps an existing AnteDecorator. It allows
+// for the AnteDecorator to be ignored for specified lanes.
+type IgnoreDecorator struct {
+	decorator sdk.AnteDecorator
+	matchFns  []mempool.TxMatchFn
+}
+
+// NewIgnoreDecorator returns a new IgnoreDecorator instance.
+func NewIgnoreDecorator(decorator sdk.AnteDecorator, matchFns ...mempool.TxMatchFn) *IgnoreDecorator {
+	return &IgnoreDecorator{
+		decorator: decorator,
+		matchFns:  matchFns,
+	}
+}
+
+// NewIgnoreDecorator is a wrapper that implements the sdk.AnteDecorator interface,
+// providing two execution paths for processing transactions:
+//   - If a transaction matches one of the designated bypass lanes, it is forwarded
+//     directly to the next AnteHandler.
+//   - Otherwise, the transaction is processed using the embedded decorator’s AnteHandler.
+func (ig IgnoreDecorator) AnteHandle(
+	ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler,
+) (sdk.Context, error) {
+	// IgnoreDecorator is only used for check tx and re-check tx.
+	if !ctx.IsCheckTx() && !ctx.IsReCheckTx() {
+		return ig.decorator.AnteHandle(ctx, tx, simulate, next)
+	}
+
+	cacheCtx, _ := ctx.CacheContext()
+	for _, matchFn := range ig.matchFns {
+		if matchFn(cacheCtx, tx) {
+			return next(ctx, tx, simulate)
+		}
+	}
+
+	return ig.decorator.AnteHandle(ctx, tx, simulate, next)
+}

app/app.go

@@ -53,12 +53,15 @@ import (
 	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 
 	"github.com/bandprotocol/chain/v3/app/keepers"
+	"github.com/bandprotocol/chain/v3/app/mempool"
 	"github.com/bandprotocol/chain/v3/app/upgrades"
 	v3 "github.com/bandprotocol/chain/v3/app/upgrades/v3"
 	v3_rc4 "github.com/bandprotocol/chain/v3/app/upgrades/v3_rc4"
 	nodeservice "github.com/bandprotocol/chain/v3/client/grpc/node"
 	proofservice "github.com/bandprotocol/chain/v3/client/grpc/oracle/proof"
+	feedskeeper "github.com/bandprotocol/chain/v3/x/feeds/keeper"
 	oraclekeeper "github.com/bandprotocol/chain/v3/x/oracle/keeper"
+	tsskeeper "github.com/bandprotocol/chain/v3/x/tss/keeper"
 )
 
 var (
@@ -254,11 +257,22 @@ func NewBandApp(
 
 	app.sm.RegisterStoreDecoders()
 
+	lanes := CreateLanes(app)
+
+	// create Band mempool
+	bandMempool := mempool.NewMempool(app.Logger(), lanes)
+	// set the mempool
+	app.SetMempool(bandMempool)
+
 	// Initialize stores.
 	app.MountKVStores(app.GetKVStoreKey())
 	app.MountTransientStores(app.GetTransientStoreKey())
 	app.MountMemoryStores(app.GetMemoryStoreKey())
 
+	feedsMsgServer := feedskeeper.NewMsgServerImpl(app.FeedsKeeper)
+	tssMsgServer := tsskeeper.NewMsgServerImpl(app.TSSKeeper)
+	oracleMsgServer := oraclekeeper.NewMsgServerImpl(app.OracleKeeper)
+
 	anteHandler, err := NewAnteHandler(
 		HandlerOptions{
 			HandlerOptions: ante.HandlerOptions{
@@ -277,12 +291,24 @@ func NewBandApp(
 			IBCKeeper:       app.IBCKeeper,
 			StakingKeeper:   app.StakingKeeper,
 			GlobalfeeKeeper: &app.GlobalFeeKeeper,
+			IgnoreDecoratorMatchFns: []mempool.TxMatchFn{
+				feedsSubmitSignalPriceTxMatchHandler(app.appCodec, &app.AuthzKeeper, feedsMsgServer),
+				tssTxMatchHandler(app.appCodec, &app.AuthzKeeper, &app.BandtssKeeper, tssMsgServer),
+				oracleReportTxMatchHandler(app.appCodec, &app.AuthzKeeper, oracleMsgServer),
+			},
 		},
 	)
 	if err != nil {
 		panic(fmt.Errorf("failed to create ante handler: %s", err))
 	}
 
+	// proposal handler
+	proposalHandler := mempool.NewProposalHandler(app.Logger(), txConfig.TxDecoder(), bandMempool)
+
+	// set the Prepare / ProcessProposal Handlers on the app to be the `LanedMempool`'s
+	app.SetPrepareProposal(proposalHandler.PrepareProposalHandler())
+	app.SetProcessProposal(proposalHandler.ProcessProposalHandler())
+
 	postHandler, err := NewPostHandler(
 		PostHandlerOptions{},
 	)

app/lanes.go

@@ -0,0 +1,113 @@
+package band
+
+import (
+	channeltypes "github.com/cosmos/ibc-go/v8/modules/core/04-channel/types"
+
+	"cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkmempool "github.com/cosmos/cosmos-sdk/types/mempool"
+
+	"github.com/bandprotocol/chain/v3/app/mempool"
+	feedstypes "github.com/bandprotocol/chain/v3/x/feeds/types"
+	oracletypes "github.com/bandprotocol/chain/v3/x/oracle/types"
+	tsstypes "github.com/bandprotocol/chain/v3/x/tss/types"
+)
+
+// DefaultLaneMatchHandler is a function that returns the match function for the default lane.
+func DefaultLaneMatchHandler() mempool.TxMatchFn {
+	return func(_ sdk.Context, _ sdk.Tx) bool {
+		return true
+	}
+}
+
+// CreateLanes creates the lanes for the Band mempool.
+func CreateLanes(app *BandApp) []*mempool.Lane {
+	// feedsLane handles feeds submit signal price transactions.
+	// Each transaction has a gas limit of 2%, and the total gas limit for the lane is 50%.
+	// It uses SenderNonceMempool to ensure transactions are ordered by sender and nonce, with no per-sender tx limit.
+	feedsLane := mempool.NewLane(
+		app.Logger(),
+		app.txConfig.TxEncoder(),
+		"feedsLane",
+		mempool.NewLaneTxMatchFn([]sdk.Msg{&feedstypes.MsgSubmitSignalPrices{}}, true),
+		math.LegacyMustNewDecFromStr("0.02"),
+		math.LegacyMustNewDecFromStr("0.5"),
+		sdkmempool.NewSenderNonceMempool(sdkmempool.SenderNonceMaxTxOpt(0)),
+		nil,
+	)
+
+	// tssLane handles TSS transactions.
+	// Each transaction has a gas limit of 10%, and the total gas limit for the lane is 20%.
+	tssLane := mempool.NewLane(
+		app.Logger(),
+		app.txConfig.TxEncoder(),
+		"tssLane",
+		mempool.NewLaneTxMatchFn(
+			[]sdk.Msg{
+				&tsstypes.MsgSubmitDKGRound1{},
+				&tsstypes.MsgSubmitDKGRound2{},
+				&tsstypes.MsgConfirm{},
+				&tsstypes.MsgComplain{},
+				&tsstypes.MsgSubmitDEs{},
+				&tsstypes.MsgSubmitSignature{},
+			},
+			true,
+		),
+		math.LegacyMustNewDecFromStr("0.1"),
+		math.LegacyMustNewDecFromStr("0.2"),
+		sdkmempool.DefaultPriorityMempool(),
+		nil,
+	)
+
+	// oracleRequestLane handles oracle request data transactions.
+	// Each transaction has a gas limit of 10%, and the total gas limit for the lane is 10%.
+	// It is blocked if the oracle report lane exceeds its limit.
+	oracleRequestLane := mempool.NewLane(
+		app.Logger(),
+		app.txConfig.TxEncoder(),
+		"oracleRequestLane",
+		mempool.NewLaneTxMatchFn(
+			[]sdk.Msg{
+				&oracletypes.MsgRequestData{},
+				&channeltypes.MsgRecvPacket{}, // TODO: Only match oracle request packet
+			},
+			false,
+		),
+		math.LegacyMustNewDecFromStr("0.1"),
+		math.LegacyMustNewDecFromStr("0.1"),
+		sdkmempool.DefaultPriorityMempool(),
+		nil,
+	)
+
+	// oracleReportLane handles oracle report data transactions.
+	// Each transaction has a gas limit of 10%, and the total gas limit for the lane is 20%.
+	// It block the oracle request lane if it exceeds its limit.
+	oracleReportLane := mempool.NewLane(
+		app.Logger(),
+		app.txConfig.TxEncoder(),
+		"oracleReportLane",
+		mempool.NewLaneTxMatchFn([]sdk.Msg{&oracletypes.MsgReportData{}}, true),
+		math.LegacyMustNewDecFromStr("0.1"),
+		math.LegacyMustNewDecFromStr("0.2"),
+		sdkmempool.DefaultPriorityMempool(),
+		func(isLaneLimitExceeded bool) {
+			oracleRequestLane.SetBlocked(isLaneLimitExceeded)
+		},
+	)
+
+	// defaultLane handles all other transactions.
+	// Each transaction has a gas limit of 10%, and the total gas limit for the lane is 10%.
+	defaultLane := mempool.NewLane(
+		app.Logger(),
+		app.txConfig.TxEncoder(),
+		"defaultLane",
+		DefaultLaneMatchHandler(),
+		math.LegacyMustNewDecFromStr("0.1"),
+		math.LegacyMustNewDecFromStr("0.1"),
+		sdkmempool.DefaultPriorityMempool(),
+		nil,
+	)
+
+	return []*mempool.Lane{feedsLane, tssLane, oracleReportLane, oracleRequestLane, defaultLane}
+}