mempool

package
v0.39.0-beta.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 9, 2026 License: Apache-2.0 Imports: 27 Imported by: 82

Documentation

Overview

TODO: Better handle abci client errors. (make it automatically handle connection errors)

Index

Constants

View Source 
const (
	MempoolChannel = byte(0x30)

	// PeerCatchupSleepIntervalMS defines how much time to sleep if a peer is behind
	PeerCatchupSleepIntervalMS = 100

	// UnknownPeerID is the peer ID to use when running CheckTx when there is
	// no peer (e.g. RPC)
	UnknownPeerID uint16 = 0

	MaxActiveIDs = math.MaxUint16
)
View Source 
const (
	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
	// package.
	MetricsSubsystem = "mempool"
)

Variables

View Source 
var (
	ErrNotImplemented = errors.New("not implemented")
	ErrEmptyTx        = errors.New("tx is empty")
	ErrSeenTx         = errors.New("tx already seen")
)
View Source 
var ErrRecheckFull = errors.New("mempool is still rechecking after a new committed block, so it is considered as full")

ErrRecheckFull is returned when checking if the mempool is full and rechecking is still in progress after a new block was committed.

View Source 
var ErrTxInCache = errors.New("tx already exists in cache")

ErrTxInCache is returned to the client if we saw tx earlier

View Source 
var ErrTxNotFound = errors.New("transaction not found in mempool")

ErrTxNotFound is returned to the client if tx is not found in mempool

Functions

func IsPreCheckError 

func IsPreCheckError(err error) bool

IsPreCheckError returns true if err is due to pre check failure.

Types

type AppMempool 

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

AppMempool represents a mempool that's implemented completely on the app-side via ABCI methods in opposite to concurrent-list mempool that stores transactions on comet's side. AppMempool only proxies requests to the app and broadcasts transactions to peers. Expectations are: - The app is expected to handle PreCheck, PostCheck, and Recheck by itself; - The mempool always returns 0 txs for ReapMaxBytesMaxGas as the app is expected to build the block; - It doesn't block other reactors for ABCI methods --> the app is expected to handle the mempool concurrently;

func NewAppMempool 

func NewAppMempool(
	config *config.MempoolConfig,
	app AppMempoolClient,
	opts ...AppMempoolOpt,
) *AppMempool

func (*AppMempool) CheckTx 

func (m *AppMempool) CheckTx(tx types.Tx, callback func(res *abci.ResponseCheckTx), _ TxInfo) error

CheckTx calls the appliction's CheckTx method.

func (*AppMempool) EnableTxsAvailable 

func (m *AppMempool) EnableTxsAvailable()

func (*AppMempool) Flush 

func (m *AppMempool) Flush()

func (*AppMempool) FlushAppConn 

func (m *AppMempool) FlushAppConn() error

FlushAppConn flushes app client (copied from CListMempool)

func (*AppMempool) InsertTx 

func (m *AppMempool) InsertTx(tx types.Tx) error

InsertTx inserts a tx into app-side mempool. The call is blocking, but thread-safe. Concurrent calls are expected and are caller's responsibility to handle.

func (*AppMempool) Lock 

func (m *AppMempool) Lock()

func (*AppMempool) ReapMaxBytesMaxGas 

