fix: remove burn from slashing

CHANGELOG.md

@@ -1,9 +1,9 @@
 # CHANGELOG
 
-## Unreleased
-
 ### Fixed
 
+- Oracle slashing no longer burns coins but instead sends them to community pool
+- Slashing overall no longer burn coins, but instead sends them to community pool
 - Add denom string length validation (max 128 bytes) to oracle precompile and query server to prevent memory exhaustion via oversized inputs
 - Add result limits to oracle list queries (ExchangeRates, Actives, VoteTargets capped at 1000; PriceSnapshotHistory capped at 500) to prevent unbounded iteration
 - Fix NewClaim constructor assigning power to Weight field instead of the weight parameter (x/oracle/types/ballot.go)

app/keepers/keepers.go

@@ -268,6 +268,7 @@ func NewAppKeeper(
 		stakingtypes.NewMultiStakingHooks(
 			appKeepers.DistrKeeper.Hooks(),
 			appKeepers.SlashingKeeper.Hooks(),
+			NewSlashHooks(appKeepers.StakingKeeper, appKeepers.BankKeeper, appKeepers.DistrKeeper),
 		),
 	)
 
@@ -446,6 +447,7 @@ func NewAppKeeper(
 		appKeepers.AccountKeeper,
 		appKeepers.BankKeeper,
 		appKeepers.StakingKeeper,
+		appKeepers.DistrKeeper,
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
 	)
 

app/keepers/slash_hooks.go

