txpool

Documentation

Index

• Variables
• type BlockInfo
• type Config
• type MainQueueTransaction
  • func (tx *MainQueueTransaction) Priority() uint64
  • func (tx *MainQueueTransaction) Sender() string
  • func (tx *MainQueueTransaction) SenderSeq() uint64
  • func (tx *MainQueueTransaction) String() string
• type PendingCheckTransaction
• type RecheckableTransactionStore
• type RepublishableTransactionSource
• type RuntimeHostProvisioner
• type TransactionMeta
• type TransactionPool
  • func New(runtimeID common.Namespace, cfg *Config, host RuntimeHostProvisioner, ...) (TransactionPool, error)
• type TransactionPublisher
• type TxQueueMeta
  • func (t *TxQueueMeta) FirstSeen() time.Time
  • func (t *TxQueueMeta) Hash() hash.Hash
  • func (t *TxQueueMeta) Raw() []byte
  • func (t *TxQueueMeta) Size() int
• type UsableTransactionSource

Variables

var (
	ErrReplacementTxPriorityTooLow = errors.New("txpool: replacement tx priority too low")
	ErrQueueFull                   = errors.New("txpool: schedule queue is full")
)

Types

type BlockInfo

type BlockInfo struct {
	// RuntimeBlock is the runtime block.
	RuntimeBlock *block.Block

	// ConsensusBlock is the consensus light block the runtime block belongs to.
	ConsensusBlock *consensus.LightBlock

	// Epoch is the epoch the runtime block belongs to.
	Epoch beacon.EpochTime

	// ActiveDescriptor is the runtime descriptor active for the runtime block.
	ActiveDescriptor *registry.Runtime
}

BlockInfo contains information related to the given runtime block.

type Config

type Config struct {
	MaxPoolSize          uint64
	MaxCheckTxBatchSize  uint64
	MaxLastSeenCacheSize uint64

	RepublishInterval time.Duration

	// RecheckInterval is the interval (in rounds) when any pending transactions are subject to a
	// recheck and any non-passing transactions are removed.
	RecheckInterval uint64
}

Config is the transaction pool configuration.

type MainQueueTransaction

type MainQueueTransaction struct {
	TxQueueMeta
	// contains filtered or unexported fields
}

MainQueueTransaction is a transaction and its metadata in the main queue.

func (*MainQueueTransaction) Priority

func (tx *MainQueueTransaction) Priority() uint64

Priority returns the transaction priority.

func (*MainQueueTransaction) Sender

func (tx *MainQueueTransaction) Sender() string

Sender returns the transaction sender.

func (*MainQueueTransaction) SenderSeq

func (tx *MainQueueTransaction) SenderSeq() uint64

SenderSeq returns the per-sender sequence number.

func (*MainQueueTransaction) String

func (tx *MainQueueTransaction) String() string

String returns a string representation of a transaction.

type PendingCheckTransaction

type PendingCheckTransaction struct {
	*TxQueueMeta
	// contains filtered or unexported fields
}

PendingCheckTransaction is a transaction pending checks.

type RecheckableTransactionStore

type RecheckableTransactionStore interface {
	// TakeAll removes all txs and returns them.
	TakeAll() []*TxQueueMeta
	// OfferChecked adds a tx that is checked.
	OfferChecked(tx *TxQueueMeta, meta *protocol.CheckTxMetadata) error
}

RecheckableTransactionStore provides methods for rechecking.

type RepublishableTransactionSource

type RepublishableTransactionSource interface {
	// GetTxsToPublish gets txs that this queue wants to publish.
	GetTxsToPublish() []*TxQueueMeta
}

RepublishableTransactionSource is a place to get txs that we want to push.

type RuntimeHostProvisioner

type RuntimeHostProvisioner interface {
	// WaitHostedRuntime waits for the hosted runtime to be provisioned and returns it.
	WaitHostedRuntime(ctx context.Context) (host.RichRuntime, error)
}

RuntimeHostProvisioner is a runtime host provisioner.

type TransactionMeta

type TransactionMeta struct {
	// Local is a flag indicating that the transaction was obtained from a local client.
	Local bool

	// Discard is a flag indicating that the transaction should be discarded after checks.
	Discard bool
}

TransactionMeta contains the per-transaction metadata.

type TransactionPool

