host

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

type Contract struct {
	Revision   types.FileContractRevision
	Signatures [2]types.TransactionSignature

	FormationSet    []types.Transaction
	FinalizationSet []types.Transaction
	ProofSet        []types.Transaction

	FormationConfirmed    bool
	FinalizationConfirmed bool
	ProofConfirmed        bool

	FormationHeight    types.BlockHeight
	FinalizationHeight types.BlockHeight
	ProofHeight        types.BlockHeight
	ProofSegment       uint64

	// Non-nil, with explanatory error message, if it is no longer possible to
	// submit a valid storage proof for the Contract.
	FatalError error
}

type ContractStore interface {
	// SigningKey returns the private key used to sign contract revisions.
	SigningKey() ed25519.PrivateKey
	// Contract returns the contract with the specified ID.
	Contract(id types.FileContractID) (Contract, error)
	// AddContract stores the provided contract, overwriting any previous
	// contract with the same ID.
	AddContract(c Contract) error
	// ReviseContract updates the current revision associated with a contract.
	ReviseContract(rev types.FileContractRevision, renterSig, hostSig []byte) error
	// UpdateContractTransactions updates the contract's various transactions.
	//
	// This method does not return an error. If a contract cannot be saved to
	// the store, the method should panic or exit with an error.
	UpdateContractTransactions(id types.FileContractID, finalization, proof []types.Transaction, err error)
	// ActionableContracts returns all of the store's contracts for which
	// ContractIsActionable returns true (as of the current block height).
	//
	// This method does not return an error. If contracts cannot be loaded from
	// the store, the method should panic or exit with an error.
	ActionableContracts() []Contract
	// ApplyConsensusChange integrates a ProcessedConsensusChange into the
	// store.
	ApplyConsensusChange(reverted, applied ProcessedConsensusChange, ccid modules.ConsensusChangeID)
	// ConsensusChangeID returns the ID of the last ProcessedConsensusChange
	// that was integrated by the store.
	ConsensusChangeID() modules.ConsensusChangeID
	// Height returns the current block height.
	Height() types.BlockHeight
}

type Metric interface {
	// contains filtered or unexported methods
}

type MetricHandshake struct {
	Err error
}

type MetricRPCEnd struct {
	ID        renterhost.Specifier
	Elapsed   time.Duration
	UpBytes   uint64
	DownBytes uint64
	Err       error
}

type MetricRPCStart struct {
	ID        renterhost.Specifier
	Timestamp time.Time
}

type MetricSessionEnd struct {
	Err error
}

type MetricsRecorder interface {
	RecordSessionMetric(ctx *SessionContext, m Metric)
}

type ProcessedConsensusChange struct {
	Contracts []types.FileContractID
	Revisions []types.FileContractID
	Proofs    []types.FileContractID
	BlockIDs  []types.BlockID
}

type SectorStore interface {
	AddSector(root crypto.Hash, sector *[renterhost.SectorSize]byte) error
	ContractRoots(id types.FileContractID) ([]crypto.Hash, error)
	DeleteSector(root crypto.Hash) error
	Sector(root crypto.Hash) (*[renterhost.SectorSize]byte, error)
	SetContractRoots(id types.FileContractID, roots []crypto.Hash) error
}

type SessionContext struct {
	UID         [16]byte
	RenterIP    string
	Timestamp   time.Time
	Elapsed     time.Duration
	BlockHeight types.BlockHeight
	UpBytes     uint64
	DownBytes   uint64

	Contract types.FileContractRevision
	Settings hostdb.HostSettings
}

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

type SettingsReporter interface {
	Settings() hostdb.HostSettings
}

type TransactionPool interface {
	AcceptTransactionSet(txns []types.Transaction) error
	FeeEstimate() (min, max types.Currency, err error)
	UnconfirmedParents(txn types.Transaction) ([]types.Transaction, error)
}

type Wallet interface {
	Address() (types.UnlockHash, error)
	FundTransaction(txn *types.Transaction, cost types.Currency) ([]crypto.Hash, func(), error)
	SignTransaction(txn *types.Transaction, toSign []crypto.Hash) error
}