modules

type Alert struct {
	// Cause is the cause for the Alert.
	// e.g. "Wallet is locked"
	Cause string `json:"cause"`
	// Msg is the message the Alert is meant to convey to the user.
	// e.g. "Contractor can't form new contracts".
	Msg string `json:"msg"`
	// Module contains information about what module the alert originated from.
	Module string `json:"module"`
	// Severity categorizes the Alerts to allow for an easy way to filter them.
	Severity AlertSeverity `json:"severity"`
}

type AlertID string

type AlertSeverity uint64

type Alerter interface {
	Alerts() (crit, err, warn, info []Alert)
}

type Allowance struct {
	Funds       types.Currency
	Hosts       uint64
	Period      uint64
	RenewWindow uint64

	// ExpectedStorage is the amount of data that we expect to have in a contract.
	ExpectedStorage uint64

	// ExpectedUpload is the expected amount of data uploaded through the API,
	// before redundancy, per block.
	ExpectedUpload uint64

	// ExpectedDownload is the expected amount of data downloaded through the
	// API per block.
	ExpectedDownload uint64

	// Erasure coding parameters.
	MinShards   uint64
	TotalShards uint64

	// The following fields provide price gouging protection for the user. By
	// setting a particular maximum price for each mechanism that a host can use
	// to charge users, the workers know to avoid hosts that go outside of the
	// safety range.
	MaxRPCPrice               types.Currency
	MaxContractPrice          types.Currency
	MaxDownloadBandwidthPrice types.Currency
	MaxSectorAccessPrice      types.Currency
	MaxStoragePrice           types.Currency
	MaxUploadBandwidthPrice   types.Currency
	MinMaxCollateral          types.Currency
	BlockHeightLeeway         uint64

	// UploadPacking indicates whether the upload packing is turned on.
	UploadPacking bool
}

type BucketFiles struct {
	Name  []byte   `json:"name"`
	Paths [][]byte `json:"paths"`
}

type ConsensusChange struct {
	// ID is a unique id for the consensus change derived from the reverted
	// and applied blocks.
	ID ConsensusChangeID

	// BlockHeight is the height of the chain after all blocks included in
	// this change have been reverted and applied.
	BlockHeight uint64

	// RevertedBlocks is the list of blocks that were reverted by the change.
	// The reverted blocks were always all reverted before the applied blocks
	// were applied. The revered blocks are presented in the order that they
	// were reverted.
	RevertedBlocks []types.Block

	// AppliedBlocks is the list of blocks that were applied by the change. The
	// applied blocks are always all applied after all the reverted blocks were
	// reverted. The applied blocks are presented in the order that they were
	// applied.
	AppliedBlocks []types.Block

	// RevertedDiffs is the set of diffs caused by reverted blocks. Each
	// element corresponds to a block in RevertedBlocks.
	RevertedDiffs []ConsensusChangeDiffs

	// AppliedDiffs is the set of diffs caused by applied blocks. Each
	// element corresponds to a block in AppliedBlocks.
	AppliedDiffs []ConsensusChangeDiffs

	// ConsensusChangeDiffs is the concatenation of all RevertedDiffs and
	// AppliedDiffs.
	ConsensusChangeDiffs

	// ChildTarget defines the target of any block that would be the child
	// of the block most recently appended to the consensus set.
	ChildTarget Target

	// MinimumValidChildTimestamp defines the minimum allowed timestamp for
	// any block that is the child of the block most recently appended to
	// the consensus set.
	MinimumValidChildTimestamp time.Time

	// Synced indicates whether or not the ConsensusSet is synced with its
	// peers.
	Synced bool

	// TryTransactionSet is an unlocked version of
	// ConsensusSet.TryTransactionSet. This allows the TryTransactionSet
	// function to be called by a subscriber during
	// ProcessConsensusChange.
	TryTransactionSet func([]types.Transaction) (ConsensusChange, error)
}

type ConsensusChangeDiffs struct {
	SiacoinOutputDiffs        []SiacoinOutputDiff
	FileContractDiffs         []FileContractDiff
	SiafundOutputDiffs        []SiafundOutputDiff
	DelayedSiacoinOutputDiffs []DelayedSiacoinOutputDiff
	SiafundPoolDiffs          []SiafundPoolDiff
}

type ConsensusChangeID types.Hash256

type ConsensusConflict string

type ConsensusSet interface {
	Alerter

	// AcceptBlock adds a block to consensus. An error will be returned if the
	// block is invalid, has been seen before, is an orphan, or doesn't
	// contribute to the heaviest fork known to the consensus set. If the block
	// does not become the head of the heaviest known fork but is otherwise
	// valid, it will be remembered by the consensus set but an error will
	// still be returned.
	AcceptBlock(types.Block) error

	// BlockAtHeight returns the block found at the input height, with a
	// bool to indicate whether that block exists.
	BlockAtHeight(uint64) (types.Block, bool)

	// BlocksByID returns a block found for a given ID and its height, with
	// a bool to indicate whether that block exists.
	BlockByID(types.BlockID) (types.Block, uint64, bool)

	// ChildTarget returns the target required to extend the current heaviest
	// fork. This function is typically used by miners looking to extend the
	// heaviest fork.
	ChildTarget(types.BlockID) (Target, bool)

	// Close will shut down the consensus set, giving the module enough time to
	// run any required closing routines.
	Close() error

	// ConsensusSetSubscribe adds a subscriber to the list of subscribers
	// and gives them every consensus change that has occurred since the
	// change with the provided id. There are a few special cases,
	// described by the ConsensusChangeX variables in this package.
	// A channel can be provided to abort the subscription process.
	ConsensusSetSubscribe(ConsensusSetSubscriber, ConsensusChangeID, <-chan struct{}) error

	// CurrentBlock returns the latest block in the heaviest known
	// blockchain.
	CurrentBlock() types.Block

	// Height returns the current height of consensus.
	Height() uint64

	// Synced returns true if the consensus set is synced with the network.
	Synced() bool

	// InCurrentPath returns true if the block id presented is found in the
	// current path, false otherwise.
	InCurrentPath(types.BlockID) bool

	// MinimumValidChildTimestamp returns the earliest timestamp that is
	// valid on the current longest fork according to the consensus set. This is
	// a required piece of information for the miner, who could otherwise be at
	// risk of mining invalid blocks.
	MinimumValidChildTimestamp(types.BlockID) (time.Time, bool)

	// StorageProofSegment returns the segment to be used in the storage proof for
	// a given file contract.
	StorageProofSegment(types.FileContractID) (uint64, error)

	// FoundationUnlockHashes returns the current primary and failsafe
	// Foundation UnlockHashes.
	FoundationUnlockHashes() (primary, failsafe types.Address)

	// TryTransactionSet checks whether the transaction set would be valid if
	// it were added in the next block. A consensus change is returned
	// detailing the diffs that would result from the application of the
	// transaction.
	TryTransactionSet([]types.Transaction) (ConsensusChange, error)

	// Unsubscribe removes a subscriber from the list of subscribers,
	// allowing for garbage collection and rescanning. If the subscriber is
	// not found in the subscriber database, no action is taken.
	Unsubscribe(ConsensusSetSubscriber)
}

