chain

type BlockSink interface {
	// Sink handles blocks that come from the Hot part, and may be finalized or not
	Sink(entry *HotEntry, canonical bool) error
}

type BlockSinkFn func(entry *HotEntry, canonical bool) error

type BlockSlotKey [32 + 8]byte

type Chain interface {
	ByStateRoot(root Root) (ChainEntry, error)
	ByBlockRoot(root Root) (ChainEntry, error)
	ClosestFrom(fromBlockRoot Root, toSlot Slot) (ChainEntry, error)
	BySlot(slot Slot) (ChainEntry, error)
	Iter() (ChainIter, error)
}

type ChainEntry interface {
	// Slot of this entry
	Slot() Slot
	// BlockRoot returns the last block root, replicating the previous block root if the current slot has none.
	BlockRoot() (root Root)
	// The parent block root. If this is an empty slot, it will just be previous block root. Can also be zeroed if unknown.
	ParentRoot() (root Root)
	// If this is an empty slot, i.e. no block
	IsEmpty() bool
	// State root (of the post-state of this entry). Should match state-root in the block at the same slot (if any)
	StateRoot() Root
	// The context of this chain entry (shuffling, proposers, etc.)
	EpochsContext(ctx context.Context) (*beacon.EpochsContext, error)
	// State of the entry, a data-sharing view. Call .Copy() before modifying this to preserve validity.
	State(ctx context.Context) (*beacon.BeaconStateView, error)
}

type ChainID string

type ChainIter interface {
	// Start is the minimum slot to reach to, inclusive.
	Start() Slot
	// End is the maximum slot to reach to, exclusive.
	End() Slot
	// Entry fetches the chain entry at the given slot.
	// If it does not exist, entry=nil, err=nil.
	// If the request is out of bounds or fails, an error may be returned.
	Entry(slot Slot) (entry ChainEntry, err error)
}

type Chains interface {
	Find(id ChainID) (pi FullChain, ok bool)
	Create(id ChainID, anchor *HotEntry) (pi FullChain, err error)
	Remove(id ChainID) (existed bool)
	List() []ChainID
}

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

type Checkpoint = beacon.Checkpoint

type ColdChain interface {
	Start() Slot
	End() Slot
	OnFinalizedEntry(entry *HotEntry) error
	Chain
}

type ColdChainIter struct {
	Chain              Chain
	StartSlot, EndSlot Slot
}

type Epoch = beacon.Epoch

type FinalizedChain struct {
	// Cache of pubkeys, may contain pubkeys that are not finalized,
	// but finalized state will not be in conflict with this cache.
	PubkeyCache *beacon.PubkeyCache
	// Start of the historical data
	AnchorSlot Slot

	// Block roots, starting at AnchorSlot
	// A blockRoot can be a copy of the previous root if current entry is empty
	BlockRoots []Root

	// State roots, starting at AnchorSlot
	StateRoots []Root

	// BlockRoots maps the canonical chain block roots to the block slot
	SlotsByBlockRoot map[Root]Slot
	// BlockRoots maps the canonical chain state roots to the state slot
	SlotsByStateRoot map[Root]Slot
}

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

type FullChain interface {
	Chain

	Justified() Checkpoint
	Finalized() Checkpoint
	Head() (ChainEntry, error)
	AddBlock(ctx context.Context, signedBlock *beacon.SignedBeaconBlock) error
	AddAttestation(att *beacon.Attestation) error

	Start() Slot
	End() Slot
	OnFinalizedEntry(entry *HotEntry) error
}

type FullChainIter struct {
	HotIter  ChainIter
	ColdIter ChainIter
}

type Gwei = beacon.Gwei

type HotChain interface {
	Chain
	Justified() Checkpoint
	Finalized() Checkpoint
	Head() (ChainEntry, error)
	// Process a block. If there is an error, the chain is not mutated, and can be continued to use.
	AddBlock(ctx context.Context, signedBlock *beacon.SignedBeaconBlock) error
	// Process an attestation. If there is an error, the chain is not mutated, and can be continued to use.
	AddAttestation(att *beacon.Attestation) error
}

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

type HotColdChain struct {
	HotChain
	ColdChain
}

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

type Root = beacon.Root

type Slot = beacon.Slot

type UnfinalizedChain struct {
	ForkChoice *forkchoice.ForkChoice

	AnchorSlot Slot

	// block++slot -> Entry
	Entries map[BlockSlotKey]*HotEntry
	// state root -> block+slot key
	State2Key map[Root]BlockSlotKey

	// BlockSink takes pruned entries and their canon status, and processes them.
	// Empty-slot entries will only occur for canonical chain,
	// non-canonical empty entries are ignored, as there can theoretically be an unlimited number of.
	// Non-canonical non-empty entries are still available, to track what is getting abandoned by the chain
	BlockSink BlockSink
}

type ValidatorIndex = beacon.ValidatorIndex