types

type AuthKeeper interface {
	// get total supply of tokens
	GetSupply(ctx sdk.Ctx) authexported.SupplyI
	// set total supply of tokens
	SetSupply(ctx sdk.Ctx, supply authexported.SupplyI)
	// get the address of a module account
	GetModuleAddress(name string) sdk.Address
	// get the module account structure
	GetModuleAccount(ctx sdk.Ctx, moduleName string) authexported.ModuleAccountI
	// set module account structure
	SetModuleAccount(sdk.Ctx, authexported.ModuleAccountI)
	// send coins to/from module accounts
	SendCoinsFromModuleToModule(ctx sdk.Ctx, senderModule, recipientModule string, amt sdk.Coins) sdk.Error
	// send coins from module to validator
	SendCoinsFromModuleToAccount(ctx sdk.Ctx, senderModule string, recipientAddr sdk.Address, amt sdk.Coins) sdk.Error
	// send coins from validator to module
	SendCoinsFromAccountToModule(ctx sdk.Ctx, senderAddr sdk.Address, recipientModule string, amt sdk.Coins) sdk.Error
	// mint coins
	MintCoins(ctx sdk.Ctx, moduleName string, amt sdk.Coins) sdk.Error
	// burn coins
	BurnCoins(ctx sdk.Ctx, name string, amt sdk.Coins) sdk.Error
	// iterate accounts
	IterateAccounts(ctx sdk.Ctx, process func(authexported.Account) (stop bool))
	// get coins
	GetCoins(ctx sdk.Ctx, addr sdk.Address) sdk.Coins
	// set coins
	SetCoins(ctx sdk.Ctx, addr sdk.Address, amt sdk.Coins) sdk.Error
	// has coins
	HasCoins(ctx sdk.Ctx, addr sdk.Address, amt sdk.Coins) bool
	// send coins
	SendCoins(ctx sdk.Ctx, fromAddr sdk.Address, toAddr sdk.Address, amt sdk.Coins) sdk.Error
	// get account
	GetAccount(ctx sdk.Ctx, addr sdk.Address) authexported.Account
}

type CodeType = sdk.CodeType

type GenesisState struct {
	Params                   Params                          `json:"params" yaml:"params"`
	PrevStateTotalPower      sdk.BigInt                      `json:"prevState_total_power" yaml:"prevState_total_power"`
	PrevStateValidatorPowers []PrevStatePowerMapping         `json:"prevState_validator_powers" yaml:"prevState_validator_powers"`
	Validators               []Validator                     `json:"validators" yaml:"validators"`
	Exported                 bool                            `json:"exported" yaml:"exported"`
	SigningInfos             map[string]ValidatorSigningInfo `json:"signing_infos" yaml:"signing_infos"`
	MissedBlocks             map[string][]MissedBlock        `json:"missed_blocks" yaml:"missed_blocks"`
	PreviousProposer         sdk.Address                     `json:"previous_proposer" yaml:"previous_proposer"`
}

type JSONValidator struct {
	Address                 sdk.Address     `json:"address" yaml:"address"`               // address of the validator; hex encoded in JSON
	PublicKey               string          `json:"public_key" yaml:"public_key"`         // the consensus public key of the validator; hex encoded in JSON
	Jailed                  bool            `json:"jailed" yaml:"jailed"`                 // has the validator been jailed from staked status?
	Status                  sdk.StakeStatus `json:"status" yaml:"status"`                 // validator status (staked/unstaking/unstaked)
	Chains                  []string        `json:"chains" yaml:"chains"`                 // validator non native blockchains
	ServiceURL              string          `json:"service_url" yaml:"service_url"`       // url where the pocket service api is hosted
	StakedTokens            sdk.BigInt      `json:"tokens" yaml:"tokens"`                 // tokens staked in the network
	UnstakingCompletionTime time.Time       `json:"unstaking_time" yaml:"unstaking_time"` // if unstaking, min time for the validator to complete unstaking
}

type MissedBlock struct {
	Index  int64 `json:"index" yaml:"index"`
	Missed bool  `json:"missed" yaml:"missed"`
}

type MsgBeginUnstake struct {
	Address github_com_pokt_network_pocket_core_types.Address `` /* 151-byte string literal not displayed */
}

type MsgProtoStake struct {
	Publickey  []byte                                           `protobuf:"bytes,1,opt,name=Publickey,proto3" json:"public_key" yaml:"public_key"`
	Chains     []string                                         `protobuf:"bytes,2,rep,name=Chains,proto3" json:"chains" yaml:"chains"`
	Value      github_com_pokt_network_pocket_core_types.BigInt `` /* 126-byte string literal not displayed */
	ServiceUrl string                                           `protobuf:"bytes,4,opt,name=ServiceUrl,proto3" json:"service_url" yaml:"service_url"`
}

