@blinklabs/dingo 0.7.0 → 0.8.0

package/peersharing.go

@@ -1,70 +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 dingo
-
-import (
-	"net"
-	"strconv"
-
-	opeersharing "github.com/blinklabs-io/gouroboros/protocol/peersharing"
-)
-
-func (n *Node) peersharingServerConnOpts() []opeersharing.PeerSharingOptionFunc {
-	return []opeersharing.PeerSharingOptionFunc{
-		opeersharing.WithShareRequestFunc(n.peersharingShareRequest),
-	}
-}
-
-func (n *Node) peersharingClientConnOpts() []opeersharing.PeerSharingOptionFunc {
-	// We don't provide any client options, but we have this here for consistency
-	return []opeersharing.PeerSharingOptionFunc{}
-}
-
-func (n *Node) peersharingShareRequest(
-	ctx opeersharing.CallbackContext,
-	amount int,
-) ([]opeersharing.PeerAddress, error) {
-	peers := []opeersharing.PeerAddress{}
-	var cnt int
-	for _, peer := range n.peerGov.GetPeers() {
-		cnt++
-		if cnt > amount {
-			break
-		}
-		if peer.Sharable {
-			host, port, err := net.SplitHostPort(peer.Address)
-			if err != nil {
-				// Skip on error
-				n.config.logger.Debug("failed to split peer address, skipping")
-				continue
-			}
-			portNum, err := strconv.ParseUint(port, 10, 16)
-			if err != nil {
-				// Skip on error
-				n.config.logger.Debug("failed to parse peer port, skipping")
-				continue
-			}
-			n.config.logger.Debug(
-				"adding peer for sharing: " + peer.Address,
-			)
-			peers = append(peers, opeersharing.PeerAddress{
-				IP:   net.ParseIP(host),
-				Port: uint16(portNum),
-			},
-			)
-		}
-	}
-	return peers, nil
-}

package/preview-local-topology.json

@@ -1,23 +0,0 @@
-{
-  "bootstrapPeers": [
-    {
-      "address": "192.168.4.56",
-      "port": 3001
-    }
-  ],
-  "localRoots": [
-    {
-      "accessPoints": [],
-      "advertise": false,
-      "trustable": false,
-      "valency": 1
-    }
-  ],
-  "publicRoots": [
-    {
-      "accessPoints": [],
-      "advertise": false
-    }
-  ],
-  "useLedgerAfterSlot": 53827185
-}

package/topology/topology.go

@@ -1,69 +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 topology
-
-import (
-	"encoding/json"
-	"io"
-	"os"
-)
-
-// TopologyConfig represents a cardano-node topology config
-type TopologyConfig struct {
-	LocalRoots         []TopologyConfigP2PLocalRoot     `json:"localRoots"`
-	PublicRoots        []TopologyConfigP2PPublicRoot    `json:"publicRoots"`
-	BootstrapPeers     []TopologyConfigP2PBootstrapPeer `json:"bootstrapPeers"`
-	UseLedgerAfterSlot int64                            `json:"useLedgerAfterSlot"`
-}
-
-type TopologyConfigP2PAccessPoint struct {
-	Address string `json:"address"`
-	Port    uint   `json:"port"`
-}
-
-type TopologyConfigP2PLocalRoot struct {
-	AccessPoints []TopologyConfigP2PAccessPoint `json:"accessPoints"`
-	Advertise    bool                           `json:"advertise"`
-	Trustable    bool                           `json:"trustable"`
-	Valency      uint                           `json:"valency"`
-}
-
-type TopologyConfigP2PPublicRoot struct {
-	AccessPoints []TopologyConfigP2PAccessPoint `json:"accessPoints"`
-	Advertise    bool                           `json:"advertise"`
-	Valency      uint                           `json:"valency"`
-}
-
-type TopologyConfigP2PBootstrapPeer = TopologyConfigP2PAccessPoint
-
-func NewTopologyConfigFromFile(path string) (*TopologyConfig, error) {
-	dataFile, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	return NewTopologyConfigFromReader(dataFile)
-}
-
-func NewTopologyConfigFromReader(r io.Reader) (*TopologyConfig, error) {
-	t := &TopologyConfig{}
-	data, err := io.ReadAll(r)
-	if err != nil {
-		return nil, err
-	}
-	if err := json.Unmarshal(data, t); err != nil {
-		return nil, err
-	}
-	return t, nil
-}

package/topology/topology_test.go

