fix: broken unit test + make x/sudo safer by making blank genesis inv…

…alid

CHANGELOG.md

@@ -66,6 +66,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [#1690](https://github.com/NibiruChain/nibiru/pull/1690) - docs(CHANGELOG.md): Correct the change log, providing clarity on what's released.
 * [#1679](https://github.com/NibiruChain/nibiru/pull/1679) - test(perp): add more tests for perp module msg server
 * [#1695](https://github.com/NibiruChain/nibiru/pull/1695) - feat(inflation): add events for inflation distribution
+* [#1695](https://github.com/NibiruChain/nibiru/pull/1695) - fix(sudo): Make blank sudoers root invalid at genesis time.
 
 ### Dependencies
 

proto/nibiru/inflation/v1/event.proto

@@ -6,21 +6,21 @@ import "cosmos/base/v1beta1/coin.proto";
 
 option go_package = "github.com/NibiruChain/nibiru/x/inflation/types";
 
-// Emitted when inflation is distributed
-message InflationDistributionEvent {
-    cosmos.base.v1beta1.Coin staking_rewards = 1 [
-        (gogoproto.moretags) = "yaml:\"staking_rewards\"",
-        (gogoproto.nullable)= false
-    ];
+// EventInflationDistribution: Emitted when NIBI tokens are minted on the
+// network based on Nibiru's inflation schedule.
+message EventInflationDistribution {
+  cosmos.base.v1beta1.Coin staking_rewards = 1 [
+    (gogoproto.moretags) = "yaml:\"staking_rewards\"",
+    (gogoproto.nullable) = false
+  ];
 
-    cosmos.base.v1beta1.Coin strategic_reserve = 2 [
-        (gogoproto.moretags) = "yaml:\"strategic_reserve\"",
-        (gogoproto.nullable)= false
-    ];
+  cosmos.base.v1beta1.Coin strategic_reserve = 2 [
+    (gogoproto.moretags) = "yaml:\"strategic_reserve\"",
+    (gogoproto.nullable) = false
+  ];
 
-    cosmos.base.v1beta1.Coin community_pool  = 3 [
-        (gogoproto.moretags) = "yaml:\"community_pool\"",
-        (gogoproto.nullable)= false
-    ];
-
-}
+  cosmos.base.v1beta1.Coin community_pool = 3 [
+    (gogoproto.moretags) = "yaml:\"community_pool\"",
+    (gogoproto.nullable) = false
+  ];
+}

x/common/testutil/testapp/testapp.go

@@ -32,9 +32,18 @@ func NewNibiruTestAppAndContext() (*app.NibiruApp, sdk.Context) {
 	encoding := app.MakeEncodingConfig()
 	var appGenesis app.GenesisState = app.NewDefaultGenesisState(encoding.Marshaler)
 	genModEpochs := epochstypes.DefaultGenesisFromTime(time.Now().UTC())
+
+	// Set happy genesis: epochs
 	appGenesis[epochstypes.ModuleName] = encoding.Marshaler.MustMarshalJSON(
 		genModEpochs,
 	)
+
+	// Set happy genesis: sudo
+	sudoGenesis := new(sudotypes.GenesisState)
+	sudoGenesis.Sudoers = DefaultSudoers()
+	appGenesis[sudotypes.ModuleName] =
+		encoding.Marshaler.MustMarshalJSON(sudoGenesis)
+
 	app := NewNibiruTestApp(appGenesis)
 	ctx := NewContext(app)
 

x/inflation/keeper/inflation.go

@@ -1,6 +1,8 @@
 package keeper
 
 import (
+	"fmt"
+
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
@@ -76,30 +78,28 @@ func (k Keeper) AllocatePolynomialInflation(
 		return sdk.Coin{}, sdk.Coin{}, sdk.Coin{}, err
 	}
 
-	// Remaining balance is strategic reserve allocation to the root account of the x/sudo module
+	// Remaining balance is strategic reserve allocation to the root account
+	// of the x/sudo module
 	strategic = k.bankKeeper.GetBalance(ctx, inflationModuleAddr, denoms.NIBI)
-	strategicAccountAddr, err := k.sudoKeeper.GetRoot(ctx)
+	strategicAccountAddr, err := k.sudoKeeper.GetRootAddr(ctx)
 	if err != nil {
-		k.Logger(ctx).Error("get root account error", "error", err)
+		err := fmt.Errorf("inflation error: failed to get sudo root account: %w", err)
+		k.Logger(ctx).Error(err.Error())
 		return staking, strategic, community, err
 	}
 
 	if err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, strategicAccountAddr, sdk.NewCoins(strategic)); err != nil {
-		k.Logger(ctx).Error("send coins to root account error", "error", err)
+		err := fmt.Errorf("inflation error: failed to send coins to sudo root account: %w", err)
+		k.Logger(ctx).Error(err.Error())
 		return sdk.Coin{}, sdk.Coin{}, sdk.Coin{}, err
 	}
 
-	if err := ctx.EventManager().EmitTypedEvents(
-		&types.InflationDistributionEvent{
+	return staking, strategic, community, ctx.EventManager().EmitTypedEvents(
+		&types.EventInflationDistribution{
 			StakingRewards:   staking,
 			StrategicReserve: strategic,
 			CommunityPool:    community,
-		},
-	); err != nil {
-		return sdk.Coin{}, sdk.Coin{}, sdk.Coin{}, err
-	}
-
-	return staking, strategic, community, nil
+		})
 }
 
 // GetAllocationProportion calculates the proportion of coins that is to be

x/inflation/keeper/inflation_test.go

@@ -79,15 +79,20 @@ func TestMintAndAllocateInflation(t *testing.T) {
 			})
 
 			staking, strategic, community, err := nibiruApp.InflationKeeper.MintAndAllocateInflation(ctx, tc.coinsToMint, types.DefaultParams())
-			require.NoError(t, err)
+			if tc.rootAccount != "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				return
+			}
 			assert.Equal(t, tc.expectedStakingAmt, staking)
 			assert.Equal(t, tc.expectedStrategicAmt, strategic)
 			assert.Equal(t, tc.expectedCommunityAmt, community)
 
 			// Get balances
 			var balanceStrategicReserve sdk.Coin
 			if tc.rootAccount != "" {
-				strategicAccount, err := nibiruApp.SudoKeeper.GetRoot(ctx)
+				strategicAccount, err := nibiruApp.SudoKeeper.GetRootAddr(ctx)
 				require.NoError(t, err)
 				balanceStrategicReserve = nibiruApp.BankKeeper.GetBalance(
 					ctx,
@@ -108,9 +113,15 @@ func TestMintAndAllocateInflation(t *testing.T) {
 			balanceCommunityPool := nibiruApp.DistrKeeper.GetFeePoolCommunityCoins(ctx)
 
 			require.NoError(t, err, tc.name)
-			assert.Equal(t, tc.expectedStakingRewardsBalance, balanceStakingRewards)
-			assert.Equal(t, tc.expectedStrategicReservesBalance, balanceStrategicReserve)
-			assert.Equal(t, tc.expectedCommunityPoolBalance, balanceCommunityPool)
+			assert.Equal(t,
+				tc.expectedStakingRewardsBalance.String(),
+				balanceStakingRewards.String())
+			assert.Equal(t,
+				tc.expectedStrategicReservesBalance.String(),
+				balanceStrategicReserve.String())
+			assert.Equal(t,
+				tc.expectedCommunityPoolBalance.String(),
+				balanceCommunityPool.String())
 		})
 	}
 }

x/inflation/types/interfaces.go

@@ -41,5 +41,5 @@ type StakingKeeper interface {
 }
 
 type SudoKeeper interface {
-	GetRoot(ctx sdk.Context) (sdk.AccAddress, error)
+	GetRootAddr(ctx sdk.Context) (sdk.AccAddress, error)
 }

x/sudo/genesis.go

@@ -28,6 +28,8 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
 	}
 }
 
