[Supplier] Initial slashing implementation

app/app_config.go

@@ -191,12 +191,17 @@ var (
 		ibcfeetypes.ModuleName,
 		// chain modules
 		servicemoduletypes.ModuleName,
-		gatewaymoduletypes.ModuleName,
-		applicationmoduletypes.ModuleName,
-		suppliermoduletypes.ModuleName,
 		sessionmoduletypes.ModuleName,
 		proofmoduletypes.ModuleName,
 		tokenomicsmoduletypes.ModuleName,
+		// CRITICAL: THE ORDER HERE IS IMPORTANT AND MUST BE CAREFULLY MAINTAINED.
+		// Gateway, Application and Supplier end blockers should be called after the
+		// tokenomics module end blocker to ensure that the tokenomics module has
+		// processed all the pending claims, minting, burning or slashing before
+		// any of the actors has a chance to withdraw their tokens.
+		gatewaymoduletypes.ModuleName,
+		applicationmoduletypes.ModuleName,
+		suppliermoduletypes.ModuleName,
 		sharedmoduletypes.ModuleName,
 		// this line is used by starport scaffolding # stargate/app/endBlockers
 	}

config.yml

@@ -251,9 +251,11 @@ genesis:
     proof:
       params:
         proof_request_probability: "0.25"
-        proof_requirement_threshold: 20
+        proof_requirement_threshold:
+          amount: "20000000"
+          denom: upokt
         proof_missing_penalty:
-          amount: "320"
+          amount: "320000000"
           denom: upokt
         proof_submission_fee:
           amount: "1000000"

e2e/tests/0_settlement.feature

@@ -16,15 +16,17 @@ Feature: Tokenomics Namespace
         And the "application" account for "app1" is staked
         And the service "anvil" registered for application "app1" has a compute units per relay of "1"
         # Start servicing relays
-        # Set proof_requirement_threshold to 19 < num_relays (20) * compute_units_per_relay (1)
+        # Set proof_requirement_threshold to 839 < num_relays (20) * compute_units_per_relay (1) * compute_units_to_tokens_multiplier (42)
         # to make sure a proof is required.
         And the "proof" module parameters are set as follows
             | name                         | value                                                            | type  |
             | relay_difficulty_target_hash | ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff | bytes |
             | proof_request_probability    | 0.25                                                             | float |
-            | proof_requirement_threshold  | 19                                                               | int64 |
+            | proof_requirement_threshold  | 839                                                              | coin  |
             | proof_missing_penalty        | 320                                                              | coin  |
             | proof_submission_fee         | 1000000                                                          | coin  |
+        And the "tokenomics" module parameters are set as follows
+            | compute_units_to_tokens_multiplier | 42                                                               | int64 |
         When the supplier "supplier1" has serviced a session with "20" relays for service "anvil" for application "app1"
         # Wait for the Claim & Proof lifecycle
         And the user should wait for the "proof" module "CreateClaim" Message to be submitted
@@ -46,14 +48,18 @@ Feature: Tokenomics Namespace
         And an account exists for "app1"
         And the "application" account for "app1" is staked
         And the service "anvil" registered for application "app1" has a compute units per relay of "1"
-        # Set proof_request_probability to 0 and proof_requirement_threshold to 100 to make sure a proof is not required.
+        # Set proof_request_probability to 0 and proof_requirement_threshold to
+        # 421 > num_relays (10) * compute_units_per_relay (1) * compute_units_to_tokens_multiplier (42)
+        # to make sure a proof is not required.
         And the "proof" module parameters are set as follows
             | name                         | value                                                            | type  |
             | relay_difficulty_target_hash | ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff | bytes |
             | proof_request_probability    | 0                                                                | float |
-            | proof_requirement_threshold  | 100                                                              | int64 |
+            | proof_requirement_threshold  | 421                                                              | coin  |
             | proof_missing_penalty        | 320                                                              | coin  |
             | proof_submission_fee         | 1000000                                                          | coin  |
+        And the "tokenomics" module parameters are set as follows
+            | compute_units_to_tokens_multiplier | 42                                                               | int64 |
         # Start servicing
         When the supplier "supplier1" has serviced a session with "10" relays for service "anvil" for application "app1"
         # Wait for the Claim & Proof lifecycle

