@blinklabs/dingo 0.7.0 → 0.8.1

package/chainsync/chainsync.go

@@ -1,97 +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 chainsync
-
-import (
-	"sync"
-
-	"github.com/blinklabs-io/dingo/chain"
-	"github.com/blinklabs-io/dingo/event"
-	"github.com/blinklabs-io/dingo/ledger"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	"github.com/blinklabs-io/gouroboros/connection"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-)
-
-type ChainsyncClientState struct {
-	Cursor               ocommon.Point
-	ChainIter            *chain.ChainIterator
-	NeedsInitialRollback bool
-}
-
-type State struct {
-	sync.Mutex
-	eventBus     *event.EventBus
-	ledgerState  *ledger.LedgerState
-	clients      map[ouroboros.ConnectionId]*ChainsyncClientState
-	clientConnId *ouroboros.ConnectionId // TODO: replace with handling of multiple chainsync clients (#385)
-}
-
-func NewState(
-	eventBus *event.EventBus,
-	ledgerState *ledger.LedgerState,
-) *State {
-	s := &State{
-		eventBus:    eventBus,
-		ledgerState: ledgerState,
-		clients:     make(map[ouroboros.ConnectionId]*ChainsyncClientState),
-	}
-	return s
-}
-
-func (s *State) AddClient(
-	connId connection.ConnectionId,
-	intersectPoint ocommon.Point,
-) (*ChainsyncClientState, error) {
-	s.Lock()
-	defer s.Unlock()
-	// Create initial chainsync state for connection
-	chainIter, err := s.ledgerState.GetChainFromPoint(intersectPoint, false)
-	if err != nil {
-		return nil, err
-	}
-	if _, ok := s.clients[connId]; !ok {
-		s.clients[connId] = &ChainsyncClientState{
-			Cursor:               intersectPoint,
-			ChainIter:            chainIter,
-			NeedsInitialRollback: true,
-		}
-	}
-	return s.clients[connId], nil
-}
-
-func (s *State) RemoveClient(connId connection.ConnectionId) {
-	s.Lock()
-	defer s.Unlock()
-	// Remove client state entry
-	delete(s.clients, connId)
-}
-
-// TODO: replace with handling of multiple chainsync clients (#385)
-func (s *State) GetClientConnId() *ouroboros.ConnectionId {
-	return s.clientConnId
-}
-
-// TODO: replace with handling of multiple chainsync clients (#385)
-func (s *State) SetClientConnId(connId ouroboros.ConnectionId) {
-	s.clientConnId = &connId
-}
-
-// TODO: replace with handling of multiple chainsync clients (#385)
-func (s *State) RemoveClientConnId(connId ouroboros.ConnectionId) {
-	if s.clientConnId != nil && *s.clientConnId == connId {
-		s.clientConnId = nil
-	}
-}

package/chainsync.go

