@blinklabs/dingo 0.6.0

package/utxorpc/utxorpc.go

@@ -0,0 +1,166 @@
+// 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 (
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"connectrpc.com/connect"
+	"connectrpc.com/grpchealth"
+	"connectrpc.com/grpcreflect"
+	"github.com/blinklabs-io/dingo/event"
+	"github.com/blinklabs-io/dingo/ledger"
+	"github.com/blinklabs-io/dingo/mempool"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/query/queryconnect"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/submit/submitconnect"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/sync/syncconnect"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/watch/watchconnect"
+	"golang.org/x/net/http2"
+	"golang.org/x/net/http2/h2c"
+)
+
+type Utxorpc struct {
+	config UtxorpcConfig
+}
+
+type UtxorpcConfig struct {
+	Logger          *slog.Logger
+	EventBus        *event.EventBus
+	LedgerState     *ledger.LedgerState
+	Mempool         *mempool.Mempool
+	Host            string
+	Port            uint
+	TlsCertFilePath string
+	TlsKeyFilePath  string
+}
+
+func NewUtxorpc(cfg UtxorpcConfig) *Utxorpc {
+	if cfg.Logger == nil {
+		cfg.Logger = slog.New(slog.NewJSONHandler(io.Discard, nil))
+	}
+	cfg.Logger = cfg.Logger.With("component", "utxorpc")
+	if cfg.Host == "" {
+		cfg.Host = "0.0.0.0"
+	}
+	if cfg.Port == 0 {
+		cfg.Port = 9090
+	}
+	return &Utxorpc{
+		config: cfg,
+	}
+}
+
+func (u *Utxorpc) Start() error {
+	mux := http.NewServeMux()
+	compress1KB := connect.WithCompressMinBytes(1024)
+	queryPath, queryHandler := queryconnect.NewQueryServiceHandler(
+		&queryServiceServer{utxorpc: u},
+		compress1KB,
+	)
+	submitPath, submitHandler := submitconnect.NewSubmitServiceHandler(
+		&submitServiceServer{utxorpc: u},
+		compress1KB,
+	)
+	syncPath, syncHandler := syncconnect.NewSyncServiceHandler(
+		&syncServiceServer{utxorpc: u},
+		compress1KB,
+	)
+	watchPath, watchHandler := watchconnect.NewWatchServiceHandler(
+		&watchServiceServer{utxorpc: u},
+		compress1KB,
+	)
+	mux.Handle(queryPath, queryHandler)
+	mux.Handle(submitPath, submitHandler)
+	mux.Handle(syncPath, syncHandler)
+	mux.Handle(watchPath, watchHandler)
+	mux.Handle(
+		grpchealth.NewHandler(
+			grpchealth.NewStaticChecker(
+				queryconnect.QueryServiceName,
+				submitconnect.SubmitServiceName,
+				syncconnect.SyncServiceName,
+				watchconnect.WatchServiceName,
+			),
+			compress1KB,
+		),
+	)
+	mux.Handle(
+		grpcreflect.NewHandlerV1(
+			grpcreflect.NewStaticReflector(
+				queryconnect.QueryServiceName,
+				submitconnect.SubmitServiceName,
+				syncconnect.SyncServiceName,
+				watchconnect.WatchServiceName,
+			),
+			compress1KB,
+		),
+	)
+	mux.Handle(
+		grpcreflect.NewHandlerV1Alpha(
+			grpcreflect.NewStaticReflector(
+				queryconnect.QueryServiceName,
+				submitconnect.SubmitServiceName,
+				syncconnect.SyncServiceName,
+				watchconnect.WatchServiceName,
+			),
+			compress1KB,
+		),
+	)
+	if u.config.TlsCertFilePath != "" && u.config.TlsKeyFilePath != "" {
+		u.config.Logger.Info(
+			fmt.Sprintf(
+				"starting gRPC TLS listener on %s:%d",
+				u.config.Host,
+				u.config.Port,
+			),
+		)
+		utxorpc := &http.Server{
+			Addr: fmt.Sprintf(
+				"%s:%d",
+				u.config.Host,
+				u.config.Port,
+			),
+			Handler:           mux,
+			ReadHeaderTimeout: 60 * time.Second,
+		}
+		return utxorpc.ListenAndServeTLS(
+			u.config.TlsCertFilePath,
+			u.config.TlsKeyFilePath,
+		)
+	} else {
+		u.config.Logger.Info(
+			fmt.Sprintf(
+				"starting gRPC listener on %s:%d",
+				u.config.Host,
+				u.config.Port,
+			),
+		)
+		utxorpc := &http.Server{
+			Addr: fmt.Sprintf(
+				"%s:%d",
+				u.config.Host,
+				u.config.Port,
+			),
+			// Use h2c so we can serve HTTP/2 without TLS
+			Handler:           h2c.NewHandler(mux, &http2.Server{}),
+			ReadHeaderTimeout: 60 * time.Second,
+		}
+		return utxorpc.ListenAndServe()
+	}
+}