+// DefaultGenesis: A blank genesis state. The DefaultGenesis is invalid because
+// it does not specify a "Sudoers.Root".
 func DefaultGenesis() *types.GenesisState {
 	return &types.GenesisState{
 		Sudoers: types.Sudoers{

x/sudo/keeper/keeper.go

@@ -27,7 +27,7 @@ func NewKeeper(
 }
 
 // Returns the root address of the sudo module.
-func (k Keeper) GetRoot(ctx sdk.Context) (sdk.AccAddress, error) {
+func (k Keeper) GetRootAddr(ctx sdk.Context) (sdk.AccAddress, error) {
 	sudoers, err := k.Sudoers.Get(ctx)
 	if err != nil {
 		return nil, err

x/sudo/keeper/msg_server_test.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/NibiruChain/nibiru/x/sudo/types"
 
-	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -25,14 +24,7 @@ func init() {
 }
 
 func setup() (*app.NibiruApp, sdk.Context) {
-	genState := app.NewDefaultGenesisState(app.MakeEncodingConfig().Marshaler)
-	nibiru := testapp.NewNibiruTestApp(genState)
-	ctx := nibiru.NewContext(false, tmproto.Header{
-		Height:  1,
-		ChainID: "nibiru-sudonet-1",
-		Time:    time.Now().UTC(),
-	})
-	return nibiru, ctx
+	return testapp.NewNibiruTestAppAndContextAtTime(time.Now().UTC())
 }
 
 func TestGenesis(t *testing.T) {
@@ -45,7 +37,7 @@ func TestGenesis(t *testing.T) {
 		{
 			name:     "default genesis (empty)",
 			genState: sudo.DefaultGenesis(),
-			empty:    true,
+			panic:    true,
 		},
 		{
 			name: "happy genesis with contracts",

x/sudo/types/errors.go

@@ -1,5 +1,20 @@
 package types
 
-import sdkerrors "cosmossdk.io/errors"
+import (
+	"fmt"
 
-var ErrUnauthorized = sdkerrors.Register(ModuleName, 2, "unauthorized: missing sudo permissions")
+	sdkerrors "cosmossdk.io/errors"
+)
+
+var (
+	ErrUnauthorized = sdkerrors.Register(ModuleName, 2, "unauthorized: missing sudo permissions")
+	errGenesis      = sdkerrors.Register(ModuleName, 3, "sudo genesis error")
+	errSudoers      = sdkerrors.Register(ModuleName, 4, "sudoers error")
+)
+
+func ErrGenesis(errMsg string) error {
+	return fmt.Errorf("%s: %s", errGenesis, errMsg)
+}
+func ErrSudoers(errMsg string) error {
+	return fmt.Errorf("%s: %s", errSudoers, errMsg)
+}