type ConsensusSetSubscriber interface {
	// ProcessConsensusChange sends a consensus update to a module through
	// a function call. Updates will always be sent in the correct order.
	// There may not be any reverted blocks, but there will always be
	// applied blocks.
	ProcessConsensusChange(ConsensusChange)
}

type ContractMetadata struct {
	ID      types.FileContractID
	HostKey types.PublicKey

	StartHeight uint64
	RenewedFrom types.FileContractID

	UploadSpending      types.Currency
	DownloadSpending    types.Currency
	FundAccountSpending types.Currency
	ContractPrice       types.Currency
	TotalCost           types.Currency

	Revision types.FileContractRevision
}

type ContractUtility struct {
	GoodForUpload bool
	GoodForRenew  bool

	// BadContract will be set to true if there's good reason to believe that
	// the contract is unusable and will continue to be unusable. For example,
	// if the host is claiming that the contract does not exist, the contract
	// should be marked as bad.
	BadContract bool
	LastOOSErr  uint64 // OOS means Out Of Storage.

	// If a contract is locked, the utility should not be updated. 'Locked' is a
	// value that gets persisted.
	Locked bool
}

type ContractWatchStatus struct {
	Archived                  bool
	FormationSweepHeight      uint64
	ContractFound             bool
	LatestRevisionFound       uint64
	StorageProofFoundAtHeight uint64
	DoubleSpendHeight         uint64
	WindowStart               uint64
	WindowEnd                 uint64
}

type CreditData struct {
	Amount    float64 `json:"amount"`
	Remaining uint64  `json:"remaining"`
}

type DelayedSiacoinOutputDiff struct {
	Direction      DiffDirection
	ID             types.SiacoinOutputID
	SiacoinOutput  types.SiacoinOutput
	MaturityHeight uint64
}

type DiffDirection bool

type EncryptionManager interface {
	// Encrypt will encrypt the wallet using the input key. Upon
	// encryption, a primary seed will be created for the wallet (no seed
	// exists prior to this point). If the key is blank, then the hash of
	// the seed that is generated will be used as the key.
	//
	// Encrypt can only be called once throughout the life of the wallet
	// and will return an error on subsequent calls (even after restarting
	// the wallet). To reset the wallet, the wallet must be deleted.
	Encrypt(masterKey WalletKey) (Seed, error)

	// Reset will reset the wallet, clearing the database and returning it to
	// the unencrypted state. Reset can only be called on a wallet that has
	// already been encrypted.
	Reset() error

	// Encrypted returns whether or not the wallet has been encrypted yet.
	// After being encrypted for the first time, the wallet can only be
	// unlocked using the encryption password.
	Encrypted() (bool, error)

	// InitFromSeed functions like Encrypt, but using a specified seed.
	// Unlike Encrypt, the blockchain will be scanned to determine the
	// seed's progress. For this reason, InitFromSeed should not be called
	// until the blockchain is fully synced.
	InitFromSeed(masterKey WalletKey, seed Seed) error

	// Lock deletes all keys in memory and prevents the wallet from being
	// used to spend coins or extract keys until 'Unlock' is called.
	Lock() error

	// Unlock must be called before the wallet is usable. All wallets and
	// wallet seeds are encrypted by default, and the wallet will not know
	// which addresses to watch for on the blockchain until unlock has been
	// called.
	//
	// All items in the wallet are encrypted using different keys which are
	// derived from the master key.
	Unlock(masterKey WalletKey) error

	// UnlockAsync must be called before the wallet is usable. All wallets and
	// wallet seeds are encrypted by default, and the wallet will not know
	// which addresses to watch for on the blockchain until unlock has been
	// called.
	// UnlockAsync will return a channel as soon as the wallet is unlocked but
	// before the wallet is caught up to consensus.
	//
	// All items in the wallet are encrypted using different keys which are
	// derived from the master key.
	UnlockAsync(masterKey WalletKey) <-chan error

	// ChangeKey changes the wallet's materKey from masterKey to newKey,
	// re-encrypting the wallet with the provided key.
	ChangeKey(masterKey WalletKey, newKey WalletKey) error

	// IsMasterKey verifies that the masterKey is the key used to encrypt
	// the wallet.
	IsMasterKey(masterKey WalletKey) (bool, error)

	// ChangeKeyWithSeed is the same as ChangeKey but uses the primary seed
	// instead of the current masterKey.
	ChangeKeyWithSeed(seed Seed, newKey WalletKey) error

	// Unlocked returns true if the wallet is currently unlocked, false
	// otherwise.
	Unlocked() (bool, error)
}

type ExtendedContract struct {
	Contract            rhpv2.ContractRevision
	StartHeight         uint64
	ContractPrice       types.Currency
	TotalCost           types.Currency
	UploadSpending      types.Currency
	DownloadSpending    types.Currency
	FundAccountSpending types.Currency
	RenewedFrom         types.FileContractID
}

type ExtendedContractSet struct {
	Contracts []ExtendedContract
}

type FileContractDiff struct {
	Direction    DiffDirection
	ID           types.FileContractID
	FileContract types.FileContract
}

type FileMetadata struct {
	Key       types.Hash256 `json:"key"`
	Bucket    []byte        `json:"bucket"`
	Path      []byte        `json:"path"`
	ETag      string        `json:"etag"`
	MimeType  []byte        `json:"mime"`
	Encrypted string        `json:"encrypted"`
	Slabs     []Slab        `json:"slabs"`
	Data      []byte        `json:"data"`
}

