costs

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

type ContractCaller interface {
	BlockNumber(ctx context.Context) (uint64, error)
}

type DataSetServiceTerminatedError struct {
	PDPEndEpoch types.Epoch
}

type DepositCalculation struct {
	// AdditionalLockup is the incremental lockup required by the upload.
	AdditionalLockup *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 LifecycleReserveCalculation struct {
	// PriceList is the canonical warm-storage price list. Nil uses zero values.
	PriceList *warmstorage.PriceList
	// PieceSizes contains every raw payload size in the planned upload.
	PieceSizes []uint64
	// IsNewDataSet is true when the upload creates a new data set.
	IsNewDataSet bool
	// CurrentLifecycleReserveBalance is required and non-negative for an
	// existing data set. It is ignored for a new data set.
	CurrentLifecycleReserveBalance *big.Int
	// PendingOneTimePayments is the non-negative fee total already waiting to be
	// paid from the reserve. Nil defaults to zero.
	PendingOneTimePayments *big.Int
}

type LifecycleReserveFunding struct {
	// InitialLockup is the reserve target locked when a new data set is created.
	InitialLockup *big.Int
	// ReserveReplenishment is the additional fixed lockup required while the
	// planned operation fees are processed.
	ReserveReplenishment *big.Int
	// Total is InitialLockup plus ReserveReplenishment.
	Total *big.Int
	// FinalReserveBalance is the simulated balance after all planned fees have
	// been processed.
	FinalReserveBalance *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, CurrentDataSetLeafCount is required.
	IsNewDataSet bool

	// CurrentDataSetLeafCount is the non-negative on-chain leaf count of an
	// existing data set. Zero means known empty; nil is invalid for an existing
	// data set. Ignored when IsNewDataSet is true.
	CurrentDataSetLeafCount *big.Int
	// CurrentLifecycleReserveBalance is required and non-negative for an
	// existing data set. It is ignored when IsNewDataSet is true.
	CurrentLifecycleReserveBalance *big.Int
	// PendingOneTimePayments is the non-negative operation-fee total already
	// waiting to be paid from an existing data set's reserve. Nil defaults to
	// zero. It is ignored when IsNewDataSet is true.
	PendingOneTimePayments *big.Int
	// PDPEndEpoch is required for an existing data set. It must point to zero;
	// a non-zero epoch means the data set can no longer accept uploads. It is
	// ignored when IsNewDataSet is true.
	PDPEndEpoch *types.Epoch

	// 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 is checked before service operations that can touch configured
	// backends. Any error returned by CheckClosed is returned without touching
	// those backends. The root synapse Client injects a shared checker whose
	// closed error matches ErrClosed. Nil is allowed for standalone use. A
	// typed-nil value is treated as nil.
	Lifecycle interface{ CheckClosed() error }
}

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 0.
	// Negative values return ErrInvalidArgument.
	ExtraRunwayEpochs int64
	// BufferEpochs is the deposit buffer for execution latency.
	// Nil uses DefaultBufferEpochs (5); a pointer to zero disables the buffer.
	// Negative values return ErrInvalidArgument.
	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
	// CurrentDataSetLeafCount is required and non-negative for an existing
	// dataset. Zero means known empty. Ignored when IsNewDataSet is true.
	CurrentDataSetLeafCount *big.Int
	// CurrentLifecycleReserveBalance is required and non-negative for an
	// existing dataset. Ignored when IsNewDataSet is true.
	CurrentLifecycleReserveBalance *big.Int
	// PendingOneTimePayments is the non-negative operation-fee total already
	// waiting to be paid from an existing dataset's reserve. Nil defaults to
	// zero. Ignored when IsNewDataSet is true.
	PendingOneTimePayments *big.Int
	// PDPEndEpoch is required for an existing dataset. It must point to zero;
	// a non-zero epoch means the dataset can no longer accept uploads. Ignored
	// when IsNewDataSet is true.
	PDPEndEpoch *types.Epoch
}

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)
}