@blinklabs/dingo 0.6.0

package/txsubmission.go

@@ -0,0 +1,233 @@
+// 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 dingo
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math"
+
+	"github.com/blinklabs-io/dingo/mempool"
+	ouroboros "github.com/blinklabs-io/gouroboros"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/protocol/txsubmission"
+)
+
+const (
+	txsubmissionRequestTxIdsCount = 10 // Number of TxIds to request from peer at one time
+)
+
+func (n *Node) txsubmissionServerConnOpts() []txsubmission.TxSubmissionOptionFunc {
+	return []txsubmission.TxSubmissionOptionFunc{
+		txsubmission.WithInitFunc(n.txsubmissionServerInit),
+	}
+}
+
+func (n *Node) txsubmissionClientConnOpts() []txsubmission.TxSubmissionOptionFunc {
+	return []txsubmission.TxSubmissionOptionFunc{
+		txsubmission.WithRequestTxIdsFunc(n.txsubmissionClientRequestTxIds),
+		txsubmission.WithRequestTxsFunc(n.txsubmissionClientRequestTxs),
+	}
+}
+
+func (n *Node) txsubmissionClientStart(connId ouroboros.ConnectionId) error {
+	// Register mempool consumer
+	// We don't bother capturing the consumer because we can easily look it up later by connection ID
+	_ = n.mempool.AddConsumer(connId)
+	// Start TxSubmission loop
+	conn := n.connManager.GetConnectionById(connId)
+	if conn == nil {
+		return fmt.Errorf("failed to lookup connection ID: %s", connId.String())
+	}
+	conn.TxSubmission().Client.Init()
+	return nil
+}
+
+func (n *Node) txsubmissionServerInit(ctx txsubmission.CallbackContext) error {
+	// Start async loop to request transactions from the peer's mempool
+	go func() {
+		for {
+			// Request available TX IDs (era and TX hash) and sizes
+			// We make the request blocking to avoid looping on our side
+			txIds, err := ctx.Server.RequestTxIds(
+				true,
+				txsubmissionRequestTxIdsCount,
+			)
+			if err != nil {
+				n.config.logger.Error(
+					fmt.Sprintf(
+						"failed to get TxIds: %s",
+						err,
+					),
+					"component", "network",
+					"protocol", "tx-submission",
+					"role", "server",
+					"connection_id", ctx.ConnectionId.String(),
+				)
+				return
+			}
+			if len(txIds) > 0 {
+				// Unwrap inner TxId from TxIdAndSize
+				var requestTxIds []txsubmission.TxId
+				for _, txId := range txIds {
+					requestTxIds = append(requestTxIds, txId.TxId)
+				}
+				// Request TX content for TxIds from above
+				txs, err := ctx.Server.RequestTxs(requestTxIds)
+				if err != nil {
+					n.config.logger.Error(
+						fmt.Sprintf(
+							"failed to get Txs: %s",
+							err,
+						),
+						"component", "network",
+						"protocol", "tx-submission",
+						"role", "server",
+						"connection_id", ctx.ConnectionId.String(),
+					)
+					return
+				}
+				for _, txBody := range txs {
+					// Decode TX from CBOR
+					tx, err := ledger.NewTransactionFromCbor(
+						uint(txBody.EraId),
+						txBody.TxBody,
+					)
+					if err != nil {
+						n.config.logger.Error(
+							fmt.Sprintf(
+								"failed to parse transaction CBOR: %s",
+								err,
+							),
+							"component", "network",
+							"protocol", "tx-submission",
+							"role", "server",
+							"connection_id", ctx.ConnectionId.String(),
+						)
+						return
+					}
+					n.config.logger.Debug(
+						"received tx",
+						"tx_hash", tx.Hash(),
+						"protocol", "tx-submission",
+						"role", "server",
+						"connection_id", ctx.ConnectionId.String(),
+					)
+					// Add transaction to mempool
+					err = n.mempool.AddTransaction(
+						uint(txBody.EraId),
+						txBody.TxBody,
+					)
+					if err != nil {
+						n.config.logger.Error(
+							fmt.Sprintf(
+								"failed to add tx %x to mempool: %s",
+								tx.Hash(),
+								err,
+							),
+							"component", "network",
+							"protocol", "tx-submission",
+							"role", "server",
+							"connection_id", ctx.ConnectionId.String(),
+						)
+						return
+					}
+				}
+			}
+		}
+	}()
+	return nil
+}
+
+func (n *Node) txsubmissionClientRequestTxIds(
+	ctx txsubmission.CallbackContext,
+	blocking bool,
+	ack uint16,
+	req uint16,
+) ([]txsubmission.TxIdAndSize, error) {
+	connId := ctx.ConnectionId
+	ret := []txsubmission.TxIdAndSize{}
+	consumer := n.mempool.Consumer(connId)
+	// Clear TX cache
+	if ack > 0 {
+		consumer.ClearCache()
+	}
+	// Get available TXs
+	var tmpTxs []*mempool.MempoolTransaction
+	for {
+		if blocking && len(tmpTxs) == 0 {
+			// Wait until we see a TX
+			tmpTx := consumer.NextTx(true)
+			if tmpTx == nil {
+				break
+			}
+			tmpTxs = append(tmpTxs, tmpTx)
+		} else {
+			// Return immediately if no TX is available
+			tmpTx := consumer.NextTx(false)
+			if tmpTx == nil {
+				break
+			}
+			tmpTxs = append(tmpTxs, tmpTx)
+		}
+	}
+	for _, tmpTx := range tmpTxs {
+		// Add to return value
+		txHashBytes, err := hex.DecodeString(tmpTx.Hash)
+		if err != nil {
+			return nil, err
+		}
+		txSize := len(tmpTx.Cbor)
+		if txSize > math.MaxUint32 {
+			return nil, errors.New("tx impossibly large")
+		}
+		ret = append(
+			ret,
+			txsubmission.TxIdAndSize{
+				TxId: txsubmission.TxId{
+					EraId: uint16(tmpTx.Type), // #nosec G115
+					TxId:  [32]byte(txHashBytes),
+				},
+				Size: uint32(txSize),
+			},
+		)
+	}
+	return ret, nil
+}
+
+func (n *Node) txsubmissionClientRequestTxs(
+	ctx txsubmission.CallbackContext,
+	txIds []txsubmission.TxId,
+) ([]txsubmission.TxBody, error) {
+	connId := ctx.ConnectionId
+	ret := []txsubmission.TxBody{}
+	consumer := n.mempool.Consumer(connId)
+	for _, txId := range txIds {
+		txHash := hex.EncodeToString(txId.TxId[:])
+		tx := consumer.GetTxFromCache(txHash)
+		if tx != nil {
+			ret = append(
+				ret,
+				txsubmission.TxBody{
+					EraId:  uint16(tx.Type), // #nosec G115
+					TxBody: tx.Cbor,
+				},
+			)
+		}
+		consumer.RemoveTxFromCache(txHash)
+	}
+	return ret, nil
+}

