Merge pull request #45 from cloudstruct/feature/txsubmission-protocol

Implement TxSubmission protocol (part 1)

Author: agaffney

ouroboros.go

@@ -9,6 +9,7 @@ import (
 	"github.com/cloudstruct/go-ouroboros-network/protocol/keepalive"
 	"github.com/cloudstruct/go-ouroboros-network/protocol/localstatequery"
 	"github.com/cloudstruct/go-ouroboros-network/protocol/localtxsubmission"
+	"github.com/cloudstruct/go-ouroboros-network/protocol/txsubmission"
 	"net"
 )
 
@@ -34,6 +35,8 @@ type Ouroboros struct {
 	localTxSubmissionCallbackConfig *localtxsubmission.CallbackConfig
 	LocalStateQuery                 *localstatequery.LocalStateQuery
 	localStateQueryCallbackConfig   *localstatequery.CallbackConfig
+	TxSubmission                    *txsubmission.TxSubmission
+	txSubmissionCallbackConfig      *txsubmission.CallbackConfig
 }
 
 type OuroborosOptions struct {
@@ -134,6 +137,7 @@ func (o *Ouroboros) setupConnection() error {
 		protoOptions.Mode = protocol.ProtocolModeNodeToNode
 		o.ChainSync = chainsync.New(protoOptions, o.chainSyncCallbackConfig)
 		o.BlockFetch = blockfetch.New(protoOptions, o.blockFetchCallbackConfig)
+		o.TxSubmission = txsubmission.New(protoOptions, o.txSubmissionCallbackConfig)
 		if versionNtN.EnableKeepAliveProtocol {
 			o.KeepAlive = keepalive.New(protoOptions, o.keepAliveCallbackConfig)
 			if o.sendKeepAlives {

protocol/protocol.go

@@ -207,6 +207,12 @@ func (p *Protocol) getNewState(msg Message) (State, error) {
 	matchFound := false
 	for _, transition := range p.config.StateMap[p.state].Transitions {
 		if transition.MsgType == msg.Type() {
+			if transition.MatchFunc != nil {
+				// Skip item if match function returns false
+				if !transition.MatchFunc(msg) {
+					continue
+				}
+			}
 			newState = transition.NewState
 			matchFound = true
 			break

protocol/state.go

@@ -23,10 +23,13 @@ func (s State) String() string {
 }
 
 type StateTransition struct {
-	MsgType  uint8
-	NewState State
+	MsgType   uint8
+	NewState  State
+	MatchFunc StateTransitionMatchFunc
 }
 
+type StateTransitionMatchFunc func(Message) bool
+
 type StateMapEntry struct {
 	Agency      uint
 	Transitions []StateTransition

protocol/txsubmission/messages.go

@@ -0,0 +1,144 @@
+package txsubmission
+
+import (
+	"fmt"
+	"github.com/cloudstruct/go-ouroboros-network/protocol"
+	"github.com/cloudstruct/go-ouroboros-network/utils"
+)
+
+const (
+	MESSAGE_TYPE_REQUEST_TX_IDS = 0
+	MESSAGE_TYPE_REPLY_TX_IDS   = 1
+	MESSAGE_TYPE_REQUEST_TXS    = 2
+	MESSAGE_TYPE_REPLY_TXS      = 3
+	MESSAGE_TYPE_DONE           = 4
+	MESSAGE_TYPE_HELLO          = 6
+)
+
+func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
+	var ret protocol.Message
+	switch msgType {
+	case MESSAGE_TYPE_REQUEST_TX_IDS:
+		ret = &MsgRequestTxIds{}
+	case MESSAGE_TYPE_REPLY_TX_IDS:
+		ret = &MsgReplyTxIds{}
+	case MESSAGE_TYPE_REQUEST_TXS:
+		ret = &MsgRequestTxs{}
+	case MESSAGE_TYPE_REPLY_TXS:
+		ret = &MsgReplyTxs{}
+	case MESSAGE_TYPE_DONE:
+		ret = &MsgDone{}
+	case MESSAGE_TYPE_HELLO:
+		ret = &MsgHello{}
+	}
+	if _, err := utils.CborDecode(data, ret); err != nil {
+		return nil, fmt.Errorf("%s: decode error: %s", PROTOCOL_NAME, err)
+	}
+	if ret != nil {
+		// Store the raw message CBOR
+		ret.SetCbor(data)
+	}
+	return ret, nil
+}
+
+type MsgRequestTxIds struct {
+	protocol.MessageBase
+	Blocking bool
+	Ack      uint16
+	Req      uint16
+}
+
+func NewMsgRequestTxIds(blocking bool, ack uint16, req uint16) *MsgRequestTxIds {
+	m := &MsgRequestTxIds{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_REQUEST_TX_IDS,
+		},
+		Blocking: blocking,
+		Ack:      ack,
+		Req:      req,
+	}
+	return m
+}
+
+type MsgReplyTxIds struct {
+	protocol.MessageBase
+	TxIds []txIdAndSize
+}
+
+func NewMsgReplyTxIds() *MsgReplyTxIds {
+	m := &MsgReplyTxIds{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_REPLY_TX_IDS,
+		},
+	}
+	return m
+}
+
+type MsgRequestTxs struct {
+	protocol.MessageBase
+	TxIds []txId
+}
+
+func NewMsgRequestTxs() *MsgRequestTxs {
+	m := &MsgRequestTxs{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_REQUEST_TXS,
+		},
+	}
+	return m
+}
+
+type MsgReplyTxs struct {
+	protocol.MessageBase
+	Txs []txBody
+}
+
+func NewMsgReplyTxs() *MsgReplyTxs {
+	m := &MsgReplyTxs{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_REPLY_TXS,
+		},
+	}
+	return m
+}
+
+type MsgDone struct {
+	protocol.MessageBase
+}
+
+func NewMsgDone() *MsgDone {
+	m := &MsgDone{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_DONE,
+		},
+	}
+	return m
+}
+
+type MsgHello struct {
+	protocol.MessageBase
+}
+
+func NewMsgHello() *MsgHello {
+	m := &MsgHello{
+		MessageBase: protocol.MessageBase{
+			MessageType: MESSAGE_TYPE_HELLO,
+		},
+	}
+	return m
+}
+
+type txId struct {
+	EraId uint16
+	TxId  [32]byte
+}
+
+type txBody struct {
+	EraId  uint16
+	TxBody []byte
+}
+
+type txIdAndSize struct {
+	TxId txId
+	Size uint32
+}