Chain-sync mini-protocol (part 2)

* basic support for parsing Shelley blocks
* skeleton for parsing post-Shelley blocks
* switch to callback model for chain-sync
* implement FindIntersect
* flesh out chain-sync state machine

Author: agaffney

block/allegra.go

@@ -0,0 +1,5 @@
+package block
+
+const (
+	BLOCK_TYPE_ALLEGRA = 4
+)

block/alonzo.go

@@ -0,0 +1,5 @@
+package block
+
+const (
+	BLOCK_TYPE_ALONZO = 5
+)

protocol/common/block.go renamed to block/bryon.go

@@ -1,7 +1,8 @@
-package common
+package block
 
-import (
-	"encoding/hex"
+const (
+	BLOCK_TYPE_BYRON_EBB  = 0
+	BLOCK_TYPE_BYRON_MAIN = 1
 )
 
 type ByronMainBlockHeader struct {
@@ -93,18 +94,6 @@ type ByronEpochBoundaryBlock struct {
 	Extra  []interface{}
 }
 
-type Blake2b256 [32]byte
-
-func (b Blake2b256) String() string {
-	return hex.EncodeToString([]byte(b[:]))
-}
-
-type Blake2b224 [28]byte
-
-func (b Blake2b224) String() string {
-	return hex.EncodeToString([]byte(b[:]))
-}
-
 /*
 blake2b-256 = bytes .size 32
 
@@ -127,6 +116,6 @@ stakeholderid = blake2b-224
 // genesisHash = [ ]
 // blockHash = [ int ]
 // blockBody = bstr
-// heade rSlot = word64
+// headerSlot = word64
 // headerBlockNo = word64
 // headerBodyHash = int

block/common.go

@@ -0,0 +1,17 @@
+package block
+
+import (
+	"encoding/hex"
+)
+
+type Blake2b256 [32]byte
+
+func (b Blake2b256) String() string {
+	return hex.EncodeToString([]byte(b[:]))
+}
+
+type Blake2b224 [28]byte
+
+func (b Blake2b224) String() string {
+	return hex.EncodeToString([]byte(b[:]))
+}

block/mary.go

@@ -0,0 +1,5 @@
+package block
+
+const (
+	BLOCK_TYPE_MARY = 3
+)

block/shelley.go

@@ -0,0 +1,45 @@
+package block
+
+import (
+	"github.com/fxamacker/cbor/v2"
+)
+
+const (
+	BLOCK_TYPE_SHELLEY = 2
+)
+
+type ShelleyBlock struct {
+	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
+	_      struct{} `cbor:",toarray"`
+	Header ShelleyBlockHeader
+	// TODO: create structure for transaction bodies that accounts for
+	// map with bytestring keys for staking reward withdrawals
+	TransactionBodies      []cbor.RawMessage
+	TransactionWitnessSets interface{}
+	TransactionMetadataSet interface{}
+}
+
+type ShelleyBlockHeader struct {
+	// Tells the CBOR decoder to convert to/from a struct and a CBOR array
+	_    struct{} `cbor:",toarray"`
+	Body struct {
+		// Tells the CBOR decoder to convert to/from a struct and a CBOR array
+		_                  struct{} `cbor:",toarray"`
+		BlockNumber        uint64
+		Slot               uint64
+		PrevHash           Blake2b256
+		IssuerVkey         interface{}
+		VrfKey             interface{}
+		NonceVrf           interface{}
+		LeaderVrf          interface{}
+		BlockBodySize      uint32
+		BlockBodyHash      Blake2b256
+		HotVkey            interface{}
+		SequenceNumber     uint32
+		KesPeriod          uint32
+		Sigma              interface{}
+		OperationalCertNum uint
+		ProtocolVersion    interface{}
+	}
+	Signature interface{}
+}

cmd/go-ouroboros-network/main.go

@@ -2,11 +2,12 @@ package main
 
 import (
 	"crypto/tls"
+	"encoding/hex"
 	"flag"
 	"fmt"
 	"github.com/cloudstruct/go-ouroboros-network"
+	"github.com/cloudstruct/go-ouroboros-network/block"
 	"github.com/cloudstruct/go-ouroboros-network/protocol/chainsync"
-	"github.com/cloudstruct/go-ouroboros-network/protocol/common"
 	"github.com/cloudstruct/go-ouroboros-network/utils"
 	"io"
 	"net"
@@ -27,6 +28,12 @@ type cmdFlags struct {
 	mainnet      bool
 }
 
+type chainSyncState struct {
+	readyForNextBlockChan chan bool
+}
+
+var syncState chainSyncState
+
 func main() {
 	f := cmdFlags{}
 	flag.StringVar(&f.socket, "socket", "", "UNIX socket path to connect to")
@@ -75,6 +82,14 @@ func main() {
 	oOpts := &ouroboros.OuroborosOptions{
 		Conn:         conn,
 		NetworkMagic: uint32(f.networkMagic),
+		ChainSyncCallbackConfig: &chainsync.ChainSyncCallbackConfig{
+			AwaitReplyFunc:        chainSyncAwaitReplyHandler,
+			RollBackwardFunc:      chainSyncRollBackwardHandler,
+			RollForwardFunc:       chainSyncRollForwardHandler,
+			IntersectFoundFunc:    chainSyncIntersectFoundHandler,
+			IntersectNotFoundFunc: chainSyncIntersectNotFoundHandler,
+			DoneFunc:              chainSyncDoneHandler,
+		},
 	}
 	o, err := ouroboros.New(oOpts)
 	if err != nil {
@@ -89,22 +104,68 @@ func main() {
 		}
 	}()
 	// Test chain-sync
+	syncState.readyForNextBlockChan = make(chan bool, 0)
+	secondToLastByronSlot := 1598398
+	//lastByronBlockHash, _ := hex.DecodeString("7e16781b40ebf8b6da18f7b5e8ade855d6738095ef2f1c58c77e88b6e45997a4")
+	secondToLastByronBlockHash, _ := hex.DecodeString("8542ae6166cc4affadefd44585488fef9a02aee7914e1e387ce5f7a33e6569c5")
+	if err := o.ChainSync.FindIntersect([]interface{}{[]interface{}{secondToLastByronSlot, secondToLastByronBlockHash}}); err != nil {
+		fmt.Printf("ERROR: FindIntersect: %s\n", err)
+		os.Exit(1)
+	}
+	// Wait until ready for next block
+	<-syncState.readyForNextBlockChan
 	for {
-		resp, err := o.ChainSync.RequestNext()
+		err := o.ChainSync.RequestNext()
 		if err != nil {
-			fmt.Printf("ERROR: %s\n", err)
+			fmt.Printf("ERROR: RequestNext: %s\n", err)
 			os.Exit(1)
 		}
 		//fmt.Printf("resp = %#v, err = %#v\n", resp, err)
-		switch resp.BlockType {
-		case chainsync.BLOCK_TYPE_BYRON_EBB:
-			fmt.Printf("found Byron EBB block\n")
-		case chainsync.BLOCK_TYPE_BYRON_MAIN:
-			block := resp.Block.(common.ByronMainBlock)
-			fmt.Printf("epoch = %d, slot = %d, prevBlock = %s\n", block.Header.ConsensusData.SlotId.Epoch, block.Header.ConsensusData.SlotId.Slot, block.Header.PrevBlock)
-		default:
-			fmt.Printf("unsupported (so far) block type %d\n", resp.BlockType)
-			fmt.Printf("%s\n", utils.DumpCborStructure(resp.Block, ""))
-		}
+		// Wait until ready for next block
+		<-syncState.readyForNextBlockChan
+	}
+}
+
+func chainSyncAwaitReplyHandler() error {
+	return nil
+}
+
+func chainSyncRollBackwardHandler(point interface{}, tip interface{}) error {
+	fmt.Printf("roll backward: point = %#v, tip = %#v\n", point, tip)
+	syncState.readyForNextBlockChan <- true
+	return nil
+}
+
+func chainSyncRollForwardHandler(blockType uint, blockData interface{}) error {
+	switch blockType {
+	case block.BLOCK_TYPE_BYRON_EBB:
+		fmt.Printf("found Byron EBB block\n")
+	case block.BLOCK_TYPE_BYRON_MAIN:
+		b := blockData.(block.ByronMainBlock)
+		fmt.Printf("era = Byron, epoch = %d, slot = %d, prevBlock = %s\n", b.Header.ConsensusData.SlotId.Epoch, b.Header.ConsensusData.SlotId.Slot, b.Header.PrevBlock)
+	case block.BLOCK_TYPE_SHELLEY:
+		b := blockData.(block.ShelleyBlock)
+		fmt.Printf("era = Shelley, slot = %d, block_no = %d, prevHash = %s\n", b.Header.Body.Slot, b.Header.Body.BlockNumber, b.Header.Body.PrevHash)
+	default:
+		fmt.Printf("unsupported (so far) block type %d\n", blockType)
+		fmt.Printf("%s\n", utils.DumpCborStructure(blockData, ""))
 	}
+	syncState.readyForNextBlockChan <- true
+	return nil
+}
+
+func chainSyncIntersectFoundHandler(point interface{}, tip interface{}) error {
+	fmt.Printf("found intersect: point = %#v, tip = %#v\n", point, tip)
+	syncState.readyForNextBlockChan <- true
+	return nil
+}
+
+func chainSyncIntersectNotFoundHandler() error {
+	fmt.Printf("ERROR: failed to find intersection\n")
+	os.Exit(1)
+	return nil
+}
+
+func chainSyncDoneHandler() error {
+	return nil
 }

ouroboros.go

@@ -18,25 +18,28 @@ type Ouroboros struct {
 	muxer              *muxer.Muxer
 	ErrorChan          chan error
 	// Mini-protocols
-	Handshake *handshake.Handshake
-	ChainSync *chainsync.ChainSync
+	Handshake               *handshake.Handshake
+	ChainSync               *chainsync.ChainSync
+	chainSyncCallbackConfig *chainsync.ChainSyncCallbackConfig
 }
 
 type OuroborosOptions struct {
 	Conn         io.ReadWriteCloser
 	NetworkMagic uint32
 	// Whether to wait for the other side to initiate the handshake. This is useful
 	// for servers
-	WaitForHandshake      bool
-	UseNodeToNodeProtocol bool
+	WaitForHandshake        bool
+	UseNodeToNodeProtocol   bool
+	ChainSyncCallbackConfig *chainsync.ChainSyncCallbackConfig
 }
 
 func New(options *OuroborosOptions) (*Ouroboros, error) {
 	o := &Ouroboros{
-		conn:             options.Conn,
-		networkMagic:     options.NetworkMagic,
-		waitForHandshake: options.WaitForHandshake,
-		ErrorChan:        make(chan error, 10),
+		conn:                    options.Conn,
+		networkMagic:            options.NetworkMagic,
+		waitForHandshake:        options.WaitForHandshake,
+		chainSyncCallbackConfig: options.ChainSyncCallbackConfig,
+		ErrorChan:               make(chan error, 10),
 	}
 	if o.conn != nil {
 		if err := o.setupConnection(); err != nil {
@@ -79,6 +82,6 @@ func (o *Ouroboros) setupConnection() error {
 	o.handshakeComplete = <-o.Handshake.Finished
 	fmt.Printf("negotiated protocol version %d\n", o.Handshake.Version)
 	// TODO: register additional mini-protocols
-	o.ChainSync = chainsync.New(o.muxer, o.ErrorChan, o.useNodeToNodeProto)
+	o.ChainSync = chainsync.New(o.muxer, o.ErrorChan, o.useNodeToNodeProto, o.chainSyncCallbackConfig)
 	return nil
 }