type TransactionPool interface {
	// Start starts the service.
	Start() error

	// Stop halts the service.
	Stop()

	// Quit returns a channel that will be closed when the service terminates.
	Quit() <-chan struct{}

	// SubmitTx adds the transaction into the transaction pool, first performing checks on it by
	// invoking the runtime. This method waits for the checks to complete.
	SubmitTx(ctx context.Context, tx []byte, meta *TransactionMeta) (*protocol.CheckTxResult, error)

	// SubmitTxNoWait adds the transaction into the transaction pool and returns immediately.
	SubmitTxNoWait(ctx context.Context, tx []byte, meta *TransactionMeta) error

	// SubmitProposedBatch adds the given (possibly new) transaction batch into the current
	// proposal queue.
	SubmitProposedBatch(batch [][]byte)

	// PromoteProposedBatch promotes the specified transactions that are already in the transaction
	// pool into the current proposal queue.
	PromoteProposedBatch(batch []hash.Hash)

	// ClearProposedBatch clears the proposal queue.
	ClearProposedBatch()

	// HandleTxsUsed indicates that given transaction hashes are processed in a block. Queues that
	// can remove those transactions will do so.
	HandleTxsUsed(txs []hash.Hash)

	// GetSchedulingSuggestion returns a list of transactions to schedule. This begins a
	// scheduling session, which suppresses transaction rechecking and republishing. Subsequently
	// call GetSchedulingExtra for more transactions, followed by FinishScheduling.
	GetSchedulingSuggestion(countHint uint32) []*TxQueueMeta

	// GetSchedulingExtra returns transactions to schedule.
	//
	// Offset specifies the transaction hash that should serve as an offset when returning
	// transactions from the pool. Transactions will be skipped until the given hash is encountered
	// and only the following transactions will be returned.
	GetSchedulingExtra(offset *hash.Hash, limit uint32) []*TxQueueMeta

	// FinishScheduling finishes a scheduling session, which resumes transaction rechecking and
	// republishing.
	FinishScheduling()

	// GetKnownBatch gets a set of known transactions from the transaction pool.
	//
	// For any missing transactions nil will be returned in their place and the map of missing
	// transactions will be populated accordingly.
	GetKnownBatch(batch []hash.Hash) ([]*TxQueueMeta, map[hash.Hash]int)

	// ProcessBlock updates the last known runtime block information.
	ProcessBlock(bi *BlockInfo) error

	// ProcessIncomingMessages loads transactions from incoming messages into the pool.
	ProcessIncomingMessages(inMsgs []*message.IncomingMessage) error

	// WakeupScheduler explicitly notifies subscribers that they should attempt scheduling.
	WakeupScheduler()

	// WatchScheduler subscribes to notifications about when to attempt scheduling. The emitted
	// boolean flag indicates whether the batch flush timeout expired.
	WatchScheduler() (pubsub.ClosableSubscription, <-chan bool)

	// WatchCheckedTransactions subscribes to notifications about new transactions being available
	// in the transaction pool for scheduling.
	WatchCheckedTransactions() (pubsub.ClosableSubscription, <-chan []*PendingCheckTransaction)

	// PendingCheckSize returns the number of transactions currently pending to be checked.
	PendingCheckSize() int
}

TransactionPool is an interface for managing a pool of transactions.

func New

func New(
	runtimeID common.Namespace,
	cfg *Config,
	host RuntimeHostProvisioner,
	history history.History,
	txPublisher TransactionPublisher,
) (TransactionPool, error)

New creates a new transaction pool instance.

type TransactionPublisher

type TransactionPublisher interface {
	// PublishTx publishes a transaction to remote peers.
	PublishTx(ctx context.Context, tx []byte) error

	// GetMinRepublishInterval returns the minimum republish interval that needs to be respected by
	// the caller. If PublishTx is called for the same transaction more quickly, the transaction
	// may be dropped and not published.
	GetMinRepublishInterval() time.Duration
}

TransactionPublisher is an interface representing a mechanism for publishing transactions.

type TxQueueMeta

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

TxQueueMeta stores some queuing-related metadata alongside a raw transaction.

func (*TxQueueMeta) FirstSeen

func (t *TxQueueMeta) FirstSeen() time.Time

FirstSeen returns the time the transaction was first seen.

func (*TxQueueMeta) Hash

func (t *TxQueueMeta) Hash() hash.Hash

Hash returns the hash of the transaction binary data.

func (*TxQueueMeta) Raw

func (t *TxQueueMeta) Raw() []byte

Raw returns the raw transaction data.

func (*TxQueueMeta) Size

func (t *TxQueueMeta) Size() int

Size returns the size (in bytes) of the raw transaction data.

type UsableTransactionSource

type UsableTransactionSource interface {
	// GetSchedulingSuggestion returns some number of txs to give to the scheduler as part of the initial
	// batch.
	GetSchedulingSuggestion(countHint uint32) []*TxQueueMeta
	// GetTxByHash returns the specific tx, if it is in this queue. The bool is like `value, ok := txMap[key]`. Used
	// for resolving a batch from hashes and serving txSync.
	GetTxByHash(h hash.Hash) *TxQueueMeta
	// HandleTxsUsed is a callback to indicate that the scheduler is done with a set of txs, by hash. For most
	// implementations, remove it from internal storage.
	HandleTxsUsed(hashes []hash.Hash)
}

UsableTransactionSource is a place to retrieve txs that are "good enough." "Good enough" variously means CheckTx'd, came from roothash incoming message, or came from our own node.