type FilterMode int

type Gateway interface {
	Alerter

	// Connect establishes a persistent connection to a peer.
	Connect(NetAddress) error

	// ConnectManual is a Connect wrapper for a user-initiated Connect.
	ConnectManual(NetAddress) error

	// Disconnect terminates a connection to a peer.
	Disconnect(NetAddress) error

	// DiscoverAddress discovers and returns the current public IP address
	// of the gateway. Contrary to Address, DiscoverAddress is blocking and
	// might take multiple minutes to return. A channel to cancel the
	// discovery can be supplied optionally.
	DiscoverAddress(cancel <-chan struct{}) (net.IP, error)

	// ForwardPort adds a port mapping to the router. It will block until
	// the mapping is established or until it is interrupted by a shutdown.
	ForwardPort(port string) error

	// DisconnectManual is a Disconnect wrapper for a user-initiated
	// disconnect.
	DisconnectManual(NetAddress) error

	// AddToBlocklist adds addresses to the blocklist of the gateway.
	AddToBlocklist(addresses []string) error

	// Blocklist returns the current blocklist of the Gateway.
	Blocklist() ([]string, error)

	// RemoveFromBlocklist removes addresses from the blocklist of the
	// gateway.
	RemoveFromBlocklist(addresses []string) error

	// SetBlocklist sets the blocklist of the gateway.
	SetBlocklist(addresses []string) error

	// Address returns the Gateway's address.
	Address() NetAddress

	// Peers returns the addresses that the Gateway is currently connected
	// to.
	Peers() []Peer

	// RegisterRPC registers a function to handle incoming connections that
	// supply the given RPC ID.
	RegisterRPC(string, RPCFunc)

	// UnregisterRPC unregisters an RPC and removes all references to the
	// RPCFunc supplied in the corresponding RegisterRPC call. References to
	// RPCFuncs registered with RegisterConnectCall are not removed and
	// should be removed with UnregisterConnectCall. If the RPC does not
	// exist no action is taken.
	UnregisterRPC(string)

	// RegisterConnectCall registers an RPC name and function to be called
	// upon connecting to a peer.
	RegisterConnectCall(string, RPCFunc)

	// UnregisterConnectCall unregisters an RPC and removes all references to the
	// RPCFunc supplied in the corresponding RegisterConnectCall call. References
	// to RPCFuncs registered with RegisterRPC are not removed and should be
	// removed with UnregisterRPC. If the RPC does not exist no action is taken.
	UnregisterConnectCall(string)

	// RPC calls an RPC on the given address. RPC cannot be called on an
	// address that the Gateway is not connected to.
	RPC(NetAddress, string, RPCFunc) error

	// Broadcast transmits obj, prefaced by the RPC name, to all of the
	// given peers in parallel.
	Broadcast(name string, obj types.EncoderTo, peers []Peer)

	// Online returns true if the gateway is connected to remote hosts.
	Online() bool

	// Close safely stops the Gateway's listener process.
	Close() error
}

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

type HostAverages struct {
	NumHosts               uint64         `json:"numhosts"`
	Duration               uint64         `json:"duration"`
	StoragePrice           types.Currency `json:"storageprice"`
	Collateral             types.Currency `json:"collateral"`
	DownloadBandwidthPrice types.Currency `json:"downloadbandwidthprice"`
	UploadBandwidthPrice   types.Currency `json:"uploadbandwidthprice"`
	ContractPrice          types.Currency `json:"contractprice"`
	BaseRPCPrice           types.Currency `json:"baserpcprice"`
	SectorAccessPrice      types.Currency `json:"sectoraccessprice"`
}

type HostDB interface {
	Alerter

	// ActiveHosts returns the list of hosts that are actively being selected
	// from.
	ActiveHosts() ([]HostDBEntry, error)

	// AllHosts returns the full list of hosts known to the hostdb, sorted in
	// order of preference.
	AllHosts() ([]HostDBEntry, error)

	// CheckForIPViolations accepts a number of host public keys and returns the
	// ones that violate the rules of the addressFilter.
	CheckForIPViolations([]types.PublicKey) ([]types.PublicKey, error)

	// Close closes the hostdb.
	Close() error

	// EstimateHostScore returns the estimated score breakdown of a host with the
	// provided settings.
	EstimateHostScore(Allowance, HostDBEntry) (HostScoreBreakdown, error)

	// Filter returns the hostdb's filterMode and filteredHosts.
	Filter() (FilterMode, map[string]types.PublicKey, []string, error)

	// SetFilterMode sets the renter's hostdb filter mode.
	SetFilterMode(FilterMode, []types.PublicKey, []string) error

	// Host returns the HostDBEntry for a given host.
	Host(pk types.PublicKey) (HostDBEntry, bool, error)

	// IncrementSuccessfulInteractions increments the number of successful
	// interactions with a host for a given key
	IncrementSuccessfulInteractions(types.PublicKey) error

	// IncrementFailedInteractions increments the number of failed interactions with
	// a host for a given key
	IncrementFailedInteractions(types.PublicKey) error

	// initialScanComplete returns a boolean indicating if the initial scan of the
	// hostdb is completed and the current block height of the hostdb.
	InitialScanComplete() (bool, uint64, error)

	// IPViolationsCheck returns a boolean indicating if the IP violation check is
	// enabled or not.
	IPViolationsCheck() (bool, error)

	// RandomHosts returns a set of random hosts, weighted by their estimated
	// usefulness / attractiveness to the renter. RandomHosts will not return
	// any offline or inactive hosts.
	RandomHosts(int, []types.PublicKey, []types.PublicKey) ([]HostDBEntry, error)

	// RandomHostsWithAllowance is the same as RandomHosts but accepts an
	// allowance as an argument to be used instead of the allowance set in the
	// manager.
	RandomHostsWithAllowance(int, []types.PublicKey, []types.PublicKey, Allowance) ([]HostDBEntry, error)

	// ScoreBreakdown returns a detailed explanation of the various properties
	// of the host.
	ScoreBreakdown(HostDBEntry) (HostScoreBreakdown, error)

	// SetAllowance updates the allowance used by the hostdb for weighing hosts by
	// updating the host weight function. It will completely rebuild the hosttree so
	// it should be used with care.
	SetAllowance(Allowance) error

	// SetIPViolationCheck enables/disables the IP violation check within the
	// hostdb.
	SetIPViolationCheck(enabled bool) error

	// LoadingComplete indicates if the HostDB has finished loading the hosts
	// from the database.
	LoadingComplete() bool

	// UpdateContracts rebuilds the knownContracts of the HostBD using the
	// provided contracts.
	UpdateContracts([]RenterContract) error
}

