@blinklabs/dingo 0.6.0 → 0.8.0

package/ledger/eras/mary.go

@@ -1,154 +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 eras
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-
-	"github.com/blinklabs-io/dingo/config/cardano"
-	"github.com/blinklabs-io/gouroboros/cbor"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	"github.com/blinklabs-io/gouroboros/ledger/allegra"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	"github.com/blinklabs-io/gouroboros/ledger/mary"
-)
-
-var MaryEraDesc = EraDesc{
-	Id:                      mary.EraIdMary,
-	Name:                    mary.EraNameMary,
-	DecodePParamsFunc:       DecodePParamsMary,
-	DecodePParamsUpdateFunc: DecodePParamsUpdateMary,
-	PParamsUpdateFunc:       PParamsUpdateMary,
-	HardForkFunc:            HardForkMary,
-	EpochLengthFunc:         EpochLengthShelley,
-	CalculateEtaVFunc:       CalculateEtaVMary,
-	CertDepositFunc:         CertDepositMary,
-	ValidateTxFunc:          ValidateTxMary,
-}
-
-func DecodePParamsMary(data []byte) (lcommon.ProtocolParameters, error) {
-	var ret mary.MaryProtocolParameters
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
-}
-
-func DecodePParamsUpdateMary(data []byte) (any, error) {
-	var ret mary.MaryProtocolParameterUpdate
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func PParamsUpdateMary(
-	currentPParams lcommon.ProtocolParameters,
-	pparamsUpdate any,
-) (lcommon.ProtocolParameters, error) {
-	maryPParams, ok := currentPParams.(*mary.MaryProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"current PParams (%T) is not expected type",
-			currentPParams,
-		)
-	}
-	maryPParamsUpdate, ok := pparamsUpdate.(mary.MaryProtocolParameterUpdate)
-	if !ok {
-		return nil, fmt.Errorf(
-			"PParams update (%T) is not expected type",
-			pparamsUpdate,
-		)
-	}
-	maryPParams.Update(&maryPParamsUpdate)
-	return maryPParams, nil
-}
-
-func HardForkMary(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevPParams lcommon.ProtocolParameters,
-) (lcommon.ProtocolParameters, error) {
-	allegraPParams, ok := prevPParams.(*allegra.AllegraProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"previous PParams (%T) are not expected type",
-			prevPParams,
-		)
-	}
-	ret := mary.UpgradePParams(*allegraPParams)
-	return &ret, nil
-}
-
-func CalculateEtaVMary(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevBlockNonce []byte,
-	block ledger.Block,
-) ([]byte, error) {
-	if len(prevBlockNonce) == 0 {
-		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
-		if err != nil {
-			return nil, err
-		}
-		prevBlockNonce = tmpNonce
-	}
-	h, ok := block.Header().(*mary.MaryBlockHeader)
-	if !ok {
-		return nil, errors.New("unexpected block type")
-	}
-	tmpNonce, err := lcommon.CalculateRollingNonce(
-		prevBlockNonce,
-		h.Body.NonceVrf.Output,
-	)
-	if err != nil {
-		return nil, err
-	}
-	return tmpNonce.Bytes(), nil
-}
-
-func CertDepositMary(
-	cert lcommon.Certificate,
-	pp lcommon.ProtocolParameters,
-) (uint64, error) {
-	tmpPparams, ok := pp.(*mary.MaryProtocolParameters)
-	if !ok {
-		return 0, errors.New("pparams are not expected type")
-	}
-	switch cert.(type) {
-	case *lcommon.PoolRegistrationCertificate:
-		return uint64(tmpPparams.PoolDeposit), nil
-	case *lcommon.StakeRegistrationCertificate:
-		return uint64(tmpPparams.KeyDeposit), nil
-	default:
-		return 0, nil
-	}
-}
-
-func ValidateTxMary(
-	tx lcommon.Transaction,
-	slot uint64,
-	ls lcommon.LedgerState,
-	pp lcommon.ProtocolParameters,
-) error {
-	errs := []error{}
-	for _, validationFunc := range mary.UtxoValidationRules {
-		errs = append(
-			errs,
-			validationFunc(tx, slot, ls, pp),
-		)
-	}
-	return errors.Join(errs...)
-}