type MsgSend struct {
	FromAddress github_com_pokt_network_pocket_core_types.Address `` /* 145-byte string literal not displayed */
	ToAddress   github_com_pokt_network_pocket_core_types.Address `` /* 139-byte string literal not displayed */
	Amount      github_com_pokt_network_pocket_core_types.BigInt  `` /* 129-byte string literal not displayed */
}

type MsgStake struct {
	PublicKey  crypto.PublicKey `json:"public_key" yaml:"public_key"`
	Chains     []string         `json:"chains" yaml:"chains"`
	Value      sdk.BigInt       `json:"value" yaml:"value"`
	ServiceUrl string           `json:"service_url" yaml:"service_url"`
}

type MsgUnjail struct {
	ValidatorAddr github_com_pokt_network_pocket_core_types.Address `` /* 137-byte string literal not displayed */
}

type Params struct {
	RelaysToTokensMultiplier int64         `json:"relays_to_tokens_multiplier" yaml:"relays_to_tokens_multiplier"`
	UnstakingTime            time.Duration `json:"unstaking_time" yaml:"unstaking_time"`                   // how much time must pass between the begin_unstaking_tx and the node going to -> unstaked status
	MaxValidators            int64         `json:"max_validators" yaml:"max_validators"`                   // maximum number of validators in the network at any given block
	StakeDenom               string        `json:"stake_denom" yaml:"stake_denom"`                         // the monetary denomination of the coins in the network `uPOKT` or `uAtom` or `Wei`
	StakeMinimum             int64         `json:"stake_minimum" yaml:"stake_minimum"`                     // minimum amount of `uPOKT` needed to stake in the network as a node
	SessionBlockFrequency    int64         `json:"session_block_frequency" yaml:"session_block_frequency"` // how many blocks are in a session (pocket network unit)
	DAOAllocation            int64         `json:"dao_allocation" yaml:"dao_allocation"`
	ProposerAllocation       int64         `json:"proposer_allocation" yaml:"proposer_allocation"`
	MaximumChains            int64         `json:"maximum_chains" yaml:"maximum_chains"`
	MaxJailedBlocks          int64         `json:"max_jailed_blocks" yaml:"max_jailed_blocks"`
	MaxEvidenceAge           time.Duration `json:"max_evidence_age" yaml:"max_evidence_age"`                     // maximum age of tendermint evidence that is still valid (currently not implemented in Cosmos or Pocket-Core)
	SignedBlocksWindow       int64         `json:"signed_blocks_window" yaml:"signed_blocks_window"`             // window of time in blocks (unit) used for signature verification -> specifically in not signing (missing) blocks
	MinSignedPerWindow       sdk.BigDec    `json:"min_signed_per_window" yaml:"min_signed_per_window"`           // minimum number of blocks the node must sign per window
	DowntimeJailDuration     time.Duration `json:"downtime_jail_duration" yaml:"downtime_jail_duration"`         // minimum amount of time node must spend in jail after missing blocks
	SlashFractionDoubleSign  sdk.BigDec    `json:"slash_fraction_double_sign" yaml:"slash_fraction_double_sign"` // the factor of which a node is slashed for a double sign
	SlashFractionDowntime    sdk.BigDec    `json:"slash_fraction_downtime" yaml:"slash_fraction_downtime"`       // the factor of which a node is slashed for missing blocks
}

type PocketKeeper interface {
	// clear the cache of validators for sessions and relays
	ClearSessionCache()
}

type Pool struct {
	Tokens sdk.BigInt
}

type PrevStatePowerMapping struct {
	Address sdk.Address
	Power   int64
}

type ProtoValidator struct {
	Address                 github_com_pokt_network_pocket_core_types.Address `` /* 131-byte string literal not displayed */
	PublicKey               []byte                                            `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"public_key" yaml:"public_key"`
	Jailed                  bool                                              `protobuf:"varint,3,opt,name=jailed,proto3" json:"jailed"`
	Status                  int32                                             `protobuf:"varint,4,opt,name=status,proto3" json:"status"`
	Chains                  []string                                          `protobuf:"bytes,5,rep,name=Chains,proto3" json:"chains"`
	ServiceURL              string                                            `protobuf:"bytes,6,opt,name=ServiceURL,proto3" json:"service_url"`
	StakedTokens            github_com_pokt_network_pocket_core_types.BigInt  `protobuf:"bytes,7,opt,name=StakedTokens,proto3,customtype=github.com/pokt-network/pocket-core/types.BigInt" json:"tokens"`
	UnstakingCompletionTime time.Time                                         `protobuf:"bytes,8,opt,name=UnstakingCompletionTime,proto3,stdtime" json:"unstaking_time" yaml:"unstaking_time"`
}