func (m *AppMempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs

func (*AppMempool) ReapMaxTxs 

func (m *AppMempool) ReapMaxTxs(_ int) types.Txs

func (*AppMempool) RemoveTxByKey 

func (m *AppMempool) RemoveTxByKey(_ types.TxKey) error

func (*AppMempool) Size 

func (m *AppMempool) Size() int

func (*AppMempool) SizeBytes 

func (m *AppMempool) SizeBytes() int64

func (*AppMempool) TxStream 

func (m *AppMempool) TxStream(ctx context.Context) <-chan types.Txs

TxStream spins up a channel that streams valid transactions from app-side mempool. The expectation is that the caller would share it with other peers to gossip transactions. chan type is a list of txs, it is guaranteed to be non-empty.

func (*AppMempool) TxsAvailable 

func (m *AppMempool) TxsAvailable() <-chan struct{}

reading from this channel will block forever, which is fine for an app mempool

func (*AppMempool) Unlock 

func (m *AppMempool) Unlock()

func (*AppMempool) Update 

func (m *AppMempool) Update(_ int64, _ types.Txs, _ []*abci.ExecTxResult, _ PreCheckFunc, _ PostCheckFunc) error

Update does nothing for an app mempool

type AppMempoolClient 

type AppMempoolClient interface {
	// InsertTx inserts a tx into app-side mempool
	InsertTx(ctx context.Context, req *abci.RequestInsertTx) (*abci.ResponseInsertTx, error)

	// CheckTxUnlocked expects the application to check the transaction, inserting if successful.
	// NOTE: Comet will not lock this method; it is expected the application side will acquire all necessary locks for successful checking.
	CheckTxUnlocked(ctx context.Context, req *abci.RequestCheckTx) (*abci.ResponseCheckTx, error)

	// ReapTxs reaps txs from app-side mempool
	ReapTxs(ctx context.Context, req *abci.RequestReapTxs) (*abci.ResponseReapTxs, error)

	// Flush app's connection
	Flush(context.Context) error
}

AppMempoolClient is the interface for the app-side mempool.

type AppMempoolOpt 

type AppMempoolOpt func(*AppMempool)

AppMempoolOpt is the option for AppMempool

func WithAMLogger 

func WithAMLogger(logger log.Logger) AppMempoolOpt

func WithAMMetrics 

func WithAMMetrics(metrics *Metrics) AppMempoolOpt

type AppReactor 

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

AppReactor for interacting with AppMempool

func NewAppReactor 

func NewAppReactor(
	config *config.MempoolConfig,
	mempool *AppMempool,
	waitForSync bool,
) *AppReactor

func (*AppReactor) EnableInOutTxs 

func (r *AppReactor) EnableInOutTxs()

EnableInOutTxs enables inbound and outbound transactions

func (*AppReactor) GetChannels 

func (r *AppReactor) GetChannels() []*p2p.ChannelDescriptor

GetChannels implements p2p.BaseReactor.

func (*AppReactor) OnStart 

func (r *AppReactor) OnStart() error

OnStart implements p2p.BaseReactor.

func (*AppReactor) OnStop 

func (r *AppReactor) OnStop()

func (*AppReactor) Receive 

func (r *AppReactor) Receive(e p2p.Envelope)

func (*AppReactor) WaitSync 

func (r *AppReactor) WaitSync() bool

WaitSync used for backward compatibility with external callers

type CListMempool added in v0.38.0 

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

CListMempool is an ordered in-memory pool for transactions before they are proposed in a consensus round. Transaction validity is checked using the CheckTx abci message before the transaction is added to the pool. The mempool uses a concurrent list structure for storing transactions that can be efficiently accessed by multiple concurrent readers.

func NewCListMempool added in v0.38.0 

func NewCListMempool(
	cfg *config.MempoolConfig,
	proxyAppConn proxy.AppConnMempool,
	height int64,
	options ...CListMempoolOption,
) *CListMempool

NewCListMempool returns a new mempool with the given configuration and connection to an application.

func (*CListMempool) CheckTx added in v0.38.0 

func (mem *CListMempool) CheckTx(
	tx types.Tx,
	cb func(*abci.ResponseCheckTx),
	txInfo TxInfo,
) error

It blocks if we're waiting on Update() or Reap(). cb: A callback from the CheckTx command. 

It gets called from another goroutine.

CONTRACT: Either cb will get called, or err returned.

Safe for concurrent use by multiple goroutines.

func (*CListMempool) EnableTxsAvailable added in v0.38.0 

func (mem *CListMempool) EnableTxsAvailable()

NOTE: not thread safe - should only be called once, on startup

func (*CListMempool) Flush added in v0.38.0 

func (mem *CListMempool) Flush()

XXX: Unsafe! Calling Flush may leave mempool in inconsistent state.

func (*CListMempool) FlushAppConn added in v0.38.0 

func (mem *CListMempool) FlushAppConn() error

Lock() must be help by the caller during execution.

func (*CListMempool) Lock added in v0.38.0 

func (mem *CListMempool) Lock()

Safe for concurrent use by multiple goroutines.

func (*CListMempool) ReapMaxBytesMaxGas added in v0.38.0 

func (mem *CListMempool) ReapMaxBytesMaxGas(maxBytes, maxGas int64) types.Txs

Safe for concurrent use by multiple goroutines.

func (*CListMempool) ReapMaxTxs added in v0.38.0 

func (mem *CListMempool) ReapMaxTxs(max int) types.Txs

Safe for concurrent use by multiple goroutines.

func (*CListMempool) RemoveTxByKey added in v0.38.0 

func (mem *CListMempool) RemoveTxByKey(txKey types.TxKey) error

RemoveTxByKey removes a transaction from the mempool by its TxKey index. Called from:

  • Update (lock held) if tx was committed
  • resCbRecheck (lock not held) if tx was invalidated

func (*CListMempool) SetLogger added in v0.38.0 

func (mem *CListMempool) SetLogger(l log.Logger)

SetLogger sets the Logger.

func (*CListMempool) Size added in v0.38.0 

func (mem *CListMempool) Size() int

Safe for concurrent use by multiple goroutines.

func (*CListMempool) SizeBytes added in v0.38.0 

func (mem *CListMempool) SizeBytes() int64

Safe for concurrent use by multiple goroutines.

func (*CListMempool) TxsAvailable added in v0.38.0 

func (mem *CListMempool) TxsAvailable() <-chan struct{}

Safe for concurrent use by multiple goroutines.

func (*CListMempool) TxsFront added in v0.38.0 

func (mem *CListMempool) TxsFront() *clist.CElement

TxsFront returns the first transaction in the ordered list for peer goroutines to call .NextWait() on. FIXME: leaking implementation details!

Safe for concurrent use by multiple goroutines.

func (*CListMempool) TxsWaitChan added in v0.38.0 

func (mem *CListMempool) TxsWaitChan() <-chan struct{}

TxsWaitChan returns a channel to wait on transactions. It will be closed once the mempool is not empty (ie. the internal `mem.txs` has at least one element)

Safe for concurrent use by multiple goroutines.

func (*CListMempool) Unlock added in v0.38.0 

func (mem *CListMempool) Unlock()

Safe for concurrent use by multiple goroutines.

func (*CListMempool) Update added in v0.38.0 

func (mem *CListMempool) Update(
	height int64,
	txs types.Txs,
	txResults []*abci.ExecTxResult,
	preCheck PreCheckFunc,
	postCheck PostCheckFunc,
) error

Lock() must be help by the caller during execution.

type CListMempoolOption added in v0.38.0 

type CListMempoolOption func(*CListMempool)

CListMempoolOption sets an optional parameter on the mempool.

func WithMetrics added in v0.38.0 

func WithMetrics(metrics *Metrics) CListMempoolOption

WithMetrics sets the metrics.

func WithPostCheck added in v0.38.0 

func WithPostCheck(f PostCheckFunc) CListMempoolOption

WithPostCheck sets a filter for the mempool to reject a tx if f(tx) returns false. This is ran after CheckTx. Only applies to the first created block. After that, Update overwrites the existing value.

func WithPreCheck added in v0.38.0 

func WithPreCheck(f PreCheckFunc) CListMempoolOption

WithPreCheck sets a filter for the mempool to reject a tx if f(tx) returns false. This is ran before CheckTx. Only applies to the first created block. After that, Update overwrites the existing value.

type ErrAppConnMempool added in v0.38.6 

type ErrAppConnMempool struct {
	Err error
}

func (ErrAppConnMempool) Error added in v0.38.6 

func (e ErrAppConnMempool) Error() string

func (ErrAppConnMempool) Unwrap added in v0.38.6 

func (e ErrAppConnMempool) Unwrap() error

type ErrFlushAppConn added in v0.38.6 

type ErrFlushAppConn struct {
	Err error
}

func (ErrFlushAppConn) Error added in v0.38.6 

func (e ErrFlushAppConn) Error() string

func (ErrFlushAppConn) Unwrap added in v0.38.6 

func (e ErrFlushAppConn) Unwrap() error

type ErrMempoolIsFull 

type ErrMempoolIsFull struct {
	NumTxs      int
	MaxTxs      int
	TxsBytes    int64
	MaxTxsBytes int64
	RecheckFull bool
}

ErrMempoolIsFull defines an error where CometBFT and the application cannot handle that much load.

func (ErrMempoolIsFull) Error 

func (e ErrMempoolIsFull) Error() string

type ErrPreCheck 

type ErrPreCheck struct {
	Err error
}

ErrPreCheck defines an error where a transaction fails a pre-check.

func (ErrPreCheck) Error 

func (e ErrPreCheck) Error() string

func (ErrPreCheck) Unwrap added in v0.38.6 

func (e ErrPreCheck) Unwrap() error

type ErrTxTooLarge 

type ErrTxTooLarge struct {
	Max    int
	Actual int
}

ErrTxTooLarge defines an error when a transaction is too big to be sent in a message to other peers.

func (ErrTxTooLarge) Error 

func (e ErrTxTooLarge) Error() string

type LRUTxCache 

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

LRUTxCache maintains a thread-safe LRU cache of raw transactions. The cache only stores the hash of the raw transaction.

func NewLRUTxCache 

func NewLRUTxCache(cacheSize int) *LRUTxCache

func (*LRUTxCache) GetList 

func (c *LRUTxCache) GetList() *list.List

GetList returns the underlying linked-list that backs the LRU cache. Note, this should be used for testing purposes only!

func (*LRUTxCache) Has 

func (c *LRUTxCache) Has(tx types.Tx) bool

func (*LRUTxCache) Push 

func (c *LRUTxCache) Push(tx types.Tx) bool

func (*LRUTxCache) Remove 

func (c *LRUTxCache) Remove(tx types.Tx)

func (*LRUTxCache) Reset 

func (c *LRUTxCache) Reset()

Reset resets the cache to an empty state.

type Mempool 

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.ResponseCheckTx), txInfo TxInfo) error

	// RemoveTxByKey removes a transaction, identified by its key,
	// from the mempool.
	RemoveTxByKey(txKey types.TxKey) error

	// ReapMaxBytesMaxGas reaps transactions from the mempool up to maxBytes
	// bytes total with the condition that the total gasWanted must be less than
	// maxGas.
	//
	// If both maxes are negative, there is no cap on the size of all returned
	// transactions (~ all available transactions).
	ReapMaxBytesMaxGas(maxBytes, maxGas int64) types.Txs

	// 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

	// Lock locks the mempool. The consensus must be able to hold lock to safely
	// update.
	// Before acquiring the lock, it signals the mempool that a new update is coming.
	// If the mempool is still rechecking at this point, it should be considered full.
	Lock()

	// Unlock unlocks the mempool.
	Unlock()

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

	// FlushAppConn flushes the mempool connection to ensure async callback calls
	// are done, e.g. from CheckTx.
	//
	// NOTE:
	// 1. Lock/Unlock must be managed by caller.
	FlushAppConn() error

	// Flush removes all transactions from the mempool and caches.
	Flush()

	// TxsAvailable returns a channel which fires once for every height, and only
	// when transactions are available in the mempool.
	//
	// NOTE:
	// 1. 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

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

