Fix version

app/app.go

@@ -46,7 +46,7 @@ func StartApp() error {
 	// initializes logging and configures it accordingly.
 	cfg, err := config.LoadConfig()
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprint(os.Stderr, err)
 		return err
 	}
 	defer panics.HandlePanic(log, "MAIN", nil)

app/appmessage/common.go

@@ -5,8 +5,10 @@
 package appmessage
 
 import (
+	"encoding/binary"
 	"fmt"
 	"io"
+	"math"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
@@ -21,6 +23,16 @@ const MaxVarIntPayload = 9
 // MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
 const MaxInvPerMsg = 1 << 17
 
+var (
+	// littleEndian is a convenience variable since binary.LittleEndian is
+	// quite long.
+	littleEndian = binary.LittleEndian
+
+	// bigEndian is a convenience variable since binary.BigEndian is quite
+	// long.
+	bigEndian = binary.BigEndian
+)
+
 // errNonCanonicalVarInt is the common format string used for non-canonically
 // encoded variable length integer errors.
 var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
@@ -41,7 +53,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 	// type assertions first.
 	switch e := element.(type) {
 	case *int32:
-		rv, err := binaryserializer.Uint32(r)
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -49,7 +61,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *uint32:
-		rv, err := binaryserializer.Uint32(r)
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -57,7 +69,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *int64:
-		rv, err := binaryserializer.Uint64(r)
+		rv, err := binaryserializer.Uint64(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -65,7 +77,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *uint64:
-		rv, err := binaryserializer.Uint64(r)
+		rv, err := binaryserializer.Uint64(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -94,7 +106,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 
 	// Unix timestamp encoded as an int64.
 	case *int64Time:
-		rv, err := binaryserializer.Uint64(r)
+		rv, err := binaryserializer.Uint64(r, binary.LittleEndian)
 		if err != nil {
 			return err
 		}
@@ -111,7 +123,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 
 	// Message header command.
 	case *MessageCommand:
-		rv, err := binaryserializer.Uint32(r)
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -144,7 +156,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *ServiceFlag:
-		rv, err := binaryserializer.Uint64(r)
+		rv, err := binaryserializer.Uint64(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -152,7 +164,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *KaspaNet:
-		rv, err := binaryserializer.Uint32(r)
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
@@ -181,28 +193,28 @@ func WriteElement(w io.Writer, element interface{}) error {
 	// type assertions first.
 	switch e := element.(type) {
 	case int32:
-		err := binaryserializer.PutUint32(w, uint32(e))
+		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case uint32:
-		err := binaryserializer.PutUint32(w, e)
+		err := binaryserializer.PutUint32(w, littleEndian, e)
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case int64:
-		err := binaryserializer.PutUint64(w, uint64(e))
+		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case uint64:
-		err := binaryserializer.PutUint64(w, e)
+		err := binaryserializer.PutUint64(w, littleEndian, e)
 		if err != nil {
 			return err
 		}
@@ -237,7 +249,7 @@ func WriteElement(w io.Writer, element interface{}) error {
 
 	// Message header command.
 	case MessageCommand:
-		err := binaryserializer.PutUint32(w, uint32(e))
+		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -269,14 +281,14 @@ func WriteElement(w io.Writer, element interface{}) error {
 		return nil
 
 	case ServiceFlag:
-		err := binaryserializer.PutUint64(w, uint64(e))
+		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case KaspaNet:
-		err := binaryserializer.PutUint32(w, uint32(e))
+		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -308,7 +320,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 	var rv uint64
 	switch discriminant {
 	case 0xff:
-		sv, err := binaryserializer.Uint64(r)
+		sv, err := binaryserializer.Uint64(r, littleEndian)
 		if err != nil {
 			return 0, err
 		}
@@ -323,7 +335,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		}
 
 	case 0xfe:
-		sv, err := binaryserializer.Uint32(r)
+		sv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return 0, err
 		}
@@ -338,7 +350,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		}
 
 	case 0xfd:
-		sv, err := binaryserializer.Uint16(r)
+		sv, err := binaryserializer.Uint16(r, littleEndian)
 		if err != nil {
 			return 0, err
 		}
@@ -358,3 +370,143 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 
 	return rv, nil
 }
+
+// WriteVarInt serializes val to w using a variable number of bytes depending
+// on its value.
+func WriteVarInt(w io.Writer, val uint64) error {
+	if val < 0xfd {
+		_, err := w.Write([]byte{uint8(val)})
+		return errors.WithStack(err)
+	}
+
+	if val <= math.MaxUint16 {
+		var buf [3]byte
+		buf[0] = 0xfd
+		littleEndian.PutUint16(buf[1:], uint16(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
+	}
+
+	if val <= math.MaxUint32 {
+		var buf [5]byte
+		buf[0] = 0xfe
+		littleEndian.PutUint32(buf[1:], uint32(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
+	}
+
+	var buf [9]byte
+	buf[0] = 0xff
+	littleEndian.PutUint64(buf[1:], val)
+	_, err := w.Write(buf[:])
+	return errors.WithStack(err)
+}
+
+// VarIntSerializeSize returns the number of bytes it would take to serialize
+// val as a variable length integer.
+func VarIntSerializeSize(val uint64) int {
+	// The value is small enough to be represented by itself, so it's
+	// just 1 byte.
+	if val < 0xfd {
+		return 1
+	}
+
+	// Discriminant 1 byte plus 2 bytes for the uint16.
+	if val <= math.MaxUint16 {
+		return 3
+	}
+
+	// Discriminant 1 byte plus 4 bytes for the uint32.
+	if val <= math.MaxUint32 {
+		return 5
+	}
+
+	// Discriminant 1 byte plus 8 bytes for the uint64.
+	return 9
+}
+
+// ReadVarString reads a variable length string from r and returns it as a Go
+// string. A variable length string is encoded as a variable length integer
+// containing the length of the string followed by the bytes that represent the
+// string itself. An error is returned if the length is greater than the
+// maximum block payload size since it helps protect against memory exhaustion
+// attacks and forced panics through malformed messages.
+func ReadVarString(r io.Reader, pver uint32) (string, error) {
+	count, err := ReadVarInt(r)
+	if err != nil {
+		return "", err
+	}
+
+	// Prevent variable length strings that are larger than the maximum
+	// message size. It would be possible to cause memory exhaustion and
+	// panics without a sane upper bound on this count.
+	if count > MaxMessagePayload {
+		str := fmt.Sprintf("variable length string is too long "+
+			"[count %d, max %d]", count, MaxMessagePayload)
+		return "", messageError("ReadVarString", str)
+	}
+
+	buf := make([]byte, count)
+	_, err = io.ReadFull(r, buf)
+	if err != nil {
+		return "", err
+	}
+	return string(buf), nil
+}
+
+// WriteVarString serializes str to w as a variable length integer containing
+// the length of the string followed by the bytes that represent the string
+// itself.
+func WriteVarString(w io.Writer, str string) error {
+	err := WriteVarInt(w, uint64(len(str)))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(str))
+	return err
+}
+
+// ReadVarBytes reads a variable length byte array. A byte array is encoded
+// as a varInt containing the length of the array followed by the bytes
+// themselves. An error is returned if the length is greater than the
+// passed maxAllowed parameter which helps protect against memory exhaustion
+// attacks and forced panics through malformed messages. The fieldName
+// parameter is only used for the error message so it provides more context in
+// the error.
+func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
+	fieldName string) ([]byte, error) {
+
+	count, err := ReadVarInt(r)
+	if err != nil {
+		return nil, err
+	}
+
+	// Prevent byte array larger than the max message size. It would
+	// be possible to cause memory exhaustion and panics without a sane
+	// upper bound on this count.
+	if count > uint64(maxAllowed) {
+		str := fmt.Sprintf("%s is larger than the max allowed size "+
+			"[count %d, max %d]", fieldName, count, maxAllowed)
+		return nil, messageError("ReadVarBytes", str)
+	}
+
+	b := make([]byte, count)
+	_, err = io.ReadFull(r, b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// WriteVarBytes serializes a variable length byte array to w as a varInt
+// containing the number of bytes, followed by the bytes themselves.
+func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
+	slen := uint64(len(bytes))
+	err := WriteVarInt(w, slen)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(bytes)
+	return err
+}

app/appmessage/common_test.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"io"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -232,3 +233,464 @@ func TestElementEncodingErrors(t *testing.T) {
 		}
 	}
 }
+
+// TestVarIntEncoding tests appmessage encode and decode for variable length integers.
+func TestVarIntEncoding(t *testing.T) {
+	tests := []struct {
+		value uint64 // Value to encode
+		buf   []byte // Encoded value
+	}{
+		// Latest protocol version.
+		// Single byte
+		{0, []byte{0x00}},
+		// Max single byte
+		{0xfc, []byte{0xfc}},
+		// Min 2-byte
+		{0xfd, []byte{0xfd, 0x0fd, 0x00}},
+		// Max 2-byte
+		{0xffff, []byte{0xfd, 0xff, 0xff}},
+		// Min 4-byte
+		{0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
+		// Max 4-byte
+		{0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
+		// Min 8-byte
+		{
+			0x100000000,
+			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
+		},
+		// Max 8-byte
+		{
+			0xffffffffffffffff,
+			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		buf := &bytes.Buffer{}
+		err := WriteVarInt(buf, test.value)
+		if err != nil {
+			t.Errorf("WriteVarInt #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarInt #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarInt(rbuf)
+		if err != nil {
+			t.Errorf("ReadVarInt #%d error %v", i, err)
+			continue
+		}
+		if val != test.value {
+			t.Errorf("ReadVarInt #%d\n got: %x want: %x", i,
+				val, test.value)
+			continue
+		}
+	}
+}
+
+// TestVarIntEncodingErrors performs negative tests against appmessage encode and decode
+// of variable length integers to confirm error paths work correctly.
+func TestVarIntEncodingErrors(t *testing.T) {
+	tests := []struct {
+		in       uint64 // Value to encode
+		buf      []byte // Encoded value
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Force errors on discriminant.
+		{0, []byte{0x00}, 0, io.ErrShortWrite, io.EOF},
+		// Force errors on 2-byte read/write.
+		{0xfd, []byte{0xfd}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0xfd, []byte{0xfd}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+		// Force errors on 4-byte read/write.
+		{0x10000, []byte{0xfe}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0x10000, []byte{0xfe}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+		// Force errors on 8-byte read/write.
+		{0x100000000, []byte{0xff}, 0, io.ErrShortWrite, io.EOF},              // error on writing length
+		{0x100000000, []byte{0xff}, 2, io.ErrShortWrite, io.ErrUnexpectedEOF}, // error on writing actual data
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarInt(w, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarInt(r)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarIntNonCanonical ensures variable length integers that are not encoded
+// canonically return the expected error.
+func TestVarIntNonCanonical(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		name string // Test name for easier identification
+		in   []byte // Value to decode
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		{
+			"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
+			pver,
+		},
+		{
+			"max single-byte value encoded with 3 bytes",
+			[]byte{0xfd, 0xfc, 0x00}, pver,
+		},
+		{
+			"0 encoded with 5 bytes",
+			[]byte{0xfe, 0x00, 0x00, 0x00, 0x00}, pver,
+		},
+		{
+			"max three-byte value encoded with 5 bytes",
+			[]byte{0xfe, 0xff, 0xff, 0x00, 0x00}, pver,
+		},
+		{
+			"0 encoded with 9 bytes",
+			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+			pver,
+		},
+		{
+			"max five-byte value encoded with 9 bytes",
+			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
+			pver,
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.in)
+		val, err := ReadVarInt(rbuf)
+		if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
+			t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i,
+				test.name, err)
+			continue
+		}
+		if val != 0 {
+			t.Errorf("ReadVarInt #%d (%s)\n got: %d want: 0", i,
+				test.name, val)
+			continue
+		}
+	}
+}
+
+// TestVarIntEncoding tests the serialize size for variable length integers.
+func TestVarIntSerializeSize(t *testing.T) {
+	tests := []struct {
+		val  uint64 // Value to get the serialized size for
+		size int    // Expected serialized size
+	}{
+		// Single byte
+		{0, 1},
+		// Max single byte
+		{0xfc, 1},
+		// Min 2-byte
+		{0xfd, 3},
+		// Max 2-byte
+		{0xffff, 3},
+		// Min 4-byte
+		{0x10000, 5},
+		// Max 4-byte
+		{0xffffffff, 5},
+		// Min 8-byte
+		{0x100000000, 9},
+		// Max 8-byte
+		{0xffffffffffffffff, 9},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		serializedSize := VarIntSerializeSize(test.val)
+		if serializedSize != test.size {
+			t.Errorf("VarIntSerializeSize #%d got: %d, want: %d", i,
+				serializedSize, test.size)
+			continue
+		}
+	}
+}
+
+// TestVarStringEncoding tests appmessage encode and decode for variable length strings.
+func TestVarStringEncoding(t *testing.T) {
+	pver := ProtocolVersion
+
+	// str256 is a string that takes a 2-byte varint to encode.
+	str256 := strings.Repeat("test", 64)
+
+	tests := []struct {
+		in   string // String to encode
+		out  string // String to decoded value
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		// Empty string
+		{"", "", []byte{0x00}, pver},
+		// Single byte varint + string
+		{"Test", "Test", append([]byte{0x04}, []byte("Test")...), pver},
+		// 2-byte varint + string
+		{str256, str256, append([]byte{0xfd, 0x00, 0x01}, []byte(str256)...), pver},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		var buf bytes.Buffer
+		err := WriteVarString(&buf, test.in)
+		if err != nil {
+			t.Errorf("WriteVarString #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarString #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarString(rbuf, test.pver)
+		if err != nil {
+			t.Errorf("ReadVarString #%d error %v", i, err)
+			continue
+		}
+		if val != test.out {
+			t.Errorf("ReadVarString #%d\n got: %s want: %s", i,
+				val, test.out)
+			continue
+		}
+	}
+}
+
+// TestVarStringEncodingErrors performs negative tests against appmessage encode and
+// decode of variable length strings to confirm error paths work correctly.
+func TestVarStringEncodingErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	// str256 is a string that takes a 2-byte varint to encode.
+	str256 := strings.Repeat("test", 64)
+
+	tests := []struct {
+		in       string // Value to encode
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Latest protocol version with intentional read/write errors.
+		// Force errors on empty string.
+		{"", []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
+		// Force error on single byte varint + string.
+		{"Test", []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+		// Force errors on 2-byte varint + string.
+		{str256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarString(w, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarString #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarString(r, test.pver)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarString #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarStringOverflowErrors performs tests to ensure deserializing variable
+// length strings intentionally crafted to use large values for the string
+// length are handled properly. This could otherwise potentially be used as an
+// attack vector.
+func TestVarStringOverflowErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+		err  error  // Expected error
+	}{
+		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+			pver, &MessageError{}},
+		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+			pver, &MessageError{}},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		_, err := ReadVarString(rbuf, test.pver)
+		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
+			t.Errorf("ReadVarString #%d wrong error got: %v, "+
+				"want: %v", i, err, reflect.TypeOf(test.err))
+			continue
+		}
+	}
+
+}
+
+// TestVarBytesEncoding tests appmessage encode and decode for variable length byte array.
+func TestVarBytesEncoding(t *testing.T) {
+	pver := ProtocolVersion
+
+	// bytes256 is a byte array that takes a 2-byte varint to encode.
+	bytes256 := bytes.Repeat([]byte{0x01}, 256)
+
+	tests := []struct {
+		in   []byte // Byte Array to write
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		// Empty byte array
+		{[]byte{}, []byte{0x00}, pver},
+		// Single byte varint + byte array
+		{[]byte{0x01}, []byte{0x01, 0x01}, pver},
+		// 2-byte varint + byte array
+		{bytes256, append([]byte{0xfd, 0x00, 0x01}, bytes256...), pver},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		var buf bytes.Buffer
+		err := WriteVarBytes(&buf, test.pver, test.in)
+		if err != nil {
+			t.Errorf("WriteVarBytes #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("WriteVarBytes #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
+			"test payload")
+		if err != nil {
+			t.Errorf("ReadVarBytes #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("ReadVarBytes #%d\n got: %s want: %s", i,
+				val, test.buf)
+			continue
+		}
+	}
+}
+
+// TestVarBytesEncodingErrors performs negative tests against appmessage encode and
+// decode of variable length byte arrays to confirm error paths work correctly.
+func TestVarBytesEncodingErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	// bytes256 is a byte array that takes a 2-byte varint to encode.
+	bytes256 := bytes.Repeat([]byte{0x01}, 256)
+
+	tests := []struct {
+		in       []byte // Byte Array to write
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
+		max      int    // Max size of fixed buffer to induce errors
+		writeErr error  // Expected write error
+		readErr  error  // Expected read error
+	}{
+		// Latest protocol version with intentional read/write errors.
+		// Force errors on empty byte array.
+		{[]byte{}, []byte{0x00}, pver, 0, io.ErrShortWrite, io.EOF},
+		// Force error on single byte varint + byte array.
+		{[]byte{0x01, 0x02, 0x03}, []byte{0x04}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+		// Force errors on 2-byte varint + byte array.
+		{bytes256, []byte{0xfd}, pver, 2, io.ErrShortWrite, io.ErrUnexpectedEOF},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode to appmessage format.
+		w := newFixedWriter(test.max)
+		err := WriteVarBytes(w, test.pver, test.in)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v",
+				i, err, test.writeErr)
+			continue
+		}
+
+		// Decode from appmessage format.
+		r := newFixedReader(test.max, test.buf)
+		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
+			"test payload")
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v",
+				i, err, test.readErr)
+			continue
+		}
+	}
+}
+
+// TestVarBytesOverflowErrors performs tests to ensure deserializing variable
+// length byte arrays intentionally crafted to use large values for the array
+// length are handled properly. This could otherwise potentially be used as an
+// attack vector.
+func TestVarBytesOverflowErrors(t *testing.T) {
+	pver := ProtocolVersion
+
+	tests := []struct {
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
+		err  error  // Expected error
+	}{
+		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+			pver, &MessageError{}},
+		{[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
+			pver, &MessageError{}},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Decode from appmessage format.
+		rbuf := bytes.NewReader(test.buf)
+		_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
+			"test payload")
+		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
+			t.Errorf("ReadVarBytes #%d wrong error got: %v, "+
+				"want: %v", i, err, reflect.TypeOf(test.err))
+			continue
+		}
+	}
+
+}

app/appmessage/domainconverters.go

@@ -17,9 +17,9 @@ func DomainBlockToMsgBlock(domainBlock *externalapi.DomainBlock) *MsgBlock {
 	}
 }
 
-// DomainBlockHeaderToBlockHeader converts an externalapi.DomainBlockHeader to MsgBlockHeader
-func DomainBlockHeaderToBlockHeader(domainBlockHeader *externalapi.DomainBlockHeader) *MsgBlockHeader {
-	return &MsgBlockHeader{
+// DomainBlockHeaderToBlockHeader converts an externalapi.DomainBlockHeader to BlockHeader
+func DomainBlockHeaderToBlockHeader(domainBlockHeader *externalapi.DomainBlockHeader) *BlockHeader {
+	return &BlockHeader{
 		Version:              domainBlockHeader.Version,
 		ParentHashes:         domainBlockHeader.ParentHashes,
 		HashMerkleRoot:       &domainBlockHeader.HashMerkleRoot,
@@ -44,8 +44,8 @@ func MsgBlockToDomainBlock(msgBlock *MsgBlock) *externalapi.DomainBlock {
 	}
 }
 
-// BlockHeaderToDomainBlockHeader converts a MsgBlockHeader to externalapi.DomainBlockHeader
-func BlockHeaderToDomainBlockHeader(blockHeader *MsgBlockHeader) *externalapi.DomainBlockHeader {
+// BlockHeaderToDomainBlockHeader converts a BlockHeader to externalapi.DomainBlockHeader
+func BlockHeaderToDomainBlockHeader(blockHeader *BlockHeader) *externalapi.DomainBlockHeader {
 	return &externalapi.DomainBlockHeader{
 		Version:              blockHeader.Version,
 		ParentHashes:         blockHeader.ParentHashes,
@@ -77,7 +77,7 @@ func DomainTransactionToMsgTx(domainTransaction *externalapi.DomainTransaction)
 		LockTime:     domainTransaction.LockTime,
 		SubnetworkID: domainTransaction.SubnetworkID,
 		Gas:          domainTransaction.Gas,
-		PayloadHash:  domainTransaction.PayloadHash,
+		PayloadHash:  &domainTransaction.PayloadHash,
 		Payload:      domainTransaction.Payload,
 	}
 }
@@ -114,12 +114,6 @@ func MsgTxToDomainTransaction(msgTx *MsgTx) *externalapi.DomainTransaction {
 	for _, txOut := range msgTx.TxOut {
 		transactionOutputs = append(transactionOutputs, txOutToDomainTransactionOutput(txOut))
 	}
-
-	payload := make([]byte, 0)
-	if msgTx.Payload != nil {
-		payload = msgTx.Payload
-	}
-
 	return &externalapi.DomainTransaction{
 		Version:      msgTx.Version,
 		Inputs:       transactionInputs,
@@ -127,8 +121,8 @@ func MsgTxToDomainTransaction(msgTx *MsgTx) *externalapi.DomainTransaction {
 		LockTime:     msgTx.LockTime,
 		SubnetworkID: msgTx.SubnetworkID,
 		Gas:          msgTx.Gas,
-		PayloadHash:  msgTx.PayloadHash,
-		Payload:      payload,
+		PayloadHash:  *msgTx.PayloadHash,
+		Payload:      msgTx.Payload,
 	}
 }
 

app/appmessage/message.go

@@ -34,27 +34,24 @@ const (
 	CmdVerAck
 	CmdRequestAddresses
 	CmdAddresses
-	CmdRequestHeaders
+	CmdRequestIBDBlocks
 	CmdBlock
 	CmdTx
 	CmdPing
 	CmdPong
 	CmdRequestBlockLocator
 	CmdBlockLocator
+	CmdSelectedTip
+	CmdRequestSelectedTip
 	CmdInvRelayBlock
 	CmdRequestRelayBlocks
 	CmdInvTransaction
 	CmdRequestTransactions
 	CmdIBDBlock
-	CmdDoneHeaders
+	CmdRequestNextIBDBlocks
+	CmdDoneIBDBlocks
 	CmdTransactionNotFound
 	CmdReject
-	CmdHeader
-	CmdRequestNextHeaders
-	CmdRequestIBDRootUTXOSetAndBlock
-	CmdIBDRootUTXOSetAndBlock
-	CmdRequestIBDBlocks
-	CmdIBDRootNotFound
 
 	// rpc
 	CmdGetCurrentNetworkRequestMessage
@@ -110,31 +107,28 @@ const (
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
 var ProtocolMessageCommandToString = map[MessageCommand]string{
-	CmdVersion:                       "Version",
-	CmdVerAck:                        "VerAck",
-	CmdRequestAddresses:              "RequestAddresses",
-	CmdAddresses:                     "Addresses",
-	CmdRequestHeaders:                "RequestHeaders",
-	CmdBlock:                         "Block",
-	CmdTx:                            "Tx",
-	CmdPing:                          "Ping",
-	CmdPong:                          "Pong",
-	CmdRequestBlockLocator:           "RequestBlockLocator",
-	CmdBlockLocator:                  "BlockLocator",
-	CmdInvRelayBlock:                 "InvRelayBlock",
-	CmdRequestRelayBlocks:            "RequestRelayBlocks",
-	CmdInvTransaction:                "InvTransaction",
-	CmdRequestTransactions:           "RequestTransactions",
-	CmdIBDBlock:                      "IBDBlock",
-	CmdDoneHeaders:                   "DoneHeaders",
-	CmdTransactionNotFound:           "TransactionNotFound",
-	CmdReject:                        "Reject",
-	CmdHeader:                        "Header",
-	CmdRequestNextHeaders:            "RequestNextHeaders",
-	CmdRequestIBDRootUTXOSetAndBlock: "RequestPruningUTXOSetAndBlock",
-	CmdIBDRootUTXOSetAndBlock:        "IBDRootUTXOSetAndBlock",
-	CmdRequestIBDBlocks:              "RequestIBDBlocks",
-	CmdIBDRootNotFound:               "IBDRootNotFound",
+	CmdVersion:              "Version",
+	CmdVerAck:               "VerAck",
+	CmdRequestAddresses:     "RequestAddresses",
+	CmdAddresses:            "Addresses",
+	CmdRequestIBDBlocks:     "RequestBlocks",
+	CmdBlock:                "Block",
+	CmdTx:                   "Tx",
+	CmdPing:                 "Ping",
+	CmdPong:                 "Pong",
+	CmdRequestBlockLocator:  "RequestBlockLocator",
+	CmdBlockLocator:         "BlockLocator",
+	CmdSelectedTip:          "SelectedTip",
+	CmdRequestSelectedTip:   "RequestSelectedTip",
+	CmdInvRelayBlock:        "InvRelayBlock",
+	CmdRequestRelayBlocks:   "RequestRelayBlocks",
+	CmdInvTransaction:       "InvTransaction",
+	CmdRequestTransactions:  "RequestTransactions",
+	CmdIBDBlock:             "IBDBlock",
+	CmdRequestNextIBDBlocks: "RequestNextIBDBlocks",
+	CmdDoneIBDBlocks:        "DoneIBDBlocks",
+	CmdTransactionNotFound:  "TransactionNotFound",
+	CmdReject:               "Reject",
 }
 
 // RPCMessageCommandToString maps all MessageCommands to their string representation

app/appmessage/p2p_blockheader.go

@@ -7,7 +7,7 @@ package appmessage
 import (
 	"math"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/util/mstime"
@@ -31,11 +31,9 @@ const MaxNumParentBlocks = 255
 // BaseBlockHeaderPayload + up to MaxNumParentBlocks hashes of parent blocks
 const MaxBlockHeaderPayload = BaseBlockHeaderPayload + (MaxNumParentBlocks * externalapi.DomainHashSize)
 
-// MsgBlockHeader defines information about a block and is used in the kaspa
+// BlockHeader defines information about a block and is used in the kaspa
 // block (MsgBlock) and headers (MsgHeader) messages.
-type MsgBlockHeader struct {
-	baseMessage
-
+type BlockHeader struct {
 	// Version of the block. This is not the same as the protocol version.
 	Version int32
 
@@ -63,7 +61,7 @@ type MsgBlockHeader struct {
 }
 
 // NumParentBlocks return the number of entries in ParentHashes
-func (h *MsgBlockHeader) NumParentBlocks() byte {
+func (h *BlockHeader) NumParentBlocks() byte {
 	numParents := len(h.ParentHashes)
 	if numParents > math.MaxUint8 {
 		panic(errors.Errorf("number of parents is %d, which is more than one byte can fit", numParents))
@@ -72,30 +70,24 @@ func (h *MsgBlockHeader) NumParentBlocks() byte {
 }
 
 // BlockHash computes the block identifier hash for the given block header.
-func (h *MsgBlockHeader) BlockHash() *externalapi.DomainHash {
-	return consensushashing.HeaderHash(BlockHeaderToDomainBlockHeader(h))
+func (h *BlockHeader) BlockHash() *externalapi.DomainHash {
+	return consensusserialization.HeaderHash(BlockHeaderToDomainBlockHeader(h))
 }
 
 // IsGenesis returns true iff this block is a genesis block
-func (h *MsgBlockHeader) IsGenesis() bool {
+func (h *BlockHeader) IsGenesis() bool {
 	return h.NumParentBlocks() == 0
 }
 
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (h *MsgBlockHeader) Command() MessageCommand {
-	return CmdHeader
-}
-
-// NewBlockHeader returns a new MsgBlockHeader using the provided version, previous
+// NewBlockHeader returns a new BlockHeader using the provided version, previous
 // block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
 // block with defaults or calclulated values for the remaining fields.
 func NewBlockHeader(version int32, parentHashes []*externalapi.DomainHash, hashMerkleRoot *externalapi.DomainHash,
-	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce uint64) *MsgBlockHeader {
+	acceptedIDMerkleRoot *externalapi.DomainHash, utxoCommitment *externalapi.DomainHash, bits uint32, nonce uint64) *BlockHeader {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
-	return &MsgBlockHeader{
+	return &BlockHeader{
 		Version:              version,
 		ParentHashes:         parentHashes,
 		HashMerkleRoot:       hashMerkleRoot,

app/appmessage/p2p_blockheader_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/kaspanet/kaspad/util/random"
 )
 
-// TestBlockHeader tests the MsgBlockHeader API.
+// TestBlockHeader tests the BlockHeader API.
 func TestBlockHeader(t *testing.T) {
 	nonce, err := random.Uint64()
 	if err != nil {
@@ -52,7 +52,7 @@ func TestIsGenesis(t *testing.T) {
 	bits := uint32(0x1d00ffff)
 	timestamp := mstime.UnixMilliseconds(0x495fab29000)
 
-	baseBlockHdr := &MsgBlockHeader{
+	baseBlockHdr := &BlockHeader{
 		Version:        1,
 		ParentHashes:   []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
 		HashMerkleRoot: mainnetGenesisMerkleRoot,
@@ -60,7 +60,7 @@ func TestIsGenesis(t *testing.T) {
 		Bits:           bits,
 		Nonce:          nonce,
 	}
-	genesisBlockHdr := &MsgBlockHeader{
+	genesisBlockHdr := &BlockHeader{
 		Version:        1,
 		ParentHashes:   []*externalapi.DomainHash{},
 		HashMerkleRoot: mainnetGenesisMerkleRoot,
@@ -70,8 +70,8 @@ func TestIsGenesis(t *testing.T) {
 	}
 
 	tests := []struct {
-		in        *MsgBlockHeader // Block header to encode
-		isGenesis bool            // Expected result for call of .IsGenesis
+		in        *BlockHeader // Block header to encode
+		isGenesis bool         // Expected result for call of .IsGenesis
 	}{
 		{genesisBlockHdr, true},
 		{baseBlockHdr, false},
@@ -81,7 +81,7 @@ func TestIsGenesis(t *testing.T) {
 	for i, test := range tests {
 		isGenesis := test.in.IsGenesis()
 		if isGenesis != test.isGenesis {
-			t.Errorf("MsgBlockHeader.IsGenesis: #%d got: %t, want: %t",
+			t.Errorf("BlockHeader.IsGenesis: #%d got: %t, want: %t",
 				i, isGenesis, test.isGenesis)
 		}
 	}

app/appmessage/p2p_ibdrootnotfound.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgIBDRootNotFound implements the Message interface and represents a kaspa
-// IBDRootNotFound message. It is used to notify the IBD root that was requested
-// by other peer was not found.
-//
-// This message has no payload.
-type MsgIBDRootNotFound struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgIBDRootNotFound) Command() MessageCommand {
-	return CmdIBDRootNotFound
-}
-
-// NewMsgIBDRootNotFound returns a new kaspa IBDRootNotFound message that conforms to the
-// Message interface.
-func NewMsgIBDRootNotFound() *MsgDoneHeaders {
-	return &MsgDoneHeaders{}
-}

app/appmessage/p2p_msgaddresses.go

@@ -4,15 +4,59 @@
 
 package appmessage
 
+import (
+	"fmt"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
 // MaxAddressesPerMsg is the maximum number of addresses that can be in a single
 // kaspa Addresses message (MsgAddresses).
 const MaxAddressesPerMsg = 1000
 
 // MsgAddresses implements the Message interface and represents a kaspa
-// Addresses message.
+// Addresses message. It is used to provide a list of known active peers on the
+// network. An active peer is considered one that has transmitted a message
+// within the last 3 hours. Nodes which have not transmitted in that time
+// frame should be forgotten. Each message is limited to a maximum number of
+// addresses, which is currently 1000. As a result, multiple messages must
+// be used to relay the full list.
+//
+// Use the AddAddress function to build up the list of known addresses when
+// sending an Addresses message to another peer.
 type MsgAddresses struct {
 	baseMessage
-	AddressList []*NetAddress
+	IncludeAllSubnetworks bool
+	SubnetworkID          *externalapi.DomainSubnetworkID
+	AddrList              []*NetAddress
+}
+
+// AddAddress adds a known active peer to the message.
+func (msg *MsgAddresses) AddAddress(na *NetAddress) error {
+	if len(msg.AddrList)+1 > MaxAddressesPerMsg {
+		str := fmt.Sprintf("too many addresses in message [max %d]",
+			MaxAddressesPerMsg)
+		return messageError("MsgAddresses.AddAddress", str)
+	}
+
+	msg.AddrList = append(msg.AddrList, na)
+	return nil
+}
+
+// AddAddresses adds multiple known active peers to the message.
+func (msg *MsgAddresses) AddAddresses(netAddrs ...*NetAddress) error {
+	for _, na := range netAddrs {
+		err := msg.AddAddress(na)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ClearAddresses removes all addresses from the message.
+func (msg *MsgAddresses) ClearAddresses() {
+	msg.AddrList = []*NetAddress{}
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,8 +67,10 @@ func (msg *MsgAddresses) Command() MessageCommand {
 
 // NewMsgAddresses returns a new kaspa Addresses message that conforms to the
 // Message interface. See MsgAddresses for details.
-func NewMsgAddresses(addressList []*NetAddress) *MsgAddresses {
+func NewMsgAddresses(includeAllSubnetworks bool, subnetworkID *externalapi.DomainSubnetworkID) *MsgAddresses {
 	return &MsgAddresses{
-		AddressList: addressList,
+		IncludeAllSubnetworks: includeAllSubnetworks,
+		SubnetworkID:          subnetworkID,
+		AddrList:              make([]*NetAddress, 0, MaxAddressesPerMsg),
 	}
 }

app/appmessage/p2p_msgaddresses_test.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"net"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestAddresses tests the MsgAddresses API.
+func TestAddresses(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(3)
+	msg := NewMsgAddresses(false, nil)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure NetAddresses are added properly.
+	tcpAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
+	na := NewNetAddress(tcpAddr, SFNodeNetwork)
+	err := msg.AddAddress(na)
+	if err != nil {
+		t.Errorf("AddAddress: %v", err)
+	}
+	if msg.AddrList[0] != na {
+		t.Errorf("AddAddress: wrong address added - got %v, want %v",
+			spew.Sprint(msg.AddrList[0]), spew.Sprint(na))
+	}
+
+	// Ensure the address list is cleared properly.
+	msg.ClearAddresses()
+	if len(msg.AddrList) != 0 {
+		t.Errorf("ClearAddresses: address list is not empty - "+
+			"got %v [%v], want %v", len(msg.AddrList),
+			spew.Sprint(msg.AddrList[0]), 0)
+	}
+
+	// Ensure adding more than the max allowed addresses per message returns
+	// error.
+	for i := 0; i < MaxAddressesPerMsg+1; i++ {
+		err = msg.AddAddress(na)
+	}
+	if err == nil {
+		t.Errorf("AddAddress: expected error on too many addresses " +
+			"not received")
+	}
+	err = msg.AddAddresses(na)
+	if err == nil {
+		t.Errorf("AddAddresses: expected error on too many addresses " +
+			"not received")
+	}
+}

app/appmessage/p2p_msgblock.go

@@ -40,7 +40,7 @@ type TxLoc struct {
 // response to a getdata message (MsgGetData) for a given block hash.
 type MsgBlock struct {
 	baseMessage
-	Header       MsgBlockHeader
+	Header       BlockHeader
 	Transactions []*MsgTx
 }
 
@@ -79,7 +79,7 @@ func (msg *MsgBlock) ConvertToPartial(subnetworkID *externalapi.DomainSubnetwork
 
 // NewMsgBlock returns a new kaspa block message that conforms to the
 // Message interface. See MsgBlock for details.
-func NewMsgBlock(blockHeader *MsgBlockHeader) *MsgBlock {
+func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
 	return &MsgBlock{
 		Header:       *blockHeader,
 		Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),

app/appmessage/p2p_msgblock_test.go

@@ -129,7 +129,7 @@ func TestConvertToPartial(t *testing.T) {
 
 // blockOne is the first block in the mainnet block DAG.
 var blockOne = MsgBlock{
-	Header: MsgBlockHeader{
+	Header: BlockHeader{
 		Version:              1,
 		ParentHashes:         []*externalapi.DomainHash{mainnetGenesisHash, simnetGenesisHash},
 		HashMerkleRoot:       mainnetGenesisMerkleRoot,

app/appmessage/p2p_msgdoneheaders.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgDoneHeaders implements the Message interface and represents a kaspa
-// DoneHeaders message. It is used to notify the IBD syncing peer that the
-// syncer sent all the requested headers.
-//
-// This message has no payload.
-type MsgDoneHeaders struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgDoneHeaders) Command() MessageCommand {
-	return CmdDoneHeaders
-}
-
-// NewMsgDoneHeaders returns a new kaspa DoneIBDBlocks message that conforms to the
-// Message interface.
-func NewMsgDoneHeaders() *MsgDoneHeaders {
-	return &MsgDoneHeaders{}
-}

app/appmessage/p2p_msgdoneibdblocks.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgDoneIBDBlocks implements the Message interface and represents a kaspa
+// DoneIBDBlocks message. It is used to notify the IBD syncing peer that the
+// syncer sent all the requested blocks.
+//
+// This message has no payload.
+type MsgDoneIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgDoneIBDBlocks) Command() MessageCommand {
+	return CmdDoneIBDBlocks
+}
+
+// NewMsgDoneIBDBlocks returns a new kaspa DoneIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgDoneIBDBlocks() *MsgDoneIBDBlocks {
+	return &MsgDoneIBDBlocks{}
+}

app/appmessage/p2p_msgibdblock_test.go

@@ -25,7 +25,7 @@ func TestIBDBlock(t *testing.T) {
 	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
-	wantCmd := MessageCommand(15)
+	wantCmd := MessageCommand(17)
 	msg := NewMsgIBDBlock(NewMsgBlock(bh))
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",

app/appmessage/p2p_msgibdrootutxosetandblock.go

@@ -1,23 +0,0 @@
-package appmessage
-
-// MsgIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
-// IBDRootUTXOSetAndBlock message. It is used to answer RequestIBDRootUTXOSetAndBlock messages.
-type MsgIBDRootUTXOSetAndBlock struct {
-	baseMessage
-	UTXOSet []byte
-	Block   *MsgBlock
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgIBDRootUTXOSetAndBlock) Command() MessageCommand {
-	return CmdIBDRootUTXOSetAndBlock
-}
-
-// NewMsgIBDRootUTXOSetAndBlock returns a new MsgIBDRootUTXOSetAndBlock.
-func NewMsgIBDRootUTXOSetAndBlock(utxoSet []byte, block *MsgBlock) *MsgIBDRootUTXOSetAndBlock {
-	return &MsgIBDRootUTXOSetAndBlock{
-		UTXOSet: utxoSet,
-		Block:   block,
-	}
-}

app/appmessage/p2p_msgrequestblocklocator.go

@@ -5,14 +5,13 @@ import (
 )
 
 // MsgRequestBlockLocator implements the Message interface and represents a kaspa
-// RequestBlockLocator message. It is used to request a block locator between low
-// and high hash.
+// RequestBlockLocator message. It is used to request a block locator between high
+// and low hash.
 // The locator is returned via a locator message (MsgBlockLocator).
 type MsgRequestBlockLocator struct {
 	baseMessage
-	LowHash  *externalapi.DomainHash
 	HighHash *externalapi.DomainHash
-	Limit    uint32
+	LowHash  *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -24,10 +23,9 @@ func (msg *MsgRequestBlockLocator) Command() MessageCommand {
 // NewMsgRequestBlockLocator returns a new RequestBlockLocator message that conforms to the
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
-func NewMsgRequestBlockLocator(lowHash, highHash *externalapi.DomainHash, limit uint32) *MsgRequestBlockLocator {
+func NewMsgRequestBlockLocator(highHash, lowHash *externalapi.DomainHash) *MsgRequestBlockLocator {
 	return &MsgRequestBlockLocator{
-		LowHash:  lowHash,
 		HighHash: highHash,
-		Limit:    limit,
+		LowHash:  lowHash,
 	}
 }

app/appmessage/p2p_msgrequestblocklocator_test.go

@@ -18,7 +18,7 @@ func TestRequestBlockLocator(t *testing.T) {
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(9)
-	msg := NewMsgRequestBlockLocator(highHash, &externalapi.DomainHash{}, 0)
+	msg := NewMsgRequestBlockLocator(highHash, &externalapi.DomainHash{})
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgRequestBlockLocator: wrong command - got %v want %v",
 			cmd, wantCmd)

app/appmessage/p2p_msgrequestheaders.go

@@ -1,34 +0,0 @@
-// Copyright (c) 2013-2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgRequestHeaders implements the Message interface and represents a kaspa
-// RequestHeaders message. It is used to request a list of blocks starting after the
-// low hash and until the high hash.
-type MsgRequestHeaders struct {
-	baseMessage
-	LowHash  *externalapi.DomainHash
-	HighHash *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestHeaders) Command() MessageCommand {
-	return CmdRequestHeaders
-}
-
-// NewMsgRequstHeaders returns a new kaspa RequestHeaders message that conforms to the
-// Message interface using the passed parameters and defaults for the remaining
-// fields.
-func NewMsgRequstHeaders(lowHash, highHash *externalapi.DomainHash) *MsgRequestHeaders {
-	return &MsgRequestHeaders{
-		LowHash:  lowHash,
-		HighHash: highHash,
-	}
-}

app/appmessage/p2p_msgrequestibdblocks.go

@@ -1,3 +1,7 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
 package appmessage
 
 import (
@@ -5,11 +9,12 @@ import (
 )
 
 // MsgRequestIBDBlocks implements the Message interface and represents a kaspa
-// RequestIBDBlocks message. It is used to request blocks as part of the IBD
-// protocol.
+// RequestIBDBlocks message. It is used to request a list of blocks starting after the
+// low hash and until the high hash.
 type MsgRequestIBDBlocks struct {
 	baseMessage
-	Hashes []*externalapi.DomainHash
+	LowHash  *externalapi.DomainHash
+	HighHash *externalapi.DomainHash
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -18,9 +23,12 @@ func (msg *MsgRequestIBDBlocks) Command() MessageCommand {
 	return CmdRequestIBDBlocks
 }
 
-// NewMsgRequestIBDBlocks returns a new MsgRequestIBDBlocks.
-func NewMsgRequestIBDBlocks(hashes []*externalapi.DomainHash) *MsgRequestIBDBlocks {
+// NewMsgRequstIBDBlocks returns a new kaspa RequestIBDBlocks message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequstIBDBlocks(lowHash, highHash *externalapi.DomainHash) *MsgRequestIBDBlocks {
 	return &MsgRequestIBDBlocks{
-		Hashes: hashes,
+		LowHash:  lowHash,
+		HighHash: highHash,
 	}
 }

app/appmessage/p2p_msgrequestibdblocks_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 )
 
-// TestRequstIBDBlocks tests the MsgRequestHeaders API.
+// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
 func TestRequstIBDBlocks(t *testing.T) {
 	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
 	lowHash, err := hashes.FromString(hashStr)
@@ -25,16 +25,16 @@ func TestRequstIBDBlocks(t *testing.T) {
 	}
 
 	// Ensure we get the same data back out.
-	msg := NewMsgRequstHeaders(lowHash, highHash)
+	msg := NewMsgRequstIBDBlocks(lowHash, highHash)
 	if *msg.HighHash != *highHash {
-		t.Errorf("NewMsgRequstHeaders: wrong high hash - got %v, want %v",
+		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
 			msg.HighHash, highHash)
 	}
 
 	// Ensure the command is expected value.
 	wantCmd := MessageCommand(4)
 	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgRequstHeaders: wrong command - got %v want %v",
+		t.Errorf("NewMsgRequstIBDBlocks: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}
 }

app/appmessage/p2p_msgrequestibdrootutxosetandblock.go

@@ -1,26 +0,0 @@
-package appmessage
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// MsgRequestIBDRootUTXOSetAndBlock implements the Message interface and represents a kaspa
-// RequestIBDRootUTXOSetAndBlock message. It is used to request the UTXO set and block body
-// of the IBD root block.
-type MsgRequestIBDRootUTXOSetAndBlock struct {
-	baseMessage
-	IBDRoot *externalapi.DomainHash
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestIBDRootUTXOSetAndBlock) Command() MessageCommand {
-	return CmdRequestIBDRootUTXOSetAndBlock
-}
-
-// NewMsgRequestIBDRootUTXOSetAndBlock returns a new MsgRequestIBDRootUTXOSetAndBlock.
-func NewMsgRequestIBDRootUTXOSetAndBlock(ibdRoot *externalapi.DomainHash) *MsgRequestIBDRootUTXOSetAndBlock {
-	return &MsgRequestIBDRootUTXOSetAndBlock{
-		IBDRoot: ibdRoot,
-	}
-}

app/appmessage/p2p_msgrequestnextheaders.go

@@ -1,22 +0,0 @@
-package appmessage
-
-// MsgRequestNextHeaders implements the Message interface and represents a kaspa
-// RequestNextHeaders message. It is used to notify the IBD syncer peer to send
-// more headers.
-//
-// This message has no payload.
-type MsgRequestNextHeaders struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message. This is part
-// of the Message interface implementation.
-func (msg *MsgRequestNextHeaders) Command() MessageCommand {
-	return CmdRequestNextHeaders
-}
-
-// NewMsgRequestNextHeaders returns a new kaspa RequestNextHeaders message that conforms to the
-// Message interface.
-func NewMsgRequestNextHeaders() *MsgRequestNextHeaders {
-	return &MsgRequestNextHeaders{}
-}

app/appmessage/p2p_msgrequestnextibdblocks.go

@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgRequestNextIBDBlocks implements the Message interface and represents a kaspa
+// RequestNextIBDBlocks message. It is used to notify the IBD syncer peer to send
+// more blocks.
+//
+// This message has no payload.
+type MsgRequestNextIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestNextIBDBlocks) Command() MessageCommand {
+	return CmdRequestNextIBDBlocks
+}
+
+// NewMsgRequestNextIBDBlocks returns a new kaspa RequestNextIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgRequestNextIBDBlocks() *MsgRequestNextIBDBlocks {
+	return &MsgRequestNextIBDBlocks{}
+}

app/appmessage/p2p_msgrequestrelayblocks.go

@@ -4,9 +4,9 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
-// MaxRequestRelayBlocksHashes is the maximum number of hashes that can
+// MsgRequestRelayBlocksHashes is the maximum number of hashes that can
 // be in a single RequestRelayBlocks message.
-const MaxRequestRelayBlocksHashes = MaxInvPerMsg
+const MsgRequestRelayBlocksHashes = MaxInvPerMsg
 
 // MsgRequestRelayBlocks implements the Message interface and represents a kaspa
 // RequestRelayBlocks message. It is used to request blocks as part of the block

app/appmessage/p2p_msgrequestselectedtip.go

@@ -0,0 +1,21 @@
+package appmessage
+
+// MsgRequestSelectedTip implements the Message interface and represents a kaspa
+// RequestSelectedTip message. It is used to request the selected tip of another peer.
+//
+// This message has no payload.
+type MsgRequestSelectedTip struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestSelectedTip) Command() MessageCommand {
+	return CmdRequestSelectedTip
+}
+
+// NewMsgRequestSelectedTip returns a new kaspa RequestSelectedTip message that conforms to the
+// Message interface.
+func NewMsgRequestSelectedTip() *MsgRequestSelectedTip {
+	return &MsgRequestSelectedTip{}
+}

app/appmessage/p2p_msgrequestselectedtip_test.go

@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestRequestSelectedTip tests the MsgRequestSelectedTip API.
+func TestRequestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(12)
+	msg := NewMsgRequestSelectedTip()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/p2p_msgselectedtip.go

@@ -0,0 +1,28 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// MsgSelectedTip implements the Message interface and represents a kaspa
+// selectedtip message. It is used to answer getseltip messages and tell
+// the asking peer what is the selected tip of this peer.
+type MsgSelectedTip struct {
+	baseMessage
+	// The selected tip hash of the generator of the message.
+	SelectedTipHash *externalapi.DomainHash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgSelectedTip) Command() MessageCommand {
+	return CmdSelectedTip
+}
+
+// NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
+// Message interface.
+func NewMsgSelectedTip(selectedTipHash *externalapi.DomainHash) *MsgSelectedTip {
+	return &MsgSelectedTip{
+		SelectedTipHash: selectedTipHash,
+	}
+}

app/appmessage/p2p_msgselectedtip_test.go

@@ -0,0 +1,18 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// TestSelectedTip tests the MsgSelectedTip API.
+func TestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(11)
+	msg := NewMsgSelectedTip(&externalapi.DomainHash{})
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}

app/appmessage/p2p_msgtx.go

@@ -6,11 +6,10 @@ package appmessage
 
 import (
 	"encoding/binary"
+	"math"
 	"strconv"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
-
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 
@@ -20,10 +19,38 @@ import (
 )
 
 const (
+	// TxVersion is the current latest supported transaction version.
+	TxVersion = 1
+
+	// MaxTxInSequenceNum is the maximum sequence number the sequence field
+	// of a transaction input can be.
+	MaxTxInSequenceNum uint64 = math.MaxUint64
+
 	// MaxPrevOutIndex is the maximum index the index field of a previous
 	// outpoint can be.
 	MaxPrevOutIndex uint32 = 0xffffffff
 
+	// SequenceLockTimeDisabled is a flag that if set on a transaction
+	// input's sequence number, the sequence number will not be interpreted
+	// as a relative locktime.
+	SequenceLockTimeDisabled = 1 << 31
+
+	// SequenceLockTimeIsSeconds is a flag that if set on a transaction
+	// input's sequence number, the relative locktime has units of 512
+	// seconds.
+	SequenceLockTimeIsSeconds = 1 << 22
+
+	// SequenceLockTimeMask is a mask that extracts the relative locktime
+	// when masked against the transaction input sequence number.
+	SequenceLockTimeMask = 0x0000ffff
+
+	// SequenceLockTimeGranularity is the defined time based granularity
+	// for milliseconds-based relative time locks. When converting from milliseconds
+	// to a sequence number, the value is right shifted by this amount,
+	// therefore the granularity of relative time locks in 524288 or 2^19
+	// seconds. Enforced relative lock times are multiples of 524288 milliseconds.
+	SequenceLockTimeGranularity = 19
+
 	// defaultTxInOutAlloc is the default size used for the backing array for
 	// transaction inputs and outputs. The array will dynamically grow as needed,
 	// but this figure is intended to provide enough space for the number of
@@ -103,7 +130,7 @@ func NewTxIn(prevOut *Outpoint, signatureScript []byte) *TxIn {
 	return &TxIn{
 		PreviousOutpoint: *prevOut,
 		SignatureScript:  signatureScript,
-		Sequence:         constants.MaxTxInSequenceNum,
+		Sequence:         MaxTxInSequenceNum,
 	}
 }
 
@@ -136,7 +163,7 @@ type MsgTx struct {
 	LockTime     uint64
 	SubnetworkID externalapi.DomainSubnetworkID
 	Gas          uint64
-	PayloadHash  externalapi.DomainHash
+	PayloadHash  *externalapi.DomainHash
 	Payload      []byte
 }
 
@@ -162,12 +189,12 @@ func (msg *MsgTx) IsCoinBase() bool {
 
 // TxHash generates the Hash for the transaction.
 func (msg *MsgTx) TxHash() *externalapi.DomainHash {
-	return consensushashing.TransactionHash(MsgTxToDomainTransaction(msg))
+	return consensusserialization.TransactionHash(MsgTxToDomainTransaction(msg))
 }
 
 // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
 func (msg *MsgTx) TxID() *externalapi.DomainTransactionID {
-	return consensushashing.TransactionID(MsgTxToDomainTransaction(msg))
+	return consensusserialization.TransactionID(MsgTxToDomainTransaction(msg))
 }
 
 // Copy creates a deep copy of a transaction so that the original does not get
@@ -283,9 +310,9 @@ func newMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, subnetworkID *externa
 		txOut = make([]*TxOut, 0, defaultTxInOutAlloc)
 	}
 
-	var payloadHash externalapi.DomainHash
+	var payloadHash *externalapi.DomainHash
 	if *subnetworkID != subnetworks.SubnetworkIDNative {
-		payloadHash = *hashes.HashData(payload)
+		payloadHash = hashes.HashData(payload)
 	}
 
 	return &MsgTx{

app/appmessage/p2p_msgversion.go

@@ -53,6 +53,9 @@ type MsgVersion struct {
 	// on the appmessage. This has a max length of MaxUserAgentLen.
 	UserAgent string
 
+	// The selected tip hash of the generator of the version message.
+	SelectedTipHash *externalapi.DomainHash
+
 	// Don't announce transactions to peer.
 	DisableRelayTx bool
 
@@ -82,7 +85,7 @@ func (msg *MsgVersion) Command() MessageCommand {
 // Message interface using the passed parameters and defaults for the remaining
 // fields.
 func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
-	subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
+	selectedTipHash *externalapi.DomainHash, subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
@@ -94,6 +97,7 @@ func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
 		Address:         addr,
 		ID:              id,
 		UserAgent:       DefaultUserAgent,
+		SelectedTipHash: selectedTipHash,
 		DisableRelayTx:  false,
 		SubnetworkID:    subnetworkID,
 	}

app/appmessage/p2p_msgversion_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
@@ -18,6 +19,7 @@ func TestVersion(t *testing.T) {
 	pver := ProtocolVersion
 
 	// Create version message data.
+	selectedTipHash := &externalapi.DomainHash{12, 34}
 	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
 	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
 	generatedID, err := id.GenerateID()
@@ -26,7 +28,7 @@ func TestVersion(t *testing.T) {
 	}
 
 	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, "mainnet", nil)
+	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
 	if msg.ProtocolVersion != pver {
 		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
 			msg.ProtocolVersion, pver)
@@ -43,6 +45,10 @@ func TestVersion(t *testing.T) {
 		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
 			msg.UserAgent, DefaultUserAgent)
 	}
+	if *msg.SelectedTipHash != *selectedTipHash {
+		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
+			msg.SelectedTipHash, selectedTipHash)
+	}
 	if msg.DisableRelayTx {
 		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
 			"default - got %v, want %v", msg.DisableRelayTx, false)

app/appmessage/rpc_get_block.go

@@ -58,7 +58,6 @@ type BlockVerboseData struct {
 	Difficulty             float64
 	ParentHashes           []string
 	SelectedParentHash     string
-	BlueScore              uint64
 }
 
 // TransactionVerboseData holds verbose data about a transaction

app/appmessage/rpc_get_block_count.go

@@ -1,7 +1,5 @@
 package appmessage
 
-import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-
 // GetBlockCountRequestMessage is an appmessage corresponding to
 // its respective RPC message
 type GetBlockCountRequestMessage struct {
@@ -22,8 +20,7 @@ func NewGetBlockCountRequestMessage() *GetBlockCountRequestMessage {
 // its respective RPC message
 type GetBlockCountResponseMessage struct {
 	baseMessage
-	BlockCount  uint64
-	HeaderCount uint64
+	BlockCount uint64
 
 	Error *RPCError
 }
@@ -34,9 +31,8 @@ func (msg *GetBlockCountResponseMessage) Command() MessageCommand {
 }
 
 // NewGetBlockCountResponseMessage returns a instance of the message
-func NewGetBlockCountResponseMessage(syncInfo *externalapi.SyncInfo) *GetBlockCountResponseMessage {
+func NewGetBlockCountResponseMessage(blockCount uint64) *GetBlockCountResponseMessage {
 	return &GetBlockCountResponseMessage{
-		BlockCount:  syncInfo.BlockCount,
-		HeaderCount: syncInfo.HeaderCount,
+		BlockCount: blockCount,
 	}
 }

app/appmessage/rpc_get_block_dag_info.go

@@ -22,7 +22,6 @@ type GetBlockDAGInfoResponseMessage struct {
 	baseMessage
 	NetworkName         string
 	BlockCount          uint64
-	HeaderCount         uint64
 	TipHashes           []string
 	VirtualParentHashes []string
 	Difficulty          float64

app/appmessage/rpc_get_connected_peer_info.go

@@ -41,6 +41,8 @@ type GetConnectedPeerInfoMessage struct {
 	ID                        string
 	Address                   string
 	LastPingDuration          int64
+	SelectedTipHash           string
+	IsSyncNode                bool
 	IsOutbound                bool
 	TimeOffset                int64
 	UserAgent                 string

app/appmessage/rpc_get_peer_addresses.go

@@ -20,8 +20,7 @@ func NewGetPeerAddressesRequestMessage() *GetPeerAddressesRequestMessage {
 // its respective RPC message
 type GetPeerAddressesResponseMessage struct {
 	baseMessage
-	Addresses       []*GetPeerAddressesKnownAddressMessage
-	BannedAddresses []*GetPeerAddressesKnownAddressMessage
+	Addresses []*GetPeerAddressesKnownAddressMessage
 
 	Error *RPCError
 }
@@ -32,10 +31,9 @@ func (msg *GetPeerAddressesResponseMessage) Command() MessageCommand {
 }
 
 // NewGetPeerAddressesResponseMessage returns a instance of the message
-func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage, bannedAddresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
+func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
 	return &GetPeerAddressesResponseMessage{
-		Addresses:       addresses,
-		BannedAddresses: bannedAddresses,
+		Addresses: addresses,
 	}
 }
 

app/component_manager.go

@@ -70,6 +70,11 @@ func (a *ComponentManager) Stop() {
 		log.Errorf("Error stopping the net adapter: %+v", err)
 	}
 
+	err = a.addressManager.Stop()
+	if err != nil {
+		log.Errorf("Error stopping address manager: %s", err)
+	}
+
 	return
 }
 
@@ -87,12 +92,10 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 	if err != nil {
 		return nil, err
 	}
-
-	addressManager, err := addressmanager.New(addressmanager.NewConfig(cfg))
+	addressManager, err := addressmanager.New(cfg, db)
 	if err != nil {
 		return nil, err
 	}
-
 	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
 	if err != nil {
 		return nil, err
@@ -138,12 +141,14 @@ func (a *ComponentManager) maybeSeedFromDNS() {
 				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
 				// IPs of nodes and not its own IP, we can not know real IP of
 				// source. So we'll take first returned address as source.
-				a.addressManager.AddAddresses(addresses...)
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
 			})
+	}
 
+	if a.cfg.GRPCSeed != "" {
 		dnsseed.SeedFromGRPC(a.cfg.NetParams(), a.cfg.GRPCSeed, appmessage.SFNodeNetwork, false, nil,
 			func(addresses []*appmessage.NetAddress) {
-				a.addressManager.AddAddresses(addresses...)
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
 			})
 	}
 }

app/protocol/blocklogger/blocklogger.go

@@ -22,7 +22,7 @@ var (
 // LogBlock logs a new block blue score as an information message
 // to show progress to the user. In order to prevent spam, it limits logging to
 // one message every 10 seconds with duration and totals included.
-func LogBlock(block *externalapi.DomainBlock) {
+func LogBlock(block *externalapi.DomainBlock) error {
 	mtx.Lock()
 	defer mtx.Unlock()
 
@@ -32,7 +32,7 @@ func LogBlock(block *externalapi.DomainBlock) {
 	now := mstime.Now()
 	duration := now.Sub(lastBlockLogTime)
 	if duration < time.Second*10 {
-		return
+		return nil
 	}
 
 	// Truncate the duration to 10s of milliseconds.
@@ -55,4 +55,5 @@ func LogBlock(block *externalapi.DomainBlock) {
 	receivedLogBlocks = 0
 	receivedLogTx = 0
 	lastBlockLogTime = now
+	return nil
 }

app/protocol/flowcontext/blocks.go

@@ -3,12 +3,8 @@ package flowcontext
 import (
 	"sync/atomic"
 
-	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/pkg/errors"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
@@ -18,29 +14,12 @@ import (
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
 func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
-	hash := consensushashing.BlockHash(block)
-	log.Debugf("OnNewBlock start for block %s", hash)
-	defer log.Debugf("OnNewBlock end for block %s", hash)
-	unorphanedBlocks, err := f.UnorphanBlocks(block)
-	if err != nil {
-		return err
-	}
+	f.Domain().MiningManager().HandleNewBlockTransactions(block.Transactions)
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphanedBlocks))
-
-	newBlocks := append([]*externalapi.DomainBlock{block}, unorphanedBlocks...)
-	for _, newBlock := range newBlocks {
-		blocklogger.LogBlock(block)
-
-		log.Tracef("OnNewBlock: passing block %s transactions to mining manager", hash)
-		_ = f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
-
-		if f.onBlockAddedToDAGHandler != nil {
-			log.Tracef("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
-			err := f.onBlockAddedToDAGHandler(newBlock)
-			if err != nil {
-				return err
-			}
+	if f.onBlockAddedToDAGHandler != nil {
+		err := f.onBlockAddedToDAGHandler(block)
+		if err != nil {
+			return err
 		}
 	}
 
@@ -53,7 +32,7 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
 	f.updateTransactionsToRebroadcast(block)
 
 	// Don't relay transactions when in IBD.
-	if f.IsIBDRunning() {
+	if atomic.LoadUint32(&f.isInIBD) != 0 {
 		return nil
 	}
 
@@ -64,7 +43,7 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
 
 	txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
 	for i, tx := range transactionsAcceptedToMempool {
-		txIDsToBroadcast[i] = consensushashing.TransactionID(tx)
+		txIDsToBroadcast[i] = consensusserialization.TransactionID(tx)
 	}
 	offset := len(transactionsAcceptedToMempool)
 	for i, txID := range txIDsToRebroadcast {
@@ -91,39 +70,11 @@ func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks
 func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 	err := f.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
-		if errors.As(err, &ruleerrors.RuleError{}) {
-			log.Infof("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
-			return nil
-		}
 		return err
 	}
 	err = f.OnNewBlock(block)
 	if err != nil {
 		return err
 	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(consensushashing.BlockHash(block)))
-}
-
-// IsIBDRunning returns true if IBD is currently marked as running
-func (f *FlowContext) IsIBDRunning() bool {
-	return atomic.LoadUint32(&f.isInIBD) != 0
-}
-
-// TrySetIBDRunning attempts to set `isInIBD`. Returns false
-// if it is already set
-func (f *FlowContext) TrySetIBDRunning() bool {
-	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 0, 1)
-	if succeeded {
-		log.Infof("IBD started")
-	}
-	return succeeded
-}
-
-// UnsetIBDRunning unsets isInIBD
-func (f *FlowContext) UnsetIBDRunning() {
-	succeeded := atomic.CompareAndSwapUint32(&f.isInIBD, 1, 0)
-	if !succeeded {
-		panic("attempted to unset isInIBD when it was not set to begin with")
-	}
-	log.Infof("IBD finished")
+	return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
 }

app/protocol/flowcontext/flow_context.go

@@ -9,7 +9,7 @@ import (
 	"github.com/kaspanet/kaspad/domain"
 
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
-	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
@@ -41,17 +41,16 @@ type FlowContext struct {
 	transactionsToRebroadcastLock sync.Mutex
 	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
 	lastRebroadcastTime           time.Time
-	sharedRequestedTransactions   *transactionrelay.SharedRequestedTransactions
+	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	isInIBD uint32
+	isInIBD       uint32
+	startIBDMutex sync.Mutex
+	ibdPeer       *peerpkg.Peer
 
 	peers      map[id.ID]*peerpkg.Peer
 	peersMutex sync.RWMutex
-
-	orphans      map[externalapi.DomainHash]*externalapi.DomainBlock
-	orphansMutex sync.RWMutex
 }
 
 // New returns a new instance of FlowContext.
@@ -64,11 +63,10 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		domain:                      domain,
 		addressManager:              addressManager,
 		connectionManager:           connectionManager,
-		sharedRequestedTransactions: transactionrelay.NewSharedRequestedTransactions(),
+		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
 		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
 		peers:                       make(map[id.ID]*peerpkg.Peer),
 		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),
-		orphans:                     make(map[externalapi.DomainHash]*externalapi.DomainBlock),
 	}
 }
 

app/protocol/flowcontext/ibd.go

@@ -0,0 +1,108 @@
+package flowcontext
+
+import (
+	"sync/atomic"
+	"time"
+
+	"github.com/kaspanet/kaspad/util/mstime"
+
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+)
+
+// StartIBDIfRequired selects a peer and starts IBD against it
+// if required
+func (f *FlowContext) StartIBDIfRequired() error {
+	f.startIBDMutex.Lock()
+	defer f.startIBDMutex.Unlock()
+
+	if f.IsInIBD() {
+		return nil
+	}
+
+	peer, err := f.selectPeerForIBD()
+	if err != nil {
+		return err
+	}
+	if peer == nil {
+		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
+		return nil
+	}
+
+	atomic.StoreUint32(&f.isInIBD, 1)
+	f.ibdPeer = peer
+	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+
+	return nil
+}
+
+// IsInIBD is true if IBD is currently running
+func (f *FlowContext) IsInIBD() bool {
+	return atomic.LoadUint32(&f.isInIBD) != 0
+}
+
+// selectPeerForIBD returns the first peer whose selected tip
+// hash is not in our DAG
+func (f *FlowContext) selectPeerForIBD() (*peerpkg.Peer, error) {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peerSelectedTipHash := peer.SelectedTipHash()
+		blockInfo, err := f.domain.Consensus().GetBlockInfo(peerSelectedTipHash)
+		if err != nil {
+			return nil, err
+		}
+		if !blockInfo.Exists {
+			return peer, nil
+		}
+	}
+	return nil, nil
+}
+
+func (f *FlowContext) requestSelectedTipsIfRequired() {
+	dagTimeCurrent, err := f.shouldRequestSelectedTips()
+	if err != nil {
+		panic(err)
+	}
+	if dagTimeCurrent {
+		return
+	}
+	f.requestSelectedTips()
+}
+
+func (f *FlowContext) shouldRequestSelectedTips() (bool, error) {
+	const minDurationToRequestSelectedTips = time.Minute
+	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return false, err
+	}
+	virtualSelectedParentTime := mstime.UnixMilliseconds(virtualSelectedParent.Header.TimeInMilliseconds)
+	return mstime.Now().Sub(virtualSelectedParentTime) > minDurationToRequestSelectedTips, nil
+}
+
+func (f *FlowContext) requestSelectedTips() {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peer.RequestSelectedTipIfRequired()
+	}
+}
+
+// FinishIBD finishes the current IBD flow and starts a new one if required.
+func (f *FlowContext) FinishIBD() error {
+	f.ibdPeer = nil
+
+	atomic.StoreUint32(&f.isInIBD, 0)
+
+	return f.StartIBDIfRequired()
+}
+
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	if !f.IsInIBD() {
+		return nil
+	}
+	return f.ibdPeer
+}

app/protocol/flowcontext/orphans.go

@@ -1,130 +0,0 @@
-package flowcontext
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/pkg/errors"
-)
-
-// AddOrphan adds the block to the orphan set
-func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
-	f.orphansMutex.Lock()
-	defer f.orphansMutex.Unlock()
-
-	orphanHash := consensushashing.BlockHash(orphanBlock)
-	f.orphans[*orphanHash] = orphanBlock
-
-	log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
-}
-
-// IsOrphan returns whether the given blockHash belongs to an orphan block
-func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
-	f.orphansMutex.RLock()
-	defer f.orphansMutex.RUnlock()
-
-	_, ok := f.orphans[*blockHash]
-	return ok
-}
-
-// UnorphanBlocks removes the block from the orphan set, and remove all of the blocks that are not orphans anymore.
-func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
-	f.orphansMutex.Lock()
-	defer f.orphansMutex.Unlock()
-
-	// Find all the children of rootBlock among the orphans
-	// and add them to the process queue
-	rootBlockHash := consensushashing.BlockHash(rootBlock)
-	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
-
-	var unorphanedBlocks []*externalapi.DomainBlock
-	for len(processQueue) > 0 {
-		var orphanHash externalapi.DomainHash
-		orphanHash, processQueue = processQueue[0], processQueue[1:]
-		orphanBlock := f.orphans[orphanHash]
-
-		log.Tracef("Considering to unorphan block %s with parents %s",
-			orphanHash, orphanBlock.Header.ParentHashes)
-
-		canBeUnorphaned := true
-		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
-			orphanBlockParentInfo, err := f.domain.Consensus().GetBlockInfo(orphanBlockParentHash)
-			if err != nil {
-				return nil, err
-			}
-			if !orphanBlockParentInfo.Exists || orphanBlockParentInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				log.Tracef("Cannot unorphan block %s. It's missing at "+
-					"least the following parent: %s", orphanHash, orphanBlockParentHash)
-
-				canBeUnorphaned = false
-				break
-			}
-		}
-		if canBeUnorphaned {
-			err := f.unorphanBlock(orphanHash)
-			if err != nil {
-				return nil, err
-			}
-			unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
-			processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
-		}
-	}
-
-	return unorphanedBlocks, nil
-}
-
-// addChildOrphansToProcessQueue finds all child orphans of `blockHash`
-// and adds them to the given `processQueue` if they don't already exist
-// inside of it
-// Note that this method does not modify the given `processQueue`
-func (f *FlowContext) addChildOrphansToProcessQueue(blockHash *externalapi.DomainHash,
-	processQueue []externalapi.DomainHash) []externalapi.DomainHash {
-
-	blockChildren := f.findChildOrphansOfBlock(blockHash)
-	for _, blockChild := range blockChildren {
-		exists := false
-		for _, queueOrphan := range processQueue {
-			if queueOrphan == blockChild {
-				exists = true
-				break
-			}
-		}
-		if !exists {
-			processQueue = append(processQueue, blockChild)
-		}
-	}
-	return processQueue
-}
-
-func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash) []externalapi.DomainHash {
-	var childOrphans []externalapi.DomainHash
-	for orphanHash, orphanBlock := range f.orphans {
-		for _, orphanBlockParentHash := range orphanBlock.Header.ParentHashes {
-			if *orphanBlockParentHash == *blockHash {
-				childOrphans = append(childOrphans, orphanHash)
-				break
-			}
-		}
-	}
-	return childOrphans
-}
-
-func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) error {
-	orphanBlock, ok := f.orphans[orphanHash]
-	if !ok {
-		return errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
-	}
-	delete(f.orphans, orphanHash)
-
-	err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
-	if err != nil {
-		if errors.As(err, &ruleerrors.RuleError{}) {
-			log.Infof("Validation failed for orphan block %s: %s", orphanHash, err)
-			return nil
-		}
-		return err
-	}
-
-	log.Infof("Unorphaned block %s", orphanHash)
-	return nil
-}

app/protocol/flowcontext/transactions.go

@@ -4,9 +4,9 @@ import (
 	"time"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 )
 
 // AddTransaction adds transaction to the mempool and propagates it.
@@ -19,7 +19,7 @@ func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
 		return err
 	}
 
-	transactionID := consensushashing.TransactionID(tx)
+	transactionID := consensusserialization.TransactionID(tx)
 	f.transactionsToRebroadcast[*transactionID] = tx
 	inv := appmessage.NewMsgInvTransaction([]*externalapi.DomainTransactionID{transactionID})
 	return f.Broadcast(inv)
@@ -32,7 +32,7 @@ func (f *FlowContext) updateTransactionsToRebroadcast(block *externalapi.DomainB
 	// anymore, although they are not included in the UTXO set.
 	// This is probably ok, since red blocks are quite rare.
 	for _, tx := range block.Transactions {
-		delete(f.transactionsToRebroadcast, *consensushashing.TransactionID(tx))
+		delete(f.transactionsToRebroadcast, *consensusserialization.TransactionID(tx))
 	}
 }
 
@@ -48,15 +48,15 @@ func (f *FlowContext) txIDsToRebroadcast() []*externalapi.DomainTransactionID {
 	txIDs := make([]*externalapi.DomainTransactionID, len(f.transactionsToRebroadcast))
 	i := 0
 	for _, tx := range f.transactionsToRebroadcast {
-		txIDs[i] = consensushashing.TransactionID(tx)
+		txIDs[i] = consensusserialization.TransactionID(tx)
 		i++
 	}
 	return txIDs
 }
 
-// SharedRequestedTransactions returns a *transactionrelay.SharedRequestedTransactions for sharing
+// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
 // data about requested transactions between different peers.
-func (f *FlowContext) SharedRequestedTransactions() *transactionrelay.SharedRequestedTransactions {
+func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
 	return f.sharedRequestedTransactions
 }
 

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -20,6 +20,10 @@ type ReceiveAddressesContext interface {
 func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
 	peer *peerpkg.Peer) error {
 
+	if !context.AddressManager().NeedMoreAddresses() {
+		return nil
+	}
+
 	subnetworkID := peer.SubnetworkID()
 	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
 	err := outgoingRoute.Enqueue(msgGetAddresses)
@@ -33,10 +37,21 @@ func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Rou
 	}
 
 	msgAddresses := message.(*appmessage.MsgAddresses)
-	if len(msgAddresses.AddressList) > addressmanager.GetAddressesMax {
+	if len(msgAddresses.AddrList) > addressmanager.GetAddressesMax {
 		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
 	}
 
-	context.AddressManager().AddAddresses(msgAddresses.AddressList...)
+	if msgAddresses.IncludeAllSubnetworks {
+		return protocolerrors.Errorf(true, "got unexpected "+
+			"IncludeAllSubnetworks=true in [%s] command", msgAddresses.Command())
+	}
+	if msgAddresses.SubnetworkID != nil && *msgAddresses.SubnetworkID != *context.Config().SubnetworkID {
+		return protocolerrors.Errorf(false, "only full nodes and %s subnetwork IDs "+
+			"are allowed in [%s] command, but got subnetwork ID %s",
+			context.Config().SubnetworkID, msgAddresses.Command(), msgAddresses.SubnetworkID)
+	}
+
+	sourceAddress := peer.Connection().NetAddress()
+	context.AddressManager().AddAddresses(msgAddresses.AddrList, sourceAddress, msgAddresses.SubnetworkID)
 	return nil
 }

app/protocol/flows/addressexchange/sendaddresses.go

@@ -1,12 +1,10 @@
 package addressexchange
 
 import (
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"math/rand"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"math/rand"
 )
 
 // SendAddressesContext is the interface for the context needed for the SendAddresses flow.
@@ -16,25 +14,21 @@ type SendAddressesContext interface {
 
 // SendAddresses sends addresses to a peer that requests it.
 func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-
-		_, ok := message.(*appmessage.MsgRequestAddresses)
-		if !ok {
-			return protocolerrors.Errorf(true, "unexpected message. "+
-				"Expected: %s, got: %s", appmessage.CmdRequestAddresses, message.Command())
-		}
-		addresses := context.AddressManager().Addresses()
-		msgAddresses := appmessage.NewMsgAddresses(shuffleAddresses(addresses))
-
-		err = outgoingRoute.Enqueue(msgAddresses)
-		if err != nil {
-			return err
-		}
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return err
 	}
+
+	msgGetAddresses := message.(*appmessage.MsgRequestAddresses)
+	addresses := context.AddressManager().AddressCache(msgGetAddresses.IncludeAllSubnetworks,
+		msgGetAddresses.SubnetworkID)
+	msgAddresses := appmessage.NewMsgAddresses(msgGetAddresses.IncludeAllSubnetworks, msgGetAddresses.SubnetworkID)
+	err = msgAddresses.AddAddresses(shuffleAddresses(addresses)...)
+	if err != nil {
+		return err
+	}
+
+	return outgoingRoute.Enqueue(msgAddresses)
 }
 
 // shuffleAddresses randomizes the given addresses sent if there are more than the maximum allowed in one message.

app/protocol/flows/blockrelay/block_locator.go

@@ -1,29 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-func (flow *handleRelayInvsFlow) sendGetBlockLocator(lowHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, limit uint32) error {
-
-	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(lowHash, highHash, limit)
-	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
-}
-
-func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return nil, err
-	}
-	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
-	if !ok {
-		return nil,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
-	}
-	return msgBlockLocator.BlockLocatorHashes, nil
-}

app/protocol/flows/blockrelay/handle_ibd_block_requests.go

@@ -1,52 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-	"github.com/pkg/errors"
-)
-
-// HandleIBDBlockRequestsContext is the interface for the context needed for the HandleIBDBlockRequests flow.
-type HandleIBDBlockRequestsContext interface {
-	Domain() domain.Domain
-}
-
-// HandleIBDBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
-// their corresponding blocks to the requesting peer.
-func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute *router.Route,
-	outgoingRoute *router.Route) error {
-
-	for {
-		message, err := incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
-		for _, hash := range msgRequestIBDBlocks.Hashes {
-			// Fetch the block from the database.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				return protocolerrors.Errorf(true, "block %s not found", hash)
-			}
-			block, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
-			}
-
-			// TODO (Partial nodes): Convert block to partial block if needed
-
-			blockMessage := appmessage.DomainBlockToMsgBlock(block)
-			ibdBlockMessage := appmessage.NewMsgIBDBlock(blockMessage)
-			err = outgoingRoute.Enqueue(ibdBlockMessage)
-			if err != nil {
-				return err
-			}
-		}
-	}
-}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -5,7 +5,6 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
@@ -32,7 +31,7 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 			if err != nil {
 				return err
 			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+			if !blockInfo.Exists {
 				return protocolerrors.Errorf(true, "block %s not found", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -2,37 +2,30 @@ package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	mathUtil "github.com/kaspanet/kaspad/util/math"
 	"github.com/pkg/errors"
 )
 
-// orphanResolutionRange is the maximum amount of blockLocator hashes
-// to search for known blocks. See isBlockInOrphanResolutionRange for
-// further details
-var orphanResolutionRange uint32 = 5
-
 // RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
 type RelayInvsContext interface {
 	Domain() domain.Domain
-	Config() *config.Config
 	NetAdapter() *netadapter.NetAdapter
 	OnNewBlock(block *externalapi.DomainBlock) error
 	SharedRequestedBlocks() *SharedRequestedBlocks
+	StartIBDIfRequired() error
+	IsInIBD() bool
 	Broadcast(message appmessage.Message) error
-	AddOrphan(orphanBlock *externalapi.DomainBlock)
-	IsOrphan(blockHash *externalapi.DomainHash) bool
-	IsIBDRunning() bool
-	TrySetIBDRunning() bool
-	UnsetIBDRunning()
 }
 
 type handleRelayInvsFlow struct {
@@ -59,7 +52,6 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 
 func (flow *handleRelayInvsFlow) start() error {
 	for {
-		log.Debugf("Waiting for inv")
 		inv, err := flow.readInv()
 		if err != nil {
 			return err
@@ -76,59 +68,32 @@ func (flow *handleRelayInvsFlow) start() error {
 				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
 					inv.Hash)
 			}
-			log.Debugf("Block %s already exists. continuing...", inv.Hash)
 			continue
 		}
 
-		if flow.IsOrphan(inv.Hash) {
-			log.Debugf("Block %s is a known orphan. continuing...", inv.Hash)
-			continue
-		}
-
-		// Block relay is disabled during IBD
-		if flow.IsIBDRunning() {
-			log.Debugf("Got block %s while in IBD. continuing...", inv.Hash)
-			continue
-		}
-
-		log.Debugf("Requesting block %s", inv.Hash)
-		block, exists, err := flow.requestBlock(inv.Hash)
+		err = flow.StartIBDIfRequired()
 		if err != nil {
 			return err
 		}
-		if exists {
-			log.Debugf("Aborting requesting block %s because it already exists", inv.Hash)
+		if flow.IsInIBD() {
+			// Block relay is disabled during IBD
 			continue
 		}
 
-		log.Debugf("Processing block %s", inv.Hash)
-		missingParents, err := flow.processBlock(block)
-		if err != nil {
-			return err
-		}
-		if len(missingParents) > 0 {
-			log.Debugf("Block %s contains orphans: %s", inv.Hash, missingParents)
-			err := flow.processOrphan(block, missingParents)
+		requestQueue := newHashesQueueSet()
+		requestQueue.enqueueIfNotExists(inv.Hash)
+
+		for requestQueue.len() > 0 {
+			err := flow.requestBlocks(requestQueue)
 			if err != nil {
 				return err
 			}
-			continue
-		}
-
-		log.Debugf("Relaying block %s", inv.Hash)
-		err = flow.relayBlock(block)
-		if err != nil {
-			return err
-		}
-		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block)
-		if err != nil {
-			return err
 		}
 	}
 }
 
 func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
+
 	if len(flow.invsQueue) > 0 {
 		var inv *appmessage.MsgInvRelayBlock
 		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
@@ -148,40 +113,76 @@ func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error)
 	return inv, nil
 }
 
-func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
-	exists := flow.SharedRequestedBlocks().addIfNotExists(requestHash)
-	if exists {
-		return nil, true, nil
+func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
+	numHashesToRequest := mathUtil.MinInt(appmessage.MsgRequestRelayBlocksHashes, requestQueue.len())
+	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
+
+	pendingBlocks := map[externalapi.DomainHash]struct{}{}
+	var filteredHashesToRequest []*externalapi.DomainHash
+	for _, hash := range hashesToRequest {
+		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
+		if exists {
+			continue
+		}
+
+		// The block can become known from another peer in the process of orphan resolution
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(hash)
+		if err != nil {
+			return err
+		}
+		if blockInfo.Exists {
+			continue
+		}
+
+		pendingBlocks[*hash] = struct{}{}
+		filteredHashesToRequest = append(filteredHashesToRequest, hash)
 	}
 
-	// In case the function returns earlier than expected, we want to make sure flow.SharedRequestedBlocks() is
-	// clean from any pending blocks.
-	defer flow.SharedRequestedBlocks().remove(requestHash)
+	// Exit early if we've filtered out all the hashes
+	if len(filteredHashesToRequest) == 0 {
+		return nil
+	}
 
-	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks([]*externalapi.DomainHash{requestHash})
+	// In case the function returns earlier than expected, we want to make sure requestedBlocks is
+	// clean from any pending blocks.
+	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
 	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
 	if err != nil {
-		return nil, false, err
+		return err
 	}
 
-	msgBlock, err := flow.readMsgBlock()
-	if err != nil {
-		return nil, false, err
-	}
+	for len(pendingBlocks) > 0 {
+		msgBlock, err := flow.readMsgBlock()
+		if err != nil {
+			return err
+		}
 
-	block := appmessage.MsgBlockToDomainBlock(msgBlock)
-	blockHash := consensushashing.BlockHash(block)
-	if *blockHash != *requestHash {
-		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
-	}
+		block := appmessage.MsgBlockToDomainBlock(msgBlock)
+		blockHash := consensusserialization.BlockHash(block)
 
-	return block, false, nil
+		if _, ok := pendingBlocks[*blockHash]; !ok {
+			return protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
+		}
+
+		err = flow.processAndRelayBlock(requestQueue, block)
+		if err != nil {
+			return err
+		}
+
+		delete(pendingBlocks, *blockHash)
+		flow.SharedRequestedBlocks().remove(blockHash)
+	}
+	return nil
 }
 
 // readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
 //
 // Note: this function assumes msgChan can contain only appmessage.MsgInvRelayBlock and appmessage.MsgBlock messages.
-func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock, err error) {
+func (flow *handleRelayInvsFlow) readMsgBlock() (
+	msgBlock *appmessage.MsgBlock, err error) {
+
 	for {
 		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 		if err != nil {
@@ -199,92 +200,63 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
-	blockHash := consensushashing.BlockHash(block)
+func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *externalapi.DomainBlock) error {
+	blockHash := consensusserialization.BlockHash(block)
 	err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
+			return errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil
+			blueScore, err := blocks.ExtractBlueScore(block)
+			if err != nil {
+				return protocolerrors.Errorf(true, "received an orphan "+
+					"block %s with malformed blue score", blockHash)
+			}
+
+			const maxOrphanBlueScoreDiff = 10000
+			virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+			if err != nil {
+				return err
+			}
+			selectedTipBlueScore, err := blocks.ExtractBlueScore(virtualSelectedParent)
+			if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
+				log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
+					"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
+					blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
+				return nil
+			}
+
+			// Request the parents for the orphan block from the peer that sent it.
+			for _, missingAncestor := range missingParentsError.MissingParentHashes {
+				requestQueue.enqueueIfNotExists(missingAncestor)
+			}
+			return nil
 		}
-		log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
 
-		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
-	}
-	return nil, nil
-}
-
-func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
-	return flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
-}
-
-func (flow *handleRelayInvsFlow) processOrphan(block *externalapi.DomainBlock, missingParents []*externalapi.DomainHash) error {
-	blockHash := consensushashing.BlockHash(block)
-
-	// Return if the block has been orphaned from elsewhere already
-	if flow.IsOrphan(blockHash) {
-		log.Debugf("Skipping orphan processing for block %s because it is already an orphan", blockHash)
-		return nil
+		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
 
-	// Add the block to the orphan set if it's within orphan resolution range
-	isBlockInOrphanResolutionRange, err := flow.isBlockInOrphanResolutionRange(blockHash)
+	err = blocklogger.LogBlock(block)
 	if err != nil {
 		return err
 	}
-	if isBlockInOrphanResolutionRange {
-		log.Debugf("Block %s is within orphan resolution range. "+
-			"Adding it to the orphan set and requesting its missing parents", blockHash)
-		flow.addToOrphanSetAndRequestMissingParents(block, missingParents)
-		return nil
-	}
-
-	// Start IBD unless we already are in IBD
-	log.Debugf("Block %s is out of orphan resolution range. "+
-		"Attempting to start IBD against it.", blockHash)
-	return flow.runIBDIfNotRunning(blockHash)
-}
-
-// isBlockInOrphanResolutionRange finds out whether the given blockHash should be
-// retrieved via the unorphaning mechanism or via IBD. This method sends a
-// getBlockLocator request to the peer with a limit of orphanResolutionRange.
-// In the response, if we know none of the hashes, we should retrieve the given
-// blockHash via IBD. Otherwise, via unorphaning.
-func (flow *handleRelayInvsFlow) isBlockInOrphanResolutionRange(blockHash *externalapi.DomainHash) (bool, error) {
-	lowHash := flow.Config().ActiveNetParams.GenesisHash
-	err := flow.sendGetBlockLocator(lowHash, blockHash, orphanResolutionRange)
+	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
 	if err != nil {
-		return false, err
+		return err
 	}
 
-	blockLocatorHashes, err := flow.receiveBlockLocator()
+	err = flow.StartIBDIfRequired()
 	if err != nil {
-		return false, err
+		return err
 	}
-	for _, blockLocatorHash := range blockLocatorHashes {
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockLocatorHash)
-		if err != nil {
-			return false, err
-		}
-		if blockInfo.Exists && blockInfo.BlockStatus != externalapi.StatusHeaderOnly {
-			return true, nil
-		}
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
 	}
-	return false, nil
-}
 
-func (flow *handleRelayInvsFlow) addToOrphanSetAndRequestMissingParents(
-	block *externalapi.DomainBlock, missingParents []*externalapi.DomainHash) {
-
-	flow.AddOrphan(block)
-	invMessages := make([]*appmessage.MsgInvRelayBlock, len(missingParents))
-	for i, missingParent := range missingParents {
-		invMessages[i] = appmessage.NewMsgInvBlock(missingParent)
-	}
-	flow.invsQueue = append(invMessages, flow.invsQueue...)
+	return nil
 }

app/protocol/flows/blockrelay/handle_request_headers_test.go

@@ -1,15 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"testing"
-)
-
-func TestMaxHeaders(t *testing.T) {
-	testutils.ForAllNets(t, false, func(t *testing.T, params *dagconfig.Params) {
-		if params.FinalityDepth() > maxHeaders {
-			t.Errorf("FinalityDepth() in %s should be lower or equal to appmessage.MaxInvPerMsg", params.Name)
-		}
-	})
-}

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

@@ -1,65 +0,0 @@
-package blockrelay
-
-import (
-	"errors"
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
-)
-
-// HandleRequestIBDRootUTXOSetAndBlockContext is the interface for the context needed for the HandleRequestIBDRootUTXOSetAndBlock flow.
-type HandleRequestIBDRootUTXOSetAndBlockContext interface {
-	Domain() domain.Domain
-}
-
-type handleRequestIBDRootUTXOSetAndBlockFlow struct {
-	HandleRequestIBDRootUTXOSetAndBlockContext
-	incomingRoute, outgoingRoute *router.Route
-}
-
-// HandleRequestIBDRootUTXOSetAndBlock listens to appmessage.MsgRequestIBDRootUTXOSetAndBlock messages and sends
-// the IBD root UTXO set and block body.
-func HandleRequestIBDRootUTXOSetAndBlock(context HandleRequestIBDRootUTXOSetAndBlockContext, incomingRoute,
-	outgoingRoute *router.Route) error {
-	flow := &handleRequestIBDRootUTXOSetAndBlockFlow{
-		HandleRequestIBDRootUTXOSetAndBlockContext: context,
-		incomingRoute: incomingRoute,
-		outgoingRoute: outgoingRoute,
-	}
-
-	return flow.start()
-}
-
-func (flow *handleRequestIBDRootUTXOSetAndBlockFlow) start() error {
-	for {
-		message, err := flow.incomingRoute.Dequeue()
-		if err != nil {
-			return err
-		}
-		msgRequestIBDRootUTXOSetAndBlock := message.(*appmessage.MsgRequestIBDRootUTXOSetAndBlock)
-
-		utxoSet, err := flow.Domain().Consensus().GetPruningPointUTXOSet(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
-		if err != nil {
-			if errors.Is(err, ruleerrors.ErrWrongPruningPointHash) {
-				err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootNotFound())
-				if err != nil {
-					return err
-				}
-
-				continue
-			}
-		}
-
-		block, err := flow.Domain().Consensus().GetBlock(msgRequestIBDRootUTXOSetAndBlock.IBDRoot)
-		if err != nil {
-			return err
-		}
-
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgIBDRootUTXOSetAndBlock(utxoSet,
-			appmessage.DomainBlockToMsgBlock(block)))
-		if err != nil {
-			return err
-		}
-	}
-}

app/protocol/flows/blockrelay/ibd.go

@@ -1,307 +0,0 @@
-package blockrelay
-
-import (
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/common"
-	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/pkg/errors"
-	"time"
-)
-
-func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.DomainHash) error {
-	wasIBDNotRunning := flow.TrySetIBDRunning()
-	if !wasIBDNotRunning {
-		log.Debugf("IBD is already running")
-		return nil
-	}
-	defer flow.UnsetIBDRunning()
-
-	log.Debugf("IBD started with peer %s and highHash %s", flow.peer, highHash)
-
-	// Fetch all the headers if we don't already have them
-	log.Debugf("Downloading headers up to %s", highHash)
-	err := flow.syncHeaders(highHash)
-	if err != nil {
-		return err
-	}
-	log.Debugf("Finished downloading headers up to %s", highHash)
-
-	// Fetch the UTXO set if we don't already have it
-	log.Debugf("Downloading the IBD root UTXO set under highHash %s", highHash)
-	syncInfo, err := flow.Domain().Consensus().GetSyncInfo()
-	if err != nil {
-		return err
-	}
-	if syncInfo.State == externalapi.SyncStateAwaitingUTXOSet {
-		found, err := flow.fetchMissingUTXOSet(syncInfo.IBDRootUTXOBlockHash)
-		if err != nil {
-			return err
-		}
-		if !found {
-			log.Infof("Cannot download the IBD root UTXO set under highHash %s", highHash)
-			return nil
-		}
-	}
-	log.Debugf("Finished downloading the IBD root UTXO set under highHash %s", highHash)
-
-	// Fetch the block bodies
-	log.Debugf("Downloading block bodies up to %s", highHash)
-	err = flow.syncMissingBlockBodies(highHash)
-	if err != nil {
-		return err
-	}
-	log.Debugf("Finished downloading block bodies up to %s", highHash)
-
-	return nil
-}
-
-func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) error {
-	log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash)
-	highestSharedBlockHash, err := flow.findHighestSharedBlockHash(highHash)
-	if err != nil {
-		return err
-	}
-	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
-
-	return flow.downloadHeaders(highestSharedBlockHash, highHash)
-}
-
-func (flow *handleRelayInvsFlow) findHighestSharedBlockHash(highHash *externalapi.DomainHash) (
-	lowHash *externalapi.DomainHash, err error) {
-
-	lowHash = flow.Config().ActiveNetParams.GenesisHash
-	currentHighHash := highHash
-
-	for {
-		err := flow.sendGetBlockLocator(lowHash, currentHighHash, 0)
-		if err != nil {
-			return nil, err
-		}
-
-		blockLocatorHashes, err := flow.receiveBlockLocator()
-		if err != nil {
-			return nil, err
-		}
-
-		// We check whether the locator's highest hash is in the local DAG.
-		// If it is, return it. If it isn't, we need to narrow our
-		// getBlockLocator request and try again.
-		locatorHighHash := blockLocatorHashes[0]
-		locatorHighHashInfo, err := flow.Domain().Consensus().GetBlockInfo(locatorHighHash)
-		if err != nil {
-			return nil, err
-		}
-		if locatorHighHashInfo.Exists {
-			return locatorHighHash, nil
-		}
-
-		lowHash, currentHighHash, err = flow.Domain().Consensus().FindNextBlockLocatorBoundaries(blockLocatorHashes)
-		if err != nil {
-			return nil, err
-		}
-	}
-}
-
-func (flow *handleRelayInvsFlow) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash) error {
-
-	err := flow.sendRequestHeaders(highestSharedBlockHash, highHash)
-	if err != nil {
-		return err
-	}
-
-	blocksReceived := 0
-	for {
-		msgBlockHeader, doneIBD, err := flow.receiveHeader()
-		if err != nil {
-			return err
-		}
-		if doneIBD {
-			return nil
-		}
-
-		err = flow.processHeader(msgBlockHeader)
-		if err != nil {
-			return err
-		}
-
-		blocksReceived++
-		if blocksReceived%ibdBatchSize == 0 {
-			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextHeaders())
-			if err != nil {
-				return err
-			}
-		}
-	}
-}
-
-func (flow *handleRelayInvsFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
-}
-
-func (flow *handleRelayInvsFlow) receiveHeader() (msgIBDBlock *appmessage.MsgBlockHeader, doneIBD bool, err error) {
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return nil, false, err
-	}
-	switch message := message.(type) {
-	case *appmessage.MsgBlockHeader:
-		return message, false, nil
-	case *appmessage.MsgDoneHeaders:
-		return nil, true, nil
-	default:
-		return nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s, got: %s", appmessage.CmdHeader, appmessage.CmdDoneHeaders, message.Command())
-	}
-}
-
-func (flow *handleRelayInvsFlow) processHeader(msgBlockHeader *appmessage.MsgBlockHeader) error {
-	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
-	block := &externalapi.DomainBlock{
-		Header:       header,
-		Transactions: nil,
-	}
-
-	blockHash := consensushashing.BlockHash(block)
-	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
-	if err != nil {
-		return err
-	}
-	if blockInfo.Exists {
-		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
-		return nil
-	}
-	err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
-	if err != nil {
-		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
-		}
-		log.Infof("Rejected block header %s from %s during IBD: %s", blockHash, flow.peer, err)
-
-		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
-	}
-	return nil
-}
-
-func (flow *handleRelayInvsFlow) fetchMissingUTXOSet(ibdRootHash *externalapi.DomainHash) (bool, error) {
-	err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootUTXOSetAndBlock(ibdRootHash))
-	if err != nil {
-		return false, err
-	}
-
-	utxoSet, block, found, err := flow.receiveIBDRootUTXOSetAndBlock()
-	if err != nil {
-		return false, err
-	}
-
-	if !found {
-		return false, nil
-	}
-
-	err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
-	if err != nil {
-		blockHash := consensushashing.BlockHash(block)
-		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "got invalid block %s during IBD", blockHash)
-	}
-
-	err = flow.Domain().Consensus().SetPruningPointUTXOSet(utxoSet)
-	if err != nil {
-		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
-	}
-
-	return true, nil
-}
-
-func (flow *handleRelayInvsFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
-	message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-	if err != nil {
-		return nil, nil, false, err
-	}
-
-	switch message := message.(type) {
-	case *appmessage.MsgIBDRootUTXOSetAndBlock:
-		return message.UTXOSet,
-			appmessage.MsgBlockToDomainBlock(message.Block), true, nil
-	case *appmessage.MsgIBDRootNotFound:
-		return nil, nil, false, nil
-	default:
-		return nil, nil, false,
-			protocolerrors.Errorf(true, "received unexpected message type. "+
-				"expected: %s or %s, got: %s",
-				appmessage.CmdIBDRootUTXOSetAndBlock, appmessage.CmdIBDRootNotFound, message.Command(),
-			)
-	}
-}
-
-func (flow *handleRelayInvsFlow) syncMissingBlockBodies(highHash *externalapi.DomainHash) error {
-	hashes, err := flow.Domain().Consensus().GetMissingBlockBodyHashes(highHash)
-	if err != nil {
-		return err
-	}
-
-	for offset := 0; offset < len(hashes); offset += ibdBatchSize {
-		var hashesToRequest []*externalapi.DomainHash
-		if offset+ibdBatchSize < len(hashes) {
-			hashesToRequest = hashes[offset : offset+ibdBatchSize]
-		} else {
-			hashesToRequest = hashes[offset:]
-		}
-
-		err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDBlocks(hashesToRequest))
-		if err != nil {
-			return err
-		}
-
-		for _, expectedHash := range hashesToRequest {
-			message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout)
-			if err != nil {
-				return err
-			}
-
-			msgIBDBlock, ok := message.(*appmessage.MsgIBDBlock)
-			if !ok {
-				return protocolerrors.Errorf(true, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
-			}
-
-			block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
-			blockHash := consensushashing.BlockHash(block)
-			if *expectedHash != *blockHash {
-				return protocolerrors.Errorf(true, "expected block %s but got %s", expectedHash, blockHash)
-			}
-
-			err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
-			if err != nil {
-				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
-			}
-			err = flow.OnNewBlock(block)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// dequeueIncomingMessageAndSkipInvs is a convenience method to be used during
-// IBD. Inv messages are expected to arrive at any given moment, but should be
-// ignored while we're in IBD
-func (flow *handleRelayInvsFlow) dequeueIncomingMessageAndSkipInvs(timeout time.Duration) (appmessage.Message, error) {
-	for {
-		message, err := flow.incomingRoute.DequeueWithTimeout(timeout)
-		if err != nil {
-			return nil, err
-		}
-		if _, ok := message.(*appmessage.MsgInvRelayBlock); !ok {
-			return message, nil
-		}
-	}
-}

app/protocol/flows/handshake/handshake.go

@@ -1,6 +1,7 @@
 package handshake
 
 import (
+	"sync"
 	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/domain"
@@ -15,6 +16,7 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util/locks"
 	"github.com/pkg/errors"
 )
 
@@ -24,6 +26,7 @@ type HandleHandshakeContext interface {
 	NetAdapter() *netadapter.NetAdapter
 	Domain() domain.Domain
 	AddressManager() *addressmanager.AddressManager
+	StartIBDIfRequired() error
 	AddToPeers(peer *peerpkg.Peer) error
 	HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error)
 }
@@ -35,12 +38,10 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 ) (*peerpkg.Peer, error) {
 
 	// For HandleHandshake to finish, we need to get from the other node
-	// a version and verack messages, so we set doneCount to 2, decrease it
-	// when sending and receiving the version, and close the doneChan when
-	// it's 0. Then we wait for on select for a tick from doneChan or from
-	// errChan.
-	doneCount := int32(2)
-	doneChan := make(chan struct{})
+	// a version and verack messages, so we increase the wait group by 2
+	// and block HandleHandshake with wg.Wait().
+	wg := sync.WaitGroup{}
+	wg.Add(2)
 
 	isStopping := uint32(0)
 	errChan := make(chan error)
@@ -55,9 +56,7 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			return
 		}
 		peerAddress = address
-		if atomic.AddInt32(&doneCount, -1) == 0 {
-			close(doneChan)
-		}
+		wg.Done()
 	})
 
 	spawn("HandleHandshake-SendVersion", func() {
@@ -66,9 +65,7 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			handleError(err, "SendVersion", &isStopping, errChan)
 			return
 		}
-		if atomic.AddInt32(&doneCount, -1) == 0 {
-			close(doneChan)
-		}
+		wg.Done()
 	})
 
 	select {
@@ -77,7 +74,7 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 			return nil, err
 		}
 		return nil, nil
-	case <-doneChan:
+	case <-locks.ReceiveFromChanWhenDone(func() { wg.Wait() }):
 	}
 
 	err := context.AddToPeers(peer)
@@ -89,8 +86,16 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 	}
 
 	if peerAddress != nil {
-		context.AddressManager().AddAddresses(peerAddress)
+		subnetworkID := peer.SubnetworkID()
+		context.AddressManager().AddAddress(peerAddress, peerAddress, subnetworkID)
+		context.AddressManager().Good(peerAddress, subnetworkID)
 	}
+
+	err = context.StartIBDIfRequired()
+	if err != nil {
+		return nil, err
+	}
+
 	return peer, nil
 }
 

app/protocol/flows/handshake/receiveversion.go

@@ -5,7 +5,6 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -42,16 +41,11 @@ func ReceiveVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *receiveVersionFlow) start() (*appmessage.NetAddress, error) {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "receiveVersionFlow.start()")
-	defer onEnd()
-
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return nil, err
 	}
 
-	log.Debugf("Got version message")
-
 	msgVersion, ok := message.(*appmessage.MsgVersion)
 	if !ok {
 		return nil, protocolerrors.New(true, "a version message must precede all others")

app/protocol/flows/handshake/sendversion.go

@@ -4,7 +4,7 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
-	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/kaspanet/kaspad/version"
 )
@@ -48,14 +48,17 @@ func SendVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *sendVersionFlow) start() error {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "sendVersionFlow.start")
-	defer onEnd()
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+	selectedTipHash := consensusserialization.BlockHash(virtualSelectedParent)
+	subnetworkID := flow.Config().SubnetworkID
 
 	// Version message.
-	localAddress := flow.AddressManager().BestLocalAddress(flow.peer.Connection().NetAddress())
-	subnetworkID := flow.Config().SubnetworkID
+	localAddress := flow.AddressManager().GetBestLocalAddress(flow.peer.Connection().NetAddress())
 	msg := appmessage.NewMsgVersion(localAddress, flow.NetAdapter().ID(),
-		flow.Config().ActiveNetParams.Name, subnetworkID)
+		flow.Config().ActiveNetParams.Name, selectedTipHash, subnetworkID)
 	msg.AddUserAgent(userAgentName, userAgentVersion, flow.Config().UserAgentComments...)
 
 	// Advertise the services flag
@@ -67,17 +70,15 @@ func (flow *sendVersionFlow) start() error {
 	// Advertise if inv messages for transactions are desired.
 	msg.DisableRelayTx = flow.Config().BlocksOnly
 
-	err := flow.outgoingRoute.Enqueue(msg)
+	err = flow.outgoingRoute.Enqueue(msg)
 	if err != nil {
 		return err
 	}
 
 	// Wait for verack
-	log.Debugf("Waiting for verack")
 	_, err = flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
 	if err != nil {
 		return err
 	}
-	log.Debugf("Got verack")
 	return nil
 }

app/protocol/flows/ibd/handle_request_block_locator.go

@@ -1,4 +1,4 @@
-package blockrelay
+package ibd
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -32,16 +32,13 @@ func HandleRequestBlockLocator(context RequestBlockLocatorContext, incomingRoute
 
 func (flow *handleRequestBlockLocatorFlow) start() error {
 	for {
-		lowHash, highHash, limit, err := flow.receiveGetBlockLocator()
+		lowHash, highHash, err := flow.receiveGetBlockLocator()
 		if err != nil {
 			return err
 		}
 
-		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash, limit)
+		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash)
 		if err != nil || len(locator) == 0 {
-			if err != nil {
-				log.Debugf("Received error from CreateBlockLocator: %s", err)
-			}
 			return protocolerrors.Errorf(true, "couldn't build a block "+
 				"locator between blocks %s and %s", lowHash, highHash)
 		}
@@ -54,15 +51,15 @@ func (flow *handleRequestBlockLocatorFlow) start() error {
 }
 
 func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, limit uint32, err error) {
+	highHash *externalapi.DomainHash, err error) {
 
 	message, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return nil, nil, 0, err
+		return nil, nil, err
 	}
 	msgGetBlockLocator := message.(*appmessage.MsgRequestBlockLocator)
 
-	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, msgGetBlockLocator.Limit, nil
+	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, nil
 }
 
 func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator externalapi.BlockLocator) error {

app/protocol/flows/ibd/handle_request_ibd_blocks.go

@@ -1,4 +1,4 @@
-package blockrelay
+package ibd
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -10,9 +10,8 @@ import (
 )
 
 const ibdBatchSize = router.DefaultMaxMessages
-const maxHeaders = appmessage.MaxInvPerMsg
 
-// RequestIBDBlocksContext is the interface for the context needed for the HandleRequestHeaders flow.
+// RequestIBDBlocksContext is the interface for the context needed for the HandleRequestIBDBlocks flow.
 type RequestIBDBlocksContext interface {
 	Domain() domain.Domain
 }
@@ -22,8 +21,8 @@ type handleRequestBlocksFlow struct {
 	incomingRoute, outgoingRoute *router.Route
 }
 
-// HandleRequestHeaders handles RequestHeaders messages
-func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+// HandleRequestIBDBlocks handles getBlocks messages
+func HandleRequestIBDBlocks(context RequestIBDBlocksContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
 	flow := &handleRequestBlocksFlow{
 		RequestIBDBlocksContext: context,
 		incomingRoute:           incomingRoute,
@@ -34,24 +33,24 @@ func HandleRequestHeaders(context RequestIBDBlocksContext, incomingRoute *router
 
 func (flow *handleRequestBlocksFlow) start() error {
 	for {
-		lowHash, highHash, err := receiveRequestHeaders(flow.incomingRoute)
+		lowHash, highHash, err := receiveRequestIBDBlocks(flow.incomingRoute)
 		if err != nil {
 			return err
 		}
 
-		msgHeaders, err := flow.buildMsgBlockHeaders(lowHash, highHash)
+		msgIBDBlocks, err := flow.buildMsgIBDBlocks(lowHash, highHash)
 		if err != nil {
 			return err
 		}
 
-		for offset := 0; offset < len(msgHeaders); offset += ibdBatchSize {
+		for offset := 0; offset < len(msgIBDBlocks); offset += ibdBatchSize {
 			end := offset + ibdBatchSize
-			if end > len(msgHeaders) {
-				end = len(msgHeaders)
+			if end > len(msgIBDBlocks) {
+				end = len(msgIBDBlocks)
 			}
 
-			blocksToSend := msgHeaders[offset:end]
-			err = flow.sendHeaders(blocksToSend)
+			blocksToSend := msgIBDBlocks[offset:end]
+			err = flow.sendMsgIBDBlocks(blocksToSend)
 			if err != nil {
 				return nil
 			}
@@ -67,57 +66,57 @@ func (flow *handleRequestBlocksFlow) start() error {
 				return err
 			}
 
-			if _, ok := message.(*appmessage.MsgRequestNextHeaders); !ok {
+			if _, ok := message.(*appmessage.MsgRequestNextIBDBlocks); !ok {
 				return protocolerrors.Errorf(true, "received unexpected message type. "+
-					"expected: %s, got: %s", appmessage.CmdRequestNextHeaders, message.Command())
+					"expected: %s, got: %s", appmessage.CmdRequestNextIBDBlocks, message.Command())
 			}
 		}
-		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneHeaders())
+		err = flow.outgoingRoute.Enqueue(appmessage.NewMsgDoneIBDBlocks())
 		if err != nil {
 			return err
 		}
 	}
 }
 
-func receiveRequestHeaders(incomingRoute *router.Route) (lowHash *externalapi.DomainHash,
+func receiveRequestIBDBlocks(incomingRoute *router.Route) (lowHash *externalapi.DomainHash,
 	highHash *externalapi.DomainHash, err error) {
 
 	message, err := incomingRoute.Dequeue()
 	if err != nil {
 		return nil, nil, err
 	}
-	msgRequestIBDBlocks := message.(*appmessage.MsgRequestHeaders)
+	msgRequestIBDBlocks := message.(*appmessage.MsgRequestIBDBlocks)
 
 	return msgRequestIBDBlocks.LowHash, msgRequestIBDBlocks.HighHash, nil
 }
 
-func (flow *handleRequestBlocksFlow) buildMsgBlockHeaders(lowHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash) ([]*appmessage.MsgBlockHeader, error) {
+func (flow *handleRequestBlocksFlow) buildMsgIBDBlocks(lowHash *externalapi.DomainHash,
+	highHash *externalapi.DomainHash) ([]*appmessage.MsgIBDBlock, error) {
 
 	blockHashes, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash)
 	if err != nil {
 		return nil, err
 	}
-
-	if len(blockHashes) > maxHeaders {
-		blockHashes = blockHashes[:maxHeaders]
+	const maxHashesInMsgIBDBlocks = appmessage.MaxInvPerMsg
+	if len(blockHashes) > maxHashesInMsgIBDBlocks {
+		blockHashes = blockHashes[:maxHashesInMsgIBDBlocks]
 	}
 
-	msgBlockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
+	msgIBDBlocks := make([]*appmessage.MsgIBDBlock, len(blockHashes))
 	for i, blockHash := range blockHashes {
-		header, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
+		block, err := flow.Domain().Consensus().GetBlock(blockHash)
 		if err != nil {
 			return nil, err
 		}
-		msgBlockHeaders[i] = appmessage.DomainBlockHeaderToBlockHeader(header)
+		msgIBDBlocks[i] = appmessage.NewMsgIBDBlock(appmessage.DomainBlockToMsgBlock(block))
 	}
 
-	return msgBlockHeaders, nil
+	return msgIBDBlocks, nil
 }
 
-func (flow *handleRequestBlocksFlow) sendHeaders(headers []*appmessage.MsgBlockHeader) error {
-	for _, msgBlockHeader := range headers {
-		err := flow.outgoingRoute.Enqueue(msgBlockHeader)
+func (flow *handleRequestBlocksFlow) sendMsgIBDBlocks(msgIBDBlocks []*appmessage.MsgIBDBlock) error {
+	for _, msgIBDBlock := range msgIBDBlocks {
+		err := flow.outgoingRoute.Enqueue(msgIBDBlock)
 		if err != nil {
 			return err
 		}

app/protocol/flows/ibd/ibd.go

@@ -0,0 +1,213 @@
+package ibd
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// HandleIBDContext is the interface for the context needed for the HandleIBD flow.
+type HandleIBDContext interface {
+	Domain() domain.Domain
+	Config() *config.Config
+	OnNewBlock(block *externalapi.DomainBlock) error
+	FinishIBD() error
+}
+
+type handleIBDFlow struct {
+	HandleIBDContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// HandleIBD waits for IBD start and handles it when IBD is triggered for this peer
+func HandleIBD(context HandleIBDContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	flow := &handleIBDFlow{
+		HandleIBDContext: context,
+		incomingRoute:    incomingRoute,
+		outgoingRoute:    outgoingRoute,
+		peer:             peer,
+	}
+	return flow.start()
+}
+
+func (flow *handleIBDFlow) start() error {
+	for {
+		err := flow.runIBD()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleIBDFlow) runIBD() error {
+	flow.peer.WaitForIBDStart()
+	defer flow.FinishIBD()
+
+	peerSelectedTipHash := flow.peer.SelectedTipHash()
+	log.Debugf("Trying to find highest shared chain block with peer %s with selected tip %s", flow.peer, peerSelectedTipHash)
+	highestSharedBlockHash, err := flow.findHighestSharedBlockHash(peerSelectedTipHash)
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("Found highest shared chain block %s with peer %s", highestSharedBlockHash, flow.peer)
+
+	return flow.downloadBlocks(highestSharedBlockHash, peerSelectedTipHash)
+}
+
+func (flow *handleIBDFlow) findHighestSharedBlockHash(peerSelectedTipHash *externalapi.DomainHash) (lowHash *externalapi.DomainHash,
+	err error) {
+
+	lowHash = flow.Config().ActiveNetParams.GenesisHash
+	highHash := peerSelectedTipHash
+
+	for {
+		err := flow.sendGetBlockLocator(lowHash, highHash)
+		if err != nil {
+			return nil, err
+		}
+
+		blockLocatorHashes, err := flow.receiveBlockLocator()
+		if err != nil {
+			return nil, err
+		}
+
+		// We check whether the locator's highest hash is in the local DAG.
+		// If it is, return it. If it isn't, we need to narrow our
+		// getBlockLocator request and try again.
+		locatorHighHash := blockLocatorHashes[0]
+		locatorHighHashInfo, err := flow.Domain().Consensus().GetBlockInfo(locatorHighHash)
+		if err != nil {
+			return nil, err
+		}
+		if locatorHighHashInfo.Exists {
+			return locatorHighHash, nil
+		}
+
+		highHash, lowHash, err = flow.Domain().Consensus().FindNextBlockLocatorBoundaries(blockLocatorHashes)
+		if err != nil {
+			return nil, err
+		}
+	}
+}
+
+func (flow *handleIBDFlow) sendGetBlockLocator(lowHash *externalapi.DomainHash, highHash *externalapi.DomainHash) error {
+
+	msgGetBlockLocator := appmessage.NewMsgRequestBlockLocator(highHash, lowHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockLocator)
+}
+
+func (flow *handleIBDFlow) receiveBlockLocator() (blockLocatorHashes []*externalapi.DomainHash, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	msgBlockLocator, ok := message.(*appmessage.MsgBlockLocator)
+	if !ok {
+		return nil,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdBlockLocator, message.Command())
+	}
+	return msgBlockLocator.BlockLocatorHashes, nil
+}
+
+func (flow *handleIBDFlow) downloadBlocks(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
+
+	err := flow.sendGetBlocks(highestSharedBlockHash, peerSelectedTipHash)
+	if err != nil {
+		return err
+	}
+
+	blocksReceived := 0
+	for {
+		msgIBDBlock, doneIBD, err := flow.receiveIBDBlock()
+		if err != nil {
+			return err
+		}
+
+		if doneIBD {
+			return nil
+		}
+
+		err = flow.processIBDBlock(msgIBDBlock)
+		if err != nil {
+			return err
+		}
+
+		blocksReceived++
+		if blocksReceived%ibdBatchSize == 0 {
+			err = flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestNextIBDBlocks())
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (flow *handleIBDFlow) sendGetBlocks(highestSharedBlockHash *externalapi.DomainHash,
+	peerSelectedTipHash *externalapi.DomainHash) error {
+
+	msgGetBlockInvs := appmessage.NewMsgRequstIBDBlocks(highestSharedBlockHash, peerSelectedTipHash)
+	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
+}
+
+func (flow *handleIBDFlow) receiveIBDBlock() (msgIBDBlock *appmessage.MsgIBDBlock, doneIBD bool, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, false, err
+	}
+	switch message := message.(type) {
+	case *appmessage.MsgIBDBlock:
+		return message, false, nil
+	case *appmessage.MsgDoneIBDBlocks:
+		return nil, true, nil
+	default:
+		return nil, false,
+			protocolerrors.Errorf(true, "received unexpected message type. "+
+				"expected: %s, got: %s", appmessage.CmdIBDBlock, message.Command())
+	}
+}
+
+func (flow *handleIBDFlow) processIBDBlock(msgIBDBlock *appmessage.MsgIBDBlock) error {
+	block := appmessage.MsgBlockToDomainBlock(msgIBDBlock.MsgBlock)
+	blockHash := consensusserialization.BlockHash(block)
+	blockInfo, err := flow.Domain().Consensus().GetBlockInfo(blockHash)
+	if err != nil {
+		return err
+	}
+	if blockInfo.Exists {
+		log.Debugf("IBD block %s is already in the DAG. Skipping...", blockHash)
+		return nil
+	}
+	err = flow.Domain().Consensus().ValidateAndInsertBlock(block)
+	if err != nil {
+		if !errors.As(err, &ruleerrors.RuleError{}) {
+			return errors.Wrapf(err, "failed to process block %s during IBD", blockHash)
+		}
+		log.Infof("Rejected block %s from %s during IBD: %s", blockHash, flow.peer, err)
+
+		return protocolerrors.Wrapf(true, err, "got invalid block %s during IBD", blockHash)
+	}
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+	err = blocklogger.LogBlock(block)
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/protocol/flows/ibd/log.go

@@ -0,0 +1,9 @@
+package ibd
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.IBDS)
+var spawn = panics.GoroutineWrapperFunc(log)

app/protocol/flows/ibd/selectedtip/handle_request_selected_tip.go

@@ -0,0 +1,66 @@
+package selectedtip
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// HandleRequestSelectedTipContext is the interface for the context needed for the HandleRequestSelectedTip flow.
+type HandleRequestSelectedTipContext interface {
+	Domain() domain.Domain
+}
+
+type handleRequestSelectedTipFlow struct {
+	HandleRequestSelectedTipContext
+	incomingRoute, outgoingRoute *router.Route
+}
+
+// HandleRequestSelectedTip handles getSelectedTip messages
+func HandleRequestSelectedTip(context HandleRequestSelectedTipContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	flow := &handleRequestSelectedTipFlow{
+		HandleRequestSelectedTipContext: context,
+		incomingRoute:                   incomingRoute,
+		outgoingRoute:                   outgoingRoute,
+	}
+	return flow.start()
+}
+
+func (flow *handleRequestSelectedTipFlow) start() error {
+	for {
+		err := flow.receiveGetSelectedTip()
+		if err != nil {
+			return err
+		}
+
+		err = flow.sendSelectedTipHash()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *handleRequestSelectedTipFlow) receiveGetSelectedTip() error {
+	message, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return err
+	}
+	_, ok := message.(*appmessage.MsgRequestSelectedTip)
+	if !ok {
+		return errors.Errorf("received unexpected message type. "+
+			"expected: %s, got: %s", appmessage.CmdRequestSelectedTip, message.Command())
+	}
+
+	return nil
+}
+
+func (flow *handleRequestSelectedTipFlow) sendSelectedTipHash() error {
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	if err != nil {
+		return err
+	}
+	msgSelectedTip := appmessage.NewMsgSelectedTip(consensusserialization.BlockHash(virtualSelectedParent))
+	return flow.outgoingRoute.Enqueue(msgSelectedTip)
+}

app/protocol/flows/ibd/selectedtip/request_selected_tip.go

@@ -0,0 +1,78 @@
+package selectedtip
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// RequestSelectedTipContext is the interface for the context needed for the RequestSelectedTip flow.
+type RequestSelectedTipContext interface {
+	Domain() domain.Domain
+	StartIBDIfRequired() error
+}
+
+type requestSelectedTipFlow struct {
+	RequestSelectedTipContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+}
+
+// RequestSelectedTip waits for selected tip requests and handles them
+func RequestSelectedTip(context RequestSelectedTipContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	flow := &requestSelectedTipFlow{
+		RequestSelectedTipContext: context,
+		incomingRoute:             incomingRoute,
+		outgoingRoute:             outgoingRoute,
+		peer:                      peer,
+	}
+	return flow.start()
+}
+
+func (flow *requestSelectedTipFlow) start() error {
+	for {
+		err := flow.runSelectedTipRequest()
+		if err != nil {
+			return err
+		}
+	}
+}
+
+func (flow *requestSelectedTipFlow) runSelectedTipRequest() error {
+
+	flow.peer.WaitForSelectedTipRequests()
+	defer flow.peer.FinishRequestingSelectedTip()
+
+	err := flow.requestSelectedTip()
+	if err != nil {
+		return err
+	}
+
+	peerSelectedTipHash, err := flow.receiveSelectedTip()
+	if err != nil {
+		return err
+	}
+
+	flow.peer.SetSelectedTipHash(peerSelectedTipHash)
+	return flow.StartIBDIfRequired()
+}
+
+func (flow *requestSelectedTipFlow) requestSelectedTip() error {
+	msgGetSelectedTip := appmessage.NewMsgRequestSelectedTip()
+	return flow.outgoingRoute.Enqueue(msgGetSelectedTip)
+}
+
+func (flow *requestSelectedTipFlow) receiveSelectedTip() (selectedTipHash *externalapi.DomainHash, err error) {
+	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return nil, err
+	}
+	msgSelectedTip := message.(*appmessage.MsgSelectedTip)
+
+	return msgSelectedTip.SelectedTipHash, nil
+}

app/protocol/flows/relaytransactions/handle_relayed_transactions.go

@@ -1,4 +1,4 @@
-package transactionrelay
+package relaytransactions
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -6,7 +6,7 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -167,7 +167,7 @@ func (flow *handleRelayedTransactionsFlow) receiveTransactions(requestedTransact
 			continue
 		}
 		tx := appmessage.MsgTxToDomainTransaction(msgTx)
-		txID := consensushashing.TransactionID(tx)
+		txID := consensusserialization.TransactionID(tx)
 		if txID != expectedID {
 			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
 				expectedID, txID)

app/protocol/flows/relaytransactions/handle_requested_transactions.go

@@ -1,4 +1,4 @@
-package transactionrelay
+package relaytransactions
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"

app/protocol/flows/relaytransactions/shared_requested_transactions.go

@@ -1,4 +1,4 @@
-package transactionrelay
+package relaytransactions
 
 import (
 	"sync"

app/protocol/manager.go

@@ -37,6 +37,12 @@ func (m *Manager) Peers() []*peerpkg.Peer {
 	return m.context.Peers()
 }
 
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (m *Manager) IBDPeer() *peerpkg.Peer {
+	return m.context.IBDPeer()
+}
+
 // AddTransaction adds transaction to the mempool and propagates it.
 func (m *Manager) AddTransaction(tx *externalapi.DomainTransaction) error {
 	return m.context.AddTransaction(tx)

app/protocol/peer/peer.go

@@ -2,6 +2,7 @@ package peer
 
 import (
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -13,14 +14,13 @@ import (
 	"github.com/kaspanet/kaspad/util/mstime"
 )
 
-// maxProtocolVersion version is the maximum supported protocol
-// version this kaspad node supports
-const maxProtocolVersion = 1
-
 // Peer holds data about a peer.
 type Peer struct {
 	connection *netadapter.NetConnection
 
+	selectedTipHashMtx sync.RWMutex
+	selectedTipHash    *externalapi.DomainHash
+
 	userAgent                string
 	services                 appmessage.ServiceFlag
 	advertisedProtocolVerion uint32 // protocol version advertised by remote
@@ -35,13 +35,21 @@ type Peer struct {
 	lastPingNonce    uint64        // The nonce of the last ping we sent
 	lastPingTime     time.Time     // Time we sent last ping
 	lastPingDuration time.Duration // Time for last ping to return
+
+	isSelectedTipRequested uint32
+	selectedTipRequestChan chan struct{}
+	lastSelectedTipRequest mstime.Time
+
+	ibdStartChan chan struct{}
 }
 
 // New returns a new Peer
 func New(connection *netadapter.NetConnection) *Peer {
 	return &Peer{
-		connection:        connection,
-		connectionStarted: time.Now(),
+		connection:             connection,
+		selectedTipRequestChan: make(chan struct{}),
+		ibdStartChan:           make(chan struct{}),
+		connectionStarted:      time.Now(),
 	}
 }
 
@@ -50,6 +58,20 @@ func (p *Peer) Connection() *netadapter.NetConnection {
 	return p.connection
 }
 
+// SelectedTipHash returns the selected tip of the peer.
+func (p *Peer) SelectedTipHash() *externalapi.DomainHash {
+	p.selectedTipHashMtx.RLock()
+	defer p.selectedTipHashMtx.RUnlock()
+	return p.selectedTipHash
+}
+
+// SetSelectedTipHash sets the selected tip of the peer.
+func (p *Peer) SetSelectedTipHash(hash *externalapi.DomainHash) {
+	p.selectedTipHashMtx.Lock()
+	defer p.selectedTipHashMtx.Unlock()
+	p.selectedTipHash = hash
+}
+
 // SubnetworkID returns the subnetwork the peer is associated with.
 // It is nil in full nodes.
 func (p *Peer) SubnetworkID() *externalapi.DomainSubnetworkID {
@@ -90,9 +112,9 @@ func (p *Peer) IsOutbound() bool {
 func (p *Peer) UpdateFieldsFromMsgVersion(msg *appmessage.MsgVersion) {
 	// Negotiate the protocol version.
 	p.advertisedProtocolVerion = msg.ProtocolVersion
-	p.protocolVersion = mathUtil.MinUint32(maxProtocolVersion, p.advertisedProtocolVerion)
+	p.protocolVersion = mathUtil.MinUint32(p.protocolVersion, p.advertisedProtocolVerion)
 	log.Debugf("Negotiated protocol version %d for peer %s",
-		p.protocolVersion, p)
+		p.protocolVersion, p.ID())
 
 	// Set the supported services for the peer to what the remote peer
 	// advertised.
@@ -102,6 +124,7 @@ func (p *Peer) UpdateFieldsFromMsgVersion(msg *appmessage.MsgVersion) {
 	p.userAgent = msg.UserAgent
 
 	p.disableRelayTx = msg.DisableRelayTx
+	p.selectedTipHash = msg.SelectedTipHash
 	p.subnetworkID = msg.SubnetworkID
 
 	p.timeOffset = mstime.Since(msg.Timestamp)
@@ -129,6 +152,46 @@ func (p *Peer) String() string {
 	return p.connection.String()
 }
 
+// RequestSelectedTipIfRequired notifies the peer that requesting
+// a selected tip is required. This triggers the selected tip
+// request flow.
+func (p *Peer) RequestSelectedTipIfRequired() {
+	if atomic.SwapUint32(&p.isSelectedTipRequested, 1) != 0 {
+		return
+	}
+
+	const minGetSelectedTipInterval = time.Minute
+	if mstime.Since(p.lastSelectedTipRequest) < minGetSelectedTipInterval {
+		return
+	}
+
+	p.lastSelectedTipRequest = mstime.Now()
+	p.selectedTipRequestChan <- struct{}{}
+}
+
+// WaitForSelectedTipRequests blocks the current thread until
+// a selected tip is requested from this peer
+func (p *Peer) WaitForSelectedTipRequests() {
+	<-p.selectedTipRequestChan
+}
+
+// FinishRequestingSelectedTip finishes requesting the selected
+// tip from this peer
+func (p *Peer) FinishRequestingSelectedTip() {
+	atomic.StoreUint32(&p.isSelectedTipRequested, 0)
+}
+
+// StartIBD starts the IBD process for this peer
+func (p *Peer) StartIBD() {
+	p.ibdStartChan <- struct{}{}
+}
+
+// WaitForIBDStart blocks the current thread until
+// IBD start is requested from this peer
+func (p *Peer) WaitForIBDStart() {
+	<-p.ibdStartChan
+}
+
 // Address returns the address associated with this connection
 func (p *Peer) Address() string {
 	return p.connection.Address()

app/protocol/protocol.go

@@ -8,8 +8,10 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/flows/addressexchange"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
 	"github.com/kaspanet/kaspad/app/protocol/flows/handshake"
+	"github.com/kaspanet/kaspad/app/protocol/flows/ibd"
+	"github.com/kaspanet/kaspad/app/protocol/flows/ibd/selectedtip"
 	"github.com/kaspanet/kaspad/app/protocol/flows/ping"
-	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
@@ -48,9 +50,15 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 			return
 		}
 
-		netConnection.SetOnInvalidMessageHandler(func(err error) {
-			if atomic.AddUint32(&isStopping, 1) == 1 {
-				errChan <- protocolerrors.Wrap(true, err, "received bad message")
+		spawn("Manager.routerInitializer-netConnection.DequeueInvalidMessage", func() {
+			for {
+				isOpen, err := netConnection.DequeueInvalidMessage()
+				if !isOpen {
+					return
+				}
+				if atomic.AddUint32(&isStopping, 1) == 1 {
+					errChan <- protocolerrors.Wrap(true, err, "received bad message")
+				}
 			}
 		})
 
@@ -105,6 +113,7 @@ func (m *Manager) registerFlows(router *routerpkg.Router, errChan chan error, is
 	flows = m.registerAddressFlows(router, isStopping, errChan)
 	flows = append(flows, m.registerBlockRelayFlows(router, isStopping, errChan)...)
 	flows = append(flows, m.registerPingFlows(router, isStopping, errChan)...)
+	flows = append(flows, m.registerIBDFlows(router, isStopping, errChan)...)
 	flows = append(flows, m.registerTransactionRelayFlow(router, isStopping, errChan)...)
 	flows = append(flows, m.registerRejectsFlow(router, isStopping, errChan)...)
 
@@ -115,7 +124,7 @@ func (m *Manager) registerAddressFlows(router *routerpkg.Router, isStopping *uin
 	outgoingRoute := router.OutgoingRoute()
 
 	return []*flow{
-		m.registerFlow("SendAddresses", router, []appmessage.MessageCommand{appmessage.CmdRequestAddresses}, isStopping, errChan,
+		m.registerOneTimeFlow("SendAddresses", router, []appmessage.MessageCommand{appmessage.CmdRequestAddresses}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return addressexchange.SendAddresses(m.context, incomingRoute, outgoingRoute)
 			},
@@ -133,10 +142,7 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 	outgoingRoute := router.OutgoingRoute()
 
 	return []*flow{
-		m.registerFlow("HandleRelayInvs", router, []appmessage.MessageCommand{
-			appmessage.CmdInvRelayBlock, appmessage.CmdBlock, appmessage.CmdBlockLocator, appmessage.CmdIBDBlock,
-			appmessage.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetAndBlock,
-			appmessage.CmdHeader}, isStopping, errChan,
+		m.registerFlow("HandleRelayInvs", router, []appmessage.MessageCommand{appmessage.CmdInvRelayBlock, appmessage.CmdBlock}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
 					outgoingRoute, peer)
@@ -148,34 +154,6 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 				return blockrelay.HandleRelayBlockRequests(m.context, incomingRoute, outgoingRoute, peer)
 			},
 		),
-
-		m.registerFlow("HandleRequestBlockLocator", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestBlockLocator}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestBlockLocator(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleRequestHeaders", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestHeaders, appmessage.CmdRequestNextHeaders}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestHeaders(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleRequestIBDRootUTXOSetAndBlock", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootUTXOSetAndBlock}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleRequestIBDRootUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleIBDBlockRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDBlocks}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return blockrelay.HandleIBDBlockRequests(m.context, incomingRoute, outgoingRoute)
-			},
-		),
 	}
 }
 
@@ -197,6 +175,43 @@ func (m *Manager) registerPingFlows(router *routerpkg.Router, isStopping *uint32
 	}
 }
 
+func (m *Manager) registerIBDFlows(router *routerpkg.Router, isStopping *uint32, errChan chan error) []*flow {
+	outgoingRoute := router.OutgoingRoute()
+
+	return []*flow{
+		m.registerFlow("HandleIBD", router, []appmessage.MessageCommand{appmessage.CmdBlockLocator, appmessage.CmdIBDBlock,
+			appmessage.CmdDoneIBDBlocks}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return ibd.HandleIBD(m.context, incomingRoute, outgoingRoute, peer)
+			},
+		),
+
+		m.registerFlow("RequestSelectedTip", router, []appmessage.MessageCommand{appmessage.CmdSelectedTip}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return selectedtip.RequestSelectedTip(m.context, incomingRoute, outgoingRoute, peer)
+			},
+		),
+
+		m.registerFlow("HandleRequestSelectedTip", router, []appmessage.MessageCommand{appmessage.CmdRequestSelectedTip}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return selectedtip.HandleRequestSelectedTip(m.context, incomingRoute, outgoingRoute)
+			},
+		),
+
+		m.registerFlow("HandleRequestBlockLocator", router, []appmessage.MessageCommand{appmessage.CmdRequestBlockLocator}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return ibd.HandleRequestBlockLocator(m.context, incomingRoute, outgoingRoute)
+			},
+		),
+
+		m.registerFlow("HandleRequestIBDBlocks", router, []appmessage.MessageCommand{appmessage.CmdRequestIBDBlocks, appmessage.CmdRequestNextIBDBlocks}, isStopping, errChan,
+			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
+				return ibd.HandleRequestIBDBlocks(m.context, incomingRoute, outgoingRoute)
+			},
+		),
+	}
+}
+
 func (m *Manager) registerTransactionRelayFlow(router *routerpkg.Router, isStopping *uint32, errChan chan error) []*flow {
 	outgoingRoute := router.OutgoingRoute()
 
@@ -204,13 +219,13 @@ func (m *Manager) registerTransactionRelayFlow(router *routerpkg.Router, isStopp
 		m.registerFlow("HandleRelayedTransactions", router,
 			[]appmessage.MessageCommand{appmessage.CmdInvTransaction, appmessage.CmdTx, appmessage.CmdTransactionNotFound}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return transactionrelay.HandleRelayedTransactions(m.context, incomingRoute, outgoingRoute)
+				return relaytransactions.HandleRelayedTransactions(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 		m.registerFlow("HandleRequestTransactions", router,
 			[]appmessage.MessageCommand{appmessage.CmdRequestTransactions}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return transactionrelay.HandleRequestedTransactions(m.context, incomingRoute, outgoingRoute)
+				return relaytransactions.HandleRequestedTransactions(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 	}

app/protocol/protocolerrors/protocolerrors.go

@@ -1,9 +1,6 @@
 package protocolerrors
 
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/pkg/errors"
-)
+import "github.com/pkg/errors"
 
 // ProtocolError is an error that signifies a violation
 // of the peer-to-peer protocol
@@ -53,14 +50,3 @@ func Wrapf(shouldBan bool, err error, format string, args ...interface{}) error
 		Cause:     errors.Wrapf(err, format, args...),
 	}
 }
-
-// ConvertToBanningProtocolErrorIfRuleError converts the given error to
-// a banning protocol error if it's a rule error, and otherwise keep it
-// as is.
-func ConvertToBanningProtocolErrorIfRuleError(err error, format string, args ...interface{}) error {
-	if !errors.As(err, &ruleerrors.RuleError{}) {
-		return err
-	}
-
-	return Wrapf(true, err, format, args...)
-}

app/rpc/rpc.go

@@ -32,7 +32,7 @@ var handlers = map[appmessage.MessageCommand]handler{
 	appmessage.CmdResolveFinalityConflictRequestMessage: rpchandlers.HandleResolveFinalityConflict,
 	appmessage.CmdNotifyFinalityConflictsRequestMessage: rpchandlers.HandleNotifyFinalityConflicts,
 	appmessage.CmdGetMempoolEntriesRequestMessage:       rpchandlers.HandleGetMempoolEntries,
-	appmessage.CmdShutDownRequestMessage:                rpchandlers.HandleShutDown,
+	appmessage.CmdShutDownRequestMessage:                rpchandlers.HandleGetMempoolEntries,
 	appmessage.CmdGetHeadersRequestMessage:              rpchandlers.HandleGetHeaders,
 }
 

app/rpc/rpccontext/notificationmanager.go

@@ -65,9 +65,7 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 	for router, listener := range nm.listeners {
 		if listener.propagateBlockAddedNotifications {
 			err := router.OutgoingRoute().Enqueue(notification)
-			if errors.Is(err, routerpkg.ErrRouteClosed) {
-				log.Warnf("Couldn't send notification: %s", err)
-			} else if err != nil {
+			if err != nil {
 				return err
 			}
 		}

app/rpc/rpccontext/verbosedata.go

@@ -3,7 +3,6 @@ package rpccontext
 import (
 	"encoding/hex"
 	"fmt"
-	"math"
 	"math/big"
 	"strconv"
 
@@ -14,7 +13,7 @@ import (
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/pointers"
@@ -23,13 +22,9 @@ import (
 // BuildBlockVerboseData builds a BlockVerboseData from the given block.
 // This method must be called with the DAG lock held for reads
 func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includeTransactionVerboseData bool) (*appmessage.BlockVerboseData, error) {
-	hash := consensushashing.BlockHash(block)
+	hash := consensusserialization.BlockHash(block)
 	blockHeader := block.Header
 
-	blockInfo, err := ctx.Domain.Consensus().GetBlockInfo(hash)
-	if err != nil {
-		return nil, err
-	}
 	result := &appmessage.BlockVerboseData{
 		Hash:                 hash.String(),
 		Version:              blockHeader.Version,
@@ -42,19 +37,18 @@ func (ctx *Context) BuildBlockVerboseData(block *externalapi.DomainBlock, includ
 		Time:                 blockHeader.TimeInMilliseconds,
 		Bits:                 strconv.FormatInt(int64(blockHeader.Bits), 16),
 		Difficulty:           ctx.GetDifficultyRatio(blockHeader.Bits, ctx.Config.ActiveNetParams),
-		BlueScore:            blockInfo.BlueScore,
 	}
 
 	txIDs := make([]string, len(block.Transactions))
 	for i, tx := range block.Transactions {
-		txIDs[i] = consensushashing.TransactionID(tx).String()
+		txIDs[i] = consensusserialization.TransactionID(tx).String()
 	}
 	result.TxIDs = txIDs
 
 	if includeTransactionVerboseData {
 		transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
 		for i, tx := range block.Transactions {
-			txID := consensushashing.TransactionID(tx).String()
+			txID := consensusserialization.TransactionID(tx).String()
 			data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
 			if err != nil {
 				return nil, err
@@ -77,11 +71,12 @@ func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) fl
 	target := util.CompactToBig(bits)
 
 	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
-	diff, _ := difficulty.Float64()
-
-	roundingPrecision := float64(100)
-	diff = math.Round(diff*roundingPrecision) / roundingPrecision
-
+	outString := difficulty.FloatString(8)
+	diff, err := strconv.ParseFloat(outString, 64)
+	if err != nil {
+		log.Errorf("Cannot get difficulty: %s", err)
+		return 0
+	}
 	return diff
 }
 
@@ -98,7 +93,7 @@ func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransactio
 
 	txReply := &appmessage.TransactionVerboseData{
 		TxID:                      txID,
-		Hash:                      consensushashing.TransactionHash(tx).String(),
+		Hash:                      consensusserialization.TransactionHash(tx).String(),
 		Size:                      estimatedsize.TransactionEstimatedSerializedSize(tx),
 		TransactionVerboseInputs:  ctx.buildTransactionVerboseInputs(tx),
 		TransactionVerboseOutputs: ctx.buildTransactionVerboseOutputs(tx, nil),

app/rpc/rpchandlers/get_block_count.go

@@ -8,10 +8,6 @@ import (
 
 // HandleGetBlockCount handles the respectively named RPC command
 func HandleGetBlockCount(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	syncInfo, err := context.Domain.Consensus().GetSyncInfo()
-	if err != nil {
-		return nil, err
-	}
-	response := appmessage.NewGetBlockCountResponseMessage(syncInfo)
+	response := appmessage.NewGetBlockCountResponseMessage(0) // TODO
 	return response, nil
 }

app/rpc/rpchandlers/get_block_dag_info.go

@@ -3,38 +3,15 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetBlockDAGInfo handles the respectively named RPC command
 func HandleGetBlockDAGInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
 	params := context.Config.ActiveNetParams
-	consensus := context.Domain.Consensus()
 
 	response := appmessage.NewGetBlockDAGInfoResponseMessage()
 	response.NetworkName = params.Name
 
-	syncInfo, err := consensus.GetSyncInfo()
-	if err != nil {
-		return nil, err
-	}
-	response.BlockCount = syncInfo.BlockCount
-	response.HeaderCount = syncInfo.HeaderCount
-
-	tipHashes, err := consensus.Tips()
-	if err != nil {
-		return nil, err
-	}
-	response.TipHashes = hashes.ToStrings(tipHashes)
-
-	virtualInfo, err := consensus.GetVirtualInfo()
-	if err != nil {
-		return nil, err
-	}
-	response.VirtualParentHashes = hashes.ToStrings(virtualInfo.ParentHashes)
-	response.Difficulty = context.GetDifficultyRatio(virtualInfo.Bits, context.Config.ActiveNetParams)
-	response.PastMedianTime = virtualInfo.PastMedianTime
-
 	return response, nil
 }

app/rpc/rpchandlers/get_block_template.go

@@ -27,11 +27,7 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 
 	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey}
 
-	templateBlock, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
-	if err != nil {
-		return nil, err
-	}
-	msgBlock := appmessage.DomainBlockToMsgBlock(templateBlock)
+	templateBlock := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
 
-	return appmessage.NewGetBlockTemplateResponseMessage(msgBlock), nil
+	return appmessage.DomainBlockToMsgBlock(templateBlock), nil
 }

app/rpc/rpchandlers/get_blocks.go

@@ -14,7 +14,6 @@ const (
 
 // HandleGetBlocks handles the respectively named RPC command
 func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetBlocksResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+
+	return nil, nil
 }

app/rpc/rpchandlers/get_chain_from_block.go

@@ -14,7 +14,5 @@ const (
 
 // HandleGetChainFromBlock handles the respectively named RPC command
 func HandleGetChainFromBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetChainFromBlockResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+	return nil, nil
 }

app/rpc/rpchandlers/get_connected_peer_info.go

@@ -9,12 +9,15 @@ import (
 // HandleGetConnectedPeerInfo handles the respectively named RPC command
 func HandleGetConnectedPeerInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
 	peers := context.ProtocolManager.Peers()
+	ibdPeer := context.ProtocolManager.IBDPeer()
 	infos := make([]*appmessage.GetConnectedPeerInfoMessage, 0, len(peers))
 	for _, peer := range peers {
 		info := &appmessage.GetConnectedPeerInfoMessage{
 			ID:                        peer.ID().String(),
 			Address:                   peer.Address(),
 			LastPingDuration:          peer.LastPingDuration().Milliseconds(),
+			SelectedTipHash:           peer.SelectedTipHash().String(),
+			IsSyncNode:                peer == ibdPeer,
 			IsOutbound:                peer.IsOutbound(),
 			TimeOffset:                peer.TimeOffset().Milliseconds(),
 			UserAgent:                 peer.UserAgent(),

app/rpc/rpchandlers/get_headers.go

@@ -8,7 +8,5 @@ import (
 
 // HandleGetHeaders handles the respectively named RPC command
 func HandleGetHeaders(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetHeadersResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+	return nil, nil
 }

app/rpc/rpchandlers/get_mempool_entries.go

@@ -8,7 +8,5 @@ import (
 
 // HandleGetMempoolEntries handles the respectively named RPC command
 func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetMempoolEntriesResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+	return nil, nil
 }

app/rpc/rpchandlers/get_mempool_entry.go

@@ -8,5 +8,5 @@ import (
 
 // HandleGetMempoolEntry handles the respectively named RPC command
 func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	return &appmessage.GetMempoolEntryResponseMessage{}, nil
+	return nil, nil
 }

app/rpc/rpchandlers/get_peer_addresses.go

@@ -1,9 +1,6 @@
 package rpchandlers
 
 import (
-	"net"
-	"strconv"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -11,20 +8,14 @@ import (
 
 // HandleGetPeerAddresses handles the respectively named RPC command
 func HandleGetPeerAddresses(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
-	netAddresses := context.AddressManager.Addresses()
-	addressMessages := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(netAddresses))
-	for i, netAddress := range netAddresses {
-		addressWithPort := net.JoinHostPort(netAddress.IP.String(), strconv.FormatUint(uint64(netAddress.Port), 10))
-		addressMessages[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: addressWithPort}
+	peersState, err := context.AddressManager.PeersStateForSerialization()
+	if err != nil {
+		return nil, err
 	}
-
-	bannedAddresses := context.AddressManager.BannedAddresses()
-	bannedAddressMessages := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(bannedAddresses))
-	for i, netAddress := range bannedAddresses {
-		addressWithPort := net.JoinHostPort(netAddress.IP.String(), strconv.FormatUint(uint64(netAddress.Port), 10))
-		bannedAddressMessages[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: addressWithPort}
+	addresses := make([]*appmessage.GetPeerAddressesKnownAddressMessage, len(peersState.Addresses))
+	for i, address := range peersState.Addresses {
+		addresses[i] = &appmessage.GetPeerAddressesKnownAddressMessage{Addr: string(address.Address)}
 	}
-
-	response := appmessage.NewGetPeerAddressesResponseMessage(addressMessages, bannedAddressMessages)
+	response := appmessage.NewGetPeerAddressesResponseMessage(addresses)
 	return response, nil
 }

app/rpc/rpchandlers/get_selected_tip_hash.go

@@ -3,7 +3,7 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -15,7 +15,7 @@ func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ a
 	}
 
 	response := appmessage.NewGetSelectedTipHashResponseMessage(
-		consensushashing.BlockHash(selectedTip).String())
+		consensusserialization.BlockHash(selectedTip).String())
 
 	return response, nil
 }

app/rpc/rpchandlers/get_subnetwork.go

@@ -8,7 +8,5 @@ import (
 
 // HandleGetSubnetwork handles the respectively named RPC command
 func HandleGetSubnetwork(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.GetSubnetworkResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+	return nil, nil
 }

app/rpc/rpchandlers/resolve_finality_conflict.go

@@ -8,7 +8,5 @@ import (
 
 // HandleResolveFinalityConflict handles the respectively named RPC command
 func HandleResolveFinalityConflict(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	response := &appmessage.ResolveFinalityConflictResponseMessage{}
-	response.Error = appmessage.RPCErrorf("not implemented")
-	return response, nil
+	return nil, nil
 }

app/rpc/rpchandlers/submit_block.go

@@ -3,7 +3,7 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -21,7 +21,7 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 		return errorMessage, nil
 	}
 
-	log.Infof("Accepted block %s via submitBlock", consensushashing.BlockHash(domainBlock))
+	log.Infof("Accepted domainBlock %s via submitBlock", consensusserialization.BlockHash(domainBlock))
 
 	response := appmessage.NewSubmitBlockResponseMessage()
 	return response, nil

app/rpc/rpchandlers/submit_transaction.go

@@ -3,7 +3,7 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
@@ -14,7 +14,7 @@ func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, requ
 	submitTransactionRequest := request.(*appmessage.SubmitTransactionRequestMessage)
 
 	domainTransaction := appmessage.MsgTxToDomainTransaction(submitTransactionRequest.Transaction)
-	transactionID := consensushashing.TransactionID(domainTransaction)
+	transactionID := consensusserialization.TransactionID(domainTransaction)
 	err := context.ProtocolManager.AddTransaction(domainTransaction)
 	if err != nil {
 		if !errors.As(err, &mempool.RuleError{}) {

cmd/kaspactl/docker/Dockerfile

@@ -6,8 +6,7 @@ RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 WORKDIR /go/src/github.com/kaspanet/kaspad
 
 RUN apk add --no-cache curl git openssh binutils gcc musl-dev
-RUN go get -u golang.org/x/lint/golint \
-              honnef.co/go/tools/cmd/staticcheck 
+RUN go get -u golang.org/x/lint/golint
 
 COPY go.mod .
 COPY go.sum .
@@ -21,7 +20,6 @@ WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspactl
 RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
 RUN go vet ./...
 RUN golint -set_exit_status ./...
-RUN staticcheck -checks SA4006 ./...
 RUN GOOS=linux go build -a -installsuffix cgo -o kaspactl .
 
 # --- multistage docker build: stage #2: runtime image

cmd/kaspaminer/docker/Dockerfile

@@ -6,8 +6,7 @@ RUN mkdir -p /go/src/github.com/kaspanet/kaspad
 WORKDIR /go/src/github.com/kaspanet/kaspad
 
 RUN apk add --no-cache curl git openssh binutils gcc musl-dev
-RUN go get -u golang.org/x/lint/golint \
-              honnef.co/go/tools/cmd/staticcheck 
+RUN go get -u golang.org/x/lint/golint
 
 COPY go.mod .
 COPY go.sum .
@@ -21,7 +20,6 @@ WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspaminer
 RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
 RUN go vet ./...
 RUN golint -set_exit_status ./...
-RUN staticcheck -checks SA4006 ./...
 RUN GOOS=linux go build -a -installsuffix cgo -o kaspaminer .
 
 # --- multistage docker build: stage #2: runtime image

cmd/kaspaminer/mineloop.go

@@ -2,13 +2,14 @@ package main
 
 import (
 	nativeerrors "errors"
-	"github.com/kaspanet/kaspad/domain/consensus/model/pow"
 	"math/rand"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
@@ -94,7 +95,7 @@ func mineNextBlock(client *minerClient, miningAddr util.Address, foundBlock chan
 }
 
 func handleFoundBlock(client *minerClient, block *externalapi.DomainBlock) error {
-	blockHash := consensushashing.BlockHash(block)
+	blockHash := consensusserialization.BlockHash(block)
 	log.Infof("Found block %s with parents %s. Submitting to %s", blockHash, block.Header.ParentHashes, client.Address())
 
 	err := client.SubmitBlock(block)
@@ -113,8 +114,9 @@ func solveBlock(block *externalapi.DomainBlock, stopChan chan struct{}, foundBlo
 			return
 		default:
 			block.Header.Nonce = i
+			hash := consensusserialization.BlockHash(block)
 			atomic.AddUint64(&hashesTried, 1)
-			if pow.CheckProofOfWorkWithTarget(block.Header, targetDifficulty) {
+			if hashes.ToBig(hash).Cmp(targetDifficulty) <= 0 {
 				foundBlock <- block
 				return
 			}

docker/Dockerfile

@@ -10,8 +10,7 @@ RUN go get -u golang.org/x/lint/golint \
       github.com/kisielk/errcheck \
       github.com/opennota/check/cmd/aligncheck \
       github.com/opennota/check/cmd/structcheck \
-      github.com/opennota/check/cmd/varcheck \
-      honnef.co/go/tools/cmd/staticcheck 
+      github.com/opennota/check/cmd/varcheck
 
 COPY go.mod .
 COPY go.sum .
@@ -26,7 +25,6 @@ RUN golint -set_exit_status ./...
 # RUN aligncheck ./...
 # RUN structcheck -e ./...
 # RUN varcheck -e ./...
-RUN staticcheck -checks "SA4006,SA4008,SA4009,SA4010,SA5003,SA1004,SA1014,SA1021,SA1023,SA1024,SA1025,SA1026,SA1027,SA1028,SA2000,SA2001,SA2003,SA4000,SA4001,SA4003,SA4004,SA4011,SA4012,SA4013,SA4014,SA4015,SA4016,SA4017,SA4018,SA4019,SA4020,SA4021,SA4022,SA4023,SA5000,SA5002,SA5004,SA5005,SA5007,SA5008,SA5009,SA5010,SA5011,SA5012,SA6001,SA6002,SA9001,SA9002,SA9003,SA9004,SA9005,SA9006,ST1019" ./...
 RUN GOOS=linux go build -a -installsuffix cgo -o kaspad .
 
 # Remove the line below and uncomment the line after it for testing with coverage

domain/consensus/consensus.go

@@ -1,49 +1,44 @@
 package consensus
 
 import (
-	"sync"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/pkg/errors"
 )
 
+// Consensus maintains the current core state of the node
+type Consensus interface {
+	BuildBlock(coinbaseData *externalapi.DomainCoinbaseData, transactions []*externalapi.DomainTransaction) (*externalapi.DomainBlock, error)
+	ValidateAndInsertBlock(block *externalapi.DomainBlock) error
+	ValidateTransactionAndPopulateWithConsensusData(transaction *externalapi.DomainTransaction) error
+
+	GetBlock(blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error)
+	GetBlockHeader(blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error)
+	GetBlockInfo(blockHash *externalapi.DomainHash) (*externalapi.BlockInfo, error)
+
+	GetHashesBetween(lowHash, highHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error)
+	GetMissingBlockBodyHashes(highHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error)
+	GetPruningPointUTXOSet() ([]byte, error)
+	SetPruningPointUTXOSet(serializedUTXOSet []byte) error
+	GetVirtualSelectedParent() (*externalapi.DomainBlock, error)
+	CreateBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error)
+	FindNextBlockLocatorBoundaries(blockLocator externalapi.BlockLocator) (lowHash, highHash *externalapi.DomainHash, err error)
+	GetSyncInfo() (*externalapi.SyncInfo, error)
+}
+
 type consensus struct {
-	lock            *sync.Mutex
 	databaseContext model.DBReader
 
 	blockProcessor        model.BlockProcessor
-	blockBuilder          model.BlockBuilder
 	consensusStateManager model.ConsensusStateManager
 	transactionValidator  model.TransactionValidator
 	syncManager           model.SyncManager
 	pastMedianTimeManager model.PastMedianTimeManager
-	blockValidator        model.BlockValidator
-	coinbaseManager       model.CoinbaseManager
-	dagTopologyManager    model.DAGTopologyManager
-	dagTraversalManager   model.DAGTraversalManager
-	difficultyManager     model.DifficultyManager
-	ghostdagManager       model.GHOSTDAGManager
-	headerTipsManager     model.HeaderTipsManager
-	mergeDepthManager     model.MergeDepthManager
-	pruningManager        model.PruningManager
-	reachabilityManager   model.ReachabilityManager
-	finalityManager       model.FinalityManager
 
-	acceptanceDataStore   model.AcceptanceDataStore
-	blockStore            model.BlockStore
-	blockHeaderStore      model.BlockHeaderStore
-	pruningStore          model.PruningStore
-	ghostdagDataStore     model.GHOSTDAGDataStore
-	blockRelationStore    model.BlockRelationStore
-	blockStatusStore      model.BlockStatusStore
-	consensusStateStore   model.ConsensusStateStore
-	headerTipsStore       model.HeaderTipsStore
-	multisetStore         model.MultisetStore
-	reachabilityDataStore model.ReachabilityDataStore
-	utxoDiffStore         model.UTXODiffStore
-	finalityStore         model.FinalityStore
+	blockStore        model.BlockStore
+	blockHeaderStore  model.BlockHeaderStore
+	pruningStore      model.PruningStore
+	ghostdagDataStore model.GHOSTDAGDataStore
+	blockStatusStore  model.BlockStatusStore
 }
 
 // BuildBlock builds a block over the current state, with the transactions
@@ -51,27 +46,18 @@ type consensus struct {
 func (s *consensus) BuildBlock(coinbaseData *externalapi.DomainCoinbaseData,
 	transactions []*externalapi.DomainTransaction) (*externalapi.DomainBlock, error) {
 
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	return s.blockBuilder.BuildBlock(coinbaseData, transactions)
+	return s.blockProcessor.BuildBlock(coinbaseData, transactions)
 }
 
 // ValidateAndInsertBlock validates the given block and, if valid, applies it
 // to the current state
 func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.blockProcessor.ValidateAndInsertBlock(block)
 }
 
 // ValidateTransactionAndPopulateWithConsensusData validates the given transaction
 // and populates it with any missing consensus data
 func (s *consensus) ValidateTransactionAndPopulateWithConsensusData(transaction *externalapi.DomainTransaction) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	err := s.transactionValidator.ValidateTransactionInIsolation(transaction)
 	if err != nil {
 		return err
@@ -82,7 +68,11 @@ func (s *consensus) ValidateTransactionAndPopulateWithConsensusData(transaction
 		return err
 	}
 
-	virtualSelectedParentMedianTime, err := s.pastMedianTimeManager.PastMedianTime(model.VirtualBlockHash)
+	virtualGHOSTDAGData, err := s.ghostdagDataStore.Get(s.databaseContext, model.VirtualBlockHash)
+	if err != nil {
+		return err
+	}
+	virtualSelectedParentMedianTime, err := s.pastMedianTimeManager.PastMedianTime(virtualGHOSTDAGData.SelectedParent)
 	if err != nil {
 		return err
 	}
@@ -92,23 +82,14 @@ func (s *consensus) ValidateTransactionAndPopulateWithConsensusData(transaction
 }
 
 func (s *consensus) GetBlock(blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.blockStore.Block(s.databaseContext, blockHash)
 }
 
 func (s *consensus) GetBlockHeader(blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.blockHeaderStore.BlockHeader(s.databaseContext, blockHash)
 }
 
 func (s *consensus) GetBlockInfo(blockHash *externalapi.DomainHash) (*externalapi.BlockInfo, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	blockInfo := &externalapi.BlockInfo{}
 
 	exists, err := s.blockStatusStore.Exists(s.databaseContext, blockHash)
@@ -126,18 +107,6 @@ func (s *consensus) GetBlockInfo(blockHash *externalapi.DomainHash) (*externalap
 	}
 	blockInfo.BlockStatus = blockStatus
 
-	// If the status is invalid, then we don't have the necessary reachability data to check if it's in PruningPoint.Future.
-	if blockStatus == externalapi.StatusInvalid {
-		return blockInfo, nil
-	}
-
-	ghostdagData, err := s.ghostdagDataStore.Get(s.databaseContext, blockHash)
-	if err != nil {
-		return nil, err
-	}
-
-	blockInfo.BlueScore = ghostdagData.BlueScore()
-
 	isBlockInHeaderPruningPointFuture, err := s.syncManager.IsBlockInHeaderPruningPointFuture(blockHash)
 	if err != nil {
 		return nil, err
@@ -148,101 +117,37 @@ func (s *consensus) GetBlockInfo(blockHash *externalapi.DomainHash) (*externalap
 }
 
 func (s *consensus) GetHashesBetween(lowHash, highHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.syncManager.GetHashesBetween(lowHash, highHash)
 }
 
 func (s *consensus) GetMissingBlockBodyHashes(highHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.syncManager.GetMissingBlockBodyHashes(highHash)
 }
 
-func (s *consensus) GetPruningPointUTXOSet(expectedPruningPointHash *externalapi.DomainHash) ([]byte, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	pruningPointHash, err := s.pruningStore.PruningPoint(s.databaseContext)
-	if err != nil {
-		return nil, err
-	}
-
-	if *expectedPruningPointHash != *pruningPointHash {
-		return nil, errors.Wrapf(ruleerrors.ErrWrongPruningPointHash, "expected pruning point %s but got %s",
-			expectedPruningPointHash,
-			pruningPointHash)
-	}
-
-	serializedUTXOSet, err := s.pruningStore.PruningPointSerializedUTXOSet(s.databaseContext)
-	if err != nil {
-		return nil, err
-	}
-	return serializedUTXOSet, nil
+func (s *consensus) GetPruningPointUTXOSet() ([]byte, error) {
+	return s.pruningStore.PruningPointSerializedUTXOSet(s.databaseContext)
 }
 
 func (s *consensus) SetPruningPointUTXOSet(serializedUTXOSet []byte) error {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.consensusStateManager.SetPruningPointUTXOSet(serializedUTXOSet)
 }
 
 func (s *consensus) GetVirtualSelectedParent() (*externalapi.DomainBlock, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	virtualGHOSTDAGData, err := s.ghostdagDataStore.Get(s.databaseContext, model.VirtualBlockHash)
 	if err != nil {
 		return nil, err
 	}
-	return s.blockStore.Block(s.databaseContext, virtualGHOSTDAGData.SelectedParent())
+	return s.GetBlock(virtualGHOSTDAGData.SelectedParent)
 }
 
-func (s *consensus) CreateBlockLocator(lowHash, highHash *externalapi.DomainHash, limit uint32) (externalapi.BlockLocator, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	return s.syncManager.CreateBlockLocator(lowHash, highHash, limit)
+func (s *consensus) CreateBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+	return s.syncManager.CreateBlockLocator(lowHash, highHash)
 }
 
 func (s *consensus) FindNextBlockLocatorBoundaries(blockLocator externalapi.BlockLocator) (lowHash, highHash *externalapi.DomainHash, err error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.syncManager.FindNextBlockLocatorBoundaries(blockLocator)
 }
 
 func (s *consensus) GetSyncInfo() (*externalapi.SyncInfo, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
 	return s.syncManager.GetSyncInfo()
 }
-
-func (s *consensus) Tips() ([]*externalapi.DomainHash, error) {
-	return s.consensusStateStore.Tips(s.databaseContext)
-}
-
-func (s *consensus) GetVirtualInfo() (*externalapi.VirtualInfo, error) {
-	blockRelations, err := s.blockRelationStore.BlockRelation(s.databaseContext, model.VirtualBlockHash)
-	if err != nil {
-		return nil, err
-	}
-	bits, err := s.difficultyManager.RequiredDifficulty(model.VirtualBlockHash)
-	if err != nil {
-		return nil, err
-	}
-	pastMedianTime, err := s.pastMedianTimeManager.PastMedianTime(model.VirtualBlockHash)
-	if err != nil {
-		return nil, err
-	}
-
-	return &externalapi.VirtualInfo{
-		ParentHashes:   blockRelations.Parents,
-		Bits:           bits,
-		PastMedianTime: pastMedianTime,
-	}, nil
-}

domain/consensus/consensus_test.go

@@ -1,76 +0,0 @@
-package consensus
-
-import (
-	"testing"
-
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"github.com/kaspanet/kaspad/domain/dagconfig"
-	"github.com/pkg/errors"
-)
-
-func TestConsensus_GetBlockInfo(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, params *dagconfig.Params) {
-
-		factory := NewFactory()
-		consensus, teardown, err := factory.NewTestConsensus(params, "TestConsensus_GetBlockInfo")
-		if err != nil {
-			t.Fatalf("Error setting up consensus: %+v", err)
-		}
-		defer teardown()
-
-		invalidBlock, _, err := consensus.BuildBlockWithParents([]*externalapi.DomainHash{params.GenesisHash}, nil, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		invalidBlock.Header.TimeInMilliseconds = 0
-		err = consensus.ValidateAndInsertBlock(invalidBlock)
-		if !errors.Is(err, ruleerrors.ErrTimeTooOld) {
-			t.Fatalf("Expected block to be invalid with err: %v, instead found: %v", ruleerrors.ErrTimeTooOld, err)
-		}
-
-		info, err := consensus.GetBlockInfo(consensushashing.BlockHash(invalidBlock))
-		if err != nil {
-			t.Fatalf("Failed to get block info: %v", err)
-		}
-
-		if !info.Exists {
-			t.Fatal("The block is missing")
-		}
-		if info.BlockStatus != externalapi.StatusInvalid {
-			t.Fatalf("Expected block status: %s, instead got: %s", externalapi.StatusInvalid, info.BlockStatus)
-		}
-		if info.IsBlockInHeaderPruningPointFuture != false {
-			t.Fatalf("Expected IsBlockInHeaderPruningPointFuture=false, instead found: %t", info.IsBlockInHeaderPruningPointFuture)
-		}
-
-		emptyCoinbase := externalapi.DomainCoinbaseData{}
-		validBlock, err := consensus.BuildBlock(&emptyCoinbase, nil)
-		if err != nil {
-			t.Fatalf("consensus.BuildBlock with an empty coinbase shouldn't fail: %v", err)
-		}
-
-		err = consensus.ValidateAndInsertBlock(validBlock)
-		if err != nil {
-			t.Fatalf("consensus.ValidateAndInsertBlock with a block straight from consensus.BuildBlock should not fail: %v", err)
-		}
-
-		info, err = consensus.GetBlockInfo(consensushashing.BlockHash(validBlock))
-		if err != nil {
-			t.Fatalf("Failed to get block info: %v", err)
-		}
-
-		if !info.Exists {
-			t.Fatal("The block is missing")
-		}
-		if info.BlockStatus != externalapi.StatusValid {
-			t.Fatalf("Expected block status: %s, instead got: %s", externalapi.StatusValid, info.BlockStatus)
-		}
-		if info.IsBlockInHeaderPruningPointFuture != true {
-			t.Fatalf("Expected IsBlockInHeaderPruningPointFuture=true, instead found: %t", info.IsBlockInHeaderPruningPointFuture)
-		}
-
-	})
-}

domain/consensus/database/serialization/block_ghostdag_data.go

@@ -3,29 +3,26 @@ package serialization
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/processes/ghostdagmanager"
-	"math/big"
 )
 
 // BlockGHOSTDAGDataToDBBlockGHOSTDAGData converts BlockGHOSTDAGData to DbBlockGhostdagData
-func BlockGHOSTDAGDataToDBBlockGHOSTDAGData(blockGHOSTDAGData model.BlockGHOSTDAGData) *DbBlockGhostdagData {
+func BlockGHOSTDAGDataToDBBlockGHOSTDAGData(blockGHOSTDAGData *model.BlockGHOSTDAGData) *DbBlockGhostdagData {
 	var selectedParent *DbHash
-	if blockGHOSTDAGData.SelectedParent() != nil {
-		selectedParent = DomainHashToDbHash(blockGHOSTDAGData.SelectedParent())
+	if blockGHOSTDAGData.SelectedParent != nil {
+		selectedParent = DomainHashToDbHash(blockGHOSTDAGData.SelectedParent)
 	}
 
 	return &DbBlockGhostdagData{
-		BlueScore:          blockGHOSTDAGData.BlueScore(),
-		BlueWork:           blockGHOSTDAGData.BlueWork().Bytes(),
+		BlueScore:          blockGHOSTDAGData.BlueScore,
 		SelectedParent:     selectedParent,
-		MergeSetBlues:      DomainHashesToDbHashes(blockGHOSTDAGData.MergeSetBlues()),
-		MergeSetReds:       DomainHashesToDbHashes(blockGHOSTDAGData.MergeSetReds()),
-		BluesAnticoneSizes: bluesAnticoneSizesToDBBluesAnticoneSizes(blockGHOSTDAGData.BluesAnticoneSizes()),
+		MergeSetBlues:      DomainHashesToDbHashes(blockGHOSTDAGData.MergeSetBlues),
+		MergeSetReds:       DomainHashesToDbHashes(blockGHOSTDAGData.MergeSetReds),
+		BluesAnticoneSizes: bluesAnticoneSizesToDBBluesAnticoneSizes(blockGHOSTDAGData.BluesAnticoneSizes),
 	}
 }
 
 // DBBlockGHOSTDAGDataToBlockGHOSTDAGData converts DbBlockGhostdagData to BlockGHOSTDAGData
-func DBBlockGHOSTDAGDataToBlockGHOSTDAGData(dbBlockGHOSTDAGData *DbBlockGhostdagData) (model.BlockGHOSTDAGData, error) {
+func DBBlockGHOSTDAGDataToBlockGHOSTDAGData(dbBlockGHOSTDAGData *DbBlockGhostdagData) (*model.BlockGHOSTDAGData, error) {
 	var selectedParent *externalapi.DomainHash
 	if dbBlockGHOSTDAGData.SelectedParent != nil {
 		var err error
@@ -50,12 +47,11 @@ func DBBlockGHOSTDAGDataToBlockGHOSTDAGData(dbBlockGHOSTDAGData *DbBlockGhostdag
 		return nil, err
 	}
 
-	return ghostdagmanager.NewBlockGHOSTDAGData(
-		dbBlockGHOSTDAGData.BlueScore,
-		new(big.Int).SetBytes(dbBlockGHOSTDAGData.BlueWork),
-		selectedParent,
-		mergetSetBlues,
-		mergetSetReds,
-		bluesAnticoneSizes,
-	), nil
+	return &model.BlockGHOSTDAGData{
+		BlueScore:          dbBlockGHOSTDAGData.BlueScore,
+		SelectedParent:     selectedParent,
+		MergeSetBlues:      mergetSetBlues,
+		MergeSetReds:       mergetSetReds,
+		BluesAnticoneSizes: bluesAnticoneSizes,
+	}, nil
 }

domain/consensus/database/serialization/blues_anticone_sizes.go

@@ -10,9 +10,8 @@ func bluesAnticoneSizesToDBBluesAnticoneSizes(bluesAnticoneSizes map[externalapi
 	dbBluesAnticoneSizes := make([]*DbBluesAnticoneSizes, len(bluesAnticoneSizes))
 	i := 0
 	for hash, anticoneSize := range bluesAnticoneSizes {
-		hashCopy := hash
 		dbBluesAnticoneSizes[i] = &DbBluesAnticoneSizes{
-			BlueHash:     DomainHashToDbHash(&hashCopy),
+			BlueHash:     DomainHashToDbHash(&hash),
 			AnticoneSize: uint32(anticoneSize),
 		}
 		i++

domain/consensus/database/serialization/blues_anticone_sizes_test.go

@@ -1,27 +0,0 @@
-package serialization
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-	"testing"
-)
-
-// TestBlueAnticoneSizesSize tests that no data can be loss when converting model.KType to the corresponding type in
-// DbBluesAnticoneSizes
-func TestKType(t *testing.T) {
-	k := model.KType(0)
-	k--
-
-	if k < model.KType(0) {
-		t.Fatalf("KType must be unsigned")
-	}
-
-	// Setting maxKType to maximum value of KType.
-	// As we verify above that KType is unsigned we can be sure that maxKType is indeed the maximum value of KType.
-	maxKType := ^model.KType(0)
-	dbBluesAnticoneSizes := DbBluesAnticoneSizes{
-		AnticoneSize: uint32(maxKType),
-	}
-	if model.KType(dbBluesAnticoneSizes.AnticoneSize) != maxKType {
-		t.Fatalf("convert from uint32 to KType losses data")
-	}
-}

domain/consensus/database/serialization/dbobjects.pb.go

@@ -865,11 +865,10 @@ type DbBlockGhostdagData struct {
 	unknownFields protoimpl.UnknownFields
 
 	BlueScore          uint64                  `protobuf:"varint,1,opt,name=blueScore,proto3" json:"blueScore,omitempty"`
-	BlueWork           []byte                  `protobuf:"bytes,2,opt,name=blueWork,proto3" json:"blueWork,omitempty"`
-	SelectedParent     *DbHash                 `protobuf:"bytes,3,opt,name=selectedParent,proto3" json:"selectedParent,omitempty"`
-	MergeSetBlues      []*DbHash               `protobuf:"bytes,4,rep,name=mergeSetBlues,proto3" json:"mergeSetBlues,omitempty"`
-	MergeSetReds       []*DbHash               `protobuf:"bytes,5,rep,name=mergeSetReds,proto3" json:"mergeSetReds,omitempty"`
-	BluesAnticoneSizes []*DbBluesAnticoneSizes `protobuf:"bytes,6,rep,name=bluesAnticoneSizes,proto3" json:"bluesAnticoneSizes,omitempty"`
+	SelectedParent     *DbHash                 `protobuf:"bytes,2,opt,name=selectedParent,proto3" json:"selectedParent,omitempty"`
+	MergeSetBlues      []*DbHash               `protobuf:"bytes,3,rep,name=mergeSetBlues,proto3" json:"mergeSetBlues,omitempty"`
+	MergeSetReds       []*DbHash               `protobuf:"bytes,4,rep,name=mergeSetReds,proto3" json:"mergeSetReds,omitempty"`
+	BluesAnticoneSizes []*DbBluesAnticoneSizes `protobuf:"bytes,5,rep,name=bluesAnticoneSizes,proto3" json:"bluesAnticoneSizes,omitempty"`
 }
 
 func (x *DbBlockGhostdagData) Reset() {
@@ -911,13 +910,6 @@ func (x *DbBlockGhostdagData) GetBlueScore() uint64 {
 	return 0
 }
 
-func (x *DbBlockGhostdagData) GetBlueWork() []byte {
-	if x != nil {
-		return x.BlueWork
-	}
-	return nil
-}
-
 func (x *DbBlockGhostdagData) GetSelectedParent() *DbHash {
 	if x != nil {
 		return x.SelectedParent
@@ -1543,194 +1535,6 @@ func (x *DbHeaderTips) GetTips() []*DbHash {
 	return nil
 }
 
-type DbTips struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Tips []*DbHash `protobuf:"bytes,1,rep,name=tips,proto3" json:"tips,omitempty"`
-}
-
-func (x *DbTips) Reset() {
-	*x = DbTips{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_dbobjects_proto_msgTypes[26]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DbTips) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DbTips) ProtoMessage() {}
-
-func (x *DbTips) ProtoReflect() protoreflect.Message {
-	mi := &file_dbobjects_proto_msgTypes[26]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DbTips.ProtoReflect.Descriptor instead.
-func (*DbTips) Descriptor() ([]byte, []int) {
-	return file_dbobjects_proto_rawDescGZIP(), []int{26}
-}
-
-func (x *DbTips) GetTips() []*DbHash {
-	if x != nil {
-		return x.Tips
-	}
-	return nil
-}
-
-type DbVirtualDiffParents struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	VirtualDiffParents []*DbHash `protobuf:"bytes,1,rep,name=virtualDiffParents,proto3" json:"virtualDiffParents,omitempty"`
-}
-
-func (x *DbVirtualDiffParents) Reset() {
-	*x = DbVirtualDiffParents{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_dbobjects_proto_msgTypes[27]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DbVirtualDiffParents) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DbVirtualDiffParents) ProtoMessage() {}
-
-func (x *DbVirtualDiffParents) ProtoReflect() protoreflect.Message {
-	mi := &file_dbobjects_proto_msgTypes[27]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DbVirtualDiffParents.ProtoReflect.Descriptor instead.
-func (*DbVirtualDiffParents) Descriptor() ([]byte, []int) {
-	return file_dbobjects_proto_rawDescGZIP(), []int{27}
-}
-
-func (x *DbVirtualDiffParents) GetVirtualDiffParents() []*DbHash {
-	if x != nil {
-		return x.VirtualDiffParents
-	}
-	return nil
-}
-
-type DbBlockCount struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
-}
-
-func (x *DbBlockCount) Reset() {
-	*x = DbBlockCount{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_dbobjects_proto_msgTypes[28]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DbBlockCount) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DbBlockCount) ProtoMessage() {}
-
-func (x *DbBlockCount) ProtoReflect() protoreflect.Message {
-	mi := &file_dbobjects_proto_msgTypes[28]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DbBlockCount.ProtoReflect.Descriptor instead.
-func (*DbBlockCount) Descriptor() ([]byte, []int) {
-	return file_dbobjects_proto_rawDescGZIP(), []int{28}
-}
-
-func (x *DbBlockCount) GetCount() uint64 {
-	if x != nil {
-		return x.Count
-	}
-	return 0
-}
-
-type DbBlockHeaderCount struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Count uint64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
-}
-
-func (x *DbBlockHeaderCount) Reset() {
-	*x = DbBlockHeaderCount{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_dbobjects_proto_msgTypes[29]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *DbBlockHeaderCount) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*DbBlockHeaderCount) ProtoMessage() {}
-
-func (x *DbBlockHeaderCount) ProtoReflect() protoreflect.Message {
-	mi := &file_dbobjects_proto_msgTypes[29]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use DbBlockHeaderCount.ProtoReflect.Descriptor instead.
-func (*DbBlockHeaderCount) Descriptor() ([]byte, []int) {
-	return file_dbobjects_proto_rawDescGZIP(), []int{29}
-}
-
-func (x *DbBlockHeaderCount) GetCount() uint64 {
-	if x != nil {
-		return x.Count
-	}
-	return 0
-}
-
 var File_dbobjects_proto protoreflect.FileDescriptor
 
 var file_dbobjects_proto_rawDesc = []byte{
@@ -1856,121 +1660,105 @@ var file_dbobjects_proto_rawDesc = []byte{
 	0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64,
 	0x72, 0x65, 0x6e, 0x22, 0x27, 0x0a, 0x0d, 0x44, 0x62, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x74,
 	0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xdb, 0x02, 0x0a,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xbf, 0x02, 0x0a,
 	0x13, 0x44, 0x62, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x47, 0x68, 0x6f, 0x73, 0x74, 0x64, 0x61, 0x67,
 	0x44, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x62, 0x6c, 0x75, 0x65, 0x53, 0x63, 0x6f, 0x72,
 	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x62, 0x6c, 0x75, 0x65, 0x53, 0x63, 0x6f,
-	0x72, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x62, 0x6c, 0x75, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x6c, 0x75, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x12, 0x3d,
-	0x0a, 0x0e, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69,
-	0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x0e, 0x73,
-	0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x3b, 0x0a,
-	0x0d, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x53, 0x65, 0x74, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x04,
+	0x72, 0x65, 0x12, 0x3d, 0x0a, 0x0e, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61,
+	0x72, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72,
+	0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73,
+	0x68, 0x52, 0x0e, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x65, 0x6e,
+	0x74, 0x12, 0x3b, 0x0a, 0x0d, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x53, 0x65, 0x74, 0x42, 0x6c, 0x75,
+	0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61,
+	0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52,
+	0x0d, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x53, 0x65, 0x74, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x39,
+	0x0a, 0x0c, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x53, 0x65, 0x74, 0x52, 0x65, 0x64, 0x73, 0x18, 0x04,
 	0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x0d, 0x6d, 0x65, 0x72,
-	0x67, 0x65, 0x53, 0x65, 0x74, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x0c, 0x6d, 0x65,
-	0x72, 0x67, 0x65, 0x53, 0x65, 0x74, 0x52, 0x65, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b,
+	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x0c, 0x6d, 0x65, 0x72,
+	0x67, 0x65, 0x53, 0x65, 0x74, 0x52, 0x65, 0x64, 0x73, 0x12, 0x53, 0x0a, 0x12, 0x62, 0x6c, 0x75,
+	0x65, 0x73, 0x41, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x18,
+	0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e, 0x74,
+	0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x52, 0x12, 0x62, 0x6c, 0x75, 0x65,
+	0x73, 0x41, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x22, 0x6d,
+	0x0a, 0x14, 0x44, 0x62, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e,
+	0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x62, 0x6c, 0x75, 0x65, 0x48, 0x61,
+	0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61,
+	0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52,
+	0x08, 0x62, 0x6c, 0x75, 0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x6e, 0x74,
+	0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x0c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x22, 0x28, 0x0a,
+	0x0a, 0x44, 0x62, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6d,
+	0x75, 0x6c, 0x74, 0x69, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6d,
+	0x75, 0x6c, 0x74, 0x69, 0x73, 0x65, 0x74, 0x22, 0x46, 0x0a, 0x09, 0x44, 0x62, 0x55, 0x74, 0x78,
+	0x6f, 0x53, 0x65, 0x74, 0x12, 0x39, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22,
+	0x87, 0x01, 0x0a, 0x14, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70,
+	0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x65, 0x72,
+	0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x4f, 0x75, 0x74,
+	0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12,
+	0x38, 0x0a, 0x09, 0x75, 0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09,
+	0x75, 0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x97, 0x01, 0x0a, 0x0b, 0x44, 0x62,
+	0x55, 0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f,
+	0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e,
+	0x74, 0x12, 0x28, 0x0a, 0x0f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69,
+	0x63, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x73, 0x63, 0x72, 0x69,
+	0x70, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x0e, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x6c, 0x75, 0x65, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x03, 0x20,
+	0x01, 0x28, 0x04, 0x52, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x6c, 0x75, 0x65, 0x53, 0x63,
+	0x6f, 0x72, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x69, 0x73, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73,
+	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x43, 0x6f, 0x69, 0x6e, 0x62,
+	0x61, 0x73, 0x65, 0x22, 0x9c, 0x01, 0x0a, 0x12, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x44, 0x61, 0x74, 0x61, 0x12, 0x41, 0x0a, 0x08, 0x74, 0x72,
+	0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73,
+	0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x52,
+	0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x54, 0x72, 0x65, 0x65, 0x4e,
+	0x6f, 0x64, 0x65, 0x52, 0x08, 0x74, 0x72, 0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x43, 0x0a,
+	0x11, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x53,
+	0x65, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61,
+	0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52,
+	0x11, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x53,
+	0x65, 0x74, 0x22, 0xbd, 0x01, 0x0a, 0x16, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62,
+	0x69, 0x6c, 0x69, 0x74, 0x79, 0x54, 0x72, 0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x31, 0x0a,
+	0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+	0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e,
+	0x12, 0x2d, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
 	0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e,
-	0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x0c, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x53, 0x65,
-	0x74, 0x52, 0x65, 0x64, 0x73, 0x12, 0x53, 0x0a, 0x12, 0x62, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e,
-	0x74, 0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x2e, 0x44, 0x62, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e,
-	0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x52, 0x12, 0x62, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e, 0x74,
-	0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x73, 0x22, 0x6d, 0x0a, 0x14, 0x44, 0x62,
-	0x42, 0x6c, 0x75, 0x65, 0x73, 0x41, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a,
-	0x65, 0x73, 0x12, 0x31, 0x0a, 0x08, 0x62, 0x6c, 0x75, 0x65, 0x48, 0x61, 0x73, 0x68, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x08, 0x62, 0x6c, 0x75,
-	0x65, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x6f, 0x6e,
-	0x65, 0x53, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x61, 0x6e, 0x74,
-	0x69, 0x63, 0x6f, 0x6e, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x22, 0x28, 0x0a, 0x0a, 0x44, 0x62, 0x4d,
-	0x75, 0x6c, 0x74, 0x69, 0x73, 0x65, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x75, 0x6c, 0x74, 0x69,
-	0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6d, 0x75, 0x6c, 0x74, 0x69,
-	0x73, 0x65, 0x74, 0x22, 0x46, 0x0a, 0x09, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x53, 0x65, 0x74,
-	0x12, 0x39, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x49, 0x74, 0x65, 0x6d, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x87, 0x01, 0x0a, 0x14,
-	0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x49, 0x74, 0x65, 0x6d, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69,
-	0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x4f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e,
-	0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x75,
-	0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
-	0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44,
-	0x62, 0x55, 0x74, 0x78, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x75, 0x74, 0x78, 0x6f,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x22, 0x97, 0x01, 0x0a, 0x0b, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x28, 0x0a,
-	0x0f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x50, 0x75,
-	0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
-	0x42, 0x6c, 0x75, 0x65, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x6c, 0x75, 0x65, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12,
-	0x1e, 0x0a, 0x0a, 0x69, 0x73, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x18, 0x04, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x43, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x22,
-	0x9c, 0x01, 0x0a, 0x12, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69,
-	0x74, 0x79, 0x44, 0x61, 0x74, 0x61, 0x12, 0x41, 0x0a, 0x08, 0x74, 0x72, 0x65, 0x65, 0x4e, 0x6f,
-	0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61,
-	0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68,
-	0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x54, 0x72, 0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52,
-	0x08, 0x74, 0x72, 0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x43, 0x0a, 0x11, 0x66, 0x75, 0x74,
-	0x75, 0x72, 0x65, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x74, 0x18, 0x02,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x11, 0x66, 0x75, 0x74,
-	0x75, 0x72, 0x65, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x74, 0x22, 0xbd,
-	0x01, 0x0a, 0x16, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
-	0x79, 0x54, 0x72, 0x65, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x31, 0x0a, 0x08, 0x63, 0x68, 0x69,
-	0x6c, 0x64, 0x72, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65,
-	0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61,
-	0x73, 0x68, 0x52, 0x08, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x2d, 0x0a, 0x06,
-	0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73,
-	0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48,
-	0x61, 0x73, 0x68, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x41, 0x0a, 0x08, 0x69,
-	0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e,
-	0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62,
-	0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x49, 0x6e, 0x74, 0x65,
-	0x72, 0x76, 0x61, 0x6c, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x22, 0x40,
-	0x0a, 0x16, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
-	0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72,
-	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10,
-	0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x65, 0x6e, 0x64,
-	0x22, 0x88, 0x01, 0x0a, 0x0a, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x44, 0x69, 0x66, 0x66, 0x12,
-	0x39, 0x0a, 0x05, 0x74, 0x6f, 0x41, 0x64, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23,
-	0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44,
-	0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49,
-	0x74, 0x65, 0x6d, 0x52, 0x05, 0x74, 0x6f, 0x41, 0x64, 0x64, 0x12, 0x3f, 0x0a, 0x08, 0x74, 0x6f,
-	0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73,
-	0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x55,
-	0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65,
-	0x6d, 0x52, 0x08, 0x74, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x22, 0x32, 0x0a, 0x1a, 0x44,
-	0x62, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x54, 0x58,
-	0x4f, 0x53, 0x65, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74,
-	0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x22,
-	0x39, 0x0a, 0x0c, 0x44, 0x62, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x54, 0x69, 0x70, 0x73, 0x12,
-	0x29, 0x0a, 0x04, 0x74, 0x69, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e,
-	0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62,
-	0x48, 0x61, 0x73, 0x68, 0x52, 0x04, 0x74, 0x69, 0x70, 0x73, 0x22, 0x33, 0x0a, 0x06, 0x44, 0x62,
-	0x54, 0x69, 0x70, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x74, 0x69, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x04, 0x74, 0x69, 0x70, 0x73, 0x22,
-	0x5d, 0x0a, 0x14, 0x44, 0x62, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66,
-	0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x45, 0x0a, 0x12, 0x76, 0x69, 0x72, 0x74, 0x75,
-	0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x12, 0x76, 0x69, 0x72, 0x74,
-	0x75, 0x61, 0x6c, 0x44, 0x69, 0x66, 0x66, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x24,
-	0x0a, 0x0c, 0x44, 0x62, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14,
-	0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63,
-	0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2a, 0x0a, 0x12, 0x44, 0x62, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48,
-	0x65, 0x61, 0x64, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f,
-	0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74,
-	0x42, 0x2a, 0x5a, 0x28, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b,
-	0x61, 0x73, 0x70, 0x61, 0x6e, 0x65, 0x74, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x64, 0x2f, 0x73,
-	0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x06, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12,
+	0x41, 0x0a, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x2e, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+	0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76,
+	0x61, 0x6c, 0x22, 0x40, 0x0a, 0x16, 0x44, 0x62, 0x52, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x69,
+	0x6c, 0x69, 0x74, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05,
+	0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x73, 0x74, 0x61,
+	0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x03, 0x65, 0x6e, 0x64, 0x22, 0x88, 0x01, 0x0a, 0x0a, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x44,
+	0x69, 0x66, 0x66, 0x12, 0x39, 0x0a, 0x05, 0x74, 0x6f, 0x41, 0x64, 0x64, 0x18, 0x01, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
+	0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x05, 0x74, 0x6f, 0x41, 0x64, 0x64, 0x12, 0x3f,
+	0x0a, 0x08, 0x74, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
+	0x32, 0x23, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x44, 0x62, 0x55, 0x74, 0x78, 0x6f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x08, 0x74, 0x6f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x22,
+	0x32, 0x0a, 0x1a, 0x44, 0x62, 0x50, 0x72, 0x75, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x69, 0x6e,
+	0x74, 0x55, 0x54, 0x58, 0x4f, 0x53, 0x65, 0x74, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x14, 0x0a,
+	0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79,
+	0x74, 0x65, 0x73, 0x22, 0x39, 0x0a, 0x0c, 0x44, 0x62, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x54,
+	0x69, 0x70, 0x73, 0x12, 0x29, 0x0a, 0x04, 0x74, 0x69, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x15, 0x2e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x2e, 0x44, 0x62, 0x48, 0x61, 0x73, 0x68, 0x52, 0x04, 0x74, 0x69, 0x70, 0x73, 0x42, 0x2a,
+	0x5a, 0x28, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6b, 0x61, 0x73,
+	0x70, 0x61, 0x6e, 0x65, 0x74, 0x2f, 0x6b, 0x61, 0x73, 0x70, 0x61, 0x64, 0x2f, 0x73, 0x65, 0x72,
+	0x69, 0x61, 0x6c, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 }
 
 var (
@@ -1985,7 +1773,7 @@ func file_dbobjects_proto_rawDescGZIP() []byte {
 	return file_dbobjects_proto_rawDescData
 }
 
-var file_dbobjects_proto_msgTypes = make([]protoimpl.MessageInfo, 30)
+var file_dbobjects_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
 var file_dbobjects_proto_goTypes = []interface{}{
 	(*DbBlock)(nil),                     // 0: serialization.DbBlock
 	(*DbBlockHeader)(nil),               // 1: serialization.DbBlockHeader
@@ -2013,10 +1801,6 @@ var file_dbobjects_proto_goTypes = []interface{}{
 	(*DbUtxoDiff)(nil),                  // 23: serialization.DbUtxoDiff
 	(*DbPruningPointUTXOSetBytes)(nil),  // 24: serialization.DbPruningPointUTXOSetBytes
 	(*DbHeaderTips)(nil),                // 25: serialization.DbHeaderTips
-	(*DbTips)(nil),                      // 26: serialization.DbTips
-	(*DbVirtualDiffParents)(nil),        // 27: serialization.DbVirtualDiffParents
-	(*DbBlockCount)(nil),                // 28: serialization.DbBlockCount
-	(*DbBlockHeaderCount)(nil),          // 29: serialization.DbBlockHeaderCount
 }
 var file_dbobjects_proto_depIdxs = []int32{
 	1,  // 0: serialization.DbBlock.header:type_name -> serialization.DbBlockHeader
@@ -2052,13 +1836,11 @@ var file_dbobjects_proto_depIdxs = []int32{
 	18, // 30: serialization.DbUtxoDiff.toAdd:type_name -> serialization.DbUtxoCollectionItem
 	18, // 31: serialization.DbUtxoDiff.toRemove:type_name -> serialization.DbUtxoCollectionItem
 	2,  // 32: serialization.DbHeaderTips.tips:type_name -> serialization.DbHash
-	2,  // 33: serialization.DbTips.tips:type_name -> serialization.DbHash
-	2,  // 34: serialization.DbVirtualDiffParents.virtualDiffParents:type_name -> serialization.DbHash
-	35, // [35:35] is the sub-list for method output_type
-	35, // [35:35] is the sub-list for method input_type
-	35, // [35:35] is the sub-list for extension type_name
-	35, // [35:35] is the sub-list for extension extendee
-	0,  // [0:35] is the sub-list for field type_name
+	33, // [33:33] is the sub-list for method output_type
+	33, // [33:33] is the sub-list for method input_type
+	33, // [33:33] is the sub-list for extension type_name
+	33, // [33:33] is the sub-list for extension extendee
+	0,  // [0:33] is the sub-list for field type_name
 }
 
 func init() { file_dbobjects_proto_init() }
@@ -2379,54 +2161,6 @@ func file_dbobjects_proto_init() {
 				return nil
 			}
 		}
-		file_dbobjects_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DbTips); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_dbobjects_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DbVirtualDiffParents); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_dbobjects_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DbBlockCount); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_dbobjects_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DbBlockHeaderCount); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -2434,7 +2168,7 @@ func file_dbobjects_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_dbobjects_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   30,
+			NumMessages:   26,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

domain/consensus/database/serialization/dbobjects.proto

@@ -83,11 +83,10 @@ message DbBlockStatus {
 
 message DbBlockGhostdagData {
   uint64 blueScore = 1;
-  bytes blueWork = 2;
-  DbHash selectedParent = 3;
-  repeated DbHash mergeSetBlues = 4;
-  repeated DbHash mergeSetReds = 5;
-  repeated DbBluesAnticoneSizes bluesAnticoneSizes = 6;
+  DbHash selectedParent = 2;
+  repeated DbHash mergeSetBlues = 3;
+  repeated DbHash mergeSetReds = 4;
+  repeated DbBluesAnticoneSizes bluesAnticoneSizes = 5;
 }
 
 message DbBluesAnticoneSizes {
@@ -142,20 +141,4 @@ message DbPruningPointUTXOSetBytes {
 
 message DbHeaderTips {
   repeated DbHash tips = 1;
-}
-
-message DbTips {
-  repeated DbHash tips = 1;
-}
-
-message DbVirtualDiffParents {
-  repeated DbHash virtualDiffParents = 1;
-}
-
-message DbBlockCount {
-  uint64 count = 1;
-}
-
-message DbBlockHeaderCount {
-  uint64 count = 1;
-}
+}

domain/consensus/database/serialization/header_tips.go

@@ -11,7 +11,7 @@ func HeaderTipsToDBHeaderTips(tips []*externalapi.DomainHash) *DbHeaderTips {
 	}
 }
 
-// DBHeaderTipsToHeaderTips converts DbHeaderTips to a slice of hashes
-func DBHeaderTipsToHeaderTips(dbHeaderTips *DbHeaderTips) ([]*externalapi.DomainHash, error) {
+// DBHeaderTipsTOHeaderTips converts DbHeaderTips to a slice of hashes
+func DBHeaderTipsTOHeaderTips(dbHeaderTips *DbHeaderTips) ([]*externalapi.DomainHash, error) {
 	return DbHashesToDomainHashes(dbHeaderTips.Tips)
 }

domain/consensus/database/serialization/tips.go

@@ -1,17 +0,0 @@
-package serialization
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-)
-
-// TipsToDBTips converts a slice of hashes to DbTips
-func TipsToDBTips(tips []*externalapi.DomainHash) *DbTips {
-	return &DbTips{
-		Tips: DomainHashesToDbHashes(tips),
-	}
-}
-
-// DBTipsToTips converts DbTips to a slice of hashes
-func DBTipsToTips(dbTips *DbTips) ([]*externalapi.DomainHash, error) {
-	return DbHashesToDomainHashes(dbTips.Tips)
-}