chain

type ActionMeta struct {
	ActionID   ids.ShortID      `serialize:"true" json:"actionID"`
	ActionType uint64           `serialize:"true" json:"actionType"`
	StartTime  uint64           `serialize:"true" json:"startTime"`
	EndTime    uint64           `serialize:"true" json:"endTime"`
	TxIDs      []ids.ID         `serialize:"true" json:"txids"`
	Voters     []common.Address `serialize:"true" json:"voters"`
	Key        string           `serialize:"true" json:"key"`
	NewValue   string           `serialize:"true" json:"newValue"`
}

type ActionsState interface {
	GetActionMeta(actionID ids.ShortID) (*ActionMeta, bool, error)
	PutAction(db database.Database, actionID ids.ShortID, pmeta *ActionMeta) error
	GetActions() ([]*ActionMeta, error)
	DelAction(db database.Database, actionID ids.ShortID) error
	ReloadActions(db database.Database) error
	CacheActionsCommit() error
	CacheActionsAbort() error
	GetVotersNum(actionType uint64, key string) (int, ids.ShortID, error)
	ProposalRepeat(actionID ids.ShortID, key string, newValue string) error
	CheckActionType(actionType uint64) bool
}

type Activity struct {
	Tmstmp       int64  `serialize:"true" json:"timestamp"`
	TxID         ids.ID `serialize:"true" json:"txId"`
	Typ          string `serialize:"true" json:"type"`
	Sender       string `serialize:"true" json:"sender,omitempty"`
	Key          string `serialize:"true" json:"key,omitempty"`
	To           string `serialize:"true" json:"to,omitempty"` // common.Address will be 0x000 when not populated
	Units        uint64 `serialize:"true" json:"units,omitempty"`
	StakerType   uint64 `serialize:"true" json:"stakerType,omitempty"`
	StakeAmount  uint64 `serialize:"true" json:"stakeAmount,omitempty"`
	StakerAddr   string `serialize:"true" json:"stakerAddr,omitempty"`
	RewardAmount uint64 `serialize:"true" json:"rewardAmount,omitempty"`

	StartTime   uint64      `serialize:"true" json:"startTime,omitempty"`
	EndTime     uint64      `serialize:"true" json:"endTime,omitempty"`
	PayAmount   uint64      `serialize:"true" json:"payAmout,omitempty"`
	Connections uint64      `serialize:"true" json:"connections,omitempty"`
	Address     string      `serialize:"true" json:"address,omitempty"`
	ActionID    ids.ShortID `serialize:"true" json:"actionID,omitempty"`
	ParamType   uint64      `serialize:"true" json:"paramType,omitempty"`
	Value       string      `serialize:"true" json:"value,omitempty"`

	Netflow uint64 `serialize:"true" json:"netflow,omitempty"`

	LocalIP   string `serialize:"true" json:"localIP,omitempty"`
	MinPort   uint64 `serialize:"true" json:"minPort,omitempty"`
	MaxPort   uint64 `serialize:"true" json:"maxPort,omitempty"`
	PublicIP  string `serialize:"true" json:"publicIP,omitempty"`
	CheckPort uint64 `serialize:"true" json:"checkPort,omitempty"`
	Country   string `serialize:"true" json:"country,omitempty"`
	//DevID     string `serialize:"true" json:"devID,omitempty"`
	WorkKey    string `serialize:"true" json:"workKey,omitempty"`
	UserType   uint64 `serialize:"true" json:"userType,omitempty"`
	ActionType uint64 `serialize:"true" json:"actionType,omitempty"`
}

type AddUserTx struct {
	*BaseTx     `serialize:"true" json:"baseTx"`
	StartTime   uint64         `serialize:"true" json:"startTime"`
	EndTime     uint64         `serialize:"true" json:"endTime"`
	PayAmount   uint64         `serialize:"true" json:"payAmount"`
	Connections uint64         `serialize:"true" json:"connections"`
	UserType    uint64         `serialize:"true" json:"userType"`
	Address     common.Address `serialize:"true" json:"address"`
}

