fix avs hooks panic (#373)

* fix avs hooks panic

* skip when avsInfo is empty

* handle error

* reject create task when no valid operator exists

* check env is set correctly

* fix lint

Author: leonz789

local_node.sh

@@ -55,6 +55,12 @@ command -v bc >/dev/null 2>&1 || {
 	exit 1
 }
 
+# check that ALCHEMY_API_KEY is set
+if [ -z "$ALCHEMY_API_KEY" ]; then
+	echo "ALCHEMY_API_KEY is not set"
+	exit 1
+fi
+
 # used to exit on first error (any non-zero exit code)
 set -e
 

x/avs/keeper/impl_epoch_hook.go

@@ -35,68 +35,66 @@ func (wrapper EpochsHooksWrapper) AfterEpochEnd(
 	// TODO:There should be a retry mechanism or compensation mechanism to handle cases of failure
 	if len(taskResList) != 0 {
 		groupedTasks := wrapper.keeper.GroupTasksByIDAndAddress(taskResList)
-		for _, value := range groupedTasks {
+		for key, value := range groupedTasks {
+			taskAddr, taskID, err := parseGroupKey(key)
+			if err != nil {
+				ctx.Logger().Error("Failed to parse group key", "key", key, "error", err)
+				continue
+			}
+			avsInfo := wrapper.keeper.GetAVSInfoByTaskAddress(ctx, taskAddr)
+			if avsInfo.AvsAddress == "" {
+				ctx.Logger().Error("Failed to update task result statistics, no AVS address found for task address!", "task address", taskAddr, "task id", taskID)
+				continue
+			}
+			avsAddr := avsInfo.AvsAddress
+			taskInfo, err := wrapper.keeper.GetTaskInfo(ctx, strconv.FormatUint(taskID, 10), taskAddr)
+			if err != nil {
+				// Log the error and continue to the next task, and this should be an 'impossible' case, since we retrieved the taskID and taskAddr from the taskResList
+				ctx.Logger().Error("Failed to update task result statistics, GetTaskInfo call failed!", "task address", taskAddr, "task id", taskID, "error", err)
+				continue
+			}
+			taskPowerTotal, err := wrapper.keeper.operatorKeeper.GetAVSUSDValue(ctx, avsAddr)
+			if err != nil || taskPowerTotal.IsZero() {
+				// Log the error and continue to the next task, and this is also an 'impossible' case, since a valid task must have a non-zero total power
+				ctx.Logger().Error("Failed to update task result statistics, GetAVSUSDValue call failed!", "avs address", avsAddr, "error", err)
+				continue
+			}
+
 			var signedOperatorList []string
-			var taskID uint64
-			var taskAddr string
-			var avsAddr string
 			var operatorPowers []*types.OperatorActivePowerInfo
 			operatorPowerTotal := sdkmath.LegacyZeroDec()
 			for _, res := range value {
 				// Find signed operators
 				if res.BlsSignature != nil && res.TaskResponseHash != "" || res.TaskResponse != nil {
 					signedOperatorList = append(signedOperatorList, res.OperatorAddress)
-					if avsAddr == "" {
-						avsInfo := wrapper.keeper.GetAVSInfoByTaskAddress(ctx, res.TaskContractAddress)
-						avsAddr = avsInfo.AvsAddress
-					}
-					if taskID == 0 {
-						taskID = res.TaskId
-					}
-					if taskAddr == "" {
-						taskAddr = res.TaskContractAddress
-					}
 					power, err := wrapper.keeper.operatorKeeper.GetOperatorOptedUSDValue(ctx, avsAddr, res.OperatorAddress)
+					activePower := sdkmath.LegacyZeroDec()
 					if err != nil || power.ActiveUSDValue.IsNegative() {
-						ctx.Logger().Error("Failed to update task result statistics,GetOperatorOptedUSDValue call failed!", "task result", taskAddr, "error", err)
-						// Handle the error gracefully, continue to the next
-						// continue
+						// Log the error and and use 0 as the active power for this operator
+						ctx.Logger().Error("Failed to get optedUSDValue for operator, skip this one", "operator", res.OperatorAddress, "avsAddr", avsAddr, "error", err)
+					} else {
+						activePower = power.ActiveUSDValue
 					}
-
 					operatorSelfPower := &types.OperatorActivePowerInfo{
 						OperatorAddress: res.OperatorAddress,
-						SelfActivePower: power.ActiveUSDValue,
+						SelfActivePower: activePower,
 					}
 					operatorPowers = append(operatorPowers, operatorSelfPower)
-					operatorPowerTotal = operatorPowerTotal.Add(power.ActiveUSDValue)
+					operatorPowerTotal = operatorPowerTotal.Add(activePower)
 				}
 			}
-			taskInfo, err := wrapper.keeper.GetTaskInfo(ctx, strconv.FormatUint(taskID, 10), taskAddr)
-			if err != nil {
-				ctx.Logger().Error("Failed to update task result statistics,GetTaskInfo call failed!", "task result", taskAddr, "error", err)
-				// Handle the error gracefully, continue to the next
-				// continue
-			}
+
 			diff := types.Difference(taskInfo.OptInOperators, signedOperatorList)
 			taskInfo.SignedOperators = signedOperatorList
 			// If a signature is submitted only once, it is counted as NoSignedOperators
 			taskInfo.NoSignedOperators = diff
 			taskInfo.OperatorActivePower = &types.OperatorActivePowerList{OperatorPowerList: operatorPowers}
-			// Calculate actual threshold
-			taskPowerTotal, err := wrapper.keeper.operatorKeeper.GetAVSUSDValue(ctx, avsAddr)
 
-			if err != nil || taskPowerTotal.IsZero() || operatorPowerTotal.IsZero() {
-				ctx.Logger().Error("Failed to update task result statistics,GetAVSUSDValue call failed!", "task result", taskAddr, "error", err)
-				// Handle the error gracefully, continue to the next
-				// continue
-			}
 			taskInfo.TaskTotalPower = taskPowerTotal
 			// Update the taskInfo in the state
 			err = wrapper.keeper.SetTaskInfo(ctx, taskInfo)
 			if err != nil {
 				ctx.Logger().Error("Failed to update task result statistics,SetTaskInfo call failed!", "task result", taskAddr, "error", err)
-				// Handle the error gracefully, continue to the next
-				// continue
 			}
 		}
 	}

x/avs/keeper/keeper.go

@@ -286,6 +286,10 @@ func (k Keeper) CreateAVSTask(ctx sdk.Context, params *types.TaskInfoParams) (ui
 	if err != nil {
 		return types.InvalidTaskID, errorsmod.Wrap(err, "CreateAVSTask: failed to get opt-in operators")
 	}
+
+	if len(operatorList) == 0 {
+		return types.InvalidTaskID, errorsmod.Wrap(types.ErrNoOptedInOperators, fmt.Sprintf("CreateAVSTask: no valid opted-in operators for AVS: %s", avsInfo.AvsAddress))
+	}
 	params.TaskID = k.GetTaskID(ctx, common.HexToAddress(params.TaskContractAddress.String()))
 	task := &types.TaskInfo{
 		Name:                  params.TaskName,

x/avs/keeper/task.go

@@ -269,7 +269,7 @@ func (k Keeper) IterateResultInfo(ctx sdk.Context, fn func(index int64, info typ
 func (k Keeper) GroupTasksByIDAndAddress(tasks []types.TaskResultInfo) map[string][]types.TaskResultInfo {
 	taskMap := make(map[string][]types.TaskResultInfo)
 	for _, task := range tasks {
-		key := task.TaskContractAddress + "_" + strconv.FormatUint(task.TaskId, 10)
+		key := task.TaskContractAddress + types.DelimiterForGroupKey + strconv.FormatUint(task.TaskId, 10)
 		taskMap[key] = append(taskMap[key], task)
 	}
 
@@ -386,3 +386,16 @@ func (k *Keeper) GetAllChallengeInfos(ctx sdk.Context) ([]types.ChallengeInfo, e
 	}
 	return ret, nil
 }
+
+func parseGroupKey(key string) (string, uint64, error) {
+	parts := strings.Split(key, types.DelimiterForGroupKey)
+	if len(parts) != 2 {
+		return "", 0, fmt.Errorf("invalid group key format: %s", key)
+	}
+	taskAddr := parts[0]
+	taskID, err := strconv.ParseUint(parts[1], 10, 64)
+	if err != nil {
+		return "", 0, fmt.Errorf("invalid task ID in group key: %s", key)
+	}
+	return taskAddr, taskID, nil
+}

x/avs/types/errors.go

@@ -119,4 +119,8 @@ var (
 		ModuleName, 28,
 		"Resource not found",
 	)
+	ErrNoOptedInOperators = errorsmod.Register(
+		ModuleName, 29,
+		"No operators have opted in to the AVS yet",
+	)
 )

x/avs/types/types.go

@@ -49,8 +49,9 @@ var (
 )
 
 const (
-	InvalidTaskID    = 0
-	BLSMessageToSign = "BLS12-381 Signed Message\nChainIDWithoutRevision: %s\nAccAddressBech32: %s"
+	InvalidTaskID        = 0
+	BLSMessageToSign     = "BLS12-381 Signed Message\nChainIDWithoutRevision: %s\nAccAddressBech32: %s"
+	DelimiterForGroupKey = "_"
 )
 
 type AVSRegisterOrDeregisterParams struct {