fix: seed slot throttles with a below-genesis sentinel

The zero value of lastCheckpointAheadWarnSlot equals slot index 0, so the
first checkpoint-ahead warning there was swallowed (CodeRabbit). Writing the
regression test surfaced that lastSlotWithForcedFork has the same collision
one field over: its zero value makes isConsensusStuck treat the genesis slot
as if a forced fork just happened and skip its entire body. Both now start at
math.MinInt64, as does lastStuckRequestSlot in the bootstrapper for the same
pattern. Pinned by TestMetaForkDetector_CheckpointAheadWarnsAtSlotIndexZero.

Refs #90

Author: MathijsBok

core/process/sync/metaForkDetector.go

@@ -47,6 +47,13 @@ func NewMetaForkDetector(
 	bfd.fork.rollBackNonce = math.MaxUint64
 	bfd.fork.probableHighestNonce = bfd.genesisNonce
 	bfd.fork.highestNonceReceived = bfd.genesisNonce
+	// Sentinels below any real slot index: the zero values would otherwise
+	// collide with slot index 0. For the warn throttle that swallows the first
+	// checkpoint-ahead warning; for lastSlotWithForcedFork it makes
+	// isConsensusStuck treat the genesis slot as if a forced fork just happened
+	// and skip its entire body.
+	bfd.lastCheckpointAheadWarnSlot.Store(math.MinInt64)
+	bfd.fork.lastSlotWithForcedFork = math.MinInt64
 
 	mfd := metaForkDetector{
 		baseForkDetector: bfd,

core/process/sync/metaForkDetector_test.go

@@ -276,3 +276,31 @@ func TestMetaForkDetector_CheckpointAheadWarnsOncePerSlot(t *testing.T) {
 	_ = bfd.CheckFork()
 	require.Greater(t, buff.Len(), firstLen)
 }
+
+// Slot index 0 is the one value that would collide with an uninitialized
+// throttle field: without the MinInt64 sentinel stored at construction, the
+// first Swap(0) returns the zero value and swallows the warning entirely.
+func TestMetaForkDetector_CheckpointAheadWarnsAtSlotIndexZero(t *testing.T) {
+	buff := &bytes.Buffer{}
+	require.Nil(t, logger.AddLogObserver(buff, &checkpointAheadWarnFormatter{}))
+	t.Cleanup(func() {
+		require.Nil(t, logger.RemoveLogObserver(buff))
+	})
+
+	sloterMock := &consensusMock.SlotManagerMock{
+		SlotIndex:          0,
+		TimeDurationCalled: func() time.Duration { return 0 },
+	}
+	bfd, err := sync.NewMetaForkDetector(sloterMock, &mock.BlackListHandlerStub{}, 0)
+	require.Nil(t, err)
+
+	// checkBlockBasicValidity accepts headers one slot ahead of the local index,
+	// so a checkpoint at slot 1 is reachable while the index still reads 0.
+	hdr := &block.Block{Header: &block.BlockHeader{Nonce: 1, Slot: 1}}
+	require.Nil(t, bfd.AddHeader(hdr, []byte("hash"), process.BHProcessed, nil, nil))
+
+	forkInfo := bfd.CheckFork()
+	require.False(t, forkInfo.IsDetected)
+
+	require.Contains(t, buff.String(), "last checkpoint is ahead of the local slot index")
+}

core/process/sync/metablock.go

@@ -2,6 +2,7 @@ package sync
 
 import (
 	"context"
+	"math"
 
 	"github.com/klever-io/klever-go/common"
 	"github.com/klever-io/klever-go/core"
@@ -64,6 +65,10 @@ func NewMetaBootstrap(arguments ArgMetaBootstrapper) (*MetaBootstrap, error) {
 		isInImportMode:  arguments.IsInImportMode,
 		hasStarted:      arguments.SlotManager.BeforeGenesis() || arguments.IsInImportMode || arguments.StartWithInSync,
 	}
+	// Sentinel below any real slot index, mirroring the fork detector's warning
+	// throttle: the zero value would equal slot index 0 and swallow the first
+	// burst there.
+	base.lastStuckRequestSlot.Store(math.MinInt64)
 
 	if base.hasStarted {
 		log.Warn("node starting inSync state")