executor

type ArchiveDbTxProcessor struct {
	*TxProcessor
}

type Consumer[T any] func(TransactionInfo[T]) error

type Context struct {
	// State is an optional StateDB instance manipulated during by the processor
	// and extensions of a block-range execution.
	State state.StateDB

	// Archive represents a historical State
	Archive state.NonCommittableStateDB

	// StateDbPath contains path to working stateDb directory
	StateDbPath string

	// AidaDb is an optional LevelDb readonly database containing data for testing StateDb (i.e. state hashes).
	AidaDb db.BaseDB

	// ErrorInput is used if continue-on-failure is enabled or if log-file is definer so that at the end
	// of the run, we log all errors into a file. This chanel should be only used for processing errors,
	// hence any non-fatal errors. Any fatal should still be returned so that the app ends.
	ErrorInput chan error

	// ExecutionResult is set after the execution.
	// It is used for validation and gas measurements.
	ExecutionResult txcontext.Result
}

type Executor[T any] interface {
	// Run feeds all transactions of the given block range [from,to) to the
	// provided processor and performs the needed call-backs on the provided
	// extensions. If a processor or an extension returns an error, execution
	// stops with the reported error.
	// PreXXX events are delivered to the extensions in the given order, while
	// PostXXX events are delivered in reverse order. If any of the extensions
	// reports an error during processing of an event, the same event is still
	// delivered to the remaining extensions before processing is aborted.
	Run(params Params, processor Processor[T], extensions []Extension[T], aidaDb db.BaseDB) error
}

type Extension[T any] interface {
	// PreRun is called before the begin of the execution of a block range,
	// even if the range is empty. The provided state lists the initial block
	// of the range. For every run, PreRun is only called once, before any
	// other call-back. If an error is reported, execution will abort after
	// PreRun has been called on all registered Extensions.
	PreRun(State[T], *Context) error

	// PostRun is guranteed to be called at the end of each execution. An
	// execution may end successfully, if no exception has been produced by
	// the Processor or any Extension, or in a failure state, if errors
	// have been produced. In case of a successful execution, the provided
	// state lists the first non-executiond block, while in an error case
	// it references the last transaction attempted to be processed. Also,
	// the second parameter contains the error causing the abort.
	PostRun(State[T], *Context, error) error

	// PreBlock is called once before the begin of processing a block with
	// the state containing the number of the Block. This function is not
	// called when running with multiple workers.
	PreBlock(State[T], *Context) error

	// PostBlock is called once after the end of processing a block with
	// the state containing the number of the Block and the last transaction
	// processed in the block. This function is not called when running with
	// multiple workers.
	PostBlock(State[T], *Context) error

	// PreTransaction is called once before each transaction with the state
	// listing the block number, the transaction number, and the substate data
	// providing the input for the subsequent execution of the transaction.
	// When running with multiple workers, this function may be called
	// concurrently, and must thus be thread safe.
	PreTransaction(State[T], *Context) error

	// PostTransaction is called once after each transaction with the state
	// listing the block number, the transaction number, and the substate data
	// providing the input for the subsequent execution of the transaction.
	// When running with multiple workers, this function may be called
	// concurrently, and must thus be thread safe.
	PostTransaction(State[T], *Context) error
}

type LiveDbTxProcessor struct {
	*TxProcessor
}

type MockExecutor[T any] struct {
	// contains filtered or unexported fields
}

type MockExecutorMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

type MockExtension[T any] struct {
	// contains filtered or unexported fields
}

type MockExtensionMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

type MockProcessor[T any] struct {
	// contains filtered or unexported fields
}

type MockProcessorMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

type MockProvider[T any] struct {
	// contains filtered or unexported fields
}

type MockProviderMockRecorder[T any] struct {
	// contains filtered or unexported fields
}

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

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

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

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

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

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

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

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

type ParallelismGranularity byte

type Params struct {
	// From is the beginning of the range of blocks to be processed (inclusive).
	From int
	// To is the end of the range of blocks to be processed (exclusive).
	To int
	// State is an optional StateDB instance to be made available to the
	// processor and extensions during execution.
	State state.StateDB
	// NumWorkers is the number of concurrent goroutines to be used to
	// process blocks. If the number of workers is 1, transactions are
	// guranteed to be processed in-order. If it is > 1 no fixed order
	// is guranteed. Any number <= 1 is considered to be 1, thus the default
	// value of 0 is valid.
	NumWorkers int
	// ParallelismGranularity determines whether parallelism is done on block or transaction level
	ParallelismGranularity ParallelismGranularity
}

type Processor[T any] interface {
	// Process is called on each transaction in the range of blocks covered
	// by an Executor run. When running with multiple workers, the Process
	// function is required to be thread safe.
	Process(State[T], *Context) error
}

type Provider[T any] interface {
	// Run iterates through transaction in the block range [from,to) in order
	// and forwards payload information for each transaction in the range to
	// the provided consumer. Execution aborts if the consumer returns an error
	// or an error during the payload retrieval process occurred.
	Run(from int, to int, consumer Consumer[T]) error
	// Close releases resources held by the provider implementation. After this
	// no more operations are allowed on the same instance.
	Close()
}

type RPCReqConsumer interface {
	Consume(block int, transaction int, req *rpc.RequestAndResults) error
}

type State[T any] struct {
	// Block the current block number, valid for all call-backs.
	Block int

	// Transaction is the transaction number of the current transaction within
	// its respective block. It is only valid for PreTransaction, PostTransaction,
	// PostBlock, and for PostRun events in case of an abort.
	Transaction int

	// Data is the input required for processing the current transaction. It is
	// only valid for Pre- and PostTransaction events.
	Data T
}

type TransactionInfo[T any] struct {
	Block       int
	Transaction int
	Data        T
}

type TxConsumer interface {
	Consume(block int, transaction int, substate txcontext.TxContext) error
}

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