[Relay Mining] Use per-service difficulty in the relayer

Makefile

@@ -444,7 +444,7 @@ test_verbose: check_go_version ## Run all go tests verbosely
 # It is not compatible with `-race`, which is why it's omitted here.
 # See ref for more details: https://github.com/golang/go/issues/54482#issuecomment-1251124908
 .PHONY: test_all
-test_all: warn_flaky_tests check_go_version ## Run all go tests showing detailed output only on failures
+test_all: warn_flaky_tests check_go_version test_gen_fixtures ## Run all go tests showing detailed output only on failures
 	go test -count=1 -buildmode=pie -tags test ./...
 
 .PHONY: test_all_with_integration
@@ -466,6 +466,14 @@ test_integration: check_go_version ## Run only the in-memory integration "unit"
 itest: check_go_version ## Run tests iteratively (see usage for more)
 	./tools/scripts/itest.sh $(filter-out $@,$(MAKECMDGOALS))
 
+# Verify there are no compile errors in pkg/relayer/miner/gen directory.
+# This is done by overriding the build tags through passing a `*.go` argument to `go test`.
+# .go files in that directory contain a `go:build ignore` directive to avoid introducing
+# unintentional churn in the randomly generated fixtures.
+.PHONY: test_gen_fixtures
+test_gen_fixtures: check_go_version ## Run all go tests verbosely
+	go test -count=1 -v -race ./pkg/relayer/miner/gen/*.go
+
 .PHONY: go_mockgen
 go_mockgen: ## Use `mockgen` to generate mocks used for testing purposes of all the modules.
 	find . -name "*_mock.go" | xargs --no-run-if-empty rm

pkg/client/interface.go

@@ -9,6 +9,8 @@
 //go:generate mockgen -destination=../../testutil/mockclient/session_query_client_mock.go -package=mockclient . SessionQueryClient
 //go:generate mockgen -destination=../../testutil/mockclient/shared_query_client_mock.go -package=mockclient . SharedQueryClient
 //go:generate mockgen -destination=../../testutil/mockclient/proof_query_client_mock.go -package=mockclient . ProofQueryClient
+//go:generate mockgen -destination=../../testutil/mockclient/tokenomics_query_client_mock.go -package=mockclient . TokenomicsQueryClient
+//go:generate mockgen -destination=../../testutil/mockclient/service_query_client_mock.go -package=mockclient . ServiceQueryClient
 //go:generate mockgen -destination=../../testutil/mockclient/cosmos_tx_builder_mock.go -package=mockclient github.com/cosmos/cosmos-sdk/client TxBuilder
 //go:generate mockgen -destination=../../testutil/mockclient/cosmos_keyring_mock.go -package=mockclient github.com/cosmos/cosmos-sdk/crypto/keyring Keyring
 //go:generate mockgen -destination=../../testutil/mockclient/cosmos_client_mock.go -package=mockclient github.com/cosmos/cosmos-sdk/client AccountRetriever
@@ -335,7 +337,6 @@ type BlockQueryClient interface {
 // protobuf message. Since the generated go types don't include interface types, this
 // is necessary to prevent dependency cycles.
 type ProofParams interface {
-	GetRelayDifficultyTargetHash() []byte
 	GetProofRequestProbability() float32
 	GetProofRequirementThreshold() uint64
 	GetProofMissingPenalty() *cosmostypes.Coin
@@ -347,3 +348,20 @@ type ProofQueryClient interface {
 	// GetParams queries the chain for the current shared module parameters.
 	GetParams(ctx context.Context) (ProofParams, error)
 }
+
+// TokenomicsRelayMiningDifficulty is a go interface type which corresponding to the poktroll.tokenomics.RelayMiningDifficulty
+// protobuf message. This is necessary to prevent dependency cycles.
+type TokenomicsRelayMiningDifficulty interface {
+	GetTargetHash() []byte
+}
+
+type TokenomicsQueryClient interface {
+	GetServiceRelayDifficultyTargetHash(ctx context.Context, serviceId string) (TokenomicsRelayMiningDifficulty, error)
+}
+
+// ServiceQueryClient defines an interface that enables the querying of the
+// on-chain service information
+type ServiceQueryClient interface {
+	// GetService queries the chain for the details of the service provided
+	GetService(ctx context.Context, serviceId string) (sharedtypes.Service, error)
+}

pkg/client/query/errors.go

@@ -9,4 +9,5 @@ var (
 	ErrQueryRetrieveSession            = sdkerrors.Register(codespace, 3, "error while trying to retrieve a session")
 	ErrQueryPubKeyNotFound             = sdkerrors.Register(codespace, 4, "account pub key not found")
 	ErrQuerySessionParams              = sdkerrors.Register(codespace, 5, "unable to query session params")
+	ErrQueryRetrieveService            = sdkerrors.Register(codespace, 6, "error while trying to retrieve a service")
 )

pkg/client/query/servicequerier.go

@@ -0,0 +1,62 @@
+package query
+
+import (
+	"context"
+
+	"cosmossdk.io/depinject"
+	"github.com/cosmos/gogoproto/grpc"
+
+	"github.com/pokt-network/poktroll/pkg/client"
+	servicetypes "github.com/pokt-network/poktroll/x/service/types"
+	sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+)
+
+var _ client.ServiceQueryClient = (*serviceQuerier)(nil)
+
+// serviceQuerier is a wrapper around the servicetypes.QueryClient that enables the
+// querying of on-chain service information through a single exposed method
+// which returns a sharedtypes.Service struct
+type serviceQuerier struct {
+	clientConn     grpc.ClientConn
+	serviceQuerier servicetypes.QueryClient
+}
+
+// NewServiceQuerier returns a new instance of a client.ServiceQueryClient by
+// injecting the dependecies provided by the depinject.Config.
+//
+// Required dependencies:
+// - clientCtx (grpc.ClientConn)
+func NewServiceQuerier(deps depinject.Config) (client.ServiceQueryClient, error) {
+	servq := &serviceQuerier{}
+
+	if err := depinject.Inject(
+		deps,
+		&servq.clientConn,
+	); err != nil {
+		return nil, err
+	}
+
+	servq.serviceQuerier = servicetypes.NewQueryClient(servq.clientConn)
+
+	return servq, nil
+}
+
+// GetService returns a sharedtypes.Service struct for a given serviceId.
+// It implements the ServiceQueryClient#GetService function.
+func (servq *serviceQuerier) GetService(
+	ctx context.Context,
+	serviceId string,
+) (sharedtypes.Service, error) {
+	req := &servicetypes.QueryGetServiceRequest{
+		Id: serviceId,
+	}
+
+	res, err := servq.serviceQuerier.Service(ctx, req)
+	if err != nil {
+		return sharedtypes.Service{}, ErrQueryRetrieveService.Wrapf(
+			"serviceId: %s; error: [%v]",
+			serviceId, err,
+		)
+	}
+	return res.Service, nil
+}

pkg/client/query/tokenomicsquerier.go

@@ -0,0 +1,55 @@
+package query
+
+import (
+	"context"
+
+	"cosmossdk.io/depinject"
+	"github.com/cosmos/gogoproto/grpc"
+
+	"github.com/pokt-network/poktroll/pkg/client"
+	tokenomicstypes "github.com/pokt-network/poktroll/x/tokenomics/types"
+)
+
+// tokenomicsQuerier is a wrapper around the tokenomicstypes.QueryClient that enables the
+// querying of on-chain tokenomics module data.
+type tokenomicsQuerier struct {
+	clientConn        grpc.ClientConn
+	tokenomicsQuerier tokenomicstypes.QueryClient
+}
+
+// NewTokenomicsQuerier returns a new instance of a client.TokenomicsQueryClient by
+// injecting the dependecies provided by the depinject.Config.
+//
+// Required dependencies:
+// - grpc.ClientConn
+func NewTokenomicsQuerier(deps depinject.Config) (client.TokenomicsQueryClient, error) {
+	querier := &tokenomicsQuerier{}
+
+	if err := depinject.Inject(
+		deps,
+		&querier.clientConn,
+	); err != nil {
+		return nil, err
+	}
+
+	querier.tokenomicsQuerier = tokenomicstypes.NewQueryClient(querier.clientConn)
+
+	return querier, nil
+}
+
+// GetServiceRelayDifficultyTargetHash queries the onchain data for
+// the relay mining difficulty associated with the given service.
+func (tq *tokenomicsQuerier) GetServiceRelayDifficultyTargetHash(
+	ctx context.Context,
+	serviceId string,
+) (client.TokenomicsRelayMiningDifficulty, error) {
+	req := &tokenomicstypes.QueryGetRelayMiningDifficultyRequest{
+		ServiceId: serviceId,
+	}
+
+	res, err := tq.tokenomicsQuerier.RelayMiningDifficulty(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return &res.RelayMiningDifficulty, nil
+}

pkg/deps/config/suppliers.go

@@ -466,6 +466,42 @@ func NewSupplyProofQueryClientFn() SupplierFn {
 	}
 }
 
+// NewSupplyTokenomicsQueryClientFn returns a function which constructs a
+// TokenomicsQueryClient instance and returns a new depinject.Config which
+// is supplied with the given deps and the new TokenomicsQueryClient.
+func NewSupplyTokenomicsQueryClientFn() SupplierFn {
+	return func(
+		_ context.Context,
+		deps depinject.Config,
+		_ *cobra.Command,
+	) (depinject.Config, error) {
+		tokenomicsQuerier, err := query.NewTokenomicsQuerier(deps)
+		if err != nil {
+			return nil, err
+		}
+
+		return depinject.Configs(deps, depinject.Supply(tokenomicsQuerier)), nil
+	}
+}
+
+// NewSupplyServiceQueryClientFn returns a function which constructs a
+// NewSupplyServiceQueryClient instance and returns a new depinject.Config which
+// is supplied with the given deps and the new ServiceQueryClient.
+func NewSupplyServiceQueryClientFn() SupplierFn {
+	return func(
+		_ context.Context,
+		deps depinject.Config,
+		_ *cobra.Command,
+	) (depinject.Config, error) {
+		serviceQuerier, err := query.NewServiceQuerier(deps)
+		if err != nil {
+			return nil, err
+		}
+
+		return depinject.Configs(deps, depinject.Supply(serviceQuerier)), nil
+	}
+}
+
 // newSupplyTxClientFn returns a new depinject.Config which is supplied with
 // the given deps and the new TxClient.
 func newSupplyTxClientsFn(ctx context.Context, deps depinject.Config, signingKeyName string) (depinject.Config, error) {

pkg/relayer/cmd/cmd.go

@@ -194,12 +194,13 @@ func setupRelayerDependencies(
 		config.NewSupplyTxClientContextFn(queryNodeGRPCUrl, txNodeRPCUrl), // leaf
 		config.NewSupplyDelegationClientFn(),                              // leaf
 		config.NewSupplySharedQueryClientFn(),                             // leaf
-		config.NewSupplyProofQueryClientFn(),
+		config.NewSupplyTokenomicsQueryClientFn(),
 		supplyMiner,
 		config.NewSupplyAccountQuerierFn(),
 		config.NewSupplyApplicationQuerierFn(),
 		config.NewSupplySupplierQuerierFn(),
 		config.NewSupplySessionQuerierFn(),
+		config.NewSupplyServiceQueryClientFn(),
 		config.NewSupplyRingCacheFn(),
 		supplyTxFactory,
 		supplyTxContext,