@blinklabs/dingo 0.7.0 → 0.8.0

package/ledger/queries.go

@@ -1,258 +0,0 @@
-// 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"
-	"fmt"
-	"math/big"
-
-	"github.com/blinklabs-io/dingo/database"
-	"github.com/blinklabs-io/dingo/ledger/eras"
-	"github.com/blinklabs-io/gouroboros/cbor"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	olocalstatequery "github.com/blinklabs-io/gouroboros/protocol/localstatequery"
-)
-
-func (ls *LedgerState) Query(query any) (any, error) {
-	switch q := query.(type) {
-	case *olocalstatequery.BlockQuery:
-		return ls.queryBlock(q)
-	case *olocalstatequery.SystemStartQuery:
-		return ls.querySystemStart()
-	case *olocalstatequery.ChainBlockNoQuery:
-		return ls.queryChainBlockNo()
-	case *olocalstatequery.ChainPointQuery:
-		return ls.queryChainPoint()
-	default:
-		return nil, fmt.Errorf("unsupported query type: %T", q)
-	}
-}
-
-func (ls *LedgerState) queryBlock(
-	query *olocalstatequery.BlockQuery,
-) (any, error) {
-	switch q := query.Query.(type) {
-	case *olocalstatequery.HardForkQuery:
-		return ls.queryHardFork(q)
-	case *olocalstatequery.ShelleyQuery:
-		return ls.queryShelley(q)
-	default:
-		return nil, fmt.Errorf("unsupported query type: %T", q)
-	}
-}
-
-func (ls *LedgerState) querySystemStart() (any, error) {
-	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
-	if shelleyGenesis == nil {
-		return nil, errors.New(
-			"unable to get shelley era genesis for system start",
-		)
-	}
-	ret := olocalstatequery.SystemStartResult{
-		Year:        *big.NewInt(int64(shelleyGenesis.SystemStart.Year())),
-		Day:         shelleyGenesis.SystemStart.YearDay(),
-		Picoseconds: *big.NewInt(int64(shelleyGenesis.SystemStart.Nanosecond() * 1000)),
-	}
-	return ret, nil
-}
-
-func (ls *LedgerState) queryChainBlockNo() (any, error) {
-	ret := []any{
-		1, // TODO: figure out what this value is (#393)
-		ls.currentTip.BlockNumber,
-	}
-	return ret, nil
-}
-
-func (ls *LedgerState) queryChainPoint() (any, error) {
-	return ls.currentTip.Point, nil
-}
-
-func (ls *LedgerState) queryHardFork(
-	query *olocalstatequery.HardForkQuery,
-) (any, error) {
-	switch q := query.Query.(type) {
-	case *olocalstatequery.HardForkCurrentEraQuery:
-		return ls.currentEra.Id, nil
-	case *olocalstatequery.HardForkEraHistoryQuery:
-		return ls.queryHardForkEraHistory()
-	default:
-		return nil, fmt.Errorf("unsupported query type: %T", q)
-	}
-}
-
-func (ls *LedgerState) queryHardForkEraHistory() (any, error) {
-	retData := []any{}
-	timespan := big.NewInt(0)
-	var epochs []database.Epoch
-	var era eras.EraDesc
-	var err error
-	var tmpStart, tmpEnd []any
-	var tmpEpoch database.Epoch
-	var tmpEra, tmpParams []any
-	var epochSlotLength, epochLength uint
-	var idx int
-	for _, era = range eras.Eras {
-		epochSlotLength, epochLength, err = era.EpochLengthFunc(
-			ls.config.CardanoNodeConfig,
-		)
-		if err != nil {
-			return nil, err
-		}
-		epochs, err = ls.db.GetEpochsByEra(era.Id, nil)
-		if err != nil {
-			return nil, err
-		}
-		tmpStart = []any{0, 0, 0}
-		tmpEnd = tmpStart
-		tmpParams = []any{
-			epochLength,
-			epochSlotLength,
-			[]any{
-				0,
-				0,
-				[]any{0},
-			},
-			0,
-		}
-		for idx, tmpEpoch = range epochs {
-			// Update era start
-			if idx == 0 {
-				tmpStart = []any{
-					new(big.Int).Set(timespan),
-					tmpEpoch.StartSlot,
-					tmpEpoch.EpochId,
-				}
-			}
-			// Add epoch length in picoseconds to timespan
-			timespan.Add(
-				timespan,
-				new(big.Int).SetUint64(
-					uint64(
-						tmpEpoch.SlotLength*tmpEpoch.LengthInSlots*1_000_000_000,
-					),
-				),
-			)
-			// Update era end
-			if idx == len(epochs)-1 {
-				tmpEnd = []any{
-					new(big.Int).Set(timespan),
-					tmpEpoch.StartSlot + uint64(tmpEpoch.LengthInSlots),
-					tmpEpoch.EpochId + 1,
-				}
-			}
-		}
-		tmpEra = []any{
-			tmpStart,
-			tmpEnd,
-			tmpParams,
-		}
-		retData = append(retData, tmpEra)
-	}
-	return cbor.IndefLengthList(retData), nil
-}
-
-func (ls *LedgerState) queryShelley(
-	query *olocalstatequery.ShelleyQuery,
-) (any, error) {
-	switch q := query.Query.(type) {
-	case *olocalstatequery.ShelleyEpochNoQuery:
-		return []any{ls.currentEpoch.EpochId}, nil
-	case *olocalstatequery.ShelleyCurrentProtocolParamsQuery:
-		return []any{ls.currentPParams}, nil
-	case *olocalstatequery.ShelleyGenesisConfigQuery:
-		return ls.queryShelleyGenesisConfig()
-	case *olocalstatequery.ShelleyUtxoByAddressQuery:
-		return ls.queryShelleyUtxoByAddress(q.Addrs)
-	case *olocalstatequery.ShelleyUtxoByTxinQuery:
-		return ls.queryShelleyUtxoByTxIn(q.TxIns)
-	// TODO (#394)
-	/*
-		case *olocalstatequery.ShelleyLedgerTipQuery:
-		case *olocalstatequery.ShelleyNonMyopicMemberRewardsQuery:
-		case *olocalstatequery.ShelleyProposedProtocolParamsUpdatesQuery:
-		case *olocalstatequery.ShelleyStakeDistributionQuery:
-		case *olocalstatequery.ShelleyUtxoWholeQuery:
-		case *olocalstatequery.ShelleyDebugEpochStateQuery:
-		case *olocalstatequery.ShelleyCborQuery:
-		case *olocalstatequery.ShelleyFilteredDelegationAndRewardAccountsQuery:
-		case *olocalstatequery.ShelleyDebugNewEpochStateQuery:
-		case *olocalstatequery.ShelleyDebugChainDepStateQuery:
-		case *olocalstatequery.ShelleyRewardProvenanceQuery:
-		case *olocalstatequery.ShelleyStakePoolsQuery:
-		case *olocalstatequery.ShelleyStakePoolParamsQuery:
-		case *olocalstatequery.ShelleyRewardInfoPoolsQuery:
-		case *olocalstatequery.ShelleyPoolStateQuery:
-		case *olocalstatequery.ShelleyStakeSnapshotsQuery:
-		case *olocalstatequery.ShelleyPoolDistrQuery:
-	*/
-	default:
-		return nil, fmt.Errorf("unsupported query type: %T", q)
-	}
-}
-
-func (ls *LedgerState) queryShelleyGenesisConfig() (any, error) {
-	shelleyGenesis := ls.config.CardanoNodeConfig.ShelleyGenesis()
-	return []any{shelleyGenesis}, nil
-}
-
-func (ls *LedgerState) queryShelleyUtxoByAddress(
-	addrs []ledger.Address,
-) (any, error) {
-	ret := make(map[olocalstatequery.UtxoId]ledger.TransactionOutput)
-	// TODO: support multiple addresses (#391)
-	utxos, err := ls.db.UtxosByAddress(addrs[0], nil)
-	if err != nil {
-		return nil, err
-	}
-	for _, utxo := range utxos {
-		txOut, err := utxo.Decode()
-		if err != nil {
-			return nil, err
-		}
-		utxoId := olocalstatequery.UtxoId{
-			Hash: ledger.NewBlake2b256(utxo.TxId),
-			Idx:  int(utxo.OutputIdx),
-		}
-		ret[utxoId] = txOut
-	}
-	return []any{ret}, nil
-}
-
-func (ls *LedgerState) queryShelleyUtxoByTxIn(
-	txIns []ledger.ShelleyTransactionInput,
-) (any, error) {
-	ret := make(map[olocalstatequery.UtxoId]ledger.TransactionOutput)
-	// TODO: support multiple TxIns (#392)
-	utxo, err := ls.db.UtxoByRef(
-		txIns[0].Id().Bytes(),
-		txIns[0].Index(),
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-	txOut, err := utxo.Decode()
-	if err != nil {
-		return nil, err
-	}
-	utxoId := olocalstatequery.UtxoId{
-		Hash: ledger.NewBlake2b256(utxo.TxId),
-		Idx:  int(utxo.OutputIdx),
-	}
-	ret[utxoId] = txOut
-	return []any{ret}, nil
-}

package/ledger/slot.go

@@ -1,127 +0,0 @@
-// 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

@@ -1,147 +0,0 @@
-// 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,
-			)
-		}
-	}
-}