package/ledger/eras/shelley.go

@@ -1,164 +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 eras
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-
-	"github.com/blinklabs-io/dingo/config/cardano"
-	"github.com/blinklabs-io/gouroboros/cbor"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
-	"github.com/blinklabs-io/gouroboros/ledger/shelley"
-)
-
-var ShelleyEraDesc = EraDesc{
-	Id:                      shelley.EraIdShelley,
-	Name:                    shelley.EraNameShelley,
-	DecodePParamsFunc:       DecodePParamsShelley,
-	DecodePParamsUpdateFunc: DecodePParamsUpdateShelley,
-	PParamsUpdateFunc:       PParamsUpdateShelley,
-	HardForkFunc:            HardForkShelley,
-	EpochLengthFunc:         EpochLengthShelley,
-	CalculateEtaVFunc:       CalculateEtaVShelley,
-	CertDepositFunc:         CertDepositShelley,
-	ValidateTxFunc:          ValidateTxShelley,
-}
-
-func DecodePParamsShelley(data []byte) (lcommon.ProtocolParameters, error) {
-	var ret shelley.ShelleyProtocolParameters
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
-}
-
-func DecodePParamsUpdateShelley(data []byte) (any, error) {
-	var ret shelley.ShelleyProtocolParameterUpdate
-	if _, err := cbor.Decode(data, &ret); err != nil {
-		return nil, err
-	}
-	return ret, nil
-}
-
-func PParamsUpdateShelley(
-	currentPParams lcommon.ProtocolParameters,
-	pparamsUpdate any,
-) (lcommon.ProtocolParameters, error) {
-	shelleyPParams, ok := currentPParams.(*shelley.ShelleyProtocolParameters)
-	if !ok {
-		return nil, fmt.Errorf(
-			"current PParams (%T) is not expected type",
-			currentPParams,
-		)
-	}
-	shelleyPParamsUpdate, ok := pparamsUpdate.(shelley.ShelleyProtocolParameterUpdate)
-	if !ok {
-		return nil, fmt.Errorf(
-			"PParams update (%T) is not expected type",
-			pparamsUpdate,
-		)
-	}
-	shelleyPParams.Update(&shelleyPParamsUpdate)
-	return shelleyPParams, nil
-}
-
-func HardForkShelley(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevPParams lcommon.ProtocolParameters,
-) (lcommon.ProtocolParameters, error) {
-	// There's no Byron protocol parameters to upgrade from, so this is mostly
-	// a dummy call for consistency
-	ret := shelley.UpgradePParams(nil)
-	shelleyGenesis := nodeConfig.ShelleyGenesis()
-	ret.UpdateFromGenesis(shelleyGenesis)
-	return &ret, nil
-}
-
-func EpochLengthShelley(
-	nodeConfig *cardano.CardanoNodeConfig,
-) (uint, uint, error) {
-	shelleyGenesis := nodeConfig.ShelleyGenesis()
-	if shelleyGenesis == nil {
-		return 0, 0, errors.New("unable to get shelley genesis")
-	}
-	// These are known to be within uint range
-	// #nosec G115
-	return uint(shelleyGenesis.SlotLength * 1000),
-		uint(shelleyGenesis.EpochLength),
-		nil
-}
-
-func CalculateEtaVShelley(
-	nodeConfig *cardano.CardanoNodeConfig,
-	prevBlockNonce []byte,
-	block ledger.Block,
-) ([]byte, error) {
-	if len(prevBlockNonce) == 0 {
-		tmpNonce, err := hex.DecodeString(nodeConfig.ShelleyGenesisHash)
-		if err != nil {
-			return nil, err
-		}
-		prevBlockNonce = tmpNonce
-	}
-	h, ok := block.Header().(*shelley.ShelleyBlockHeader)
-	if !ok {
-		return nil, errors.New("unexpected block type")
-	}
-	tmpNonce, err := lcommon.CalculateRollingNonce(
-		prevBlockNonce,
-		h.Body.NonceVrf.Output,
-	)
-	if err != nil {
-		return nil, err
-	}
-	return tmpNonce.Bytes(), nil
-}
-
-func CertDepositShelley(
-	cert lcommon.Certificate,
-	pp lcommon.ProtocolParameters,
-) (uint64, error) {
-	tmpPparams, ok := pp.(*shelley.ShelleyProtocolParameters)
-	if !ok {
-		return 0, errors.New("pparams are not expected type")
-	}
-	switch cert.(type) {
-	case *lcommon.PoolRegistrationCertificate:
-		return uint64(tmpPparams.PoolDeposit), nil
-	case *lcommon.StakeRegistrationCertificate:
-		return uint64(tmpPparams.KeyDeposit), nil
-	default:
-		return 0, nil
-	}
-}
-
-func ValidateTxShelley(
-	tx lcommon.Transaction,
-	slot uint64,
-	ls lcommon.LedgerState,
-	pp lcommon.ProtocolParameters,
-) error {
-	errs := []error{}
-	for _, validationFunc := range shelley.UtxoValidationRules {
-		errs = append(
-			errs,
-			validationFunc(tx, slot, ls, pp),
-		)
-	}
-	return errors.Join(errs...)
-}

