Merge remote-tracking branch 'pokt/main' into todo_beta/refactor/supp…

…lier_staking_fee

* pokt/main:
  chore: add localnet_config option to disable hot-reloading (#979)
  [Code Health] fix: tokenomics module gRPC return errors (#963)
  [Code Health] fix: supplier module gRPC return errors (#962)
  [Supplier] feat: add `staking_fee` param to supplier module (#944)
  [Code Health] fix: application module gRPC status error returns (#954)
  [Code Health] fix: shared module gRPC return errors (#961)
  [Code Health] fix: session module gRPC status return errors (#960)
  [Code Health] fix: service module gRPC status error returns (#959)
  [Code Health] fix: proof module gRPC status error returns (#956)
  [Code Health] fix: gateway module gRPC status error returns (#955)

Tiltfile

@@ -26,6 +26,7 @@ def merge_dicts(base, updates):
 #            environment is not broken for future engineers.
 localnet_config_path = "localnet_config.yaml"
 localnet_config_defaults = {
+    "hot-reloading": True,
     "validator": {
         "cleanupBeforeEachStart": True,
         "logs": {
@@ -182,29 +183,30 @@ secret_create_generic(
 # Import configuration files into Kubernetes ConfigMap
 configmap_create("poktrolld-configs", from_file=listdir("localnet/poktrolld/config/"), watch=True)
 
-# Hot reload protobuf changes
-local_resource(
-    "hot-reload: generate protobufs",
-    "make proto_regen",
-    deps=["proto"],
-    labels=["hot-reloading"],
-)
-# Hot reload the poktrolld binary used by the k8s cluster
-local_resource(
-    "hot-reload: poktrolld",
-    "GOOS=linux ignite chain build --skip-proto --output=./bin --debug -v",
-    deps=hot_reload_dirs,
-    labels=["hot-reloading"],
-    resource_deps=["hot-reload: generate protobufs"],
-)
-# Hot reload the local poktrolld binary used by the CLI
-local_resource(
-    "hot-reload: poktrolld - local cli",
-    "ignite chain build --skip-proto --debug -v -o $(go env GOPATH)/bin",
-    deps=hot_reload_dirs,
-    labels=["hot-reloading"],
-    resource_deps=["hot-reload: generate protobufs"],
-)
+if localnet_config["hot-reloading"]:
+    # Hot reload protobuf changes
+    local_resource(
+        "hot-reload: generate protobufs",
+        "make proto_regen",
+        deps=["proto"],
+        labels=["hot-reloading"],
+    )
+    # Hot reload the poktrolld binary used by the k8s cluster
+    local_resource(
+        "hot-reload: poktrolld",
+        "GOOS=linux ignite chain build --skip-proto --output=./bin --debug -v",
+        deps=hot_reload_dirs,
+        labels=["hot-reloading"],
+        resource_deps=["hot-reload: generate protobufs"],
+    )
+    # Hot reload the local poktrolld binary used by the CLI
+    local_resource(
+        "hot-reload: poktrolld - local cli",
+        "ignite chain build --skip-proto --debug -v -o $(go env GOPATH)/bin",
+        deps=hot_reload_dirs,
+        labels=["hot-reloading"],
+        resource_deps=["hot-reload: generate protobufs"],
+    )
 
 # Build an image with a poktrolld binary
 docker_build_with_restart(

x/application/keeper/msg_server_delegate_to_gateway.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/telemetry"
 	apptypes "github.com/pokt-network/poktroll/x/application/types"
@@ -20,44 +22,66 @@ func (k msgServer) DelegateToGateway(ctx context.Context, msg *apptypes.MsgDeleg
 	)
 
 	logger := k.Logger().With("method", "DelegateToGateway")
-	logger.Info(fmt.Sprintf("About to delegate application to gateway with msg: %v", msg))
+	logger.Info(fmt.Sprintf("About to delegate application to gateway with msg: %+v", msg))
 
 	if err := msg.ValidateBasic(); err != nil {
-		logger.Error(fmt.Sprintf("Delegation Message failed basic validation: %v", err))
-		return nil, err
+		logger.Info(fmt.Sprintf("Delegation Message failed basic validation: %s", err))
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Retrieve the application from the store
-	app, found := k.GetApplication(ctx, msg.AppAddress)
+	app, found := k.GetApplication(ctx, msg.GetAppAddress())
 	if !found {
 		logger.Info(fmt.Sprintf("Application not found with address [%s]", msg.AppAddress))
-		return nil, apptypes.ErrAppNotFound.Wrapf("application not found with address: %s", msg.AppAddress)
+		return nil, status.Error(
+			codes.NotFound,
+			apptypes.ErrAppNotFound.Wrapf(
+				"application with address: %s", msg.GetAppAddress(),
+			).Error(),
+		)
 	}
 	logger.Info(fmt.Sprintf("Application found with address [%s]", msg.AppAddress))
 
 	// Check if the gateway is staked
-	if _, found := k.gatewayKeeper.GetGateway(ctx, msg.GatewayAddress); !found {
-		logger.Info(fmt.Sprintf("Gateway not found with address [%s]", msg.GatewayAddress))
-		return nil, apptypes.ErrAppGatewayNotFound.Wrapf("gateway not found with address: %s", msg.GatewayAddress)
+	if _, found := k.gatewayKeeper.GetGateway(ctx, msg.GetGatewayAddress()); !found {
+		logger.Info(fmt.Sprintf("Gateway not found with address [%s]", msg.GetGatewayAddress()))
+		return nil, status.Error(
+			codes.NotFound,
+			apptypes.ErrAppGatewayNotFound.Wrapf(
+				"gateway with address: %q", msg.GetGatewayAddress(),
+			).Error(),
+		)
 	}
 
 	// Ensure the application is not already delegated to the maximum number of gateways
 	maxDelegatedParam := k.GetParams(ctx).MaxDelegatedGateways
 	if uint64(len(app.DelegateeGatewayAddresses)) >= maxDelegatedParam {
 		logger.Info(fmt.Sprintf("Application already delegated to maximum number of gateways: %d", maxDelegatedParam))
-		return nil, apptypes.ErrAppMaxDelegatedGateways.Wrapf("application already delegated to %d gateways", maxDelegatedParam)
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			apptypes.ErrAppMaxDelegatedGateways.Wrapf(
+				"application with address %q already delegated to %d (max) gateways",
+				msg.GetAppAddress(), maxDelegatedParam,
+			).Error(),
+		)
 	}
 
 	// Check if the application is already delegated to the gateway
 	for _, gatewayAddr := range app.DelegateeGatewayAddresses {
-		if gatewayAddr == msg.GatewayAddress {
+		if gatewayAddr == msg.GetGatewayAddress() {
 			logger.Info(fmt.Sprintf("Application already delegated to gateway with address [%s]", msg.GatewayAddress))
-			return nil, apptypes.ErrAppAlreadyDelegated.Wrapf("application already delegated to gateway with address: %s", msg.GatewayAddress)
+			return nil, status.Error(
+				codes.AlreadyExists,
+				apptypes.ErrAppAlreadyDelegated.Wrapf(
+					"application with address %q already delegated to gateway with address: %q",
+					msg.GetAppAddress(), msg.GetGatewayAddress(),
+				).Error(),
+			)
 		}
 	}
 
 	// Update the application with the new delegatee public key
-	app.DelegateeGatewayAddresses = append(app.DelegateeGatewayAddresses, msg.GatewayAddress)
+	app.DelegateeGatewayAddresses = append(app.DelegateeGatewayAddresses, msg.GetGatewayAddress())
 	logger.Info("Successfully added delegatee public key to application")
 
 	// Update the application store with the new delegation
@@ -72,12 +96,13 @@ func (k msgServer) DelegateToGateway(ctx context.Context, msg *apptypes.MsgDeleg
 		Application:      &app,
 		SessionEndHeight: sessionEndHeight,
 	}
-	logger.Info(fmt.Sprintf("Emitting application redelegation event %v", event))
+	logger.Info(fmt.Sprintf("Emitting application redelegation event %+v", event))
 
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 	if err := sdkCtx.EventManager().EmitTypedEvent(event); err != nil {
-		logger.Error(fmt.Sprintf("Failed to emit application redelegation event: %v", err))
-		return nil, err
+		err = fmt.Errorf("failed to emit application redelegation event: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	isSuccessful = true

x/application/keeper/msg_server_delegate_to_gateway_test.go

@@ -182,7 +182,7 @@ func TestMsgServer_DelegateToGateway_FailDuplicate(t *testing.T) {
 
 	// Attempt to delegate the application to the gateway again
 	_, err = srv.DelegateToGateway(ctx, delegateMsg2)
-	require.ErrorIs(t, err, apptypes.ErrAppAlreadyDelegated)
+	require.ErrorContains(t, err, apptypes.ErrAppAlreadyDelegated.Error())
 
 	events = sdkCtx.EventManager().Events()
 	require.Equal(t, 0, len(events))
@@ -221,7 +221,7 @@ func TestMsgServer_DelegateToGateway_FailGatewayNotStaked(t *testing.T) {
 
 	// Attempt to delegate the application to the unstaked gateway
 	_, err = srv.DelegateToGateway(ctx, delegateMsg)
-	require.ErrorIs(t, err, apptypes.ErrAppGatewayNotFound)
+	require.ErrorContains(t, err, apptypes.ErrAppGatewayNotFound.Error())
 	foundApp, isAppFound := k.GetApplication(ctx, appAddr)
 	require.True(t, isAppFound)
 	require.Equal(t, 0, len(foundApp.DelegateeGatewayAddresses))
@@ -312,7 +312,7 @@ func TestMsgServer_DelegateToGateway_FailMaxReached(t *testing.T) {
 
 	// Attempt to delegate the application when the max is already reached
 	_, err = srv.DelegateToGateway(ctx, delegateMsg)
-	require.ErrorIs(t, err, apptypes.ErrAppMaxDelegatedGateways)
+	require.ErrorContains(t, err, apptypes.ErrAppMaxDelegatedGateways.Error())
 
 	events = sdkCtx.EventManager().Events()
 	filteredEvents = testevents.FilterEvents[*apptypes.EventRedelegation](t, events)

x/application/keeper/msg_server_undelegate_from_gateway.go

@@ -6,6 +6,8 @@ import (
 	"slices"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/telemetry"
 	apptypes "github.com/pokt-network/poktroll/x/application/types"
@@ -20,32 +22,43 @@ func (k msgServer) UndelegateFromGateway(ctx context.Context, msg *apptypes.MsgU
 	)
 
 	logger := k.Logger().With("method", "UndelegateFromGateway")
-	logger.Info(fmt.Sprintf("About to undelegate application from gateway with msg: %v", msg))
+	logger.Info(fmt.Sprintf("About to undelegate application from gateway with msg: %+v", msg))
 
 	// Basic validation of the message
 	if err := msg.ValidateBasic(); err != nil {
-		logger.Error(fmt.Sprintf("Undelegation Message failed basic validation: %v", err))
-		return nil, err
+		logger.Info(fmt.Sprintf("Undelegation Message failed basic validation: %s", err))
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Retrieve the application from the store
-	foundApp, isAppFound := k.GetApplication(ctx, msg.AppAddress)
+	foundApp, isAppFound := k.GetApplication(ctx, msg.GetAppAddress())
 	if !isAppFound {
-		logger.Info(fmt.Sprintf("Application not found with address [%s]", msg.AppAddress))
-		return nil, apptypes.ErrAppNotFound.Wrapf("application not found with address: %s", msg.AppAddress)
+		logger.Info(fmt.Sprintf("Application not found with address [%s]", msg.GetAppAddress()))
+		return nil, status.Error(
+			codes.NotFound,
+			apptypes.ErrAppNotFound.Wrapf(
+				"application with address: %q", msg.GetAppAddress(),
+			).Error(),
+		)
 	}
-	logger.Info(fmt.Sprintf("Application found with address [%s]", msg.AppAddress))
+	logger.Info(fmt.Sprintf("Application found with address [%s]", msg.GetAppAddress()))
 
 	// Check if the application is already delegated to the gateway
 	foundIdx := -1
 	for i, gatewayAddr := range foundApp.DelegateeGatewayAddresses {
-		if gatewayAddr == msg.GatewayAddress {
+		if gatewayAddr == msg.GetGatewayAddress() {
 			foundIdx = i
 		}
 	}
 	if foundIdx == -1 {
-		logger.Info(fmt.Sprintf("Application not delegated to gateway with address [%s]", msg.GatewayAddress))
-		return nil, apptypes.ErrAppNotDelegated.Wrapf("application not delegated to gateway with address: %s", msg.GatewayAddress)
+		logger.Info(fmt.Sprintf("Application not delegated to gateway with address [%s]", msg.GetGatewayAddress()))
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			apptypes.ErrAppNotDelegated.Wrapf(
+				"application with address %q not delegated to gateway with address: %q",
+				msg.GetAppAddress(), msg.GetGatewayAddress(),
+			).Error(),
+		)
 	}
 
 	// Remove the gateway from the application's delegatee gateway public keys
@@ -55,7 +68,7 @@ func (k msgServer) UndelegateFromGateway(ctx context.Context, msg *apptypes.MsgU
 	currentHeight := sdkCtx.BlockHeight()
 	sessionEndHeight := k.sharedKeeper.GetSessionEndHeight(ctx, currentHeight)
 
-	k.recordPendingUndelegation(ctx, &foundApp, msg.GatewayAddress, currentHeight)
+	k.recordPendingUndelegation(ctx, &foundApp, msg.GetGatewayAddress(), currentHeight)
 
 	// Update the application store with the new delegation
 	k.SetApplication(ctx, foundApp)
@@ -67,8 +80,9 @@ func (k msgServer) UndelegateFromGateway(ctx context.Context, msg *apptypes.MsgU
 		SessionEndHeight: sessionEndHeight,
 	}
 	if err := sdkCtx.EventManager().EmitTypedEvent(event); err != nil {
-		logger.Error(fmt.Sprintf("Failed to emit application redelegation event: %v", err))
-		return nil, err
+		err = fmt.Errorf("failed to emit application redelegation event: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 	logger.Info(fmt.Sprintf("Emitted application redelegation event %v", event))
 

x/application/keeper/msg_server_undelegate_from_gateway_test.go

@@ -174,7 +174,7 @@ func TestMsgServer_UndelegateFromGateway_FailNotDelegated(t *testing.T) {
 
 	// Attempt to undelgate the application from the gateway
 	_, err = srv.UndelegateFromGateway(ctx, undelegateMsg)
-	require.ErrorIs(t, err, types.ErrAppNotDelegated)
+	require.ErrorContains(t, err, types.ErrAppNotDelegated.Error())
 	foundApp, isAppFound := k.GetApplication(ctx, appAddr)
 	require.True(t, isAppFound)
 	require.Equal(t, appAddr, foundApp.Address)
@@ -221,7 +221,7 @@ func TestMsgServer_UndelegateFromGateway_FailNotDelegated(t *testing.T) {
 
 	// Ensure the failed undelegation did not affect the application
 	_, err = srv.UndelegateFromGateway(ctx, undelegateMsg)
-	require.ErrorIs(t, err, types.ErrAppNotDelegated)
+	require.ErrorContains(t, err, apptypes.ErrAppNotDelegated.Error())
 
 	events = sdkCtx.EventManager().Events()
 	require.Equal(t, 0, len(events), "expected no events")

x/application/keeper/msg_server_unstake_application.go

@@ -31,25 +31,40 @@ func (k msgServer) UnstakeApplication(
 	// Check if the application already exists or not.
 	foundApp, isAppFound := k.GetApplication(ctx, msg.GetAddress())
 	if !isAppFound {
-		logger.Info(fmt.Sprintf("Application not found. Cannot unstake address (%s)", msg.GetAddress()))
-		return nil, apptypes.ErrAppNotFound.Wrapf("application (%s)", msg.GetAddress())
+		logger.Info(fmt.Sprintf("Application not found. Cannot unstake address [%s]", msg.GetAddress()))
+		return nil, status.Error(
+			codes.NotFound,
+			apptypes.ErrAppNotFound.Wrapf(
+				"application with address %q", msg.GetAddress(),
+			).Error(),
+		)
 	}
-	logger.Info(fmt.Sprintf("Application found. Unstaking application for address (%s)", msg.GetAddress()))
+	logger.Info(fmt.Sprintf("Application found. Unstaking application for address [%s]", msg.GetAddress()))
 
 	// Check if the application has already initiated the unstaking process.
 	if foundApp.IsUnbonding() {
-		logger.Warn(fmt.Sprintf("Application (%s) is still unbonding from previous unstaking", msg.GetAddress()))
-		return nil, apptypes.ErrAppIsUnstaking.Wrapf("application (%s)", msg.GetAddress())
+		logger.Info(fmt.Sprintf("Application with address [%s] is still unbonding from previous unstaking", msg.GetAddress()))
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			apptypes.ErrAppIsUnstaking.Wrapf(
+				"application with address %q", msg.GetAddress(),
+			).Error(),
+		)
 	}
 
 	// Check if the application has already initiated a transfer process.
 	// Transferring applications CANNOT unstake.
 	if foundApp.HasPendingTransfer() {
 		logger.Warn(fmt.Sprintf(
-			"Application (%s) has a pending transfer to (%s)",
+			"Application with address [%s] has a pending transfer to [%s]",
 			msg.Address, foundApp.GetPendingTransfer().GetDestinationAddress()),
 		)
-		return nil, apptypes.ErrAppHasPendingTransfer.Wrapf("application (%s)", msg.GetAddress())
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			apptypes.ErrAppHasPendingTransfer.Wrapf(
+				"application with address %q", msg.GetAddress(),
+			).Error(),
+		)
 	}
 
 	sdkCtx := sdk.UnwrapSDKContext(ctx)

x/application/keeper/msg_server_unstake_application_test.go

@@ -224,7 +224,7 @@ func TestMsgServer_UnstakeApplication_FailIfNotStaked(t *testing.T) {
 	unstakeMsg := &apptypes.MsgUnstakeApplication{Address: appAddr}
 	_, err := srv.UnstakeApplication(ctx, unstakeMsg)
 	require.Error(t, err)
-	require.ErrorIs(t, err, apptypes.ErrAppNotFound)
+	require.ErrorContains(t, err, apptypes.ErrAppNotFound.Error())
 
 	_, isAppFound = applicationModuleKeepers.GetApplication(ctx, appAddr)
 	require.False(t, isAppFound)
@@ -253,7 +253,7 @@ func TestMsgServer_UnstakeApplication_FailIfCurrentlyUnstaking(t *testing.T) {
 
 	// Verify that the application cannot unstake if it is already unstaking.
 	_, err = srv.UnstakeApplication(ctx, unstakeMsg)
-	require.ErrorIs(t, err, apptypes.ErrAppIsUnstaking)
+	require.ErrorContains(t, err, apptypes.ErrAppIsUnstaking.Error())
 }
 
 func createAppStakeMsg(appAddr string, stakeAmount int64) *apptypes.MsgStakeApplication {