activity

type BlockValidation struct {
	Height   uint64
	Metadata *api.BlockMetadata
}

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

type CrossValidatorParams struct {
	fx.In
	fxparams.Params
	Runtime         cadence.Runtime
	ValidatorClient client.Client `name:"validator"`
	MetaStorage     metastorage.MetaStorage
	StorageClient   blobstorage.BlobStorage
	Parser          parser.Parser
}

type CrossValidatorRequest struct {
	Tag                     uint32 `validate:"required"`
	StartHeight             uint64
	ValidationHeightPadding uint64 `validate:"required"`
	MaxHeightsToValidate    uint64 `validate:"required"`
	Parallelism             int    `validate:"required,gt=0"`
}

type CrossValidatorResponse struct {
	EndHeight uint64
	BlockGap  uint64
}

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

type EventLoaderParams struct {
	fx.In
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type EventLoaderRequest struct {
	EventTag uint32 `validate:"required"`
	Events   []*model.EventEntry
}

type EventLoaderResponse struct {
}

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

type EventReaderParams struct {
	fx.In
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type EventReaderRequest struct {
	EventTag      uint32
	StartSequence uint64
	EndSequence   uint64
	LatestEvent   bool
}

type EventReaderResponse struct {
	// Eventdata is set to nil if event does not exist in meta storage
	Eventdata []*model.EventEntry
}

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

type EventReconcilerParams struct {
	fx.In
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type EventReconcilerRequest struct {
	Tag                 uint32 `validate:"required"`
	EventTag            uint32 `validate:"required"`
	UpgradeFromEventTag uint32
	UpgradeFromEvents   []*model.EventEntry
}

type EventReconcilerResponse struct {
	Eventdata []*model.EventEntry
}

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

type ExtractorParams struct {
	fx.In
	Runtime          cadence.Runtime
	BlockchainClient client.Client `name:"slave"`
	BlobStorage      blobstorage.BlobStorage
	MetaStorage      metastorage.MetaStorage
	FailoverManager  endpoints.FailoverManager
}

type ExtractorRequest struct {
	Tag              uint32 `validate:"required"`
	Heights          []uint64
	WithBestEffort   bool
	RehydrateFromTag *uint32
	UpgradeFromTag   *uint32
	DataCompression  api.Compression
	Failover         bool
}

type ExtractorResponse struct {
	Metadatas []*api.BlockMetadata
}

type Heartbeater interface {
	RecordHeartbeat(ctx context.Context, details ...any)
}

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

type LivenessCheckParams struct {
	fx.In
	fxparams.Params
	Runtime                cadence.Runtime
	MasterBlockchainClient client.Client `name:"master"`
	FailoverManager        endpoints.FailoverManager
}

type LivenessCheckRequest struct {
	Tag                    uint32        `validate:"required"`
	Failover               bool          // Failover will switch master to failover clusters.
	LivenessCheckThreshold time.Duration // LivenessCheckThreshold is the threshold to check if the last block is too old in nodes.
}

type LivenessCheckResponse struct {
	LivenessCheckViolation bool
}

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

type LoaderParams struct {
	fx.In
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type LoaderRequest struct {
	Metadata        []*api.BlockMetadata `validate:"required"`
	LastBlock       *api.BlockMetadata
	UpdateWatermark bool
}

type LoaderResponse struct {
}

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

type ReaderParams struct {
	fx.In
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type ReaderRequest struct {
	Tag         uint32 `validate:"required"`
	Height      uint64
	LatestBlock bool
}

type ReaderResponse struct {
	// Metadata is set to nil if the block does not exist in meta storage.
	Metadata *api.BlockMetadata
}

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

type ReplicatorParams struct {
	fx.In
	fxparams.Params
	Runtime         cadence.Runtime
	Client          gateway.Client
	BlockDownloader downloader.BlockDownloader
	MetaStorage     metastorage.MetaStorage
	BlobStorage     blobstorage.BlobStorage
}

type ReplicatorRequest struct {
	Tag         uint32
	StartHeight uint64
	EndHeight   uint64
	Parallelism int
	Compression api.Compression
}

type ReplicatorResponse struct {
	StartHeight uint64
	EndHeight   uint64
}

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

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

type StreamerParams struct {
	fx.In
	fxparams.Params
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type StreamerRequest struct {
	BatchSize             uint64 `validate:"required"`
	Tag                   uint32 `validate:"required"`
	MaxAllowedReorgHeight uint64
	EventTag              uint32
}

type StreamerResponse struct {
	LatestStreamedHeight uint64
	Gap                  uint64
	EventTag             uint32
	TimeSinceLastBlock   time.Duration
}

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

type SyncerParams struct {
	fx.In
	fxparams.Params
	Runtime          cadence.Runtime
	Heartbeater      Heartbeater
	MetaStorage      metastorage.MetaStorage
	BlobStorage      blobstorage.BlobStorage
	BlockchainClient client.ClientParams
	FailoverManager  endpoints.FailoverManager
}

type SyncerRequest struct {
	Tag                          uint32 `validate:"required"`
	MinStartHeight               uint64
	MaxBlocksToSync              uint64 `validate:"required"`
	Parallelism                  int    `validate:"required"`
	DataCompression              api.Compression
	Failover                     bool   // Failover will switch master/slave to failover clusters.
	ConsensusFailover            bool   // ConsensusFailover will switch consensus client to failover clusters.
	FastSync                     bool   // FastSync should be enabled if the chain has no reorg.
	IrreversibleDistance         uint64 // A reorg will be rejected if it exceeds this distance.
	NumBlocksToSkip              uint64 // Skip the last N blocks to work around syncing delays in the nodes.
	TransactionsWriteParallelism int    // Parallelism set to the concurrency of adding/updating transactions table, it is also the feature flag to enable transaction processing if value > 0.
	ConsensusValidation          bool   // ConsensusValidation is a feature flag to enable consensus layer validation.
	ConsensusValidationMuted     bool   // ConsensusValidationMuted is a feature flag to mute consensus layer validation failures.
}

type SyncerResponse struct {
	LatestSyncedHeight uint64
	SyncGap            uint64
	TimeSinceLastBlock time.Duration
}

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

type UpdateWatermarkParams struct {
	fx.In
	fxparams.Params
	Runtime     cadence.Runtime
	MetaStorage metastorage.MetaStorage
}

type UpdateWatermarkRequest struct {
	Tag         uint32
	BlockHeight uint64
	// validate the chain starting from this block (inclusive)
	ValidateStart uint64
}

type UpdateWatermarkResponse struct {
	BlockHeight uint64
}

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

type ValidatorParams struct {
	fx.In
	fxparams.Params
	Runtime         cadence.Runtime
	MetaStorage     metastorage.MetaStorage
	Client          client.ClientParams
	Parser          parser.Parser
	StorageClient   blobstorage.BlobStorage
	FailoverManager endpoints.FailoverManager
}

type ValidatorRequest struct {
	Tag                     uint32 `validate:"required"`
	StartHeight             uint64
	ValidationHeightPadding uint64 `validate:"required"`
	MaxHeightsToValidate    uint64 `validate:"required"`
	StartEventId            int64
	MaxEventsToValidate     uint64 `validate:"required"`
	Parallelism             int    `validate:"required,gt=0"`
	EventTag                uint32
	Failover                bool
}

type ValidatorResponse struct {
	LastValidatedHeight      uint64
	BlockGap                 uint64
	LastValidatedEventId     int64
	LastValidatedEventHeight uint64
	EventGap                 int64
	EventTag                 uint32
}