platformvm

type APIAllychain struct {
	// ID of the allychain
	ID ids.ID `json:"id"`

	// Each element of [ControlKeys] the address of a public key.
	// A transaction to add a validator to this allychain requires
	// signatures from [Threshold] of these keys to be valid.
	ControlKeys []string    `json:"controlKeys"`
	Threshold   json.Uint32 `json:"threshold"`
}

type APIAllychainValidator struct {
	APIStaker
	// The owner the staking reward, if applicable, will go to
	Connected bool `json:"connected"`
}

type APIBlockchain struct {
	// Blockchain's ID
	ID ids.ID `json:"id"`

	// Blockchain's (non-unique) human-readable name
	Name string `json:"name"`

	// Allychain that validates the blockchain
	AllychainID ids.ID `json:"allychainID"`

	// Virtual Machine the blockchain runs
	VMID ids.ID `json:"vmID"`
}

type APIChain struct {
	GenesisData string   `json:"genesisData"`
	VMID        ids.ID   `json:"vmID"`
	FxIDs       []ids.ID `json:"fxIDs"`
	Name        string   `json:"name"`
	AllychainID ids.ID   `json:"allychainID"`
}

type APIOwner struct {
	Locktime  json.Uint64 `json:"locktime"`
	Threshold json.Uint32 `json:"threshold"`
	Addresses []string    `json:"addresses"`
}

type APIPrimaryNominator struct {
	APIStaker
	RewardOwner     *APIOwner    `json:"rewardOwner,omitempty"`
	PotentialReward *json.Uint64 `json:"potentialReward,omitempty"`
}

type APIPrimaryValidator struct {
	APIStaker
	// The owner the staking reward, if applicable, will go to
	RewardOwner        *APIOwner     `json:"rewardOwner,omitempty"`
	PotentialReward    *json.Uint64  `json:"potentialReward,omitempty"`
	DelegationFee      json.Float32  `json:"delegationFee"`
	ExactDelegationFee *json.Uint32  `json:"exactDelegationFee,omitempty"`
	Uptime             *json.Float32 `json:"uptime"`
	Connected          bool          `json:"connected"`
	Staked             []APIUTXO     `json:"staked,omitempty"`
	// The nominators delegating to this validator
	Nominators []APIPrimaryNominator `json:"nominators"`
}

type APIStaker struct {
	TxID        ids.ID       `json:"txID"`
	StartTime   json.Uint64  `json:"startTime"`
	EndTime     json.Uint64  `json:"endTime"`
	Weight      *json.Uint64 `json:"weight,omitempty"`
	StakeAmount *json.Uint64 `json:"stakeAmount,omitempty"`
	NodeID      ids.NodeID   `json:"nodeID"`
}

type APIUTXO struct {
	Locktime json.Uint64 `json:"locktime"`
	Amount   json.Uint64 `json:"amount"`
	Address  string      `json:"address"`
	Message  string      `json:"message"`
}

type AbortBlock struct {
	DoubleDecisionBlock `serialize:"true"`
	// contains filtered or unexported fields
}

type AddAllychainValidatorArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader
	APIStaker
	// ID of allychain to validate
	AllychainID string `json:"allychainID"`
}

type AddNominatorArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader
	APIStaker
	RewardAddress string `json:"rewardAddress"`
}

type AddValidatorArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader
	APIStaker
	// The address the staking reward, if applicable, will go to
	RewardAddress     string       `json:"rewardAddress"`
	DelegationFeeRate json.Float32 `json:"delegationFeeRate"`
}

type Allychain interface {
	// ID returns this allychain's ID
	ID() ids.ID

	// Validators returns the validators that compose this allychain
	Validators() []validators.Validator
}

type AtomicBlock struct {
	CommonDecisionBlock `serialize:"true"`

	Tx Tx `serialize:"true" json:"tx"`
	// contains filtered or unexported fields
}

type BaseTx struct {
	axc.BaseTx `serialize:"true"`
	// contains filtered or unexported fields
}

type Block interface {
	snowman.Block
	// contains filtered or unexported methods
}

