ffs

type APIID string

type APIIDPinnedCid struct {
	ID        APIID
	Staged    bool
	CreatedAt int64
}

type AuthEntry struct {
	Token string
	APIID APIID
}

type ColdConfig struct {
	// Enabled indicates that data will be saved in Cold storage.
	// If is switched from false->true, it will consider the other attributes
	// as the desired state of the data in this Storage.
	Enabled bool
	// Filecoin describes the desired Filecoin configuration for a Cid in the
	// Filecoin network.
	Filecoin FilConfig
}

type ColdInfo struct {
	Enabled  bool
	Filecoin FilInfo
}

type ColdStorage interface {
	// Store stores a Cid using the provided configuration and
	// account address. It returns a slice of accepted proposed deals,
	// a slice of rejected proposal deals, and the size of the data.
	Store(context.Context, cid.Cid, FilConfig) ([]cid.Cid, []DealError, abi.PaddedPieceSize, error)

	// WaitForDeal blocks the provided Deal Proposal reach a
	// final state. If the deal finishes successfully it returns a FilStorage
	// result. If the deal finished with error, it returns a ffs.DealError
	// error result, so it should be considered in error handling.
	WaitForDeal(context.Context, cid.Cid, cid.Cid, time.Duration, chan deals.StorageDealInfo) (FilStorage, error)

	// Fetch fetches the cid data in the underlying storage.
	Fetch(context.Context, cid.Cid, *cid.Cid, string, []string, uint64, string) (FetchInfo, error)

	// EnsureRenewals executes renewal logic for a Cid under a particular
	// configuration. It returns a slice of deal errors happened during execution.
	EnsureRenewals(context.Context, cid.Cid, FilInfo, FilConfig, time.Duration, chan deals.StorageDealInfo) (FilInfo, []DealError, error)

	// IsFIlDealActive returns true if the proposal Cid is active on chain;
	// returns false otherwise.
	IsFilDealActive(context.Context, cid.Cid) (bool, error)
}

type DealError struct {
	ProposalCid cid.Cid
	Miner       string
	Message     string
}

type DealRecordsManager interface {
	ListStorageDealRecords(opts ...deals.DealRecordsOption) ([]deals.StorageDealRecord, error)
	ListRetrievalDealRecords(opts ...deals.DealRecordsOption) ([]deals.RetrievalDealRecord, error)
}

type FetchInfo struct {
	RetrievedMiner string
	FundsSpent     uint64
}

type FilConfig struct {
	// RepFactor indicates the desired amount of active deals
	// with different miners to store the data. While making deals
	// the other attributes of FilConfig are considered for miner selection.
	RepFactor int
	// DealMinDuration indicates the duration to be used when making new deals.
	DealMinDuration int64
	// ExcludedMiners is a set of miner addresses won't be ever be selected
	// when making new deals, even if they comply to other filters.
	ExcludedMiners []string
	// TrustedMiners is a set of miner addresses which will be forcibly used
	// when making new deals. An empty/nil list disables this feature.
	TrustedMiners []string
	// CountryCodes indicates that new deals should select miners on specific
	// countries.
	CountryCodes []string
	// Renew indicates deal-renewal configuration.
	Renew FilRenew
	// Addr is the wallet address used to store the data in filecoin
	Addr string
	// MaxPrice is the maximum price that will be spent per RepFactor to store the data in units of attoFIL per GiB per epoch
	MaxPrice uint64
	// FastRetrieval indicates that created deals should enable the
	// fast retrieval feature.
	FastRetrieval bool
	// DealStartOffset indicates how many epochs in the future impose a
	// deadline to new deals being active on-chain. This value might influence
	// if miners accept deals, since they should seal fast enough to satisfy
	// this constraint.
	DealStartOffset int64
}

type FilInfo struct {
	// DataCid corresponds to the PayloadCid of the deal.
	DataCid cid.Cid
	// Size is the size of the Piece. Recall that this size
	// is which is accounted for payment. Also is equal or
	// greater than the original data size.
	// This value might be zero for imported deals; if that's
	// the case, will be re-calculated in the next made deal.
	Size uint64
	// Proposals contains known deals for the data.
	Proposals []FilStorage
}

type FilRenew struct {
	// Enabled indicates that deal-renewal is enabled for this Cid.
	Enabled bool
	// Threshold indicates how many epochs before expiring should trigger
	// deal renewal. e.g: 100 epoch before expiring.
	Threshold int
}

type FilStorage struct {
	// ProposalCid of the deal.
	ProposalCid cid.Cid
	// PieceCid is the piece Cid.
	PieceCid cid.Cid
	// Renewed indicates if this deal was
	// already renewed, so it can expiry
	// safely if renewals are enabled.
	Renewed bool
	// Duration is the duration of the deal.
	Duration int64
	// ActivationEpoch is the epoch in which
	// the deal was activated.
	ActivationEpoch int64
	// StartEpoch is the starting epoch in which
	// the deal is considered active on-chain.
	StartEpoch uint64
	// Miner is the miner address which is storing
	// deals data.
	Miner string
	// EpochPrice is the price of attoFil per GiB
	// per epoch paid in this deal.
	EpochPrice uint64
}

type HotConfig struct {
	// Enable indicates if Cid data is stored. If true, it will consider
	// further configurations to execute actions.
	Enabled bool
	// AllowUnfreeze indicates that if data isn't available in hot storage,
	// it's allowed to be feeded by Cold Storage if available.
	AllowUnfreeze bool
	// UnfreezeMaxPrice indicates the maximum amount of attoFil to pay for
	// retrieval of data to unfreeze.
	UnfreezeMaxPrice uint64
	// Ipfs contains configuration related to storing Cid data in a IPFS node.
	Ipfs IpfsConfig
}

