scanner

type AddressBatch struct {
	Addresses   []flow.Address
	BlockHeight uint64
	// contains filtered or unexported fields
}

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

type AddressProviderConfig struct {
	ExcludeAddress func(id flow.ChainID, address flow.Address) bool
}

type Component interface {
	Err() error
	Done() <-chan struct{}
	Start(ctx context.Context) <-chan struct{}
}

type ComponentBase struct {
	Logger zerolog.Logger
	// contains filtered or unexported fields
}

type Config struct {
	ScriptRunnerConfig
	FullScanRunnerConfig
	IncrementalScannerConfig

	ScriptResultHandler ScriptResultHandler
	Reporter            StatusReporter

	ContinuousScan bool
	BatchSize      int

	Logger zerolog.Logger
}

type DefaultStatusReporter struct {
	*ComponentBase
	// contains filtered or unexported fields
}

type FullScan struct {
	*ComponentBase
	// contains filtered or unexported fields
}

type FullScanRunner struct {
	FullScanRunnerConfig
	// contains filtered or unexported fields
}

type FullScanRunnerConfig struct {
	AddressProviderConfig

	ChainID flow.ChainID
}

type IncrementalScanner struct {
	*ComponentBase
	IncrementalScannerConfig
	// contains filtered or unexported fields
}

type IncrementalScannerConfig struct {
	CandidateScanners []candidates.CandidateScanner
	// IncrementalScannerBlockLag is the number of blocks the incremental scanner lag behind the latest block from
	// GetLatestBlockHeader. This is to avoid most of the "retry for collection in finalized block" errors.
	// Another way to avoid them is to always use the same access node.
	IncrementalScannerBlockLag uint64

	// IncrementalScannerMaxBlockGap is the maximum number of blocks that can scanned by the incremental scanner.
	// If the gap is larger than this, the incremental scanner will skip ahead and request a full scan.
	IncrementalScannerMaxBlockGap uint64
}

type NoOpScriptResultHandler struct{}

type NoOpStatusReporter struct{}

type ProcessedAddressBatch struct {
	AddressBatch
	Result cadence.Value
}

type ScanConcluded struct {
	LatestScannedBlockHeight uint64
	// ScanIsComplete is false if a full scan was not completed,
	// this means some accounts may have stale data, or have been missed all together.
	ScanIsComplete bool
}

type Scanner struct {
	Config
	// contains filtered or unexported fields
}

type ScriptErrorAction interface {
	// contains filtered or unexported methods
}

type ScriptErrorActionExclude struct {
	Addresses []flow.Address
}

type ScriptErrorActionNone struct{}

type ScriptErrorActionRetry struct{}

type ScriptErrorActionSplit struct{}

type ScriptErrorActionUnhandled struct{}

type ScriptResultHandler interface {
	// Handle will be called concurrently for each ProcessedAddressBatch.
	Handle(batch ProcessedAddressBatch) error
}

type ScriptResultProcessor struct {
	*ComponentBase
	// contains filtered or unexported fields
}

type ScriptRunner struct {
	*ComponentBase

	ScriptRunnerConfig
	// contains filtered or unexported fields
}

type ScriptRunnerConfig struct {
	Script []byte

	MaxConcurrentScripts int
	HandleScriptError    func(AddressBatch, error) ScriptErrorAction
}

type StatusReporter interface {
	ReportIncrementalBlockDiff(diff uint64)
	ReportIncrementalBlockHeight(height uint64)
	ReportIsFullScanRunning(running bool)
	ReportFullScanProgress(current uint64, total uint64)
}

type StatusReporterOption = func(*DefaultStatusReporter)