slot_selector.go

package dasmon

import (
	"fmt"
	"math"
	"math/rand"
)

// SlotSelectionStrategy defines how slots are selected for custody probing
type SlotSelectionStrategy string

const (
	// SlotSelectionUniform uses uniform random distribution across the custody window
	SlotSelectionUniform SlotSelectionStrategy = "uniform"

	// SlotSelectionRecent biases selection toward recent slots (closer to chain head)
	// Uses exponential decay distribution
	SlotSelectionRecent SlotSelectionStrategy = "recent"

	// SlotSelectionHistorical biases selection toward older slots (further from chain head)
	// Uses inverted exponential distribution
	SlotSelectionHistorical SlotSelectionStrategy = "historical"

	// SlotSelectionHeavilyRecent strongly biases selection toward very recent slots
	// Uses more aggressive exponential decay than "recent"
	SlotSelectionHeavilyRecent SlotSelectionStrategy = "heavily_recent"

	// SlotSelectionHeavilyHistorical strongly biases selection toward older slots
	// Uses more aggressive distribution than "historical"
	SlotSelectionHeavilyHistorical SlotSelectionStrategy = "heavily_historical"
)

// SlotSelector is an interface for selecting slots based on different strategies.
type SlotSelector interface {
	// SelectSlot selects a slot from the range [earliest, latest) based on the configured strategy.
	// Returns earliest if the range is empty (latest <= earliest).
	SelectSlot(within Range[uint64]) uint64
}

// ParseSlotSelector creates a SlotSelector implementation based on the given strategy.
// Returns an error if the strategy is unknown.
func ParseSlotSelector(strategy SlotSelectionStrategy) (SlotSelector, error) {
	switch strategy {
	case SlotSelectionUniform:
		return &uniformSelector{}, nil
	case SlotSelectionRecent:
		return &recentSelector{decayFactor: 1.5}, nil
	case SlotSelectionHistorical:
		return &historicalSelector{decayFactor: 1.5}, nil
	case SlotSelectionHeavilyRecent:
		return &recentSelector{decayFactor: 3.0}, nil
	case SlotSelectionHeavilyHistorical:
		return &historicalSelector{decayFactor: 3.0}, nil
	default:
		return nil, fmt.Errorf("unknown slot selection strategy: %s", strategy)
	}
}

// uniformSelector selects slots using uniform random distribution.
type uniformSelector struct{}

func (s *uniformSelector) SelectSlot(within Range[uint64]) uint64 {
	slotDelta := within.Length()
	if slotDelta == 0 {
		return within.Start
	}
	return within.Start + uint64(rand.Uint64()%slotDelta)
}

// recentSelector selects slots with bias toward recent slots (closer to chain head).
// Uses exponential decay distribution where recent slots have higher probability.
type recentSelector struct {
	// decayFactor controls the strength of the bias.
	// Higher values create stronger concentration toward recent slots.
	decayFactor float64
}

func (s *recentSelector) SelectSlot(within Range[uint64]) uint64 {
	slotDelta := within.Length()
	if slotDelta == 0 {
		return within.Start
	}

	// Use exponential distribution transformed to [0, 1) naturally
	// 1 - exp(-x/k) maps exponential to [0, 1) with bias toward 0
	expValue := rand.ExpFloat64()
	normalizedValue := 1.0 - math.Exp(-expValue/s.decayFactor)

	// Map to slot range: invert so 0 maps to latest-1 (most recent)
	offset := uint64(normalizedValue * float64(slotDelta-1))

	// Invert: subtract from latest-1 to bias toward recent while staying < latest
	return within.End - 1 - uint64(offset)
}

// historicalSelector selects slots with bias toward older slots (further from chain head).
// Uses inverted exponential distribution.
type historicalSelector struct {
	// decayFactor controls the strength of the bias.
	// Higher values create stronger concentration toward historical slots.
	decayFactor float64
}

func (s *historicalSelector) SelectSlot(within Range[uint64]) uint64 {
	slotDelta := within.Length()
	if slotDelta == 0 {
		return within.Start
	}

	// Use exponential distribution transformed to [0, 1) naturally
	// 1 - exp(-x/k) maps exponential to [0, 1) with bias toward 0
	expValue := rand.ExpFloat64()
	normalizedValue := 1.0 - math.Exp(-expValue/s.decayFactor)

	// Map to slot range: 0 maps to earliest (most historical)
	offset := uint64(normalizedValue * float64(slotDelta-1))

	// Add to earliest to bias toward historical slots while staying < latest
	return within.Start + uint64(offset)
}