type BuildGenesisArgs struct {
	AxcAssetID    ids.ID                `json:"axcAssetID"`
	NetworkID     json.Uint32           `json:"networkID"`
	UTXOs         []APIUTXO             `json:"utxos"`
	Validators    []APIPrimaryValidator `json:"validators"`
	Chains        []APIChain            `json:"chains"`
	Time          json.Uint64           `json:"time"`
	InitialSupply json.Uint64           `json:"initialSupply"`
	Message       string                `json:"message"`
	Encoding      formatting.Encoding   `json:"encoding"`
}

type BuildGenesisReply struct {
	Bytes    string              `json:"bytes"`
	Encoding formatting.Encoding `json:"encoding"`
}

type Client interface {
	// GetHeight returns the current block height of the P Chain
	GetHeight(ctx context.Context, options ...rpc.Option) (uint64, error)
	// ExportKey returns the private key corresponding to [address] from [user]'s account
	ExportKey(ctx context.Context, user api.UserPass, address ids.ShortID, options ...rpc.Option) (*crypto.PrivateKeySECP256K1R, error)
	// ImportKey imports the specified [privateKey] to [user]'s keystore
	ImportKey(ctx context.Context, user api.UserPass, privateKey *crypto.PrivateKeySECP256K1R, options ...rpc.Option) (ids.ShortID, error)
	// GetBalance returns the balance of [addrs] on the P Chain
	GetBalance(ctx context.Context, addrs []ids.ShortID, options ...rpc.Option) (*GetBalanceResponse, error)
	// CreateAddress creates a new address for [user]
	CreateAddress(ctx context.Context, user api.UserPass, options ...rpc.Option) (ids.ShortID, error)
	// ListAddresses returns an array of platform addresses controlled by [user]
	ListAddresses(ctx context.Context, user api.UserPass, options ...rpc.Option) ([]ids.ShortID, error)
	// GetUTXOs returns the byte representation of the UTXOs controlled by [addrs]
	GetUTXOs(
		ctx context.Context,
		addrs []ids.ShortID,
		limit uint32,
		startAddress ids.ShortID,
		startUTXOID ids.ID,
		options ...rpc.Option,
	) ([][]byte, ids.ShortID, ids.ID, error)
	// GetAtomicUTXOs returns the byte representation of the atomic UTXOs controlled by [addrs]
	// from [sourceChain]
	GetAtomicUTXOs(
		ctx context.Context,
		addrs []ids.ShortID,
		sourceChain string,
		limit uint32,
		startAddress ids.ShortID,
		startUTXOID ids.ID,
		options ...rpc.Option,
	) ([][]byte, ids.ShortID, ids.ID, error)
	// GetAllychains returns information about the specified allychains
	GetAllychains(context.Context, []ids.ID, ...rpc.Option) ([]ClientAllychain, error)
	// GetStakingAssetID returns the assetID of the asset used for staking on
	// allychain corresponding to [allychainID]
	GetStakingAssetID(context.Context, ids.ID, ...rpc.Option) (ids.ID, error)
	// GetCurrentValidators returns the list of current validators for allychain with ID [allychainID]
	GetCurrentValidators(ctx context.Context, allychainID ids.ID, nodeIDs []ids.NodeID, options ...rpc.Option) ([]ClientPrimaryValidator, error)
	// GetPendingValidators returns the list of pending validators for allychain with ID [allychainID]
	GetPendingValidators(ctx context.Context, allychainID ids.ID, nodeIDs []ids.NodeID, options ...rpc.Option) ([]interface{}, []interface{}, error)
	// GetCurrentSupply returns an upper bound on the supply of AXC in the system
	GetCurrentSupply(ctx context.Context, options ...rpc.Option) (uint64, error)
	// SampleValidators returns the nodeIDs of a sample of [sampleSize] validators from the current validator set for allychain with ID [allychainID]
	SampleValidators(ctx context.Context, allychainID ids.ID, sampleSize uint16, options ...rpc.Option) ([]ids.NodeID, error)
	// AddValidator issues a transaction to add a validator to the primary network
	// and returns the txID
	AddValidator(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		rewardAddress ids.ShortID,
		nodeID ids.NodeID,
		stakeAmount,
		startTime,
		endTime uint64,
		delegationFeeRate float32,
		options ...rpc.Option,
	) (ids.ID, error)
	// AddNominator issues a transaction to add a nominator to the primary network
	// and returns the txID
	AddNominator(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		rewardAddress ids.ShortID,
		nodeID ids.NodeID,
		stakeAmount,
		startTime,
		endTime uint64,
		options ...rpc.Option,
	) (ids.ID, error)
	// AddAllychainValidator issues a transaction to add validator [nodeID] to allychain
	// with ID [allychainID] and returns the txID
	AddAllychainValidator(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		allychainID ids.ID,
		nodeID ids.NodeID,
		stakeAmount,
		startTime,
		endTime uint64,
		options ...rpc.Option,
	) (ids.ID, error)
	// CreateAllychain issues a transaction to create [allychain] and returns the txID
	CreateAllychain(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		controlKeys []ids.ShortID,
		threshold uint32,
		options ...rpc.Option,
	) (ids.ID, error)
	// ExportAXC issues an ExportTx transaction and returns the txID
	ExportAXC(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		to ids.ShortID,
		toChainIDAlias string,
		amount uint64,
		options ...rpc.Option,
	) (ids.ID, error)
	// ImportAXC issues an ImportTx transaction and returns the txID
	ImportAXC(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		to ids.ShortID,
		sourceChain string,
		options ...rpc.Option,
	) (ids.ID, error)
	// CreateBlockchain issues a CreateBlockchain transaction and returns the txID
	CreateBlockchain(
		ctx context.Context,
		user api.UserPass,
		from []ids.ShortID,
		changeAddr ids.ShortID,
		allychainID ids.ID,
		vmID string,
		fxIDs []string,
		name string,
		genesisData []byte,
		options ...rpc.Option,
	) (ids.ID, error)
	// GetBlockchainStatus returns the current status of blockchain with ID: [blockchainID]
	GetBlockchainStatus(ctx context.Context, blockchainID string, options ...rpc.Option) (status.BlockchainStatus, error)
	// ValidatedBy returns the ID of the Allychain that validates [blockchainID]
	ValidatedBy(ctx context.Context, blockchainID ids.ID, options ...rpc.Option) (ids.ID, error)
	// Validates returns the list of blockchains that are validated by the allychain with ID [allychainID]
	Validates(ctx context.Context, allychainID ids.ID, options ...rpc.Option) ([]ids.ID, error)
	// GetBlockchains returns the list of blockchains on the platform
	GetBlockchains(ctx context.Context, options ...rpc.Option) ([]APIBlockchain, error)
	// IssueTx issues the transaction and returns its txID
	IssueTx(ctx context.Context, tx []byte, options ...rpc.Option) (ids.ID, error)
	// GetTx returns the byte representation of the transaction corresponding to [txID]
	GetTx(ctx context.Context, txID ids.ID, options ...rpc.Option) ([]byte, error)
	// GetTxStatus returns the status of the transaction corresponding to [txID]
	GetTxStatus(ctx context.Context, txID ids.ID, options ...rpc.Option) (*GetTxStatusResponse, error)
	// AwaitTxDecided polls [GetTxStatus] until a status is returned that
	// implies the tx may be decided.
	AwaitTxDecided(
		ctx context.Context,
		txID ids.ID,
		freq time.Duration,
		options ...rpc.Option,
	) (*GetTxStatusResponse, error)
	// GetStake returns the amount of nAXC that [addrs] have cumulatively
	// staked on the Primary Network.
	GetStake(ctx context.Context, addrs []ids.ShortID, options ...rpc.Option) (uint64, [][]byte, error)
	// GetMinStake returns the minimum staking amount in nAXC for validators
	// and nominators respectively
	GetMinStake(ctx context.Context, options ...rpc.Option) (uint64, uint64, error)
	// GetTotalStake returns the total amount (in nAXC) staked on the network
	GetTotalStake(ctx context.Context, allychainID ids.ID, options ...rpc.Option) (uint64, error)
	// GetMaxStakeAmount returns the maximum amount of nAXC staking to the named
	// node during the time period.
	GetMaxStakeAmount(
		ctx context.Context,
		allychainID ids.ID,
		nodeID ids.NodeID,
		startTime uint64,
		endTime uint64,
		options ...rpc.Option,
	) (uint64, error)
	// GetRewardUTXOs returns the reward UTXOs for a transaction
	GetRewardUTXOs(context.Context, *api.GetTxArgs, ...rpc.Option) ([][]byte, error)
	// GetTimestamp returns the current chain timestamp
	GetTimestamp(ctx context.Context, options ...rpc.Option) (time.Time, error)
	// GetValidatorsAt returns the weights of the validator set of a provided allychain
	// at the specified height.
	GetValidatorsAt(ctx context.Context, allychainID ids.ID, height uint64, options ...rpc.Option) (map[ids.NodeID]uint64, error)
	// GetBlock returns the block with the given id.
	GetBlock(ctx context.Context, blockID ids.ID, options ...rpc.Option) ([]byte, error)
}

