review code

Author: maoaixiao1314

init.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
 
+set -euo pipefail
+IFS=$'\n\t'
 # Set environment variables
 KEY="dev0"
 CHAINID="hetu_560000-1"

x/blockinflation/keeper/alpha_token.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"math/big"
+	"strings"
 	"sync"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -37,16 +38,17 @@ func (k Keeper) MintAlphaTokens(ctx sdk.Context, netuid uint16, recipient string
 		return fmt.Errorf("subnet not found: %d", netuid)
 	}
 
-	// 2. Check if the subnet has an AlphaToken address in its params
+	// 2. Resolve and validate the subnet's AlphaToken address
 	alphaTokenAddress, ok := subnet.Params["alpha_token"]
-	if !ok || alphaTokenAddress == "" {
-		return fmt.Errorf("subnet has no alpha token address in params: %d", netuid)
+	alphaTokenAddress = strings.TrimSpace(alphaTokenAddress)
+	if !ok || alphaTokenAddress == "" || !common.IsHexAddress(alphaTokenAddress) {
+		return fmt.Errorf("invalid or missing alpha token address in subnet params: %d", netuid)
 	}
 
-	// 3. Parse the AlphaToken address
+	// 3. Parse and validate the AlphaToken address
 	alphaTokenAddr := common.HexToAddress(alphaTokenAddress)
-	if (alphaTokenAddr == common.Address{}) {
-		return fmt.Errorf("invalid alpha token address: %s", alphaTokenAddress)
+	if alphaTokenAddr == (common.Address{}) {
+		return fmt.Errorf("alpha token address cannot be the zero address: %s", alphaTokenAddress)
 	}
 
 	// 4. Get the AlphaToken ABI (cached)
@@ -55,11 +57,15 @@ func (k Keeper) MintAlphaTokens(ctx sdk.Context, netuid uint16, recipient string
 		return fmt.Errorf("failed to load AlphaToken ABI: %w", err)
 	}
 
-	// 5. Convert recipient address to Ethereum address
-	recipientAddr := common.HexToAddress(recipient)
-	if (recipientAddr == common.Address{}) {
+	// 5. Validate and convert recipient address
+	recipient = strings.TrimSpace(recipient)
+	if !common.IsHexAddress(recipient) {
 		return fmt.Errorf("invalid recipient address: %s", recipient)
 	}
+	recipientAddr := common.HexToAddress(recipient)
+	if recipientAddr == (common.Address{}) {
+		return fmt.Errorf("recipient address cannot be the zero address: %s", recipient)
+	}
 
 	// 6. Convert amount to big.Int
 	amountBig := new(big.Int).SetUint64(amount)

x/blockinflation/keeper/genesis.go

@@ -1,13 +1,26 @@
 package keeper
 
 import (
+	"fmt"
+
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	blockinflationtypes "github.com/hetu-project/hetu/v1/x/blockinflation/types"
 )
 
 // InitGenesis initializes the blockinflation module's state from a provided genesis state.
 func (k Keeper) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data *blockinflationtypes.GenesisState) {
+	if data == nil {
+		panic("blockinflation: nil genesis state")
+	}
+
+	// Validate parameters
+	if data.Params.MintDenom == "" {
+		panic("blockinflation: params.mint_denom must not be empty")
+	}
+	// TODO: If Params exposes a Validate() or ValidateBasic(), call it here.
+	// if err := data.Params.Validate(); err != nil { panic(fmt.Errorf("invalid blockinflation params: %w", err)) }
+
 	// Set parameters
 	k.SetParams(ctx, data.Params)
 
@@ -19,19 +32,40 @@ func (k Keeper) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data *blockinf
 	k.Logger(ctx).Debug("InitGenesis: retrieved params", "params", params)
 
 	// Set total issuance
-	if !data.TotalIssuance.Amount.IsNil() {
-		k.SetTotalIssuance(ctx, data.TotalIssuance)
+	if err := sdk.ValidateDenom(data.TotalIssuance.Denom); err != nil {
+		panic(fmt.Errorf("blockinflation: invalid total_issuance denom: %w", err))
+	}
+	if data.TotalIssuance.Amount.IsNegative() {
+		panic("blockinflation: total_issuance amount must be >= 0")
 	}
+	if data.TotalIssuance.Denom != data.Params.MintDenom {
+		panic(fmt.Errorf("blockinflation: total_issuance denom %q must match params.mint_denom %q", data.TotalIssuance.Denom, data.Params.MintDenom))
+	}
+	k.SetTotalIssuance(ctx, data.TotalIssuance)
 
 	// Set total burned
-	if !data.TotalBurned.Amount.IsNil() {
-		k.SetTotalBurned(ctx, data.TotalBurned)
+	if err := sdk.ValidateDenom(data.TotalBurned.Denom); err != nil {
+		panic(fmt.Errorf("blockinflation: invalid total_burned denom: %w", err))
+	}
+	if data.TotalBurned.Amount.IsNegative() {
+		panic("blockinflation: total_burned amount must be >= 0")
+	}
+	if data.TotalBurned.Denom != data.Params.MintDenom {
+		panic(fmt.Errorf("blockinflation: total_burned denom %q must match params.mint_denom %q", data.TotalBurned.Denom, data.Params.MintDenom))
 	}
+	k.SetTotalBurned(ctx, data.TotalBurned)
 
 	// Set pending subnet rewards
-	if !data.PendingSubnetRewards.Amount.IsNil() {
-		k.SetPendingSubnetRewards(ctx, data.PendingSubnetRewards)
+	if err := sdk.ValidateDenom(data.PendingSubnetRewards.Denom); err != nil {
+		panic(fmt.Errorf("blockinflation: invalid pending_subnet_rewards denom: %w", err))
+	}
+	if data.PendingSubnetRewards.Amount.IsNegative() {
+		panic("blockinflation: pending_subnet_rewards amount must be >= 0")
+	}
+	if data.PendingSubnetRewards.Denom != data.Params.MintDenom {
+		panic(fmt.Errorf("blockinflation: pending_subnet_rewards denom %q must match params.mint_denom %q", data.PendingSubnetRewards.Denom, data.Params.MintDenom))
 	}
+	k.SetPendingSubnetRewards(ctx, data.PendingSubnetRewards)
 
 	k.Logger(ctx).Info("blockinflation: initialized genesis state",
 		"total_issuance", data.TotalIssuance.String(),

x/blockinflation/keeper/inflation.go

@@ -50,14 +50,12 @@ func (k Keeper) CalculateBlockEmission(ctx sdk.Context) (math.Int, error) {
 	flooredLog := stdmath.Floor(logResult)
 	flooredLogInt := int64(flooredLog)
 
-	// Calculate 2^flooredLog
-	multiplier := stdmath.Pow(2.0, float64(flooredLogInt))
-
-	// Calculate block emission percentage: 1 / multiplier
-	blockEmissionPercentage := math.LegacyOneDec().Quo(math.LegacyNewDecWithPrec(int64(multiplier*1000), 3))
-
-	// Calculate actual block emission using high-precision arithmetic
-	blockEmission := defaultBlockEmissionDec.Mul(blockEmissionPercentage)
+	// Calculate actual block emission by halving default emission flooredLogInt times.
+	// This avoids float math and overflow.
+	blockEmission := defaultBlockEmissionDec
+	for i := int64(0); i < flooredLogInt; i++ {
+		blockEmission = blockEmission.Quo(math.LegacyNewDec(2))
+	}
 
 	// Convert back to math.Int with proper rounding
 	blockEmissionInt := blockEmission.TruncateInt()
@@ -69,8 +67,6 @@ func (k Keeper) CalculateBlockEmission(ctx sdk.Context) (math.Int, error) {
 		"log_arg", logArg.String(),
 		"log_result", fmt.Sprintf("%.6f", logResult),
 		"floored_log", flooredLogInt,
-		"multiplier", fmt.Sprintf("%.6f", multiplier),
-		"emission_percentage", blockEmissionPercentage.String(),
 		"block_emission", blockEmissionInt.String(),
 	)
 
@@ -159,7 +155,10 @@ func (k Keeper) MintAndAllocateBlockInflation(ctx sdk.Context) error {
 
 	// Update total issuance
 	currentIssuance := k.GetTotalIssuance(ctx)
-	newIssuance := currentIssuance.Add(mintedCoin)
+	if currentIssuance.Denom != mintedCoin.Denom {
+		return fmt.Errorf("denom mismatch: totalIssuance=%s minted=%s", currentIssuance.Denom, mintedCoin.Denom)
+	}
+	newIssuance := sdk.NewCoin(currentIssuance.Denom, currentIssuance.Amount.Add(mintedCoin.Amount))
 	k.SetTotalIssuance(ctx, newIssuance)
 
 	k.Logger(ctx).Info("minted and allocated block inflation",

x/blockinflation/types/expected_keepers.go

@@ -4,7 +4,6 @@ package types
 import (
 	"context"
 
-	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
@@ -14,13 +13,8 @@ import (
 )
 
 // SubnetInfo defines the expected subnet info structure
-type SubnetInfo struct {
-	Netuid                uint16
-	Owner                 string
-	AlphaToken            string
-	EMAPriceHalvingBlocks uint64
-	Params                map[string]string
-}
+// Deprecated: Use eventtypes.SubnetInfo directly
+type SubnetInfo = eventtypes.SubnetInfo
 
 // AccountKeeper defines the expected interface needed to retrieve account info.
 type AccountKeeper interface {
@@ -38,39 +32,8 @@ type BankKeeper interface {
 }
 
 // EventKeeper defines the expected interface for the event module keeper
-type EventKeeper interface {
-	GetAllSubnetNetuids(ctx sdk.Context) []uint16
-	GetSubnetsToEmitTo(ctx sdk.Context) []uint16
-	GetSubnetFirstEmissionBlock(ctx sdk.Context, netuid uint16) (uint64, bool)
-	GetSubnet(ctx sdk.Context, netuid uint16) (eventtypes.Subnet, bool)
-	GetAlphaPrice(ctx sdk.Context, netuid uint16) math.LegacyDec
-	GetMovingAlphaPrice(ctx sdk.Context, netuid uint16) math.LegacyDec
-	UpdateMovingPrice(ctx sdk.Context, netuid uint16, movingAlpha math.LegacyDec, halvingBlocks uint64)
-	GetSubnetAlphaIn(ctx sdk.Context, netuid uint16) math.Int
-	GetSubnetAlphaOut(ctx sdk.Context, netuid uint16) math.Int
-	GetSubnetTAO(ctx sdk.Context, netuid uint16) math.Int
-	GetSubnetAlphaInEmission(ctx sdk.Context, netuid uint16) math.Int
-	GetSubnetAlphaOutEmission(ctx sdk.Context, netuid uint16) math.Int
-	GetSubnetTaoInEmission(ctx sdk.Context, netuid uint16) math.Int
-	AddSubnetAlphaIn(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddSubnetAlphaOut(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddSubnetTAO(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddSubnetAlphaInEmission(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddSubnetAlphaOutEmission(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddSubnetTaoInEmission(ctx sdk.Context, netuid uint16, amount math.Int)
-	SetSubnetAlphaOut(ctx sdk.Context, netuid uint16, amount math.Int)
-	GetPendingEmission(ctx sdk.Context, netuid uint16) math.Int
-	SetPendingEmission(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddPendingEmission(ctx sdk.Context, netuid uint16, amount math.Int)
-	GetPendingOwnerCut(ctx sdk.Context, netuid uint16) math.Int
-	SetPendingOwnerCut(ctx sdk.Context, netuid uint16, amount math.Int)
-	AddPendingOwnerCut(ctx sdk.Context, netuid uint16, amount math.Int)
-	GetBlocksSinceLastStep(ctx sdk.Context, netuid uint16) uint64
-	SetBlocksSinceLastStep(ctx sdk.Context, netuid uint16, blocks uint64)
-	GetLastMechanismStepBlock(ctx sdk.Context, netuid uint16) int64
-	SetLastMechanismStepBlock(ctx sdk.Context, netuid uint16, block int64)
-	GetAllValidatorStakesByNetuid(ctx sdk.Context, netuid uint16) []eventtypes.ValidatorStake
-}
+// Deprecated: Use eventtypes.EventKeeper directly
+type EventKeeper = eventtypes.EventKeeper
 
 // StakeworkKeeper defines the expected interface for the stakework module keeper
 type StakeworkKeeper interface {

x/blockinflation/types/genesis.go

@@ -1,6 +1,8 @@
 package types
 
 import (
+	"fmt"
+
 	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -19,11 +21,13 @@ type GenesisState struct {
 
 // DefaultGenesisState returns default genesis state
 func DefaultGenesisState() *GenesisState {
+	p := DefaultParams()
+	denom := p.MintDenom
 	return &GenesisState{
-		Params:               DefaultParams(),
-		TotalIssuance:        sdk.NewCoin("ahetu", math.ZeroInt()),
-		TotalBurned:          sdk.NewCoin("ahetu", math.ZeroInt()),
-		PendingSubnetRewards: sdk.NewCoin("ahetu", math.ZeroInt()),
+		Params:               p,
+		TotalIssuance:        sdk.NewCoin(denom, math.ZeroInt()),
+		TotalBurned:          sdk.NewCoin(denom, math.ZeroInt()),
+		PendingSubnetRewards: sdk.NewCoin(denom, math.ZeroInt()),
 	}
 }
 
@@ -48,5 +52,16 @@ func (gs GenesisState) Validate() error {
 		return err
 	}
 
+	// Ensure all coins use the configured mint denom
+	if gs.TotalIssuance.Denom != gs.Params.MintDenom {
+		return fmt.Errorf("total_issuance denom %q must match params.mint_denom %q", gs.TotalIssuance.Denom, gs.Params.MintDenom)
+	}
+	if gs.TotalBurned.Denom != gs.Params.MintDenom {
+		return fmt.Errorf("total_burned denom %q must match params.mint_denom %q", gs.TotalBurned.Denom, gs.Params.MintDenom)
+	}
+	if gs.PendingSubnetRewards.Denom != gs.Params.MintDenom {
+		return fmt.Errorf("pending_subnet_rewards denom %q must match params.mint_denom %q", gs.PendingSubnetRewards.Denom, gs.Params.MintDenom)
+	}
+
 	return nil
 }

x/blockinflation/types/subnet_reward.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	stdmath "math"
+	"strconv"
 
 	"cosmossdk.io/math"
 )
@@ -13,9 +14,14 @@ func CalculateSubnetRewardRatio(params Params, subnetCount uint64) math.LegacyDe
 		return math.LegacyZeroDec()
 	}
 
-	// Calculate log(1 + subnet_count) and convert to LegacyDec
-	logFloat := stdmath.Log(float64(1 + subnetCount))
-	logValue := math.LegacyNewDecFromInt(math.NewInt(int64(logFloat * 1000000))).Quo(math.LegacyNewDec(1000000))
+	// Calculate log(1 + subnet_count) with better numerical stability and convert to LegacyDec
+	logFloat := stdmath.Log1p(float64(subnetCount))
+	logStr := strconv.FormatFloat(logFloat, 'f', 18, 64) // 18 fractional digits to match LegacyDec precision
+	logValue, err := math.LegacyNewDecFromStr(logStr)
+	if err != nil {
+		// Fallback to a less precise but safe conversion if string parsing fails
+		logValue = math.LegacyNewDecWithPrec(int64(logFloat*1000000000000000000), 18)
+	}
 
 	// Calculate base + k * log(1 + subnet_count)
 	ratio := params.SubnetRewardBase.Add(params.SubnetRewardK.Mul(logValue))

x/event/keeper/keeper.go

@@ -422,49 +422,49 @@ func (k Keeper) handleNetworkRegistered(ctx sdk.Context, log ethTypes.Log) {
 
 	// Override Core network parameters (if event has values)
 	if event.Hyperparams.Rho != 0 {
-		params["rho"] = strconv.FormatFloat(float64(event.Hyperparams.Rho)/10000.0, 'f', -1, 64)
+		params[types.KeyRho] = strconv.FormatFloat(float64(event.Hyperparams.Rho)/10000.0, 'f', -1, 64)
 	}
 	if event.Hyperparams.Kappa != 0 {
-		params["kappa"] = fmt.Sprintf("%d", event.Hyperparams.Kappa)
+		params[types.KeyKappa] = fmt.Sprintf("%d", event.Hyperparams.Kappa)
 	}
 	if event.Hyperparams.ImmunityPeriod != 0 {
-		params["immunity_period"] = fmt.Sprintf("%d", event.Hyperparams.ImmunityPeriod)
+		params[types.KeyImmunityPeriod] = fmt.Sprintf("%d", event.Hyperparams.ImmunityPeriod)
 	}
 	if event.Hyperparams.Tempo != 0 {
-		params["tempo"] = fmt.Sprintf("%d", event.Hyperparams.Tempo)
+		params[types.KeyTempo] = fmt.Sprintf("%d", event.Hyperparams.Tempo)
 	}
 	if event.Hyperparams.MaxValidators != 0 {
-		params["max_validators"] = fmt.Sprintf("%d", event.Hyperparams.MaxValidators)
+		params[types.KeyMaxValidators] = fmt.Sprintf("%d", event.Hyperparams.MaxValidators)
 	}
 	if event.Hyperparams.ActivityCutoff != 0 {
-		params["activity_cutoff"] = fmt.Sprintf("%d", event.Hyperparams.ActivityCutoff)
+		params[types.KeyActivityCutoff] = fmt.Sprintf("%d", event.Hyperparams.ActivityCutoff)
 	}
 	if event.Hyperparams.MaxAllowedUids != 0 {
-		params["max_allowed_uids"] = fmt.Sprintf("%d", event.Hyperparams.MaxAllowedUids)
+		params[types.KeyMaxAllowedUids] = fmt.Sprintf("%d", event.Hyperparams.MaxAllowedUids)
 	}
 	if event.Hyperparams.MaxAllowedValidators != 0 {
-		params["max_allowed_validators"] = fmt.Sprintf("%d", event.Hyperparams.MaxAllowedValidators)
+		params[types.KeyMaxAllowedValidators] = fmt.Sprintf("%d", event.Hyperparams.MaxAllowedValidators)
 	}
 	if event.Hyperparams.MinAllowedWeights != 0 {
-		params["min_allowed_weights"] = fmt.Sprintf("%d", event.Hyperparams.MinAllowedWeights)
+		params[types.KeyMinAllowedWeights] = fmt.Sprintf("%d", event.Hyperparams.MinAllowedWeights)
 	}
 	if event.Hyperparams.MaxWeightsLimit != 0 {
-		params["max_weights_limit"] = fmt.Sprintf("%d", event.Hyperparams.MaxWeightsLimit)
+		params[types.KeyMaxWeightsLimit] = fmt.Sprintf("%d", event.Hyperparams.MaxWeightsLimit)
 	}
 
 	// Directly add Economic & Governance parameters
-	params["base_neuron_cost"] = event.Hyperparams.BaseNeuronCost.String()
-	params["current_difficulty"] = fmt.Sprintf("%d", event.Hyperparams.CurrentDifficulty)
-	params["target_regs_per_interval"] = fmt.Sprintf("%d", event.Hyperparams.TargetRegsPerInterval)
-	params["max_regs_per_block"] = fmt.Sprintf("%d", event.Hyperparams.MaxRegsPerBlock)
-	params["weights_rate_limit"] = fmt.Sprintf("%d", event.Hyperparams.WeightsRateLimit)
-	params["weights_set_rate_limit"] = fmt.Sprintf("%d", event.Hyperparams.WeightsRateLimit) // Compatible with stakework
-	params["registration_allowed"] = fmt.Sprintf("%t", event.Hyperparams.RegistrationAllowed)
-	params["commit_reveal_enabled"] = fmt.Sprintf("%t", event.Hyperparams.CommitRevealEnabled)
-	params["commit_reveal_period"] = fmt.Sprintf("%d", event.Hyperparams.CommitRevealPeriod)
-	params["serving_rate_limit"] = fmt.Sprintf("%d", event.Hyperparams.ServingRateLimit)
-	params["validator_threshold"] = event.Hyperparams.ValidatorThreshold.String()
-	params["neuron_threshold"] = event.Hyperparams.NeuronThreshold.String()
+	params[types.KeyBaseNeuronCost] = event.Hyperparams.BaseNeuronCost.String()
+	params[types.KeyCurrentDifficulty] = fmt.Sprintf("%d", event.Hyperparams.CurrentDifficulty)
+	params[types.KeyTargetRegsPerInterval] = fmt.Sprintf("%d", event.Hyperparams.TargetRegsPerInterval)
+	params[types.KeyMaxRegsPerBlock] = fmt.Sprintf("%d", event.Hyperparams.MaxRegsPerBlock)
+	params[types.KeyWeightsRateLimit] = fmt.Sprintf("%d", event.Hyperparams.WeightsRateLimit)
+	params[types.KeyWeightsSetRateLimit] = fmt.Sprintf("%d", event.Hyperparams.WeightsRateLimit) // Compatible with stakework
+	params[types.KeyRegistrationAllowed] = fmt.Sprintf("%t", event.Hyperparams.RegistrationAllowed)
+	params[types.KeyCommitRevealEnabled] = fmt.Sprintf("%t", event.Hyperparams.CommitRevealEnabled)
+	params[types.KeyCommitRevealPeriod] = fmt.Sprintf("%d", event.Hyperparams.CommitRevealPeriod)
+	params[types.KeyServingRateLimit] = fmt.Sprintf("%d", event.Hyperparams.ServingRateLimit)
+	params[types.KeyValidatorThreshold] = event.Hyperparams.ValidatorThreshold.String()
+	params[types.KeyNeuronThreshold] = event.Hyperparams.NeuronThreshold.String()
 
 	// Create subnet structure
 	subnet := types.Subnet{