@blinklabs/dingo 0.6.0

package/ledger/slot.go

@@ -0,0 +1,127 @@
+// 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 ledger
+
+import (
+	"errors"
+	"math"
+	"time"
+
+	"github.com/blinklabs-io/dingo/database"
+)
+
+// SlotToTime returns the current time for a given slot based on known epochs
+func (ls *LedgerState) SlotToTime(slot uint64) (time.Time, error) {
+	if slot > math.MaxInt64 {
+		return time.Time{}, errors.New("slot is larger than time.Duration")
+	}
+	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
+	if shelleyGenesis == nil {
+		return time.Time{}, errors.New("could not get genesis config")
+	}
+	slotTime := shelleyGenesis.SystemStart
+	// Special case for chain genesis
+	if slot == 0 {
+		return slotTime, nil
+	}
+	foundSlot := false
+	for _, epoch := range ls.epochCache {
+		if epoch.StartSlot > math.MaxInt64 ||
+			epoch.LengthInSlots > math.MaxInt64 ||
+			epoch.SlotLength > math.MaxInt64 {
+			return time.Time{}, errors.New(
+				"epoch slot values are larger than time.Duration",
+			)
+		}
+		if slot < epoch.StartSlot+uint64(epoch.LengthInSlots) {
+			slotTime = slotTime.Add(
+				time.Duration(
+					int64(slot)-int64(epoch.StartSlot),
+				) * (time.Duration(epoch.SlotLength) * time.Millisecond),
+			)
+			foundSlot = true
+			break
+		}
+		slotTime = slotTime.Add(
+			time.Duration(
+				epoch.LengthInSlots,
+			) * (time.Duration(epoch.SlotLength) * time.Millisecond),
+		)
+	}
+	if !foundSlot {
+		return slotTime, errors.New("slot not found in known epochs")
+	}
+	return slotTime, nil
+}
+
+// TimeToSlot returns the slot number for a given time based on known epochs
+func (ls *LedgerState) TimeToSlot(t time.Time) (uint64, error) {
+	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
+	if shelleyGenesis == nil {
+		return 0, errors.New("could not get genesis config")
+	}
+	epochStartTime := shelleyGenesis.SystemStart
+	// Special case for chain genesis
+	if t.Equal(epochStartTime) {
+		return 0, nil
+	}
+	var timeSlot uint64
+	foundTime := false
+	for _, epoch := range ls.epochCache {
+		if epoch.LengthInSlots > math.MaxInt64 ||
+			epoch.SlotLength > math.MaxInt64 {
+			return 0, errors.New(
+				"epoch slot values are larger than time.Duration",
+			)
+		}
+		slotDuration := time.Duration(epoch.SlotLength) * time.Millisecond
+		if slotDuration < 0 {
+			return 0, errors.New("slot duration is negative")
+		}
+		epochEndTime := epochStartTime.Add(
+			time.Duration(epoch.LengthInSlots) * slotDuration,
+		)
+		if (t.Equal(epochStartTime) || t.After(epochStartTime)) &&
+			t.Before(epochEndTime) {
+			// Figure out how far into the epoch the specified time is
+			timeDiff := t.Sub(epochStartTime)
+			// nolint:gosec
+			// This will never overflow using 2 positive int64 values, but gosec seems determined
+			// to complain about it
+			timeSlot += uint64(timeDiff / slotDuration)
+			foundTime = true
+			break
+		}
+		epochStartTime = epochEndTime
+		timeSlot += uint64(epoch.LengthInSlots)
+	}
+	if !foundTime {
+		return timeSlot, errors.New("time not found in known epochs")
+	}
+	return timeSlot, nil
+}
+
+// SlotToEpoch returns a known epoch by slot number
+func (ls *LedgerState) SlotToEpoch(slot uint64) (database.Epoch, error) {
+	for _, epoch := range ls.epochCache {
+		if slot < epoch.StartSlot {
+			continue
+		}
+		if slot < epoch.StartSlot+uint64(epoch.LengthInSlots) {
+			return epoch, nil
+		}
+	}
+	return database.Epoch{}, errors.New("slot not found in known epochs")
+}

