costs

type AccountSummary struct {
	Funds                 *big.Int
	AvailableFunds        *big.Int
	Debt                  *big.Int
	LockupRatePerEpoch    *big.Int
	LockupRatePerMonth    *big.Int
	FundedUntilEpoch      *big.Int
	RunwayInEpochs        *big.Int
	GrossCoverageInEpochs *big.Int
	CurrentEpoch          *big.Int
}

type AdditionalLockup struct {
	RateDeltaPerEpoch *big.Int
	StreamingLockup   *big.Int
	LifecycleLockup   *big.Int
	CDNLockup         *big.Int
	CacheMissLockup   *big.Int
	Total             *big.Int

	// Deprecated: Use RateDeltaPerEpoch.
	RateDelta *big.Int
	// Deprecated: Use StreamingLockup.
	RateLockup *big.Int
	// Deprecated: Use CDNLockup and CacheMissLockup.
	CDNFixedLockup *big.Int
	// Deprecated: Use LifecycleLockup.
	SybilFee *big.Int
	// Deprecated: Use Total.
	TotalLockup *big.Int
}

type ContractCaller interface {
	CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
	BlockNumber(ctx context.Context) (uint64, error)
}

type DepositCalculation struct {
	// AdditionalLockup is the incremental lockup required by the upload.
	AdditionalLockup *big.Int
	// Fees are one-time operation fees required by the upload.
	Fees *big.Int
	// RateDelta is the incremental per-epoch payment rate added by the upload.
	RateDelta *big.Int
	// CurrentLockupRate is the account's existing per-epoch payment rate.
	CurrentLockupRate *big.Int
	// Debt is already-accrued payment debt that must be covered.
	Debt *big.Int
	// AvailableFunds is the account balance available after projected lockup.
	AvailableFunds *big.Int
	// RunwayInEpochs is the current account runway after projection.
	RunwayInEpochs *big.Int
	// ExtraRunwayEpochs is extra epoch runway on top of the required lockup.
	ExtraRunwayEpochs int64
	// BufferEpochs is the deposit buffer for execution latency.
	// Zero means no buffer for direct calculations; service options apply their
	// own default before calling CalculateDepositNeeded.
	BufferEpochs int64
	// IsNewDataSet is true when creating a fresh dataset.
	IsNewDataSet bool
}

type EffectiveRate struct {
	RatePerEpoch *big.Int
	RatePerMonth *big.Int
}

type MultiContextCosts struct {
	// RatePerEpoch is the sum of per-context effective rates (post-upload).
	RatePerEpoch *big.Int
	// RatePerMonth is the sum of per-context monthly effective rates.
	RatePerMonth *big.Int
	// Fees is the aggregate one-time fee breakdown.
	Fees UploadFees
	// Lockup is the aggregate lockup breakdown.
	Lockup AdditionalLockup
	// DepositNeeded is the single USDFC deposit covering all contexts.
	DepositNeeded *big.Int
	// RequiredLockupPeriod is the max lockup period required for FWSS
	// approval, sourced from the price list.
	RequiredLockupPeriod *big.Int
	// NeedsFWSSMaxApproval is true when the FWSS operator does not yet
	// hold max approval for the payer.
	NeedsFWSSMaxApproval bool
	// Ready is true when DepositNeeded is zero and FWSS approval is set.
	Ready bool
}

type MultiContextRef struct {
	// IsNewDataSet is true when the target will create a new data set
	// on this provider (contributes lifecycle and optional CDN/cache-miss
	// lockup). When false, CurrentDataSetSizeBytes is consulted so the
	// marginal rate is computed above the existing size.
	IsNewDataSet bool

	// CurrentDataSetSizeBytes is the current on-chain size of the
	// existing data set (zero or nil when IsNewDataSet is true). When
	// unknown, pass nil and the marginal rate is computed from zero size.
	CurrentDataSetSizeBytes *big.Int

	// WithCDN toggles CDN and cache-miss lockup for this target. Only
	// meaningful when IsNewDataSet is true.
	WithCDN bool
}

type Options struct {
	// Chain selects the network whose contract addresses are used.
	// Zero value is chain.Mainnet. Explicit addresses below override the
	// chain registry for callers that resolve current contracts dynamically.
	Chain chain.Chain

	// USDFCTokenAddress is the payment token used for account and approval
	// reads. Zero falls back to Chain.Addresses().USDFC.
	USDFCTokenAddress common.Address

	// WarmStorageAddress is the FWSS operator used for approval reads. Zero
	// falls back to Chain.Addresses().FWSS.
	WarmStorageAddress common.Address

	// WarmStorage reads on-chain service pricing. Required.
	WarmStorage WarmStorageReader

	// Payments reads account and allowance state. Required.
	Payments PaymentsReader

	// Caller provides chain reads for cost calculations. Required.
	Caller ContractCaller

	// Logger is the structured logger. If nil, logging is silent.
	Logger *slog.Logger

	// Lifecycle, when non-nil, ties this Service to the owning Client's
	// close state. After the Lifecycle is closed, every method returns
	// ErrClosed. Nil is allowed for standalone use.
	Lifecycle *lifecycle.Lifecycle
}

type PaymentsReader interface {
	AccountInfo(ctx context.Context, token, owner common.Address) (*payments.AccountState, error)
	ServiceApproval(ctx context.Context, token, client, operator common.Address) (*payments.OperatorApproval, error)
}

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

type UploadCostOptions struct {
	// ExtraRunwayEpochs is extra epoch runway on top of lockup. Defaults to DefaultExtraRunwayEpochs (0).
	ExtraRunwayEpochs int64
	// BufferEpochs is the deposit buffer for execution latency.
	// Zero (the zero value) uses DefaultBufferEpochs (5); there is no way to
	// request a zero-epoch buffer via this field.
	BufferEpochs int64
	// EnableCDN adds CDN and cache-miss lockup for a new dataset.
	EnableCDN bool
	// IsNewDataSet must be true when creating a fresh dataset.
	IsNewDataSet bool
	// CurrentDataSetSizeBytes is the existing payload in the dataset (0 for new datasets).
	CurrentDataSetSizeBytes *big.Int
	// PieceCount is the number of pieces added by this upload. Zero defaults
	// to one piece.
	PieceCount *big.Int
}

type UploadCosts struct {
	Rate                 EffectiveRate
	Fees                 UploadFees
	Lockup               AdditionalLockup
	DepositNeeded        *big.Int
	RequiredLockupPeriod *big.Int
	NeedsFWSSMaxApproval bool
	Ready                bool
}

type UploadFees struct {
	CreateDataSetFee *big.Int
	AddPiecesFee     *big.Int
	Total            *big.Int
}

type WarmStorageReader interface {
	GetPriceList(ctx context.Context) (*warmstorage.PriceList, error)
}