type Airdrop struct {
	// Address strings are hex-formatted common.Address
	Address common.Address `serialize:"true" json:"address"`
}

type BaseTx struct {
	// BlkID is the ID of a block in the [lookbackWindow].
	BlockID ids.ID `serialize:"true" json:"blockId"`

	// Magic is a value defined in genesis to protect against replay attacks on
	// different VMs.
	Magic uint64 `serialize:"true" json:"magic"`

	// Price is the value per unit to spend on this transaction.
	Price uint64 `serialize:"true" json:"price"`
}

type ClaimTx struct {
	*BaseTx      `serialize:"true" json:"baseTx"`
	RewardAmount uint64 `serialize:"true" json:"reward"`
	EndTime      uint64 `serialize:"true" json:"endTime"`
}

type Context struct {
	RecentBlockIDs  set.Set[ids.ID]
	RecentTxIDs     set.Set[ids.ID]
	RecentLoadUnits uint64

	Prices []uint64
	Costs  []uint64

	NextCost  uint64
	NextPrice uint64
}

type CustomAllocation struct {
	// Address strings are hex-formatted common.Address
	Address common.Address `serialize:"true" json:"address"`
	Balance uint64         `serialize:"true" json:"balance"`
}

type DetailMeta struct {
	StakerType     uint64         `serialize:"true" json:"stakerType"`
	Country        string         `serialize:"true" json:"country"`
	LocalIP        string         `serialize:"true" json:"localIP"`
	PublicIP       string         `serialize:"true" json:"publicIP"`
	MinPort        uint64         `serialize:"true" json:"minPort"`
	MaxPort        uint64         `serialize:"true" json:"maxPort"`
	CheckPort      uint64         `serialize:"true" json:"checkPort"`
	WorkKey        string         `serialize:"true" json:"workKey"`
	TxID           ids.ID         `serialize:"true" json:"txid"`
	LastUpdateTime uint64         `serialize:"true" json:"lastUpdateTime"`
	WorkAddress    common.Address `serialize:"true" json:"workAddress"`
	StakeAddress   common.Address `serialize:"true" json:"stakeAddress"`
}

type DetailsState interface {
	GetDetailMeta(address common.Address) (*DetailMeta, bool, error)
	PutDetail(db database.Database, address common.Address, pmeta *DetailMeta) error
	GetDetails() ([]*DetailMeta, error)
	DelDetail(db database.Database, address common.Address) error
	ReloadDetails(db database.Database) error
	CacheDetailsCommit() error
	CacheDetailsAbort() error
}

type Genesis struct {
	Magic uint64 `serialize:"true" json:"magic"`

	// Tx params
	BaseTxUnits uint64 `serialize:"true" json:"baseTxUnits"`

	// SetTx params
	ValueUnitSize uint64 `serialize:"true" json:"valueUnitSize"`
	MaxValueSize  uint64 `serialize:"true" json:"maxValueSize"`

	// Fee Mechanism Params
	MinPrice         uint64 `serialize:"true" json:"minPrice"`
	LookbackWindow   int64  `serialize:"true" json:"lookbackWindow"`
	TargetBlockRate  int64  `serialize:"true" json:"targetBlockRate"` // seconds
	TargetBlockSize  uint64 `serialize:"true" json:"targetBlockSize"` // units
	MaxBlockSize     uint64 `serialize:"true" json:"maxBlockSize"`    // units
	BlockCostEnabled bool   `serialize:"true" json:"blockCostEnabled"`

	// Allocations
	CustomAllocation []*CustomAllocation `serialize:"true" json:"customAllocation"`
	AirdropHash      string              `serialize:"true" json:"airdropHash"`
	AirdropUnits     uint64              `serialize:"true" json:"airdropUnits"`

	//chain Params
	TotalTokens      uint64 `serialize:"true" json:"totalTokens"`
	ClaimMinUnits    uint64 `serialize:"true" json:"claimMinUnits"`
	ClaimMinInterval uint64 `serialize:"true" json:"claimMinInterval"`
	TotalYears       uint32 `serialize:"true" json:"totalYears"`
	RateSustainYears uint32 `serialize:"true" json:"rateChangeYears"`

	ChainCreateTime uint64 `serialize:"true" json:"chainCreateTime"`

	MinerPerc      uint32 `serialize:"true" json:"minerPerc"`
	FoundationPerc uint32 `serialize:"true" json:"foundationPerc"`

	RoutePerc     uint32 `serialize:"true" json:"routePerc"`
	SerPerc       uint32 `serialize:"true" json:"serPerc"`
	ValidatorPerc uint32 `serialize:"true" json:"validatorPerc"`

	BaseSerPerc    uint32 `serialize:"true" json:"baseSer"`
	MeritSerPerc   uint32 `serialize:"true" json:"meritSerPerc"`
	BaseRoutePerc  uint32 `serialize:"true" json:"baseRoutePerc"`
	MeritRoutePerc uint32 `serialize:"true" json:"meritRoutePerc"`

	BurnPerc uint32 `serialize:"true" json:"burnPerc"`

	RouteStake uint64 `serialize:"true" json:"routeAmount"`
	SerStake   uint64 `serialize:"true" json:"serAmount"`

	MonthCard  uint64 `serialize:"true" json:"month"`
	SeasonCard uint64 `serialize:"true" json:"season"`
	AnnualCard uint64 `serialize:"true" json:"annual"`

	MinStakeTime uint64 `serialize:"true" json:"minStakeTime"`

	RootAddress    string `serialize:"true" json:"rootAddress"`
	FoundationAddr string `serialize:"true" json:"foundation"`
}

