@blinklabs/dingo 0.7.0 → 0.8.0

package/utxorpc/sync.go

@@ -1,276 +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 utxorpc
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"connectrpc.com/connect"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-	sync "github.com/utxorpc/go-codegen/utxorpc/v1alpha/sync"
-	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/sync/syncconnect"
-)
-
-// syncServiceServer implements the SyncService API
-type syncServiceServer struct {
-	syncconnect.UnimplementedSyncServiceHandler
-	utxorpc *Utxorpc
-}
-
-// FetchBlock
-func (s *syncServiceServer) FetchBlock(
-	ctx context.Context,
-	req *connect.Request[sync.FetchBlockRequest],
-) (*connect.Response[sync.FetchBlockResponse], error) {
-	ref := req.Msg.GetRef() // []*BlockRef
-	fieldMask := req.Msg.GetFieldMask()
-
-	s.utxorpc.config.Logger.Info(
-		fmt.Sprintf(
-			"Got a FetchBlock request with ref %v and fieldMask %v",
-			ref,
-			fieldMask,
-		),
-	)
-	resp := &sync.FetchBlockResponse{}
-
-	// Get our points
-	var points []ocommon.Point
-	if len(ref) > 0 {
-		for _, blockRef := range ref {
-			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)
-	}
-
-	for _, point := range points {
-		block, err := s.utxorpc.config.LedgerState.GetBlock(point)
-		if err != nil {
-			return nil, err
-		}
-		if block == nil {
-			return nil, errors.New("block returned nil")
-		}
-		var acb sync.AnyChainBlock
-		ret, err := block.Decode()
-		if err != nil {
-			return nil, err
-		}
-		acbc := sync.AnyChainBlock_Cardano{
-			Cardano: ret.Utxorpc(),
-		}
-		acb.Chain = &acbc
-		resp.Block = append(resp.Block, &acb)
-	}
-
-	return connect.NewResponse(resp), nil
-}
-
-// DumpHistory
-func (s *syncServiceServer) DumpHistory(
-	ctx context.Context,
-	req *connect.Request[sync.DumpHistoryRequest],
-) (*connect.Response[sync.DumpHistoryResponse], error) {
-	startToken := req.Msg.GetStartToken() // *BlockRef
-	maxItems := req.Msg.GetMaxItems()     // uint32
-	fieldMask := req.Msg.GetFieldMask()
-
-	s.utxorpc.config.Logger.Info(
-		fmt.Sprintf(
-			"Got a DumpHistory request with token %v and maxItems %d and fieldMask %v",
-			startToken,
-			maxItems,
-			fieldMask,
-		),
-	)
-	resp := &sync.DumpHistoryResponse{}
-
-	// Get our points
-	var points []ocommon.Point
-	if maxItems > 0 {
-		tmpPoints, err := s.utxorpc.config.LedgerState.RecentChainPoints(
-			int(maxItems),
-		)
-		if err != nil {
-			return nil, err
-		}
-		points = tmpPoints
-	} else {
-		point := s.utxorpc.config.LedgerState.Tip().Point
-		points = append(points, point)
-	}
-	// TODO: make this work (#401)
-	// if startToken != nil {
-	// 	blockIdx := startToken.GetIndex()
-	// 	blockHash := startToken.GetHash()
-	// 	slot := uint64(blockIdx)
-	// 	point = ocommon.NewPoint(slot, blockHash)
-	// }
-
-	for _, point := range points {
-		block, err := s.utxorpc.config.LedgerState.GetBlock(point)
-		if err != nil {
-			return nil, err
-		}
-		if block == nil {
-			return nil, errors.New("block returned nil")
-		}
-		var acb sync.AnyChainBlock
-		ret, err := block.Decode()
-		if err != nil {
-			return nil, err
-		}
-		acbc := sync.AnyChainBlock_Cardano{
-			Cardano: ret.Utxorpc(),
-		}
-		acb.Chain = &acbc
-		resp.Block = append(resp.Block, &acb)
-	}
-
-	return connect.NewResponse(resp), nil
-}
-
-// FollowTip
-func (s *syncServiceServer) FollowTip(
-	ctx context.Context,
-	req *connect.Request[sync.FollowTipRequest],
-	stream *connect.ServerStream[sync.FollowTipResponse],
-) error {
-	intersect := req.Msg.GetIntersect() // []*BlockRef
-
-	s.utxorpc.config.Logger.Info(
-		fmt.Sprintf(
-			"Got a FollowTip request with intersect %v",
-			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 {
-			// Send block response
-			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
-			}
-			var acb sync.AnyChainBlock
-			acbc := sync.AnyChainBlock_Cardano{
-				Cardano: block.Utxorpc(),
-			}
-			acb.Chain = &acbc
-			resp := &sync.FollowTipResponse{
-				Action: &sync.FollowTipResponse_Apply{
-					Apply: &acb,
-				},
-			}
-			err = stream.Send(resp)
-			if err != nil {
-				s.utxorpc.config.Logger.Error(
-					"failed to send message to client",
-					"error", err,
-				)
-				return err
-			}
-		}
-	}
-}
-
-// ReadTip
-func (s *syncServiceServer) ReadTip(
-	ctx context.Context,
-	req *connect.Request[sync.ReadTipRequest],
-) (*connect.Response[sync.ReadTipResponse], error) {
-	s.utxorpc.config.Logger.Info("Got a ReadTip request")
-	resp := &sync.ReadTipResponse{}
-
-	point := s.utxorpc.config.LedgerState.Tip().Point
-	resp.Tip = &sync.BlockRef{Index: point.Slot, Hash: point.Hash}
-
-	return connect.NewResponse(resp), nil
-}

package/utxorpc/utxorpc.go

@@ -1,166 +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 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()
-	}
-}