Mempool defines the mempool interface.

Updates to the mempool need to be synchronized with committing a block so applications can reset their transient state on Commit.

type Metrics 

type Metrics struct {
	// Number of uncommitted transactions in the mempool.
	Size metrics.Gauge

	// Total size of the mempool in bytes.
	SizeBytes metrics.Gauge

	// Histogram of transaction sizes in bytes.
	TxSizeBytes metrics.Histogram `metrics_buckettype:"exp" metrics_bucketsizes:"1,3,7"`

	// FailedTxs defines the number of failed transactions. These are
	// transactions that failed to make it into the mempool because they were
	// deemed invalid.
	// metrics:Number of failed transactions.
	FailedTxs metrics.Counter

	// RejectedTxs defines the number of rejected transactions. These are
	// transactions that failed to make it into the mempool due to resource
	// limits, e.g. mempool is full.
	// metrics:Number of rejected transactions.
	RejectedTxs metrics.Counter

	// EvictedTxs defines the number of evicted transactions. These are valid
	// transactions that passed CheckTx and make it into the mempool but later
	// became invalid.
	// metrics:Number of evicted transactions.
	EvictedTxs metrics.Counter

	// Number of times transactions are rechecked in the mempool.
	RecheckTimes metrics.Counter

	// Number of connections being actively used for gossiping transactions
	// (experimental feature).
	ActiveOutboundConnections metrics.Gauge

	// Number of times transactions were received more than once.
	//metrics:Number of duplicate transaction reception.
	AlreadyReceivedTxs metrics.Counter

	// BatchSize size of an inbound/outbound batch of mempool txs (in txs num, not bytes)
	BatchSize metrics.Histogram `metrics_labels:"dir" metrics_bucketsizes:"1,2,5,10,30,50,100,200,300"`

	// ReapedTxs is the number of transactions reaped from the mempool
	ReapedTxs metrics.Counter
}