type GovernTx struct {
	*BaseTx  `serialize:"true" json:"baseTx"`
	ActionID ids.ShortID `serialize:"true" json:"actionID"`
}

type Input struct {
	Typ          string         `json:"type"`
	Key          string         `json:"key"`
	Value        []byte         `json:"value"`
	To           common.Address `json:"to"`
	Units        uint64         `json:"units"`
	StakerType   uint64         `json:"stakerType"`
	StakerAddr   common.Address `json:"stakerAddr"`
	StakeAmount  uint64         `json:"stakeAmount"`
	RewardAmount uint64         `json:"rewardAmount"`
	ActionID     ids.ShortID    `json:"actionID"`
	LocalIP      string         `json:"localIP"`
	MinPort      uint64         `json:"minPort"`
	MaxPort      uint64         `json:"maxPort"`
	PublicIP     string         `json:"publicIP"`
	CheckPort    uint64         `json:"checkPort"`
	Netflow      uint64         `json:"netflow"`
	StartTime    uint64         `json:"startTime"`
	EndTime      uint64         `json:"endTime"`
	Ser          common.Address `json:"ser"`
	NewValue     string         `json:"newValue"`
	Country      string         `json:"country"`
	WorkKey      string         `json:"workKey"`
}

type KeyValueMeta struct {
	Key       string     `serialize:"true" json:"key"`
	ValueMeta *ValueMeta `serialize:"true" json:"valueMeta"`
}

type Mempool interface {
	Len() int
	Prune(set.Set[ids.ID])
	PopMax() (*Transaction, uint64)
	Add(*Transaction) bool
	NewTxs(uint64) []*Transaction
}

type MockMempool struct {
	// contains filtered or unexported fields
}

type MockMempoolMockRecorder struct {
	// contains filtered or unexported fields
}

type MockUnsignedTransaction struct {
	// contains filtered or unexported fields
}

type MockUnsignedTransactionMockRecorder struct {
	// contains filtered or unexported fields
}

type MockVM struct {
	// contains filtered or unexported fields
}

type MockVMMockRecorder struct {
	// contains filtered or unexported fields
}

type PowMeta struct {
	PowType        uint64         `serialize:"true" json:"powType"`
	TotalTime      uint64         `serialize:"true" json:"totalTime"`
	Totalflow      uint64         `serialize:"true" json:"totalflow"`
	LastUpdateTime uint64         `serialize:"true" json:"lastUpdateTime"`
	LastUpdateTXID ids.ID         `serialize:"true" json:"lastUpdateTxId"`
	Miner          common.Address `serialize:"true" json:"miner"`
}