@@ -1,179 +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 topology_test
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/blinklabs-io/dingo/topology"
-)
-
-type topologyTestDefinition struct {
-	jsonData       string
-	expectedObject *topology.TopologyConfig
-}
-
-var topologyTests = []topologyTestDefinition{
-	{
-		jsonData: `
-{
-  "localRoots": [
-    {
-      "accessPoints": [],
-      "advertise": false,
-      "valency": 1
-    }
-  ],
-  "publicRoots": [
-    {
-      "accessPoints": [
-        {
-          "address": "backbone.cardano.iog.io",
-          "port": 3001
-        }
-      ],
-      "advertise": false
-    },
-    {
-      "accessPoints": [
-        {
-          "address": "backbone.mainnet.emurgornd.com",
-          "port": 3001
-        }
-      ],
-      "advertise": false
-    }
-  ],
-  "useLedgerAfterSlot": 99532743
-}
-`,
-		expectedObject: &topology.TopologyConfig{
-			LocalRoots: []topology.TopologyConfigP2PLocalRoot{
-				{
-					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
-					Advertise:    false,
-					Valency:      1,
-				},
-			},
-			PublicRoots: []topology.TopologyConfigP2PPublicRoot{
-				{
-					AccessPoints: []topology.TopologyConfigP2PAccessPoint{
-						{
-							Address: "backbone.cardano.iog.io",
-							Port:    3001,
-						},
-					},
-					Advertise: false,
-				},
-				{
-					AccessPoints: []topology.TopologyConfigP2PAccessPoint{
-						{
-							Address: "backbone.mainnet.emurgornd.com",
-							Port:    3001,
-						},
-					},
-					Advertise: false,
-				},
-			},
-			UseLedgerAfterSlot: 99532743,
-		},
-	},
-	{
-		jsonData: `
-{
-  "bootstrapPeers": [
-    {
-      "address": "backbone.cardano.iog.io",
-      "port": 3001
-    },
-    {
-      "address": "backbone.mainnet.emurgornd.com",
-      "port": 3001
-    },
-    {
-      "address": "backbone.mainnet.cardanofoundation.org",
-      "port": 3001
-    }
-  ],
-  "localRoots": [
-    {
-      "accessPoints": [],
-      "advertise": false,
-      "trustable": false,
-      "valency": 1
-    }
-  ],
-  "publicRoots": [
-    {
-      "accessPoints": [],
-      "advertise": false
-    }
-  ],
-  "useLedgerAfterSlot": 128908821
-}
-`,
-		expectedObject: &topology.TopologyConfig{
-			LocalRoots: []topology.TopologyConfigP2PLocalRoot{
-				{
-					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
-					Advertise:    false,
-					Trustable:    false,
-					Valency:      1,
-				},
-			},
-			PublicRoots: []topology.TopologyConfigP2PPublicRoot{
-				{
-					AccessPoints: []topology.TopologyConfigP2PAccessPoint{},
-					Advertise:    false,
-				},
-			},
-			BootstrapPeers: []topology.TopologyConfigP2PBootstrapPeer{
-				{
-					Address: "backbone.cardano.iog.io",
-					Port:    3001,
-				},
-				{
-					Address: "backbone.mainnet.emurgornd.com",
-					Port:    3001,
-				},
-				{
-					Address: "backbone.mainnet.cardanofoundation.org",
-					Port:    3001,
-				},
-			},
-			UseLedgerAfterSlot: 128908821,
-		},
-	},
-}
-
-func TestParseTopologyConfig(t *testing.T) {
-	for _, test := range topologyTests {
-		topology, err := topology.NewTopologyConfigFromReader(
-			strings.NewReader(test.jsonData),
-		)
-		if err != nil {
-			t.Fatalf("failed to load TopologyConfig from JSON data: %s", err)
-		}
-		if !reflect.DeepEqual(topology, test.expectedObject) {
-			t.Fatalf(
-				"did not get expected object\n  got:\n    %#v\n  wanted:\n    %#v",
-				topology,
-				test.expectedObject,
-			)
-		}
-	}
-}

package/tracing.go

@@ -1,65 +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"
-	"log/slog"
-
-	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
-	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
-	"go.opentelemetry.io/otel/propagation"
-	"go.opentelemetry.io/otel/sdk/trace"
-)
-
-func (n *Node) setupTracing() error {
-	// Set up propagator.
-	otel.SetTextMapPropagator(
-		propagation.NewCompositeTextMapPropagator(
-			propagation.TraceContext{},
-			propagation.Baggage{},
-		),
-	)
-
-	// Set up trace provider.
-	var traceExporter trace.SpanExporter
-	var err error
-	if n.config.tracingStdout {
-		traceExporter, err = stdouttrace.New(
-			stdouttrace.WithPrettyPrint(),
-		)
-	} else {
-		// TODO: make options configurable (#387)
-		traceExporter, err = otlptracehttp.New(context.TODO())
-	}
-	if err != nil {
-		return err
-	}
-	tracerProvider := trace.NewTracerProvider(
-		trace.WithBatcher(traceExporter),
-	)
-	n.shutdownFuncs = append(n.shutdownFuncs, tracerProvider.Shutdown)
-	otel.SetTracerProvider(tracerProvider)
-	otel.SetErrorHandler(
-		otel.ErrorHandlerFunc(
-			func(err error) {
-				slog.Error(err.Error())
-			},
-		),
-	)
-
-	return nil
-}

package/txsubmission.go

@@ -1,233 +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 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
-}