package/ledger/slot_test.go

@@ -0,0 +1,147 @@
+// 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 ledger
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/blinklabs-io/dingo/config/cardano"
+	"github.com/blinklabs-io/dingo/database"
+)
+
+func TestSlotCalc(t *testing.T) {
+	testLedgerState := &LedgerState{
+		epochCache: []database.Epoch{
+			{
+				EpochId:       0,
+				StartSlot:     0,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+			{
+				EpochId:       1,
+				StartSlot:     86400,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+			{
+				EpochId:       2,
+				StartSlot:     172800,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+			{
+				EpochId:       3,
+				StartSlot:     259200,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+			{
+				EpochId:       4,
+				StartSlot:     345600,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+			{
+				EpochId:       5,
+				StartSlot:     432000,
+				SlotLength:    1000,
+				LengthInSlots: 86400,
+			},
+		},
+		config: LedgerStateConfig{
+			CardanoNodeConfig: &cardano.CardanoNodeConfig{},
+		},
+	}
+	testShelleyGenesis := `{"systemStart": "2022-10-25T00:00:00Z"}`
+	if err := testLedgerState.config.CardanoNodeConfig.LoadShelleyGenesisFromReader(strings.NewReader(testShelleyGenesis)); err != nil {
+		t.Fatalf("unexpected error loading cardano node config: %s", err)
+	}
+	testDefs := []struct {
+		slot     uint64
+		slotTime time.Time
+		epoch    uint64
+	}{
+		{
+			slot:     0,
+			slotTime: time.Date(2022, time.October, 25, 0, 0, 0, 0, time.UTC),
+			epoch:    0,
+		},
+		{
+			slot: 86399,
+			slotTime: time.Date(
+				2022,
+				time.October,
+				25,
+				23,
+				59,
+				59,
+				0,
+				time.UTC,
+			),
+			epoch: 0,
+		},
+		{
+			slot:     86400,
+			slotTime: time.Date(2022, time.October, 26, 0, 0, 0, 0, time.UTC),
+			epoch:    1,
+		},
+		{
+			slot:     432001,
+			slotTime: time.Date(2022, time.October, 30, 0, 0, 1, 0, time.UTC),
+			epoch:    5,
+		},
+	}
+	for _, testDef := range testDefs {
+		// Slot to time
+		tmpSlotToTime, err := testLedgerState.SlotToTime(testDef.slot)
+		if err != nil {
+			t.Errorf("unexpected error converting slot to time: %s", err)
+		}
+		if !tmpSlotToTime.Equal(testDef.slotTime) {
+			t.Errorf(
+				"did not get expected time from slot: got %s, wanted %s",
+				tmpSlotToTime,
+				testDef.slotTime,
+			)
+		}
+		// Time to slot
+		tmpTimeToSlot, err := testLedgerState.TimeToSlot(testDef.slotTime)
+		if err != nil {
+			t.Errorf("unexpected error converting time to slot: %s", err)
+		}
+		if tmpTimeToSlot != testDef.slot {
+			t.Errorf(
+				"did not get expected slot from time: got %d, wanted %d",
+				tmpTimeToSlot,
+				testDef.slot,
+			)
+		}
+		// Slot to epoch
+		tmpSlotToEpoch, err := testLedgerState.SlotToEpoch(testDef.slot)
+		if err != nil {
+			t.Errorf("unexpected error getting epoch from slot: %s", err)
+		}
+		if tmpSlotToEpoch.EpochId != testDef.epoch {
+			t.Errorf(
+				"did not get expected epoch from slot: got %d, wanted %d",
+				tmpSlotToEpoch.EpochId,
+				testDef.epoch,
+			)
+		}
+	}
+}