review code

Author: maoaixiao1314

init.sh

@@ -18,8 +18,15 @@ echo "Home directory: $HETUD_HOME"
 # Build the binary
 # go build ./cmd/hetud
 
-# Clear the home folder
-rm -rf "$HETUD_HOME"
+# Clear the home folder (guarded)
+if [[ -z "${HETUD_HOME:-}" || "$HETUD_HOME" = "/" ]]; then
+  echo "Refusing to remove HETUD_HOME=$HETUD_HOME"
+  exit 1
+fi
+echo "About to remove $HETUD_HOME (override with SKIP_RESET=1 to skip)"
+if [[ "${SKIP_RESET:-0}" != "1" ]]; then
+  rm -rf "$HETUD_HOME"
+fi
 
 # Initialize configuration
 # hetud config keyring-backend "$KEYRING"
@@ -64,7 +71,12 @@ jq ".consensus_params[\"block\"][\"time_iota_ms\"]=\"30000\"" "$GENESIS" > "$TMP
 jq ".consensus_params[\"block\"][\"max_gas\"]=\"10000000\"" "$GENESIS" > "$TMPGENESIS" && mv "$TMPGENESIS" "$GENESIS"
 
 # Modify the configuration file
-sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' "$ETHCONFIG"
+# Cross-platform in-place sed
+if sed --version >/dev/null 2>&1; then
+  sed -i 's/create_empty_blocks = true/create_empty_blocks = false/g' "$ETHCONFIG"   # GNU sed
+else
+  sed -i '' 's/create_empty_blocks = true/create_empty_blocks = false/g' "$ETHCONFIG" # BSD sed (macOS)
+fi
 
 # Allocate genesis accounts
 hetud add-genesis-account "$KEY" 100000000000000000000000000ahetu --keyring-backend "$KEYRING" --home "$HETUD_HOME"
@@ -73,10 +85,10 @@ hetud add-genesis-account "$KEY" 100000000000000000000000000ahetu --keyring-back
 hetud gentx "$KEY" 2000000000000000000000ahetu --keyring-backend "$KEYRING" --chain-id "$CHAINID" --home "$HETUD_HOME" --fees 1000000ahetu --gas 200000
 
 # Collect genesis transactions
-hetud collect-gentxs
+hetud collect-gentxs --home "$HETUD_HOME"
 
 # Validate genesis file
-hetud validate-genesis
+hetud validate-genesis --home "$HETUD_HOME"
 
 # Configure P2P for external connections
 # Get the node ID

x/blockinflation/keeper/coinbase.go

@@ -179,7 +179,11 @@ func (k Keeper) RunCoinbase(ctx sdk.Context, blockEmission math.Int) error {
 			k.Logger(ctx).Error("subnet not found", "netuid", netuid)
 			continue
 		}