@@ -0,0 +1,117 @@
+package keepers
+
+import (
+	"context"
+
+	"cosmossdk.io/math"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	tokenfactorytypes "github.com/kiichain/kiichain/v7/x/tokenfactory/types"
+)
+
+// slashStakingKeeper is the staking-keeper subset needed by SlashHooks
+type slashStakingKeeper interface {
+	GetValidator(ctx context.Context, addr sdk.ValAddress) (stakingtypes.Validator, error)
+	BondDenom(ctx context.Context) (string, error)
+}
+
+// slashBankKeeper is the bank-keeper subset needed by SlashHooks
+type slashBankKeeper interface {
+	MintCoins(ctx context.Context, moduleName string, amounts sdk.Coins) error
+}
+
+// slashDistrKeeper is the distribution-keeper subset needed by SlashHooks
+type slashDistrKeeper interface {
+	FundCommunityPool(ctx context.Context, amount sdk.Coins, sender sdk.AccAddress) error
+}
+
+// SlashHooks implements stakingtypes.StakingHooks
+type SlashHooks struct {
+	stakingKeeper slashStakingKeeper
+	bankKeeper    slashBankKeeper
+	distrKeeper   slashDistrKeeper
+}
+
+// NewSlashHooks returns a SlashHooks
+func NewSlashHooks(sk slashStakingKeeper, bk slashBankKeeper, dk slashDistrKeeper) SlashHooks {
+	return SlashHooks{stakingKeeper: sk, bankKeeper: bk, distrKeeper: dk}
+}
+
+var _ stakingtypes.StakingHooks = SlashHooks{}
+
+// BeforeValidatorSlashed mints the equivalent of the slash amount into the
+// community pool before the tokens are burned
+func (h SlashHooks) BeforeValidatorSlashed(ctx context.Context, valAddr sdk.ValAddress, fraction math.LegacyDec) error {
+	validator, err := h.stakingKeeper.GetValidator(ctx, valAddr)
+	if err != nil || !validator.Tokens.IsPositive() {
+		return err
+	}
+
+	// The effectiveFraction passed by slashToPool is tokensToBurn / validator.Tokens,
+	// so multiplying back recovers tokensToBurn
+	mintAmount := math.LegacyNewDecFromInt(validator.Tokens).Mul(fraction).TruncateInt()
+	if mintAmount.IsZero() {
+		return nil
+	}
+
+	bondDenom, err := h.stakingKeeper.BondDenom(ctx)
+	if err != nil {
+		return err
+	}
+
+	coins := sdk.NewCoins(sdk.NewCoin(bondDenom, mintAmount))
+
+	// Mint into the tokenfactory module account (needs mint permission)
+	// and immediately forward to the distribution community pool
+	if err := h.bankKeeper.MintCoins(ctx, tokenfactorytypes.ModuleName, coins); err != nil {
+		return err
+	}
+
+	tokenfactoryAddr := authtypes.NewModuleAddress(tokenfactorytypes.ModuleName)
+	return h.distrKeeper.FundCommunityPool(ctx, coins, tokenfactoryAddr)
+}
+
+// The remaining hooks are not in use; only BeforeValidatorSlashed is used
+
+func (h SlashHooks) AfterValidatorCreated(_ context.Context, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) BeforeValidatorModified(_ context.Context, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) AfterValidatorRemoved(_ context.Context, _ sdk.ConsAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) AfterValidatorBonded(_ context.Context, _ sdk.ConsAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) AfterValidatorBeginUnbonding(_ context.Context, _ sdk.ConsAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) BeforeDelegationCreated(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) BeforeDelegationSharesModified(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) BeforeDelegationRemoved(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) AfterDelegationModified(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error {
+	return nil
+}
+
+func (h SlashHooks) AfterUnbondingInitiated(_ context.Context, _ uint64) error {
+	return nil
+}

app/keepers/slash_hooks_test.go

@@ -0,0 +1,139 @@
+package keepers_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	tmtypes "github.com/cometbft/cometbft/proto/tendermint/types"
+
+	"cosmossdk.io/math"
+
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
+	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	kiichain "github.com/kiichain/kiichain/v7/app"
+	helpers "github.com/kiichain/kiichain/v7/app/helpers"
+)
+
+// createBondedValidator funds a new validator address, creates the validator,
+// runs EndBlocker to move it to the bonded set, and registers signing info.
+// Returns the val address and consensus address
+func createBondedValidator(t *testing.T, app *kiichain.KiichainApp, ctx sdk.Context, stakedAmount math.Int) (sdk.ValAddress, sdk.ConsAddress) {
+	t.Helper()
+
+	privKey := secp256k1.GenPrivKey()
+	pubKey := privKey.PubKey()
+	valAddr := sdk.ValAddress(pubKey.Address())
+	consAddr := sdk.ConsAddress(pubKey.Address())
+
+	bondDenom, err := app.StakingKeeper.BondDenom(ctx)
+	require.NoError(t, err)
+
+	selfBond := sdk.NewCoins(sdk.NewCoin(bondDenom, stakedAmount))
+	require.NoError(t, app.BankKeeper.MintCoins(ctx, "tokenfactory", selfBond))
+	require.NoError(t, app.BankKeeper.SendCoinsFromModuleToAccount(ctx, "tokenfactory", sdk.AccAddress(valAddr), selfBond))
+
+	msgServer := stakingkeeper.NewMsgServerImpl(app.StakingKeeper)
+	createMsg, err := stakingtypes.NewMsgCreateValidator(
+		valAddr.String(),
+		pubKey,
+		sdk.NewCoin(bondDenom, stakedAmount),
+		stakingtypes.Description{Moniker: "test-validator"},
+		stakingtypes.NewCommissionRates(
+			math.LegacyNewDecWithPrec(5, 2),
+			math.LegacyNewDecWithPrec(20, 2),
+			math.LegacyNewDecWithPrec(1, 2),
+		),
+		math.OneInt(),
+	)
+	require.NoError(t, err)
+	_, err = msgServer.CreateValidator(ctx, createMsg)
+	require.NoError(t, err)
+
+	_, err = app.StakingKeeper.EndBlocker(ctx)
+	require.NoError(t, err)
+
+	signingInfo := slashingtypes.NewValidatorSigningInfo(
+		consAddr, ctx.BlockHeight(), 0, time.Unix(0, 0), false, 0,
+	)
+	require.NoError(t, app.SlashingKeeper.SetValidatorSigningInfo(ctx, consAddr, signingInfo))
+
+	return valAddr, consAddr
+}
+
+// TestSlashHooks_SupplyUnchangedAfterSlash verifies that when
+// the staking keeper slashes a validator, the total token supply is
+// unchanged
+func TestSlashHooks_SupplyUnchangedAfterSlash(t *testing.T) {
+	app := helpers.Setup(t)
+	ctx := app.NewUncachedContext(true, tmtypes.Header{
+		Height:  1,
+		ChainID: "testing",
+		Time:    time.Now().UTC(),
+	})
+
+	bondDenom, err := app.StakingKeeper.BondDenom(ctx)
+	require.NoError(t, err)
+
+	stakedAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	valAddr, consAddr := createBondedValidator(t, app, ctx, stakedAmount)
+
+	supplyBefore := app.BankKeeper.GetSupply(ctx, bondDenom).Amount
+
+	validator, err := app.StakingKeeper.GetValidator(ctx, valAddr)
+	require.NoError(t, err)
+	powerReduction := app.StakingKeeper.PowerReduction(ctx)
+	consensusPower := validator.GetConsensusPower(powerReduction)
+
+	slashFactor := math.LegacyNewDecWithPrec(5, 2) // 5%
+	slashed, err := app.StakingKeeper.Slash(ctx, consAddr, 0, consensusPower, slashFactor)
+	require.NoError(t, err)
+	require.True(t, slashed.IsPositive(), "expected a non-zero slash amount")
+
+	// Supply must be unchanged: the burn is offset by the hook's mint
+	require.Equal(t, supplyBefore, app.BankKeeper.GetSupply(ctx, bondDenom).Amount,
+		"total supply must be unchanged after slash")
+
+	// Community pool must have received exactly the slashed amount
+	feePool, err := app.DistrKeeper.FeePool.Get(ctx)
+	require.NoError(t, err)
+	communityPool := feePool.CommunityPool.AmountOf(bondDenom)
+	require.Equal(t, math.LegacyNewDecFromInt(slashed), communityPool,
+		"community pool must receive exactly the slash amount")
+}
+
+// TestSlashHooks_ZeroSlashFactor verifies no tokens move and supply is
+// unchanged when the slash factor is zero
+func TestSlashHooks_ZeroSlashFactor(t *testing.T) {
+	app := helpers.Setup(t)
+	ctx := app.NewUncachedContext(true, tmtypes.Header{
+		Height:  1,
+		ChainID: "testing",
+		Time:    time.Now().UTC(),
+	})
+
+	bondDenom, err := app.StakingKeeper.BondDenom(ctx)
+	require.NoError(t, err)
+
+	stakedAmount := sdk.TokensFromConsensusPower(100, sdk.DefaultPowerReduction)
+	_, consAddr := createBondedValidator(t, app, ctx, stakedAmount)
+
+	supplyBefore := app.BankKeeper.GetSupply(ctx, bondDenom).Amount
+
+	validator, err := app.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
+	require.NoError(t, err)
+	powerReduction := app.StakingKeeper.PowerReduction(ctx)
+	consensusPower := validator.GetConsensusPower(powerReduction)
+
+	slashed, err := app.StakingKeeper.Slash(ctx, consAddr, 0, consensusPower, math.LegacyZeroDec())
+	require.NoError(t, err)
+	require.True(t, slashed.IsZero(), "expected zero slash for zero factor")
+
+	require.Equal(t, supplyBefore, app.BankKeeper.GetSupply(ctx, bondDenom).Amount,
+		"supply must be unchanged when slash factor is zero")
+}