type ClientAllychain struct {
	// ID of the allychain
	ID ids.ID
	// Each element of [ControlKeys] the address of a public key.
	// A transaction to add a validator to this allychain requires
	// signatures from [Threshold] of these keys to be valid.
	ControlKeys []ids.ShortID
	Threshold   uint32
}

type ClientOwner struct {
	Locktime  uint64
	Threshold uint32
	Addresses []ids.ShortID
}

type ClientPrimaryNominator struct {
	ClientStaker
	RewardOwner     *ClientOwner
	PotentialReward *uint64
}

type ClientPrimaryValidator struct {
	ClientStaker
	// The owner the staking reward, if applicable, will go to
	RewardOwner     *ClientOwner
	PotentialReward *uint64
	DelegationFee   float32
	Uptime          *float32
	Connected       *bool
	// The nominators delegating to this validator
	Nominators []ClientPrimaryNominator
}

type ClientStaker struct {
	// the txID of the transaction that added this staker.
	TxID ids.ID
	// the Unix time when they start staking
	StartTime uint64
	// the Unix time when they are done staking
	EndTime uint64
	// the validator weight when sampling validators
	Weight *uint64
	// the amount of tokens being staked.
	StakeAmount *uint64
	// the node ID of the staker
	NodeID ids.NodeID
}