type PowState interface {
	GetCurPow(powType byte) (map[common.Address]*PowMeta, error)
	GetPendingPow(powType byte) (map[common.Address]*PowMeta, map[common.Address]*PowMeta, error)
	GetPowMeta(powType byte, address common.Address) (*PowMeta, bool, error)

	PutPow(db database.Database, powType byte, pmeta *ProofMeta) error

	GetPows(powType byte) ([]*PowMeta, error)

	DelPow(db database.Database, powType byte, address common.Address) error
	ReloadPows(db database.Database) error
	CachePowsCommit() error
	CachePowsAbort() error

	TotalPowTime(powType byte) (uint64, error)
}

type ProofMeta struct {
	Netflow    uint64         `serialize:"true" json:"netflow"`
	WorkTime   uint64         `serialize:"true" json:"workTime"`
	Miner      common.Address `serialize:"true" json:"miner"`
	TxID       ids.ID         `serialize:"true" json:"txId"`
	UpdateTime uint64         `serialize:"true" json:"updateTime"`
}

type ProofTx struct {
	*BaseTx   `serialize:"true" json:"baseTx"`
	Netflow   uint64         `serialize:"true" json:"netflow"`
	StartTime uint64         `serialize:"true" json:"startTime"`
	EndTime   uint64         `serialize:"true" json:"endTime"`
	Ser       common.Address `serialize:"true" json:"ser"`
}

type ProposalTx struct {
	*BaseTx    `serialize:"true" json:"baseTx"`
	ActionID   ids.ShortID `serialize:"true" json:"actionID"`
	StartTime  uint64      `serialize:"true" json:"startTime"`
	EndTime    uint64      `serialize:"true" json:"endTime"`
	ActionType uint64      `serialize:"true" json:"actionType"`
	Key        string      `serialize:"true" json:"key"`
	NewValue   string      `serialize:"true" json:"newValue"`
}

type RefreshTx struct {
	*BaseTx   `serialize:"true" json:"baseTx"`
	Country   string `serialize:"true" json:"country"`
	LocalIP   string `serialize:"true" json:"localIP"`
	PublicIP  string `serialize:"true" json:"publicIP"`
	MinPort   uint64 `serialize:"true" json:"minPort"`
	MaxPort   uint64 `serialize:"true" json:"maxPort"`
	CheckPort uint64 `serialize:"true" json:"checkPort"`
	WorkKey   string `serialize:"true" json:"workKey"`
}

type RegisterTx struct {
	*BaseTx    `serialize:"true" json:"baseTx"`
	ActionID   ids.ShortID    `serialize:"true" json:"actionID"`
	StakerType uint64         `serialize:"true" json:"stakerType"`
	Country    string         `serialize:"true" json:"country"`
	LocalIP    string         `serialize:"true" json:"localIP"`
	PublicIP   string         `serialize:"true" json:"publicIP"`
	MinPort    uint64         `serialize:"true" json:"minPort"`
	MaxPort    uint64         `serialize:"true" json:"maxPort"`
	CheckPort  uint64         `serialize:"true" json:"checkPort"`
	WorkKey    string         `serialize:"true" json:"workKey"`
	StakerAddr common.Address `serialize:"true" json:"stakeAddress"`
}

type RewardGlobal struct {
	LastOprTime uint64 `serialize:"true" json:"lastOprTime"`
	LastOprTXID ids.ID `serialize:"true" json:"lastOprTxId"`
}

type RewardMeta struct {
	YieldReward   uint64         `serialize:"true" json:"yieldReward"`
	BaseReward    uint64         `serialize:"true" json:"BaseReward"`
	MeritReward   uint64         `serialize:"true" json:"meritReward"`
	LastOprTime   uint64         `serialize:"true" json:"lastOprTime"`
	LastOprTXID   ids.ID         `serialize:"true" json:"lastOprTxId"`
	LastClaimTime uint64         `serialize:"true" json:"lastClaimTime"`
	LastClaimTXID ids.ID         `serialize:"true" json:"lastClaimTxId"`
	RewardAddr    common.Address `serialize:"true" json:"rewardAddr"`
}

