focus

type BinaryFocusTracker ¶

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

BinaryFocusTracker tracks confidence for binary consensus (Previously BinaryConfidence in Avalanche)

Binary focus tracking is like a lens focusing between two possible states - as consensus forms, focus sharpens on one choice through beta consecutive rounds.

func NewBinaryFocusTracker(beta int) *BinaryFocusTracker

func (b *BinaryFocusTracker) GetBeta() int

func (b *BinaryFocusTracker) GetChoice() ids.ID

func (b *BinaryFocusTracker) GetConfidence() int

func (b *BinaryFocusTracker) GetFocusState() *FocusState

func (b *BinaryFocusTracker) GetSuccessRate() int

func (b *BinaryFocusTracker) IsFocused() bool

func (b *BinaryFocusTracker) RecordPoll(successful bool, choice ids.ID)

func (b *BinaryFocusTracker) Reset()

type Confidence ¶

type Confidence interface {
	// RecordPoll records the result of a photon sampling round
	RecordPoll(successful bool, choice ids.ID)

	// GetConfidence returns current confidence level (0 to Beta)
	GetConfidence() int

	// IsFocused returns true if fully focused (beta rounds achieved)
	IsFocused() bool

	// GetBeta returns the beta parameter
	GetBeta() int

	// GetChoice returns the choice we're focusing on
	GetChoice() ids.ID

	// Reset clears confidence state
	Reset()
}

Confidence represents focus intensity for beta-round tracking (Previously known as Confidence in Avalanche consensus)

As photonic consensus progresses, the "focus" intensifies through beta consecutive rounds of agreement, eventually achieving finality when fully focused.

func NewFromConfig(cfg Config) Confidence

type Config ¶

type Config struct {
	Type FocusType
	Beta int
}

Config represents focus tracking configuration

type Factory ¶

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

Factory creates focus tracking mechanisms (Previously ConfidenceFactory in Avalanche)

func NewFactory(beta int) *Factory

func (f *Factory) New(focusType FocusType) Confidence

func (f *Factory) NewBinary() Confidence

func (f *Factory) NewUnary() Confidence

type FocusState ¶

type FocusState struct {
	Choice           ids.ID // The choice being focused on
	ConsecutivePolls int    // Number of consecutive successful polls
	Beta             int    // Required consecutive polls for focus
	TotalPolls       int    // Total polls conducted
	SuccessfulPolls  int    // Total successful polls
}

FocusState represents the current focusing state (Previously ConfidenceState)

func (f *FocusState) GetIntensity() int

func (f *FocusState) IsFocused() bool

type FocusType ¶

type FocusType int

FocusType identifies the type of focus tracking

const (
	BinaryFocus FocusType = iota
	UnaryFocus
	MultiChoiceFocus
)

type Parameters ¶

type Parameters struct {
	K               int // Photon sample size
	AlphaPreference int // Wave threshold for preference
	AlphaConfidence int // Wave threshold for confidence
	Beta            int // Focus rounds for finality
}

Parameters holds all photonic consensus parameters (Maps to Avalanche consensus Parameters)

type UnaryFocusTracker ¶

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

UnaryFocusTracker tracks confidence for unary consensus (Previously UnaryConfidence in Avalanche)

Unary focus tracking is like measuring photon intensity - we're not choosing between options but confirming presence through repeated observations.

func NewUnaryFocusTracker(beta int) *UnaryFocusTracker

func (u *UnaryFocusTracker) GetBeta() int

func (u *UnaryFocusTracker) GetChoice() ids.ID

func (u *UnaryFocusTracker) GetConfidence() int

func (u *UnaryFocusTracker) GetRecentSuccessRate() int

func (u *UnaryFocusTracker) IsFocused() bool

func (u *UnaryFocusTracker) RecordPoll(successful bool, choice ids.ID)

func (u *UnaryFocusTracker) Reset()

func (u *UnaryFocusTracker) TimeSinceLastPoll() time.Duration