Metrics contains metrics exposed by this package. see MetricsProvider for descriptions.

func NopMetrics 

func NopMetrics() *Metrics

func PrometheusMetrics 

func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics

type NopMempool added in v0.37.4 

type NopMempool struct{}

NopMempool is a mempool that does nothing.

The ABCI app is responsible for storing, disseminating, and proposing transactions. See [ADR-111](../docs/architecture/adr-111-nop-mempool.md).

func (*NopMempool) CheckTx added in v0.37.4 

func (*NopMempool) CheckTx(types.Tx, func(*abci.ResponseCheckTx), TxInfo) error

CheckTx always returns an error.

func (*NopMempool) EnableTxsAvailable added in v0.37.4 

func (*NopMempool) EnableTxsAvailable()

EnableTxsAvailable does nothing.

func (*NopMempool) Flush added in v0.37.4 

func (*NopMempool) Flush()

Flush does nothing.

func (*NopMempool) FlushAppConn added in v0.37.4 

func (*NopMempool) FlushAppConn() error

FlushAppConn does nothing.

func (*NopMempool) Lock added in v0.37.4 

func (*NopMempool) Lock()

Lock does nothing.

func (*NopMempool) ReapMaxBytesMaxGas added in v0.37.4 

func (*NopMempool) ReapMaxBytesMaxGas(int64, int64) types.Txs

