repv2

type Donation struct {
	Pid    Pid      `json:"p"`
	Amount LinoCoin `json:"a"`
	Impact IF       `json:"i"`
}

type IF = bigInt // Impact factor

type Int struct {
	*big.Int
}

type LinoCoin = bigInt

type Pid string

type PostIFPair struct {
	Pid   Pid `json:"p"`
	SumIF IF  `json:"s_if"`
}

type Rep = bigInt

type Reputation interface {
	// Donate to post @p p wit @p s coins.
	// Note that if migrate is required, it must be done before donate.
	DonateAt(u Uid, p Pid, s LinoCoin) IF

	// user's freescore += @p r, NOTE: unit is COIN.
	IncFreeScore(u Uid, r Rep)

	// needs to be called every endblocker.
	Update(t Time)

	// current reputation of the user.
	GetReputation(u Uid) Rep

	// Round 0 is an invalidated round
	// Round 1 is a short round that will last for only one block, because round-1's
	// start time is set to 0.
	GetCurrentRound() (RoundId, Time) // current round and its start time.

	// ExportImporter
	ExportToFile(file string) error
	ImportFromFile(file string) error
}

type ReputationImpl struct {
	BestN                int
	UserMaxN             int
	RoundDurationSeconds int64
	SampleWindowSize     int64
	DecayFactor          int64
	// contains filtered or unexported fields
}

type ReputationStore interface {
	// Export all state to deterministic bytes
	Export() *UserReputationTable

	// Import state from bytes
	Import(tb *UserReputationTable)

	// Iterator over usernames
	IterateUsers(UserIterator)

	GetUserMeta(u Uid) *userMeta
	SetUserMeta(u Uid, data *userMeta)

	SetRoundMeta(r RoundId, dt *roundMeta)
	GetRoundMeta(r RoundId) *roundMeta

	// total donation power received of a @p post in @p r round.
	GetRoundPostMeta(r RoundId, p Pid) *roundPostMeta
	SetRoundPostMeta(r RoundId, p Pid, dt *roundPostMeta)
	DelRoundPostMeta(r RoundId, p Pid)

	/// -----------  In this round  -------------
	// RoundId is the current round, starts from 1.
	GetCurrentRound() RoundId

	// Global data.
	GetGameMeta() *gameMeta
	SetGameMeta(dt *gameMeta)
}

type RoundId int64

type Store interface {
	Set(key []byte, val []byte)
	Get(key []byte) []byte
	Has(key []byte) bool
	Delete(key []byte)
	// Iterator over a domain of keys in ascending order. End is exclusive.
	// Start must be less than end, or the Iterator is invalid.
	// Iterator must be closed by caller.
	// To iterate over entire domain, use store.Iterator(nil, nil)
	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
	Iterator(start, end []byte) db.Iterator
}

type Time int64

type Uid string

type UserIterator = func(user Uid) bool // return true to break.

type UserReputation struct {
	Username      Uid  `json:"username"`
	CustomerScore Rep  `json:"customer_score"`
	FreeScore     Rep  `json:"free_score"`
	IsMiniDollar  bool `json:"is_mini_dollar,omitempty"`
}

type UserReputationTable struct {
	Reputations []UserReputation `json:"reputations"`
}