type HostDBEntry struct {
	// Need to wrap rhpv2.HostSettings in a separate named field due to
	// issues with JSON encoding.
	Settings   rhpv2.HostSettings   `json:"settings"`
	PriceTable rhpv3.HostPriceTable `json:"pricetable"`

	// FirstSeen is the first block height at which this host was announced.
	FirstSeen uint64 `json:"firstseen"`

	// LastAnnouncement is the last block height at which this host was announced.
	LastAnnouncement uint64 `json:"lastannouncement"`

	// Measurements that have been taken on the host. The most recent
	// measurements are kept in full detail, historic ones are compressed into
	// the historic values.
	HistoricDowntime time.Duration `json:"historicdowntime"`
	HistoricUptime   time.Duration `json:"historicuptime"`
	ScanHistory      HostDBScans   `json:"scanhistory"`

	// Measurements that are taken whenever we interact with a host.
	HistoricFailedInteractions     float64 `json:"historicfailedinteractions"`
	HistoricSuccessfulInteractions float64 `json:"historicsuccessfulinteractions"`
	RecentFailedInteractions       float64 `json:"recentfailedinteractions"`
	RecentSuccessfulInteractions   float64 `json:"recentsuccessfulinteractions"`

	LastHistoricUpdate uint64 `json:"lasthistoricupdate"`

	// Measurements related to the IP subnet mask.
	IPNets          []string  `json:"ipnets"`
	LastIPNetChange time.Time `json:"lastipnetchange"`

	// The public key of the host, stored separately to minimize risk of certain
	// MitM based vulnerabilities.
	PublicKey types.PublicKey `json:"publickey"`

	// Filtered says whether or not a HostDBEntry is being filtered out of the
	// filtered hosttree due to the filter mode of the hosttree.
	Filtered bool `json:"filtered"`
}

type HostDBScan struct {
	Timestamp time.Time `json:"timestamp"`
	Success   bool      `json:"success"`
}

type HostDBScans []HostDBScan

type HostScoreBreakdown struct {
	Score            types.Currency `json:"score"`
	Age              float64        `json:"agescore"`
	Collateral       float64        `json:"collateralscore"`
	Interactions     float64        `json:"interactionscore"`
	StorageRemaining float64        `json:"storageremainingscore"`
	Uptime           float64        `json:"uptimescore"`
	Version          float64        `json:"versionscore"`
	Prices           float64        `json:"pricescore"`
}

type KeyManager interface {
	// AllAddresses returns all addresses that the wallet is able to spend
	// from, including unseeded addresses. Addresses are returned sorted in
	// byte-order.
	AllAddresses() ([]types.Address, error)

	// AllSeeds returns all of the seeds that are being tracked by the
	// wallet, including the primary seed. Only the primary seed is used to
	// generate new addresses, but the wallet can spend funds sent to
	// public keys generated by any of the seeds returned.
	AllSeeds() ([]Seed, error)

	// LastAddresses returns the last n addresses starting at the last seedProgress
	// for which an address was generated.
	LastAddresses(n uint64) ([]types.Address, error)

	// LoadSeed will recreate a wallet file using the recovery phrase.
	// LoadSeed only needs to be called if the original seed file or
	// encryption password was lost. The master key is used to encrypt the
	// recovery seed before saving it to disk.
	LoadSeed(WalletKey, Seed) error

	// MarkAddressUnused marks the provided address as unused which causes it to be
	// handed out by a subsequent call to `NextAddresses` again.
	MarkAddressUnused(...types.UnlockConditions) error

	// NextAddress returns a new coin address generated from the
	// primary seed.
	NextAddress() (types.UnlockConditions, error)

	// NextAddresses returns n new coin addresses generated from the
	// primary seed.
	NextAddresses(uint64) ([]types.UnlockConditions, error)

	// PrimarySeed returns the unencrypted primary seed of the wallet,
	// along with a uint64 indicating how many addresses may be safely
	// generated from the seed.
	PrimarySeed() (Seed, uint64, error)

	// SignTransaction adds a signature to each of the specified inputs.
	SignTransaction(txn *types.Transaction, toSign []types.Hash256, cf types.CoveredFields) error

	// SweepSeed scans the blockchain for outputs generated from seed and
	// creates a transaction that transfers them to the wallet. Note that
	// this incurs a transaction fee. It returns the total value of the
	// outputs, minus the fee. If only Siafunds were found, the fee is
	// deducted from the wallet.
	SweepSeed(seed Seed) (coins types.Currency, funds uint64, err error)
}

type MaintenanceSpending struct {
	AccountBalanceCost   types.Currency
	FundAccountCost      types.Currency
	UpdatePriceTableCost types.Currency
}

