contracts

type Alerts interface {
	Register(alerts.Alert)
	Dismiss(...types.Hash256)
}

type ChainManager interface {
	TipState() consensus.State
	IndexAtHeight(height uint64) (types.ChainIndex, error)
	Subscribe(s modules.ConsensusSetSubscriber, ccID modules.ConsensusChangeID, cancel <-chan struct{}) error
}

type Contract struct {
	SignedRevision

	Status           ContractStatus `json:"status"`
	LockedCollateral types.Currency `json:"lockedCollateral"`
	Usage            Usage          `json:"usage"`

	// NegotiationHeight is the height the contract was negotiated at.
	NegotiationHeight uint64 `json:"negotiationHeight"`
	// FormationConfirmed is true if the contract formation transaction
	// has been confirmed on the blockchain.
	FormationConfirmed bool `json:"formationConfirmed"`
	// RevisionConfirmed is true if the contract revision transaction has
	// been confirmed on the blockchain.
	RevisionConfirmed bool `json:"revisionConfirmed"`
	// ResolutionHeight is the height the storage proof was confirmed
	// at. If the contract has not been resolved, the field is the zero
	// value.
	ResolutionHeight uint64 `json:"resolutionHeight"`
	// RenewedTo is the ID of the contract that renewed this contract. If
	// this contract was not renewed, this field is the zero value.
	RenewedTo types.FileContractID `json:"renewedTo"`
	// RenewedFrom is the ID of the contract that this contract renewed. If
	// this contract is not a renewal, the field is the zero value.
	RenewedFrom types.FileContractID `json:"renewedFrom"`
}

type ContractFilter struct {
	// filters
	Statuses    []ContractStatus       `json:"statuses"`
	ContractIDs []types.FileContractID `json:"contractIDs"`
	RenewedFrom []types.FileContractID `json:"renewedFrom"`
	RenewedTo   []types.FileContractID `json:"renewedTo"`
	RenterKey   []types.PublicKey      `json:"renterKey"`

	MinNegotiationHeight uint64 `json:"minNegotiationHeight"`
	MaxNegotiationHeight uint64 `json:"maxNegotiationHeight"`

	MinExpirationHeight uint64 `json:"minExpirationHeight"`
	MaxExpirationHeight uint64 `json:"maxExpirationHeight"`

	// pagination
	Limit  int `json:"limit"`
	Offset int `json:"offset"`

	// sorting
	SortField string `json:"sortField"`
	SortDesc  bool   `json:"sortDesc"`
}

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

type ContractStatus uint8

type ContractStore interface {
	LastContractChange() (id modules.ConsensusChangeID, err error)
	// Contracts returns a paginated list of contracts sorted by expiration
	// asc.
	Contracts(ContractFilter) ([]Contract, int, error)
	// Contract returns the contract with the given ID.
	Contract(types.FileContractID) (Contract, error)
	// ContractFormationSet returns the formation transaction set for the
	// contract with the given ID.
	ContractFormationSet(types.FileContractID) ([]types.Transaction, error)
	// ExpireContract is used to mark a contract as complete. It should only
	// be used on active or pending contracts.
	ExpireContract(types.FileContractID, ContractStatus) error
	// Add stores the provided contract, should error if the contract
	// already exists in the store.
	AddContract(revision SignedRevision, formationSet []types.Transaction, lockedCollateral types.Currency, initialUsage Usage, negotationHeight uint64) error
	// RenewContract renews a contract. It is expected that the existing
	// contract will be cleared.
	RenewContract(renewal SignedRevision, existing SignedRevision, formationSet []types.Transaction, lockedCollateral types.Currency, clearingUsage, initialUsage Usage, negotationHeight uint64) error
	// SectorRoots returns the sector roots for a contract. If limit is 0, all roots
	// are returned.
	SectorRoots(id types.FileContractID) ([]types.Hash256, error)
	// ContractAction calls contractFn on every contract in the store that
	// needs a lifecycle action performed.
	ContractAction(height uint64, contractFn func(types.FileContractID, uint64, string)) error
	// ReviseContract atomically updates a contract and its associated
	// sector roots.
	ReviseContract(revision SignedRevision, oldRoots []types.Hash256, usage Usage, sectorChanges []SectorChange) error
	// UpdateContractState atomically updates the contract manager's state.
	UpdateContractState(modules.ConsensusChangeID, uint64, func(UpdateStateTransaction) error) error
	// ExpireContractSectors removes sector roots for any contracts that are
	// past their proof window.
	ExpireContractSectors(height uint64) error
}

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

type IntegrityResult struct {
	ExpectedRoot types.Hash256 `json:"expectedRoot"`
	ActualRoot   types.Hash256 `json:"actualRoot"`
	Error        error         `json:"error"`
}

type SectorAction string

type SectorChange struct {
	Action SectorAction
	Root   types.Hash256
	A, B   uint64
}

type SignedRevision struct {
	Revision types.FileContractRevision `json:"revision"`

	HostSignature   types.Signature `json:"hostSignature"`
	RenterSignature types.Signature `json:"renterSignature"`
}

type StorageManager interface {
	// Read reads a sector from the store
	Read(root types.Hash256) (*[rhp2.SectorSize]byte, error)
}

type TransactionPool interface {
	AcceptTransactionSet([]types.Transaction) error
	RecommendedFee() types.Currency
}

type UpdateStateTransaction interface {
	ContractRelevant(types.FileContractID) (bool, error)

	ConfirmFormation(types.FileContractID) error
	ConfirmRevision(types.FileContractRevision) error
	ConfirmResolution(id types.FileContractID, height uint64) error

	RevertFormation(types.FileContractID) error
	RevertRevision(types.FileContractID) error
	RevertResolution(types.FileContractID) error
}

type Usage struct {
	RPCRevenue       types.Currency `json:"rpc"`
	StorageRevenue   types.Currency `json:"storage"`
	EgressRevenue    types.Currency `json:"egress"`
	IngressRevenue   types.Currency `json:"ingress"`
	RegistryRead     types.Currency `json:"registryRead"`
	RegistryWrite    types.Currency `json:"registryWrite"`
	AccountFunding   types.Currency `json:"accountFunding"`
	RiskedCollateral types.Currency `json:"riskedCollateral"`
}

type Wallet interface {
	Address() types.Address
	UnlockConditions() types.UnlockConditions
	FundTransaction(txn *types.Transaction, amount types.Currency) (toSign []types.Hash256, release func(), err error)
	SignTransaction(cs consensus.State, txn *types.Transaction, toSign []types.Hash256, cf types.CoveredFields) error
}