@blinklabs/dingo 0.6.0

package/ledger/eras/mary.go

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

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

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

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

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

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