synapse

type ChainEpochReader interface {
	CurrentEpoch(ctx context.Context) (int64, error)
}

type CleanupContext interface {
	DeletePiecesByID(context.Context, []sdktypes.BigInt) (*sdktypes.WriteResult, error)
}

type CleanupPieceState struct {
	Status      CleanupPieceStatus
	BlockNumber uint64
}

type CleanupPieceStatus string

type CleanupPiecesState struct {
	Pieces          map[string]CleanupPieceStatus
	QueueLength     int
	BlockNumber     uint64
	VerifierVersion string
}

type ClientConfig struct {
	PrivateKey           string
	RPCURL               string
	WithCDN              bool
	AllowPrivateNetworks bool
	Logger               *slog.Logger
}

type ClientNonceState struct {
	Consumed    bool
	DataSetID   sdktypes.BigInt
	NextPieceID sdktypes.BigInt
}

type CommitNonceReader interface {
	// ClientNonce reports what FWSS recorded for a nonce this node's payer
	// signed.
	ClientNonce(ctx context.Context, nonce sdktypes.BigInt) (ClientNonceState, error)
	// PieceCIDAt returns the piece CID a data set holds at a piece ID, or
	// cid.Undef when none is there.
	PieceCIDAt(ctx context.Context, dataSetID, pieceID sdktypes.BigInt) (cid.Cid, error)
}

type CommitRejection uint8

type DataSetCreationStatusInput struct {
	StatusURL         string
	TransactionID     string
	ExpectedDataSetID string
}

type DataSetServiceEndedError struct {
	Cause error
}

type DataSetTarget interface {
	StorageTarget
	ContextIdentity() storage.ContextIdentity
	CreateStoreSession(ctx context.Context) (string, error)
	UploadStoreSession(ctx context.Context, serviceURL, sessionID string, reader io.Reader, opts *storage.StoreOptions) (*storage.StoreResult, error)
	FinalizeStoreSession(ctx context.Context, serviceURL, sessionID string, pieceCID cid.Cid) error
	PresignForCommit(context.Context, []storage.PieceInput) ([]byte, error)
	SubmitPull(context.Context, storage.PullRequest) (*storage.PullResult, error)
	SubmitCommit(context.Context, storage.CommitRequest) (*storage.CommitSubmission, error)
	GetCommitStatus(context.Context, string) (*storage.CommitStatus, error)
	PieceStatus(context.Context, cid.Cid) (*storage.PieceStatus, error)
	// CheckWritable reads the data set's chain state and reports whether it
	// still accepts new pieces. It contacts no provider.
	CheckWritable(context.Context) error
}

type NoProviderCandidatesError struct {
	Cause error
}

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

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

type PDPStatusCheckerOptions struct {
	Timeout              time.Duration
	AllowPrivateNetworks bool
}

type PDPStatusResult struct {
	State          PDPStatusState
	StatusURL      string
	TxStatus       string
	DataSetID      string
	DataSetCreated bool
	Error          string
}

type PDPStatusState string

type ParkedPieceChecker interface {
	FindParkedPiece(context.Context, string, cid.Cid) (ParkedPieceState, error)
}

type ParkedPieceState string

type PaymentAccountInfo struct {
	Funds               *big.Int
	AvailableFunds      *big.Int
	LockupCurrent       *big.Int
	LockupRate          *big.Int
	LockupLastSettledAt *big.Int
	FundedUntilEpoch    *big.Int
	FundedUntilTime     *time.Time
	RunwaySeconds       *int64
	LockupRatePerDay    *big.Int
	LockupRatePerMonth  *big.Int
	NoActiveSpend       bool
}

type ProviderInventory struct {
	Selection     providerselect.Inventory
	Providers     map[string]storage.Provider
	PartialErrors map[string]string
}

type ProviderPiecesState struct {
	Known   []sdktypes.BigInt
	Unknown []sdktypes.BigInt
	Errors  map[string]error
}