type Manager interface {
	Alerter

	// AcceptContracts accepts a set of contracts from the renter
	// and adds them to the contract set.
	AcceptContracts(types.PublicKey, []ContractMetadata)

	// ActiveHosts returns an array of HostDB's active hosts.
	ActiveHosts() ([]HostDBEntry, error)

	// AllHosts returns an array of all hosts.
	AllHosts() ([]HostDBEntry, error)

	// AssembleParts puts together the parts of a multipart upload and
	// marks the resulting file as pending upload.
	AssembleParts(types.PublicKey, types.Hash256) error

	// BlockHeight returns the current block height.
	BlockHeight() uint64

	// BufferedFilesDir returns the path to the buffered files directory.
	BufferedFilesDir() string

	// BytesUploaded returns the size of the file already uploaded.
	BytesUploaded(types.PublicKey, []byte, []byte) (string, uint64, error)

	// Close safely shuts down the manager.
	Close() error

	// Contracts returns storage contracts.
	Contracts() []RenterContract

	// ContractsByRenter returns storage contracts filtered by the renter.
	ContractsByRenter(types.PublicKey) []RenterContract

	// CreateNewRenter inserts a new renter into the map.
	CreateNewRenter(string, types.PublicKey)

	// DeleteBufferedFile deletes the specified file and the associated
	// database record.
	DeleteBufferedFile(types.PublicKey, []byte, []byte) error

	// DeleteBufferedFiles deletes the files waiting to be uploaded.
	DeleteBufferedFiles(types.PublicKey) error

	// DeleteMetadata deletes the renter's saved file metadata.
	DeleteMetadata(types.PublicKey) error

	// DeleteMultipart deletes an aborted multipart upload.
	DeleteMultipart(types.PublicKey, types.Hash256) error

	// DeleteMultipartUploads deletes the unfinished multipart uploads.
	DeleteMultipartUploads(types.PublicKey) error

	// DeleteObject deletes the saved file metadata object.
	DeleteObject(types.PublicKey, []byte, []byte) error

	// DeleteRenter deletes the renter data from the memory.
	DeleteRenter(string)

	// DownloadObject downloads an object and returns it.
	DownloadObject(io.Writer, types.PublicKey, []byte, []byte) error

	// FeeEstimation returns the minimum and the maximum estimated fees for
	// a transaction.
	FeeEstimation() (types.Currency, types.Currency)

	// Filter returns the HostDB's filterMode and filteredHosts.
	Filter() (FilterMode, map[string]types.PublicKey, []string, error)

	// FormContract forms a contract with the specified host.
	FormContract(*RPCSession, types.PublicKey, types.PublicKey, types.PublicKey, uint64, uint64, uint64, uint64, uint64, uint64) (RenterContract, error)

	// FormContracts forms the required number of contracts with the hosts.
	FormContracts(types.PublicKey, types.PrivateKey, Allowance) ([]RenterContract, error)

	// GetAverages retrieves the host network averages.
	GetAverages() HostAverages

	// GetBalance retrieves the balance information on the account.
	GetBalance(string) (UserBalance, error)

	// GetBufferSize returns the total size of the temporary files.
	GetBufferSize() (uint64, error)

	// GetEmailPreferences returns the email preferences.
	GetEmailPreferences() (string, types.Currency)

	// GetModifiedSlabs returns the slabs modified since the last retrieval.
	GetModifiedSlabs(types.PublicKey) ([]Slab, error)

	// GetRenter returns the renter by the public key.
	GetRenter(types.PublicKey) (Renter, error)

	// GetSiacoinRate calculates the SC price in a given currency.
	GetSiacoinRate(string) (float64, error)

	// GetSpendings retrieves the user's spendings.
	GetSpendings(string, int, int) (UserSpendings, error)

	// GetWalletSeed returns the wallet seed.
	GetWalletSeed() (Seed, error)

	// Host returns the host associated with the given public key.
	Host(types.PublicKey) (HostDBEntry, bool, error)

	// IncrementStats increments the number of formed or renewed contracts.
	IncrementStats(string, bool) error

	// InitialScanComplete returns a boolean indicating if the initial scan of the
	// HostDB is completed.
	InitialScanComplete() (bool, uint64, error)

	// LockSiacoins moves a part of the balance to "locked".
	LockSiacoins(string, float64) error

	// Maintenance returns true if the maintenance mode is active.
	Maintenance() bool

	// OldContracts returns the contracts that have expired.
	OldContracts() []RenterContract

	// OldContractsByRenter returns expired contracts filtered by the renter.
	OldContractsByRenter(types.PublicKey) []RenterContract

	// PutMultipartPart associates the uploaded file with the part of
	// a multipart upload.
	PutMultipartPart(types.PublicKey, types.Hash256, int, string) error

	// RandomHosts picks up to the specified number of random hosts from the
	// hostdb sorted by weight.
	RandomHosts(uint64, Allowance) ([]HostDBEntry, error)

	// RefreshedContract returns a bool indicating if the contract was refreshed.
	RefreshedContract(types.FileContractID) bool

	// RegisterMultipart registers a new multipart upload.
	RegisterMultipart(types.PublicKey, types.Hash256, []byte, []byte, []byte, bool) (types.Hash256, error)

	// RegisterUpload associates the uploaded file with the object.
	RegisterUpload(types.PublicKey, []byte, []byte, []byte, bool, string, bool) error

	// RenewContract renews a contract.
	RenewContract(*RPCSession, types.PublicKey, types.FileContractID, uint64, uint64, uint64, uint64, uint64, uint64) (RenterContract, error)

	// RenewContracts renews a set of contracts and returns a new set.
	RenewContracts(types.PublicKey, types.PrivateKey, Allowance, []types.FileContractID) ([]RenterContract, error)

	// RenewedFrom returns the ID of the contract the given contract was renewed
	// from, if any.
	RenewedFrom(types.FileContractID) types.FileContractID

	// Renters retrieves the list of renters.
	Renters() []Renter

	// RetrieveMetadata retrieves the file metadata from the database.
	RetrieveMetadata(types.PublicKey, []BucketFiles) ([]FileMetadata, error)

	// RetrieveSpendings retrieves the user's spendings for the current and
	// the previous months in the specified currency.
	RetrieveSpendings(string, string) ([]UserSpendings, error)

	// ScoreBreakdown returns the score breakdown of the specific host.
	ScoreBreakdown(HostDBEntry) (HostScoreBreakdown, error)

	// SetAllowance sets the renter's allowance.
	SetAllowance(types.PublicKey, Allowance) error

	// SetEmailPreferences changes the email preferences.
	SetEmailPreferences(string, types.Currency) error

	// SetFilterMode sets the HostDB's filter mode.
	SetFilterMode(FilterMode, []types.PublicKey, []string) error

	// StartMaintenance switches the maintenance mode on and off.
	StartMaintenance(bool) error

	// UnlockSiacoins moves a part of the amount from "locked" to "available",
	// while the other part (fees and other spent funds) is "burned".
	UnlockSiacoins(string, float64, float64, uint64) error

	// UpdateBalance updates the balance information on the account.
	UpdateBalance(string, UserBalance) error

	// UpdateContract updates the contract with the new revision and spending
	// details.
	UpdateContract(types.FileContractRevision, []types.TransactionSignature, types.Currency, types.Currency, types.Currency) error

	// UpdateMetadata updates the file metadata in the database.
	UpdateMetadata(types.PublicKey, FileMetadata) error

	// UpdatePrices updates the pricing table in the database.
	UpdatePrices(Pricing) error

	// UpdateRenterSettings updates the renter's opt-in settings.
	UpdateRenterSettings(types.PublicKey, RenterSettings, types.PrivateKey, types.PrivateKey) error

	// UpdateSlab updates a file slab after a successful migration.
	UpdateSlab(types.PublicKey, Slab, bool) error

	// UpdateSpendings updates the user's spendings.
	UpdateSpendings(string, UserSpendings, int, int) error
}

