chainsync

Documentation

Index

• Constants
• Variables
• func NewMsgFromCbor(protoMode protocol.ProtocolMode, msgType uint, data []byte) (protocol.Message, error)
• func NewMsgFromCborNtC(msgType uint, data []byte) (protocol.Message, error)
• func NewMsgFromCborNtN(msgType uint, data []byte) (protocol.Message, error)
• type ChainSync
  • func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConfig) *ChainSync
  • func (c *ChainSync) FindIntersect(points []interface{}) error
  • func (c *ChainSync) RequestNext() error
• type ChainSyncAwaitReplyFunc
• type ChainSyncCallbackConfig
• type ChainSyncDoneFunc
• type ChainSyncIntersectFoundFunc
• type ChainSyncIntersectNotFoundFunc
• type ChainSyncRollBackwardFunc
• type ChainSyncRollForwardFunc
• type MsgAwaitReply
• type MsgDone
• type MsgFindIntersect
  • func NewMsgFindIntersect(points []interface{}) *MsgFindIntersect
• type MsgIntersectFound
• type MsgIntersectNotFound
• type MsgRequestNext
  • func NewMsgRequestNext() *MsgRequestNext
• type MsgRollBackward
• type MsgRollForwardNtC
• type MsgRollForwardNtN
• type Point
  • func (p *Point) UnmarshalCBOR(data []byte) error
• type Tip
• type WrappedBlock
• type WrappedHeader
• type WrappedHeaderByron

Constants

const (
	PROTOCOL_NAME          = "chain-sync"
	PROTOCOL_ID_NTN uint16 = 2
	PROTOCOL_ID_NTC uint16 = 5
)

const (
	MESSAGE_TYPE_REQUEST_NEXT        = 0
	MESSAGE_TYPE_AWAIT_REPLY         = 1
	MESSAGE_TYPE_ROLL_FORWARD        = 2
	MESSAGE_TYPE_ROLL_BACKWARD       = 3
	MESSAGE_TYPE_FIND_INTERSECT      = 4
	MESSAGE_TYPE_INTERSECT_FOUND     = 5
	MESSAGE_TYPE_INTERSECT_NOT_FOUND = 6
	MESSAGE_TYPE_DONE                = 7
)

Variables

var (
	STATE_IDLE       = protocol.NewState(1, "Idle")
	STATE_CAN_AWAIT  = protocol.NewState(2, "CanAwait")
	STATE_MUST_REPLY = protocol.NewState(3, "MustReply")
	STATE_INTERSECT  = protocol.NewState(4, "Intersect")
	STATE_DONE       = protocol.NewState(5, "Done")
)

var StateMap = protocol.StateMap{
	STATE_IDLE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_CLIENT,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_REQUEST_NEXT,
				NewState: STATE_CAN_AWAIT,
			},
			{
				MsgType:  MESSAGE_TYPE_FIND_INTERSECT,
				NewState: STATE_INTERSECT,
			},
			{
				MsgType:  MESSAGE_TYPE_DONE,
				NewState: STATE_DONE,
			},
		},
	},
	STATE_CAN_AWAIT: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_AWAIT_REPLY,
				NewState: STATE_MUST_REPLY,
			},
			{
				MsgType:  MESSAGE_TYPE_ROLL_FORWARD,
				NewState: STATE_IDLE,
			},
			{
				MsgType:  MESSAGE_TYPE_ROLL_BACKWARD,
				NewState: STATE_IDLE,
			},
		},
	},
	STATE_INTERSECT: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_INTERSECT_FOUND,
				NewState: STATE_IDLE,
			},
			{
				MsgType:  MESSAGE_TYPE_INTERSECT_NOT_FOUND,
				NewState: STATE_IDLE,
			},
		},
	},
	STATE_MUST_REPLY: protocol.StateMapEntry{
		Agency: protocol.AGENCY_SERVER,
		Transitions: []protocol.StateTransition{
			{
				MsgType:  MESSAGE_TYPE_ROLL_FORWARD,
				NewState: STATE_IDLE,
			},
			{
				MsgType:  MESSAGE_TYPE_ROLL_BACKWARD,
				NewState: STATE_IDLE,
			},
		},
	},
	STATE_DONE: protocol.StateMapEntry{
		Agency: protocol.AGENCY_NONE,
	},
}