type CommitBlock struct {
	DoubleDecisionBlock `serialize:"true"`
	// contains filtered or unexported fields
}

type CommonBlock struct {
	PrntID ids.ID `serialize:"true" json:"parentID"` // parent's ID
	Hght   uint64 `serialize:"true" json:"height"`   // This block's height. The genesis block is at height 0.
	// contains filtered or unexported fields
}

type CommonDecisionBlock struct {
	CommonBlock `serialize:"true"`
	// contains filtered or unexported fields
}

type CreateAllychainArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader
	// The ID member of APIAllychain is ignored
	APIAllychain
}

type CreateBlockchainArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader
	// ID of Allychain that validates the new blockchain
	AllychainID ids.ID `json:"allychainID"`
	// ID of the VM the new blockchain is running
	VMID string `json:"vmID"`
	// IDs of the FXs the VM is running
	FxIDs []string `json:"fxIDs"`
	// Human-readable name for the new blockchain, not necessarily unique
	Name string `json:"name"`
	// Genesis state of the blockchain being created
	GenesisData string `json:"genesisData"`
	// Encoding format to use for genesis data
	Encoding formatting.Encoding `json:"encoding"`
}

type DoubleDecisionBlock struct {
	CommonDecisionBlock `serialize:"true"`
}

type ExportAXCArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader

	// Amount of AXC to send
	Amount json.Uint64 `json:"amount"`

	// Chain the funds are going to. Optional. Used if To address does not include the chainID.
	TargetChain string `json:"targetChain"`

	// ID of the address that will receive the AXC. This address may include the
	// chainID, which is used to determine what the destination chain is.
	To string `json:"to"`
}

type ExportKeyArgs struct {
	api.UserPass
	Address string `json:"address"`
}

type ExportKeyReply struct {
	// The decrypted PrivateKey for the Address provided in the arguments
	PrivateKey *crypto.PrivateKeySECP256K1R `json:"privateKey"`
}

type Factory struct {
	config.Config
}

type Genesis struct {
	UTXOs         []*GenesisUTXO `serialize:"true"`
	Validators    []*Tx          `serialize:"true"`
	Chains        []*Tx          `serialize:"true"`
	Timestamp     uint64         `serialize:"true"`
	InitialSupply uint64         `serialize:"true"`
	Message       string         `serialize:"true"`
}