type ProviderTarget interface {
	StorageTarget
	CreateDataSet(context.Context, *storage.CreateDataSetOptions) (*storage.CreateDataSetResult, error)
	WaitForDataSetCreated(context.Context, string, sdktypes.BigInt) (*storage.CreateDataSetResult, error)
	// ContextIdentity is the payer, chain, and record keeper the target signs
	// for. Client data set IDs are only unique within it.
	ContextIdentity() storage.ContextIdentity
	// FindDataSetByClientDataSetID reads the chain for the data set a create
	// request with this ID produced. Not found only means none is visible yet.
	FindDataSetByClientDataSetID(context.Context, sdktypes.BigInt) (storage.DataSetRef, bool, error)
}

type ProviderUnavailableError struct {
	Cause error
}

type PullErrorDisposition uint8

type ReadinessCheck struct {
	ID            string          `json:"id"`
	Status        ReadinessStatus `json:"status"`
	Message       string          `json:"message"`
	Action        string          `json:"action,omitempty"`
	RequiredUSDFC string          `json:"required_usdfc,omitempty"`
}

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

type ReadinessCheckerOption func(*ReadinessChecker)

type ReadinessClient interface {
	ProviderInventory(context.Context, ReadinessConfig) (ProviderInventory, error)
	Address() common.Address
	Chain() chain.Chain
	ResolvedAddresses() sdk.ResolvedAddresses
	Payments() readinessPayments
	Storage() readinessStorage
	Close() error
}

type ReadinessClientFactory func(context.Context, ReadinessConfig) (ReadinessClient, error)

type ReadinessConfig struct {
	Network              string
	RPCURL               string
	PrivateKey           string
	WithCDN              bool
	AllowPrivateNetworks bool
	DefaultCopies        int
	AnchorProviderTier   string
	ProviderTimeout      time.Duration
	ProviderConcurrency  int
}

type ReadinessMode string

type ReadinessResult struct {
	Status        ReadinessStatus   `json:"status"`
	Mode          ReadinessMode     `json:"mode"`
	CheckedAt     time.Time         `json:"checked_at"`
	Checks        []ReadinessCheck  `json:"checks"`
	PartialErrors map[string]string `json:"partial_errors,omitempty"`
	// contains filtered or unexported fields
}

type ReadinessStatus string

type RemovalChainReader interface {
	Preflight(context.Context, sdktypes.BigInt) (RemovalPreflight, error)
	ProvingConfig(context.Context) (RemovalProvingConfig, error)
}

type RemovalPreflight struct {
	DataSetMissing   bool
	EndEpoch         int64
	ReserveTopUp     *big.Int
	PayerUnderfunded bool
	Reason           string
}

type RemovalProvingConfig struct {
	MaxProvingPeriod int64
	ChallengeWindow  int64
}

type RemovalRejection uint8

type ServiceTerminator interface {
	PDPVerifierAddress() common.Address
	// TerminateService wraps its error with ErrTerminationNotSent when nothing
	// left the process, and with ErrTerminationTransactionNotSent when only a
	// provider relay request may have.
	TerminateService(ctx context.Context, dataSetID sdktypes.BigInt, hooks TerminationHooks) (*TerminationResult, error)
	// VerifyServicePayer reads the data set's record and fails with
	// ErrServicePaidByAnother when this wallet does not pay for it; any other
	// error means the record could not be read. It sends nothing, so a caller can
	// check before committing to a termination.
	VerifyServicePayer(ctx context.Context, dataSetID sdktypes.BigInt) error
	// ContextIdentity reports the payer, chain, and record keeper this
	// terminator signs for, so a caller can tell that a recorded request was
	// made under another one.
	ContextIdentity() storage.ContextIdentity
}

