Merge pull request #425 from blinklabs-io/feat/generalize-proto-versions

feat: generalize protocol version handling

Author: agaffney

connection.go

@@ -221,6 +221,13 @@ func (c *Connection) shutdown() {
 // setupConnection establishes the muxer, configures and starts the handshake process, and initializes
 // the appropriate mini-protocols
 func (c *Connection) setupConnection() error {
+	// Check network magic value
+	if c.networkMagic == 0 {
+		return fmt.Errorf(
+			"invalid network magic value provided: %d\n",
+			c.networkMagic,
+		)
+	}
 	// Start Goroutine to shutdown when doneChan is closed
 	go func() {
 		<-c.doneChan
@@ -255,36 +262,41 @@ func (c *Connection) setupConnection() error {
 		Muxer:     c.muxer,
 		ErrorChan: c.protoErrorChan,
 	}
-	var protoVersions []uint16
 	if c.useNodeToNodeProto {
-		protoVersions = GetProtocolVersionsNtN()
 		protoOptions.Mode = protocol.ProtocolModeNodeToNode
 	} else {
-		protoVersions = GetProtocolVersionsNtC()
 		protoOptions.Mode = protocol.ProtocolModeNodeToClient
 	}
 	if c.server {
 		protoOptions.Role = protocol.ProtocolRoleServer
 	} else {
 		protoOptions.Role = protocol.ProtocolRoleClient
 	}
-	// Check network magic value
-	if c.networkMagic == 0 {
-		return fmt.Errorf(
-			"invalid network magic value provided: %d\n",
-			c.networkMagic,
-		)
+	// Generate protocol version map for handshake
+	handshakeDiffusionMode := protocol.DiffusionModeInitiatorOnly
+	if c.fullDuplex {
+		handshakeDiffusionMode = protocol.DiffusionModeInitiatorAndResponder
 	}
+	protoVersions := protocol.GetProtocolVersionMap(
+		protoOptions.Mode,
+		c.networkMagic,
+		handshakeDiffusionMode,
+		// TODO: make these configurable
+		protocol.PeerSharingModeNoPeerSharing,
+		protocol.QueryModeDisabled,
+	)
 	// Perform handshake
 	var handshakeVersion uint16
 	var handshakeFullDuplex bool
 	handshakeConfig := handshake.NewConfig(
-		handshake.WithProtocolVersions(protoVersions),
-		handshake.WithNetworkMagic(c.networkMagic),
-		handshake.WithClientFullDuplex(c.fullDuplex),
-		handshake.WithFinishedFunc(func(version uint16, fullDuplex bool) error {
+		handshake.WithProtocolVersionMap(protoVersions),
+		handshake.WithFinishedFunc(func(version uint16, versionData protocol.VersionData) error {
 			handshakeVersion = version
-			handshakeFullDuplex = fullDuplex
+			if c.useNodeToNodeProto {
+				if versionData.DiffusionMode() == protocol.DiffusionModeInitiatorAndResponder {
+					handshakeFullDuplex = true
+				}
+			}
 			close(c.handshakeFinishedChan)
 			return nil
 		}),
@@ -307,10 +319,6 @@ func (c *Connection) setupConnection() error {
 	}
 	// Provide the negotiated protocol version to the various mini-protocols
 	protoOptions.Version = handshakeVersion
-	// Drop bit used to signify NtC protocol versions
-	if protoOptions.Version > protocolVersionNtCFlag {
-		protoOptions.Version = protoOptions.Version - protocolVersionNtCFlag
-	}
 	// Start Goroutine to pass along errors from the mini-protocols
 	c.waitGroup.Add(1)
 	go func() {
@@ -331,7 +339,7 @@ func (c *Connection) setupConnection() error {
 	}()
 	// Configure the relevant mini-protocols
 	if c.useNodeToNodeProto {
-		versionNtN := GetProtocolVersionNtN(handshakeVersion)
+		versionNtN := protocol.GetProtocolVersion(handshakeVersion)
 		protoOptions.Mode = protocol.ProtocolModeNodeToNode
 		c.chainSync = chainsync.New(protoOptions, c.chainSyncConfig)
 		c.blockFetch = blockfetch.New(protoOptions, c.blockFetchConfig)
@@ -365,7 +373,7 @@ func (c *Connection) setupConnection() error {
 			}
 		}
 	} else {
-		versionNtC := GetProtocolVersionNtC(handshakeVersion)
+		versionNtC := protocol.GetProtocolVersion(handshakeVersion)
 		protoOptions.Mode = protocol.ProtocolModeNodeToClient
 		c.chainSync = chainsync.New(protoOptions, c.chainSyncConfig)
 		c.localTxSubmission = localtxsubmission.New(protoOptions, c.localTxSubmissionConfig)

internal/test/ouroboros_mock/entry.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	MockNetworkMagic       uint32 = 999999
-	MockProtocolVersionNtC uint16 = 14
+	MockProtocolVersionNtC uint16 = (14 + protocol.ProtocolVersionNtCOffset)
 )
 
 type EntryType int
@@ -57,6 +57,9 @@ var ConversationEntryHandshakeResponse = ConversationEntry{
 	ProtocolId: handshake.ProtocolId,
 	IsResponse: true,
 	OutputMessages: []protocol.Message{
-		handshake.NewMsgAcceptVersion(MockProtocolVersionNtC, MockNetworkMagic),
+		handshake.NewMsgAcceptVersion(
+			MockProtocolVersionNtC,
+			protocol.VersionDataNtC9to14(MockNetworkMagic),
+		),
 	},
 }

protocol/handshake/client.go

@@ -65,39 +65,7 @@ func (c *Client) Start() {
 	c.onceStart.Do(func() {
 		c.Protocol.Start()
 		// Send our ProposeVersions message
-		versionMap := make(map[uint16]interface{})
-		diffusionMode := DiffusionModeInitiatorOnly
-		if c.config.ClientFullDuplex {
-			diffusionMode = DiffusionModeInitiatorAndResponder
-		}
-		for _, version := range c.config.ProtocolVersions {
-			if c.Mode() == protocol.ProtocolModeNodeToNode {
-				if version >= 11 {
-					// TODO: make peer sharing mode configurable once it actually works
-					versionMap[version] = NtNVersionDataPeerSharingQuery{
-						NetworkMagic:                       c.config.NetworkMagic,
-						InitiatorAndResponderDiffusionMode: diffusionMode,
-						PeerSharing:                        PeerSharingModeNoPeerSharing,
-						Query:                              QueryModeDisabled,
-					}
-				} else {
-					versionMap[version] = NtNVersionDataLegacy{
-						NetworkMagic:                       c.config.NetworkMagic,
-						InitiatorAndResponderDiffusionMode: diffusionMode,
-					}
-				}
-			} else {
-				if (version - NodeToClientVersionOffset) >= 15 {
-					versionMap[version] = NtCVersionData{
-						NetworkMagic: c.config.NetworkMagic,
-						Query:        QueryModeDisabled,
-					}
-				} else {
-					versionMap[version] = c.config.NetworkMagic
-				}
-			}
-		}
-		msg := NewMsgProposeVersions(versionMap)
+		msg := NewMsgProposeVersions(c.config.ProtocolVersionMap)
 		_ = c.SendMessage(msg)
 	})
 }
@@ -119,24 +87,19 @@ func (c *Client) handleMessage(msg protocol.Message, isResponse bool) error {
 	return err
 }
 
-func (c *Client) handleAcceptVersion(msgGeneric protocol.Message) error {
+func (c *Client) handleAcceptVersion(msg protocol.Message) error {
 	if c.config.FinishedFunc == nil {
 		return fmt.Errorf(
 			"received handshake AcceptVersion message but no callback function is defined",
 		)
 	}
-	msg := msgGeneric.(*MsgAcceptVersion)
-	fullDuplex := false
-	if c.Mode() == protocol.ProtocolModeNodeToNode {
-		// TODO: switch to using the VersionData types
-		// this is more annoying than it would seem until we fix some other things
-		versionData := msg.VersionData.([]interface{})
-		//nolint:gosimple
-		if versionData[1].(bool) == DiffusionModeInitiatorAndResponder {
-			fullDuplex = true
-		}
+	msgAcceptVersion := msg.(*MsgAcceptVersion)
+	protoVersion := protocol.GetProtocolVersion(msgAcceptVersion.Version)
+	versionData, err := protoVersion.NewVersionDataFromCborFunc(msgAcceptVersion.VersionData)
+	if err != nil {
+		return err
 	}
-	return c.config.FinishedFunc(msg.Version, fullDuplex)
+	return c.config.FinishedFunc(msgAcceptVersion.Version, versionData)
 }
 
 func (c *Client) handleRefuse(msgGeneric protocol.Message) error {

protocol/handshake/handshake.go

@@ -27,28 +27,6 @@ const (
 	ProtocolId   = 0
 )
 
-// Diffusion modes
-const (
-	DiffusionModeInitiatorOnly         = true
-	DiffusionModeInitiatorAndResponder = false
-)
-
-// Peer sharing modes
-const (
-	PeerSharingModeNoPeerSharing      = 0
-	PeerSharingModePeerSharingPrivate = 1
-	PeerSharingModePeerSharingPublic  = 2
-)
-
-// Query modes
-const (
-	QueryModeDisabled = false
-	QueryModeEnabled  = true
-)
-
-// NtC version numbers have the 15th bit set
-const NodeToClientVersionOffset = 0x8000
-
 var (
 	statePropose = protocol.NewState(1, "Propose")
 	stateConfirm = protocol.NewState(2, "Confirm")
@@ -92,15 +70,13 @@ type Handshake struct {
 
 // Config is used to configure the Handshake protocol instance
 type Config struct {
-	ProtocolVersions []uint16
-	NetworkMagic     uint32
-	ClientFullDuplex bool
-	FinishedFunc     FinishedFunc
-	Timeout          time.Duration
+	ProtocolVersionMap protocol.ProtocolVersionMap
+	FinishedFunc       FinishedFunc
+	Timeout            time.Duration
 }
 
 // Callback function types
-type FinishedFunc func(uint16, bool) error
+type FinishedFunc func(uint16, protocol.VersionData) error
 
 // New returns a new Handshake object
 func New(protoOptions protocol.ProtocolOptions, cfg *Config) *Handshake {
@@ -126,24 +102,10 @@ func NewConfig(options ...HandshakeOptionFunc) Config {
 	return c
 }
 
-// WithProtocolVersions specifies the supported protocol versions
-func WithProtocolVersions(versions []uint16) HandshakeOptionFunc {
-	return func(c *Config) {
-		c.ProtocolVersions = versions
-	}
-}
-
-// WithNetworkMagic specifies the network magic value
-func WithNetworkMagic(networkMagic uint32) HandshakeOptionFunc {
-	return func(c *Config) {
-		c.NetworkMagic = networkMagic
-	}
-}
-
-// WithClientFullDuplex specifies whether to request full duplex mode when acting as a client
-func WithClientFullDuplex(fullDuplex bool) HandshakeOptionFunc {
+// WithProtocolVersionMap specifies the supported protocol versions
+func WithProtocolVersionMap(versionMap protocol.ProtocolVersionMap) HandshakeOptionFunc {
 	return func(c *Config) {
-		c.ClientFullDuplex = fullDuplex
+		c.ProtocolVersionMap = versionMap
 	}
 }
 

protocol/handshake/messages.go

@@ -58,37 +58,45 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 
 type MsgProposeVersions struct {
 	protocol.MessageBase
-	VersionMap map[uint16]interface{}
+	VersionMap map[uint16]cbor.RawMessage
 }
 
 func NewMsgProposeVersions(
-	versionMap map[uint16]interface{},
+	versionMap protocol.ProtocolVersionMap,
 ) *MsgProposeVersions {
+	rawVersionMap := map[uint16]cbor.RawMessage{}
+	for version, versionData := range versionMap {
+		// This should never fail with our known VersionData types
+		cborData, _ := cbor.Encode(&versionData)
+		rawVersionMap[version] = cbor.RawMessage(cborData)
+	}
 	m := &MsgProposeVersions{
 		MessageBase: protocol.MessageBase{
 			MessageType: MessageTypeProposeVersions,
 		},
-		VersionMap: versionMap,
+		VersionMap: rawVersionMap,
 	}
 	return m
 }
 
 type MsgAcceptVersion struct {
 	protocol.MessageBase
 	Version     uint16
-	VersionData interface{}
+	VersionData cbor.RawMessage
 }
 
 func NewMsgAcceptVersion(
 	version uint16,
-	versionData interface{},
+	versionData protocol.VersionData,
 ) *MsgAcceptVersion {
+	// This should never fail with our known VersionData types
+	cborData, _ := cbor.Encode(&versionData)
 	m := &MsgAcceptVersion{
 		MessageBase: protocol.MessageBase{
 			MessageType: MessageTypeAcceptVersion,
 		},
 		Version:     version,
-		VersionData: versionData,
+		VersionData: cbor.RawMessage(cborData),
 	}
 	return m
 }

protocol/handshake/messages_test.go

@@ -34,18 +34,36 @@ var tests = []testDefinition{
 		CborHex:     "8200a4078202f4088202f4098202f40a8202f4",
 		MessageType: MessageTypeProposeVersions,
 		Message: NewMsgProposeVersions(
-			map[uint16]interface{}{
-				7:  []interface{}{uint64(2), false},
-				8:  []interface{}{uint64(2), false},
-				9:  []interface{}{uint64(2), false},
-				10: []interface{}{uint64(2), false},
+			map[uint16]protocol.VersionData{
+				7: protocol.VersionDataNtN7to10{
+					CborNetworkMagic:                       2,
+					CborInitiatorAndResponderDiffusionMode: false,
+				},
+				8: protocol.VersionDataNtN7to10{
+					CborNetworkMagic:                       2,
+					CborInitiatorAndResponderDiffusionMode: false,
+				},
+				9: protocol.VersionDataNtN7to10{
+					CborNetworkMagic:                       2,
+					CborInitiatorAndResponderDiffusionMode: false,
+				},
+				10: protocol.VersionDataNtN7to10{
+					CborNetworkMagic:                       2,
+					CborInitiatorAndResponderDiffusionMode: false,
+				},
 			},
 		),
 	},
 	{
 		CborHex:     "83010a8202f4",
 		MessageType: MessageTypeAcceptVersion,
-		Message:     NewMsgAcceptVersion(10, []interface{}{uint64(2), false}),
+		Message: NewMsgAcceptVersion(
+			10,
+			protocol.VersionDataNtN7to10{
+				CborNetworkMagic:                       2,
+				CborInitiatorAndResponderDiffusionMode: false,
+			},
+		),
 	},
 	{
 		CborHex:     "82028200840708090a",

protocol/handshake/server.go

@@ -70,19 +70,17 @@ func (s *Server) handleProposeVersions(msgGeneric protocol.Message) error {
 	}
 	msg := msgGeneric.(*MsgProposeVersions)
 	var highestVersion uint16
-	var fullDuplex bool
-	var versionData []interface{}
+	var versionData protocol.VersionData
 	for proposedVersion := range msg.VersionMap {
 		if proposedVersion > highestVersion {
-			for _, allowedVersion := range s.config.ProtocolVersions {
+			for allowedVersion := range s.config.ProtocolVersionMap {
 				if allowedVersion == proposedVersion {
 					highestVersion = proposedVersion
-					versionData = msg.VersionMap[proposedVersion].([]interface{})
-					//nolint:gosimple
-					if versionData[1].(bool) == DiffusionModeInitiatorAndResponder {
-						fullDuplex = true
-					} else {
-						fullDuplex = false
+					versionConfig := protocol.GetProtocolVersion(proposedVersion)
+					tmpVersionData, err := versionConfig.NewVersionDataFromCborFunc(msg.VersionMap[proposedVersion])
+					versionData = tmpVersionData
+					if err != nil {
+						return err
 					}
 					break
 				}
@@ -94,7 +92,7 @@ func (s *Server) handleProposeVersions(msgGeneric protocol.Message) error {
 		if err := s.SendMessage(resp); err != nil {
 			return err
 		}
-		return s.config.FinishedFunc(highestVersion, fullDuplex)
+		return s.config.FinishedFunc(highestVersion, versionData)
 	} else {
 		// TODO: handle failures
 		// https://github.com/blinklabs-io/gouroboros/issues/32