type GenesisUTXO struct {
	axc.UTXO `serialize:"true"`
	Message  []byte `serialize:"true" json:"message"`
}

type GetAllychainsArgs struct {
	// IDs of the allychains to retrieve information about
	// If omitted, gets all allychains
	IDs []ids.ID `json:"ids"`
}

type GetAllychainsResponse struct {
	// Each element is a allychain that exists
	// Null if there are no allychains other than the primary network
	Allychains []APIAllychain `json:"allychains"`
}

type GetBalanceRequest struct {
	// TODO: remove Address
	Address   *string  `json:"address,omitempty"`
	Addresses []string `json:"addresses"`
}

type GetBalanceResponse struct {
	// Balance, in nAXC, of the address
	Balance            json.Uint64   `json:"balance"`
	Unlocked           json.Uint64   `json:"unlocked"`
	LockedStakeable    json.Uint64   `json:"lockedStakeable"`
	LockedNotStakeable json.Uint64   `json:"lockedNotStakeable"`
	UTXOIDs            []*axc.UTXOID `json:"utxoIDs"`
}

type GetBlockchainStatusArgs struct {
	BlockchainID string `json:"blockchainID"`
}

type GetBlockchainStatusReply struct {
	Status status.BlockchainStatus `json:"status"`
}

type GetBlockchainsResponse struct {
	// blockchains that exist
	Blockchains []APIBlockchain `json:"blockchains"`
}

type GetCurrentSupplyReply struct {
	Supply json.Uint64 `json:"supply"`
}

type GetCurrentValidatorsArgs struct {
	// Allychain we're listing the validators of
	// If omitted, defaults to primary network
	AllychainID ids.ID `json:"allychainID"`
	// NodeIDs of validators to request. If [NodeIDs]
	// is empty, it fetches all current validators. If
	// some nodeIDs are not currently validators, they
	// will be omitted from the response.
	NodeIDs []ids.NodeID `json:"nodeIDs"`
}

type GetCurrentValidatorsReply struct {
	Validators []interface{} `json:"validators"`
}

type GetHeightResponse struct {
	Height json.Uint64 `json:"height"`
}

type GetMaxStakeAmountArgs struct {
	AllychainID ids.ID      `json:"allychainID"`
	NodeID      ids.NodeID  `json:"nodeID"`
	StartTime   json.Uint64 `json:"startTime"`
	EndTime     json.Uint64 `json:"endTime"`
}

type GetMaxStakeAmountReply struct {
	Amount json.Uint64 `json:"amount"`
}

type GetMinStakeReply struct {
	//  The minimum amount of tokens one must bond to be a validator
	MinValidatorStake json.Uint64 `json:"minValidatorStake"`
	// Minimum stake, in nAXC, that can be delegated on the primary network
	MinNominatorStake json.Uint64 `json:"minNominatorStake"`
}

type GetPendingValidatorsArgs struct {
	// Allychain we're getting the pending validators of
	// If omitted, defaults to primary network
	AllychainID ids.ID `json:"allychainID"`
	// NodeIDs of validators to request. If [NodeIDs]
	// is empty, it fetches all pending validators. If
	// some requested nodeIDs are not pending validators,
	// they are omitted from the response.
	NodeIDs []ids.NodeID `json:"nodeIDs"`
}

type GetPendingValidatorsReply struct {
	Validators []interface{} `json:"validators"`
	Nominators []interface{} `json:"nominators"`
}

type GetRewardUTXOsReply struct {
	// Number of UTXOs returned
	NumFetched json.Uint64 `json:"numFetched"`
	// The UTXOs
	UTXOs []string `json:"utxos"`
	// Encoding specifies the encoding format the UTXOs are returned in
	Encoding formatting.Encoding `json:"encoding"`
}

type GetStakeArgs struct {
	api.JSONAddresses
	Encoding formatting.Encoding `json:"encoding"`
}

type GetStakeReply struct {
	Staked json.Uint64 `json:"staked"`
	// String representation of staked outputs
	// Each is of type axc.TransferableOutput
	Outputs []string `json:"stakedOutputs"`
	// Encoding of [Outputs]
	Encoding formatting.Encoding `json:"encoding"`
}