type MerkleTree struct {
	merkletree.Tree
}

type NetAddress string

type Peer struct {
	Inbound    bool       `json:"inbound"`
	Local      bool       `json:"local"`
	NetAddress NetAddress `json:"netaddress"`
	Version    string     `json:"version"`
}

type PeerConn interface {
	net.Conn
	RPCAddr() NetAddress
}

type Portal interface {
	Alerter

	// Close safely shuts down the portal.
	Close() error

	// GetAnnouncement returns the current portal announcement.
	GetAnnouncement() (string, uint64, error)

	// GetCredits retrieves the promotion data.
	GetCredits() CreditData

	// SetAnnouncement sets a new portal announcement.
	SetAnnouncement(string, uint64) error

	// SetCredits updates the promotion data.
	SetCredits(CreditData)
}

type Price struct {
	PrePayment float64 `json:"prepayment"`
	Invoicing  float64 `json:"invoicing"`
}

type Pricing struct {
	// FormContract is how much the satellite charges for
	// forming or renewing a single contract.
	FormContract Price `json:"formcontract"`

	// SaveMetadata is the fee for saving a single slab
	// metadata.
	SaveMetadata Price `json:"savemetadata"`

	// StoreMetadata is the fee for storing a single slab
	// metadata for one month.
	StoreMetadata Price `json:"storemetadata"`

	// StorePartialData is the fee for storing one MiB of
	// partial slab data for one month.
	StorePartialData Price `json:"storepartialdata"`

	// RetrieveMetadata is the fee for retrieving a single
	// slab metadata.
	RetrieveMetadata Price `json:"retrievemetadata"`

	// MigrateSlab is the fee for migrating a single slab.
	MigrateSlab Price `json:"migrateslab"`
}

type ProcessedInput struct {
	ParentID       types.Hash256   `json:"parentid"`
	FundType       types.Specifier `json:"fundtype"`
	WalletAddress  bool            `json:"walletaddress"`
	RelatedAddress types.Address   `json:"relatedaddress"`
	Value          types.Currency  `json:"value"`
}

type ProcessedOutput struct {
	ID             types.Hash256   `json:"id"`
	FundType       types.Specifier `json:"fundtype"`
	MaturityHeight uint64          `json:"maturityheight"`
	WalletAddress  bool            `json:"walletaddress"`
	RelatedAddress types.Address   `json:"relatedaddress"`
	Value          types.Currency  `json:"value"`
}

type ProcessedTransaction struct {
	Transaction           types.Transaction   `json:"transaction"`
	TransactionID         types.TransactionID `json:"transactionid"`
	ConfirmationHeight    uint64              `json:"confirmationheight"`
	ConfirmationTimestamp time.Time           `json:"confirmationtimestamp"`

	Inputs  []ProcessedInput  `json:"inputs"`
	Outputs []ProcessedOutput `json:"outputs"`
}

type Provider interface {
	Alerter

	// Close safely shuts down the provider.
	Close() error

	// PublicKey returns the provider's public key.
	PublicKey() types.PublicKey

	// SecretKey returns the provider's secret key.
	SecretKey() types.PrivateKey
}

type RPCError struct {
	Type        types.Specifier
	Data        []byte
	Description string
}

type RPCFunc func(PeerConn) error

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

type RPCSession struct {
	Conn      net.Conn
	Aead      cipher.AEAD
	Challenge [16]byte
}

type Renter struct {
	Allowance     Allowance
	CurrentPeriod uint64
	PublicKey     types.PublicKey
	Email         string // Link to the user account.
	Settings      RenterSettings
	PrivateKey    types.PrivateKey
	AccountKey    types.PrivateKey
}

type RenterContract struct {
	ID              types.FileContractID
	HostPublicKey   types.PublicKey
	RenterPublicKey types.PublicKey
	Transaction     types.Transaction

	StartHeight uint64
	EndHeight   uint64

	// RenterFunds is the amount remaining in the contract that the renter can
	// spend.
	RenterFunds types.Currency

	// The FileContract does not indicate what funds were spent on, so we have
	// to track the various costs manually.
	DownloadSpending    types.Currency
	FundAccountSpending types.Currency
	MaintenanceSpending MaintenanceSpending
	StorageSpending     types.Currency
	UploadSpending      types.Currency

	// Utility contains utility information about the renter.
	Utility ContractUtility

	// TotalCost indicates the amount of money that the renter spent and/or
	// locked up while forming a contract. This includes fees, and includes
	// funds which were allocated (but not necessarily committed) to spend on
	// uploads/downloads/storage.
	TotalCost types.Currency

	// ContractFee is the amount of money paid to the host to cover potential
	// future transaction fees that the host may incur, and to cover any other
	// overheads the host may have.
	//
	// TxnFee is the amount of money spent on the transaction fee when putting
	// the renter contract on the blockchain.
	//
	// SiafundFee is the amount of money spent on siafund fees when creating the
	// contract. The siafund fee that the renter pays covers both the renter and
	// the host portions of the contract, and therefore can be unexpectedly high
	// if the the host collateral is high.
	ContractFee types.Currency
	TxnFee      types.Currency
	SiafundFee  types.Currency

	// Imported indicates if the contract was imported via RPCShareContracts.
	Imported bool

	// Unlocked indicates if the contract payout has been unlocked.
	Unlocked bool
}

type RenterSettings struct {
	AutoRenewContracts bool `json:"autorenew"`
	BackupFileMetadata bool `json:"backupmetadata"`
	AutoRepairFiles    bool `json:"autorepair"`
	ProxyUploads       bool `json:"proxyuploads"`
}