@@ -1,223 +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 dingo
-
-import (
-	"fmt"
-
-	"github.com/blinklabs-io/dingo/event"
-	"github.com/blinklabs-io/dingo/ledger"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	gledger "github.com/blinklabs-io/gouroboros/ledger"
-	ochainsync "github.com/blinklabs-io/gouroboros/protocol/chainsync"
-	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
-)
-
-const (
-	chainsyncIntersectPointCount = 100
-)
-
-func (n *Node) chainsyncServerConnOpts() []ochainsync.ChainSyncOptionFunc {
-	return []ochainsync.ChainSyncOptionFunc{
-		ochainsync.WithFindIntersectFunc(n.chainsyncServerFindIntersect),
-		ochainsync.WithRequestNextFunc(n.chainsyncServerRequestNext),
-	}
-}
-
-func (n *Node) chainsyncClientConnOpts() []ochainsync.ChainSyncOptionFunc {
-	return []ochainsync.ChainSyncOptionFunc{
-		ochainsync.WithRollForwardFunc(n.chainsyncClientRollForward),
-		ochainsync.WithRollBackwardFunc(n.chainsyncClientRollBackward),
-		// Enable pipelining of RequestNext messages to speed up chainsync
-		ochainsync.WithPipelineLimit(50),
-		// Set the recv queue size to 2x our pipeline limit
-		ochainsync.WithRecvQueueSize(100),
-	}
-}
-
-func (n *Node) chainsyncClientStart(connId ouroboros.ConnectionId) error {
-	conn := n.connManager.GetConnectionById(connId)
-	if conn == nil {
-		return fmt.Errorf("failed to lookup connection ID: %s", connId.String())
-	}
-	intersectPoints, err := n.ledgerState.RecentChainPoints(
-		chainsyncIntersectPointCount,
-	)
-	if err != nil {
-		return err
-	}
-	// Determine start point if we have no stored chain points
-	if len(intersectPoints) == 0 {
-		if n.config.intersectTip {
-			// Start initial chainsync from current chain tip
-			tip, err := conn.ChainSync().Client.GetCurrentTip()
-			if err != nil {
-				return err
-			}
-			intersectPoints = append(
-				intersectPoints,
-				tip.Point,
-			)
-			return conn.ChainSync().Client.Sync(intersectPoints)
-		} else if len(n.config.intersectPoints) > 0 {
-			// Start initial chainsync at specific point(s)
-			intersectPoints = append(
-				intersectPoints,
-				n.config.intersectPoints...,
-			)
-		}
-	}
-	return conn.ChainSync().Client.Sync(intersectPoints)
-}
-
-func (n *Node) chainsyncServerFindIntersect(
-	ctx ochainsync.CallbackContext,
-	points []ocommon.Point,
-) (ocommon.Point, ochainsync.Tip, error) {
-	n.ledgerState.RLock()
-	defer n.ledgerState.RUnlock()
-	var retPoint ocommon.Point
-	var retTip ochainsync.Tip
-	// Find intersection
-	intersectPoint, err := n.ledgerState.GetIntersectPoint(points)
-	if err != nil {
-		return retPoint, retTip, err
-	}
-
-	// Populate return tip
-	retTip = n.ledgerState.Tip()
-
-	if intersectPoint == nil {
-		return retPoint, retTip, ochainsync.ErrIntersectNotFound
-	}
-
-	// Add our client to the chainsync state
-	_, err = n.chainsyncState.AddClient(
-		ctx.ConnectionId,
-		*intersectPoint,
-	)
-	if err != nil {
-		return retPoint, retTip, err
-	}
-
-	// Populate return point
-	retPoint = *intersectPoint
-
-	return retPoint, retTip, nil
-}
-
-func (n *Node) chainsyncServerRequestNext(
-	ctx ochainsync.CallbackContext,
-) error {
-	// Create/retrieve chainsync state for connection
-	tip := n.ledgerState.Tip()
-	clientState, err := n.chainsyncState.AddClient(
-		ctx.ConnectionId,
-		tip.Point,
-	)
-	if err != nil {
-		return err
-	}
-	if clientState.NeedsInitialRollback {
-		err := ctx.Server.RollBackward(
-			clientState.Cursor,
-			tip,
-		)
-		if err != nil {
-			return err
-		}
-		clientState.NeedsInitialRollback = false
-		return nil
-	}
-	// Check for available block
-	next, err := clientState.ChainIter.Next(false)
-	if err != nil {
-		return err
-	}
-	if next != nil {
-		return ctx.Server.RollForward(
-			next.Block.Type,
-			next.Block.Cbor,
-			tip,
-		)
-	}
-	// Send AwaitReply
-	if err := ctx.Server.AwaitReply(); err != nil {
-		return err
-	}
-	// Wait for next block and send
-	go func() {
-		next, _ := clientState.ChainIter.Next(true)
-		if next == nil {
-			return
-		}
-		tip := n.ledgerState.Tip()
-		_ = ctx.Server.RollForward(
-			next.Block.Type,
-			next.Block.Cbor,
-			tip,
-		)
-	}()
-	return nil
-}
-
-func (n *Node) chainsyncClientRollBackward(
-	ctx ochainsync.CallbackContext,
-	point ocommon.Point,
-	tip ochainsync.Tip,
-) error {
-	// Generate event
-	n.eventBus.Publish(
-		ledger.ChainsyncEventType,
-		event.NewEvent(
-			ledger.ChainsyncEventType,
-			ledger.ChainsyncEvent{
-				Rollback: true,
-				Point:    point,
-				Tip:      tip,
-			},
-		),
-	)
-	return nil
-}
-
-func (n *Node) chainsyncClientRollForward(
-	ctx ochainsync.CallbackContext,
-	blockType uint,
-	blockData interface{},
-	tip ochainsync.Tip,
-) error {
-	switch v := blockData.(type) {
-	case gledger.BlockHeader:
-		blockSlot := v.SlotNumber()
-		blockHash := v.Hash().Bytes()
-		n.eventBus.Publish(
-			ledger.ChainsyncEventType,
-			event.NewEvent(
-				ledger.ChainsyncEventType,
-				ledger.ChainsyncEvent{
-					ConnectionId: ctx.ConnectionId,
-					Point:        ocommon.NewPoint(blockSlot, blockHash),
-					Type:         blockType,
-					BlockHeader:  v,
-					Tip:          tip,
-				},
-			),
-		)
-	default:
-		return fmt.Errorf("unexpected block data type: %T", v)
-	}
-	return nil
-}

package/cmd/dingo/load.go

