diff --git a/Tiltfile b/Tiltfile
index bc0d78b92..03cf76bb4 100644
--- a/Tiltfile
+++ b/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(
diff --git a/x/application/keeper/msg_server_delegate_to_gateway.go b/x/application/keeper/msg_server_delegate_to_gateway.go
index f109d0ce3..395346d88 100644
--- a/x/application/keeper/msg_server_delegate_to_gateway.go
+++ b/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
diff --git a/x/application/keeper/msg_server_delegate_to_gateway_test.go b/x/application/keeper/msg_server_delegate_to_gateway_test.go
index 18525fa4f..873817d8b 100644
--- a/x/application/keeper/msg_server_delegate_to_gateway_test.go
+++ b/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)
diff --git a/x/application/keeper/msg_server_undelegate_from_gateway.go b/x/application/keeper/msg_server_undelegate_from_gateway.go
index 8af02752d..9fd7b1258 100644
--- a/x/application/keeper/msg_server_undelegate_from_gateway.go
+++ b/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))
 
diff --git a/x/application/keeper/msg_server_undelegate_from_gateway_test.go b/x/application/keeper/msg_server_undelegate_from_gateway_test.go
index bc562a81a..4a2f7663b 100644
--- a/x/application/keeper/msg_server_undelegate_from_gateway_test.go
+++ b/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")
diff --git a/x/application/keeper/msg_server_unstake_application.go b/x/application/keeper/msg_server_unstake_application.go
index 337df4382..bdd3a6bb5 100644
--- a/x/application/keeper/msg_server_unstake_application.go
+++ b/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)
diff --git a/x/application/keeper/msg_server_unstake_application_test.go b/x/application/keeper/msg_server_unstake_application_test.go
index fa1a59002..68fb1db13 100644
--- a/x/application/keeper/msg_server_unstake_application_test.go
+++ b/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 {
diff --git a/x/application/keeper/msg_server_update_param.go b/x/application/keeper/msg_server_update_param.go
index a06925e75..0912fcb14 100644
--- a/x/application/keeper/msg_server_update_param.go
+++ b/x/application/keeper/msg_server_update_param.go
@@ -17,12 +17,12 @@ func (k msgServer) UpdateParam(ctx context.Context, msg *apptypes.MsgUpdateParam
 	)
 
 	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	if k.GetAuthority() != msg.Authority {
 		return nil, status.Error(
-			codes.InvalidArgument,
+			codes.PermissionDenied,
 			apptypes.ErrAppInvalidSigner.Wrapf(
 				"invalid authority; expected %s, got %s",
 				k.GetAuthority(), msg.Authority,
@@ -38,12 +38,22 @@ func (k msgServer) UpdateParam(ctx context.Context, msg *apptypes.MsgUpdateParam
 
 		params.MaxDelegatedGateways = msg.GetAsUint64()
 		if _, ok := msg.AsType.(*apptypes.MsgUpdateParam_AsUint64); !ok {
-			return nil, apptypes.ErrAppParamInvalid.Wrapf("unsupported value type for %s param: %T", msg.Name, msg.AsType)
+			return nil, status.Error(
+				codes.InvalidArgument,
+				apptypes.ErrAppParamInvalid.Wrapf(
+					"unsupported value type for %s param: %T", msg.Name, msg.AsType,
+				).Error(),
+			)
 		}
 		maxDelegatedGateways := msg.GetAsUint64()
 
 		if err := apptypes.ValidateMaxDelegatedGateways(maxDelegatedGateways); err != nil {
-			return nil, apptypes.ErrAppParamInvalid.Wrapf("maxdelegegated_gateways (%d): %v", maxDelegatedGateways, err)
+			return nil, status.Error(
+				codes.InvalidArgument,
+				apptypes.ErrAppParamInvalid.Wrapf(
+					"max_delegegated_gateways (%d): %s", maxDelegatedGateways, err,
+				).Error(),
+			)
 		}
 		params.MaxDelegatedGateways = maxDelegatedGateways
 	case apptypes.ParamMinStake:
diff --git a/x/application/keeper/msg_update_params.go b/x/application/keeper/msg_update_params.go
index 52335b954..1e101297e 100644
--- a/x/application/keeper/msg_update_params.go
+++ b/x/application/keeper/msg_update_params.go
@@ -2,20 +2,34 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/application/types"
 )
 
 func (k msgServer) UpdateParams(ctx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrAppInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrAppInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s",
+				k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/application/keeper/query_application.go b/x/application/keeper/query_application.go
index 446449d29..4ec5e8ac6 100644
--- a/x/application/keeper/query_application.go
+++ b/x/application/keeper/query_application.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	"cosmossdk.io/store/prefix"
 	"github.com/cosmos/cosmos-sdk/runtime"
@@ -13,6 +14,8 @@ import (
 )
 
 func (k Keeper) AllApplications(ctx context.Context, req *types.QueryAllApplicationsRequest) (*types.QueryAllApplicationsResponse, error) {
+	logger := k.Logger().With("method", "AllApplications")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -25,7 +28,8 @@ func (k Keeper) AllApplications(ctx context.Context, req *types.QueryAllApplicat
 	pageRes, err := query.Paginate(applicationStore, req.Pagination, func(key []byte, value []byte) error {
 		var application types.Application
 		if err := k.cdc.Unmarshal(value, &application); err != nil {
-			return err
+			logger.Error(fmt.Sprintf("unmarshaling application with key (hex): %x: %+v", key, err))
+			return status.Error(codes.Internal, err.Error())
 		}
 
 		// Ensure that the PendingUndelegations is an empty map and not nil when
diff --git a/x/gateway/keeper/msg_server_stake_gateway.go b/x/gateway/keeper/msg_server_stake_gateway.go
index 8a6ce25ab..3f3f1cc14 100644
--- a/x/gateway/keeper/msg_server_stake_gateway.go
+++ b/x/gateway/keeper/msg_server_stake_gateway.go
@@ -90,7 +90,7 @@ func (k msgServer) StakeGateway(
 	if err != nil {
 		// TODO_TECHDEBT(#384): determine whether to continue using cosmos logger for debug level.
 		logger.Error(fmt.Sprintf("could not escrowed %v coins from %q to %q module account due to %v", coinsToEscrow, gatewayAddress, types.ModuleName, err))
-		return nil, err
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	// Update the Gateway in the store
diff --git a/x/gateway/keeper/msg_server_unstake_gateway.go b/x/gateway/keeper/msg_server_unstake_gateway.go
index 2e09bec19..d8c757713 100644
--- a/x/gateway/keeper/msg_server_unstake_gateway.go
+++ b/x/gateway/keeper/msg_server_unstake_gateway.go
@@ -30,7 +30,7 @@ func (k msgServer) UnstakeGateway(
 	logger.Info(fmt.Sprintf("About to unstake gateway with msg: %v", msg))
 
 	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Check if the gateway already exists or not
@@ -38,22 +38,28 @@ func (k msgServer) UnstakeGateway(
 	gateway, isGatewayFound := k.GetGateway(ctx, msg.Address)
 	if !isGatewayFound {
 		logger.Info(fmt.Sprintf("Gateway not found. Cannot unstake address %s", msg.Address))
-		return nil, types.ErrGatewayNotFound
+		return nil, status.Error(
+			codes.NotFound,
+			types.ErrGatewayNotFound.Wrapf(
+				"gateway with address %s", msg.Address,
+			).Error(),
+		)
 	}
 	logger.Info(fmt.Sprintf("Gateway found. Unstaking gateway for address %s", msg.Address))
 
 	// Retrieve the address of the gateway
 	gatewayAddress, err := sdk.AccAddressFromBech32(msg.Address)
 	if err != nil {
-		logger.Error(fmt.Sprintf("could not parse address %s", msg.Address))
-		return nil, err
+		logger.Info(fmt.Sprintf("could not parse address %s", msg.Address))
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Send the coins from the gateway pool back to the gateway
 	err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, gatewayAddress, []sdk.Coin{*gateway.Stake})
 	if err != nil {
-		logger.Error(fmt.Sprintf("could not send %v coins from %s module to %s account due to %v", gateway.Stake, gatewayAddress, types.ModuleName, err))
-		return nil, err
+		err = fmt.Errorf("could not send %v coins from %s module to %s account due to %v", gateway.Stake, gatewayAddress, types.ModuleName, err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	// Update the Gateway in the store
diff --git a/x/gateway/keeper/msg_server_unstake_gateway_test.go b/x/gateway/keeper/msg_server_unstake_gateway_test.go
index 4c977ef3c..64ad5cadf 100644
--- a/x/gateway/keeper/msg_server_unstake_gateway_test.go
+++ b/x/gateway/keeper/msg_server_unstake_gateway_test.go
@@ -66,7 +66,7 @@ func TestMsgServer_UnstakeGateway_FailIfNotStaked(t *testing.T) {
 	unstakeMsg := &types.MsgUnstakeGateway{Address: addr}
 	_, err := srv.UnstakeGateway(ctx, unstakeMsg)
 	require.Error(t, err)
-	require.ErrorIs(t, err, types.ErrGatewayNotFound)
+	require.ErrorContains(t, err, types.ErrGatewayNotFound.Error())
 
 	_, isGatewayFound = k.GetGateway(ctx, addr)
 	require.False(t, isGatewayFound)
diff --git a/x/gateway/keeper/msg_update_params.go b/x/gateway/keeper/msg_update_params.go
index d8039b896..9b13b4d17 100644
--- a/x/gateway/keeper/msg_update_params.go
+++ b/x/gateway/keeper/msg_update_params.go
@@ -2,8 +2,11 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/gateway/types"
 )
@@ -12,17 +15,26 @@ func (k msgServer) UpdateParams(
 	goCtx context.Context,
 	req *types.MsgUpdateParams,
 ) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrGatewayInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrGatewayInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	// NOTE(#322): Omitted parameters will be set to their zero value.
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/gateway/keeper/query_gateway.go b/x/gateway/keeper/query_gateway.go
index 0b6d2ab2a..8420bde17 100644
--- a/x/gateway/keeper/query_gateway.go
+++ b/x/gateway/keeper/query_gateway.go
@@ -14,6 +14,8 @@ import (
 )
 
 func (k Keeper) AllGateways(ctx context.Context, req *types.QueryAllGatewaysRequest) (*types.QueryAllGatewaysResponse, error) {
+	logger := k.Logger().With("method", "AllGateways")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -26,7 +28,8 @@ func (k Keeper) AllGateways(ctx context.Context, req *types.QueryAllGatewaysRequ
 	pageRes, err := query.Paginate(gatewayStore, req.Pagination, func(key []byte, value []byte) error {
 		var gateway types.Gateway
 		if err := k.cdc.Unmarshal(value, &gateway); err != nil {
-			return err
+			logger.Error(fmt.Sprintf("unmarshaling gateway with key (hex): %x: %+v", key, err))
+			return status.Error(codes.Internal, err.Error())
 		}
 
 		gateways = append(gateways, gateway)
diff --git a/x/proof/keeper/msg_server_create_claim.go b/x/proof/keeper/msg_server_create_claim.go
index d9c4a32d3..f9e06055c 100644
--- a/x/proof/keeper/msg_server_create_claim.go
+++ b/x/proof/keeper/msg_server_create_claim.go
@@ -33,7 +33,7 @@ func (k msgServer) CreateClaim(
 
 	// Basic validation of the CreateClaim message.
 	if err = msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	logger.Info("validated the createClaim message")
 
diff --git a/x/proof/keeper/msg_update_params.go b/x/proof/keeper/msg_update_params.go
index 392f9333f..8b95781b2 100644
--- a/x/proof/keeper/msg_update_params.go
+++ b/x/proof/keeper/msg_update_params.go
@@ -2,20 +2,33 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/proof/types"
 )
 
 func (k msgServer) UpdateParams(ctx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrProofInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrProofInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/proof/keeper/query_claim.go b/x/proof/keeper/query_claim.go
index 520aa4b0c..399cf3f27 100644
--- a/x/proof/keeper/query_claim.go
+++ b/x/proof/keeper/query_claim.go
@@ -3,6 +3,7 @@ package keeper
 import (
 	"context"
 	"encoding/binary"
+	"fmt"
 
 	"cosmossdk.io/store/prefix"
 	"github.com/cosmos/cosmos-sdk/runtime"
@@ -14,6 +15,8 @@ import (
 )
 
 func (k Keeper) AllClaims(ctx context.Context, req *types.QueryAllClaimsRequest) (*types.QueryAllClaimsResponse, error) {
+	logger := k.Logger().With("method", "AllClaims")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -65,7 +68,9 @@ func (k Keeper) AllClaims(ctx context.Context, req *types.QueryAllClaimsRequest)
 			// The value is the encoded claim.
 			var claim types.Claim
 			if err := k.cdc.Unmarshal(value, &claim); err != nil {
-				return err
+				err = fmt.Errorf("unable to unmarshal claim with key (hex): %x: %+v", key, err)
+				logger.Error(err.Error())
+				return status.Error(codes.Internal, err.Error())
 			}
 			claims = append(claims, claim)
 		}
diff --git a/x/proof/keeper/query_proof.go b/x/proof/keeper/query_proof.go
index 12eae432c..f2a84ba42 100644
--- a/x/proof/keeper/query_proof.go
+++ b/x/proof/keeper/query_proof.go
@@ -14,6 +14,8 @@ import (
 )
 
 func (k Keeper) AllProofs(ctx context.Context, req *types.QueryAllProofsRequest) (*types.QueryAllProofsResponse, error) {
+	logger := k.Logger().With("method", "AllProofs")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -63,7 +65,9 @@ func (k Keeper) AllProofs(ctx context.Context, req *types.QueryAllProofsRequest)
 			// The value is the encoded proof.
 			var proof types.Proof
 			if err := k.cdc.Unmarshal(value, &proof); err != nil {
-				return err
+				err = fmt.Errorf("unable to unmarshal proof with key (hex): %x: %+v", key, err)
+				logger.Error(err.Error())
+				return status.Error(codes.Internal, err.Error())
 			}
 
 			proofs = append(proofs, proof)
diff --git a/x/proof/keeper/session.go b/x/proof/keeper/session.go
index 9d33d76c6..68a72cf10 100644
--- a/x/proof/keeper/session.go
+++ b/x/proof/keeper/session.go
@@ -2,8 +2,10 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	cosmostypes "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/proof/types"
 	sessiontypes "github.com/pokt-network/poktroll/x/session/types"
@@ -30,6 +32,8 @@ func (k Keeper) queryAndValidateSessionHeader(
 	// session header is to be validated.
 	sessionRes, err := k.sessionKeeper.GetSession(ctx, sessionReq)
 	if err != nil {
+		// NB: Strip internal error status from error. An appropriate status will be associated by the caller.
+		err = fmt.Errorf("%s", status.Convert(err).Message())
 		return nil, err
 	}
 	onChainSession := sessionRes.GetSession()
diff --git a/x/service/keeper/msg_server_add_service.go b/x/service/keeper/msg_server_add_service.go
index 52fe8365e..2d3dd69c0 100644
--- a/x/service/keeper/msg_server_add_service.go
+++ b/x/service/keeper/msg_server_add_service.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"
 	"github.com/pokt-network/poktroll/x/service/types"
@@ -33,39 +35,48 @@ func (k msgServer) AddService(
 	// Validate the message.
 	if err := msg.ValidateBasic(); err != nil {
 		logger.Error(fmt.Sprintf("Adding service failed basic validation: %v", err))
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Check if the service already exists or not.
 	foundService, found := k.GetService(ctx, msg.Service.Id)
 	if found {
 		if foundService.OwnerAddress != msg.Service.OwnerAddress {
-			logger.Error(fmt.Sprintf("Owner address of existing service (%q) does not match the owner address %q", foundService.OwnerAddress, msg.OwnerAddress))
-			return nil, types.ErrServiceInvalidOwnerAddress.Wrapf(
-				"existing owner address %q does not match the new owner address %q",
-				foundService.OwnerAddress, msg.Service.OwnerAddress,
+			return nil, status.Error(
+				codes.InvalidArgument,
+				types.ErrServiceInvalidOwnerAddress.Wrapf(
+					"existing owner address %q does not match the new owner address %q",
+					foundService.OwnerAddress, msg.Service.OwnerAddress,
+				).Error(),
 			)
 		}
-		return nil, types.ErrServiceAlreadyExists.Wrapf(
-			"TODO_MAINNET(@red-0ne): This is an ephemeral state of the code. Once we s/AddService/UpdateService/g, add the business logic here for updates here.",
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			types.ErrServiceAlreadyExists.Wrapf(
+				"TODO_MAINNET(@red-0ne): This is an ephemeral state of the code. Once we s/AddService/UpdateService/g, add the business logic here for updates here.",
+			).Error(),
 		)
 	}
 
 	// Retrieve the address of the actor adding the service; the owner of the service.
 	serviceOwnerAddr, err := sdk.AccAddressFromBech32(msg.OwnerAddress)
 	if err != nil {
-		logger.Error(fmt.Sprintf("could not parse address %s", msg.OwnerAddress))
-		return nil, types.ErrServiceInvalidAddress.Wrapf(
-			"%s is not in Bech32 format", msg.OwnerAddress,
+		return nil, status.Error(
+			codes.InvalidArgument,
+			types.ErrServiceInvalidAddress.Wrapf(
+				"%s is not in Bech32 format", msg.OwnerAddress,
+			).Error(),
 		)
 	}
 
 	// Check the actor has sufficient funds to pay for the add service fee.
 	accCoins := k.bankKeeper.SpendableCoins(ctx, serviceOwnerAddr)
 	if accCoins.Len() == 0 {
-		logger.Error(fmt.Sprintf("%s doesn't have any funds to add service: %v", serviceOwnerAddr, err))
-		return nil, types.ErrServiceNotEnoughFunds.Wrapf(
-			"account has no spendable coins",
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			types.ErrServiceNotEnoughFunds.Wrapf(
+				"account has no spendable coins",
+			).Error(),
 		)
 	}
 
@@ -73,10 +84,12 @@ func (k msgServer) AddService(
 	accBalance := accCoins.AmountOf("upokt")
 	addServiceFee := k.GetParams(ctx).AddServiceFee
 	if accBalance.LTE(addServiceFee.Amount) {
-		logger.Error(fmt.Sprintf("%s doesn't have enough funds to add service: %v", serviceOwnerAddr, err))
-		return nil, types.ErrServiceNotEnoughFunds.Wrapf(
-			"account has %s, but the service fee is %s",
-			accBalance, k.GetParams(ctx).AddServiceFee,
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			types.ErrServiceNotEnoughFunds.Wrapf(
+				"account has %s, but the service fee is %s",
+				accBalance, k.GetParams(ctx).AddServiceFee,
+			).Error(),
 		)
 	}
 
@@ -84,10 +97,13 @@ func (k msgServer) AddService(
 	serviceFee := sdk.NewCoins(*addServiceFee)
 	err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, serviceOwnerAddr, types.ModuleName, serviceFee)
 	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to deduct service fee from actor's balance: %v", err))
-		return nil, types.ErrServiceFailedToDeductFee.Wrapf(
-			"account has %s, failed to deduct %s",
-			accBalance, k.GetParams(ctx).AddServiceFee,
+		logger.Error(fmt.Sprintf("Failed to deduct service fee from actor's balance: %+v", err))
+		return nil, status.Error(
+			codes.Internal,
+			types.ErrServiceFailedToDeductFee.Wrapf(
+				"account has %s, failed to deduct %s",
+				accBalance, k.GetParams(ctx).AddServiceFee,
+			).Error(),
 		)
 	}
 
diff --git a/x/service/keeper/msg_update_params.go b/x/service/keeper/msg_update_params.go
index 964d1db26..d8317c864 100644
--- a/x/service/keeper/msg_update_params.go
+++ b/x/service/keeper/msg_update_params.go
@@ -2,20 +2,33 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/service/types"
 )
 
 func (k msgServer) UpdateParams(ctx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrServiceInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrServiceInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/service/keeper/query_relay_mining_difficulty.go b/x/service/keeper/query_relay_mining_difficulty.go
index 17cef487a..82403fd0a 100644
--- a/x/service/keeper/query_relay_mining_difficulty.go
+++ b/x/service/keeper/query_relay_mining_difficulty.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	"cosmossdk.io/store/prefix"
 	"github.com/cosmos/cosmos-sdk/runtime"
@@ -13,6 +14,8 @@ import (
 )
 
 func (k Keeper) RelayMiningDifficultyAll(ctx context.Context, req *types.QueryAllRelayMiningDifficultyRequest) (*types.QueryAllRelayMiningDifficultyResponse, error) {
+	logger := k.Logger().With("method", "RelayMiningDifficultyAll")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -25,7 +28,9 @@ func (k Keeper) RelayMiningDifficultyAll(ctx context.Context, req *types.QueryAl
 	pageRes, err := query.Paginate(relayMiningDifficultyStore, req.Pagination, func(key []byte, value []byte) error {
 		var relayMiningDifficulty types.RelayMiningDifficulty
 		if err := k.cdc.Unmarshal(value, &relayMiningDifficulty); err != nil {
-			return err
+			err = fmt.Errorf("unable to unmarshal relayMiningDifficulty with key (hex): %x: %w", key, err)
+			logger.Error(err.Error())
+			return status.Error(codes.Internal, err.Error())
 		}
 
 		relayMiningDifficulties = append(relayMiningDifficulties, relayMiningDifficulty)
diff --git a/x/service/keeper/query_service.go b/x/service/keeper/query_service.go
index 0792fa688..73f420edc 100644
--- a/x/service/keeper/query_service.go
+++ b/x/service/keeper/query_service.go
@@ -2,6 +2,7 @@ package keeper
 
 import (
 	"context"
+	"fmt"
 
 	"cosmossdk.io/store/prefix"
 	"github.com/cosmos/cosmos-sdk/runtime"
@@ -15,6 +16,8 @@ import (
 
 // AllServices queries all services.
 func (k Keeper) AllServices(ctx context.Context, req *types.QueryAllServicesRequest) (*types.QueryAllServicesResponse, error) {
+	logger := k.Logger().With("method", "AllServices")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -27,7 +30,9 @@ func (k Keeper) AllServices(ctx context.Context, req *types.QueryAllServicesRequ
 	pageRes, err := query.Paginate(serviceStore, req.Pagination, func(key []byte, value []byte) error {
 		var service sharedtypes.Service
 		if err := k.cdc.Unmarshal(value, &service); err != nil {
-			return err
+			err = fmt.Errorf("unable to unmarshal service with key (hex): %x: %w", key, err)
+			logger.Error(err.Error())
+			return status.Error(codes.Internal, err.Error())
 		}
 
 		services = append(services, service)
diff --git a/x/session/keeper/msg_update_params.go b/x/session/keeper/msg_update_params.go
index 84a5debfa..57564b921 100644
--- a/x/session/keeper/msg_update_params.go
+++ b/x/session/keeper/msg_update_params.go
@@ -2,21 +2,34 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/session/types"
 )
 
 func (k msgServer) UpdateParams(ctx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrSessionInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrSessionInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/session/keeper/query_get_session.go b/x/session/keeper/query_get_session.go
index bc25fff0e..412d77c45 100644
--- a/x/session/keeper/query_get_session.go
+++ b/x/session/keeper/query_get_session.go
@@ -14,6 +14,8 @@ import (
 // GetSession should be deterministic and always return the same session for
 // the same block height.
 func (k Keeper) GetSession(ctx context.Context, req *types.QueryGetSessionRequest) (*types.QueryGetSessionResponse, error) {
+	logger := k.Logger().With("method", "GetSession")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -36,12 +38,13 @@ func (k Keeper) GetSession(ctx context.Context, req *types.QueryGetSessionReques
 		blockHeight = req.BlockHeight
 	}
 
-	k.Logger().Debug(fmt.Sprintf("Getting session for height: %d", blockHeight))
+	logger.Debug(fmt.Sprintf("Getting session for height: %d", blockHeight))
 
 	sessionHydrator := NewSessionHydrator(req.ApplicationAddress, req.ServiceId, blockHeight)
 	session, err := k.HydrateSession(ctx, sessionHydrator)
 	if err != nil {
-		return nil, err
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	res := &types.QueryGetSessionResponse{
diff --git a/x/shared/keeper/msg_update_params.go b/x/shared/keeper/msg_update_params.go
index 9df191361..c313387f6 100644
--- a/x/shared/keeper/msg_update_params.go
+++ b/x/shared/keeper/msg_update_params.go
@@ -3,23 +3,34 @@ package keeper
 import (
 	"context"
 
-	sdkerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/shared/types"
 )
 
 func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	if k.GetAuthority() != req.Authority {
-		return nil, sdkerrors.Wrapf(types.ErrSharedInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrSharedInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s",
+				k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = types.ErrSharedParamInvalid.Wrapf("unable to set params: %v", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/supplier/keeper/msg_server_unstake_supplier.go b/x/supplier/keeper/msg_server_unstake_supplier.go
index 17cfda752..2ac70a39b 100644
--- a/x/supplier/keeper/msg_server_unstake_supplier.go
+++ b/x/supplier/keeper/msg_server_unstake_supplier.go
@@ -28,32 +28,45 @@ func (k msgServer) UnstakeSupplier(
 	logger.Info(fmt.Sprintf("About to unstake supplier with msg: %v", msg))
 
 	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	// Check if the supplier already exists or not
-	supplier, isSupplierFound := k.GetSupplier(ctx, msg.OperatorAddress)
+	supplier, isSupplierFound := k.GetSupplier(ctx, msg.GetOperatorAddress())
 	if !isSupplierFound {
-		logger.Info(fmt.Sprintf("Supplier not found. Cannot unstake address %s", msg.OperatorAddress))
-		return nil, suppliertypes.ErrSupplierNotFound
+		logger.Info(fmt.Sprintf("Supplier not found. Cannot unstake address %s", msg.GetOperatorAddress()))
+		return nil, status.Error(
+			codes.NotFound,
+			suppliertypes.ErrSupplierNotFound.Wrapf(
+				"supplier with operator address %q", msg.GetOperatorAddress(),
+			).Error(),
+		)
 	}
 
 	// Ensure the singer address matches the owner address or the operator address.
-	if !supplier.HasOperator(msg.Signer) && !supplier.HasOwner(msg.Signer) {
-		logger.Error("only the supplier owner or operator is allowed to unstake the supplier")
-		return nil, sharedtypes.ErrSharedUnauthorizedSupplierUpdate.Wrapf(
-			"signer %q is not allowed to unstake supplier %v",
-			msg.Signer,
-			supplier,
+	if !supplier.HasOperator(msg.GetSigner()) && !supplier.HasOwner(msg.GetSigner()) {
+		logger.Info("only the supplier owner or operator is allowed to unstake the supplier")
+		return nil, status.Error(
+			codes.PermissionDenied,
+			sharedtypes.ErrSharedUnauthorizedSupplierUpdate.Wrapf(
+				"signer %q is not allowed to unstake supplier %+v",
+				msg.Signer,
+				supplier,
+			).Error(),
 		)
 	}
 
-	logger.Info(fmt.Sprintf("Supplier found. Unstaking supplier for address %s", msg.OperatorAddress))
+	logger.Info(fmt.Sprintf("Supplier found. Unstaking supplier with operating address %s", msg.GetOperatorAddress()))
 
 	// Check if the supplier has already initiated the unstake action.
 	if supplier.IsUnbonding() {
-		logger.Warn(fmt.Sprintf("Supplier %s still unbonding from previous unstaking", msg.OperatorAddress))
-		return nil, suppliertypes.ErrSupplierIsUnstaking
+		logger.Info(fmt.Sprintf("Supplier %s still unbonding from previous unstaking", msg.GetOperatorAddress()))
+		return nil, status.Error(
+			codes.FailedPrecondition,
+			suppliertypes.ErrSupplierIsUnstaking.Wrapf(
+				"supplier with operator address %q", msg.GetOperatorAddress(),
+			).Error(),
+		)
 	}
 
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
diff --git a/x/supplier/keeper/msg_server_unstake_supplier_test.go b/x/supplier/keeper/msg_server_unstake_supplier_test.go
index 015b4cde4..4338b4e52 100644
--- a/x/supplier/keeper/msg_server_unstake_supplier_test.go
+++ b/x/supplier/keeper/msg_server_unstake_supplier_test.go
@@ -280,7 +280,7 @@ func TestMsgServer_UnstakeSupplier_FailIfNotStaked(t *testing.T) {
 	}
 	_, err := srv.UnstakeSupplier(ctx, unstakeMsg)
 	require.Error(t, err)
-	require.ErrorIs(t, err, suppliertypes.ErrSupplierNotFound)
+	require.ErrorContains(t, err, suppliertypes.ErrSupplierNotFound.Error())
 
 	_, isSupplierFound = supplierModuleKeepers.GetSupplier(ctx, supplierOperatorAddr)
 	require.False(t, isSupplierFound)
@@ -311,7 +311,7 @@ func TestMsgServer_UnstakeSupplier_FailIfCurrentlyUnstaking(t *testing.T) {
 	ctx = keepertest.SetBlockHeight(ctx, sdkCtx.BlockHeight()+1)
 
 	_, err = srv.UnstakeSupplier(ctx, unstakeMsg)
-	require.ErrorIs(t, err, suppliertypes.ErrSupplierIsUnstaking)
+	require.ErrorContains(t, err, suppliertypes.ErrSupplierIsUnstaking.Error())
 }
 
 func TestMsgServer_UnstakeSupplier_OperatorCanUnstake(t *testing.T) {
diff --git a/x/supplier/keeper/msg_update_params.go b/x/supplier/keeper/msg_update_params.go
index ed841b914..4fa159dff 100644
--- a/x/supplier/keeper/msg_update_params.go
+++ b/x/supplier/keeper/msg_update_params.go
@@ -2,6 +2,10 @@ package keeper
 
 import (
 	"context"
+	"fmt"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 
 	"github.com/pokt-network/poktroll/x/supplier/types"
 )
@@ -10,15 +14,24 @@ func (k msgServer) UpdateParams(
 	ctx context.Context,
 	req *types.MsgUpdateParams,
 ) (*types.MsgUpdateParamsResponse, error) {
+	logger := k.Logger().With("method", "UpdateParams")
+
 	if err := req.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	if k.GetAuthority() != req.Authority {
-		return nil, types.ErrSupplierInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrSupplierInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority,
+			).Error(),
+		)
 	}
 
 	if err := k.SetParams(ctx, req.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	return &types.MsgUpdateParamsResponse{}, nil
diff --git a/x/supplier/keeper/query_supplier.go b/x/supplier/keeper/query_supplier.go
index 92112827a..3d370a8fa 100644
--- a/x/supplier/keeper/query_supplier.go
+++ b/x/supplier/keeper/query_supplier.go
@@ -18,6 +18,8 @@ func (k Keeper) AllSuppliers(
 	ctx context.Context,
 	req *types.QueryAllSuppliersRequest,
 ) (*types.QueryAllSuppliersResponse, error) {
+	logger := k.Logger().With("method", "AllSuppliers")
+
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "invalid request")
 	}
@@ -33,7 +35,9 @@ func (k Keeper) AllSuppliers(
 		func(key []byte, value []byte) error {
 			var supplier sharedtypes.Supplier
 			if err := k.cdc.Unmarshal(value, &supplier); err != nil {
-				return err
+				err = fmt.Errorf("unmarshaling supplier with key (hex): %x: %+v", key, err)
+				logger.Error(err.Error())
+				return status.Error(codes.Internal, err.Error())
 			}
 
 			suppliers = append(suppliers, supplier)
diff --git a/x/tokenomics/keeper/msg_server_update_param.go b/x/tokenomics/keeper/msg_server_update_param.go
index 92af35e30..643ee17a8 100644
--- a/x/tokenomics/keeper/msg_server_update_param.go
+++ b/x/tokenomics/keeper/msg_server_update_param.go
@@ -22,11 +22,17 @@ func (k msgServer) UpdateParam(
 	)
 
 	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	if k.GetAuthority() != msg.Authority {
-		return nil, tokenomicstypes.ErrTokenomicsInvalidSigner.Wrapf("invalid authority; expected %s, got %s", k.GetAuthority(), msg.Authority)
+		return nil, status.Error(
+			codes.PermissionDenied,
+			tokenomicstypes.ErrTokenomicsInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s",
+				k.GetAuthority(), msg.Authority,
+			).Error(),
+		)
 	}
 
 	params := k.GetParams(ctx)
diff --git a/x/tokenomics/keeper/msg_update_params.go b/x/tokenomics/keeper/msg_update_params.go
index cefb8e7d6..16e1bfe95 100644
--- a/x/tokenomics/keeper/msg_update_params.go
+++ b/x/tokenomics/keeper/msg_update_params.go
@@ -4,6 +4,9 @@ import (
 	"context"
 	"fmt"
 
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
 	"github.com/pokt-network/poktroll/x/tokenomics/types"
 )
 
@@ -11,21 +14,26 @@ func (k msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams)
 	logger := k.Logger()
 
 	if err := msg.ValidateBasic(); err != nil {
-		return nil, err
+		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	if msg.Authority != k.GetAuthority() {
-		return nil, types.ErrTokenomicsInvalidSigner.Wrapf(
-			"invalid authority; expected %s, got %s",
-			k.GetAuthority(),
-			msg.Authority,
+		return nil, status.Error(
+			codes.PermissionDenied,
+			types.ErrTokenomicsInvalidSigner.Wrapf(
+				"invalid authority; expected %s, got %s",
+				k.GetAuthority(),
+				msg.Authority,
+			).Error(),
 		)
 	}
 
 	logger.Info(fmt.Sprintf("About to update params from [%v] to [%v]", k.GetParams(ctx), msg.Params))
 
 	if err := k.SetParams(ctx, msg.Params); err != nil {
-		return nil, err
+		err = fmt.Errorf("unable to set params: %w", err)
+		logger.Error(err.Error())
+		return nil, status.Error(codes.Internal, err.Error())
 	}
 
 	logger.Info("Done updating params")