package/utxorpc/watch.go

@@ -0,0 +1,310 @@
+// 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"
+	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
+	cardano "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano"
+	watch "github.com/utxorpc/go-codegen/utxorpc/v1alpha/watch"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/watch/watchconnect"
+)
+
+// watchServiceServer implements the WatchService API
+type watchServiceServer struct {
+	watchconnect.UnimplementedWatchServiceHandler
+	utxorpc *Utxorpc
+}
+
+// WatchTx
+func (s *watchServiceServer) WatchTx(
+	ctx context.Context,
+	req *connect.Request[watch.WatchTxRequest],
+	stream *connect.ServerStream[watch.WatchTxResponse],
+) error {
+	predicate := req.Msg.GetPredicate() // Predicate
+	fieldMask := req.Msg.GetFieldMask()
+	intersect := req.Msg.GetIntersect() // []*BlockRef
+
+	s.utxorpc.config.Logger.Info(
+		fmt.Sprintf(
+			"Got a WatchTx request with predicate %v and fieldMask %v and intersect %v",
+			predicate,
+			fieldMask,
+			intersect,
+		),
+	)
+
+	// Get our points
+	var points []ocommon.Point
+	if len(intersect) > 0 {
+		for _, blockRef := range intersect {
+			blockIdx := blockRef.GetIndex()
+			blockHash := blockRef.GetHash()
+			slot := blockIdx
+			point := ocommon.NewPoint(slot, blockHash)
+			points = append(points, point)
+		}
+	} else {
+		point := s.utxorpc.config.LedgerState.Tip().Point
+		points = append(points, point)
+	}
+
+	// Get our starting point matching our chain
+	point, err := s.utxorpc.config.LedgerState.GetIntersectPoint(points)
+	if err != nil {
+		s.utxorpc.config.Logger.Error(
+			"failed to get points",
+			"error", err,
+		)
+		return err
+	}
+	if point == nil {
+		s.utxorpc.config.Logger.Error(
+			"nil point returned",
+		)
+		return errors.New("nil point returned")
+	}
+
+	// Create our chain iterator
+	chainIter, err := s.utxorpc.config.LedgerState.GetChainFromPoint(
+		*point,
+		false,
+	)
+	if err != nil {
+		s.utxorpc.config.Logger.Error(
+			"failed to get chain iterator",
+			"error", err,
+		)
+		return err
+	}
+
+	for {
+		// Check for available block
+		next, err := chainIter.Next(true)
+		if err != nil {
+			s.utxorpc.config.Logger.Error(
+				"failed to iterate chain",
+				"error", err,
+			)
+			return err
+		}
+		if next != nil {
+			// Get ledger.Block from bytes
+			blockBytes := next.Block.Cbor[:]
+			blockType, err := ledger.DetermineBlockType(blockBytes)
+			if err != nil {
+				s.utxorpc.config.Logger.Error(
+					"failed to get block type",
+					"error", err,
+				)
+				return err
+			}
+			block, err := ledger.NewBlockFromCbor(blockType, blockBytes)
+			if err != nil {
+				s.utxorpc.config.Logger.Error(
+					"failed to get block",
+					"error", err,
+				)
+				return err
+			}
+
+			// Loop through transactions
+			for _, tx := range block.Transactions() {
+				var act watch.AnyChainTx
+				actc := watch.AnyChainTx_Cardano{
+					Cardano: tx.Utxorpc(),
+				}
+				act.Chain = &actc
+				resp := &watch.WatchTxResponse{
+					Action: &watch.WatchTxResponse_Apply{
+						Apply: &act,
+					},
+				}
+				if predicate == nil {
+					err := stream.Send(resp)
+					if err != nil {
+						return err
+					}
+				} else {
+					found := false
+					assetFound := false
+
+					// Check Predicate
+					addressPattern := predicate.GetMatch().GetCardano().GetHasAddress()
+					mintAssetPattern := predicate.GetMatch().GetCardano().GetMintsAsset()
+					moveAssetPattern := predicate.GetMatch().GetCardano().GetMovesAsset()
+
+					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 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 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 fmt.Errorf(
+									"failed to decode delegation part: %w",
+									err,
+								)
+							}
+							addresses = append(addresses, delegationAddr)
+						}
+					}
+
+					var assetPatterns []*cardano.AssetPattern
+					if mintAssetPattern != nil {
+						assetPatterns = append(assetPatterns, mintAssetPattern)
+					}
+					if moveAssetPattern != nil {
+						assetPatterns = append(assetPatterns, moveAssetPattern)
+					}
+
+					// Convert everything to utxos (ledger.TransactionOutput) for matching
+					var utxos []ledger.TransactionOutput
+					utxos = append(tx.Outputs(), tx.CollateralReturn())
+					var inputs []ledger.TransactionInput
+					inputs = append(tx.Inputs(), tx.ReferenceInputs()...)
+					inputs = append(inputs, tx.Collateral()...)
+					for _, input := range inputs {
+						utxo, err := s.utxorpc.config.LedgerState.UtxoByRef(
+							input.Id().Bytes(),
+							input.Index(),
+						)
+						if err != nil {
+							return fmt.Errorf(
+								"failed to look up input: %w",
+								err,
+							)
+						}
+						ret, err := utxo.Decode() // ledger.TransactionOutput
+						if err != nil {
+							return err
+						}
+						if ret == nil {
+							return errors.New("decode returned empty utxo")
+						}
+						utxos = append(utxos, ret)
+					}
+
+					// Check UTxOs for addresses
+					for _, address := range addresses {
+						if found {
+							break
+						}
+						if assetFound {
+							found = true
+							break
+						}
+						for _, utxo := range utxos {
+							if found {
+								break
+							}
+							if assetFound {
+								found = true
+								break
+							}
+							if utxo.Address().String() == address.String() {
+								if found {
+									break
+								}
+								if assetFound {
+									found = true
+									break
+								}
+								// We matched address, check assetPatterns
+								for _, assetPattern := range assetPatterns {
+									// Address found, no assetPattern
+									if assetPattern == nil {
+										found = true
+										break
+									}
+									// Filter on assetPattern
+									for _, policyId := range utxo.Assets().Policies() {
+										if assetFound {
+											found = true
+											break
+										}
+										if bytes.Equal(
+											policyId.Bytes(),
+											assetPattern.GetPolicyId(),
+										) {
+											for _, asset := range utxo.Assets().Assets(policyId) {
+												if bytes.Equal(asset, assetPattern.GetAssetName()) {
+													found = true
+													assetFound = true
+													break
+												}
+											}
+										}
+									}
+								}
+								if found {
+									break
+								}
+								// Asset not found; skip this UTxO
+								if !assetFound {
+									continue
+								}
+								found = true
+							}
+						}
+					}
+					if found {
+						err := stream.Send(resp)
+						if err != nil {
+							return err
+						}
+					}
+				}
+			}
+		}
+	}
+}