[Utility] Feat: Chain-specific compute unit to tokens multipliers

proto/poktroll/shared/service.proto

@@ -13,6 +13,9 @@ message Service {
 
   // TODO_BETA: Name is currently unused but acts as a reminder that an optional onchain representation of the service is necessary
   string name = 2; // (Optional) Semantic human readable name for the service
+
+  // Used alongside the global 'compute_units_to_tokens_multipler' to calculate the cost of a relay for this service
+  uint64 compute_units_per_relay = 3; // Compute units required per relay for this service
 }
 
 // ApplicationServiceConfig holds the service configuration the application stakes for

testutil/proof/fixture_generators.go

@@ -18,10 +18,11 @@ func BaseClaim(appAddr, supplierAddr string, sum uint64) prooftypes.Claim {
 		SupplierAddress: supplierAddr,
 		SessionHeader: &sessiontypes.SessionHeader{
 			ApplicationAddress: appAddr,
-			Service: &sharedtypes.Service{
-				Id:   "svc1",
-				Name: "svcName1",
-			},
+			Service: sharedtypes.NewService(
+				"svc1",
+				"svcName1",
+				1,
+			),
 			SessionId:               "session_id",
 			SessionStartBlockHeight: 1,
 			SessionEndBlockHeight:   testsession.GetSessionEndHeightWithDefaultParams(1),

x/service/keeper/msg_server_add_service_test.go

@@ -21,13 +21,15 @@ func TestMsgServer_AddService(t *testing.T) {
 
 	// Declare test services
 	svc1 := sharedtypes.Service{
-		Id:   "svc1",
-		Name: "service 1",
+		Id:                   "svc1",
+		Name:                 "service 1",
+		ComputeUnitsPerRelay: 1,
 	}
 
 	preExistingService := sharedtypes.Service{
-		Id:   "svc2",
-		Name: "service 2",
+		Id:                   "svc2",
+		Name:                 "service 2",
+		ComputeUnitsPerRelay: 1,
 	}
 
 	// Generate a valid address
@@ -125,6 +127,17 @@ func TestMsgServer_AddService(t *testing.T) {
 			},
 			expectedErr: types.ErrServiceMissingName,
 		},
+		{
+			desc:    "invalid - zero compute units per relay",
+			setup:   func(t *testing.T) {},
+			address: sample.AccAddress(),
+			service: sharedtypes.Service{
+				Id:                   "svc1",
+				Name:                 "service 1",
+				ComputeUnitsPerRelay: 0,
+			},
+			expectedErr: types.ErrServiceInvalidComputUnitsPerRelay,
+		},
 		{
 			desc:        "invalid - service already exists (same service supplier)",
 			setup:       func(t *testing.T) {},

x/service/module/tx_add_service.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"fmt"
 	"strconv"
 
 	"github.com/cosmos/cosmos-sdk/client"
@@ -15,14 +16,14 @@ var _ = strconv.Itoa(0)
 
 func CmdAddService() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "add-service <service_id> <service_name>",
+		Use:   fmt.Sprintf("add-service <service_id> <service_name> [compute_units_per_relay: default={%d}]", types.DefaultComputeUnitsPerRelay),
 		Short: "Add a new service to the network",
 		Long: `Add a new service to the network that will be available for applications,
 gateways and suppliers to use. The service id MUST be unique but the service name doesn't have to be.
 
 Example:
 $ poktrolld tx service add-service "svc1" "service_one" --keyring-backend test --from $(SUPPLIER) --node $(POCKET_NODE) --home $(POKTROLLD_HOME)`,
-		Args: cobra.ExactArgs(2),
+		Args: cobra.MinimumNArgs(2),
 		RunE: func(cmd *cobra.Command, args []string) (err error) {
 			serviceIdStr := args[0]
 			serviceNameStr := args[1]
@@ -32,10 +33,22 @@ $ poktrolld tx service add-service "svc1" "service_one" --keyring-backend test -
 				return err
 			}
 
+			computeUnitsPerRelay := types.DefaultComputeUnitsPerRelay
+			// if compute units per relay argument is provided
+			if len(args) > 2 {
+				computeUnitsPerRelay, err = strconv.ParseUint(args[2], 10, 64)
+				if err != nil {
+					return types.ErrServiceInvalidComputUnitsPerRelay.Wrapf("unable to parse as uint64: %s", args[2])
+				}
+			} else {
+				fmt.Printf("Using default compute_units_per_relay: %d\n", types.DefaultComputeUnitsPerRelay)
+			}
+
 			msg := types.NewMsgAddService(
 				clientCtx.GetFromAddress().String(),
 				serviceIdStr,
 				serviceNameStr,
+				computeUnitsPerRelay,
 			)
 			if err := msg.ValidateBasic(); err != nil {
 				return err

x/service/module/tx_add_service_test.go

@@ -2,6 +2,7 @@ package service_test
 
 import (
 	"fmt"
+	"strconv"
 	"testing"
 
 	sdkerrors "cosmossdk.io/errors"
@@ -52,12 +53,14 @@ func TestCLI_AddService(t *testing.T) {
 
 	// Prepare two valid services
 	svc1 := sharedtypes.Service{
-		Id:   "svc1",
-		Name: "service name",
+		Id:                   "svc1",
+		Name:                 "service name",
+		ComputeUnitsPerRelay: 1,
 	}
 	svc2 := sharedtypes.Service{
-		Id:   "svc2",
-		Name: "service name 2",
+		Id:                   "svc2",
+		Name:                 "service name 2",
+		ComputeUnitsPerRelay: 1,
 	}
 	// Add svc2 to the network
 	args := []string{
@@ -81,6 +84,15 @@ func TestCLI_AddService(t *testing.T) {
 			supplierAddress: account.Address.String(),
 			service:         svc1,
 		},
+		{
+			desc:            "valid - add new service without compute units per relay",
+			supplierAddress: account.Address.String(),
+			service: sharedtypes.Service{
+				Id:                   svc1.Id,
+				Name:                 svc1.Name,
+				ComputeUnitsPerRelay: 0,
+			},
+		},
 		{
 			desc:            "invalid - missing service id",
 			supplierAddress: account.Address.String(),
@@ -114,12 +126,17 @@ func TestCLI_AddService(t *testing.T) {
 			require.NoError(t, net.WaitForNextBlock())
 
 			// Prepare the arguments for the CLI command
-			args := []string{
+			argsAndFlags := []string{
 				test.service.Id,
 				test.service.Name,
-				fmt.Sprintf("--%s=%s", flags.FlagFrom, test.supplierAddress),
 			}
-			args = append(args, commonArgs...)
+			if test.service.ComputeUnitsPerRelay > 0 {
+				// Only include compute units per relay argument if provided
+				argsAndFlags = append(argsAndFlags, strconv.FormatUint(test.service.ComputeUnitsPerRelay, 10))
+			}
+			argsAndFlags = append(argsAndFlags, fmt.Sprintf("--%s=%s", flags.FlagFrom, test.supplierAddress))
+
+			args := append(argsAndFlags, commonArgs...)
 
 			// Execute the command
 			addServiceOutput, err := clitestutil.ExecTestCLICmd(ctx, service.CmdAddService(), args)

x/service/types/errors.go

@@ -6,16 +6,17 @@ import sdkerrors "cosmossdk.io/errors"
 
 // x/service module sentinel errors
 var (
-	ErrServiceInvalidSigner        = sdkerrors.Register(ModuleName, 1100, "expected gov account as only signer for proposal message")
-	ErrServiceDuplicateIndex       = sdkerrors.Register(ModuleName, 1101, "duplicate index when adding a new service")
-	ErrServiceInvalidAddress       = sdkerrors.Register(ModuleName, 1102, "invalid address when adding a new service")
-	ErrServiceMissingID            = sdkerrors.Register(ModuleName, 1103, "missing service ID")
-	ErrServiceMissingName          = sdkerrors.Register(ModuleName, 1104, "missing service name")
-	ErrServiceAlreadyExists        = sdkerrors.Register(ModuleName, 1105, "service already exists")
-	ErrServiceInvalidServiceFee    = sdkerrors.Register(ModuleName, 1106, "invalid ServiceFee")
-	ErrServiceAccountNotFound      = sdkerrors.Register(ModuleName, 1107, "account not found")
-	ErrServiceNotEnoughFunds       = sdkerrors.Register(ModuleName, 1108, "not enough funds to add service")
-	ErrServiceFailedToDeductFee    = sdkerrors.Register(ModuleName, 1109, "failed to deduct fee")
-	ErrServiceInvalidRelayResponse = sdkerrors.Register(ModuleName, 1110, "invalid relay response")
-	ErrServiceInvalidRelayRequest  = sdkerrors.Register(ModuleName, 1111, "invalid relay request")
+	ErrServiceInvalidSigner              = sdkerrors.Register(ModuleName, 1100, "expected gov account as only signer for proposal message")
+	ErrServiceDuplicateIndex             = sdkerrors.Register(ModuleName, 1101, "duplicate index when adding a new service")
+	ErrServiceInvalidAddress             = sdkerrors.Register(ModuleName, 1102, "invalid address when adding a new service")
+	ErrServiceMissingID                  = sdkerrors.Register(ModuleName, 1103, "missing service ID")
+	ErrServiceMissingName                = sdkerrors.Register(ModuleName, 1104, "missing service name")
+	ErrServiceAlreadyExists              = sdkerrors.Register(ModuleName, 1105, "service already exists")
+	ErrServiceInvalidServiceFee          = sdkerrors.Register(ModuleName, 1106, "invalid ServiceFee")
+	ErrServiceAccountNotFound            = sdkerrors.Register(ModuleName, 1107, "account not found")
+	ErrServiceNotEnoughFunds             = sdkerrors.Register(ModuleName, 1108, "not enough funds to add service")
+	ErrServiceFailedToDeductFee          = sdkerrors.Register(ModuleName, 1109, "failed to deduct fee")
+	ErrServiceInvalidRelayResponse       = sdkerrors.Register(ModuleName, 1110, "invalid relay response")
+	ErrServiceInvalidRelayRequest        = sdkerrors.Register(ModuleName, 1111, "invalid relay request")
+	ErrServiceInvalidComputUnitsPerRelay = sdkerrors.Register(ModuleName, 1112, "invalid compute units per relay")
 )

x/service/types/message_add_service.go

@@ -2,19 +2,25 @@ package types
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
-
 	"github.com/pokt-network/poktroll/x/shared/types"
 )
 
+const (
+	DefaultComputeUnitsPerRelay uint64 = 1
+	// ComputeUnitsPerRelayMax is the maximum allowed compute_units_per_relay value when adding or updating a service
+	ComputeUnitsPerRelayMax uint64 = 2 ^ 16
+)
+
 var _ sdk.Msg = (*MsgAddService)(nil)
 
-func NewMsgAddService(address, serviceId, serviceName string) *MsgAddService {
+func NewMsgAddService(address, serviceId, serviceName string, computeUnitsPerRelay uint64) *MsgAddService {
 	return &MsgAddService{
 		Address: address,
-		Service: types.Service{
-			Id:   serviceId,
-			Name: serviceName,
-		},
+		Service: *types.NewService(
+			serviceId,
+			serviceName,
+			computeUnitsPerRelay,
+		),
 	}
 }
 
@@ -30,5 +36,18 @@ func (msg *MsgAddService) ValidateBasic() error {
 	if msg.Service.Name == "" {
 		return ErrServiceMissingName
 	}
+	if err := ValidateComputeUnitsPerRelay(msg.Service.ComputeUnitsPerRelay); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ValidateComputeUnitsPerRelay makes sure the compute units per relay is a valid value
+func ValidateComputeUnitsPerRelay(computeUnitsPerRelay uint64) error {
+	if computeUnitsPerRelay == 0 {
+		return ErrServiceInvalidComputUnitsPerRelay.Wrap("compute units per relay must be greater than 0")
+	} else if computeUnitsPerRelay > ComputeUnitsPerRelayMax {
+		return ErrServiceInvalidComputUnitsPerRelay.Wrapf("compute units per relay must be less than %d", ComputeUnitsPerRelayMax)
+	}
 	return nil
 }

x/service/types/message_add_service_test.go

@@ -36,11 +36,18 @@ func TestMsgAddService_ValidateBasic(t *testing.T) {
 				Service: sharedtypes.Service{Id: "svc1"}, // Name intentionally omitted
 			},
 			expectedErr: ErrServiceMissingName,
+		}, {
+			desc: "valid service supplier address - zero compute units per relay",
+			msg: MsgAddService{
+				Address: sample.AccAddress(),
+				Service: sharedtypes.Service{Id: "svc1", Name: "service name", ComputeUnitsPerRelay: 0},
+			},
+			expectedErr: ErrServiceInvalidComputUnitsPerRelay,
 		}, {
 			desc: "valid service supplier address and service",
 			msg: MsgAddService{
 				Address: sample.AccAddress(),
-				Service: sharedtypes.Service{Id: "svc1", Name: "service name"},
+				Service: sharedtypes.Service{Id: "svc1", Name: "service name", ComputeUnitsPerRelay: 1},
 			},
 			expectedErr: nil,
 		},
@@ -56,3 +63,39 @@ func TestMsgAddService_ValidateBasic(t *testing.T) {
 		})
 	}
 }
+
+func TestValidateComputeUnitsPerRelay(t *testing.T) {
+	tests := []struct {
+		desc                 string
+		computeUnitsPerRelay uint64
+		expectedErr          error
+	}{
+		{
+			desc:                 "zero compute units per relay",
+			computeUnitsPerRelay: 0,
+			expectedErr:          ErrServiceInvalidComputUnitsPerRelay,
+		}, {
+			desc:                 "valid compute units per relay",
+			computeUnitsPerRelay: 1,
+			expectedErr:          nil,
+		}, {
+			desc:                 "max compute units per relay",
+			computeUnitsPerRelay: ComputeUnitsPerRelayMax,
+			expectedErr:          nil,
+		}, {
+			desc:                 "compute units per relay greater than max",
+			computeUnitsPerRelay: ComputeUnitsPerRelayMax + 1,
+			expectedErr:          ErrServiceInvalidComputUnitsPerRelay,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			err := ValidateComputeUnitsPerRelay(test.computeUnitsPerRelay)
+			if test.expectedErr != nil {
+				require.ErrorIs(t, err, test.expectedErr)
+				return
+			}
+			require.NoError(t, err)
+		})
+	}
+}

x/shared/types/service.go

@@ -0,0 +1,10 @@
+package types
+
+// NewService creates a new Service instance
+func NewService(id string, name string, computeUnitsPerRelay uint64) *Service {
+	return &Service{
+		Id:                   id,
+		Name:                 name,
+		ComputeUnitsPerRelay: computeUnitsPerRelay,
+	}
+}