Functions

func NewMsgFromCbor

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

func NewMsgFromCborNtC

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

func NewMsgFromCborNtN

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

Types

type ChainSync

type ChainSync struct {
	// contains filtered or unexported fields
}

func New

func New(options protocol.ProtocolOptions, callbackConfig *ChainSyncCallbackConfig) *ChainSync

func (*ChainSync) FindIntersect

func (c *ChainSync) FindIntersect(points []interface{}) error

func (*ChainSync) RequestNext

func (c *ChainSync) RequestNext() error

type ChainSyncAwaitReplyFunc

type ChainSyncAwaitReplyFunc func() error

Callback function types

type ChainSyncCallbackConfig

type ChainSyncCallbackConfig struct {
	AwaitReplyFunc        ChainSyncAwaitReplyFunc
	RollBackwardFunc      ChainSyncRollBackwardFunc
	RollForwardFunc       ChainSyncRollForwardFunc
	IntersectFoundFunc    ChainSyncIntersectFoundFunc
	IntersectNotFoundFunc ChainSyncIntersectNotFoundFunc
	DoneFunc              ChainSyncDoneFunc
}

type ChainSyncDoneFunc

type ChainSyncDoneFunc func() error

type ChainSyncIntersectFoundFunc

type ChainSyncIntersectFoundFunc func(interface{}, interface{}) error

type ChainSyncIntersectNotFoundFunc

type ChainSyncIntersectNotFoundFunc func(interface{}) error

type ChainSyncRollBackwardFunc

type ChainSyncRollBackwardFunc func(interface{}, interface{}) error

type ChainSyncRollForwardFunc

type ChainSyncRollForwardFunc func(uint, interface{}) error

type MsgAwaitReply

type MsgAwaitReply struct {
	protocol.MessageBase
}

type MsgDone

type MsgDone struct {
	protocol.MessageBase
}

type MsgFindIntersect

type MsgFindIntersect struct {
	protocol.MessageBase
	Points []interface{}
}

func NewMsgFindIntersect

func NewMsgFindIntersect(points []interface{}) *MsgFindIntersect

type MsgIntersectFound

type MsgIntersectFound struct {
	protocol.MessageBase
	Point Point
	Tip   Tip
}

type MsgIntersectNotFound

type MsgIntersectNotFound struct {
	protocol.MessageBase
	Tip Tip
}

type MsgRequestNext

type MsgRequestNext struct {
	protocol.MessageBase
}

func NewMsgRequestNext

func NewMsgRequestNext() *MsgRequestNext

type MsgRollBackward

type MsgRollBackward struct {
	protocol.MessageBase
	Point Point
	Tip   Tip
}

type MsgRollForwardNtC

type MsgRollForwardNtC struct {
	protocol.MessageBase
	WrappedData []byte
	Tip         Tip
}

type MsgRollForwardNtN

type MsgRollForwardNtN struct {
	protocol.MessageBase
	WrappedHeader WrappedHeader
	Tip           Tip
}

type Point

type Point struct {
	Slot uint64
	Hash []byte
}

func (*Point) UnmarshalCBOR

func (p *Point) UnmarshalCBOR(data []byte) error

A "point" can sometimes be empty, but the CBOR library gets grumpy about this when doing automatic decoding from an array, so we have to handle this case specially

type Tip

type Tip struct {
	Point       Point
	BlockNumber uint64
	// contains filtered or unexported fields
}

type WrappedBlock

type WrappedBlock struct {
	Type     uint
	RawBlock cbor.RawMessage
	// contains filtered or unexported fields
}

type WrappedHeader

type WrappedHeader struct {
	Type    uint
	RawData cbor.RawMessage
	// contains filtered or unexported fields
}

type WrappedHeaderByron

type WrappedHeaderByron struct {
	Unknown struct {
		Type    uint
		Unknown uint64
		// contains filtered or unexported fields
	}
	RawHeader []byte
	// contains filtered or unexported fields
}