-		params := stakeworktypes.ParseEpochParams(subnet.Params)
+		params, err := stakeworktypes.ParseEpochParams(subnet.Params)
+		if err != nil {
+			k.Logger(ctx).Error("failed to parse epoch parameters", "netuid", netuid, "err", err)
+			continue
+		}
 		tempo := params.Tempo
 		if k.stakeworkKeeper.ShouldRunEpoch(ctx, netuid, tempo) {
 			k.Logger(ctx).Debug("Epoch triggered", "netuid", netuid, "block", ctx.BlockHeight())

x/event/keeper/keeper.go

@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"math/big"
+	"strconv"
 
 	"cosmossdk.io/log"
 	"cosmossdk.io/math"
@@ -25,6 +26,7 @@ import (
 )
 
 // ----------- Event topic constants -----------
+// Deprecated: Use Keeper instance fields (k.topicXXX) instead of these global constants
 var (
 	// Legacy events remain unchanged (backward compatibility)
 	SubnetRegisteredTopic  = crypto.Keccak256Hash([]byte("SubnetRegistered(address,uint16,uint256,uint256,address,string)")).Hex()
@@ -61,6 +63,23 @@ type Keeper struct {
 	subnetManagerABI abi.ABI
 	neuronManagerABI abi.ABI
 	globalStakingABI abi.ABI
+
+	// Event topic IDs
+	topicSubnetRegistered        string
+	topicStakedSelf              string
+	topicUnstakedSelf            string
+	topicStakedDelegated         string
+	topicUnstakedDelegated       string
+	topicWeightsSet              string
+	topicNetworkRegistered       string
+	topicSubnetActivated         string
+	topicNetworkConfigUpdated    string
+	topicNeuronRegistered        string
+	topicNeuronDeregistered      string
+	topicNeuronStakeChanged      string
+	topicServiceUpdated          string
+	topicSubnetAllocationChanged string
+	topicDeallocatedFromSubnet   string
 }
 
 // ----------- Keeper initialization -----------
@@ -75,7 +94,7 @@ func NewKeeper(
 	neuronManagerABI abi.ABI,
 	globalStakingABI abi.ABI,
 ) *Keeper {
-	return &Keeper{
+	k := &Keeper{
 		cdc:                 cdc,
 		storeKey:            storeKey,
 		subnetRegistryABI:   subnetRegistryABI,
@@ -86,6 +105,24 @@ func NewKeeper(
 		neuronManagerABI:    neuronManagerABI,
 		globalStakingABI:    globalStakingABI,
 	}
+	// Legacy events
+	k.topicSubnetRegistered = k.subnetRegistryABI.Events["SubnetRegistered"].ID.Hex()
+	k.topicStakedSelf = k.stakingSelfABI.Events["Staked"].ID.Hex()
+	k.topicUnstakedSelf = k.stakingSelfABI.Events["Unstaked"].ID.Hex()
+	k.topicStakedDelegated = k.stakingDelegatedABI.Events["Staked"].ID.Hex()
+	k.topicUnstakedDelegated = k.stakingDelegatedABI.Events["Unstaked"].ID.Hex()
+	k.topicWeightsSet = k.weightsABI.Events["WeightsSet"].ID.Hex()
+	// New events
+	k.topicNetworkRegistered = k.subnetManagerABI.Events["NetworkRegistered"].ID.Hex()
+	k.topicSubnetActivated = k.subnetManagerABI.Events["SubnetActivated"].ID.Hex()
+	k.topicNetworkConfigUpdated = k.subnetManagerABI.Events["NetworkConfigUpdated"].ID.Hex()
+	k.topicNeuronRegistered = k.neuronManagerABI.Events["NeuronRegistered"].ID.Hex()
+	k.topicNeuronDeregistered = k.neuronManagerABI.Events["NeuronDeregistered"].ID.Hex()
+	k.topicNeuronStakeChanged = k.neuronManagerABI.Events["StakeAllocationChanged"].ID.Hex()
+	k.topicServiceUpdated = k.neuronManagerABI.Events["ServiceUpdated"].ID.Hex()
+	k.topicSubnetAllocationChanged = k.globalStakingABI.Events["SubnetAllocationChanged"].ID.Hex()
+	k.topicDeallocatedFromSubnet = k.globalStakingABI.Events["DeallocatedFromSubnet"].ID.Hex()
+	return k
 }
 
 // ----------- Logger -----------
@@ -106,51 +143,51 @@ func (k *Keeper) HandleEvmLogs(ctx sdk.Context, logs []ethTypes.Log) {
 
 		switch topic {
 		// Legacy events (maintain compatibility)
-		case SubnetRegisteredTopic:
+		case k.topicSubnetRegistered:
 			k.Logger(ctx).Debug("Identified SubnetRegistered event")
 			k.handleSubnetRegistered(ctx, log)
-		case StakedSelfTopic:
+		case k.topicStakedSelf:
 			k.Logger(ctx).Debug("Identified StakedSelf event")
 			k.handleStaked(ctx, log)
-		case UnstakedSelfTopic:
+		case k.topicUnstakedSelf:
 			k.Logger(ctx).Debug("Identified UnstakedSelf event")
 			k.handleUnstaked(ctx, log)
-		case StakedDelegatedTopic:
+		case k.topicStakedDelegated:
 			k.Logger(ctx).Debug("Identified StakedDelegated event")
 			k.handleDelegatedStaked(ctx, log)
-		case UnstakedDelegatedTopic:
+		case k.topicUnstakedDelegated:
 			k.Logger(ctx).Debug("Identified UnstakedDelegated event")
 			k.handleDelegatedUnstaked(ctx, log)
-		case WeightsSetTopic:
+		case k.topicWeightsSet:
 			k.Logger(ctx).Debug("Identified WeightsSet event")
 			k.handleWeightsSet(ctx, log)
 
 		// New events
-		case NetworkRegisteredTopic:
+		case k.topicNetworkRegistered:
 			k.Logger(ctx).Debug("Identified NetworkRegistered event")
 			k.handleNetworkRegistered(ctx, log)
-		case SubnetActivatedTopic:
+		case k.topicSubnetActivated:
 			k.Logger(ctx).Debug("Identified SubnetActivated event")
 			k.handleSubnetActivated(ctx, log)
-		case NetworkConfigUpdatedTopic:
+		case k.topicNetworkConfigUpdated:
 			k.Logger(ctx).Debug("Identified NetworkConfigUpdated event")
 			k.handleNetworkConfigUpdated(ctx, log)
-		case NeuronRegisteredTopic:
+		case k.topicNeuronRegistered:
 			k.Logger(ctx).Debug("Identified NeuronRegistered event")
 			k.handleNeuronRegistered(ctx, log)
-		case NeuronDeregisteredTopic:
+		case k.topicNeuronDeregistered:
 			k.Logger(ctx).Debug("Identified NeuronDeregistered event")
 			k.handleNeuronDeregistered(ctx, log)
-		case NeuronStakeChangedTopic:
+		case k.topicNeuronStakeChanged:
 			k.Logger(ctx).Debug("Identified NeuronStakeChanged event")
 			k.handleNeuronStakeChanged(ctx, log)
-		case ServiceUpdatedTopic:
+		case k.topicServiceUpdated:
 			k.Logger(ctx).Debug("Identified ServiceUpdated event")
 			k.handleServiceUpdated(ctx, log)
-		case SubnetAllocationChangedTopic:
+		case k.topicSubnetAllocationChanged:
 			k.Logger(ctx).Debug("Identified SubnetAllocationChanged event")
 			k.handleSubnetAllocationChanged(ctx, log)
-		case DeallocatedFromSubnetTopic:
+		case k.topicDeallocatedFromSubnet:
 			k.Logger(ctx).Debug("Identified DeallocatedFromSubnet event")
 			k.handleDeallocatedFromSubnet(ctx, log)
 		default:
@@ -385,10 +422,10 @@ 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"] = fmt.Sprintf("%.1f", float64(event.Hyperparams.Rho)/10000.0) // uint16 to float64, assuming original value is scaled by 10000
+		params["rho"] = strconv.FormatFloat(float64(event.Hyperparams.Rho)/10000.0, 'f', -1, 64)
 	}
 	if event.Hyperparams.Kappa != 0 {
-		params["kappa"] = fmt.Sprintf("%.1f", float64(event.Hyperparams.Kappa)/10000.0) // uint16 to float64, assuming original value is scaled by 10000
+		params["kappa"] = fmt.Sprintf("%d", event.Hyperparams.Kappa)
 	}
 	if event.Hyperparams.ImmunityPeriod != 0 {
 		params["immunity_period"] = fmt.Sprintf("%d", event.Hyperparams.ImmunityPeriod)

x/stakework/README.md

@@ -125,7 +125,7 @@ type EpochParams struct {
 ### 1. Run Epoch
 
 ```go
-result, err := k.RunEpoch(ctx, netuid, raoEmission)
+result, err := k.RunEpoch(ctx, netuid, ahetuEmission)
 if err != nil {
     return err
 }

x/stakework/keeper/epoch.go

@@ -33,7 +33,11 @@ func (k Keeper) RunEpoch(ctx sdk.Context, netuid uint16, raoEmission uint64) (*t
 	logger.Debug("Retrieved subnet data", "netuid", netuid, "subnet", subnet)
 
 	// 2. Parse subnet parameters
-	params := types.ParseEpochParams(subnet.Params)
+	params, err := types.ParseEpochParams(subnet.Params)
+	if err != nil {
+		logger.Error("Failed to parse epoch parameters", "netuid", netuid, "err", err)
+		return nil, fmt.Errorf("failed to parse epoch parameters: %w", err)
+	}
 	logger.Debug("Parsed subnet parameters",
 		"kappa", params.Kappa,
 		"alpha", params.Alpha,
@@ -540,7 +544,8 @@ func (k Keeper) distributeEmission(normIncentive, normDividends []float64, raoEm
 	emission := make([]uint64, n)
 
 	for i := 0; i < n; i++ {
-		emission[i] = uint64(normIncentive[i]*float64(raoEmission)) + uint64(normDividends[i]*float64(raoEmission))
+		// emission[i] = uint64(normIncentive[i]*float64(raoEmission)) + uint64(normDividends[i]*float64(raoEmission))
+		emission[i] = uint64((normIncentive[i] + normDividends[i]) * float64(raoEmission))
 	}
 
 	return emission

x/stakework/module.go

@@ -2,6 +2,7 @@ package stakework
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"cosmossdk.io/core/appmodule"
 	"cosmossdk.io/depinject"
@@ -112,25 +113,8 @@ func (AppModule) ConsensusVersion() uint64 { return 1 }
 
 // BeginBlock executes at the beginning of each block
 func (am AppModule) BeginBlock(ctx sdk.Context, _ interface{}) {
-	// Check if epochs need to be run
-	am.checkAndRunEpochs(ctx)
-}
-
-// checkAndRunEpochs checks and runs epochs
-func (am AppModule) checkAndRunEpochs(ctx sdk.Context) {
-	// Get all subnets
-	subnets := am.keeper.GetEventKeeper().GetAllSubnets(ctx)
-
-	for _, subnet := range subnets {
-		// Attempt to run epoch
-		_, err := am.keeper.RunEpoch(ctx, subnet.Netuid, 1000000) // Default 1M rao emission
-		if err != nil {
-			// If not an error due to time not being due, log it
-			if err != keeper.ErrEpochNotDue {
-				ctx.Logger().Error("Failed to run epoch", "netuid", subnet.Netuid, "error", err)
-			}
-		}
-	}
+	// 移除 checkAndRunEpochs 调用
+	// 依赖 blockinflation 模块的 coinbase.go 来运行 epoch
 }
 
 // Dependency injection support
@@ -143,9 +127,8 @@ func (am AppModule) IsAppModule() {}
 
 // ProvideModule provides module dependencies
 func ProvideModule(in depinject.Config) (keeper.Keeper, error) {
-	// This needs to be implemented based on the actual dependency injection configuration
-	// For now, return a simple implementation
-	return keeper.Keeper{}, nil
+	// TODO: Implement proper dependency injection
+	return keeper.Keeper{}, fmt.Errorf("ProvideModule not yet implemented")
 }
 
 // InitGenesis initializes the genesis state