protocol

type Attestations struct {

	// Logger embeds a logger that can be used to log messages emitted by this component.
	log.Logger
	// contains filtered or unexported fields
}

type BlockFilteredEvent struct {
	Block  *model.Block
	Reason error
	Source peer.ID
}

type Blocks struct {

	// Logger embeds a logger that can be used to log messages emitted by this chain.
	log.Logger
	// contains filtered or unexported fields
}

type Chain struct {
	// ForkingPoint contains the first commitment of this chain.
	ForkingPoint reactive.Variable[*Commitment]

	// ParentChain contains the chain that this chain forked from.
	ParentChain reactive.Variable[*Chain]

	// DivergencePointVerified contains a flag that indicates whether the divergence point of this chain is verified.
	DivergencePointVerified reactive.Event

	// ChildChains contains the set of all chains that forked from this chain.
	ChildChains reactive.Set[*Chain]

	// LatestCommitment contains the latest commitment of this chain.
	LatestCommitment reactive.Variable[*Commitment]

	// LatestAttestedCommitment contains the latest commitment of this chain for which attestations were received.
	LatestAttestedCommitment reactive.Variable[*Commitment]

	// LatestProducedCommitment contains the latest commitment of this chain that we produced ourselves by booking the
	// corresponding blocks in the Engine.
	LatestProducedCommitment reactive.Variable[*Commitment]

	// WarpSyncMode contains a flag that indicates whether this chain is in warp sync mode.
	WarpSyncMode reactive.Variable[bool]

	// LatestSyncedSlot contains the latest commitment of this chain for which all blocks were booked.
	LatestSyncedSlot reactive.Variable[iotago.SlotIndex]

	// OutOfSyncThreshold contains the slot at which the chain will consider itself to be out of sync and switch to warp
	// sync mode. It is derived from the latest network slot minus two times the max committable age.
	OutOfSyncThreshold reactive.Variable[iotago.SlotIndex]

	// RequestAttestations contains a flag that indicates whether this chain should verify the claimed weight by
	// requesting attestations.
	RequestAttestations reactive.Variable[bool]

	// StartEngine contains a flag that indicates whether this chain should verify the state by processing blocks in an
	// engine.
	StartEngine reactive.Variable[bool]

	// Engine contains the engine instance that is used to process blocks for this chain.
	Engine reactive.Variable[*engine.Engine]

	// IsEvicted contains a flag that indicates whether this chain was evicted.
	IsEvicted reactive.Event

	// Logger embeds a logger that can be used to log messages emitted by this chain.
	log.Logger
	// contains filtered or unexported fields
}

type Chains struct {
	// Set contains all non-evicted chains that are managed by the protocol.
	reactive.Set[*Chain]

	// Main contains the main chain.
	Main reactive.Variable[*Chain]

	// HeaviestClaimedCandidate contains the candidate chain with the heaviest claimed weight according to its latest commitment. The weight has neither been checked via attestations nor verified by downloading all data.
	HeaviestClaimedCandidate *ChainsCandidate

	// HeaviestAttestedCandidate contains the candidate chain with the heaviest weight as checked by attestations. The chain has not been instantiated into an engine yet.
	HeaviestAttestedCandidate *ChainsCandidate

	// HeaviestVerifiedCandidate contains the candidate chain with the heaviest verified weight, meaning the chain has been instantiated into an engine and the commitments have been produced by the engine itself.
	HeaviestVerifiedCandidate *ChainsCandidate

	// LatestSeenSlot contains the slot of the latest commitment of any received block.
	LatestSeenSlot reactive.Variable[iotago.SlotIndex]

	// Logger contains a reference to the logger that is used by this component.
	log.Logger
	// contains filtered or unexported fields
}

type ChainsCandidate struct {
	// Variable contains the heaviest chain candidate.
	reactive.Variable[*Chain]
	// contains filtered or unexported fields
}

