ffs

type APIID string

type CidConfig struct {
	// Cid is the Cid of the stored data.
	Cid cid.Cid
	// Hot has desired storing configuration in Hot Storage.
	Hot HotConfig
	// Cold has desired storing configuration in the Cold Storage.
	Cold ColdConfig
	// Repairable indicates if this cid config should be tracked
	// for auto-repair.
	Repairable bool
}

type CidInfo struct {
	JobID   JobID
	Cid     cid.Cid
	Created time.Time
	Hot     HotInfo
	Cold    ColdInfo
}

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

type CidLoggerCtxKey int

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 {
	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, uint64, error)

	// WaitForDeals block until all provided Deal Proposals reach a
	// final state, and return the success result plus failed deals
	// that didn't reach success final status.
	WaitForDeals(context.Context, cid.Cid, []cid.Cid) ([]FilStorage, []DealError, error)

	// Fetch fetches the cid data in the underlying storage.
	Fetch(context.Context, cid.Cid, string) 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) (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 DefaultConfig struct {
	Hot        HotConfig
	Cold       ColdConfig
	Repairable bool
}

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 to store the data
	MaxPrice uint64
}

type FilInfo struct {
	DataCid   cid.Cid
	Size      uint64
	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     cid.Cid
	Renewed         bool
	Duration        int64
	ActivationEpoch int64
	StartEpoch      uint64
	Miner           string
	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 the Hot Storage,
	// it's allowed to be feeded by Cold Storage if available.
	AllowUnfreeze bool
	// 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 {
	// Add adds io.Reader data ephemerally (not pinned).
	Add(context.Context, io.Reader) (cid.Cid, error)

	// Remove removes a stored Cid.
	Remove(context.Context, cid.Cid) error

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

	// Store stores 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
	Store(context.Context, 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, cid.Cid, cid.Cid) (int, error)

	// Put adds a raw block.
	Put(context.Context, blocks.Block) error

	// IsStore returns true if the Cid is stored, or false
	// otherwise.
	IsStored(context.Context, cid.Cid) (bool, 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 Job struct {
	ID         JobID
	APIID      APIID
	Cid        cid.Cid
	Status     JobStatus
	ErrCause   string
	DealErrors []DealError
}

type JobID string

type JobStatus int

type LogEntry struct {
	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
}

type PaychDir int

type PaychInfo struct {
	CtlAddr   string
	Addr      string
	Direction PaychDir
}

type PaychManager interface {
	// List lists all payment channels involving the specified addresses.
	List(ctx context.Context, addrs ...string) ([]PaychInfo, error)
	// Create creates a new payment channel.
	Create(ctx context.Context, from string, to string, amount uint64) (PaychInfo, cid.Cid, error)
	// Redeem redeems a payment channel.
	Redeem(ctx context.Context, ch string) error
}

type WalletManager interface {
	// NewAddress creates a new address.
	NewAddress(context.Context, string) (string, error)
	// Balance returns the current balance for an address.
	Balance(context.Context, string) (uint64, error)
	// SendFil sends fil from one address to another.
	SendFil(context.Context, string, string, *big.Int) error
}