type HotInfo struct {
	Enabled bool
	Size    int
	Ipfs    IpfsHotInfo
}

type HotStorage interface {
	// Stage adds io.Reader and stage-pins it.
	Stage(context.Context, APIID, io.Reader) (cid.Cid, error)

	// StageCid stage-pins a cid.
	StageCid(context.Context, APIID, cid.Cid) error

	// Unpin unpins a Cid.
	Unpin(context.Context, APIID, cid.Cid) error

	// Get retrieves a stored Cid data.
	Get(context.Context, cid.Cid) (io.Reader, error)

	// Pin pins a Cid. If the data wasn't previously Added,
	// depending on the implementation it may use internal mechanisms
	// for pulling the data, e.g: IPFS network
	Pin(context.Context, APIID, cid.Cid) (int, error)

	// Replace replaces a stored Cid with a new one. It's mostly
	// thought for mutating data doing this efficiently.
	Replace(context.Context, APIID, cid.Cid, cid.Cid) (int, error)

	// IsPinned returns true if the Cid is pinned, or false
	// otherwise.
	IsPinned(context.Context, APIID, cid.Cid) (bool, error)

	// GCStaged unpins Cids that are stage-pinned that aren't
	// contained in a exclude list, and were pinned before a time.
	GCStaged(context.Context, []cid.Cid, time.Time) ([]cid.Cid, error)

	// PinnedCids returns pinned cids information.
	PinnedCids(context.Context) ([]PinnedCid, error)
}

type IpfsConfig struct {
	// AddTimeout is an upper bound on adding data to IPFS node from
	// the network before failing.
	AddTimeout int
}

type IpfsHotInfo struct {
	Created time.Time
}

type JobID string

type JobLogger interface {
	Log(context.Context, string, ...interface{})
	Watch(context.Context, chan<- LogEntry) error
	GetByCid(context.Context, APIID, cid.Cid) ([]LogEntry, error)
}

type JobLoggerCtxKey int

type JobStatus int

type LogEntry struct {
	APIID     APIID
	Cid       cid.Cid
	Timestamp time.Time
	Jid       JobID
	Msg       string
}

type MinerProposal struct {
	Addr       string
	EpochPrice uint64
}

type MinerSelector interface {
	// GetMiners returns a specified amount of miners that satisfy
	// provided filters.
	GetMiners(int, MinerSelectorFilter) ([]MinerProposal, error)
}

type MinerSelectorFilter struct {
	// ExcludedMiners contains miner addresses that should not be considered in
	// returned results. An empty list means no exclusions.
	ExcludedMiners []string
	// TrustedMiners contains miner addresses that will be prioritized
	// if are available in the query result. If the number of expected
	// results exceeeds the number of trusted miners, the remaining amount
	// of results will be returned still applying the rest of the filters
	// and the MinerSelector sorting logic.
	TrustedMiners []string
	// CountryCodes contains long-ISO country names that should be
	// considered in selected miners. An empty list means no filtering.
	CountryCodes []string
	// MaxPrice is the max ask price to consider when selecting miner deals
	MaxPrice uint64
	// PieceSize is the piece size of the data.
	PieceSize uint64
}

type PaychDir int

type PaychInfo struct {
	CtlAddr   string
	Addr      string
	Direction PaychDir
}

type PinnedCid struct {
	Cid    cid.Cid
	APIIDs []APIIDPinnedCid
}

type RetrievalID string

type RetrievalInfo struct {
	ID        RetrievalID
	DataCid   cid.Cid
	TotalPaid uint64
	MinerAddr string
	Size      int64
	CreatedAt time.Time
}

type RetrievalJob struct {
	ID          JobID
	APIID       APIID
	RetrievalID RetrievalID
	Status      JobStatus
	ErrCause    string
}

type StorageConfig struct {
	Hot        HotConfig
	Cold       ColdConfig
	Repairable bool
}

type StorageInfo struct {
	// APIID indicate from which instance this
	// information belongs.
	APIID APIID
	// JobID indicates the Job ID which updated
	// the current information. It *may be empty* if
	// the data was imported manually.
	JobID JobID
	// Cid of payload.
	Cid cid.Cid
	// Created is the timestamp of the data.
	Created time.Time
	// Hot contains hot storage information.
	Hot HotInfo
	// Cold contains cold storage information.
	Cold ColdInfo
}

type StorageJob struct {
	ID         JobID
	APIID      APIID
	Cid        cid.Cid
	Status     JobStatus
	ErrCause   string
	DealInfo   []deals.StorageDealInfo
	DealErrors []DealError
	CreatedAt  int64
}

type WalletManager interface {
	// MasterAddr returns the master address.
	// Will return address.Undef is Powergate was started with no master address.
	MasterAddr() address.Address
	// NewAddress creates a new address.
	NewAddress(context.Context, string) (string, error)
	// Balance returns the current balance for an address.
	Balance(context.Context, string) (*big.Int, error)
	// SendFil sends fil from one address to another.
	SendFil(context.Context, string, string, *big.Int) error
	// Sign signs a message using an address.
	Sign(context.Context, string, []byte) ([]byte, error)
	// Verify verifies if a message was signed with an address.
	Verify(context.Context, string, []byte, []byte) (bool, error)
}