type Commitment struct {
	// Commitment contains the underlying model.Commitment that is represented by this Commitment.
	*model.Commitment

	// Parent contains the Commitment that is referenced as a parent in this Commitment.
	Parent reactive.Variable[*Commitment]

	// Children contains the Commitments that reference this Commitment as a parent.
	Children reactive.Set[*Commitment]

	// MainChild contains the Commitment that is the main child of this Commitment (continues the chain).
	MainChild reactive.Variable[*Commitment]

	// Chain contains the Chain that this Commitment is part of.
	Chain reactive.Variable[*Chain]

	// RequestAttestations contains a flag indicating if the node should request attestations for this Commitment.
	RequestAttestations reactive.Variable[bool]

	// WarpSyncBlocks contains a flag indicating if the node should request the blocks of this Commitment using warp
	// sync.
	WarpSyncBlocks reactive.Variable[bool]

	// BlocksToWarpSync contains the set of blocks that should be requested using warp sync.
	BlocksToWarpSync reactive.Variable[ds.Set[iotago.BlockID]]

	// Weight contains the weight of this Commitment (the difference between the cumulative weight of this Commitment
	// and its parent).
	Weight reactive.Variable[uint64]

	// AttestedWeight contains the weight of the Commitment that was attested by other nodes.
	AttestedWeight reactive.Variable[uint64]

	// CumulativeWeight contains the cumulative weight of all Commitments up to this point.
	CumulativeWeight reactive.Variable[uint64]

	// CumulativeAttestedWeight contains the cumulative weight of all attested Commitments up to this point.
	CumulativeAttestedWeight reactive.Variable[uint64]

	// CumulativeVerifiedWeight contains the cumulative weight of all verified Commitments up to this point.
	CumulativeVerifiedWeight reactive.Variable[uint64]

	// IsRoot contains a flag indicating if this Commitment is the root of the Chain.
	IsRoot reactive.Event

	// IsAttested contains a flag indicating if we have received attestations for this Commitment.
	IsAttested reactive.Event

	// IsSynced contains a flag that indicates if a Commitment was fully downloaded and processed.
	IsSynced reactive.Event

	// IsCommittable contains a flag that indicates if a Commitment is ready to be committed by the warp sync process.
	IsCommittable reactive.Event

	// IsVerified contains a flag indicating if this Commitment is verified (we produced this Commitment ourselves by
	// booking all the contained blocks and transactions).
	IsVerified reactive.Event

	// IsAboveLatestVerifiedCommitment contains a flag indicating if this Commitment is above the latest verified
	// Commitment.
	IsAboveLatestVerifiedCommitment reactive.Variable[bool]

	// ReplayDroppedBlocks contains a flag indicating if we should replay the blocks that were dropped while the
	// Commitment was pending.
	ReplayDroppedBlocks reactive.Variable[bool]

	// IsEvicted contains a flag indicating if this Commitment was evicted from the Protocol.
	IsEvicted reactive.Event

	// Logger embeds a logger that can be used to log messages emitted by this Commitment.
	log.Logger
	// contains filtered or unexported fields
}

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

type Commitments struct {
	// Set contains all non-evicted commitments that are managed by the protocol.
	reactive.Set[*Commitment]

	// Root contains the root commitment.
	Root reactive.Variable[*Commitment]

	// Logger contains a reference to the logger that is used by this component.
	log.Logger
	// contains filtered or unexported fields
}

type Engines struct {
	// Main contains the main engine.
	Main reactive.Variable[*engine.Engine]

	// ReactiveModule embeds a reactive module that provides default API for logging and lifecycle management.
	module.Module
	// contains filtered or unexported fields
}

type Events struct {
	Engine         *engine.Events
	ProtocolFilter *event.Event1[*BlockFilteredEvent]
}

type Network struct {
	// Protocol contains the network endpoint of the protocol.
	*core.Protocol

	// Logger contains a reference to the logger that is used by this component.
	log.Logger
	// contains filtered or unexported fields
}