package/utxorpc/query.go

@@ -0,0 +1,311 @@
+// 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 utxorpc
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+
+	"connectrpc.com/connect"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	query "github.com/utxorpc/go-codegen/utxorpc/v1alpha/query"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/query/queryconnect"
+)
+
+// queryServiceServer implements the QueryService API
+type queryServiceServer struct {
+	queryconnect.UnimplementedQueryServiceHandler
+	utxorpc *Utxorpc
+}
+
+// ReadParams
+func (s *queryServiceServer) ReadParams(
+	ctx context.Context,
+	req *connect.Request[query.ReadParamsRequest],
+) (*connect.Response[query.ReadParamsResponse], error) {
+	fieldMask := req.Msg.GetFieldMask()
+
+	s.utxorpc.config.Logger.Info(
+		fmt.Sprintf(
+			"Got a ReadParams request with fieldMask %v",
+			fieldMask,
+		),
+	)
+	resp := &query.ReadParamsResponse{}
+
+	protoParams := s.utxorpc.config.LedgerState.GetCurrentPParams()
+	if protoParams == nil {
+		return nil, errors.New("current protocol parameters empty")
+	}
+
+	// Get chain point (slot and hash)
+	point := s.utxorpc.config.LedgerState.Tip().Point
+
+	// Set up response parameters
+	acpc := &query.AnyChainParams_Cardano{
+		Cardano: protoParams.Utxorpc(),
+	}
+	resp.LedgerTip = &query.ChainPoint{
+		Slot: point.Slot,
+		Hash: point.Hash,
+	}
+	resp.Values = &query.AnyChainParams{
+		Params: acpc,
+	}
+	return connect.NewResponse(resp), nil
+}
+
+// ReadUtxos
+func (s *queryServiceServer) ReadUtxos(
+	ctx context.Context,
+	req *connect.Request[query.ReadUtxosRequest],
+) (*connect.Response[query.ReadUtxosResponse], error) {
+	keys := req.Msg.GetKeys() // []*TxoRef
+
+	s.utxorpc.config.Logger.Info(
+		fmt.Sprintf("Got a ReadUtxos request with keys %v", keys),
+	)
+	resp := &query.ReadUtxosResponse{}
+
+	// Get UTxOs from ledger
+	for _, txo := range keys {
+		utxo, err := s.utxorpc.config.LedgerState.UtxoByRef(
+			txo.GetHash(),
+			txo.GetIndex(),
+		)
+		if err != nil {
+			return nil, err
+		}
+		var aud query.AnyUtxoData
+		ret, err := utxo.Decode()
+		if err != nil {
+			return nil, err
+		}
+		if ret == nil {
+			return nil, errors.New("decode returned empty utxo")
+		}
+		audc := query.AnyUtxoData_Cardano{
+			Cardano: ret.Utxorpc(),
+		}
+		aud.NativeBytes = utxo.Cbor
+		aud.TxoRef = txo
+
+		if audc.Cardano.GetDatum() != nil {
+			// Check if Datum.Hash is all zeroes
+			isAllZeroes := true
+			for _, b := range audc.Cardano.GetDatum().GetHash() {
+				if b != 0 {
+					isAllZeroes = false
+					break
+				}
+			}
+			if isAllZeroes {
+				// No actual datum; set Datum to nil to omit it
+				audc.Cardano.Datum = nil
+			}
+		}
+		aud.ParsedState = &audc
+		resp.Items = append(resp.Items, &aud)
+	}
+
+	// Get chain point (slot and hash)
+	point := s.utxorpc.config.LedgerState.Tip().Point
+
+	// Set up response utxos
+	resp.LedgerTip = &query.ChainPoint{
+		Slot: point.Slot,
+		Hash: point.Hash,
+	}
+
+	return connect.NewResponse(resp), nil
+}
+
+// SearchUtxos
+func (s *queryServiceServer) SearchUtxos(
+	ctx context.Context,
+	req *connect.Request[query.SearchUtxosRequest],
+) (*connect.Response[query.SearchUtxosResponse], error) {
+	predicate := req.Msg.GetPredicate()   // *UtxoPredicate
+	startToken := req.Msg.GetStartToken() // string
+	maxItems := req.Msg.GetMaxItems()     // int32
+	fieldMask := req.Msg.GetFieldMask()
+
+	s.utxorpc.config.Logger.Info(
+		fmt.Sprintf(
+			"Got a SearchUtxos request with predicate %v, startToken %s, maxItems %d, and fieldMask %v",
+			predicate,
+			startToken,
+			maxItems,
+			fieldMask,
+		),
+	)
+	resp := &query.SearchUtxosResponse{}
+
+	// TODO: make this optional and create separate code paths
+	if predicate == nil {
+		return nil, fmt.Errorf("empty predicate: %v", predicate)
+	}
+
+	addressPattern := predicate.GetMatch().GetCardano().GetAddress()
+	assetPattern := predicate.GetMatch().GetCardano().GetAsset()
+
+	var addresses []ledger.Address
+	if addressPattern != nil {
+		// Handle Exact Address
+		exactAddressBytes := addressPattern.GetExactAddress()
+		if exactAddressBytes != nil {
+			var addr ledger.Address
+			err := addr.UnmarshalCBOR(exactAddressBytes)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"failed to decode exact address: %w",
+					err,
+				)
+			}
+			addresses = append(addresses, addr)
+		}
+
+		// Handle Payment Part
+		paymentPart := addressPattern.GetPaymentPart()
+		if paymentPart != nil {
+			s.utxorpc.config.Logger.Info("PaymentPart is present, decoding...")
+			var paymentAddr ledger.Address
+			err := paymentAddr.UnmarshalCBOR(paymentPart)
+			if err != nil {
+				return nil, fmt.Errorf("failed to decode payment part: %w", err)
+			}
+			addresses = append(addresses, paymentAddr)
+		}
+
+		// Handle Delegation Part
+		delegationPart := addressPattern.GetDelegationPart()
+		if delegationPart != nil {
+			s.utxorpc.config.Logger.Info(
+				"DelegationPart is present, decoding...",
+			)
+			var delegationAddr ledger.Address
+			err := delegationAddr.UnmarshalCBOR(delegationPart)
+			if err != nil {
+				return nil, fmt.Errorf(
+					"failed to decode delegation part: %w",
+					err,
+				)
+			}
+			addresses = append(addresses, delegationAddr)
+		}
+	}
+
+	// Get UTxOs from ledger
+	for _, address := range addresses {
+		utxos, err := s.utxorpc.config.LedgerState.UtxosByAddress(address)
+		if err != nil {
+			return nil, err
+		}
+		for _, utxo := range utxos {
+			var aud query.AnyUtxoData
+			ret, err := utxo.Decode()
+			if err != nil {
+				return nil, err
+			}
+			if ret == nil {
+				return nil, errors.New("decode returned empty utxo")
+			}
+			audc := query.AnyUtxoData_Cardano{
+				Cardano: ret.Utxorpc(),
+			}
+			aud.NativeBytes = utxo.Cbor
+			aud.TxoRef = &query.TxoRef{
+				Hash:  utxo.TxId,
+				Index: utxo.OutputIdx,
+			}
+			if audc.Cardano.GetDatum() != nil {
+				// Check if Datum.Hash is all zeroes
+				isAllZeroes := true
+				for _, b := range audc.Cardano.GetDatum().GetHash() {
+					if b != 0 {
+						isAllZeroes = false
+						break
+					}
+				}
+				if isAllZeroes {
+					// No actual datum; set Datum to nil to omit it
+					audc.Cardano.Datum = nil
+				}
+			}
+			aud.ParsedState = &audc
+
+			// If AssetPattern is specified, filter based on it
+			if assetPattern != nil {
+				assetFound := false
+				for _, multiasset := range audc.Cardano.GetAssets() {
+					if bytes.Equal(
+						multiasset.GetPolicyId(),
+						assetPattern.GetPolicyId(),
+					) {
+						for _, asset := range multiasset.GetAssets() {
+							if bytes.Equal(
+								asset.GetName(),
+								assetPattern.GetAssetName(),
+							) {
+								assetFound = true
+								break
+							}
+						}
+					}
+					if assetFound {
+						break
+					}
+				}
+
+				// Asset not found; skip this UTxO
+				if !assetFound {
+					continue
+				}
+			}
+			resp.Items = append(resp.Items, &aud)
+		}
+	}
+	// Get chain point (slot and hash)
+	point := s.utxorpc.config.LedgerState.Tip().Point
+
+	resp.LedgerTip = &query.ChainPoint{
+		Slot: point.Slot,
+		Hash: point.Hash,
+	}
+	return connect.NewResponse(resp), nil
+}
+
+// ReadData
+func (s *queryServiceServer) ReadData(
+	ctx context.Context,
+	req *connect.Request[query.ReadDataRequest],
+) (*connect.Response[query.ReadDataResponse], error) {
+	keys := req.Msg.GetKeys() // [][]byte
+	fieldMask := req.Msg.GetFieldMask()
+
+	s.utxorpc.config.Logger.Info(
+		fmt.Sprintf(
+			"Got a ReadData request with keys %v and fieldMask %v",
+			keys,
+			fieldMask,
+		),
+	)
+	resp := &query.ReadDataResponse{}
+
+	// TODO: do the thing once #317 is resolved
+	return connect.NewResponse(resp), nil
+}