ethreceipts

type FilterCond struct {
	TxnHash  *ethkit.Hash
	From     *ethkit.Address
	To       *ethkit.Address
	LogTopic *ethkit.Hash // event signature topic hash
	Logs     func([]*types.Log) bool
}

type FilterOptions struct {
	// ID is a caller-supplied label, not a unique registration identity.
	ID uint64

	// Finalize requests a final receipt after the mined receipt.
	Finalize bool

	// LimitOne stops matching after one mined receipt and preserves queued finality.
	LimitOne bool

	// SearchCache searches the monitor's retained blocks when the filter is registered.
	SearchCache bool

	// QueryOnChainTxnHash will query the chain for the txn hash at the start
	// of a filter subscription. This is only useful when used in combination with
	// TxnHash filter cond, to search for past transactions which may have been
	// mined before the filter was created.
	QueryOnChainTxnHash bool

	// QueryOnChain optionally fetches a receipt when the filter is registered.
	QueryOnChain func(context.Context) (*types.Receipt, error)

	// MaxWait limits blocks without a match before matching is exhausted.
	// Receipts already queued for finality are still finalized.
	//
	// nil : use the ReceiptsListener option FilterMaxWaitNumBlocks value as the default
	// <0  : use ReceiptsListener option NumBlocksToFinality * 2
	// 0   : option is disabled, and has no limit on wait. filters need to be manually unsubscribed
	// N   : a specified number of blocks without a match before exhaustion
	MaxWait *int
}

type FilterQuery interface {
	ID(uint64) FilterQuery
	Finalize(bool) FilterQuery
	LimitOne(bool) FilterQuery
	SearchCache(bool) FilterQuery
	QueryOnChainTxnHash(bool) FilterQuery
	QueryOnChain(func(context.Context) (*types.Receipt, error)) FilterQuery
	MaxWait(int) FilterQuery

	// Deprecated: use QueryOnChainTxnHash instead.
	SearchOnChain(bool) FilterQuery
}

type Filterer interface {
	FilterQuery

	FilterID() uint64
	Options() FilterOptions
	Cond() FilterCond

	Match(ctx context.Context, receipt Receipt) (bool, error)
	StartBlockNum() uint64
	LastMatchBlockNum() uint64
	Exhausted() <-chan struct{}
}

type Options struct {
	// MaxConcurrentFetchReceiptWorkers limits concurrent receipt RPC requests.
	MaxConcurrentFetchReceiptWorkers int

	// MaxConcurrentFilterWorkers limits concurrent block and filter processing.
	MaxConcurrentFilterWorkers int

	// MaxConcurrentSearchOnChainWorkers limits on-chain searches per subscriber.
	MaxConcurrentSearchOnChainWorkers int

	// PastReceiptsCacheSize limits the number of cached receipts.
	PastReceiptsCacheSize int

	// NumBlocksToFinality is the number of blocks after mining required for finality.
	// Values <= 0 select the network's finality policy when Run starts.
	NumBlocksToFinality int

	// FilterMaxWaitNumBlocks sets the default block wait between filter matches.
	// Zero disables the limit. Individual filters can override it with MaxWait.
	FilterMaxWaitNumBlocks int

	// Alerter receives listener and subscriber alerts.
	Alerter util.Alerter
}

type Receipt struct {
	Filter  Filterer // reference to filter which triggered this event
	Final   bool     // flags that this receipt is finalized
	Reorged bool     // chain reorged / removed the txn
	// contains filtered or unexported fields
}

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

type Subscription interface {
	TransactionReceipt() <-chan Receipt
	Done() <-chan struct{}
	// Unsubscribe closes the subscription. Repeated and concurrent calls are safe.
	Unsubscribe()

	Filters() []Filterer
	AddFilter(filters ...FilterQuery)
	// RemoveFilter removes the first matching active registration, or its queued
	// finality owner if inactive. Comparable filters retain Go equality. Otherwise
	// callback-bearing values of the same type use a stable nonnil Exhausted signal
	// as base identity. Values sharing a base are aliases; distinct callbacks need
	// distinct bases or pointer identities for independent removal. Values without
	// a stable signal should be registered as pointers for individual removal.
	RemoveFilter(filter Filterer)
	ClearFilters()
}

type WaitReceiptFinalityFunc func(ctx context.Context) (*Receipt, error)