feat: implement staking decorator to prevent unregistered accounts to become validators

app/ante/handler.go

@@ -0,0 +1,93 @@
+package ante
+
+import (
+	errorsmod "cosmossdk.io/errors"
+	"cosmossdk.io/log"
+	storetypes "cosmossdk.io/store/types"
+	txsigning "cosmossdk.io/x/tx/signing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	signing "github.com/cosmos/cosmos-sdk/types/tx/signing"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	keyregistrykeeper "github.com/node101-io/pulsar-chain/x/keyregistry/keeper"
+)
+
+// HandlerOptions are the options required for constructing the app ante handler.
+type HandlerOptions struct {
+	AccountKeeper          authante.AccountKeeper
+	BankKeeper             authtypes.BankKeeper
+	ExtensionOptionChecker authante.ExtensionOptionChecker
+	FeegrantKeeper         authante.FeegrantKeeper
+	SignModeHandler        *txsigning.HandlerMap
+	SigGasConsumer         func(meter storetypes.GasMeter, sig signing.SignatureV2, params authtypes.Params) error
+	TxFeeChecker           authante.TxFeeChecker
+	SigVerifyOptions       []authante.SigVerificationDecoratorOption
+	KeyregistryKeeper      *keyregistrykeeper.Keeper
+	MinaNetworkID          string
+	Logger                 log.Logger
+}
+
+// NewAnteHandler returns the chain ante handler.
+func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
+	if options.AccountKeeper == nil {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder")
+	}
+
+	if options.BankKeeper == nil {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder")
+	}
+
+	if options.SignModeHandler == nil {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder")
+	}
+
+	if options.KeyregistryKeeper == nil {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "keyregistry keeper is required for ante builder")
+	}
+
+	if options.MinaNetworkID == "" {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "mina network ID is required for ante builder")
+	}
+
+	if options.Logger == nil {
+		return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "logger is required for ante builder")
+	}
+
+	cosmosSetPubKey := authante.NewSetPubKeyDecorator(options.AccountKeeper)
+	cosmosValidateSigCount := authante.NewValidateSigCountDecorator(options.AccountKeeper)
+	cosmosSigGasConsume := authante.NewSigGasConsumeDecorator(options.AccountKeeper, options.SigGasConsumer)
+	cosmosSigVerify := authante.NewSigVerificationDecorator(
+		options.AccountKeeper,
+		options.SignModeHandler,
+		options.SigVerifyOptions...,
+	)
+
+	minaVerifier := NewMinaVerifier(
+		options.KeyregistryKeeper,
+		options.AccountKeeper,
+		options.SignModeHandler,
+		options.MinaNetworkID,
+		options.Logger,
+	)
+
+	anteDecorators := []sdk.AnteDecorator{
+		authante.NewSetUpContextDecorator(),
+		authante.NewExtensionOptionsDecorator(NewTxAuthExtensionOptionChecker(options.ExtensionOptionChecker)),
+		authante.NewValidateBasicDecorator(),
+		authante.NewTxTimeoutHeightDecorator(),
+		authante.NewValidateMemoDecorator(options.AccountKeeper),
+		authante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
+		authante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper, options.TxFeeChecker),
+		NewTxAuthModeDecorator(),
+		NewRoutedSetPubKeyDecorator(cosmosSetPubKey),
+		NewRoutedValidateSigCountDecorator(options.AccountKeeper, cosmosValidateSigCount),
+		NewRoutedSigGasConsumeDecorator(options.AccountKeeper, cosmosSigGasConsume),
+		NewRoutedSigVerificationDecorator(cosmosSigVerify, minaVerifier),
+		NewStakingDecorator(options.KeyregistryKeeper),
+		authante.NewIncrementSequenceDecorator(options.AccountKeeper),
+	}
+
+	return sdk.ChainAnteDecorators(anteDecorators...), nil
+}

app/ante/handler_test.go