type Options struct {
	// BaseDirectory is the directory where the protocol will store its data.
	BaseDirectory string

	// SnapshotPath is the path to the snapshot file that should be used to initialize the protocol.
	SnapshotPath string

	// CommitmentCheck is an opt flag that allows engines check correctness of commitment and ledger state upon startup.
	CommitmentCheck bool

	// MaxAllowedWallClockDrift specifies how far in the future are blocks allowed to be ahead of our own wall clock (defaults to 0 seconds).
	MaxAllowedWallClockDrift time.Duration

	// EngineOptions contains the options for the Engines.
	EngineOptions []options.Option[engine.Engine]

	// StorageOptions contains the options for the Storage.
	StorageOptions []options.Option[storage.Storage]

	CommitmentRequesterOptions  []options.Option[eventticker.EventTicker[iotago.SlotIndex, iotago.CommitmentID]]
	AttestationRequesterOptions []options.Option[eventticker.EventTicker[iotago.SlotIndex, iotago.CommitmentID]]
	WarpSyncRequesterOptions    []options.Option[eventticker.EventTicker[iotago.SlotIndex, iotago.CommitmentID]]

	// PreSolidFilterProvider contains the provider for the PreSolidFilter engine modules.
	PreSolidFilterProvider module.Provider[*engine.Engine, presolidfilter.PreSolidFilter]

	// PostSolidFilterProvider contains the provider for the PostSolidFilter engine modules.
	PostSolidFilterProvider module.Provider[*engine.Engine, postsolidfilter.PostSolidFilter]

	// BlockDAGProvider contains the provider for the BlockDAG engine modules.
	BlockDAGProvider module.Provider[*engine.Engine, blockdag.BlockDAG]

	// TipManagerProvider contains the provider for the TipManager engine modules.
	TipManagerProvider module.Provider[*engine.Engine, tipmanager.TipManager]

	// TipSelectionProvider contains the provider for the TipSelection engine modules.
	TipSelectionProvider module.Provider[*engine.Engine, tipselection.TipSelection]

	// BookerProvider contains the provider for the Booker engine modules.
	BookerProvider module.Provider[*engine.Engine, booker.Booker]

	// ClockProvider contains the provider for the Clock engine modules.
	ClockProvider module.Provider[*engine.Engine, clock.Clock]

	// BlockGadgetProvider contains the provider for the BlockGadget engine modules.
	BlockGadgetProvider module.Provider[*engine.Engine, blockgadget.Gadget]

	// SlotGadgetProvider contains the provider for the SlotGadget engine modules.
	SlotGadgetProvider module.Provider[*engine.Engine, slotgadget.Gadget]

	// SybilProtectionProvider contains the provider for the SybilProtection engine modules.
	SybilProtectionProvider module.Provider[*engine.Engine, sybilprotection.SybilProtection]

	// NotarizationProvider contains the provider for the Notarization engine modules.
	NotarizationProvider module.Provider[*engine.Engine, notarization.Notarization]

	// SyncManagerProvider contains the provider for the SyncManager engine modules.
	SyncManagerProvider module.Provider[*engine.Engine, syncmanager.SyncManager]

	// AttestationProvider contains the provider for the Attestation engine modules.
	AttestationProvider module.Provider[*engine.Engine, attestation.Attestations]

	// LedgerProvider contains the provider for the Ledger engine modules.
	LedgerProvider module.Provider[*engine.Engine, ledger.Ledger]

	// BlockRetainerProvider contains the provider for the BlockRetainer engine modules.
	BlockRetainerProvider module.Provider[*engine.Engine, retainer.BlockRetainer]

	// TransactionRetainerProvider contains the provider for the TransactionRetainer engine modules.
	TransactionRetainerProvider module.Provider[*engine.Engine, retainer.TransactionRetainer]

	// SchedulerProvider contains the provider for the Scheduler engine modules.
	SchedulerProvider module.Provider[*engine.Engine, scheduler.Scheduler]

	// UpgradeOrchestratorProvider contains the provider for the UpgradeOrchestrator engine modules.
	UpgradeOrchestratorProvider module.Provider[*engine.Engine, upgrade.Orchestrator]
}

type Protocol struct {
	// Events contains a centralized access point for all events that are triggered by the main engine of the protocol.
	Events *Events

	// Workers contains the worker pools that are used by the protocol.
	Workers *workerpool.Group

	// Network contains the network endpoint of the protocol.
	Network *Network

	// Commitments contains the commitments that are managed by the protocol.
	Commitments *Commitments

	// Chains contains the chains that are managed by the protocol.
	Chains *Chains

	// Blocks contains the subcomponent that is responsible for handling block requests and responses.
	Blocks *Blocks

	// Attestations contains the subcomponent that is responsible for handling attestation requests and responses.
	Attestations *Attestations

	// WarpSync contains the subcomponent that is responsible for handling warp sync requests and responses.
	WarpSync *WarpSync

	// Engines contains the engines that are managed by the protocol.
	Engines *Engines

	// Options contains the options that were used to create the protocol.
	Options *Options

	// EvictionState contains the eviction state of the protocol.
	reactive.EvictionState[iotago.SlotIndex]

	// ReactiveModule embeds the reactive module logic of the protocol.
	module.Module
}

type WarpSync struct {

	// Logger embeds a logger that can be used to log messages emitted by this chain.
	log.Logger
	// contains filtered or unexported fields
}