ReapMaxBytesMaxGas always returns nil.

func (*NopMempool) ReapMaxTxs added in v0.37.4 

func (*NopMempool) ReapMaxTxs(int) types.Txs

ReapMaxTxs always returns nil.

func (*NopMempool) RemoveTxByKey added in v0.37.4 

func (*NopMempool) RemoveTxByKey(types.TxKey) error

RemoveTxByKey always returns an error.

func (*NopMempool) SetTxRemovedCallback added in v0.37.4 

func (*NopMempool) SetTxRemovedCallback(func(txKey types.TxKey))

SetTxRemovedCallback does nothing.

func (*NopMempool) Size added in v0.37.4 

func (*NopMempool) Size() int

Size always returns 0.

func (*NopMempool) SizeBytes added in v0.37.4 

func (*NopMempool) SizeBytes() int64

SizeBytes always returns 0.

func (*NopMempool) TxsAvailable added in v0.37.4 

func (*NopMempool) TxsAvailable() <-chan struct{}

TxsAvailable always returns nil.

func (*NopMempool) Unlock added in v0.37.4 

func (*NopMempool) Unlock()

Unlock does nothing.

func (*NopMempool) Update added in v0.37.4 

func (*NopMempool) Update(
	int64,
	types.Txs,
	[]*abci.ExecTxResult,
	PreCheckFunc,
	PostCheckFunc,
) error

Update does nothing.

type NopMempoolReactor added in v0.37.4 

type NopMempoolReactor struct {
	service.BaseService
}

NopMempoolReactor is a mempool reactor that does nothing.

func NewNopMempoolReactor added in v0.37.4 

func NewNopMempoolReactor() *NopMempoolReactor

NewNopMempoolReactor returns a new `nop` reactor.

To be used only in RPC.

func (*NopMempoolReactor) AddPeer added in v0.37.4 

func (*NopMempoolReactor) AddPeer(p2p.Peer)

AddPeer does nothing.

func (*NopMempoolReactor) GetChannels added in v0.37.4 

func (*NopMempoolReactor) GetChannels() []*p2p.ChannelDescriptor

GetChannels always returns nil.

func (*NopMempoolReactor) InitPeer added in v0.37.4 

func (*NopMempoolReactor) InitPeer(p2p.Peer) p2p.Peer

InitPeer always returns nil.

func (*NopMempoolReactor) Receive added in v0.38.2 

func (*NopMempoolReactor) Receive(p2p.Envelope)

Receive does nothing.

func (*NopMempoolReactor) RemovePeer added in v0.37.4 

func (*NopMempoolReactor) RemovePeer(p2p.Peer, any)

RemovePeer does nothing.

func (*NopMempoolReactor) SetSwitch added in v0.37.4 

func (*NopMempoolReactor) SetSwitch(p2p.Switcher)

SetSwitch does nothing.

func (*NopMempoolReactor) WaitSync added in v0.37.4 

func (*NopMempoolReactor) WaitSync() bool

WaitSync always returns false

type NopTxCache 

type NopTxCache struct{}

NopTxCache defines a no-op raw transaction cache.

func (NopTxCache) Has 

func (NopTxCache) Has(types.Tx) bool

func (NopTxCache) Push 