e2e/tests/parse_params_test.go

@@ -138,7 +138,7 @@ func (s *suite) newProofMsgUpdateParams(params paramsMap) cosmostypes.Msg {
 		case prooftypes.ParamProofRequestProbability:
 			msgUpdateParams.Params.ProofRequestProbability = paramValue.value.(float32)
 		case prooftypes.ParamProofRequirementThreshold:
-			msgUpdateParams.Params.ProofRequirementThreshold = uint64(paramValue.value.(int64))
+			msgUpdateParams.Params.ProofRequirementThreshold = paramValue.value.(*cosmostypes.Coin)
 		case prooftypes.ParamProofMissingPenalty:
 			msgUpdateParams.Params.ProofMissingPenalty = paramValue.value.(*cosmostypes.Coin)
 		case prooftypes.ParamProofSubmissionFee:

e2e/tests/session.feature

@@ -2,15 +2,17 @@ Feature: Session Namespace
 
   Scenario: Supplier completes claim/proof lifecycle for a valid session
     Given the user has the pocketd binary installed
-    # Set proof_requirement_threshold to 4 < num_relays (5) * compute_units_per_relay (1)
+    # Set proof_requirement_threshold to 209 < num_relays (5) * compute_units_per_relay (1) * compute_units_to_tokens_multiplier (42)
     # to make sure a proof is required.
     And the "proof" module parameters are set as follows
         | name                         | value                                                            | type  |
         | relay_difficulty_target_hash | ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff | bytes |
         | proof_request_probability    | 0.25                                                             | float |
-        | proof_requirement_threshold  | 4                                                                | int64 |
+        | proof_requirement_threshold  | 209                                                              | coin  |
         | proof_missing_penalty        | 320                                                              | coin  |
         | proof_submission_fee         | 1000000                                                          | coin  |
+    And the "tokenomics" module parameters are set as follows
+        | compute_units_to_tokens_multiplier | 42                                                               | int64 |
     When the supplier "supplier1" has serviced a session with "5" relays for service "anvil" for application "app1"
     And the user should wait for the "proof" module "CreateClaim" Message to be submitted
     And the user should wait for the "proof" module "ClaimCreated" tx event to be broadcast

e2e/tests/update_params.feature

@@ -40,7 +40,7 @@ Feature: Params Namespace
       | name                         | value                                                            | type  |
       | relay_difficulty_target_hash | 00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff | bytes |
       | proof_request_probability    | 0.1                                                              | float |
-      | proof_requirement_threshold  | 100                                                              | int64 |
+      | proof_requirement_threshold  | 100                                                              | coin  |
       | proof_missing_penalty        | 500                                                              | coin  |
       | proof_submission_fee         | 5000000                                                          | coin  |
     Then all "proof" module params should be updated
@@ -91,7 +91,7 @@ Feature: Params Namespace
       | tokenomics | /poktroll.tokenomics.MsgUpdateParam | compute_units_to_tokens_multiplier    | 68          | int64      |
       | proof      | /poktroll.proof.MsgUpdateParam      | min_relay_difficulty_bits             | 12          | int64      |
       | proof      | /poktroll.proof.MsgUpdateParam      | proof_request_probability             | 0.1         | float      |
-      | proof      | /poktroll.proof.MsgUpdateParam      | proof_requirement_threshold           | 100         | int64      |
+      | proof      | /poktroll.proof.MsgUpdateParam      | proof_requirement_threshold           | 100         | coin       |
       | proof      | /poktroll.proof.MsgUpdateParam      | proof_missing_penalty                 | 500         | coin       |
       | proof      | /poktroll.proof.MsgUpdateParam      | proof_submission_fee                  | 5000000     | coin       |
       | shared     | /poktroll.shared.MsgUpdateParam     | num_blocks_per_session                | 5           | int64      |

e2e/tests/update_params_test.go

@@ -385,7 +385,7 @@ func (s *suite) assertExpectedModuleParamsUpdated(moduleName string) {
 
 		proofRequirementThreshold, ok := paramsMap[prooftypes.ParamProofRequirementThreshold]
 		if ok {
-			params.ProofRequirementThreshold = uint64(proofRequirementThreshold.value.(int64))
+			params.ProofRequirementThreshold = proofRequirementThreshold.value.(*cosmostypes.Coin)
 		}
 
 		proofMissingPenalty, ok := paramsMap[prooftypes.ParamProofMissingPenalty]

pkg/client/interface.go

@@ -338,8 +338,9 @@ type BlockQueryClient interface {
 // is necessary to prevent dependency cycles.
 type ProofParams interface {
 	GetProofRequestProbability() float32
-	GetProofRequirementThreshold() uint64
+	GetProofRequirementThreshold() *cosmostypes.Coin
 	GetProofMissingPenalty() *cosmostypes.Coin
+	GetProofSubmissionFee() *cosmostypes.Coin
 }
 
 // ProofQueryClient defines an interface that enables the querying of the
@@ -355,8 +356,20 @@ type TokenomicsRelayMiningDifficulty interface {
 	GetTargetHash() []byte
 }
 
+// TokenomicsParams is a go interface type which corresponds to the poktroll.tokenomics.Params
+// protobuf message. Since the generated go types don't include interface types, this
+// is necessary to prevent dependency cycles.
+type TokenomicsParams interface {
+	GetComputeUnitsToTokensMultiplier() uint64
+	NumComputeUnitsToCoin(numClaimComputeUnits uint64) (cosmostypes.Coin, error)
+}
+
+// TokenomicsQueryClient defines an interface that enables the querying of the
+// on-chain tokenomics information
 type TokenomicsQueryClient interface {
 	GetServiceRelayDifficultyTargetHash(ctx context.Context, serviceId string) (TokenomicsRelayMiningDifficulty, error)
+	// GetParams queries the chain for the current tokenomics module parameters.
+	GetParams(ctx context.Context) (TokenomicsParams, error)
 }
 
 // ServiceQueryClient defines an interface that enables the querying of the

pkg/client/query/tokenomicsquerier.go

@@ -53,3 +53,17 @@ func (tq *tokenomicsQuerier) GetServiceRelayDifficultyTargetHash(
 	}
 	return &res.RelayMiningDifficulty, nil
 }
+
+// GetParams queries & returns the tokenomics module on-chain parameters.
+//
+// TODO_TECHDEBT(#543): We don't really want to have to query the params for every method call.
+// Once `ModuleParamsClient` is implemented, use its replay observable's `#Last()` method
+// to get the most recently (asynchronously) observed (and cached) value.
+func (sq *tokenomicsQuerier) GetParams(ctx context.Context) (client.TokenomicsParams, error) {
+	req := &tokenomicstypes.QueryParamsRequest{}
+	res, err := sq.tokenomicsQuerier.Params(ctx, req)
+	if err != nil {
+		return nil, ErrQuerySessionParams.Wrapf("[%v]", err)
+	}
+	return &res.Params, nil
+}

pkg/relayer/session/claim.go

@@ -180,6 +180,11 @@ func (rs *relayerSessionsManager) newMapClaimSessionsFn(
 			return either.Success(sessionTrees), false
 		}
 
+		// TODO_FOLLOWUP(@red-0ne): Ensure that the supplier operator account
+		// has enough funds to cover for any potential proof submission in order to
+		// avoid slashing due to missing proofs.
+		// We should order the claimMsgs by reward amount and include claims up to
+		// whatever the supplier can afford to cover.
 		claimMsgs := make([]client.MsgCreateClaim, len(sessionTrees))
 		for idx, sessionTree := range sessionTrees {
 			claimMsgs[idx] = &prooftypes.MsgCreateClaim{

pkg/relayer/session/proof.go

@@ -287,14 +287,25 @@ func (rs *relayerSessionsManager) isProofRequired(
 		return false, err
 	}
 
+	tokenomicsParams, err := rs.tokenomicsQueryClient.GetParams(ctx)
+	if err != nil {
+		return false, err
+	}
+
+	// The amount of uPOKT being claimed.
+	claimedAmount, err := tokenomicsParams.NumComputeUnitsToCoin(numClaimComputeUnits)
+	if err != nil {
+		return false, err
+	}
+
 	logger = logger.With(
-		"num_claim_compute_units", numClaimComputeUnits,
-		"proof_requirement_threshold", proofParams.GetProofRequirementThreshold(),
+		"claimed_amount_upokt", claimedAmount.Amount.Uint64(),
+		"proof_requirement_threshold_upokt", proofParams.GetProofRequirementThreshold(),
 	)
 
-	// Require a proof if the claim's compute units meets or exceeds the threshold.
+	// Require a proof if the claimed amount meets or exceeds the threshold.
 	// TODO_MAINNET: This should be proportional to the supplier's stake as well.
-	if numClaimComputeUnits >= proofParams.GetProofRequirementThreshold() {
+	if claimedAmount.Amount.GTE(proofParams.GetProofRequirementThreshold().Amount) {
 		logger.Info().Msg("compute units is above threshold, claim requires proof")
 
 		return true, nil

pkg/relayer/session/session.go

@@ -64,6 +64,9 @@ type relayerSessionsManager struct {
 	// requirement probability governance parameters to determine whether a submitted
 	// claim requires a proof.
 	proofQueryClient client.ProofQueryClient
+
+	// tokenomicsQueryClient is used to query for the tokenomics module parameters.
+	tokenomicsQueryClient client.TokenomicsQueryClient
 }
 
 // NewRelayerSessions creates a new relayerSessions.
@@ -94,6 +97,7 @@ func NewRelayerSessions(
 		&rs.sharedQueryClient,
 		&rs.serviceQueryClient,
 		&rs.proofQueryClient,
+		&rs.tokenomicsQueryClient,
 	); err != nil {
 		return nil, err
 	}

pkg/relayer/session/session_test.go

@@ -8,12 +8,15 @@ import (
 	"time"
 
 	"cosmossdk.io/depinject"
+	sdkmath "cosmossdk.io/math"
 	coretypes "github.com/cometbft/cometbft/rpc/core/types"
 	cmttypes "github.com/cometbft/cometbft/types"
+	sdktypes "github.com/cosmos/cosmos-sdk/types"
 	"github.com/golang/mock/gomock"
 	"github.com/pokt-network/smt"
 	"github.com/stretchr/testify/require"
 
+	"github.com/pokt-network/poktroll/app/volatile"
 	"github.com/pokt-network/poktroll/pkg/client"
 	"github.com/pokt-network/poktroll/pkg/observable/channel"
 	"github.com/pokt-network/poktroll/pkg/polylog/polyzero"
@@ -103,6 +106,7 @@ func requireProofCountEqualsExpectedValueFromProofParams(t *testing.T, proofPara
 
 	serviceQueryClientMock := testqueryclients.NewTestServiceQueryClient(t)
 	proofQueryClientMock := testqueryclients.NewTestProofQueryClientWithParams(t, &proofParams)
+	tokenomicsQueryClient := testqueryclients.NewTestTokenomicsQueryClient(t)
 
 	deps := depinject.Supply(
 		blockClient,
@@ -111,6 +115,7 @@ func requireProofCountEqualsExpectedValueFromProofParams(t *testing.T, proofPara
 		sharedQueryClientMock,
 		serviceQueryClientMock,
 		proofQueryClientMock,
+		tokenomicsQueryClient,
 	)
 	storesDirectoryOpt := testrelayer.WithTempStoresDirectory(t)
 
@@ -192,7 +197,7 @@ func TestRelayerSessionsManager_ProofThresholdRequired(t *testing.T) {
 	proofParams := prooftypes.DefaultParams()
 
 	// Set proof requirement threshold to a low enough value so a proof is always requested.
-	proofParams.ProofRequirementThreshold = 1
+	proofParams.ProofRequirementThreshold = &sdktypes.Coin{Denom: volatile.DenomuPOKT, Amount: sdkmath.NewInt(1)}
 
 	// The test is submitting a single claim. Having the proof requirement threshold
 	// set to 1 results in exactly 1 proof being requested.
@@ -204,8 +209,8 @@ func TestRelayerSessionsManager_ProofThresholdRequired(t *testing.T) {
 func TestRelayerSessionsManager_ProofProbabilityRequired(t *testing.T) {
 	proofParams := prooftypes.DefaultParams()
 
-	// Set proof requirement threshold to max uint64 to skip the threshold check.
-	proofParams.ProofRequirementThreshold = math.MaxUint64
+	// Set proof requirement threshold to max int64 to skip the threshold check.
+	proofParams.ProofRequirementThreshold = &sdktypes.Coin{Denom: volatile.DenomuPOKT, Amount: sdkmath.NewInt(math.MaxInt64)}
 	// Set proof request probability to 1 so a proof is always requested.
 	proofParams.ProofRequestProbability = 1
 
@@ -219,8 +224,8 @@ func TestRelayerSessionsManager_ProofProbabilityRequired(t *testing.T) {
 func TestRelayerSessionsManager_ProofNotRequired(t *testing.T) {
 	proofParams := prooftypes.DefaultParams()
 
-	// Set proof requirement threshold to max uint64 to skip the threshold check.
-	proofParams.ProofRequirementThreshold = math.MaxUint64
+	// Set proof requirement threshold to max int64 to skip the threshold check.
+	proofParams.ProofRequirementThreshold = &sdktypes.Coin{Denom: volatile.DenomuPOKT, Amount: sdkmath.NewInt(math.MaxInt64)}
 	// Set proof request probability to 0 so a proof is never requested.
 	proofParams.ProofRequestProbability = 0
 

proto/poktroll/proof/params.proto

@@ -26,18 +26,20 @@ message Params {
   // is equal to or above the threshold. This is in contrast to the this requirement
   // being determined probabilistically via ProofRequestProbability.
   //
-  // TODO_MAINNET: Consider renaming this to `proof_requirement_threshold_compute_units`.
-  uint64 proof_requirement_threshold = 3 [(gogoproto.jsontag) = "proof_requirement_threshold"];
+  // TODO_MAINNET: Consider renaming this to `proof_requirement_threshold_upokt`.
+  cosmos.base.v1beta1.Coin proof_requirement_threshold = 3 [(gogoproto.jsontag) = "proof_requirement_threshold"];
 
   // proof_missing_penalty is the number of tokens (uPOKT) which should be slashed from a supplier
   // when a proof is required (either via proof_requirement_threshold or proof_missing_penalty)
   // but is not provided.
+  // TODO_MAINNET: Consider renaming this to `proof_missing_penalty_upokt`.
   cosmos.base.v1beta1.Coin proof_missing_penalty = 4 [(gogoproto.jsontag) = "proof_missing_penalty"];
 
   // proof_submission_fee is the number of tokens (uPOKT) which should be paid by
   // the supplier operator when submitting a proof.
   // This is needed to account for the cost of storing proofs on-chain and prevent
   // spamming (i.e. sybil bloat attacks) the network with non-required proofs.
+  // TODO_MAINNET: Consider renaming this to `proof_submission_fee_upokt`.
   cosmos.base.v1beta1.Coin proof_submission_fee = 5 [(gogoproto.jsontag) = "proof_submission_fee"];
 
   // IMPORTANT: Make sure to update all related files if you're modifying or adding a new parameter.

proto/poktroll/tokenomics/event.proto

@@ -59,4 +59,15 @@ message EventApplicationOverserviced {
     // is a function of the relay mining algorithm.
     // E.g. The application's stake divided by the number of suppliers in a session.
     cosmos.base.v1beta1.Coin effective_burn  = 4;
+}
+
+// EventSupplierSlashed is emitted when a supplier is slashed for not providing,
+// or provided invalid required proofs for claims.
+message EventSupplierSlashed {
+    string supplier_operator_addr = 1;
+    // Number of claims that were expired and led to the slashing.
+    uint64 num_expired_claims = 2;
+    // Amount slashed from the supplier's stake due to the expired claims.
+    // This is a function of the number of expired claims and proof missing penalty.
+    cosmos.base.v1beta1.Coin slashing_amount = 3;
 }