x/oracle/keeper/keeper.go

@@ -25,6 +25,7 @@ type Keeper struct {
 	accountKeeper types.AccountKeeper
 	bankKeeper    types.BankKeeper
 	StakingKeeper types.StakingKeeper
+	distrKeeper   types.DistributionKeeper
 
 	// Schema of the module
 	Schema                    collections.Schema
@@ -44,7 +45,7 @@ type Keeper struct {
 // NewKeeper creates an oracle Keeper instance
 func NewKeeper(cdc codec.BinaryCodec, storeService corestoretypes.KVStoreService,
 	accountKeeper types.AccountKeeper, bankKeeper types.BankKeeper, stakingKeeper types.StakingKeeper,
-	authority string,
+	distrKeeper types.DistributionKeeper, authority string,
 ) Keeper {
 	// Ensure oracle module account is set
 	addr := accountKeeper.GetModuleAddress(types.ModuleName)
@@ -66,6 +67,7 @@ func NewKeeper(cdc codec.BinaryCodec, storeService corestoretypes.KVStoreService
 		accountKeeper:             accountKeeper,
 		bankKeeper:                bankKeeper,
 		StakingKeeper:             stakingKeeper,
+		distrKeeper:               distrKeeper,
 		Params:                    collections.NewItem(sb, types.ParamsKey, "params", codec.CollValue[types.Params](cdc)),
 		ExchangeRate:              collections.NewMap(sb, types.ExchangeRateKey, "exchange_rate", collections.StringKey, codec.CollValue[types.OracleExchangeRate](cdc)),
 		FeederDelegation:          collections.NewMap(sb, types.FeederDelegationKey, "feeder_delegation", sdk.ValAddressKey, collections.StringValue),

x/oracle/keeper/slash.go

@@ -7,6 +7,7 @@ import (
 	"cosmossdk.io/math"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
 	"github.com/kiichain/kiichain/v7/x/oracle/types"
@@ -15,9 +16,6 @@ import (
 // SlashAndResetCounters calculate if the validator must be slashed if success votes / total votes
 // is lower than MinValidPerWindow param. Then reset the vote penalty info
 func (k Keeper) SlashAndResetCounters(ctx sdk.Context) error {
-	height := ctx.BlockHeight()
-	distributionHeight := height - sdk.ValidatorUpdateDelay - 1
-
 	// Get the module params
 	params, err := k.Params.Get(ctx)
 	if err != nil {
@@ -69,8 +67,8 @@ func (k Keeper) SlashAndResetCounters(ctx sdk.Context) error {
 				// Calculate consensus power
 				consensusPower := validator.GetConsensusPower(powerReduction)
 
-				// Slash the validator
-				_, err = k.StakingKeeper.Slash(ctx, consAddr, distributionHeight, consensusPower, slashFraction)
+				// Redirect the slash amount to the community pool instead of burning
+				_, err = k.slashToPool(ctx, consAddr, consensusPower, slashFraction)
 				if err != nil {
 					k.Logger(ctx).Error("failed to slash validator", "operator", operator.String(), "error", err)
 					return true, err
@@ -103,3 +101,54 @@ func (k Keeper) SlashAndResetCounters(ctx sdk.Context) error {
 	})
 	return err
 }
+
+// slashToPool removes tokens from a validator and sends them to the community pool
+// instead of burning, preserving total supply.
+func (k Keeper) slashToPool(ctx sdk.Context, consAddr sdk.ConsAddress, consensusPower int64, slashFactor math.LegacyDec) (math.Int, error) {
+	if slashFactor.IsZero() {
+		return math.ZeroInt(), nil
+	}
+
+	// Calculate slash amount: same math as the staking module
+	amount := k.StakingKeeper.TokensFromConsensusPower(ctx, consensusPower)
+	slashAmount := math.LegacyNewDecFromInt(amount).Mul(slashFactor).TruncateInt()
+
+	// Get the concrete validator (needed for RemoveValidatorTokens)
+	validator, err := k.StakingKeeper.GetValidatorByConsAddr(ctx, consAddr)
+	if err != nil {
+		return math.ZeroInt(), err
+	}
+
+	// Clamp slash amount to the validator's available tokens
+	tokensToBurn := math.MinInt(slashAmount, validator.Tokens)
+	if tokensToBurn.IsZero() {
+		return math.ZeroInt(), nil
+	}
+
+	// Remove tokens from the validator's bookkeeping without burning
+	_, err = k.StakingKeeper.RemoveValidatorTokens(ctx, validator, tokensToBurn)
+	if err != nil {
+		return math.ZeroInt(), err
+	}
+
+	// Create the coin (value but with akii)
+	bondDenom, err := k.StakingKeeper.BondDenom(ctx)
+	if err != nil {
+		return math.ZeroInt(), err
+	}
+	coins := sdk.NewCoins(sdk.NewCoin(bondDenom, tokensToBurn))
+	// Send the slashed tokens from the bonded pool to the community pool
+	bondedPoolAddr := authtypes.NewModuleAddress(stakingtypes.BondedPoolName)
+	if err := k.distrKeeper.FundCommunityPool(ctx, coins, bondedPoolAddr); err != nil {
+		return math.ZeroInt(), err
+	}
+
+	k.Logger(ctx).Info(
+		"oracle slash redirected to community pool",
+		"validator", consAddr.String(),
+		"slash_factor", slashFactor.String(),
+		"amount", tokensToBurn.String(),
+	)
+
+	return tokensToBurn, nil
+}