func (NopTxCache) Push(types.Tx) bool

func (NopTxCache) Remove 

func (NopTxCache) Remove(types.Tx)

func (NopTxCache) Reset 

func (NopTxCache) Reset()

type PeerState added in v0.38.0 

type PeerState interface {
	GetHeight() int64
}

PeerState describes the state of a peer.

type PostCheckFunc 

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

PostCheckFunc is an optional filter executed after CheckTx and rejects transaction if false is returned. An example would be to ensure a transaction doesn't require more gas than available for the block.

func PostCheckMaxGas 

func PostCheckMaxGas(maxGas int64) PostCheckFunc

PostCheckMaxGas checks that the wanted gas is smaller or equal to the passed maxGas. Returns nil if maxGas is -1.

type PreCheckFunc 

type PreCheckFunc func(types.Tx) error

PreCheckFunc is an optional filter executed before CheckTx and rejects transaction if false is returned. An example would be to ensure that a transaction doesn't exceeded the block size.

func PreCheckMaxBytes 

func PreCheckMaxBytes(maxBytes int64) PreCheckFunc

PreCheckMaxBytes checks that the size of the transaction is smaller or equal to the expected maxBytes.

type Reactor added in v0.38.0 

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

Reactor handles mempool tx broadcasting amongst peers. It maintains a map from peer ID to counter, to prevent gossiping txs to the peers you received it from.

func NewReactor added in v0.38.0 

func NewReactor(config *cfg.MempoolConfig, mempool *CListMempool, waitSync bool) *Reactor

NewReactor returns a new Reactor with the given config and mempool.

func (*Reactor) AddPeer added in v0.38.0 

func (memR *Reactor) AddPeer(peer p2p.Peer)

AddPeer implements Reactor. It starts a broadcast routine ensuring all txs are forwarded to the given peer.

func (*Reactor) EnableInOutTxs added in v1.0.0 

func (memR *Reactor) EnableInOutTxs()

func (*Reactor) GetChannels added in v0.38.0 

func (memR *Reactor) GetChannels() []*p2p.ChannelDescriptor

GetChannels implements Reactor by returning the list of channels for this reactor.

func (*Reactor) InitPeer added in v0.38.0 

func (memR *Reactor) InitPeer(peer p2p.Peer) p2p.Peer

InitPeer implements Reactor by creating a state for the peer.

func (*Reactor) OnStart added in v0.38.0 

func (memR *Reactor) OnStart() error

OnStart implements p2p.BaseReactor.

func (*Reactor) Receive added in v0.38.0 

func (memR *Reactor) Receive(e p2p.Envelope)

Receive implements Reactor. It adds any received transactions to the mempool.

func (*Reactor) RemovePeer added in v0.38.0 

func (memR *Reactor) RemovePeer(peer p2p.Peer, _ any)

RemovePeer implements Reactor.

func (*Reactor) SetLogger added in v0.38.0 

func (memR *Reactor) SetLogger(l log.Logger)

SetLogger sets the Logger on the reactor and the underlying mempool.

func (*Reactor) WaitSync added in v1.0.0 

func (memR *Reactor) WaitSync() bool

type TxCache 

type TxCache interface {
	// Reset resets the cache to an empty state.
	Reset()

	// Push adds the given raw transaction to the cache and returns true if it was
	// newly added. Otherwise, it returns false.
	Push(tx types.Tx) bool

	// Remove removes the given raw transaction from the cache.
	Remove(tx types.Tx)

	// Has reports whether tx is present in the cache. Checking for presence is
	// not treated as an access of the value.
	Has(tx types.Tx) bool
}

TxCache defines an interface for raw transaction caching in a mempool. Currently, a TxCache does not allow direct reading or getting of transaction values. A TxCache is used primarily to push transactions and removing transactions. Pushing via Push returns a boolean telling the caller if the transaction already exists in the cache or not.

type TxInfo 

type TxInfo struct {
	// SenderID is the internal peer ID used in the mempool to identify the
	// sender, storing two bytes with each transaction instead of 20 bytes for
	// the types.NodeID.
	SenderID uint16

	// SenderP2PID is the actual p2p.ID of the sender, used e.g. for logging.
	SenderP2PID p2p.ID
}

TxInfo are parameters that get passed when attempting to add a tx to the mempool.

type TxKey 

type TxKey [sha256.Size]byte

TxKey is the fixed length array key used as an index.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.