type RenterSpending struct {
	// ContractFees are the sum of all fees in the contract. This means it
	// includes the ContractFee, TxnFee and SiafundFee
	ContractFees types.Currency
	// DownloadSpending is the money currently spent on downloads.
	DownloadSpending types.Currency
	// FundAccountSpending is the money used to fund an ephemeral account on the
	// host.
	FundAccountSpending types.Currency
	// MaintenanceSpending is the money spent on maintenance tasks in support of
	// the RHP3 protocol, this includes updating the price table as well as
	// syncing the ephemeral account balance.
	MaintenanceSpending MaintenanceSpending
	// StorageSpending is the money currently spent on storage.
	StorageSpending types.Currency
	// ContractSpending is the total amount of money that the renter has put
	// into contracts, whether it's locked and the renter gets that money
	// back or whether it's spent and the renter won't get the money back.
	TotalAllocated types.Currency
	// UploadSpending is the money currently spent on uploads.
	UploadSpending types.Currency
	// Unspent is locked-away, unspent money.
	Unspent types.Currency
	// WithheldFunds are the funds from the previous period that are tied up
	// in contracts and have not been released yet
	WithheldFunds types.Currency
	// ReleaseBlock is the block at which the WithheldFunds should be
	// released to the renter, based on worst case.
	// Contract End Height + Host Window Size + Maturity Delay
	ReleaseBlock uint64
	// PreviousSpending is the total spend funds from old contracts
	// that are not included in the current period spending
	PreviousSpending types.Currency
}

type RequestBody interface {
	DecodeFrom(d *types.Decoder)
	EncodeTo(e *types.Encoder)
}

type Seed [16]byte

type Shard struct {
	Host types.PublicKey `json:"host"`
	Root types.Hash256   `json:"root"`
}

type SiacoinOutputDiff struct {
	Direction     DiffDirection
	ID            types.SiacoinOutputID
	SiacoinOutput types.SiacoinOutput
}

type SiacoinSenderMulti interface {
	// SendSiacoinsMulti sends coins to multiple addresses.
	SendSiacoinsMulti(outputs []types.SiacoinOutput) ([]types.Transaction, error)
}

type SiafundOutputDiff struct {
	Direction     DiffDirection
	ID            types.SiafundOutputID
	SiafundOutput types.SiafundOutput
	ClaimStart    types.Currency
}

type SiafundPoolDiff struct {
	Direction DiffDirection
	Previous  types.Currency
	Adjusted  types.Currency
}

type Slab struct {
	Key       types.Hash256 `json:"key"`
	MinShards uint8         `json:"minShards"`
	Offset    uint64        `json:"offset"`
	Length    uint64        `json:"length"`
	Partial   bool          `json:"partial"`
	Shards    []Shard       `json:"shards"`
}

type SpendingDetails struct {
	DownloadSpending    types.Currency
	FundAccountSpending types.Currency
	MaintenanceSpending MaintenanceSpending
	StorageSpending     types.Currency
	UploadSpending      types.Currency
}

type Target types.Hash256

type TransactionBuilder interface {
	// FundTransaction adds siacoin inputs worth at least the requested
	// amount to the provided transaction. A change output is also added,
	// if necessary. The inputs will not be available to future calls to
	// FundTransaction unless ReleaseInputs is called.
	FundTransaction(txn *types.Transaction, amount types.Currency) (types.Transaction, []types.Hash256, error)

	// MarkWalletInputs scans a transaction and infers which inputs belong
	// to this wallet. This allows those inputs to be signed.
	MarkWalletInputs(txn types.Transaction) []types.Hash256

	// ReleaseInputs is a helper function that releases the inputs of txn
	// for use in other transactions. It should only be called on
	// transactions that are invalid or will never be broadcast.
	ReleaseInputs(txnSet []types.Transaction)

	// Sign will sign any inputs added by FundTransaction.
	Sign(txn *types.Transaction, toSign []types.Hash256, cf types.CoveredFields) error
}

type TransactionPool interface {
	Alerter

	// AcceptTransactionSet accepts a set of potentially interdependent
	// transactions.
	AcceptTransactionSet([]types.Transaction) error

	// Broadcast broadcasts a transaction set to all of the transaction pool's
	// peers.
	Broadcast(ts []types.Transaction)

	// Close is necessary for clean shutdown (e.g. during testing).
	Close() error

	// FeeEstimation returns an estimation for how high the transaction fee
	// needs to be per byte. The minimum recommended targets getting accepted
	// in ~3 blocks, and the maximum recommended targets getting accepted
	// immediately. Taking the average has a moderate chance of being accepted
	// within one block. The minimum has a strong chance of getting accepted
	// within 10 blocks.
	FeeEstimation() (minimumRecommended, maximumRecommended types.Currency)

	// Transaction returns the transaction and unconfirmed parents
	// corresponding to the provided transaction id.
	Transaction(id types.TransactionID) (txn types.Transaction, unconfirmedParents []types.Transaction, exists bool)

	// Transactions returns the transactions of the transaction pool.
	Transactions() []types.Transaction

	// TransactionConfirmed returns true if the transaction has been seen on the
	// blockchain. Note, however, that the block containing the transaction may
	// later be invalidated by a reorg.
	TransactionConfirmed(id types.TransactionID) (bool, error)

	// TransactionList returns a list of all transactions in the transaction
	// pool. The transactions are provided in an order that can acceptably be
	// put into a block.
	TransactionList() []types.Transaction

	// TransactionPoolSubscribe adds a subscriber to the transaction pool.
	// Subscribers will receive all consensus set changes as well as
	// transaction pool changes, and should not subscribe to both.
	TransactionPoolSubscribe(TransactionPoolSubscriber)

	// TransactionSet returns the transaction set the provided object
	// appears in.
	TransactionSet(types.Hash256) []types.Transaction

	// Unsubscribe removes a subscriber from the transaction pool.
	Unsubscribe(TransactionPoolSubscriber)
}

type TransactionPoolDiff struct {
	AppliedTransactions  []*UnconfirmedTransactionSet
	RevertedTransactions []TransactionSetID
}

type TransactionPoolSubscriber interface {
	// ReceiveTransactionPoolUpdate notifies subscribers of a change to the
	// consensus set and/or unconfirmed set, and includes the consensus change
	// that would result if all of the transactions made it into a block.
	ReceiveUpdatedUnconfirmedTransactions(*TransactionPoolDiff)
}