type GetStakingAssetIDArgs struct {
	AllychainID ids.ID `json:"allychainID"`
}

type GetStakingAssetIDResponse struct {
	AssetID ids.ID `json:"assetID"`
}

type GetTimestampReply struct {
	// Current timestamp
	Timestamp time.Time `json:"timestamp"`
}

type GetTotalStakeArgs struct {
	// Allychain we're getting the total stake
	// If omitted returns Primary network weight
	AllychainID ids.ID `json:"allychainID"`
}

type GetTotalStakeReply struct {
	Stake  json.Uint64 `json:"stake,omitempty"`
	Weight json.Uint64 `json:"weight,omitempty"`
}

type GetTxStatusArgs struct {
	TxID ids.ID `json:"txID"`
}

type GetTxStatusResponse struct {
	Status status.Status `json:"status"`
	// Reason this tx was dropped.
	// Only non-empty if Status is dropped
	Reason string `json:"reason,omitempty"`
}

type GetValidatorsAtArgs struct {
	Height      json.Uint64 `json:"height"`
	AllychainID ids.ID      `json:"allychainID"`
}

type GetValidatorsAtReply struct {
	Validators map[ids.NodeID]uint64 `json:"validators"`
}

type ImportAXCArgs struct {
	// User, password, from addrs, change addr
	api.JSONSpendHeader

	// Chain the funds are coming from
	SourceChain string `json:"sourceChain"`

	// The address that will receive the imported funds
	To string `json:"to"`
}

type ImportKeyArgs struct {
	api.UserPass
	PrivateKey *crypto.PrivateKeySECP256K1R `json:"privateKey"`
}

type Index struct {
	Address string `json:"address"` // The address as a string
	UTXO    string `json:"utxo"`    // The UTXO ID as a string
}

type InternalState interface {
	MutableState
	uptime.State
	axc.UTXOReader

	SetHeight(height uint64)

	AddCurrentStaker(tx *Tx, potentialReward uint64)
	DeleteCurrentStaker(tx *Tx)
	GetValidatorWeightDiffs(height uint64, allychainID ids.ID) (map[ids.NodeID]*ValidatorWeightDiff, error)

	AddPendingStaker(tx *Tx)
	DeletePendingStaker(tx *Tx)

	SetCurrentStakerChainState(currentStakerChainState)
	SetPendingStakerChainState(pendingStakerChainState)

	GetLastAccepted() ids.ID
	SetLastAccepted(ids.ID)

	GetBlock(blockID ids.ID) (Block, error)
	AddBlock(block Block)

	Abort()
	Commit() error
	CommitBatch() (database.Batch, error)
	Close() error
}

type Mempool interface {
	Add(tx *Tx) error
	Has(txID ids.ID) bool
	Get(txID ids.ID) *Tx

	AddDecisionTx(tx *Tx)
	AddProposalTx(tx *Tx)

	HasDecisionTxs() bool
	HasProposalTx() bool

	RemoveDecisionTxs(txs []*Tx)
	RemoveProposalTx(tx *Tx)

	PopDecisionTxs(maxTxsBytes int) []*Tx
	PopProposalTx() *Tx

	// Note: dropped txs are added to droppedTxIDs but not
	// not evicted from unissued decision/proposal txs.
	// This allows previously dropped txs to be possibly
	// reissued.
	MarkDropped(txID ids.ID, reason string)
	GetDropReason(txID ids.ID) (string, bool)
}

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

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

type MutableState interface {
	UTXOState
	ValidatorState

	AddRewardUTXO(txID ids.ID, utxo *axc.UTXO)
	GetRewardUTXOs(txID ids.ID) ([]*axc.UTXO, error)

	GetTimestamp() time.Time
	SetTimestamp(time.Time)

	GetCurrentSupply() uint64
	SetCurrentSupply(uint64)

	GetAllychains() ([]*Tx, error)
	AddAllychain(createAllychainTx *Tx)

	GetChains(allychainID ids.ID) ([]*Tx, error)
	AddChain(createChainTx *Tx)

	GetTx(txID ids.ID) (*Tx, status.Status, error)
	AddTx(tx *Tx, status status.Status)
}

