mempool

type AuctionBidInfo struct {
	Bidder       sdk.AccAddress
	Bid          sdk.Coin
	Transactions [][]byte
	Timeout      uint64
	Signers      []map[string]struct{}
}

type AuctionFactory interface {
	// WrapBundleTransaction defines a function that wraps a bundle transaction into a sdk.Tx. Since
	// this is a potentially expensive operation, we allow each application chain to define how
	// they want to wrap the transaction such that it is only called when necessary (i.e. when the
	// transaction is being considered in the proposal handlers).
	WrapBundleTransaction(tx []byte) (sdk.Tx, error)

	// GetAuctionBidInfo defines a function that returns the bid info from an auction transaction.
	GetAuctionBidInfo(tx sdk.Tx) (*AuctionBidInfo, error)
}

type AuctionMempool struct {

	// AuctionFactory implements the functionality required to process auction transactions.
	AuctionFactory
	// contains filtered or unexported fields
}

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

type Mempool interface {
	// Inherit the methods of the SDK's Mempool interface.
	sdkmempool.Mempool

	// GetTopAuctionTx returns the top auction bid transaction in the mempool.
	GetTopAuctionTx(ctx context.Context) sdk.Tx

	// CoutnAuctionTx returns the number of auction bid transactions in the mempool.
	CountAuctionTx() int

	// AuctionBidSelect returns an iterator over the auction bid transactions in the mempool.
	AuctionBidSelect(ctx context.Context) sdkmempool.Iterator

	// Contains returns true if the mempool contains the given transaction.
	Contains(tx sdk.Tx) (bool, error)

	// AuctionFactory implements the functionality required to process auction transactions.
	AuctionFactory
}

type PriorityNonceIterator[C comparable] struct {
	// contains filtered or unexported fields
}

type PriorityNonceMempool[C comparable] struct {
	// contains filtered or unexported fields
}

type PriorityNonceMempoolConfig[C comparable] struct {
	// TxPriority defines the transaction priority and comparator.
	TxPriority TxPriority[C]

	// OnRead is a callback to be called when a tx is read from the mempool.
	OnRead func(tx sdk.Tx)

	// TxReplacement is a callback to be called when duplicated transaction nonce
	// detected during mempool insert. An application can define a transaction
	// replacement rule based on tx priority or certain transaction fields.
	TxReplacement func(op, np C, oTx, nTx sdk.Tx) bool

	// MaxTx sets the maximum number of transactions allowed in the mempool with
	// the semantics:
	// - if MaxTx == 0, there is no cap on the number of transactions in the mempool
	// - if MaxTx > 0, the mempool will cap the number of transactions it stores,
	//   and will prioritize transactions by their priority and sender-nonce
	//   (sequence number) when evicting transactions.
	// - if MaxTx < 0, `Insert` is a no-op.
	MaxTx int
}

type TxPriority[C comparable] struct {
	// GetTxPriority returns the priority of the transaction. A priority must be
	// comparable via Compare.
	GetTxPriority func(ctx context.Context, tx sdk.Tx) C

	// CompareTxPriority compares two transaction priorities. The result should be
	// 0 if a == b, -1 if a < b, and +1 if a > b.
	Compare func(a, b C) int

	// MinValue defines the minimum priority value, e.g. MinInt64. This value is
	// used when instantiating a new iterator and comparing weights.
	MinValue C
}

type TxWithTimeoutHeight interface {
	sdk.Tx

	GetTimeoutHeight() uint64
}