type RewardState interface {
	GetRewardMeta(address common.Address) (*RewardMeta, bool, error)
	UpdateReward(db database.Database, pG *RewardGlobal, pmeta *RewardMeta) error
	UpdateOwner(db database.Database, pmeta *RewardMeta) error
	UpdateGlobal(db database.Database, pG *RewardGlobal) error
	GetRewards() ([]*RewardMeta, error)
	DelReward(db database.Database, address common.Address) error
	ReloadRewards(db database.Database) error
	CacheRewardsCommit() error
	CacheRewardsAbort() error
	GetLastUpdateTime() (uint64, error)
	GetLastClaimTime(address common.Address) (uint64, error)
}

type SamaState interface {
	SysParams
	StakerState
	RewardState
	PowState
	YieldsState
	UsersState
	DetailsState
	ActionsState
	UserTypesState
	Commit() error
	Abort() error
	CalcReward(claimerType byte, address common.Address, endTime uint64) (uint64, uint64, uint64, error)
	CheckPayAmount(db database.Database, userType uint64, amount uint64, startTime uint64, endTime uint64) (bool, error)

	DealStakeTx(db database.Database, staker *StakerMeta) error
	DealUnStakeTx(db database.Database, stakerType byte, address common.Address, txID ids.ID, endTime uint64) error
	DealAddUserTx(db database.Database, txID ids.ID, blkTime uint64, user *UserMeta) error
	UpdateNodeParams(db database.Database, detail *DetailMeta) error

	UpdateStakerReward(db database.Database, stakerType byte, address common.Address, txID ids.ID, endTime uint64) error
	UpdateFoundationReward(db database.Database, address common.Address, txID ids.ID, endTime uint64) error

	IsBeConfirmed(actionType uint64, key string) (bool, ids.ShortID, error)
	ProposalStatus(actionID ids.ShortID) (bool, error)
	IsValidWorkAddress(address common.Address) (bool, byte, error)
	CheckClaimAddress(address common.Address) (bool, byte, error)
}

type SetTx struct {
	*BaseTx `serialize:"true" json:"baseTx"`

	Value []byte `serialize:"true" json:"value"`
}

type StakeTx struct {
	*BaseTx     `serialize:"true" json:"baseTx"`
	StakerType  uint64         `serialize:"true" json:"stakerType"`
	StakeAmount uint64         `serialize:"true" json:"stakeAmount"`
	StakerAddr  common.Address `serialize:"true" json:"stakerAddr"`
}

type StakerMeta struct {
	TxID        ids.ID         `serialize:"true" json:"txId"`
	StakerType  uint64         `serialize:"true" json:"stakerType"`
	StakeAmount uint64         `serialize:"true" json:"stakeAmount"`
	StakeTime   uint64         `serialize:"true" json:"stakeTime"`
	StakerAddr  common.Address `serialize:"true" json:"stakerAddr"`
}

type StakerState interface {
	GetPendingStakers(stakerType byte) (map[common.Address]*StakerMeta, map[common.Address]*StakerMeta, error)
	GetStakerMeta(stakerType byte, address common.Address) (*StakerMeta, bool, error)
	PutStaker(db database.Database, pmeta *StakerMeta) error
	GetStakers(stakerType byte) ([]*StakerMeta, error)
	DelStaker(db database.Database, stakerType byte, address common.Address) error
	ReloadStakers(db database.Database) error
	CacheStakersCommit() error
	CacheStakersAbort() error
	GetStakersNum() (int, int, int)

	IsRoute(address common.Address) (bool, error)
	IsSer(address common.Address) (bool, error)
	IsValidator(address common.Address) (bool, error)

	IsStaker(address common.Address) (bool, byte, error)
}

type StatefulBlock struct {
	Prnt        ids.ID         `serialize:"true" json:"parent"`
	Tmstmp      int64          `serialize:"true" json:"timestamp"`
	Hght        uint64         `serialize:"true" json:"height"`
	Price       uint64         `serialize:"true" json:"price"`
	Cost        uint64         `serialize:"true" json:"cost"`
	AccessProof common.Hash    `serialize:"true" json:"accessProof"`
	Txs         []*Transaction `serialize:"true" json:"txs"`
}