type ProposalBlock struct {
	CommonBlock `serialize:"true"`

	Tx Tx `serialize:"true" json:"tx"`
	// contains filtered or unexported fields
}

type SampleValidatorsArgs struct {
	// Number of validators in the sample
	Size json.Uint16 `json:"size"`

	// ID of allychain to sample validators from
	// If omitted, defaults to the primary network
	AllychainID ids.ID `json:"allychainID"`
}

type SampleValidatorsReply struct {
	Validators []ids.NodeID `json:"validators"`
}

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

type StandardBlock struct {
	CommonDecisionBlock `serialize:"true"`

	Txs []*Tx `serialize:"true" json:"txs"`
	// contains filtered or unexported fields
}

type StaticClient interface {
	BuildGenesis(ctx context.Context, args *BuildGenesisArgs, options ...rpc.Option) (*BuildGenesisReply, error)
}

type StaticService struct{}

type TimedTx interface {
	ID() ids.ID
	StartTime() time.Time
	EndTime() time.Time
	Weight() uint64
	Bytes() []byte
}

type TimedTxHeap interface {
	TxHeap

	Timestamp() time.Time
}

type Tx struct {
	// The body of this transaction
	UnsignedTx `serialize:"true" json:"unsignedTx"`

	// The credentials of this transaction
	Creds []verify.Verifiable `serialize:"true" json:"credentials"`
}

type TxHeap interface {
	Add(tx *Tx)
	Get(txID ids.ID) *Tx
	Remove(txID ids.ID) *Tx
	Peek() *Tx
	RemoveTop() *Tx
	Len() int
}

type UTXOAdder interface {
	AddUTXO(utxo *axc.UTXO)
}

type UTXODeleter interface {
	DeleteUTXO(utxoID ids.ID)
}

type UTXOGetter interface {
	GetUTXO(utxoID ids.ID) (*axc.UTXO, error)
}

type UTXOState interface {
	UTXOGetter
	UTXOAdder
	UTXODeleter
}

type UnsignedAddAllychainValidatorTx struct {
	// Metadata, inputs and outputs
	BaseTx `serialize:"true"`
	// The validator
	Validator coreChainValidator.AllychainValidator `serialize:"true" json:"validator"`
	// Auth that will be allowing this validator into the network
	AllychainAuth verify.Verifiable `serialize:"true" json:"allychainAuthorization"`
}

type UnsignedAddNominatorTx struct {
	// Metadata, inputs and outputs
	BaseTx `serialize:"true"`
	// Describes the delegatee
	Validator coreChainValidator.Validator `serialize:"true" json:"validator"`
	// Where to send staked tokens when done validating
	Stake []*axc.TransferableOutput `serialize:"true" json:"stake"`
	// Where to send staking rewards when done validating
	RewardsOwner fx.Owner `serialize:"true" json:"rewardsOwner"`
}

type UnsignedAddValidatorTx struct {
	// Metadata, inputs and outputs
	BaseTx `serialize:"true"`
	// Describes the delegatee
	Validator coreChainValidator.Validator `serialize:"true" json:"validator"`
	// Where to send staked tokens when done validating
	Stake []*axc.TransferableOutput `serialize:"true" json:"stake"`
	// Where to send staking rewards when done validating
	RewardsOwner fx.Owner `serialize:"true" json:"rewardsOwner"`
	// Fee this validator charges nominators as a percentage, times 10,000
	// For example, if this validator has Shares=300,000 then they take 30% of rewards from nominators
	Shares uint32 `serialize:"true" json:"shares"`
}

type UnsignedAdvanceTimeTx struct {
	axc.Metadata

	// Unix time this block proposes increasing the timestamp to
	Time uint64 `serialize:"true" json:"time"`
}

type UnsignedAtomicTx interface {
	UnsignedDecisionTx

	// Execute this transaction with the provided state.
	AtomicExecute(vm *VM, parentState MutableState, stx *Tx) (VersionedState, error)

	// Accept this transaction with the additionally provided state transitions.
	AtomicAccept(ctx *snow.Context, batch database.Batch) error
}

type UnsignedCreateAllychainTx struct {
	// Metadata, inputs and outputs
	BaseTx `serialize:"true"`
	// Who is authorized to manage this allychain
	Owner fx.Owner `serialize:"true" json:"owner"`
}

