chore: complete poc for hyperlane app middleware

Author: 0xstepit

tests/simapp/app.go

@@ -198,6 +198,8 @@ func NewMiniAppWithCustomConfig(
 
 	app.App = appBuilder.Build(db, traceStore, baseAppOptions...)
 
+	app.RegisterWarpApps()
+
 	// register streaming services
 	if err := app.RegisterStreamingServices(appOpts, app.kvStoreKeys()); err != nil {
 		return nil, err

tests/simapp/warp.go

@@ -0,0 +1,16 @@
+package simapp
+
+import (
+	warp "github.com/bcp-innovations/hyperlane-cosmos/x/warp"
+	warpTypes "github.com/bcp-innovations/hyperlane-cosmos/x/warp/types"
+)
+
+func (app *App) RegisterWarpApps() {
+
+	warpApps := []warp.WarpApp{
+		{TokenType: warpTypes.HYP_TOKEN_TYPE_COLLATERAL, App: &app.WarpKeeper},
+		{TokenType: warpTypes.HYP_TOKEN_TYPE_SYNTHETIC, App: &app.WarpKeeper},
+	}
+
+	warp.RegisterWarpApp(app.HyperlaneKeeper, warpApps...)
+}

x/core/keeper/keeper.go

@@ -87,6 +87,10 @@ func (k Keeper) AppRouter() *util.Router[util.HyperlaneApp] {
 	return k.appRouter
 }
 
+func (k Keeper) RegisterApp(moduleId uint8, module util.HyperlaneApp) {
+	k.appRouter.RegisterModule(moduleId, module)
+}
+
 func (k *Keeper) ReceiverIsmId(ctx context.Context, recipient util.HexAddress) (util.HexAddress, error) {
 	handler, err := k.appRouter.GetModule(recipient)
 	if err != nil {

x/warp/depinject.go

@@ -7,6 +7,7 @@ import (
 	"cosmossdk.io/core/store"
 	"cosmossdk.io/depinject"
 	modulev1 "github.com/bcp-innovations/hyperlane-cosmos/api/warp/module/v1"
+	"github.com/bcp-innovations/hyperlane-cosmos/util"
 	coreKeeper "github.com/bcp-innovations/hyperlane-cosmos/x/core/keeper"
 	"github.com/bcp-innovations/hyperlane-cosmos/x/warp/keeper"
 	"github.com/bcp-innovations/hyperlane-cosmos/x/warp/types"
@@ -61,6 +62,17 @@ func ProvideModule(in ModuleInputs) ModuleOutputs {
 	return ModuleOutputs{Module: m, Keeper: k}
 }
 
+type WarpApp struct {
+	TokenType types.HypTokenType
+	App       util.HyperlaneApp
+}
+
+func RegisterWarpApp(coreKeeper *coreKeeper.Keeper, warpApps ...WarpApp) {
+	for _, warpApp := range warpApps {
+		coreKeeper.RegisterApp(uint8(warpApp.TokenType), warpApp.App)
+	}
+}
+
 // AutoCLIOptions implements the autocli.HasAutoCLIConfig interface.
 func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
 	return &autocliv1.ModuleOptions{}

x/warp/keeper/keeper.go

@@ -74,9 +74,6 @@ func NewKeeper(
 		panic(err)
 	}
 
-	coreKeeper.AppRouter().RegisterModule(uint8(types.HYP_TOKEN_TYPE_COLLATERAL), &k)
-	coreKeeper.AppRouter().RegisterModule(uint8(types.HYP_TOKEN_TYPE_SYNTHETIC), &k)
-
 	k.Schema = schema
 
 	return k

x/warp/middleware/hook.go

@@ -0,0 +1,63 @@
+package middleware
+
+import (
+	"context"
+	"github.com/bcp-innovations/hyperlane-cosmos/util"
+)
+
+// HandleFn is the signature of the Handle function of an Hyperlane application.
+type HandleFn = func(ctx context.Context, mailboxId util.HexAddress, message util.HyperlaneMessage) error
+
+type HandleHookI interface {
+	PreHandleHook(ctx context.Context, mailboxID util.HexAddress, message util.HyperlaneMessage) error
+	PostHandleHook(ctx context.Context, mailboxID util.HexAddress, message util.HyperlaneMessage) error
+}
+
+type HandleHook struct {
+	// preHandleHook is the behavior expected from a type that hook BEFORE executing
+	// the Hyperlane application Handle method.
+	preHandleFn HandleFn
+
+	// postHandleHook is the behavior expected from a type that hook AFTER executing
+	// the Hyperlane application Handle method.
+	postHandleFn HandleFn
+}
+
+func (h *HandleHook) PreHandleHook(ctx context.Context, mailboxID util.HexAddress, message util.HyperlaneMessage) error {
+	if h.preHandleFn != nil {
+		return h.preHandleFn(ctx, mailboxID, message)
+	}
+
+	return nil
+}
+
+func (h *HandleHook) PostHandleHook(ctx context.Context, mailboxID util.HexAddress, message util.HyperlaneMessage) error {
+	if h.postHandleFn != nil {
+		return h.postHandleFn(ctx, mailboxID, message)
+	}
+
+	return nil
+}
+
+func NewHandleHook(opts ...HandleHookOpt) *HandleHook {
+	h := &HandleHook{}
+
+	for _, opt := range opts {
+		opt(h)
+	}
+	return h
+}
+
+type HandleHookOpt func(*HandleHook)
+
+func WithPreHandleHookFn(fn HandleFn) HandleHookOpt {
+	return func(h *HandleHook) {
+		h.preHandleFn = fn
+	}
+}
+
+func WithPostHandleFn(fn HandleFn) HandleHookOpt {
+	return func(h *HandleHook) {
+		h.postHandleFn = fn
+	}
+}

x/warp/middleware/middleware.go

@@ -0,0 +1,56 @@
+package middleware
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bcp-innovations/hyperlane-cosmos/util"
+)
+
+// AppMiddleware defines the behavior an Hyperlane application middleware must implement.
+type AppMiddleware interface {
+	util.HyperlaneApp
+}
+
+var _ AppMiddleware = (*Middleware)(nil)
+
+// Middleware is the default concrete type used to implement an Hyperlane
+// application middleware.
+type Middleware struct {
+	util.HyperlaneApp
+	hook HandleHookI
+}
+
+func NewMiddleware(inner util.HyperlaneApp, hook HandleHookI) *Middleware {
+	return &Middleware{
+		HyperlaneApp: inner,
+		hook:         hook,
+	}
+}
+
+func (m *Middleware) Exists(ctx context.Context, recipient util.HexAddress) (bool, error) {
+	return m.HyperlaneApp.Exists(ctx, recipient)
+}
+
+func (m *Middleware) Handle(ctx context.Context, mailboxID util.HexAddress, message util.HyperlaneMessage) error {
+
+	err := m.hook.PreHandleHook(ctx, mailboxID, message)
+	if err != nil {
+		return fmt.Errorf("failed to execute pre handle hook: %w", err)
+	}
+
+	err = m.HyperlaneApp.Handle(ctx, mailboxID, message)
+	if err != nil {
+		return err
+	}
+
+	err = m.hook.PostHandleHook(ctx, mailboxID, message)
+	if err != nil {
+		return fmt.Errorf("failed to execute post handle hook: %w", err)
+	}
+	return nil
+}
+
+func (m *Middleware) ReceiverIsmId(ctx context.Context, recipient util.HexAddress) (*util.HexAddress, error) {
+	return m.HyperlaneApp.ReceiverIsmId(ctx, recipient)
+}