block

type BlockProposal interface {
	// UpdateProposal updates the proposal with the given transactions. There are a
	// few invarients that are checked:
	//  1. The total size of the proposal must be less than the maximum number of bytes allowed.
	//  2. The total size of the partial proposal must be less than the maximum number of bytes allowed for
	//     the lane.
	UpdateProposal(lane LaneProposal, partialProposalTxs [][]byte) error

	// GetMaxTxBytes returns the maximum number of bytes that can be included in the proposal.
	GetMaxTxBytes() int64

	// GetTotalTxBytes returns the total number of bytes currently included in the proposal.
	GetTotalTxBytes() int64

	// GetTxs returns the transactions in the proposal.
	GetTxs() [][]byte

	// GetNumTxs returns the number of transactions in the proposal.
	GetNumTxs() int

	// Contains returns true if the proposal contains the given transaction.
	Contains(tx []byte) bool

	// AddVoteExtension adds a vote extension to the proposal.
	AddVoteExtension(voteExtension []byte)

	// GetVoteExtensions returns the vote extensions in the proposal.
	GetVoteExtensions() [][]byte

	// GetProposal returns all of the transactions in the proposal along with the vote extensions
	// at the top of the proposal.
	GetProposal() [][]byte
}

type Lane interface {
	LaneMempool

	// PrepareLane builds a portion of the block. It inputs the maxTxBytes that can be
	// included in the proposal for the given lane, the partial proposal, and a function
	// to call the next lane in the chain. The next lane in the chain will be called with
	// the updated proposal and context.
	PrepareLane(
		ctx sdk.Context,
		proposal BlockProposal,
		maxTxBytes int64,
		next PrepareLanesHandler,
	) (BlockProposal, error)

	// CheckOrder validates that transactions belonging to this lane are not misplaced
	// in the block proposal and respect the ordering rules of the lane.
	CheckOrder(ctx sdk.Context, txs []sdk.Tx) error

	// ProcessLane verifies this lane's portion of a proposed block. It inputs the transactions
	// that may belong to this lane and a function to call the next lane in the chain. The next
	// lane in the chain will be called with the updated context and filtered down transactions.
	ProcessLane(ctx sdk.Context, proposalTxs []sdk.Tx, next ProcessLanesHandler) (sdk.Context, error)

	// GetMaxBlockSpace returns the max block space for the lane as a relative percentage.
	GetMaxBlockSpace() math.LegacyDec

	// Logger returns the lane's logger.
	Logger() log.Logger

	// Name returns the name of the lane.
	Name() string

	// SetAnteHandler sets the lane's antehandler.
	SetAnteHandler(antehander sdk.AnteHandler)

	// SetIgnoreList sets the lanes that should be ignored by this lane.
	SetIgnoreList(ignoreList []Lane)

	// Match determines if a transaction belongs to this lane.
	Match(ctx sdk.Context, tx sdk.Tx) bool
}

type LaneMempool interface {
	sdkmempool.Mempool

	// Compare determines the relative priority of two transactions belonging in the same lane. Compare
	// will return -1 if this transaction has a lower priority than the other transaction, 0 if they have
	// the same priority, and 1 if this transaction has a higher priority than the other transaction.
	Compare(ctx sdk.Context, this, other sdk.Tx) int

	// Contains returns true if the transaction is contained in the mempool.
	Contains(tx sdk.Tx) bool
}

type LaneProposal interface {
	// Logger returns the lane's logger.
	Logger() log.Logger

	// GetMaxBlockSpace returns the maximum block space for the lane as a relative percentage.
	GetMaxBlockSpace() math.LegacyDec

	// Name returns the name of the lane.
	Name() string
}

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

type Mempool interface {
	sdkmempool.Mempool

	// Registry returns the mempool's lane registry.
	Registry() []Lane

	// Contains returns the any of the lanes currently contain the transaction.
	Contains(tx sdk.Tx) bool

	// GetTxDistribution returns the number of transactions in each lane.
	GetTxDistribution() map[string]int
}

type PrepareLanesHandler func(ctx sdk.Context, proposal BlockProposal) (BlockProposal, error)

type ProcessLanesHandler func(ctx sdk.Context, txs []sdk.Tx) (sdk.Context, error)

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