dealpusher

type DDOBalanceStatus struct {
	WalletAddr     common.Address
	NativeFIL      *big.Int // native FIL balance (for gas)
	TokenBalance   *big.Int // payment token balance held in wallet
	DepositedFunds *big.Int // funds already deposited in payments contract
	LockupCurrent  *big.Int // current lockup in payments contract
	Available      *big.Int // deposited - lockup (spendable for new deals)
}

type DDODealManager interface {
	// ValidateSP checks that the provider is registered and active in the
	// DDO contract, and returns its on-chain config.
	ValidateSP(ctx context.Context, providerActorID uint64) (*DDOSPConfig, error)

	// CheckBalance queries the wallet's native FIL and payment token balances,
	// as well as the payments contract account status. Returns a summary that
	// the scheduler uses for pre-flight logging and low-balance warnings.
	CheckBalance(ctx context.Context, walletAddr common.Address) (*DDOBalanceStatus, error)

	// EnsurePayments checks account balance and operator approval, deposits
	// and approves if needed. Takes the actual pieces (not aggregated totals)
	// because the SDK computes per-piece lockup: allocationLockupAmount * len(pieces).
	EnsurePayments(ctx context.Context, evmSigner signer.EVMSigner,
		pieces []DDOPieceSubmission, cfg DDOSchedulingConfig) error

	// CreateAllocations submits a batch of pieces as DDO allocations.
	CreateAllocations(ctx context.Context, evmSigner signer.EVMSigner,
		pieces []DDOPieceSubmission, cfg DDOSchedulingConfig) (*DDOQueuedTx, error)

	// WaitForConfirmations polls for tx confirmation to the specified depth.
	WaitForConfirmations(ctx context.Context, txHash string,
		depth uint64, pollInterval time.Duration) (*DDOTransactionReceipt, error)

	// ParseAllocationIDs extracts allocation IDs from a confirmed tx receipt.
	ParseAllocationIDs(ctx context.Context, txHash string) ([]uint64, error)
}

type DDOPieceSubmission struct {
	PieceCID    cid.Cid
	PieceSize   uint64
	ProviderID  uint64
	DownloadURL string
}

type DDOQueuedTx struct {
	Hash string
}

type DDOSPConfig struct {
	IsActive     bool
	MinPieceSize uint64
	MaxPieceSize uint64
	MinTermLen   int64
	MaxTermLen   int64
}

type DDOSchedulingConfig struct {
	BatchSize         int           // pieces per createAllocationRequests tx
	ConfirmationDepth uint64        // block confirmations before considering tx final
	PollingInterval   time.Duration // confirmation polling interval
	TermMin           int64         // min term in epochs, default 518400 (~6 months)
	TermMax           int64         // max term in epochs, default 5256000 (~5 years)
	ExpirationOffset  int64         // expiration offset in epochs, default 172800
}

type DDOTransactionReceipt struct {
	Hash        string
	BlockNumber uint64
	GasUsed     uint64
	Status      uint64
}

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

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

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

type OnChainPDPConfig struct {
	// DB is required.
	DB *gorm.DB
	// RPCURL is the FEVM JSON-RPC endpoint (read-only; we never submit txs).
	RPCURL string
	// SourceURLBase is the HTTPS base singularity serves pieces from. The
	// per-piece URL is constructed as <base>/piece/<pieceCidV2>. Required.
	SourceURLBase string
	// RecordKeeper is the FWSS contract address (hex). Empty defaults to
	// the network FWSS from go-synapse constants.
	RecordKeeper string
}

type Option func(*DealPusher)

type PDPPieceInput struct {
	PieceCID    cid.Cid
	PieceSize   int64 // padded
	PayloadSize int64 // real CAR bytes; encoded into the CommPv2 CID, fetched over HTTP
}

type PDPProofSetManager interface {
	// PullPiecesToFWSS pushes a batch of pieces to the SP via the FWSS-pull
	// flow. If no assembling proof set has room, a new FWSS-listened set is
	// created atomically with the first batch; otherwise pieces are added
	// to the existing assembling set. Blocks until Curio reports the SP
	// transfer is complete and the on-chain tx confirms (giving us the
	// dataSetId), or the configured timeout elapses. The returned
	// DataSetID is the set the pieces landed in.
	//
	// evmSigner is the client's secp256k1 wallet; its EVMAddress is the
	// on-chain payer, and its raw key (via signer.EVMSigner.ECDSAKey)
	// is used for the EIP-712 extraData signing.
	PullPiecesToFWSS(
		ctx context.Context,
		evmSigner signer.EVMSigner,
		provider string,
		pieces []PDPPieceInput,
		cfg PDPSchedulingConfig,
	) (PDPPullResult, error)
}

type PDPPullResult struct {
	// DataSetID is the FWSS-listened data set the pieces ended up in.
	// For new sets, this is the SetID Curio returns after the
	// createDataSet+addPieces tx confirms.
	DataSetID uint64
}

type PDPSchedulingConfig struct {
	// BatchSize bounds pieces per /pdp/piece/pull request.
	BatchSize int
	// MaxPiecesPerProofSet bounds pieces per data set; the scheduler starts
	// a new set when the current one fills.
	MaxPiecesPerProofSet int
	// PullTimeout bounds the time we wait for Curio to finish pulling a
	// batch (per request, not aggregate).
	PullTimeout time.Duration
}