type StatelessBlock struct {
	*StatefulBlock `serialize:"true" json:"block"`
	// contains filtered or unexported fields
}

type SysParams interface {
	ReloadParams(db database.Database) error
	ModifyParams(db database.Database, key string, newValue string, txID ids.ID, updateTime uint64) error
	CacheParamsCommit() error
	CacheParamsAbort() error
	GetChainSymbol() string
	GetChainTokenAmount() uint64
	GetPercRoute() uint32
	GetPercSer() uint32
	GetPercValidator() uint32
	GetRoutePercBase() uint32
	GetRoutePercMerit() uint32
	GetSerPercBase() uint32
	GetSerPercMerit() uint32
	GetPercBurn() uint32
	GetPercFoundation() uint32
	GetTotalYears() uint32
	GetRateSustainYears() uint32
	GetChainCreateTime() uint64
	GetMonthCardPrice() uint64
	GetSeasonCardPrice() uint64
	GetAnnualCardPrice() uint64
	GetMinStakeTime() uint64
	GetRootAddress() string
	GetSysParams() *SysParamsMeta
	CompCurParam(key string, newValue string) error
	GetFoundationAddress() string
}

type SysParamsMeta struct {
	Symbol           string `serialize:"true" json:"symbol"`
	TotalTokens      uint64 `serialize:"true" json:"totalTokens"`
	ClaimMinUnits    uint64 `serialize:"true" json:"claimMinUnits"`
	ClaimMinInterval uint64 `serialize:"true" json:"claimMinInterval"`
	TotalYears       uint32 `serialize:"true" json:"totalYears"`
	RateSustainYears uint32 `serialize:"true" json:"rateChangeYears"`
	ChainCreateTime  uint64 `serialize:"true" json:"chainCreateTime"`
	MinerPerc        uint32 `serialize:"true" json:"minerPerc"`
	FoundationPerc   uint32 `serialize:"true" json:"foundationPerc"`
	RoutePerc        uint32 `serialize:"true" json:"routePerc"`
	SerPerc          uint32 `serialize:"true" json:"serPerc"`
	ValidatorPerc    uint32 `serialize:"true" json:"validatorPerc"`
	BaseSerPerc      uint32 `serialize:"true" json:"baseSer"`
	MeritSerPerc     uint32 `serialize:"true" json:"meritSerPerc"`
	BaseRoutePerc    uint32 `serialize:"true" json:"baseRoutePerc"`
	MeritRoutePerc   uint32 `serialize:"true" json:"meritRoutePerc"`
	RouteStakeAmount uint64 `serialize:"true" json:"routeAmount"`
	SerStakeAmount   uint64 `serialize:"true" json:"serAmount"`
	MinStakeTime     uint64 `serialize:"true" json:"minStakeTime"`
	MonthCard        uint64 `serialize:"true" json:"month"`
	SeasonCard       uint64 `serialize:"true" json:"season"`
	AnnualCard       uint64 `serialize:"true" json:"annual"`
	BurnPerc         uint32 `serialize:"true" json:"burnPerc"`
	RootAddress      string `serialize:"true" json:"rootAddress"`
	FoundationAddr   string `serialize:"true" json:"foundation"`
	UpdateTime       uint64 `serialize:"true" json:"updateTime"`
	UpdateTxID       ids.ID `serialize:"true" json:"updateTxId"`
}

type Transaction struct {
	UnsignedTransaction `serialize:"true" json:"unsignedTransaction"`
	Signature           []byte `serialize:"true" json:"signature"`
	// contains filtered or unexported fields
}

type TransactionContext struct {
	Genesis   *Genesis
	Database  database.Database
	BlockTime uint64
	TxID      ids.ID
	Sender    common.Address
	// contains filtered or unexported fields
}

type TransferTx struct {
	*BaseTx `serialize:"true" json:"baseTx"`

	// To is the recipient of the [Units].
	To common.Address `serialize:"true" json:"to"`

	// Units are transferred to [To].
	Units uint64 `serialize:"true" json:"units"`
}