type UnsignedCreateChainTx struct {
	// Metadata, inputs and outputs
	BaseTx `serialize:"true"`
	// ID of the Allychain that validates this blockchain
	AllychainID ids.ID `serialize:"true" json:"allychainID"`
	// A human readable name for the chain; need not be unique
	ChainName string `serialize:"true" json:"chainName"`
	// ID of the VM running on the new chain
	VMID ids.ID `serialize:"true" json:"vmID"`
	// IDs of the feature extensions running on the new chain
	FxIDs []ids.ID `serialize:"true" json:"fxIDs"`
	// Byte representation of genesis state of the new chain
	GenesisData []byte `serialize:"true" json:"genesisData"`
	// Authorizes this blockchain to be added to this allychain
	AllychainAuth verify.Verifiable `serialize:"true" json:"allychainAuthorization"`
}

type UnsignedDecisionTx interface {
	UnsignedTx

	// Execute this transaction with the provided state.
	Execute(vm *VM, vs VersionedState, stx *Tx) (
		onAcceptFunc func() error,
		err error,
	)

	// To maintain consistency with the Atomic txs
	InputUTXOs() ids.Set

	// AtomicOperations provides the requests to be written to shared memory.
	AtomicOperations() (ids.ID, *atomic.Requests, error)
}

type UnsignedExportTx struct {
	BaseTx `serialize:"true"`

	// Which chain to send the funds to
	DestinationChain ids.ID `serialize:"true" json:"destinationChain"`

	// Outputs that are exported to the chain
	ExportedOutputs []*axc.TransferableOutput `serialize:"true" json:"exportedOutputs"`
}

type UnsignedImportTx struct {
	BaseTx `serialize:"true"`

	// Which chain to consume the funds from
	SourceChain ids.ID `serialize:"true" json:"sourceChain"`

	// Inputs that consume UTXOs produced on the chain
	ImportedInputs []*axc.TransferableInput `serialize:"true" json:"importedInputs"`
}

type UnsignedProposalTx interface {
	UnsignedTx

	// Attempts to verify this transaction with the provided state.
	Execute(vm *VM, state MutableState, stx *Tx) (
		onCommitState VersionedState,
		onAbortState VersionedState,
		err error,
	)
	InitiallyPrefersCommit(vm *VM) bool
}

type UnsignedRewardValidatorTx struct {
	axc.Metadata

	// ID of the tx that created the nominator/validator being removed/rewarded
	TxID ids.ID `serialize:"true" json:"txID"`
	// contains filtered or unexported fields
}

type UnsignedTx interface {
	// TODO: Remove this initialization pattern from both the platformvm and the
	// avm.
	snow.ContextInitializable
	Initialize(unsignedBytes, signedBytes []byte)
	ID() ids.ID
	UnsignedBytes() []byte
	Bytes() []byte

	// InputIDs returns the set of inputs this transaction consumes
	InputIDs() ids.Set

	// Attempts to verify this transaction without any provided state.
	SyntacticVerify(ctx *snow.Context) error

	// Attempts to verify this transaction with the provided state.
	SemanticVerify(vm *VM, parentState MutableState, stx *Tx) error
}

type VM struct {
	Factory

	axc.AddressManager
	axc.AtomicUTXOManager
	// contains filtered or unexported fields
}

type ValidatedByArgs struct {
	// ValidatedBy returns the ID of the Allychain validating the blockchain with this ID
	BlockchainID ids.ID `json:"blockchainID"`
}

type ValidatedByResponse struct {
	// ID of the Allychain validating the specified blockchain
	AllychainID ids.ID `json:"allychainID"`
}

type ValidatesArgs struct {
	AllychainID ids.ID `json:"allychainID"`
}

type ValidatesResponse struct {
	BlockchainIDs []ids.ID `json:"blockchainIDs"`
}

type ValidatorState interface {
	CurrentStakerChainState() currentStakerChainState
	PendingStakerChainState() pendingStakerChainState
}

type ValidatorWeightDiff struct {
	Decrease bool   `serialize:"true"`
	Amount   uint64 `serialize:"true"`
}

type VersionedState interface {
	MutableState

	SetBase(MutableState)
	Apply(InternalState)
}