type QueryAccountBalanceParams struct {
	sdk.Address
}

type QueryAccountParams struct {
	sdk.Address
}

type QuerySigningInfoParams struct {
	Address sdk.Address
}

type QuerySigningInfosParams struct {
	Page, Limit int
}

type QueryStakedValidatorsParams struct {
	Page, Limit int
}

type QueryUnstakedValidatorsParams struct {
	Page, Limit int
}

type QueryUnstakingValidatorsParams struct {
	Page, Limit int
}

type QueryValidatorParams struct {
	Address sdk.Address
}

type QueryValidatorsParams struct {
	StakingStatus sdk.StakeStatus `json:"staking_status"`
	JailedStatus  int             `json:"jailed_status"`
	Blockchain    string          `json:"blockchain"`
	Page          int             `json:"page"`
	Limit         int             `json:"per_page"`
}

type StakingPool Pool

type Validator struct {
	Address                 sdk.Address      `json:"address" yaml:"address"`               // address of the validator; hex encoded in JSON
	PublicKey               crypto.PublicKey `json:"public_key" yaml:"public_key"`         // the consensus public key of the validator; hex encoded in JSON
	Jailed                  bool             `json:"jailed" yaml:"jailed"`                 // has the validator been jailed from staked status?
	Status                  sdk.StakeStatus  `json:"status" yaml:"status"`                 // validator status (staked/unstaking/unstaked)
	Chains                  []string         `json:"chains" yaml:"chains"`                 // validator non native blockchains
	ServiceURL              string           `json:"service_url" yaml:"service_url"`       // url where the pocket service api is hosted
	StakedTokens            sdk.BigInt       `json:"tokens" yaml:"tokens"`                 // tokens staked in the network
	UnstakingCompletionTime time.Time        `json:"unstaking_time" yaml:"unstaking_time"` // if unstaking, min time for the validator to complete unstaking
}

type ValidatorSet interface {
	// iterate through validators by address, execute func for each validator
	IterateAndExecuteOverVals(sdk.Ctx, func(index int64, validator posexported.ValidatorI) (stop bool))
	// iterate through staked validators by address, execute func for each validator
	IterateAndExecuteOverStakedVals(sdk.Ctx, func(index int64, validator posexported.ValidatorI) (stop bool))
	// iterate through the validator set of the prevState block by address, execute func for each validator
	IterateAndExecuteOverPrevStateVals(sdk.Ctx, func(index int64, validator posexported.ValidatorI) (stop bool))
	// get a particular validator by address
	Validator(sdk.Ctx, sdk.Address) posexported.ValidatorI
	// total staked tokens within the validator set
	TotalTokens(sdk.Ctx) sdk.BigInt
	// jail a validator
	JailValidator(sdk.Ctx, sdk.Address)
	// unjail a validator
	UnjailValidator(sdk.Ctx, sdk.Address)
	// MaxValidators returns the maximum amount of staked validators
	MaxValidators(sdk.Ctx) int64
}

type ValidatorSigningInfo struct {
	Address github_com_pokt_network_pocket_core_types.Address `protobuf:"bytes,1,opt,name=address,proto3,casttype=github.com/pokt-network/pocket-core/types.Address" json:"address"`
	// height at which validator was first a candidate OR was unjailed
	StartHeight int64 `protobuf:"varint,2,opt,name=start_height,json=startHeight,proto3" json:"start_height" yaml:"start_height"`
	// index offset into signed block bit array
	Index int64 `protobuf:"varint,3,opt,name=Index,proto3" json:"index_offset" yaml:"index_offset"`
	// timestamp validator cannot be unjailed until
	JailedUntil time.Time `protobuf:"bytes,4,opt,name=jailed_until,json=jailedUntil,proto3,stdtime" json:"jailed_until" yaml:"jailed_until"`
	// missed blocks counter (to avoid scanning the array every time)
	MissedBlocksCounter int64 `` /* 140-byte string literal not displayed */
	JailedBlocksCounter int64 `` /* 140-byte string literal not displayed */
}

type Validators []Validator

type ValidatorsPage struct {
	Result Validators `json:"result"`
	Total  int        `json:"total_pages"`
	Page   int        `json:"page"`
}