type UnStakeTx struct {
	*BaseTx      `serialize:"true" json:"baseTx"`
	RewardAmount uint64 `serialize:"true" json:"rewardAmount"`
	StakerType   uint64 `serialize:"true" json:"stakerType"`
	EndTime      uint64 `serialize:"true" json:"endTime"`
}

type UnsignedTransaction interface {
	Copy() UnsignedTransaction
	GetBlockID() ids.ID
	GetMagic() uint64
	GetPrice() uint64
	SetBlockID(ids.ID)
	SetMagic(uint64)
	SetPrice(uint64)
	FeeUnits(*Genesis) uint64  // number of units to mine tx
	LoadUnits(*Genesis) uint64 // units that should impact fee rate

	ExecuteBase(*Genesis) error
	Execute(*TransactionContext) error
	TypedData() *tdata.TypedData
	Activity() *Activity
}

type UserMeta struct {
	StartTime   uint64         `serialize:"true" json:"startTime"`
	EndTime     uint64         `serialize:"true" json:"endTime"`
	Connections uint64         `serialize:"true" json:"connections"`
	PayAmount   uint64         `serialize:"true" json:"payAmount"`
	TxsID       []ids.ID       `serialize:"true" json:"txsid"`
	UserType    uint64         `serialize:"true" json:"userType"`
	Address     common.Address `serialize:"true" json:"address"`
}

type UserType struct {
	TypeName string `serialize:"true" json:"typeName"`
	TypeID   uint64 `serialize:"true" json:"typeID"`
	FeeUnits uint64 `serialize:"true" json:"fee"`
}

type UserTypesState interface {
	GetUserType(db database.Database, id uint64) (*UserType, bool, error)
	AddUserType(db database.Database, pmeta *UserType) error
	DelUserType(db database.Database, id uint64) error
	GetUserTypes(db database.Database) (map[uint64]*UserType, error)
	ReloadUserTypes(db database.Database) error
	CacheUserTypesCommit() error
	CacheUserTypesAbort() error

	CheckUserType(id uint64) bool
	CheckFee(id uint64, fee uint64) bool
}

type UsersState interface {
	GetUserMeta(db database.Database, address common.Address) (*UserMeta, bool, error)
	PutUser(db database.Database, pmeta *UserMeta) error
	DelUser(db database.Database, address common.Address) error
	GetUsers(db database.Database) ([]*UserMeta, error)
	ReloadUsers(db database.Database) error
	CacheUsersCommit() error
	CacheUsersAbort() error
}

type VM interface {
	Genesis() *Genesis
	IsBootstrapped() bool
	State() database.Database
	Mempool() Mempool
	GetStatelessBlock(ids.ID) (*StatelessBlock, error)
	ExecutionContext(currentTime int64, parent *StatelessBlock) (*Context, error)
	Verified(*StatelessBlock)
	Rejected(*StatelessBlock)
	Accepted(*StatelessBlock)
	SamaState() SamaState
}

type ValueMeta struct {
	Size    uint64 `serialize:"true" json:"size"`
	TxID    ids.ID `serialize:"true" json:"txId"`
	Created uint64 `serialize:"true" json:"created"`
}

type VoteTx struct {
	*BaseTx  `serialize:"true" json:"baseTx"`
	ActionID ids.ShortID `serialize:"true" json:"actionID"`
}

type WithdrawnTx struct {
	*BaseTx  `serialize:"true" json:"baseTx"`
	ActionID ids.ShortID `serialize:"true" json:"actionID"`
}

type YieldMeta struct {
	Total         uint64 `serialize:"true" json:"total"`
	Undistributed uint64 `serialize:"true" json:"undistributed"`
	LastOprTime   uint64 `serialize:"true" json:"lastOprTime"`
	LastOprTXID   ids.ID `serialize:"true" json:"lastOprTxId"`
}

type YieldsState interface {
	GetChainYields() uint64
	ModifyYields(db database.Database, yield uint64, txID ids.ID, blkTime uint64) error
	ReloadYields(db database.Database) error
	CacheYieldsCommit() error
	CacheYieldsAbort() error
}