@@ -1,52 +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 main
-
-import (
-	"log/slog"
-	"os"
-
-	"github.com/blinklabs-io/dingo/internal/config"
-	"github.com/blinklabs-io/dingo/internal/node"
-	"github.com/spf13/cobra"
-)
-
-func loadRun(_ *cobra.Command, args []string, cfg *config.Config) {
-	if len(args) != 1 {
-		slog.Error("you must provide the path to an ImmutableDB")
-		os.Exit(1)
-	}
-	logger := commonRun()
-	if err := node.Load(cfg, logger, args[0]); err != nil {
-		slog.Error(err.Error())
-		os.Exit(1)
-	}
-}
-
-func loadCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "load db-path",
-		Short: "Load blocks from ImmutableDB",
-		Run: func(cmd *cobra.Command, args []string) {
-			cfg := config.FromContext(cmd.Context())
-			if cfg == nil {
-				slog.Error("no config found in context")
-				os.Exit(1)
-			}
-			loadRun(cmd, args, cfg)
-		},
-	}
-	return cmd
-}

package/cmd/dingo/main.go

@@ -1,118 +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 main
-
-import (
-	"fmt"
-	"log/slog"
-	"os"
-
-	"github.com/blinklabs-io/dingo/internal/config"
-	"github.com/blinklabs-io/dingo/internal/version"
-	"github.com/spf13/cobra"
-	"go.uber.org/automaxprocs/maxprocs"
-)
-
-const (
-	programName = "dingo"
-)
-
-func slogPrintf(format string, v ...any) {
-	slog.Info(fmt.Sprintf(format, v...),
-		"component", programName,
-	)
-}
-
-var (
-	globalFlags = struct {
-		version bool
-		debug   bool
-	}{}
-	configFile string
-)
-
-func commonRun() *slog.Logger {
-	if globalFlags.version {
-		fmt.Printf("%s %s\n", programName, version.GetVersionString())
-		os.Exit(0)
-	}
-	// Configure logger
-	logLevel := slog.LevelInfo
-	addSource := false
-	if globalFlags.debug {
-		logLevel = slog.LevelDebug
-		// addSource = true
-	}
-	logger := slog.New(
-		slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-			AddSource: addSource,
-			Level:     logLevel,
-		}),
-	)
-	slog.SetDefault(logger)
-	// Configure max processes with our logger wrapper, toss undo func
-	_, err := maxprocs.Set(maxprocs.Logger(slogPrintf))
-	if err != nil {
-		// If we hit this, something really wrong happened
-		slog.Error(err.Error())
-		os.Exit(1)
-	}
-	logger.Info(
-		"version: "+version.GetVersionString(),
-		"component", programName,
-	)
-	return logger
-}
-
-func main() {
-	rootCmd := &cobra.Command{
-		Use: programName,
-		Run: func(cmd *cobra.Command, args []string) {
-			cfg := config.FromContext(cmd.Context())
-			if cfg == nil {
-				slog.Error("no config found in context")
-				os.Exit(1)
-			}
-			serveRun(cmd, args, cfg)
-		},
-	}
-
-	// Global flags
-	rootCmd.PersistentFlags().
-		BoolVarP(&globalFlags.debug, "debug", "D", false, "enable debug logging")
-	rootCmd.PersistentFlags().
-		BoolVarP(&globalFlags.version, "version", "", false, "show version and exit")
-	rootCmd.PersistentFlags().
-		StringVar(&configFile, "config", "", "path to config file")
-
-	rootCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
-		cfg, err := config.LoadConfig(configFile)
-		if err != nil {
-			return fmt.Errorf("failed to load config: %w", err)
-		}
-		cmd.SetContext(config.WithContext(cmd.Context(), cfg))
-		return nil
-	}
-
-	// Subcommands
-	rootCmd.AddCommand(serveCommand())
-	rootCmd.AddCommand(loadCommand())
-
-	// Execute cobra command
-	if err := rootCmd.Execute(); err != nil {
-		// NOTE: we purposely don't display the error, since cobra will have already displayed it
-		os.Exit(1)
-	}
-}

package/cmd/dingo/serve.go

@@ -1,49 +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 main
-
-import (
-	"log/slog"
-	"os"
-
-	"github.com/blinklabs-io/dingo/internal/config"
-	"github.com/blinklabs-io/dingo/internal/node"
-	"github.com/spf13/cobra"
-)
-
-func serveRun(_ *cobra.Command, _ []string, cfg *config.Config) {
-	logger := commonRun()
-	// Run node
-	if err := node.Run(cfg, logger); err != nil {
-		slog.Error(err.Error())
-		os.Exit(1)
-	}
-}
-
-func serveCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "serve",
-		Short: "Run as a node",
-		Run: func(cmd *cobra.Command, args []string) {
-			cfg := config.FromContext(cmd.Context())
-			if cfg == nil {
-				slog.Error("no config found in context")
-				os.Exit(1)
-			}
-			serveRun(cmd, args, cfg)
-		},
-	}
-	return cmd
-}