api

type AccountManager interface {
	Accounts(limit, offset int) ([]accounts.Account, error)
	AccountFunding(accountID rhp3.Account) ([]accounts.FundingSource, error)
}

type AddVolumeRequest struct {
	LocalPath  string `json:"localPath"`
	MaxSectors uint64 `json:"maxSectors"`
}

type AlertResp []alerts.Alert

type Alerts interface {
	Active() []alerts.Alert
	Dismiss(...types.Hash256)
}

type BuildState struct {
	Network   string    `json:"network"`
	Version   string    `json:"version"`
	Commit    string    `json:"commit"`
	OS        string    `json:"os"`
	BuildTime time.Time `json:"buildTime"`
}

type ChainManager interface {
	Synced() bool
	TipState() consensus.State
}

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

type ConsensusState struct {
	Synced     bool             `json:"synced"`
	ChainIndex types.ChainIndex `json:"chainIndex"`
}

type ContractIntegrityResponse struct {
	BadSectors   []types.Hash256 `json:"badSectors"`
	TotalSectors uint64          `json:"totalSectors"`
}

type ContractManager interface {
	Contracts(filter contracts.ContractFilter) ([]contracts.Contract, int, error)
	Contract(id types.FileContractID) (contracts.Contract, error)

	// CheckIntegrity checks the integrity of a contract's sector roots on
	// disk. The result of each sector checked is sent on the returned
	// channel. Read errors are logged.
	CheckIntegrity(ctx context.Context, contractID types.FileContractID) (<-chan contracts.IntegrityResult, uint64, error)
}

type ContractsResponse struct {
	Count     int                  `json:"count"`
	Contracts []contracts.Contract `json:"contracts"`
}

type CreateDirRequest struct {
	Path string `json:"path"`
}

type HostSettings settings.Settings

type HostState struct {
	Name             string                `json:"name,omitempty"`
	PublicKey        types.PublicKey       `json:"publicKey"`
	LastAnnouncement settings.Announcement `json:"lastAnnouncement"`
	WalletAddress    types.Address         `json:"walletAddress"`
	StartTime        time.Time             `json:"startTime"`
	BuildState
}

type IntegrityCheckResult struct {
	Start time.Time `json:"start"`
	End   time.Time `json:"end"`

	CheckedSectors uint64                      `json:"checkedSectors"`
	TotalSectors   uint64                      `json:"totalSectors"`
	BadSectors     []contracts.IntegrityResult `json:"badSectors"`
}

type JSONErrors []error

type MetricManager interface {
	// PeriodMetrics returns metrics for n periods starting at start.
	PeriodMetrics(start time.Time, periods int, interval metrics.Interval) (period []metrics.Metrics, err error)
	// Metrics returns aggregated metrics for the host as of the timestamp.
	Metrics(time.Time) (m metrics.Metrics, err error)
}

type Metrics metrics.Metrics

type Peer struct {
	Address string `json:"address"`
	Version string `json:"version"`
}

type PeerResp []Peer

type PinnedSettings interface {
	Update(context.Context, pin.PinnedSettings) error
	Pinned(context.Context) pin.PinnedSettings
}

type RHPSessionReporter interface {
	Subscribe(rhp.SessionSubscriber)
	Unsubscribe(rhp.SessionSubscriber)

	Active() []rhp.Session
}

type RegisterWebHookRequest struct {
	CallbackURL string   `json:"callbackURL"`
	Scopes      []string `json:"scopes"`
}

type ResizeVolumeRequest struct {
	MaxSectors uint64 `json:"maxSectors"`
}

type ServerOption func(*api)

type SessionResp []rhp.Session

type Setting func(map[string]any)

type Settings interface {
	Announce() error

	UpdateSettings(s settings.Settings) error
	Settings() settings.Settings
	LastAnnouncement() (settings.Announcement, error)

	UpdateDDNS(force bool) error
}

type Syncer interface {
	Address() modules.NetAddress
	Peers() []modules.Peer
	Connect(addr modules.NetAddress) error
	Disconnect(addr modules.NetAddress) error
}

type SyncerAddrResp string

type SyncerConnectRequest struct {
	Address string `json:"address"`
}

type SystemDirResponse struct {
	Path        string   `json:"path"`
	TotalBytes  uint64   `json:"totalBytes"`
	FreeBytes   uint64   `json:"freeBytes"`
	Directories []string `json:"directories"`
}

type TPool interface {
	RecommendedFee() (fee types.Currency)
	AcceptTransactionSet(txns []types.Transaction) error
}

type TPoolResp types.Currency

type UpdateVolumeRequest struct {
	ReadOnly bool `json:"readOnly"`
}

type VerifySectorResponse struct {
	storage.SectorReference
	Error string `json:"error,omitempty"`
}

type VolumeManager interface {
	Usage() (usedSectors uint64, totalSectors uint64, err error)
	Volumes() ([]storage.VolumeMeta, error)
	Volume(id int64) (storage.VolumeMeta, error)
	AddVolume(ctx context.Context, localPath string, maxSectors uint64, result chan<- error) (storage.Volume, error)
	RemoveVolume(ctx context.Context, id int64, force bool, result chan<- error) error
	ResizeVolume(ctx context.Context, id int64, maxSectors uint64, result chan<- error) error
	SetReadOnly(id int64, readOnly bool) error
	RemoveSector(root types.Hash256) error
	ResizeCache(size uint32)
	Read(types.Hash256) (*[rhp2.SectorSize]byte, error)

	// SectorReferences returns the references to a sector
	SectorReferences(root types.Hash256) (storage.SectorReference, error)
}

type VolumeMeta struct {
	storage.VolumeMeta
	Errors JSONErrors `json:"errors"`
}

type VolumeResp []VolumeMeta

type Wallet interface {
	Address() types.Address
	ScanHeight() uint64
	Balance() (spendable, confirmed, unconfirmed types.Currency, err error)
	UnconfirmedTransactions() ([]wallet.Transaction, error)
	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
	Transactions(limit, offset int) ([]wallet.Transaction, error)
}

type WalletPendingResp []wallet.Transaction

type WalletResponse struct {
	ScanHeight  uint64         `json:"scanHeight"`
	Address     types.Address  `json:"address"`
	Spendable   types.Currency `json:"spendable"`
	Confirmed   types.Currency `json:"confirmed"`
	Unconfirmed types.Currency `json:"unconfirmed"`
}

type WalletSendSiacoinsRequest struct {
	Address          types.Address  `json:"address"`
	Amount           types.Currency `json:"amount"`
	SubtractMinerFee bool           `json:"subtractMinerFee"`
}

type WalletTransactionsResp []wallet.Transaction

type WebHooks interface {
	WebHooks() ([]webhooks.WebHook, error)
	RegisterWebHook(callbackURL string, scopes []string) (webhooks.WebHook, error)
	UpdateWebHook(id int64, callbackURL string, scopes []string) (webhooks.WebHook, error)
	RemoveWebHook(id int64) error
	BroadcastToWebhook(id int64, event, scope string, data interface{}) error
}