module

func ChurnRequestsGetActiveTopicsAndDemand ¶

func ChurnRequestsGetActiveTopicsAndDemand(ctx sdk.Context, k keeper.Keeper, currentTime uint64) ([]state.Topic, cosmosMath.Uint, error)

The price of inference for a topic is determined by the price that maximizes the demand drawn from valid requests. Which topics get processed (inference solicitation and weight-adjustment) is based on ordering topics by their return at their optimal prices and then skimming the top.

func GetParticipantEmissionsForTopic ¶

func GetParticipantEmissionsForTopic(
	ctx sdk.Context,
	am AppModule,
	topicId keeper.TOPIC_ID,
	topicStake *Uint,
	cumulativeEmission *Uint,
	accumulatedMetDemand *Uint,
	totalStake *Uint) (rewards map[string]*Uint, err error)

******************************************************** * PUBLIC EXPORTED READ-ONLY FUNCTIONS * ******************************************************** For a given topic: given the sum total of all stake in that topic, given the amount of new tokens scheduled to be emitted this epoch, given the total amount of stake in the network, return the amount of new tokens to be emitted to each partipicant in that topic

func GetRequestsThatMaxFees ¶

func GetRequestsThatMaxFees(
	ctx sdk.Context,
	k keeper.Keeper,
	currentTime uint64,
	requestsForGivenTopic []state.InferenceRequest) (
	bestPrice cosmosMath.Uint,
	maxFees cosmosMath.Uint,
	requests []state.InferenceRequest,
	err error)

Generate a demand curve, which is a data structure that captures the price that maximizes the demand drawn from valid requests. Each price is mapped to the list of people willing to pay AT LEAST that price for inference. Then the maximum amount of fees is found by multiplying the price by the number of requests willing to pay at least that price. TODO: think if we can sort the data structure first, then process it in order to do O(2*n) probably we can use some kind of ordered tree to do this instead of what we are currently doing which is O(n^2)

func InactivateLowDemandTopics ¶

func InactivateLowDemandTopics(ctx context.Context, k keeper.Keeper) (remainingActiveTopics []*state.Topic, err error)

Inactivates topics with below keeper.MIN_TOPIC_UNMET_DEMAND demand returns a list of topics that are still active after this operation

func IsValidAtPrice ¶

func IsValidAtPrice(
	ctx sdk.Context,
	k keeper.Keeper,
	req state.InferenceRequest,
	price cosmosMath.Uint,
	currentTime uint64) (bool, error)

Check that a request:

should be checked in this timestep
AND did not expire
AND would have enough funds to cover the potential next price
AND admits and acceptable max price per inference

func MaskWeightsIfInsufficientLiveness ¶ added in v0.0.1

func MaskWeightsIfInsufficientLiveness(
	ctx sdk.Context,
	am AppModule,
	topicId keeper.TOPIC_ID,
	weights map[string]map[string]*Uint) (map[string]map[string]*Uint, error)

This function checks topic weights and then masks them if not enough inferences were collected in that timestep It should:

mask the inputted weights above with GetNumInferencesInRewardEpoch(),
checking inference cadence by reward epoch length / topic inference cadence
simple forgiveness check (only if many inferences are missing, don't reward)

func SortTopicsByReturnDescWithRandomTiebreaker ¶

func SortTopicsByReturnDescWithRandomTiebreaker(valsToSort []state.Topic, weights map[TopicId]PriceAndReturn, randSeed uint64) []state.Topic

Sorts the given slice of topics in descending order according to their corresponding return, using randomness as tiebreaker e.g. ([]uint64{1, 2, 3}, map[uint64]uint64{1: 2, 2: 2, 3: 3}, 0) -> [3, 1, 2] or [3, 2, 1]