@@ -0,0 +1,191 @@
+package ante_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"cosmossdk.io/core/address"
+	"cosmossdk.io/log"
+	txsigning "cosmossdk.io/x/tx/signing"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	"github.com/stretchr/testify/require"
+
+	appante "github.com/node101-io/pulsar-chain/app/ante"
+	keyregistrykeeper "github.com/node101-io/pulsar-chain/x/keyregistry/keeper"
+)
+
+type stubAccountKeeper struct{}
+
+func (stubAccountKeeper) GetParams(context.Context) authtypes.Params {
+	return authtypes.Params{}
+}
+
+func (stubAccountKeeper) GetAccount(context.Context, sdk.AccAddress) sdk.AccountI {
+	return nil
+}
+
+func (stubAccountKeeper) SetAccount(context.Context, sdk.AccountI) {}
+
+func (stubAccountKeeper) GetModuleAddress(string) sdk.AccAddress {
+	return nil
+}
+
+func (stubAccountKeeper) AddressCodec() address.Codec {
+	return nil
+}
+
+func (stubAccountKeeper) UnorderedTransactionsEnabled() bool {
+	return false
+}
+
+func (stubAccountKeeper) RemoveExpiredUnorderedNonces(sdk.Context) error {
+	return nil
+}
+
+func (stubAccountKeeper) TryAddUnorderedNonce(sdk.Context, []byte, time.Time) error {
+	return nil
+}
+
+type stubBankKeeper struct{}
+
+func (stubBankKeeper) IsSendEnabledCoins(context.Context, ...sdk.Coin) error {
+	return nil
+}
+
+func (stubBankKeeper) SendCoins(context.Context, sdk.AccAddress, sdk.AccAddress, sdk.Coins) error {
+	return nil
+}
+
+func (stubBankKeeper) SendCoinsFromAccountToModule(context.Context, sdk.AccAddress, string, sdk.Coins) error {
+	return nil
+}
+
+var (
+	_ authante.AccountKeeper = stubAccountKeeper{}
+	_ authtypes.BankKeeper   = stubBankKeeper{}
+)
+
+var stubKeyregistryKeeper = &keyregistrykeeper.Keeper{}
+
+// A fully populated HandlerOptions should construct a usable ante chain.
+// This is the baseline success case that all of the stricter validation tests compare against.
+func TestNewAnteHandler(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:     stubAccountKeeper{},
+		BankKeeper:        stubBankKeeper{},
+		SignModeHandler:   &txsigning.HandlerMap{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		MinaNetworkID:     appante.DefaultMinaNetworkID,
+		Logger:            log.NewNopLogger(),
+	})
+
+	require.NoError(t, err)
+	require.NotNil(t, anteHandler)
+}
+
+// AccountKeeper is required because the auth ante stack depends on account state almost everywhere.
+// Failing at construction time is safer than letting a partially wired handler reach runtime.
+func TestNewAnteHandlerRequiresAccountKeeper(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		BankKeeper:        stubBankKeeper{},
+		SignModeHandler:   &txsigning.HandlerMap{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		MinaNetworkID:     appante.DefaultMinaNetworkID,
+		Logger:            log.NewNopLogger(),
+	})
+
+	require.ErrorContains(t, err, "account keeper is required for ante builder")
+	require.Nil(t, anteHandler)
+}
+
+// BankKeeper is mandatory for fee deduction in the default auth decorators.
+// This test ensures the constructor rejects missing fee-transfer dependencies immediately.
+func TestNewAnteHandlerRequiresBankKeeper(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:     stubAccountKeeper{},
+		SignModeHandler:   &txsigning.HandlerMap{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		MinaNetworkID:     appante.DefaultMinaNetworkID,
+		Logger:            log.NewNopLogger(),
+	})
+
+	require.ErrorContains(t, err, "bank keeper is required for ante builder")
+	require.Nil(t, anteHandler)
+}
+
+// SignModeHandler is needed by both the Cosmos and Mina signature verification paths.
+// Missing it would make sign-byte generation impossible later in the ante chain.
+func TestNewAnteHandlerRequiresSignModeHandler(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:     stubAccountKeeper{},
+		BankKeeper:        stubBankKeeper{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		MinaNetworkID:     appante.DefaultMinaNetworkID,
+		Logger:            log.NewNopLogger(),
+	})
+
+	require.ErrorContains(t, err, "sign mode handler is required for ante builder")
+	require.Nil(t, anteHandler)
+}
+
+// KeyregistryKeeper is part of the custom verifier contract for Mina-authenticated txs.
+// The constructor should refuse to build an ante handler that can never resolve Mina signers.
+func TestNewAnteHandlerRequiresKeyregistryKeeper(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:   stubAccountKeeper{},
+		BankKeeper:      stubBankKeeper{},
+		SignModeHandler: &txsigning.HandlerMap{},
+		MinaNetworkID:   appante.DefaultMinaNetworkID,
+		Logger:          log.NewNopLogger(),
+	})
+
+	require.ErrorContains(t, err, "keyregistry keeper is required for ante builder")
+	require.Nil(t, anteHandler)
+}
+
+// Mina network selection affects how Mina signatures are verified on-chain.
+// This test guards against silently constructing a verifier with an empty network ID.
+func TestNewAnteHandlerRequiresMinaNetworkID(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:     stubAccountKeeper{},
+		BankKeeper:        stubBankKeeper{},
+		SignModeHandler:   &txsigning.HandlerMap{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		Logger:            log.NewNopLogger(),
+	})
+
+	require.ErrorContains(t, err, "mina network ID is required for ante builder")
+	require.Nil(t, anteHandler)
+}
+
+// The custom verifier emits debug information when verification is skipped.
+// Requiring a logger up front avoids nil logger surprises during ante execution.
+func TestNewAnteHandlerRequiresLogger(t *testing.T) {
+	t.Parallel()
+
+	anteHandler, err := appante.NewAnteHandler(appante.HandlerOptions{
+		AccountKeeper:     stubAccountKeeper{},
+		BankKeeper:        stubBankKeeper{},
+		SignModeHandler:   &txsigning.HandlerMap{},
+		KeyregistryKeeper: stubKeyregistryKeeper,
+		MinaNetworkID:     appante.DefaultMinaNetworkID,
+	})
+
+	require.ErrorContains(t, err, "logger is required for ante builder")
+	require.Nil(t, anteHandler)
+}