handshake

Documentation

Index

• Constants
• Variables
• func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error)
• type Handshake
  • func New(options protocol.ProtocolOptions, allowedVersions []uint16) *Handshake
  • func (h *Handshake) ProposeVersions(versions []uint16, networkMagic uint32) error
• type MsgAcceptVersion
  • func NewMsgAcceptVersion(version uint16, versionData interface{}) *MsgAcceptVersion
• type MsgProposeVersions
  • func NewMsgProposeVersions(versionMap map[uint16]interface{}) *MsgProposeVersions
• type MsgRefuse

Constants

const (
	PROTOCOL_NAME = "handshake"
	PROTOCOL_ID   = 0

	DIFFUSION_MODE_INITIATOR_ONLY          = true
	DIFFUSION_MODE_INITIATOR_AND_RESPONDER = false
)

const (
	MESSAGE_TYPE_PROPOSE_VERSIONS = 0
	MESSAGE_TYPE_ACCEPT_VERSION   = 1
	MESSAGE_TYPE_REFUSE           = 2

	REFUSE_REASON_VERSION_MISMATCH = 0
	REFUSE_REASON_DECODE_ERROR     = 1
	REFUSE_REASON_REFUSED          = 2
)

Variables

var (
	STATE_PROPOSE = protocol.NewState(1, "Propose")
	STATE_CONFIRM = protocol.NewState(2, "Confirm")
	STATE_DONE    = protocol.NewState(3, "Done")
)

var StateMap = protocol.StateMap{
	STATE_PROPOSE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_CLIENT,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_PROPOSE_VERSIONS,
				NewState: STATE_CONFIRM,
			},
		},
	},
	STATE_CONFIRM: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_ACCEPT_VERSION,
				NewState: STATE_DONE,
			},
			{
				MsgType:  MESSAGE_TYPE_REFUSE,
				NewState: STATE_DONE,
			},
		},
	},
	STATE_DONE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_NONE,
	},
}

Functions

func NewMsgFromCbor

func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error)

Types

type Handshake

type Handshake struct {
	Version  uint16
	Finished chan bool
	// contains filtered or unexported fields
}

func New

func New(options protocol.ProtocolOptions, allowedVersions []uint16) *Handshake

func (*Handshake) ProposeVersions

func (h *Handshake) ProposeVersions(versions []uint16, networkMagic uint32) error

type MsgAcceptVersion

type MsgAcceptVersion struct {
	protocol.MessageBase
	Version     uint16
	VersionData interface{}
}

func NewMsgAcceptVersion

func NewMsgAcceptVersion(version uint16, versionData interface{}) *MsgAcceptVersion

type MsgProposeVersions

type MsgProposeVersions struct {
	protocol.MessageBase
	VersionMap map[uint16]interface{}
}

func NewMsgProposeVersions

func NewMsgProposeVersions(versionMap map[uint16]interface{}) *MsgProposeVersions

type MsgRefuse

type MsgRefuse struct {
	protocol.MessageBase
	Reason []interface{}
}