type TransactionSetID types.Hash256

type UnconfirmedTransactionSet struct {
	Change *ConsensusChange
	ID     TransactionSetID

	IDs          []types.TransactionID
	Sizes        []uint64
	Transactions []types.Transaction
}

type UnspentOutput struct {
	ID                 types.Hash256   `json:"id"`
	FundType           types.Specifier `json:"fundtype"`
	UnlockHash         types.Address   `json:"unlockhash"`
	Value              types.Currency  `json:"value"`
	ConfirmationHeight uint64          `json:"confirmationheight"`
	IsWatchOnly        bool            `json:"iswatchonly"`
}

type UserBalance struct {
	Email      string  `json:"email"`
	IsUser     bool    `json:"isuser"`
	IsRenter   bool    `json:"isrenter"`
	Subscribed bool    `json:"subscribed"`
	Balance    float64 `json:"balance"`
	Locked     float64 `json:"locked"`
	Currency   string  `json:"currency"`
	SCRate     float64 `json:"scrate"`
	StripeID   string  `json:"stripeid"`
	Invoice    string  `json:"-"`
	OnHold     uint64  `json:"-"`
}

type UserSpendings struct {
	Locked         float64 `json:"locked"`
	Used           float64 `json:"used"`
	Overhead       float64 `json:"overhead"`
	SCRate         float64 `json:"scrate"`
	Formed         uint64  `json:"formed"`
	Renewed        uint64  `json:"renewed"`
	SlabsSaved     uint64  `json:"slabssaved"`
	SlabsRetrieved uint64  `json:"slabsretrieved"`
	SlabsMigrated  uint64  `json:"slabsmigrated"`
}

type ValuedTransaction struct {
	ProcessedTransaction

	ConfirmedIncomingValue types.Currency `json:"confirmedincomingvalue"`
	ConfirmedOutgoingValue types.Currency `json:"confirmedoutgoingvalue"`
}

type Wallet interface {
	Alerter
	EncryptionManager
	KeyManager
	TransactionBuilder

	// AddUnlockConditions adds a set of UnlockConditions to the wallet database.
	AddUnlockConditions(uc types.UnlockConditions) error

	// AddWatchAddresses instructs the wallet to begin tracking a set of
	// addresses, in addition to the addresses it was previously tracking.
	// If none of the addresses have appeared in the blockchain, the
	// unused flag may be set to true. Otherwise, the wallet must rescan
	// the blockchain to search for transactions containing the addresses.
	AddWatchAddresses(addrs []types.Address, unused bool) error

	// Close permits clean shutdown during testing and serving.
	Close() error

	// ConfirmedBalance returns the confirmed balance of the wallet, minus
	// any outgoing transactions. ConfirmedBalance will include unconfirmed
	// refund transactions.
	ConfirmedBalance() (siacoinBalance types.Currency, siafundBalance uint64, siacoinClaimBalance types.Currency, err error)

	// UnconfirmedBalance returns the unconfirmed balance of the wallet.
	// Outgoing funds and incoming funds are reported separately. Refund
	// outputs are included, meaning that sending a single coin to
	// someone could result in 'outgoing: 12, incoming: 11'. Siafunds are
	// not considered in the unconfirmed balance.
	UnconfirmedBalance() (outgoingSiacoins types.Currency, incomingSiacoins types.Currency, err error)

	// Height returns the wallet's internal processed consensus height.
	Height() (uint64, error)

	// AddressTransactions returns all of the transactions that are related
	// to a given address.
	AddressTransactions(types.Address) ([]ProcessedTransaction, error)

	// AddressUnconfirmedHistory returns all of the unconfirmed
	// transactions related to a given address.
	AddressUnconfirmedTransactions(types.Address) ([]ProcessedTransaction, error)

	// Transaction returns the transaction with the given id. The bool
	// indicates whether the transaction is in the wallet database. The
	// wallet only stores transactions that are related to the wallet.
	Transaction(types.TransactionID) (ProcessedTransaction, bool, error)

	// Transactions returns all of the transactions that were confirmed at
	// heights [startHeight, endHeight]. Unconfirmed transactions are not
	// included.
	Transactions(startHeight uint64, endHeight uint64) ([]ProcessedTransaction, error)

	// UnconfirmedTransactions returns all unconfirmed transactions
	// relative to the wallet.
	UnconfirmedTransactions() ([]ProcessedTransaction, error)

	// RemoveWatchAddresses instructs the wallet to stop tracking a set of
	// addresses and delete their associated transactions. If none of the
	// addresses have appeared in the blockchain, the unused flag may be
	// set to true. Otherwise, the wallet must rescan the blockchain to
	// rebuild its transaction history.
	RemoveWatchAddresses(addrs []types.Address, unused bool) error

	// Rescanning reports whether the wallet is currently rescanning the
	// blockchain.
	Rescanning() (bool, error)

	// Settings returns the Wallet's current settings.
	Settings() (WalletSettings, error)

	// SetSettings sets the Wallet's settings.
	SetSettings(WalletSettings) error

	// SendSiacoins is a tool for sending Siacoins from the wallet to an
	// address. Sending money usually results in multiple transactions. The
	// transactions are automatically given to the transaction pool, and are
	// also returned to the caller.
	SendSiacoins(amount types.Currency, dest types.Address) ([]types.Transaction, error)

	// SendSiacoinsFeeIncluded sends Siacoins with fees included.
	SendSiacoinsFeeIncluded(amount types.Currency, dest types.Address) ([]types.Transaction, error)

	SiacoinSenderMulti

	// DustThreshold returns the quantity per byte below which a Currency is
	// considered to be Dust.
	DustThreshold() (types.Currency, error)

	// UnspentOutputs returns the unspent outputs tracked by the wallet.
	UnspentOutputs() ([]UnspentOutput, error)

	// UnlockConditions returns the UnlockConditions for the specified
	// address, if they are known to the wallet.
	UnlockConditions(addr types.Address) (types.UnlockConditions, error)

	// WatchAddresses returns the set of addresses that the wallet is
	// currently watching.
	WatchAddresses() ([]types.Address, error)
}

type WalletKey []byte

type WalletSettings struct {
	NoDefrag bool `json:"nodefrag"`
}

type WalletTransactionID types.Hash256