@blinklabs/dingo 0.7.0 → 0.8.0

package/node.go

@@ -1,320 +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 (
-	"context"
-	"errors"
-	"fmt"
-	"slices"
-
-	"github.com/blinklabs-io/dingo/chainsync"
-	"github.com/blinklabs-io/dingo/connmanager"
-	"github.com/blinklabs-io/dingo/event"
-	"github.com/blinklabs-io/dingo/ledger"
-	"github.com/blinklabs-io/dingo/mempool"
-	"github.com/blinklabs-io/dingo/peergov"
-	"github.com/blinklabs-io/dingo/utxorpc"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	oblockfetch "github.com/blinklabs-io/gouroboros/protocol/blockfetch"
-	ochainsync "github.com/blinklabs-io/gouroboros/protocol/chainsync"
-	olocalstatequery "github.com/blinklabs-io/gouroboros/protocol/localstatequery"
-	olocaltxmonitor "github.com/blinklabs-io/gouroboros/protocol/localtxmonitor"
-	olocaltxsubmission "github.com/blinklabs-io/gouroboros/protocol/localtxsubmission"
-	opeersharing "github.com/blinklabs-io/gouroboros/protocol/peersharing"
-	otxsubmission "github.com/blinklabs-io/gouroboros/protocol/txsubmission"
-)
-
-type Node struct {
-	config         Config
-	connManager    *connmanager.ConnectionManager
-	peerGov        *peergov.PeerGovernor
-	chainsyncState *chainsync.State
-	eventBus       *event.EventBus
-	mempool        *mempool.Mempool
-	ledgerState    *ledger.LedgerState
-	utxorpc        *utxorpc.Utxorpc
-	shutdownFuncs  []func(context.Context) error
-}
-
-func New(cfg Config) (*Node, error) {
-	eventBus := event.NewEventBus(cfg.promRegistry)
-	n := &Node{
-		config:   cfg,
-		eventBus: eventBus,
-	}
-	if err := n.configPopulateNetworkMagic(); err != nil {
-		return nil, fmt.Errorf("invalid configuration: %w", err)
-	}
-	if err := n.configValidate(); err != nil {
-		return nil, fmt.Errorf("invalid configuration: %w", err)
-	}
-	return n, nil
-}
-
-func (n *Node) Run() error {
-	// Configure tracing
-	if n.config.tracing {
-		if err := n.setupTracing(); err != nil {
-			return err
-		}
-	}
-	// Load state
-	state, err := ledger.NewLedgerState(
-		ledger.LedgerStateConfig{
-			DataDir:                    n.config.dataDir,
-			EventBus:                   n.eventBus,
-			Logger:                     n.config.logger,
-			CardanoNodeConfig:          n.config.cardanoNodeConfig,
-			PromRegistry:               n.config.promRegistry,
-			BlockfetchRequestRangeFunc: n.blockfetchClientRequestRange,
-		},
-	)
-	if err != nil {
-		return fmt.Errorf("failed to load state database: %w", err)
-	}
-	// Add shutdown cleanup for ledger/database
-	n.shutdownFuncs = append(
-		n.shutdownFuncs,
-		func(_ context.Context) error {
-			return state.Close()
-		},
-	)
-	n.ledgerState = state
-	// Initialize mempool
-	n.mempool = mempool.NewMempool(
-		n.config.logger,
-		n.eventBus,
-		n.config.promRegistry,
-		n.ledgerState,
-	)
-	// Initialize chainsync state
-	n.chainsyncState = chainsync.NewState(
-		n.eventBus,
-		n.ledgerState,
-	)
-	// Configure connection manager
-	if err := n.configureConnManager(); err != nil {
-		return err
-	}
-	// Configure peer governor
-	n.peerGov = peergov.NewPeerGovernor(
-		peergov.PeerGovernorConfig{
-			Logger:      n.config.logger,
-			EventBus:    n.eventBus,
-			ConnManager: n.connManager,
-		},
-	)
-	n.eventBus.SubscribeFunc(
-		peergov.OutboundConnectionEventType,
-		n.handleOutboundConnEvent,
-	)
-	if n.config.topologyConfig != nil {
-		n.peerGov.LoadTopologyConfig(n.config.topologyConfig)
-	}
-	if err := n.peerGov.Start(); err != nil {
-		return err
-	}
-	// Configure UTxO RPC
-	n.utxorpc = utxorpc.NewUtxorpc(
-		utxorpc.UtxorpcConfig{
-			Logger:      n.config.logger,
-			EventBus:    n.eventBus,
-			LedgerState: n.ledgerState,
-			Mempool:     n.mempool,
-			Port:        n.config.utxorpcPort,
-		},
-	)
-	if err := n.utxorpc.Start(); err != nil {
-		return err
-	}
-
-	// Wait forever
-	select {}
-}
-
-func (n *Node) Stop() error {
-	return n.shutdown()
-}
-
-func (n *Node) shutdown() error {
-	ctx := context.TODO()
-	var err error
-	// Shutdown ledger
-	err = errors.Join(err, n.ledgerState.Close())
-	// Call shutdown functions
-	for _, fn := range n.shutdownFuncs {
-		err = errors.Join(err, fn(ctx))
-	}
-	n.shutdownFuncs = nil
-	return err
-}
-
-func (n *Node) configureConnManager() error {
-	// Configure listeners
-	tmpListeners := make([]ListenerConfig, len(n.config.listeners))
-	for idx, l := range n.config.listeners {
-		if l.UseNtC {
-			// Node-to-client
-			l.ConnectionOpts = append(
-				l.ConnectionOpts,
-				ouroboros.WithNetworkMagic(n.config.networkMagic),
-				ouroboros.WithChainSyncConfig(
-					ochainsync.NewConfig(
-						n.chainsyncServerConnOpts()...,
-					),
-				),
-				ouroboros.WithLocalStateQueryConfig(
-					olocalstatequery.NewConfig(
-						n.localstatequeryServerConnOpts()...,
-					),
-				),
-				ouroboros.WithLocalTxMonitorConfig(
-					olocaltxmonitor.NewConfig(
-						n.localtxmonitorServerConnOpts()...,
-					),
-				),
-				ouroboros.WithLocalTxSubmissionConfig(
-					olocaltxsubmission.NewConfig(
-						n.localtxsubmissionServerConnOpts()...,
-					),
-				),
-			)
-		} else {
-			// Node-to-node config
-			l.ConnectionOpts = append(
-				l.ConnectionOpts,
-				ouroboros.WithPeerSharing(n.config.peerSharing),
-				ouroboros.WithNetworkMagic(n.config.networkMagic),
-				ouroboros.WithPeerSharingConfig(
-					opeersharing.NewConfig(
-						n.peersharingServerConnOpts()...,
-					),
-				),
-				ouroboros.WithTxSubmissionConfig(
-					otxsubmission.NewConfig(
-						n.txsubmissionServerConnOpts()...,
-					),
-				),
-				ouroboros.WithChainSyncConfig(
-					ochainsync.NewConfig(
-						n.chainsyncServerConnOpts()...,
-					),
-				),
-				ouroboros.WithBlockFetchConfig(
-					oblockfetch.NewConfig(
-						n.blockfetchServerConnOpts()...,
-					),
-				),
-			)
-		}
-		tmpListeners[idx] = l
-	}
-	// Create connection manager
-	n.connManager = connmanager.NewConnectionManager(
-		connmanager.ConnectionManagerConfig{
-			Logger:             n.config.logger,
-			EventBus:           n.eventBus,
-			Listeners:          tmpListeners,
-			OutboundSourcePort: n.config.outboundSourcePort,
-			OutboundConnOpts: []ouroboros.ConnectionOptionFunc{
-				ouroboros.WithNetworkMagic(n.config.networkMagic),
-				ouroboros.WithNodeToNode(true),
-				ouroboros.WithKeepAlive(true),
-				ouroboros.WithFullDuplex(true),
-				ouroboros.WithPeerSharing(n.config.peerSharing),
-				ouroboros.WithPeerSharingConfig(
-					opeersharing.NewConfig(
-						slices.Concat(
-							n.peersharingClientConnOpts(),
-							n.peersharingServerConnOpts(),
-						)...,
-					),
-				),
-				ouroboros.WithTxSubmissionConfig(
-					otxsubmission.NewConfig(
-						slices.Concat(
-							n.txsubmissionClientConnOpts(),
-							n.txsubmissionServerConnOpts(),
-						)...,
-					),
-				),
-				ouroboros.WithChainSyncConfig(
-					ochainsync.NewConfig(
-						slices.Concat(
-							n.chainsyncClientConnOpts(),
-							n.chainsyncServerConnOpts(),
-						)...,
-					),
-				),
-				ouroboros.WithBlockFetchConfig(
-					oblockfetch.NewConfig(
-						slices.Concat(
-							n.blockfetchClientConnOpts(),
-							n.blockfetchServerConnOpts(),
-						)...,
-					),
-				),
-			},
-		},
-	)
-	// Subscribe to connection closed events
-	n.eventBus.SubscribeFunc(
-		connmanager.ConnectionClosedEventType,
-		n.handleConnClosedEvent,
-	)
-	// Start listeners
-	if err := n.connManager.Start(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (n *Node) handleConnClosedEvent(evt event.Event) {
-	e := evt.Data.(connmanager.ConnectionClosedEvent)
-	connId := e.ConnectionId
-	// Remove any chainsync client state
-	n.chainsyncState.RemoveClient(connId)
-	// Remove mempool consumer
-	n.mempool.RemoveConsumer(connId)
-	// Release chainsync client
-	n.chainsyncState.RemoveClientConnId(connId)
-}
-
-func (n *Node) handleOutboundConnEvent(evt event.Event) {
-	e := evt.Data.(peergov.OutboundConnectionEvent)
-	connId := e.ConnectionId
-	// TODO: replace this with handling for multiple chainsync clients (#385)
-	// Start chainsync client if we don't have another
-	n.chainsyncState.Lock()
-	defer n.chainsyncState.Unlock()
-	chainsyncClientConnId := n.chainsyncState.GetClientConnId()
-	if chainsyncClientConnId == nil {
-		if err := n.chainsyncClientStart(connId); err != nil {
-			n.config.logger.Error(
-				"failed to start chainsync client",
-				"error",
-				err,
-			)
-			return
-		}
-		n.chainsyncState.SetClientConnId(connId)
-	}
-	// Start txsubmission client
-	if err := n.txsubmissionClientStart(connId); err != nil {
-		n.config.logger.Error("failed to start chainsync client", "error", err)
-		return
-	}
-}

package/peergov/event.go

@@ -1,27 +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 peergov
-
-import (
-	ouroboros "github.com/blinklabs-io/gouroboros"
-)
-
-const (
-	OutboundConnectionEventType = "peergov.outbound-conn"
-)
-
-type OutboundConnectionEvent struct {
-	ConnectionId ouroboros.ConnectionId
-}

package/peergov/peer.go

@@ -1,67 +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 peergov
-
-import (
-	"time"
-
-	ouroboros "github.com/blinklabs-io/gouroboros"
-	oprotocol "github.com/blinklabs-io/gouroboros/protocol"
-)
-
-type PeerSource uint16
-
-const (
-	PeerSourceUnknown               = 0
-	PeerSourceTopologyLocalRoot     = 1
-	PeerSourceTopologyPublicRoot    = 2
-	PeerSourceTopologyBootstrapPeer = 3
-	PeerSourceP2PLedger             = 4
-	PeerSourceP2PGossip             = 5
-	PeerSourceInboundConn           = 6
-)
-
-type Peer struct {
-	Address        string
-	Source         PeerSource
-	Connection     *PeerConnection
-	Sharable       bool
-	ReconnectCount int
-	ReconnectDelay time.Duration
-}
-
-func (p *Peer) setConnection(conn *ouroboros.Connection, outbound bool) {
-	connId := conn.Id()
-	protoVersion, versionData := conn.ProtocolVersion()
-	p.Connection = &PeerConnection{
-		Id:              connId,
-		ProtocolVersion: uint(protoVersion),
-		VersionData:     versionData,
-	}
-	// Determine whether connection can be used as a client
-	// This should be true for any outbound connections and any inbound
-	// connections in full-duplex mode
-	if outbound ||
-		versionData.DiffusionMode() == oprotocol.DiffusionModeInitiatorAndResponder {
-		p.Connection.IsClient = true
-	}
-}
-
-type PeerConnection struct {
-	Id              ouroboros.ConnectionId
-	ProtocolVersion uint
-	VersionData     oprotocol.VersionData
-	IsClient        bool
-}

package/peergov/peergov.go

@@ -1,290 +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 peergov
-
-import (
-	"fmt"
-	"io"
-	"log/slog"
-	"net"
-	"strconv"
-	"sync"
-	"time"
-
-	"github.com/blinklabs-io/dingo/connmanager"
-	"github.com/blinklabs-io/dingo/event"
-	"github.com/blinklabs-io/dingo/topology"
-	ouroboros "github.com/blinklabs-io/gouroboros"
-)
-
-const (
-	initialReconnectDelay  = 1 * time.Second
-	maxReconnectDelay      = 128 * time.Second
-	reconnectBackoffFactor = 2
-)
-
-type PeerGovernor struct {
-	mu     sync.Mutex
-	config PeerGovernorConfig
-	peers  []*Peer
-}
-
-type PeerGovernorConfig struct {
-	Logger      *slog.Logger
-	EventBus    *event.EventBus
-	ConnManager *connmanager.ConnectionManager
-}
-
-func NewPeerGovernor(cfg PeerGovernorConfig) *PeerGovernor {
-	if cfg.Logger == nil {
-		cfg.Logger = slog.New(slog.NewJSONHandler(io.Discard, nil))
-	}
-	cfg.Logger = cfg.Logger.With("component", "peergov")
-	return &PeerGovernor{
-		config: cfg,
-	}
-}
-
-func (p *PeerGovernor) Start() error {
-	// Setup connmanager event listeners
-	p.config.EventBus.SubscribeFunc(
-		connmanager.InboundConnectionEventType,
-		p.handleInboundConnectionEvent,
-	)
-	p.config.EventBus.SubscribeFunc(
-		connmanager.ConnectionClosedEventType,
-		p.handleConnectionClosedEvent,
-	)
-	// Start outbound connections
-	p.startOutboundConnections()
-	return nil
-}
-
-func (p *PeerGovernor) LoadTopologyConfig(
-	topologyConfig *topology.TopologyConfig,
-) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	// Remove peers originally sourced from the topology
-	tmpPeers := []*Peer{}
-	for _, tmpPeer := range p.peers {
-		if tmpPeer.Source == PeerSourceTopologyBootstrapPeer ||
-			tmpPeer.Source == PeerSourceTopologyLocalRoot ||
-			tmpPeer.Source == PeerSourceTopologyPublicRoot {
-			continue
-		}
-		tmpPeers = append(tmpPeers, tmpPeer)
-	}
-	p.peers = tmpPeers
-	// Add topology bootstrap peers
-	for _, bootstrapPeer := range topologyConfig.BootstrapPeers {
-		tmpAddress := net.JoinHostPort(
-			bootstrapPeer.Address,
-			strconv.FormatUint(uint64(bootstrapPeer.Port), 10),
-		)
-		p.peers = append(
-			p.peers,
-			&Peer{
-				Address: tmpAddress,
-				Source:  PeerSourceTopologyBootstrapPeer,
-			},
-		)
-	}
-	// Add topology local roots
-	for _, localRoot := range topologyConfig.LocalRoots {
-		for _, ap := range localRoot.AccessPoints {
-			tmpAddress := net.JoinHostPort(
-				ap.Address,
-				strconv.FormatUint(uint64(ap.Port), 10),
-			)
-			tmpPeer := &Peer{
-				Address:  tmpAddress,
-				Source:   PeerSourceTopologyLocalRoot,
-				Sharable: localRoot.Advertise,
-			}
-			for i, peer := range p.peers {
-				// This peer already appears, remove it
-				if peer.Address == tmpAddress {
-					copy(p.peers[i:], p.peers[i+1:])   // shift left
-					p.peers[len(p.peers)-1] = nil      // clear last
-					p.peers = p.peers[:len(p.peers)-1] // truncate
-				}
-			}
-			p.peers = append(p.peers, tmpPeer)
-		}
-	}
-	// Add topology public roots
-	for _, publicRoot := range topologyConfig.PublicRoots {
-		for _, ap := range publicRoot.AccessPoints {
-			tmpAddress := net.JoinHostPort(
-				ap.Address,
-				strconv.FormatUint(uint64(ap.Port), 10),
-			)
-			tmpPeer := &Peer{
-				Address:  tmpAddress,
-				Source:   PeerSourceTopologyPublicRoot,
-				Sharable: publicRoot.Advertise,
-			}
-			for i, peer := range p.peers {
-				// This peer already appears, remove it
-				if peer.Address == tmpAddress {
-					copy(p.peers[i:], p.peers[i+1:])   // shift left
-					p.peers[len(p.peers)-1] = nil      // clear last
-					p.peers = p.peers[:len(p.peers)-1] // truncate
-				}
-			}
-			p.peers = append(p.peers, tmpPeer)
-		}
-	}
-}
-
-func (p *PeerGovernor) GetPeers() []Peer {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	ret := make([]Peer, len(p.peers))
-	for idx, peer := range p.peers {
-		ret[idx] = *peer
-	}
-	return ret
-}
-
-func (p *PeerGovernor) peerIndexByAddress(address string) int {
-	for idx, tmpPeer := range p.peers {
-		if tmpPeer.Address == address {
-			return idx
-		}
-	}
-	return -1
-}
-
-func (p *PeerGovernor) peerIndexByConnId(connId ouroboros.ConnectionId) int {
-	for idx, tmpPeer := range p.peers {
-		if tmpPeer.Connection == nil {
-			continue
-		}
-		if tmpPeer.Connection.Id == connId {
-			return idx
-		}
-	}
-	return -1
-}
-
-func (p *PeerGovernor) startOutboundConnections() {
-	p.config.Logger.Debug(
-		"starting connections",
-		"role", "client",
-	)
-	for _, tmpPeer := range p.peers {
-		go p.createOutboundConnection(tmpPeer)
-	}
-}
-
-func (p *PeerGovernor) createOutboundConnection(peer *Peer) {
-	for {
-		conn, err := p.config.ConnManager.CreateOutboundConn(peer.Address)
-		if err == nil {
-			connId := conn.Id()
-			peer.ReconnectCount = 0
-			peer.setConnection(conn, true)
-			// Generate event
-			if p.config.EventBus != nil {
-				p.config.EventBus.Publish(
-					OutboundConnectionEventType,
-					event.NewEvent(
-						OutboundConnectionEventType,
-						OutboundConnectionEvent{
-							ConnectionId: connId,
-						},
-					),
-				)
-			}
-			return
-		}
-		p.config.Logger.Error(
-			fmt.Sprintf(
-				"outbound: failed to establish connection to %s: %s",
-				peer.Address,
-				err,
-			),
-		)
-		if peer.ReconnectDelay == 0 {
-			peer.ReconnectDelay = initialReconnectDelay
-		} else if peer.ReconnectDelay < maxReconnectDelay {
-			peer.ReconnectDelay = peer.ReconnectDelay * reconnectBackoffFactor
-		}
-		peer.ReconnectCount += 1
-		p.config.Logger.Info(
-			fmt.Sprintf(
-				"outbound: delaying %s (retry %d) before reconnecting to %s",
-				peer.ReconnectDelay,
-				peer.ReconnectCount,
-				peer.Address,
-			),
-		)
-		time.Sleep(peer.ReconnectDelay)
-	}
-}
-
-func (p *PeerGovernor) handleInboundConnectionEvent(evt event.Event) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	e := evt.Data.(connmanager.InboundConnectionEvent)
-	var tmpPeer *Peer
-	peerIdx := p.peerIndexByAddress(e.RemoteAddr.String())
-	if peerIdx == -1 {
-		tmpPeer = &Peer{
-			Address: e.RemoteAddr.String(),
-			Source:  PeerSourceInboundConn,
-		}
-		// Add inbound peer
-		p.peers = append(
-			p.peers,
-			tmpPeer,
-		)
-	} else {
-		tmpPeer = p.peers[peerIdx]
-	}
-	conn := p.config.ConnManager.GetConnectionById(e.ConnectionId)
-	tmpPeer.setConnection(conn, false)
-	if tmpPeer.Connection != nil {
-		tmpPeer.Sharable = tmpPeer.Connection.VersionData.PeerSharing()
-	}
-}
-
-func (p *PeerGovernor) handleConnectionClosedEvent(evt event.Event) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	e := evt.Data.(connmanager.ConnectionClosedEvent)
-	if e.Error != nil {
-		p.config.Logger.Error(
-			fmt.Sprintf(
-				"unexpected connection failure: %s",
-				e.Error,
-			),
-			"connection_id", e.ConnectionId.String(),
-		)
-	} else {
-		p.config.Logger.Info("connection closed",
-			"connection_id", e.ConnectionId.String(),
-		)
-	}
-	peerIdx := p.peerIndexByConnId(e.ConnectionId)
-	if peerIdx != -1 {
-		p.peers[peerIdx].Connection = nil
-		if p.peers[peerIdx].Source != PeerSourceInboundConn {
-			go p.createOutboundConnection(p.peers[peerIdx])
-		}
-	}
-}