mempool

type AccountRetriever interface {
	GetAccountNonce(address string) uint64
}

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

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

type AddressRecorder interface {
	GetAddressList() []string
	GetAddressNonce(address string) (uint64, bool)
	GetAddressTxsCnt(address string) int
	GetAddressTxs(address string, max int) types.Txs
	CleanItems(address string, nonce uint64)
}

type BaseTxQueue struct {
	*AddressRecord
	// contains filtered or unexported fields
}

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

type CListMempoolOption func(*CListMempool)

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

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

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

type ErrPreCheck struct {
	Reason error
}

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

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

type ExTxInfo struct {
	Sender      string   `json:"sender"`
	SenderNonce uint64   `json:"sender_nonce"`
	GasPrice    *big.Int `json:"gas_price"`
	Nonce       uint64   `json:"nonce"`
}

type GPOConfig struct {
	Weight  int
	Default *big.Int
	Blocks  int
}

type GasInfo struct {
	// GasWanted is the maximum units of work we allow this tx to perform.
	GasWanted uint64

	// GasUsed is the amount of gas actually consumed.
	GasUsed uint64
}

type GasTxQueue struct {
	*AddressRecord
	// contains filtered or unexported fields
}

type ITransactionQueue interface {
	Len() int
	Insert(tx *mempoolTx) error
	Remove(element *clist.CElement)
	RemoveByKey(key [sha256.Size]byte) *clist.CElement
	Front() *clist.CElement
	Back() *clist.CElement
	BroadcastFront() *clist.CElement
	BroadcastLen() int
	Load(hash [sha256.Size]byte) (*clist.CElement, bool)
	TxsWaitChan() <-chan struct{}

	AddressRecorder
}

type Mempool interface {
	// CheckTx executes a new transaction against the application to determine
	// its validity and whether it should be added to the mempool.
	CheckTx(tx types.Tx, callback func(*abci.Response), txInfo TxInfo) error

	ZeroReorgChan() <-chan int64
	GetZeroDataByBTCHeight(btcHeight int64) (types.ZeroData, error)
	DelZeroDataByBTCHeight(btcHeight int64)
	SetZeroDataDelivered(btcH int64, value bool)
	GetZeroDataMinHeight() int64
	DelAllPrevZeroDataBeforeHeight(height int64)

	ReapEssentialTx(tx types.Tx) abci.TxEssentials

	// ReapMaxTxs reaps up to max transactions from the mempool.
	// If max is negative, there is no cap on the size of all returned
	// transactions (~ all available transactions).
	ReapMaxTxs(max int) types.Txs

	ReapUserTxsCnt(address string) int

	// only for checkTx used!
	GetUserPendingTxsCnt(address string) int

	ReapUserTxs(address string, max int) types.Txs
	GetPendingNonce(address string) (uint64, bool)

	// Lock locks the mempool. The consensus must be able to hold lock to safely update.
	Lock()

	// Unlock unlocks the mempool.
	Unlock()

	// Update informs the mempool that the given txs were committed and can be discarded.
	// NOTE: this should be called *after* block is committed by consensus.
	// NOTE: Lock/Unlock must be managed by caller
	Update(
		blockHeight int64,
		blockTxs types.Txs,
		deliverTxResponses []*abci.ResponseDeliverTx,
		newPreFn PreCheckFunc,
		newPostFn PostCheckFunc,
	) error

	UpdateForBRCZeroData(height int64, btcHeight int64)
	// FlushAppConn flushes the mempool connection to ensure async reqResCb calls are
	// done. E.g. from CheckTx.
	// NOTE: Lock/Unlock must be managed by caller
	FlushAppConn() error

	// Flush removes all transactions from the mempool and cache
	Flush()

	// TxsAvailable returns a channel which fires once for every height,
	// and only when transactions are available in the mempool.
	// NOTE: the returned channel may be nil if EnableTxsAvailable was not called.
	TxsAvailable() <-chan struct{}

	// EnableTxsAvailable initializes the TxsAvailable channel, ensuring it will
	// trigger once every height when transactions are available.
	EnableTxsAvailable()

	// Size returns the number of transactions in the mempool.
	Size() int

	// TxsBytes returns the total size of all txs in the mempool.
	TxsBytes() int64

	SetEventBus(eventBus types.TxEventPublisher)

	GetConfig() *cfg.MempoolConfig
	GetTxByHash(hash [sha256.Size]byte) (types.Tx, error)

	GetAddressList() []string
	SetAccountRetriever(retriever AccountRetriever)

	SetTxInfoParser(parser TxInfoParser)

	GetTxSimulateGas(txHash string) int64

	GetEnableDeleteMinGPTx() bool

	GetPendingPoolTxsBytes() map[string]map[string]types.WrappedMempoolTx

	GetCurrentZeroData() map[int64]types.ZeroData
}

type Message interface{}

type Metrics struct {
	// Size of the mempool.
	Size metrics.Gauge
	// Histogram of transaction sizes, in bytes.
	TxSizeBytes metrics.Histogram
	// Number of failed transactions.
	FailedTxs metrics.Counter
	// Number of times transactions are rechecked in the mempool.
	RecheckTimes metrics.Counter
	// Size of the pending pool
	PendingPoolSize metrics.Gauge
	// Size of the pending pool
	GasUsed metrics.Gauge
}

type Oracle struct {
	CurrentBlockGPs *types.SingleBlockGPs
	// hold the gas prices of the latest few blocks
	BlockGPQueue *types.BlockGPResults
	// contains filtered or unexported fields
}

type PeerState interface {
	GetHeight() int64
}

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

type PostCheckFunc func(types.Tx, *abci.ResponseCheckTx) error

type PreCheckFunc func(types.Tx) error

type Reactor struct {
	p2p.BaseReactor
	// contains filtered or unexported fields
}

type Result struct {
	// Data is any data returned from message or handler execution. It MUST be length
	// prefixed in order to separate data from multiple message executions.
	Data []byte

	// Log contains the log information from message or handler execution.
	Log string

	// Events contains a slice of Event objects that were emitted during message or
	// handler execution.
	Events []abci.Event
}

type SimulationResponse struct {
	GasInfo
	Result *Result
}

type TxInfo struct {
	// SenderID is the internal peer ID used in the mempool to identify the
	// sender, storing 2 bytes with each tx instead of 20 bytes for the p2p.ID.
	SenderID uint16
	// SenderP2PID is the actual p2p.ID of the sender, used e.g. for logging.
	SenderP2PID p2p.ID
	// contains filtered or unexported fields
}

type TxInfoParser interface {
	GetRawTxInfo(tx types.Tx) ExTxInfo
	GetTxHistoryGasUsed(tx types.Tx, gasLimit int64) (int64, bool)
	GetRealTxFromRawTx(rawTx types.Tx) abci.TxEssentials
}

type TxMessage struct {
	Tx   types.Tx
	From string
}

type WrapCMTxMessage struct {
	Wtx  *types.WrapCMTx `json:"wtx"`
	From string          `json:"from"`
}

type WrappedTx struct {
	Payload   []byte `json:"payload"`   // std tx or evm tx
	From      string `json:"from"`      // from address of evm tx or ""
	Signature []byte `json:"signature"` // signature for payload
	NodeKey   []byte `json:"nodeKey"`   // pub key of the node who signs the tx
}

type WtxMessage struct {
	Wtx *WrappedTx
}