type StorageClient interface {
	ContextIdentity() storage.ContextIdentity
	PDPVerifierAddress() common.Address
	Download(ctx context.Context, pieceCID cid.Cid, opts *storage.DownloadOptions) (io.ReadCloser, error)
	PrepareUpload(ctx context.Context, dataSize uint64, targets []StorageTarget) (*sdkcosts.MultiContextCosts, error)
	SelectUploadTargets(ctx context.Context, opts storage.SelectUploadContextsOptions) ([]StorageTarget, error)
	OpenProviderTarget(ctx context.Context, providerID sdktypes.BigInt, opts storage.NewProviderContextOptions) (ProviderTarget, error)
	OpenDataSetTarget(ctx context.Context, dataSetID sdktypes.BigInt, opts storage.NewDataSetContextOptions) (DataSetTarget, error)
	FindMatchingDataSet(ctx context.Context, providerID sdktypes.BigInt, metadata map[string]string, withCDN bool) (*storage.DataSetRef, error)
	OpenCleanupContext(ctx context.Context, dataSetID sdktypes.BigInt, opts storage.NewDataSetContextOptions) (CleanupContext, error)
	// DeletionStates reads exact piece or data-set cleanup evidence at one block.
	// Removed data sets require the caller's recorded creation identity.
	DeletionStates(ctx context.Context, dataSetID sdktypes.BigInt, pieceIDs []sdktypes.BigInt) (CleanupPiecesState, error)
	ProviderPiecesKnown(ctx context.Context, serviceURL string, dataSetID sdktypes.BigInt, pieceIDs []sdktypes.BigInt) (ProviderPiecesState, error)
}

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

type StorageTarget interface {
	ProviderID() sdktypes.BigInt
	DataSetRef() (storage.DataSetRef, bool)
	GetProviderInfo() storage.Provider
	CDNEnabled() bool
	PieceURL(cid.Cid) string
	ServiceURL() string
}

type TerminationBlockedError struct {
	Reason    string
	Shortfall *big.Int
	Err       error
}

type TerminationHooks struct {
	// OnSubmitted receives a transaction hash as soon as one is known.
	OnSubmitted func(hash string) error
	// BeforeDirect runs before the payer wallet may broadcast a transaction. An
	// error prevents the direct submission.
	BeforeDirect func() error
}

type TerminationResult struct {
	TxHash          string
	ConfirmedTxHash string
	ReceiptStatus   *uint64
	EndEpoch        *int64
}

type WalletInfo struct {
	Address              string
	Network              string
	ChainID              int64
	Nonce                *uint64
	CurrentEpoch         *big.Int
	EpochDurationSeconds int64
	PaymentsAddress      string
	USDFCAddress         string
	USDFCDecimals        uint8
	FILGasBalance        *big.Int
	USDFCWalletBalance   *big.Int
	PaymentAccount       *PaymentAccountInfo
	Errors               map[string]string
}

type WalletOperator interface {
	WalletIdentity() walletoperation.ExecutionIdentity
	FundUSDFC(ctx context.Context, amount *big.Int) (WalletSubmission, error)
	WithdrawUSDFC(ctx context.Context, amount *big.Int) (WalletSubmission, error)
	ApproveFWSS(ctx context.Context) (WalletSubmission, error)
	RebroadcastSignedTransaction(ctx context.Context, operationType model.WalletOperationType, amount *big.Int, submission WalletSubmission, observationTimeout time.Duration) error
}

type WalletQuerier interface {
	WalletIdentity() walletoperation.ExecutionIdentity
	GetWalletInfo(ctx context.Context) (*WalletInfo, error)
}

type WalletReplayClient interface {
	ChainID(context.Context) (*big.Int, error)
	TransactionReceipt(context.Context, common.Hash) (*ethtypes.Receipt, error)
	TransactionByHash(context.Context, common.Hash) (*ethtypes.Transaction, bool, error)
	HeaderByNumber(context.Context, *big.Int) (*ethtypes.Header, error)
	NonceAt(context.Context, common.Address, *big.Int) (uint64, error)
	PendingNonceAt(context.Context, common.Address) (uint64, error)
	SendTransaction(context.Context, *ethtypes.Transaction) error
}

type WalletSubmission struct {
	TxHash            string
	SignedTransaction []byte
	// NotSent reports SDK proof that this invocation did not send a transaction.
	NotSent bool
}