package/ledger/error.go

@@ -1,19 +0,0 @@
-// Copyright 2024 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"
-
-var ErrBlockNotFound = errors.New("block not found")

package/ledger/event.go

@@ -1,50 +0,0 @@
-// Copyright 2024 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 (
-	"github.com/blinklabs-io/dingo/event"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	ochainsync "github.com/blinklabs-io/gouroboros/protocol/chainsync"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-)
-
-const (
-	BlockfetchEventType event.EventType = "blockfetch.event"
-	ChainsyncEventType  event.EventType = "chainsync.event"
-)
-
-// BlockfetchEvent represents either a Block or BatchDone blockfetch event. We use
-// a single event type for both to make synchronization easier.
-type BlockfetchEvent struct {
-	ConnectionId ouroboros.ConnectionId // Connection ID associated with event
-	Point        ocommon.Point          // Chain point for block
-	Block        ledger.Block
-	Type         uint // Block type ID
-	BatchDone    bool // Set to true for a BatchDone event
-}
-
-// ChainsyncEvent represents either a RollForward or RollBackward chainsync event.
-// We use a single event type for both to make synchronization easier.
-type ChainsyncEvent struct {
-	ConnectionId ouroboros.ConnectionId // Connection ID associated with event
-	Point        ocommon.Point          // Chain point for roll forward/backward
-	Tip          ochainsync.Tip         // Upstream chain tip
-	BlockNumber  uint64
-	BlockHeader  ledger.BlockHeader
-	Type         uint // Block or header type ID
-	Rollback     bool
-}

package/ledger/metrics.go

@@ -1,53 +0,0 @@
-// Copyright 2024 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 (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-type stateMetrics struct {
-	blockNum    prometheus.Gauge
-	density     prometheus.Gauge
-	epochNum    prometheus.Gauge
-	slotInEpoch prometheus.Gauge
-	slotNum     prometheus.Gauge
-}
-
-func (m *stateMetrics) init(promRegistry prometheus.Registerer) {
-	promautoFactory := promauto.With(promRegistry)
-	m.blockNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_blockNum_int",
-		Help: "current block number",
-	})
-	// TODO: figure out how to calculate this (#390)
-	m.density = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_density_real",
-		Help: "chain density",
-	})
-	m.epochNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_epoch_int",
-		Help: "current epoch number",
-	})
-	m.slotInEpoch = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_slotInEpoch_int",
-		Help: "current relative slot number in epoch",
-	})
-	m.slotNum = promautoFactory.NewGauge(prometheus.GaugeOpts{
-		Name: "cardano_node_metrics_slotNum_int",
-		Help: "current slot number",
-	})
-}

package/ledger/queries.go

@@ -1,260 +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",
-		)
-	}
-	// Nanosecond is always within uint64 range
-	// #nosec G115
-	ret := olocalstatequery.SystemStartResult{
-		Year:        shelleyGenesis.SystemStart.Year(),
-		Day:         shelleyGenesis.SystemStart.YearDay(),
-		Picoseconds: uint64(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
-}