feat(chainsync): add EpochNumber to ChainSyncStatus

Closes #187

Signed-off-by: Chris Gianelloni <[email protected]>

Author: wolf31o2

input/chainsync/chainsync.go

@@ -40,6 +40,34 @@ import (
 	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
 )
 
+// EpochFromSlot returns the epoch number for a given slot, using Cardano era rules.
+func EpochFromSlot(slot uint64) uint64 {
+	cfg := config.GetConfig()
+	byron := cfg.ByronGenesis
+	shelley := cfg.ShelleyGenesis
+
+	endSlot := uint64(0)
+	if byron.EndSlot != nil {
+		endSlot = *byron.EndSlot
+	}
+	epochs := uint64(0)
+	if byron.Epochs != nil {
+		epochs = *byron.Epochs
+	}
+	if slot <= endSlot {
+		if byron.EpochLength == 0 {
+			return 0 // avoid div by zero
+		}
+		return slot / byron.EpochLength
+	}
+	shelleyStartEpoch := epochs
+	shelleyStartSlot := endSlot + 1
+	if shelley.EpochLength == 0 {
+		return shelleyStartEpoch // avoid div by zero
+	}
+	return shelleyStartEpoch + (slot-shelleyStartSlot)/shelley.EpochLength
+}
+
 const (
 	// Size of cache for recent chainsync cursors
 	cursorCacheSize = 20
@@ -84,6 +112,7 @@ type ChainSyncStatus struct {
 	TipBlockHash  string
 	SlotNumber    uint64
 	BlockNumber   uint64
+	EpochNumber   uint64
 	TipSlotNumber uint64
 	TipReached    bool
 }
@@ -522,6 +551,7 @@ func (c *ChainSync) updateStatus(
 	c.status.SlotNumber = slotNumber
 	c.status.BlockNumber = blockNumber
 	c.status.BlockHash = blockHash
+	c.status.EpochNumber = EpochFromSlot(slotNumber)
 	c.status.TipSlotNumber = tipSlotNumber
 	c.status.TipBlockHash = tipBlockHash
 	if c.statusUpdateFunc != nil {

input/chainsync/chainsync_test.go

@@ -1,3 +1,16 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 package chainsync
 
 import (
@@ -65,14 +78,12 @@ func TestHandleRollBackward(t *testing.T) {
 
 	// Verify that the status was updated correctly
 	assert.Equal(t, uint64(12345), c.status.SlotNumber)
-	assert.Equal(
-		t,
-		uint64(0),
-		c.status.BlockNumber,
-	) // BlockNumber should be 0 after rollback
+	assert.Equal(t, uint64(0), c.status.BlockNumber) // BlockNumber should be 0 after rollback
 	assert.Equal(t, "0102030405", c.status.BlockHash)
 	assert.Equal(t, uint64(67890), c.status.TipSlotNumber)
 	assert.Equal(t, "060708090a", c.status.TipBlockHash)
+	// New: Check EpochNumber (Byron era: 12345/21600 = 0)
+	assert.Equal(t, uint64(0), c.status.EpochNumber)
 }
 
 func TestGetKupoClient(t *testing.T) {

internal/config/config.go

@@ -15,6 +15,7 @@
 package config
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -24,21 +25,79 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
+// ByronGenesisConfig holds Byron era genesis parameters
+type ByronGenesisConfig struct {
+	EpochLength        uint64  `yaml:"epoch_length"`
+	ByronSlotsPerEpoch uint64  `yaml:"byron_slots_per_epoch"`
+	EndSlot            *uint64 `yaml:"end_slot"`
+	Epochs             *uint64 `yaml:"epochs"`
+}
+
+// ShelleyGenesisConfig holds Shelley era genesis parameters
+type ShelleyGenesisConfig struct {
+	EpochLength uint64 `yaml:"epoch_length"`
+}
+
+// ShelleyTransEpoch holds transition slot/epoch info
+type ShelleyTransEpoch struct {
+	FirstShelleySlot  uint64 `yaml:"first_shelley_slot"`
+	FirstShelleyEpoch uint64 `yaml:"first_shelley_epoch"`
+}
+
+// populateByronGenesis sets defaults and validates ByronGenesisConfig
+func (c *Config) populateByronGenesis() error {
+	cfg := &c.ByronGenesis
+	if cfg.EpochLength == 0 {
+		cfg.EpochLength = 21600
+	}
+	if cfg.ByronSlotsPerEpoch == 0 {
+		cfg.ByronSlotsPerEpoch = cfg.EpochLength
+	}
+	if cfg.EndSlot == nil {
+		defaultEndSlot := uint64(4492799)
+		cfg.EndSlot = &defaultEndSlot
+	}
+	if cfg.Epochs == nil {
+		defaultEpochs := uint64(208)
+		cfg.Epochs = &defaultEpochs
+	}
+	if cfg.EpochLength == 0 {
+		return errors.New("ByronGenesisConfig: EpochLength must be nonzero")
+	}
+	if cfg.EndSlot == nil {
+		return errors.New("ByronGenesisConfig: EndSlot must be set (can be zero for Byron-less networks)")
+	}
+	if cfg.Epochs == nil {
+		return errors.New("ByronGenesisConfig: Epochs must be set (can be zero for Byron-less networks)")
+	}
+	return nil
+}
+
+// populateShelleyGenesis sets defaults and validates ShelleyGenesisConfig
+func (c *Config) populateShelleyGenesis() {
+	cfg := &c.ShelleyGenesis
+	if cfg.EpochLength == 0 {
+		cfg.EpochLength = 432000
+	}
+}
+
 const (
 	DefaultInputPlugin  = "chainsync"
 	DefaultOutputPlugin = "log"
 )
 
 type Config struct {
-	Plugin     map[string]map[string]map[any]any `yaml:"plugins"`
-	Logging    LoggingConfig                     `yaml:"logging"`
-	ConfigFile string                            `yaml:"-"`
-	Input      string                            `yaml:"input"    envconfig:"INPUT"`
-	Output     string                            `yaml:"output"   envconfig:"OUTPUT"`
-	KupoUrl    string                            `yaml:"kupo_url" envconfig:"KUPO_URL"`
-	Api        ApiConfig                         `yaml:"api"`
-	Debug      DebugConfig                       `yaml:"debug"`
-	Version    bool                              `yaml:"-"`
+	Plugin         map[string]map[string]map[any]any `yaml:"plugins"`
+	Logging        LoggingConfig                     `yaml:"logging"`
+	ConfigFile     string                            `yaml:"-"`
+	Input          string                            `yaml:"input"    envconfig:"INPUT"`
+	Output         string                            `yaml:"output"   envconfig:"OUTPUT"`
+	KupoUrl        string                            `yaml:"kupo_url" envconfig:"KUPO_URL"`
+	Api            ApiConfig                         `yaml:"api"`
+	Debug          DebugConfig                       `yaml:"debug"`
+	ByronGenesis   ByronGenesisConfig                `yaml:"byron_genesis" envconfig:"BYRON_GENESIS"`
+	ShelleyGenesis ShelleyGenesisConfig              `yaml:"shelley_genesis" envconfig:"SHELLEY_GENESIS"`
+	Version        bool                              `yaml:"-"`
 }
 
 type ApiConfig struct {
@@ -71,6 +130,14 @@ var globalConfig = &Config{
 	Input:   DefaultInputPlugin,
 	Output:  DefaultOutputPlugin,
 	KupoUrl: "",
+	ByronGenesis: ByronGenesisConfig{
+		EpochLength: 21600,
+		EndSlot:     func() *uint64 { v := uint64(4492799); return &v }(),
+		Epochs:      func() *uint64 { v := uint64(208); return &v }(),
+	},
+	ShelleyGenesis: ShelleyGenesisConfig{
+		EpochLength: 432000,
+	},
 }
 
 func (c *Config) Load(configFile string) error {
@@ -86,12 +153,15 @@ func (c *Config) Load(configFile string) error {
 		}
 	}
 	// Load config values from environment variables
-	// We use "dummy" as the app name here to (mostly) prevent picking up env
-	// vars that we hadn't explicitly specified in annotations above
 	err := envconfig.Process("dummy", c)
 	if err != nil {
 		return fmt.Errorf("error processing environment: %w", err)
 	}
+	// Populate Byron and Shelley genesis configs (from nview)
+	if err := c.populateByronGenesis(); err != nil {
+		return fmt.Errorf("error populating Byron genesis: %w", err)
+	}
+	c.populateShelleyGenesis()
 	return nil
 }