Pruning fixes (#1243)

* Pruning related fixes

* Rename setBlockStatus->setBlockStatusAfterBlockValidation

* Rename StatusValid->StatusUTXOValid

* Add comment

* Fix typo

* Rename hasValidatedOnlyHeader->hasValidatedHeader

* Rename checkBlockBodiesExist->checkParentBlockBodiesExist

* Add comments and logs

* Adding logs

* Add logs and assert

* Add comment

* Fix typo

* Fix log

app/appmessage/common.go

@@ -5,10 +5,8 @@
 package appmessage
 
 import (
-	"encoding/binary"
 	"fmt"
 	"io"
-	"math"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
@@ -23,16 +21,6 @@ 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 " +
@@ -53,7 +41,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 	// type assertions first.
 	switch e := element.(type) {
 	case *int32:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
+		rv, err := binaryserializer.Uint32(r)
 		if err != nil {
 			return err
 		}
@@ -61,7 +49,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *uint32:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
+		rv, err := binaryserializer.Uint32(r)
 		if err != nil {
 			return err
 		}
@@ -69,7 +57,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *int64:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
+		rv, err := binaryserializer.Uint64(r)
 		if err != nil {
 			return err
 		}
@@ -77,7 +65,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *uint64:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
+		rv, err := binaryserializer.Uint64(r)
 		if err != nil {
 			return err
 		}
@@ -106,7 +94,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 
 	// Unix timestamp encoded as an int64.
 	case *int64Time:
-		rv, err := binaryserializer.Uint64(r, binary.LittleEndian)
+		rv, err := binaryserializer.Uint64(r)
 		if err != nil {
 			return err
 		}
@@ -123,7 +111,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 
 	// Message header command.
 	case *MessageCommand:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
+		rv, err := binaryserializer.Uint32(r)
 		if err != nil {
 			return err
 		}
@@ -156,7 +144,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *ServiceFlag:
-		rv, err := binaryserializer.Uint64(r, littleEndian)
+		rv, err := binaryserializer.Uint64(r)
 		if err != nil {
 			return err
 		}
@@ -164,7 +152,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil
 
 	case *KaspaNet:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
+		rv, err := binaryserializer.Uint32(r)
 		if err != nil {
 			return err
 		}
@@ -193,28 +181,28 @@ func WriteElement(w io.Writer, element interface{}) error {
 	// type assertions first.
 	switch e := element.(type) {
 	case int32:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
+		err := binaryserializer.PutUint32(w, uint32(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case uint32:
-		err := binaryserializer.PutUint32(w, littleEndian, e)
+		err := binaryserializer.PutUint32(w, e)
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case int64:
-		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
+		err := binaryserializer.PutUint64(w, uint64(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case uint64:
-		err := binaryserializer.PutUint64(w, littleEndian, e)
+		err := binaryserializer.PutUint64(w, e)
 		if err != nil {
 			return err
 		}
@@ -249,7 +237,7 @@ func WriteElement(w io.Writer, element interface{}) error {
 
 	// Message header command.
 	case MessageCommand:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
+		err := binaryserializer.PutUint32(w, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -281,14 +269,14 @@ func WriteElement(w io.Writer, element interface{}) error {
 		return nil
 
 	case ServiceFlag:
-		err := binaryserializer.PutUint64(w, littleEndian, uint64(e))
+		err := binaryserializer.PutUint64(w, uint64(e))
 		if err != nil {
 			return err
 		}
 		return nil
 
 	case KaspaNet:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
+		err := binaryserializer.PutUint32(w, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -320,7 +308,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 	var rv uint64
 	switch discriminant {
 	case 0xff:
-		sv, err := binaryserializer.Uint64(r, littleEndian)
+		sv, err := binaryserializer.Uint64(r)
 		if err != nil {
 			return 0, err
 		}
@@ -335,7 +323,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		}
 
 	case 0xfe:
-		sv, err := binaryserializer.Uint32(r, littleEndian)
+		sv, err := binaryserializer.Uint32(r)
 		if err != nil {
 			return 0, err
 		}
@@ -350,7 +338,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		}
 
 	case 0xfd:
-		sv, err := binaryserializer.Uint16(r, littleEndian)
+		sv, err := binaryserializer.Uint16(r)
 		if err != nil {
 			return 0, err
 		}
@@ -370,143 +358,3 @@ 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,7 +8,6 @@ import (
 	"bytes"
 	"io"
 	"reflect"
-	"strings"
 	"testing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -233,464 +232,3 @@ 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/message.go

@@ -41,8 +41,6 @@ const (
 	CmdPong
 	CmdRequestBlockLocator
 	CmdBlockLocator
-	CmdSelectedTip
-	CmdRequestSelectedTip
 	CmdInvRelayBlock
 	CmdRequestRelayBlocks
 	CmdInvTransaction
@@ -123,8 +121,6 @@ var ProtocolMessageCommandToString = map[MessageCommand]string{
 	CmdPong:                          "Pong",
 	CmdRequestBlockLocator:           "RequestBlockLocator",
 	CmdBlockLocator:                  "BlockLocator",
-	CmdSelectedTip:                   "SelectedTip",
-	CmdRequestSelectedTip:            "RequestSelectedTip",
 	CmdInvRelayBlock:                 "InvRelayBlock",
 	CmdRequestRelayBlocks:            "RequestRelayBlocks",
 	CmdInvTransaction:                "InvTransaction",

app/appmessage/p2p_msgblockheader.go

@@ -7,7 +7,7 @@ package appmessage
 import (
 	"math"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/util/mstime"
@@ -73,7 +73,7 @@ func (h *MsgBlockHeader) NumParentBlocks() byte {
 
 // BlockHash computes the block identifier hash for the given block header.
 func (h *MsgBlockHeader) BlockHash() *externalapi.DomainHash {
-	return consensusserialization.HeaderHash(BlockHeaderToDomainBlockHeader(h))
+	return consensushashing.HeaderHash(BlockHeaderToDomainBlockHeader(h))
 }
 
 // IsGenesis returns true iff this block is a genesis block

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(17)
+	wantCmd := MessageCommand(15)
 	msg := NewMsgIBDBlock(NewMsgBlock(bh))
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",

app/appmessage/p2p_msgrequestblocklocator.go

@@ -5,13 +5,14 @@ import (
 )
 
 // MsgRequestBlockLocator implements the Message interface and represents a kaspa
-// RequestBlockLocator message. It is used to request a block locator between high
-// and low hash.
+// RequestBlockLocator message. It is used to request a block locator between low
+// and high hash.
 // The locator is returned via a locator message (MsgBlockLocator).
 type MsgRequestBlockLocator struct {
 	baseMessage
-	HighHash *externalapi.DomainHash
 	LowHash  *externalapi.DomainHash
+	HighHash *externalapi.DomainHash
+	Limit    uint32
 }
 
 // Command returns the protocol command string for the message. This is part
@@ -23,9 +24,10 @@ 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(highHash, lowHash *externalapi.DomainHash) *MsgRequestBlockLocator {
+func NewMsgRequestBlockLocator(lowHash, highHash *externalapi.DomainHash, limit uint32) *MsgRequestBlockLocator {
 	return &MsgRequestBlockLocator{
-		HighHash: highHash,
 		LowHash:  lowHash,
+		HighHash: highHash,
+		Limit:    limit,
 	}
 }

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{})
+	msg := NewMsgRequestBlockLocator(highHash, &externalapi.DomainHash{}, 0)
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgRequestBlockLocator: wrong command - got %v want %v",
 			cmd, wantCmd)

app/appmessage/p2p_msgrequestibdblocks.go

@@ -4,10 +4,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 )
 
-// MaxRequestIBDBlocksHashes is the maximum number of hashes that can
-// be in a single RequestIBDBlocks message.
-const MaxRequestIBDBlocksHashes = MaxInvPerMsg
-
 // MsgRequestIBDBlocks implements the Message interface and represents a kaspa
 // RequestIBDBlocks message. It is used to request blocks as part of the IBD
 // protocol.

app/appmessage/p2p_msgrequestselectedtip.go

@@ -1,21 +0,0 @@
-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

@@ -1,20 +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 (
-	"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

@@ -1,28 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -10,7 +10,7 @@ import (
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 
@@ -162,12 +162,12 @@ func (msg *MsgTx) IsCoinBase() bool {
 
 // TxHash generates the Hash for the transaction.
 func (msg *MsgTx) TxHash() *externalapi.DomainHash {
-	return consensusserialization.TransactionHash(MsgTxToDomainTransaction(msg))
+	return consensushashing.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 consensusserialization.TransactionID(MsgTxToDomainTransaction(msg))
+	return consensushashing.TransactionID(MsgTxToDomainTransaction(msg))
 }
 
 // Copy creates a deep copy of a transaction so that the original does not get

app/appmessage/p2p_msgversion.go

@@ -53,9 +53,6 @@ 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
 
@@ -85,7 +82,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,
-	selectedTipHash *externalapi.DomainHash, subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
+	subnetworkID *externalapi.DomainSubnetworkID) *MsgVersion {
 
 	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
@@ -97,7 +94,6 @@ 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,7 +10,6 @@ import (
 	"testing"
 
 	"github.com/davecgh/go-spew/spew"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
@@ -19,7 +18,6 @@ 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()
@@ -28,7 +26,7 @@ func TestVersion(t *testing.T) {
 	}
 
 	// Ensure we get the correct data back out.
-	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
+	msg := NewMsgVersion(me, generatedID, "mainnet", nil)
 	if msg.ProtocolVersion != pver {
 		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
 			msg.ProtocolVersion, pver)
@@ -45,10 +43,6 @@ 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_count.go

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

app/appmessage/rpc_get_block_dag_info.go

@@ -22,6 +22,7 @@ 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,8 +41,6 @@ type GetConnectedPeerInfoMessage struct {
 	ID                        string
 	Address                   string
 	LastPingDuration          int64
-	SelectedTipHash           string
-	IsSyncNode                bool
 	IsOutbound                bool
 	TimeOffset                int64
 	UserAgent                 string

app/appmessage/rpc_notify_chain_changed.go

@@ -49,8 +49,8 @@ type ChainBlock struct {
 
 // AcceptedBlock represents a block accepted into the DAG
 type AcceptedBlock struct {
-	Hash          string
-	AcceptedTxIDs []string
+	Hash                   string
+	AcceptedTransactionIDs []string
 }
 
 // Command returns the protocol command string for the message

app/component_manager.go

@@ -140,9 +140,7 @@ func (a *ComponentManager) maybeSeedFromDNS() {
 				// source. So we'll take first returned address as source.
 				a.addressManager.AddAddresses(addresses...)
 			})
-	}
 
-	if a.cfg.GRPCSeed != "" {
 		dnsseed.SeedFromGRPC(a.cfg.NetParams(), a.cfg.GRPCSeed, appmessage.SFNodeNetwork, false, nil,
 			func(addresses []*appmessage.NetAddress) {
 				a.addressManager.AddAddresses(addresses...)

app/protocol/flowcontext/blocks.go

@@ -1,13 +1,14 @@
 package flowcontext
 
 import (
+	"sync/atomic"
+
 	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/pkg/errors"
-	"sync/atomic"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
@@ -17,18 +18,25 @@ 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
 	}
 
+	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
@@ -45,7 +53,7 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
 	f.updateTransactionsToRebroadcast(block)
 
 	// Don't relay transactions when in IBD.
-	if atomic.LoadUint32(&f.isInIBD) != 0 {
+	if f.IsIBDRunning() {
 		return nil
 	}
 
@@ -56,7 +64,7 @@ func (f *FlowContext) broadcastTransactionsAfterBlockAdded(
 
 	txIDsToBroadcast := make([]*externalapi.DomainTransactionID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
 	for i, tx := range transactionsAcceptedToMempool {
-		txIDsToBroadcast[i] = consensusserialization.TransactionID(tx)
+		txIDsToBroadcast[i] = consensushashing.TransactionID(tx)
 	}
 	offset := len(transactionsAcceptedToMempool)
 	for i, txID := range txIDsToRebroadcast {
@@ -81,10 +89,10 @@ func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks
 
 // AddBlock adds the given block to the DAG and propagates it.
 func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
-	err := f.Domain().Consensus().ValidateAndInsertBlock(block)
+	_, err := f.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
-			log.Infof("Validation failed for block %s: %s", consensusserialization.BlockHash(block), err)
+			log.Infof("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
 			return nil
 		}
 		return err
@@ -93,5 +101,29 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 	if err != nil {
 		return err
 	}
-	return f.Broadcast(appmessage.NewMsgInvBlock(consensusserialization.BlockHash(block)))
+	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")
 }

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/relaytransactions"
+	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/infrastructure/config"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
@@ -41,13 +41,11 @@ type FlowContext struct {
 	transactionsToRebroadcastLock sync.Mutex
 	transactionsToRebroadcast     map[externalapi.DomainTransactionID]*externalapi.DomainTransaction
 	lastRebroadcastTime           time.Time
-	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
+	sharedRequestedTransactions   *transactionrelay.SharedRequestedTransactions
 
 	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
 
-	isInIBD       uint32
-	startIBDMutex sync.Mutex
-	ibdPeer       *peerpkg.Peer
+	isInIBD uint32
 
 	peers      map[id.ID]*peerpkg.Peer
 	peersMutex sync.RWMutex
@@ -66,7 +64,7 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		domain:                      domain,
 		addressManager:              addressManager,
 		connectionManager:           connectionManager,
-		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
+		sharedRequestedTransactions: transactionrelay.NewSharedRequestedTransactions(),
 		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
 		peers:                       make(map[id.ID]*peerpkg.Peer),
 		transactionsToRebroadcast:   make(map[externalapi.DomainTransactionID]*externalapi.DomainTransaction),

app/protocol/flowcontext/ibd.go

@@ -1,130 +0,0 @@
-package flowcontext
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"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
-	}
-
-	syncInfo, err := f.domain.Consensus().GetSyncInfo()
-	if err != nil {
-		return err
-	}
-
-	if syncInfo.State == externalapi.SyncStateRelay {
-		return nil
-	}
-
-	peer, err := f.selectPeerForIBD(syncInfo)
-	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(syncInfo *externalapi.SyncInfo) (*peerpkg.Peer, error) {
-	f.peersMutex.RLock()
-	defer f.peersMutex.RUnlock()
-
-	for _, peer := range f.peers {
-		peerSelectedTipHash := peer.SelectedTipHash()
-
-		if f.IsOrphan(peerSelectedTipHash) {
-			continue
-		}
-
-		blockInfo, err := f.domain.Consensus().GetBlockInfo(peerSelectedTipHash)
-		if err != nil {
-			return nil, err
-		}
-		if syncInfo.State == externalapi.SyncStateHeadersFirst {
-			if !blockInfo.Exists {
-				return peer, nil
-			}
-		} else {
-			if blockInfo.Exists && blockInfo.BlockStatus == externalapi.StatusHeaderOnly &&
-				blockInfo.IsBlockInHeaderPruningPointFuture {
-				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

@@ -3,7 +3,7 @@ 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/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/pkg/errors"
 )
 
@@ -12,7 +12,7 @@ func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
 	f.orphansMutex.Lock()
 	defer f.orphansMutex.Unlock()
 
-	orphanHash := consensusserialization.BlockHash(orphanBlock)
+	orphanHash := consensushashing.BlockHash(orphanBlock)
 	f.orphans[*orphanHash] = orphanBlock
 
 	log.Infof("Received a block with missing parents, adding to orphan pool: %s", orphanHash)
@@ -34,7 +34,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*ext
 
 	// Find all the children of rootBlock among the orphans
 	// and add them to the process queue
-	rootBlockHash := consensusserialization.BlockHash(rootBlock)
+	rootBlockHash := consensushashing.BlockHash(rootBlock)
 	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
 
 	var unorphanedBlocks []*externalapi.DomainBlock
@@ -52,7 +52,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*ext
 			if err != nil {
 				return nil, err
 			}
-			if !orphanBlockParentInfo.Exists {
+			if !orphanBlockParentInfo.Exists || orphanBlockParentInfo.BlockStatus == externalapi.StatusHeaderOnly {
 				log.Tracef("Cannot unorphan block %s. It's missing at "+
 					"least the following parent: %s", orphanHash, orphanBlockParentHash)
 
@@ -116,7 +116,7 @@ func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) error {
 	}
 	delete(f.orphans, orphanHash)
 
-	err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock)
+	_, 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)

app/protocol/flowcontext/transactions.go

@@ -4,9 +4,9 @@ import (
 	"time"
 
 	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
+	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 )
 
 // AddTransaction adds transaction to the mempool and propagates it.
@@ -19,7 +19,7 @@ func (f *FlowContext) AddTransaction(tx *externalapi.DomainTransaction) error {
 		return err
 	}
 
-	transactionID := consensusserialization.TransactionID(tx)
+	transactionID := consensushashing.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, *consensusserialization.TransactionID(tx))
+		delete(f.transactionsToRebroadcast, *consensushashing.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] = consensusserialization.TransactionID(tx)
+		txIDs[i] = consensushashing.TransactionID(tx)
 		i++
 	}
 	return txIDs
 }
 
-// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
+// SharedRequestedTransactions returns a *transactionrelay.SharedRequestedTransactions for sharing
 // data about requested transactions between different peers.
-func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
+func (f *FlowContext) SharedRequestedTransactions() *transactionrelay.SharedRequestedTransactions {
 	return f.sharedRequestedTransactions
 }
 

app/protocol/flows/blockrelay/block_locator.go

@@ -0,0 +1,29 @@
+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,9 +1,10 @@
-package ibd
+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"
 )
@@ -30,7 +31,7 @@ func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute
 			if err != nil {
 				return err
 			}
-			if !blockInfo.Exists {
+			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
 				return protocolerrors.Errorf(true, "block %s not found", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -5,6 +5,7 @@ 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"
 )
@@ -31,7 +32,7 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 			if err != nil {
 				return err
 			}
-			if !blockInfo.Exists {
+			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
 				return protocolerrors.Errorf(true, "block %s not found", hash)
 			}
 			block, err := context.Domain().Consensus().GetBlock(hash)

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -8,25 +8,31 @@ import (
 	"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/blocks"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/infrastructure/config"
 	"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 {
@@ -53,6 +59,7 @@ 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
@@ -69,30 +76,54 @@ 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
 		}
 
-		err = flow.StartIBDIfRequired()
+		// 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)
 		if err != nil {
 			return err
 		}
-		if flow.IsInIBD() {
-			// Block relay is disabled during IBD
+		if exists {
+			log.Debugf("Aborting requesting block %s because it already exists", inv.Hash)
 			continue
 		}
 
-		requestQueue := newHashesQueueSet()
-		requestQueue.enqueueIfNotExists(inv.Hash)
-
-		for requestQueue.len() > 0 {
-			err := flow.requestBlocks(requestQueue)
+		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)
 			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
 		}
 	}
 }
@@ -117,68 +148,34 @@ func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error)
 	return inv, nil
 }
 
-func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
-	numHashesToRequest := mathUtil.MinInt(appmessage.MaxRequestRelayBlocksHashes, 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)
+func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
+	exists := flow.SharedRequestedBlocks().addIfNotExists(requestHash)
+	if exists {
+		return nil, true, nil
 	}
 
-	// Exit early if we've filtered out all the hashes
-	if len(filteredHashesToRequest) == 0 {
-		return nil
-	}
-
-	// In case the function returns earlier than expected, we want to make sure requestedBlocks is
+	// In case the function returns earlier than expected, we want to make sure flow.SharedRequestedBlocks() is
 	// clean from any pending blocks.
-	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+	defer flow.SharedRequestedBlocks().remove(requestHash)
 
-	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks([]*externalapi.DomainHash{requestHash})
 	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
 	if err != nil {
-		return err
+		return nil, false, err
 	}
 
-	for len(pendingBlocks) > 0 {
-		msgBlock, err := flow.readMsgBlock()
-		if err != nil {
-			return err
-		}
-
-		block := appmessage.MsgBlockToDomainBlock(msgBlock)
-		blockHash := consensusserialization.BlockHash(block)
-
-		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)
+	msgBlock, err := flow.readMsgBlock()
+	if err != nil {
+		return nil, false, err
 	}
-	return nil
+
+	block := appmessage.MsgBlockToDomainBlock(msgBlock)
+	blockHash := consensushashing.BlockHash(block)
+	if *blockHash != *requestHash {
+		return nil, false, protocolerrors.Errorf(true, "got unrequested block %s", blockHash)
+	}
+
+	return block, false, nil
 }
 
 // readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
@@ -202,68 +199,91 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *externalapi.DomainBlock) error {
-	blockHash := consensusserialization.BlockHash(block)
-	err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
+	blockHash := consensushashing.BlockHash(block)
+	_, err := flow.Domain().Consensus().ValidateAndInsertBlock(block)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return errors.Wrapf(err, "failed to process block %s", blockHash)
+			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			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 err != nil {
-				return err
-			}
-
-			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
-			}
-
-			// Add the orphan to the orphan pool
-			flow.AddOrphan(block)
-
-			// Request the parents for the orphan block from the peer that sent it.
-			for _, missingAncestor := range missingParentsError.MissingParentHashes {
-				requestQueue.enqueueIfNotExists(missingAncestor)
-			}
-			return nil
+			return missingParentsError.MissingParentHashes, nil
 		}
-		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
-
-		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+		log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
-
-	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
-	if err != nil {
-		return err
-	}
-
-	log.Infof("Accepted block %s via relay", blockHash)
-
-	err = flow.StartIBDIfRequired()
-	if err != nil {
-		return err
-	}
-	err = flow.OnNewBlock(block)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	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
+	}
+
+	// Add the block to the orphan set if it's within orphan resolution range
+	isBlockInOrphanResolutionRange, err := flow.isBlockInOrphanResolutionRange(blockHash)
+	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)
+	if err != nil {
+		return false, err
+	}
+
+	blockLocatorHashes, err := flow.receiveBlockLocator()
+	if err != nil {
+		return false, 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
+		}
+	}
+	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...)
 }

app/protocol/flows/blockrelay/handle_request_block_locator.go

@@ -1,4 +1,4 @@
-package ibd
+package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
@@ -32,13 +32,16 @@ func HandleRequestBlockLocator(context RequestBlockLocatorContext, incomingRoute
 
 func (flow *handleRequestBlockLocatorFlow) start() error {
 	for {
-		lowHash, highHash, err := flow.receiveGetBlockLocator()
+		lowHash, highHash, limit, err := flow.receiveGetBlockLocator()
 		if err != nil {
 			return err
 		}
 
-		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash)
+		locator, err := flow.Domain().Consensus().CreateBlockLocator(lowHash, highHash, limit)
 		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)
 		}
@@ -51,15 +54,15 @@ func (flow *handleRequestBlockLocatorFlow) start() error {
 }
 
 func (flow *handleRequestBlockLocatorFlow) receiveGetBlockLocator() (lowHash *externalapi.DomainHash,
-	highHash *externalapi.DomainHash, err error) {
+	highHash *externalapi.DomainHash, limit uint32, err error) {
 
 	message, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 	msgGetBlockLocator := message.(*appmessage.MsgRequestBlockLocator)
 
-	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, nil
+	return msgGetBlockLocator.LowHash, msgGetBlockLocator.HighHash, msgGetBlockLocator.Limit, nil
 }
 
 func (flow *handleRequestBlockLocatorFlow) sendBlockLocator(locator externalapi.BlockLocator) error {

app/protocol/flows/blockrelay/handle_request_headers.go

@@ -1,4 +1,4 @@
-package ibd
+package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"

app/protocol/flows/blockrelay/handle_request_headers_test.go

@@ -1,4 +1,4 @@
-package ibd
+package blockrelay
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"

app/protocol/flows/blockrelay/handle_request_ibd_root_utxo_set_and_block.go

@@ -1,4 +1,4 @@
-package ibd
+package blockrelay
 
 import (
 	"errors"

app/protocol/flows/blockrelay/ibd.go

@@ -0,0 +1,313 @@
+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.IsAwaitingUTXOSet {
+		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) (succeed bool, err 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().ValidateAndInsertPruningPoint(block, utxoSet)
+	if err != nil {
+		return false, protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "error with IBD root UTXO set")
+	}
+
+	syncInfo, err := flow.Domain().Consensus().GetSyncInfo()
+	if err != nil {
+		return false, err
+	}
+
+	// TODO: Find a better way to deal with finality conflicts.
+	if syncInfo.IsAwaitingUTXOSet {
+		log.Warnf("Still awaiting for UTXO set. This can happen only because the given pruning point violates " +
+			"finality. If this keeps happening delete the data directory and restart your node.")
+		return false, nil
+	}
+
+	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

@@ -24,7 +24,6 @@ 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)
 }
@@ -92,12 +91,6 @@ func HandleHandshake(context HandleHandshakeContext, netConnection *netadapter.N
 	if peerAddress != nil {
 		context.AddressManager().AddAddresses(peerAddress)
 	}
-
-	err = context.StartIBDIfRequired()
-	if err != nil {
-		return nil, err
-	}
-
 	return peer, nil
 }
 

app/protocol/flows/handshake/receiveversion.go

@@ -5,6 +5,7 @@ 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"
 )
 
@@ -41,11 +42,16 @@ 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/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/infrastructure/logger"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/kaspanet/kaspad/version"
 )
@@ -48,17 +48,14 @@ func SendVersion(context HandleHandshakeContext, incomingRoute *router.Route,
 }
 
 func (flow *sendVersionFlow) start() error {
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return err
-	}
-	selectedTipHash := consensusserialization.BlockHash(virtualSelectedParent)
-	subnetworkID := flow.Config().SubnetworkID
+	onEnd := logger.LogAndMeasureExecutionTime(log, "sendVersionFlow.start")
+	defer onEnd()
 
 	// Version message.
 	localAddress := flow.AddressManager().BestLocalAddress(flow.peer.Connection().NetAddress())
+	subnetworkID := flow.Config().SubnetworkID
 	msg := appmessage.NewMsgVersion(localAddress, flow.NetAdapter().ID(),
-		flow.Config().ActiveNetParams.Name, selectedTipHash, subnetworkID)
+		flow.Config().ActiveNetParams.Name, subnetworkID)
 	msg.AddUserAgent(userAgentName, userAgentVersion, flow.Config().UserAgentComments...)
 
 	// Advertise the services flag
@@ -70,15 +67,17 @@ 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/ibd.go

@@ -1,355 +0,0 @@
-package ibd
-
-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/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()
-	err := flow.ibdLoop()
-	if err != nil {
-		finishIBDErr := flow.FinishIBD()
-		if finishIBDErr != nil {
-			return finishIBDErr
-		}
-		return err
-	}
-	return flow.FinishIBD()
-}
-
-func (flow *handleIBDFlow) ibdLoop() error {
-	for {
-		syncInfo, err := flow.Domain().Consensus().GetSyncInfo()
-		if err != nil {
-			return err
-		}
-
-		switch syncInfo.State {
-		case externalapi.SyncStateHeadersFirst:
-			err := flow.syncHeaders()
-			if err != nil {
-				return err
-			}
-		case externalapi.SyncStateMissingUTXOSet:
-			found, err := flow.fetchMissingUTXOSet(syncInfo.IBDRootUTXOBlockHash)
-			if err != nil {
-				return err
-			}
-
-			if !found {
-				return nil
-			}
-		case externalapi.SyncStateMissingBlockBodies:
-			err := flow.syncMissingBlockBodies()
-			if err != nil {
-				return err
-			}
-		case externalapi.SyncStateRelay:
-			return nil
-		default:
-			return errors.Errorf("unexpected state %s", syncInfo.State)
-		}
-	}
-}
-
-func (flow *handleIBDFlow) syncHeaders() error {
-	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.downloadHeaders(highestSharedBlockHash, peerSelectedTipHash)
-}
-
-func (flow *handleIBDFlow) syncMissingBlockBodies() error {
-	hashes, err := flow.Domain().Consensus().GetMissingBlockBodyHashes(flow.peer.SelectedTipHash())
-	if err != nil {
-		return err
-	}
-
-	for offset := 0; offset < len(hashes); offset += appmessage.MaxRequestIBDBlocksHashes {
-		var hashesToRequest []*externalapi.DomainHash
-		if offset+appmessage.MaxRequestIBDBlocksHashes < len(hashes) {
-			hashesToRequest = hashes[offset : offset+appmessage.MaxRequestIBDBlocksHashes]
-		} else {
-			hashesToRequest = hashes[offset:]
-		}
-
-		err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDBlocks(hashesToRequest))
-		if err != nil {
-			return err
-		}
-
-		for _, expectedHash := range hashesToRequest {
-			message, err := flow.incomingRoute.DequeueWithTimeout(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 := consensusserialization.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
-}
-
-func (flow *handleIBDFlow) 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 := consensusserialization.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 *handleIBDFlow) receiveIBDRootUTXOSetAndBlock() ([]byte, *externalapi.DomainBlock, bool, error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(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 *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) downloadHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	err := flow.sendRequestHeaders(highestSharedBlockHash, peerSelectedTipHash)
-	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 *handleIBDFlow) sendRequestHeaders(highestSharedBlockHash *externalapi.DomainHash,
-	peerSelectedTipHash *externalapi.DomainHash) error {
-
-	msgGetBlockInvs := appmessage.NewMsgRequstHeaders(highestSharedBlockHash, peerSelectedTipHash)
-	return flow.outgoingRoute.Enqueue(msgGetBlockInvs)
-}
-
-func (flow *handleIBDFlow) receiveHeader() (msgIBDBlock *appmessage.MsgBlockHeader, doneIBD bool, err error) {
-	message, err := flow.incomingRoute.DequeueWithTimeout(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 *handleIBDFlow) processHeader(msgBlockHeader *appmessage.MsgBlockHeader) error {
-	header := appmessage.BlockHeaderToDomainBlockHeader(msgBlockHeader)
-	block := &externalapi.DomainBlock{
-		Header:       header,
-		Transactions: nil,
-	}
-
-	blockHash := consensusserialization.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
-}

app/protocol/flows/ibd/log.go

@@ -1,9 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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/transactionrelay/handle_relayed_transactions.go

@@ -1,4 +1,4 @@
-package relaytransactions
+package transactionrelay
 
 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/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"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 := consensusserialization.TransactionID(tx)
+		txID := consensushashing.TransactionID(tx)
 		if txID != expectedID {
 			return protocolerrors.Errorf(true, "expected transaction %s, but got %s",
 				expectedID, txID)

app/protocol/flows/transactionrelay/handle_requested_transactions.go

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

app/protocol/flows/transactionrelay/shared_requested_transactions.go

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

app/protocol/manager.go

@@ -37,12 +37,6 @@ 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,7 +2,6 @@ package peer
 
 import (
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
@@ -22,9 +21,6 @@ const maxProtocolVersion = 1
 type Peer struct {
 	connection *netadapter.NetConnection
 
-	selectedTipHashMtx sync.RWMutex
-	selectedTipHash    *externalapi.DomainHash
-
 	userAgent                string
 	services                 appmessage.ServiceFlag
 	advertisedProtocolVerion uint32 // protocol version advertised by remote
@@ -39,21 +35,13 @@ 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,
-		selectedTipRequestChan: make(chan struct{}),
-		ibdStartChan:           make(chan struct{}),
-		connectionStarted:      time.Now(),
+		connection:        connection,
+		connectionStarted: time.Now(),
 	}
 }
 
@@ -62,20 +50,6 @@ 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 {
@@ -128,7 +102,6 @@ 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)
@@ -156,46 +129,6 @@ 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,10 +8,8 @@ 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/relaytransactions"
+	"github.com/kaspanet/kaspad/app/protocol/flows/transactionrelay"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
@@ -107,7 +105,6 @@ 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)...)
 
@@ -136,7 +133,10 @@ func (m *Manager) registerBlockRelayFlows(router *routerpkg.Router, isStopping *
 	outgoingRoute := router.OutgoingRoute()
 
 	return []*flow{
-		m.registerFlow("HandleRelayInvs", router, []appmessage.MessageCommand{appmessage.CmdInvRelayBlock, appmessage.CmdBlock}, isStopping, errChan,
+		m.registerFlow("HandleRelayInvs", router, []appmessage.MessageCommand{
+			appmessage.CmdInvRelayBlock, appmessage.CmdBlock, appmessage.CmdBlockLocator, appmessage.CmdIBDBlock,
+			appmessage.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetAndBlock,
+			appmessage.CmdHeader}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
 				return blockrelay.HandleRelayInvs(m.context, incomingRoute,
 					outgoingRoute, peer)
@@ -148,6 +148,34 @@ 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)
+			},
+		),
 	}
 }
 
@@ -169,62 +197,6 @@ 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.CmdDoneHeaders, appmessage.CmdIBDRootNotFound, appmessage.CmdIBDRootUTXOSetAndBlock, appmessage.CmdHeader},
-			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("HandleRequestHeaders", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestHeaders, appmessage.CmdRequestNextHeaders}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return ibd.HandleRequestHeaders(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleRequestIBDRootUTXOSetAndBlock", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDRootUTXOSetAndBlock}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return ibd.HandleRequestIBDRootUTXOSetAndBlock(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-
-		m.registerFlow("HandleIBDBlockRequests", router,
-			[]appmessage.MessageCommand{appmessage.CmdRequestIBDBlocks}, isStopping, errChan,
-			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return ibd.HandleIBDBlockRequests(m.context, incomingRoute, outgoingRoute)
-			},
-		),
-	}
-}
-
 func (m *Manager) registerTransactionRelayFlow(router *routerpkg.Router, isStopping *uint32, errChan chan error) []*flow {
 	outgoingRoute := router.OutgoingRoute()
 
@@ -232,13 +204,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 relaytransactions.HandleRelayedTransactions(m.context, incomingRoute, outgoingRoute)
+				return transactionrelay.HandleRelayedTransactions(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 		m.registerFlow("HandleRequestTransactions", router,
 			[]appmessage.MessageCommand{appmessage.CmdRequestTransactions}, isStopping, errChan,
 			func(incomingRoute *routerpkg.Route, peer *peerpkg.Peer) error {
-				return relaytransactions.HandleRequestedTransactions(m.context, incomingRoute, outgoingRoute)
+				return transactionrelay.HandleRequestedTransactions(m.context, incomingRoute, outgoingRoute)
 			},
 		),
 	}

app/rpc/rpccontext/notificationmanager.go

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

app/rpc/rpccontext/verbosedata.go

@@ -3,7 +3,7 @@ package rpccontext
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/blocks"
+	"math"
 	"math/big"
 	"strconv"
 
@@ -14,7 +14,7 @@ import (
 
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/pointers"
@@ -23,14 +23,13 @@ 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 := consensusserialization.BlockHash(block)
+	hash := consensushashing.BlockHash(block)
 	blockHeader := block.Header
 
-	blueScore, err := blocks.ExtractBlueScore(block)
+	blockInfo, err := ctx.Domain.Consensus().GetBlockInfo(hash)
 	if err != nil {
 		return nil, err
 	}
-
 	result := &appmessage.BlockVerboseData{
 		Hash:                 hash.String(),
 		Version:              blockHeader.Version,
@@ -43,19 +42,19 @@ 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:            blueScore,
+		BlueScore:            blockInfo.BlueScore,
 	}
 
 	txIDs := make([]string, len(block.Transactions))
 	for i, tx := range block.Transactions {
-		txIDs[i] = consensusserialization.TransactionID(tx).String()
+		txIDs[i] = consensushashing.TransactionID(tx).String()
 	}
 	result.TxIDs = txIDs
 
 	if includeTransactionVerboseData {
 		transactionVerboseData := make([]*appmessage.TransactionVerboseData, len(block.Transactions))
 		for i, tx := range block.Transactions {
-			txID := consensusserialization.TransactionID(tx).String()
+			txID := consensushashing.TransactionID(tx).String()
 			data, err := ctx.BuildTransactionVerboseData(tx, txID, blockHeader, hash.String())
 			if err != nil {
 				return nil, err
@@ -78,12 +77,11 @@ func (ctx *Context) GetDifficultyRatio(bits uint32, params *dagconfig.Params) fl
 	target := util.CompactToBig(bits)
 
 	difficulty := new(big.Rat).SetFrac(params.PowMax, target)
-	outString := difficulty.FloatString(8)
-	diff, err := strconv.ParseFloat(outString, 64)
-	if err != nil {
-		log.Errorf("Cannot get difficulty: %s", err)
-		return 0
-	}
+	diff, _ := difficulty.Float64()
+
+	roundingPrecision := float64(100)
+	diff = math.Round(diff*roundingPrecision) / roundingPrecision
+
 	return diff
 }
 
@@ -100,7 +98,7 @@ func (ctx *Context) BuildTransactionVerboseData(tx *externalapi.DomainTransactio
 
 	txReply := &appmessage.TransactionVerboseData{
 		TxID:                      txID,
-		Hash:                      consensusserialization.TransactionHash(tx).String(),
+		Hash:                      consensushashing.TransactionHash(tx).String(),
 		Size:                      estimatedsize.TransactionEstimatedSerializedSize(tx),
 		TransactionVerboseInputs:  ctx.buildTransactionVerboseInputs(tx),
 		TransactionVerboseOutputs: ctx.buildTransactionVerboseOutputs(tx, nil),

app/rpc/rpchandlers/get_block_count.go

@@ -12,6 +12,6 @@ func HandleGetBlockCount(context *rpccontext.Context, _ *router.Router, _ appmes
 	if err != nil {
 		return nil, err
 	}
-	response := appmessage.NewGetBlockCountResponseMessage(syncInfo.BlockCount)
+	response := appmessage.NewGetBlockCountResponseMessage(syncInfo)
 	return response, nil
 }

app/rpc/rpchandlers/get_block_dag_info.go

@@ -3,15 +3,38 @@ 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_connected_peer_info.go

@@ -9,15 +9,12 @@ 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_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/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -15,7 +15,7 @@ func HandleGetSelectedTipHash(context *rpccontext.Context, _ *router.Router, _ a
 	}
 
 	response := appmessage.NewGetSelectedTipHashResponseMessage(
-		consensusserialization.BlockHash(selectedTip).String())
+		consensushashing.BlockHash(selectedTip).String())
 
 	return response, 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/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"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", consensusserialization.BlockHash(domainBlock))
+	log.Infof("Accepted block %s via submitBlock", consensushashing.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/consensusserialization"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"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 := consensusserialization.TransactionID(domainTransaction)
+	transactionID := consensushashing.TransactionID(domainTransaction)
 	err := context.ProtocolManager.AddTransaction(domainTransaction)
 	if err != nil {
 		if !errors.As(err, &mempool.RuleError{}) {

cmd/kaspaminer/mineloop.go

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

domain/consensus/consensus.go

@@ -11,7 +11,7 @@ import (
 
 type consensus struct {
 	lock            *sync.Mutex
-	databaseContext model.DBReader
+	databaseContext model.DBManager
 
 	blockProcessor        model.BlockProcessor
 	blockBuilder          model.BlockBuilder
@@ -25,23 +25,25 @@ type consensus struct {
 	dagTraversalManager   model.DAGTraversalManager
 	difficultyManager     model.DifficultyManager
 	ghostdagManager       model.GHOSTDAGManager
-	headerTipsManager     model.HeaderTipsManager
+	headerTipsManager     model.HeadersSelectedTipManager
 	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
+	acceptanceDataStore     model.AcceptanceDataStore
+	blockStore              model.BlockStore
+	blockHeaderStore        model.BlockHeaderStore
+	pruningStore            model.PruningStore
+	ghostdagDataStore       model.GHOSTDAGDataStore
+	blockRelationStore      model.BlockRelationStore
+	blockStatusStore        model.BlockStatusStore
+	consensusStateStore     model.ConsensusStateStore
+	headersSelectedTipStore model.HeaderSelectedTipStore
+	multisetStore           model.MultisetStore
+	reachabilityDataStore   model.ReachabilityDataStore
+	utxoDiffStore           model.UTXODiffStore
+	finalityStore           model.FinalityStore
 }
 
 // BuildBlock builds a block over the current state, with the transactions
@@ -57,7 +59,7 @@ func (s *consensus) BuildBlock(coinbaseData *externalapi.DomainCoinbaseData,
 
 // ValidateAndInsertBlock validates the given block and, if valid, applies it
 // to the current state
-func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock) error {
+func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock) (*externalapi.BlockInsertionResult, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
@@ -129,11 +131,12 @@ func (s *consensus) GetBlockInfo(blockHash *externalapi.DomainHash) (*externalap
 		return blockInfo, nil
 	}
 
-	isBlockInHeaderPruningPointFuture, err := s.syncManager.IsBlockInHeaderPruningPointFuture(blockHash)
+	ghostdagData, err := s.ghostdagDataStore.Get(s.databaseContext, blockHash)
 	if err != nil {
 		return nil, err
 	}
-	blockInfo.IsBlockInHeaderPruningPointFuture = isBlockInHeaderPruningPointFuture
+
+	blockInfo.BlueScore = ghostdagData.BlueScore()
 
 	return blockInfo, nil
 }
@@ -174,11 +177,11 @@ func (s *consensus) GetPruningPointUTXOSet(expectedPruningPointHash *externalapi
 	return serializedUTXOSet, nil
 }
 
-func (s *consensus) SetPruningPointUTXOSet(serializedUTXOSet []byte) error {
+func (s *consensus) ValidateAndInsertPruningPoint(newPruningPoint *externalapi.DomainBlock, serializedUTXOSet []byte) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	return s.consensusStateManager.SetPruningPointUTXOSet(serializedUTXOSet)
+	return s.blockProcessor.ValidateAndInsertPruningPoint(newPruningPoint, serializedUTXOSet)
 }
 
 func (s *consensus) GetVirtualSelectedParent() (*externalapi.DomainBlock, error) {
@@ -189,14 +192,39 @@ func (s *consensus) GetVirtualSelectedParent() (*externalapi.DomainBlock, error)
 	if err != nil {
 		return nil, err
 	}
-	return s.blockStore.Block(s.databaseContext, virtualGHOSTDAGData.SelectedParent)
+	return s.blockStore.Block(s.databaseContext, virtualGHOSTDAGData.SelectedParent())
 }
 
-func (s *consensus) CreateBlockLocator(lowHash, highHash *externalapi.DomainHash) (externalapi.BlockLocator, error) {
+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
+}
+
+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)
+	return s.syncManager.CreateBlockLocator(lowHash, highHash, limit)
 }
 
 func (s *consensus) FindNextBlockLocatorBoundaries(blockLocator externalapi.BlockLocator) (lowHash, highHash *externalapi.DomainHash, err error) {

domain/consensus/consensus_test.go

@@ -5,7 +5,7 @@ import (
 
 	"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/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/pkg/errors"
@@ -19,19 +19,19 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error setting up consensus: %+v", err)
 		}
-		defer teardown()
+		defer teardown(false)
 
 		invalidBlock, _, err := consensus.BuildBlockWithParents([]*externalapi.DomainHash{params.GenesisHash}, nil, nil)
 		if err != nil {
 			t.Fatal(err)
 		}
 		invalidBlock.Header.TimeInMilliseconds = 0
-		err = consensus.ValidateAndInsertBlock(invalidBlock)
+		_, 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(consensusserialization.BlockHash(invalidBlock))
+		info, err := consensus.GetBlockInfo(consensushashing.BlockHash(invalidBlock))
 		if err != nil {
 			t.Fatalf("Failed to get block info: %v", err)
 		}
@@ -42,9 +42,6 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 		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)
@@ -52,12 +49,12 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 			t.Fatalf("consensus.BuildBlock with an empty coinbase shouldn't fail: %v", err)
 		}
 
-		err = consensus.ValidateAndInsertBlock(validBlock)
+		_, 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(consensusserialization.BlockHash(validBlock))
+		info, err = consensus.GetBlockInfo(consensushashing.BlockHash(validBlock))
 		if err != nil {
 			t.Fatalf("Failed to get block info: %v", err)
 		}
@@ -65,11 +62,8 @@ func TestConsensus_GetBlockInfo(t *testing.T) {
 		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)
+		if info.BlockStatus != externalapi.StatusUTXOValid {
+			t.Fatalf("Expected block status: %s, instead got: %s", externalapi.StatusUTXOValid, info.BlockStatus)
 		}
 
 	})

domain/consensus/database/serialization/block_ghostdag_data.go

@@ -3,26 +3,29 @@ 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,
+		BlueScore:          blockGHOSTDAGData.BlueScore(),
+		BlueWork:           blockGHOSTDAGData.BlueWork().Bytes(),
 		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
@@ -47,11 +50,12 @@ func DBBlockGHOSTDAGDataToBlockGHOSTDAGData(dbBlockGHOSTDAGData *DbBlockGhostdag
 		return nil, err
 	}
 
-	return &model.BlockGHOSTDAGData{
-		BlueScore:          dbBlockGHOSTDAGData.BlueScore,
-		SelectedParent:     selectedParent,
-		MergeSetBlues:      mergetSetBlues,
-		MergeSetReds:       mergetSetReds,
-		BluesAnticoneSizes: bluesAnticoneSizes,
-	}, nil
+	return ghostdagmanager.NewBlockGHOSTDAGData(
+		dbBlockGHOSTDAGData.BlueScore,
+		new(big.Int).SetBytes(dbBlockGHOSTDAGData.BlueWork),
+		selectedParent,
+		mergetSetBlues,
+		mergetSetReds,
+		bluesAnticoneSizes,
+	), nil
 }

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

@@ -865,10 +865,11 @@ type DbBlockGhostdagData struct {
 	unknownFields protoimpl.UnknownFields
 
 	BlueScore          uint64                  `protobuf:"varint,1,opt,name=blueScore,proto3" json:"blueScore,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"`
+	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"`
 }
 
 func (x *DbBlockGhostdagData) Reset() {
@@ -910,6 +911,13 @@ 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
@@ -1848,119 +1856,121 @@ 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, 0xbf, 0x02, 0x0a,
+	0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xdb, 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, 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,
+	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,
 	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, 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,
+	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,
 	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,
+	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, 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,
+	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,
 }
 
 var (

domain/consensus/database/serialization/dbobjects.proto

@@ -83,10 +83,11 @@ message DbBlockStatus {
 
 message DbBlockGhostdagData {
   uint64 blueScore = 1;
-  DbHash selectedParent = 2;
-  repeated DbHash mergeSetBlues = 3;
-  repeated DbHash mergeSetReds = 4;
-  repeated DbBluesAnticoneSizes bluesAnticoneSizes = 5;
+  bytes blueWork = 2;
+  DbHash selectedParent = 3;
+  repeated DbHash mergeSetBlues = 4;
+  repeated DbHash mergeSetReds = 5;
+  repeated DbBluesAnticoneSizes bluesAnticoneSizes = 6;
 }
 
 message DbBluesAnticoneSizes {

domain/consensus/database/serialization/utxo_collection.go

@@ -2,32 +2,39 @@ package serialization
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 )
 
-func utxoCollectionToDBUTXOCollection(utxoCollection model.UTXOCollection) []*DbUtxoCollectionItem {
-	items := make([]*DbUtxoCollectionItem, len(utxoCollection))
+func utxoCollectionToDBUTXOCollection(utxoCollection model.UTXOCollection) ([]*DbUtxoCollectionItem, error) {
+	items := make([]*DbUtxoCollectionItem, utxoCollection.Len())
 	i := 0
-	for outpoint, entry := range utxoCollection {
-		outpointCopy := outpoint
+	utxoIterator := utxoCollection.Iterator()
+	for utxoIterator.Next() {
+		outpoint, entry, err := utxoIterator.Get()
+		if err != nil {
+			return nil, err
+		}
+
 		items[i] = &DbUtxoCollectionItem{
-			Outpoint:  DomainOutpointToDbOutpoint(&outpointCopy),
+			Outpoint:  DomainOutpointToDbOutpoint(outpoint),
 			UtxoEntry: UTXOEntryToDBUTXOEntry(entry),
 		}
 		i++
 	}
 
-	return items
+	return items, nil
 }
 
 func dbUTXOCollectionToUTXOCollection(items []*DbUtxoCollectionItem) (model.UTXOCollection, error) {
-	collection := make(model.UTXOCollection)
+	utxoMap := make(map[externalapi.DomainOutpoint]externalapi.UTXOEntry, len(items))
 	for _, item := range items {
 		outpoint, err := DbOutpointToDomainOutpoint(item.Outpoint)
 		if err != nil {
 			return nil, err
 		}
 
-		collection[*outpoint] = DBUTXOEntryToUTXOEntry(item.UtxoEntry)
+		utxoMap[*outpoint] = DBUTXOEntryToUTXOEntry(item.UtxoEntry)
 	}
-	return collection, nil
+	return utxo.NewUTXOCollection(utxoMap), nil
 }

domain/consensus/database/serialization/utxo_diff.go

@@ -2,18 +2,29 @@ package serialization
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 )
 
 // UTXODiffToDBUTXODiff converts UTXODiff to DbUtxoDiff
-func UTXODiffToDBUTXODiff(diff *model.UTXODiff) *DbUtxoDiff {
-	return &DbUtxoDiff{
-		ToAdd:    utxoCollectionToDBUTXOCollection(diff.ToAdd),
-		ToRemove: utxoCollectionToDBUTXOCollection(diff.ToRemove),
+func UTXODiffToDBUTXODiff(diff model.UTXODiff) (*DbUtxoDiff, error) {
+	toAdd, err := utxoCollectionToDBUTXOCollection(diff.ToAdd())
+	if err != nil {
+		return nil, err
 	}
+
+	toRemove, err := utxoCollectionToDBUTXOCollection(diff.ToRemove())
+	if err != nil {
+		return nil, err
+	}
+
+	return &DbUtxoDiff{
+		ToAdd:    toAdd,
+		ToRemove: toRemove,
+	}, nil
 }
 
 // DBUTXODiffToUTXODiff converts DbUtxoDiff to UTXODiff
-func DBUTXODiffToUTXODiff(diff *DbUtxoDiff) (*model.UTXODiff, error) {
+func DBUTXODiffToUTXODiff(diff *DbUtxoDiff) (model.UTXODiff, error) {
 	toAdd, err := dbUTXOCollectionToUTXOCollection(diff.ToAdd)
 	if err != nil {
 		return nil, err
@@ -24,8 +35,5 @@ func DBUTXODiffToUTXODiff(diff *DbUtxoDiff) (*model.UTXODiff, error) {
 		return nil, err
 	}
 
-	return &model.UTXODiff{
-		ToAdd:    toAdd,
-		ToRemove: toRemove,
-	}, nil
+	return utxo.NewUTXODiffFromCollections(toAdd, toRemove)
 }

domain/consensus/database/serialization/utxo_entry.go

@@ -2,24 +2,20 @@ package serialization
 
 import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 )
 
 // UTXOEntryToDBUTXOEntry converts UTXOEntry to DbUtxoEntry
-func UTXOEntryToDBUTXOEntry(utxoEntry *externalapi.UTXOEntry) *DbUtxoEntry {
+func UTXOEntryToDBUTXOEntry(utxoEntry externalapi.UTXOEntry) *DbUtxoEntry {
 	return &DbUtxoEntry{
-		Amount:          utxoEntry.Amount,
-		ScriptPublicKey: utxoEntry.ScriptPublicKey,
-		BlockBlueScore:  utxoEntry.BlockBlueScore,
-		IsCoinbase:      utxoEntry.IsCoinbase,
+		Amount:          utxoEntry.Amount(),
+		ScriptPublicKey: utxoEntry.ScriptPublicKey(),
+		BlockBlueScore:  utxoEntry.BlockBlueScore(),
+		IsCoinbase:      utxoEntry.IsCoinbase(),
 	}
 }
 
 // DBUTXOEntryToUTXOEntry convert DbUtxoEntry ro UTXOEntry
-func DBUTXOEntryToUTXOEntry(dbUtxoEntry *DbUtxoEntry) *externalapi.UTXOEntry {
-	return &externalapi.UTXOEntry{
-		Amount:          dbUtxoEntry.Amount,
-		ScriptPublicKey: dbUtxoEntry.ScriptPublicKey,
-		BlockBlueScore:  dbUtxoEntry.BlockBlueScore,
-		IsCoinbase:      dbUtxoEntry.IsCoinbase,
-	}
+func DBUTXOEntryToUTXOEntry(dbUtxoEntry *DbUtxoEntry) externalapi.UTXOEntry {
+	return utxo.NewUTXOEntry(dbUtxoEntry.Amount, dbUtxoEntry.ScriptPublicKey, dbUtxoEntry.IsCoinbase, dbUtxoEntry.BlockBlueScore)
 }

domain/consensus/datastructures/consensusstatestore/consensusstatestore.go

@@ -9,7 +9,7 @@ import (
 type consensusStateStore struct {
 	tipsStaging               []*externalapi.DomainHash
 	virtualDiffParentsStaging []*externalapi.DomainHash
-	virtualUTXODiffStaging    *model.UTXODiff
+	virtualUTXODiffStaging    model.UTXODiff
 	virtualUTXOSetStaging     model.UTXOCollection
 
 	tipsCache               []*externalapi.DomainHash

domain/consensus/datastructures/consensusstatestore/utxo.go

@@ -19,12 +19,12 @@ func utxoKey(outpoint *externalapi.DomainOutpoint) (model.DBKey, error) {
 	return utxoSetBucket.Key(serializedOutpoint), nil
 }
 
-func (css *consensusStateStore) StageVirtualUTXODiff(virtualUTXODiff *model.UTXODiff) error {
+func (css *consensusStateStore) StageVirtualUTXODiff(virtualUTXODiff model.UTXODiff) error {
 	if css.virtualUTXOSetStaging != nil {
 		return errors.New("cannot stage virtual UTXO diff while virtual UTXO set is staged")
 	}
 
-	css.virtualUTXODiffStaging = virtualUTXODiff.Clone()
+	css.virtualUTXODiffStaging = virtualUTXODiff
 	return nil
 }
 
@@ -33,8 +33,13 @@ func (css *consensusStateStore) commitVirtualUTXODiff(dbTx model.DBTransaction)
 		return nil
 	}
 
-	for toRemoveOutpoint := range css.virtualUTXODiffStaging.ToRemove {
-		dbKey, err := utxoKey(&toRemoveOutpoint)
+	toRemoveIterator := css.virtualUTXODiffStaging.ToRemove().Iterator()
+	for toRemoveIterator.Next() {
+		toRemoveOutpoint, _, err := toRemoveIterator.Get()
+		if err != nil {
+			return err
+		}
+		dbKey, err := utxoKey(toRemoveOutpoint)
 		if err != nil {
 			return err
 		}
@@ -44,8 +49,13 @@ func (css *consensusStateStore) commitVirtualUTXODiff(dbTx model.DBTransaction)
 		}
 	}
 
-	for toAddOutpoint, toAddEntry := range css.virtualUTXODiffStaging.ToAdd {
-		dbKey, err := utxoKey(&toAddOutpoint)
+	toAddIterator := css.virtualUTXODiffStaging.ToAdd().Iterator()
+	for toAddIterator.Next() {
+		toAddOutpoint, toAddEntry, err := toAddIterator.Get()
+		if err != nil {
+			return err
+		}
+		dbKey, err := utxoKey(toAddOutpoint)
 		if err != nil {
 			return err
 		}
@@ -69,8 +79,13 @@ func (css *consensusStateStore) commitVirtualUTXOSet(dbTx model.DBTransaction) e
 		return nil
 	}
 
-	for outpoint, utxoEntry := range css.virtualUTXOSetStaging {
-		dbKey, err := utxoKey(&outpoint)
+	iterator := css.virtualUTXOSetStaging.Iterator()
+	for iterator.Next() {
+		outpoint, utxoEntry, err := iterator.Get()
+		if err != nil {
+			return err
+		}
+		dbKey, err := utxoKey(outpoint)
 		if err != nil {
 			return err
 		}
@@ -90,7 +105,7 @@ func (css *consensusStateStore) commitVirtualUTXOSet(dbTx model.DBTransaction) e
 }
 
 func (css *consensusStateStore) UTXOByOutpoint(dbContext model.DBReader, outpoint *externalapi.DomainOutpoint) (
-	*externalapi.UTXOEntry, error) {
+	externalapi.UTXOEntry, error) {
 
 	if css.virtualUTXOSetStaging != nil {
 		return css.utxoByOutpointFromStagedVirtualUTXOSet(outpoint)
@@ -101,13 +116,13 @@ func (css *consensusStateStore) UTXOByOutpoint(dbContext model.DBReader, outpoin
 
 func (css *consensusStateStore) utxoByOutpointFromStagedVirtualUTXODiff(dbContext model.DBReader,
 	outpoint *externalapi.DomainOutpoint) (
-	*externalapi.UTXOEntry, error) {
+	externalapi.UTXOEntry, error) {
 
 	if css.virtualUTXODiffStaging != nil {
-		if _, ok := css.virtualUTXODiffStaging.ToRemove[*outpoint]; ok {
+		if css.virtualUTXODiffStaging.ToRemove().Contains(outpoint) {
 			return nil, errors.Errorf("outpoint was not found")
 		}
-		if utxoEntry, ok := css.virtualUTXODiffStaging.ToAdd[*outpoint]; ok {
+		if utxoEntry, ok := css.virtualUTXODiffStaging.ToAdd().Get(outpoint); ok {
 			return utxoEntry, nil
 		}
 	}
@@ -126,8 +141,8 @@ func (css *consensusStateStore) utxoByOutpointFromStagedVirtualUTXODiff(dbContex
 }
 
 func (css *consensusStateStore) utxoByOutpointFromStagedVirtualUTXOSet(outpoint *externalapi.DomainOutpoint) (
-	*externalapi.UTXOEntry, error) {
-	if utxoEntry, ok := css.virtualUTXOSetStaging[*outpoint]; ok {
+	externalapi.UTXOEntry, error) {
+	if utxoEntry, ok := css.virtualUTXOSetStaging.Get(outpoint); ok {
 		return utxoEntry, nil
 	}
 
@@ -146,10 +161,10 @@ func (css *consensusStateStore) hasUTXOByOutpointFromStagedVirtualUTXODiff(dbCon
 	outpoint *externalapi.DomainOutpoint) (bool, error) {
 
 	if css.virtualUTXODiffStaging != nil {
-		if _, ok := css.virtualUTXODiffStaging.ToRemove[*outpoint]; ok {
+		if css.virtualUTXODiffStaging.ToRemove().Contains(outpoint) {
 			return false, nil
 		}
-		if _, ok := css.virtualUTXODiffStaging.ToAdd[*outpoint]; ok {
+		if _, ok := css.virtualUTXODiffStaging.ToAdd().Get(outpoint); ok {
 			return true, nil
 		}
 	}
@@ -163,8 +178,7 @@ func (css *consensusStateStore) hasUTXOByOutpointFromStagedVirtualUTXODiff(dbCon
 }
 
 func (css *consensusStateStore) hasUTXOByOutpointFromStagedVirtualUTXOSet(outpoint *externalapi.DomainOutpoint) bool {
-	_, ok := css.virtualUTXOSetStaging[*outpoint]
-	return ok
+	return css.virtualUTXOSetStaging.Contains(outpoint)
 }
 
 func (css *consensusStateStore) VirtualUTXOSetIterator(dbContext model.DBReader) (model.ReadOnlyUTXOSetIterator, error) {
@@ -193,7 +207,7 @@ func (u utxoSetIterator) Next() bool {
 	return u.cursor.Next()
 }
 
-func (u utxoSetIterator) Get() (outpoint *externalapi.DomainOutpoint, utxoEntry *externalapi.UTXOEntry, err error) {
+func (u utxoSetIterator) Get() (outpoint *externalapi.DomainOutpoint, utxoEntry externalapi.UTXOEntry, err error) {
 	key, err := u.cursor.Key()
 	if err != nil {
 		panic(err)
@@ -222,18 +236,19 @@ func (css *consensusStateStore) StageVirtualUTXOSet(virtualUTXOSetIterator model
 		return errors.New("cannot stage virtual UTXO set while virtual UTXO diff is staged")
 	}
 
-	css.virtualUTXOSetStaging = make(model.UTXOCollection)
+	utxoMap := make(map[externalapi.DomainOutpoint]externalapi.UTXOEntry)
 	for virtualUTXOSetIterator.Next() {
 		outpoint, entry, err := virtualUTXOSetIterator.Get()
 		if err != nil {
 			return err
 		}
 
-		if _, exists := css.virtualUTXOSetStaging[*outpoint]; exists {
+		if _, exists := utxoMap[*outpoint]; exists {
 			return errors.Errorf("outpoint %s is found more than once in the given iterator", outpoint)
 		}
-		css.virtualUTXOSetStaging[*outpoint] = entry
+		utxoMap[*outpoint] = entry
 	}
+	css.virtualUTXOSetStaging = utxo.NewUTXOCollection(utxoMap)
 
 	return nil
 }

domain/consensus/datastructures/consensusstatestore/utxo_serialization.go

@@ -10,7 +10,7 @@ func serializeOutpoint(outpoint *externalapi.DomainOutpoint) ([]byte, error) {
 	return proto.Marshal(serialization.DomainOutpointToDbOutpoint(outpoint))
 }
 
-func serializeUTXOEntry(entry *externalapi.UTXOEntry) ([]byte, error) {
+func serializeUTXOEntry(entry externalapi.UTXOEntry) ([]byte, error) {
 	return proto.Marshal(serialization.UTXOEntryToDBUTXOEntry(entry))
 }
 
@@ -24,7 +24,7 @@ func deserializeOutpoint(outpointBytes []byte) (*externalapi.DomainOutpoint, err
 	return serialization.DbOutpointToDomainOutpoint(dbOutpoint)
 }
 
-func deserializeUTXOEntry(entryBytes []byte) (*externalapi.UTXOEntry, error) {
+func deserializeUTXOEntry(entryBytes []byte) (externalapi.UTXOEntry, error) {
 	dbEntry := &serialization.DbUtxoEntry{}
 	err := proto.Unmarshal(entryBytes, dbEntry)
 	if err != nil {

domain/consensus/datastructures/finalitystore/finality_store.go

@@ -0,0 +1,78 @@
+package finalitystore
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/dbkeys"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/lrucache"
+)
+
+var bucket = dbkeys.MakeBucket([]byte("finality-points"))
+
+type finalityStore struct {
+	staging  map[externalapi.DomainHash]*externalapi.DomainHash
+	toDelete map[externalapi.DomainHash]struct{}
+	cache    *lrucache.LRUCache
+}
+
+// New instantiates a new FinalityStore
+func New(cacheSize int) model.FinalityStore {
+	return &finalityStore{
+		staging:  make(map[externalapi.DomainHash]*externalapi.DomainHash),
+		toDelete: make(map[externalapi.DomainHash]struct{}),
+		cache:    lrucache.New(cacheSize),
+	}
+}
+
+func (fs *finalityStore) StageFinalityPoint(blockHash *externalapi.DomainHash, finalityPointHash *externalapi.DomainHash) {
+	fs.staging[*blockHash] = finalityPointHash
+}
+
+func (fs *finalityStore) FinalityPoint(
+	dbContext model.DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
+	if finalityPointHash, ok := fs.staging[*blockHash]; ok {
+		return finalityPointHash, nil
+	}
+
+	if finalityPointHash, ok := fs.cache.Get(blockHash); ok {
+		return finalityPointHash.(*externalapi.DomainHash), nil
+	}
+
+	finalityPointHashBytes, err := dbContext.Get(fs.hashAsKey(blockHash))
+	if err != nil {
+		return nil, err
+	}
+	finalityPointHash, err := hashes.FromBytes(finalityPointHashBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	fs.cache.Add(blockHash, finalityPointHash)
+	return finalityPointHash, nil
+}
+
+func (fs *finalityStore) Discard() {
+	fs.staging = make(map[externalapi.DomainHash]*externalapi.DomainHash)
+}
+
+func (fs *finalityStore) Commit(dbTx model.DBTransaction) error {
+	for hash, finalityPointHash := range fs.staging {
+		err := dbTx.Put(fs.hashAsKey(&hash), finalityPointHash[:])
+		if err != nil {
+			return err
+		}
+		fs.cache.Add(&hash, finalityPointHash)
+	}
+
+	fs.Discard()
+	return nil
+}
+
+func (fs *finalityStore) IsStaged() bool {
+	return len(fs.staging) == 0
+}
+
+func (fs *finalityStore) hashAsKey(hash *externalapi.DomainHash) model.DBKey {
+	return bucket.Key(hash[:])
+}

domain/consensus/datastructures/ghostdagdatastore/ghostdagdatastore.go

@@ -13,21 +13,21 @@ var bucket = dbkeys.MakeBucket([]byte("block-ghostdag-data"))
 
 // ghostdagDataStore represents a store of BlockGHOSTDAGData
 type ghostdagDataStore struct {
-	staging map[externalapi.DomainHash]*model.BlockGHOSTDAGData
+	staging map[externalapi.DomainHash]model.BlockGHOSTDAGData
 	cache   *lrucache.LRUCache
 }
 
 // New instantiates a new GHOSTDAGDataStore
 func New(cacheSize int) model.GHOSTDAGDataStore {
 	return &ghostdagDataStore{
-		staging: make(map[externalapi.DomainHash]*model.BlockGHOSTDAGData),
+		staging: make(map[externalapi.DomainHash]model.BlockGHOSTDAGData),
 		cache:   lrucache.New(cacheSize),
 	}
 }
 
 // Stage stages the given blockGHOSTDAGData for the given blockHash
-func (gds *ghostdagDataStore) Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData *model.BlockGHOSTDAGData) {
-	gds.staging[*blockHash] = blockGHOSTDAGData.Clone()
+func (gds *ghostdagDataStore) Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData model.BlockGHOSTDAGData) {
+	gds.staging[*blockHash] = blockGHOSTDAGData
 }
 
 func (gds *ghostdagDataStore) IsStaged() bool {
@@ -35,7 +35,7 @@ func (gds *ghostdagDataStore) IsStaged() bool {
 }
 
 func (gds *ghostdagDataStore) Discard() {
-	gds.staging = make(map[externalapi.DomainHash]*model.BlockGHOSTDAGData)
+	gds.staging = make(map[externalapi.DomainHash]model.BlockGHOSTDAGData)
 }
 
 func (gds *ghostdagDataStore) Commit(dbTx model.DBTransaction) error {
@@ -56,13 +56,13 @@ func (gds *ghostdagDataStore) Commit(dbTx model.DBTransaction) error {
 }
 
 // Get gets the blockGHOSTDAGData associated with the given blockHash
-func (gds *ghostdagDataStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*model.BlockGHOSTDAGData, error) {
+func (gds *ghostdagDataStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) (model.BlockGHOSTDAGData, error) {
 	if blockGHOSTDAGData, ok := gds.staging[*blockHash]; ok {
-		return blockGHOSTDAGData.Clone(), nil
+		return blockGHOSTDAGData, nil
 	}
 
 	if blockGHOSTDAGData, ok := gds.cache.Get(blockHash); ok {
-		return blockGHOSTDAGData.(*model.BlockGHOSTDAGData).Clone(), nil
+		return blockGHOSTDAGData.(model.BlockGHOSTDAGData), nil
 	}
 
 	blockGHOSTDAGDataBytes, err := dbContext.Get(gds.hashAsKey(blockHash))
@@ -75,18 +75,18 @@ func (gds *ghostdagDataStore) Get(dbContext model.DBReader, blockHash *externala
 		return nil, err
 	}
 	gds.cache.Add(blockHash, blockGHOSTDAGData)
-	return blockGHOSTDAGData.Clone(), nil
+	return blockGHOSTDAGData, nil
 }
 
 func (gds *ghostdagDataStore) hashAsKey(hash *externalapi.DomainHash) model.DBKey {
 	return bucket.Key(hash[:])
 }
 
-func (gds *ghostdagDataStore) serializeBlockGHOSTDAGData(blockGHOSTDAGData *model.BlockGHOSTDAGData) ([]byte, error) {
+func (gds *ghostdagDataStore) serializeBlockGHOSTDAGData(blockGHOSTDAGData model.BlockGHOSTDAGData) ([]byte, error) {
 	return proto.Marshal(serialization.BlockGHOSTDAGDataToDBBlockGHOSTDAGData(blockGHOSTDAGData))
 }
 
-func (gds *ghostdagDataStore) deserializeBlockGHOSTDAGData(blockGHOSTDAGDataBytes []byte) (*model.BlockGHOSTDAGData, error) {
+func (gds *ghostdagDataStore) deserializeBlockGHOSTDAGData(blockGHOSTDAGDataBytes []byte) (model.BlockGHOSTDAGData, error) {
 	dbBlockGHOSTDAGData := &serialization.DbBlockGhostdagData{}
 	err := proto.Unmarshal(blockGHOSTDAGDataBytes, dbBlockGHOSTDAGData)
 	if err != nil {

domain/consensus/datastructures/headersselectedtipstore/headertipsstore.go

@@ -0,0 +1,100 @@
+package headersselectedtipstore
+
+import (
+	"github.com/golang/protobuf/proto"
+	"github.com/kaspanet/kaspad/domain/consensus/database/serialization"
+	"github.com/kaspanet/kaspad/domain/consensus/model"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/dbkeys"
+)
+
+var headerSelectedTipKey = dbkeys.MakeBucket().Key([]byte("headers-selected-tip"))
+
+type headerSelectedTipStore struct {
+	staging *externalapi.DomainHash
+	cache   *externalapi.DomainHash
+}
+
+// New instantiates a new HeaderSelectedTipStore
+func New() model.HeaderSelectedTipStore {
+	return &headerSelectedTipStore{}
+}
+
+func (hts *headerSelectedTipStore) Has(dbContext model.DBReader) (bool, error) {
+	if hts.staging != nil {
+		return true, nil
+	}
+
+	if hts.cache != nil {
+		return true, nil
+	}
+
+	return dbContext.Has(headerSelectedTipKey)
+}
+
+func (hts *headerSelectedTipStore) Discard() {
+	hts.staging = nil
+}
+
+func (hts *headerSelectedTipStore) Commit(dbTx model.DBTransaction) error {
+	if hts.staging == nil {
+		return nil
+	}
+
+	selectedTipBytes, err := hts.serializeHeadersSelectedTip(hts.staging)
+	if err != nil {
+		return err
+	}
+	err = dbTx.Put(headerSelectedTipKey, selectedTipBytes)
+	if err != nil {
+		return err
+	}
+	hts.cache = hts.staging
+
+	hts.Discard()
+	return nil
+}
+
+func (hts *headerSelectedTipStore) Stage(selectedTip *externalapi.DomainHash) {
+	hts.staging = selectedTip.Clone()
+}
+
+func (hts *headerSelectedTipStore) IsStaged() bool {
+	return hts.staging != nil
+}
+
+func (hts *headerSelectedTipStore) HeadersSelectedTip(dbContext model.DBReader) (*externalapi.DomainHash, error) {
+	if hts.staging != nil {
+		return hts.staging.Clone(), nil
+	}
+
+	if hts.cache != nil {
+		return hts.cache.Clone(), nil
+	}
+
+	selectedTipBytes, err := dbContext.Get(headerSelectedTipKey)
+	if err != nil {
+		return nil, err
+	}
+
+	selectedTip, err := hts.deserializeHeadersSelectedTip(selectedTipBytes)
+	if err != nil {
+		return nil, err
+	}
+	hts.cache = selectedTip
+	return hts.cache.Clone(), nil
+}
+
+func (hts *headerSelectedTipStore) serializeHeadersSelectedTip(selectedTip *externalapi.DomainHash) ([]byte, error) {
+	return proto.Marshal(serialization.DomainHashToDbHash(selectedTip))
+}
+
+func (hts *headerSelectedTipStore) deserializeHeadersSelectedTip(selectedTipBytes []byte) (*externalapi.DomainHash, error) {
+	dbHash := &serialization.DbHash{}
+	err := proto.Unmarshal(selectedTipBytes, dbHash)
+	if err != nil {
+		return nil, err
+	}
+
+	return serialization.DbHashToDomainHash(dbHash)
+}

domain/consensus/datastructures/headertipsstore/headertipsstore.go

@@ -1,101 +0,0 @@
-package headertipsstore
-
-import (
-	"github.com/golang/protobuf/proto"
-	"github.com/kaspanet/kaspad/domain/consensus/database/serialization"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/dbkeys"
-)
-
-var headerTipsKey = dbkeys.MakeBucket().Key([]byte("header-tips"))
-
-type headerTipsStore struct {
-	staging []*externalapi.DomainHash
-	cache   []*externalapi.DomainHash
-}
-
-// New instantiates a new HeaderTipsStore
-func New() model.HeaderTipsStore {
-	return &headerTipsStore{}
-}
-
-func (hts *headerTipsStore) HasTips(dbContext model.DBReader) (bool, error) {
-	if len(hts.staging) > 0 {
-		return true, nil
-	}
-
-	if len(hts.cache) > 0 {
-		return true, nil
-	}
-
-	return dbContext.Has(headerTipsKey)
-}
-
-func (hts *headerTipsStore) Discard() {
-	hts.staging = nil
-}
-
-func (hts *headerTipsStore) Commit(dbTx model.DBTransaction) error {
-	if hts.staging == nil {
-		return nil
-	}
-
-	tipsBytes, err := hts.serializeTips(hts.staging)
-	if err != nil {
-		return err
-	}
-	err = dbTx.Put(headerTipsKey, tipsBytes)
-	if err != nil {
-		return err
-	}
-	hts.cache = hts.staging
-
-	hts.Discard()
-	return nil
-}
-
-func (hts *headerTipsStore) Stage(tips []*externalapi.DomainHash) {
-	hts.staging = externalapi.CloneHashes(tips)
-}
-
-func (hts *headerTipsStore) IsStaged() bool {
-	return hts.staging != nil
-}
-
-func (hts *headerTipsStore) Tips(dbContext model.DBReader) ([]*externalapi.DomainHash, error) {
-	if hts.staging != nil {
-		return externalapi.CloneHashes(hts.staging), nil
-	}
-
-	if hts.cache != nil {
-		return externalapi.CloneHashes(hts.cache), nil
-	}
-
-	tipsBytes, err := dbContext.Get(headerTipsKey)
-	if err != nil {
-		return nil, err
-	}
-
-	tips, err := hts.deserializeTips(tipsBytes)
-	if err != nil {
-		return nil, err
-	}
-	hts.cache = tips
-	return externalapi.CloneHashes(tips), nil
-}
-
-func (hts *headerTipsStore) serializeTips(tips []*externalapi.DomainHash) ([]byte, error) {
-	dbTips := serialization.HeaderTipsToDBHeaderTips(tips)
-	return proto.Marshal(dbTips)
-}
-
-func (hts *headerTipsStore) deserializeTips(tipsBytes []byte) ([]*externalapi.DomainHash, error) {
-	dbTips := &serialization.DbHeaderTips{}
-	err := proto.Unmarshal(tipsBytes, dbTips)
-	if err != nil {
-		return nil, err
-	}
-
-	return serialization.DBHeaderTipsToHeaderTips(dbTips)
-}

domain/consensus/datastructures/utxodiffstore/utxodiffstore.go

@@ -15,7 +15,7 @@ var utxoDiffChildBucket = dbkeys.MakeBucket([]byte("utxo-diff-children"))
 
 // utxoDiffStore represents a store of UTXODiffs
 type utxoDiffStore struct {
-	utxoDiffStaging      map[externalapi.DomainHash]*model.UTXODiff
+	utxoDiffStaging      map[externalapi.DomainHash]model.UTXODiff
 	utxoDiffChildStaging map[externalapi.DomainHash]*externalapi.DomainHash
 	toDelete             map[externalapi.DomainHash]struct{}
 	utxoDiffCache        *lrucache.LRUCache
@@ -25,7 +25,7 @@ type utxoDiffStore struct {
 // New instantiates a new UTXODiffStore
 func New(cacheSize int) model.UTXODiffStore {
 	return &utxoDiffStore{
-		utxoDiffStaging:      make(map[externalapi.DomainHash]*model.UTXODiff),
+		utxoDiffStaging:      make(map[externalapi.DomainHash]model.UTXODiff),
 		utxoDiffChildStaging: make(map[externalapi.DomainHash]*externalapi.DomainHash),
 		toDelete:             make(map[externalapi.DomainHash]struct{}),
 		utxoDiffCache:        lrucache.New(cacheSize),
@@ -34,8 +34,8 @@ func New(cacheSize int) model.UTXODiffStore {
 }
 
 // Stage stages the given utxoDiff for the given blockHash
-func (uds *utxoDiffStore) Stage(blockHash *externalapi.DomainHash, utxoDiff *model.UTXODiff, utxoDiffChild *externalapi.DomainHash) {
-	uds.utxoDiffStaging[*blockHash] = utxoDiff.Clone()
+func (uds *utxoDiffStore) Stage(blockHash *externalapi.DomainHash, utxoDiff model.UTXODiff, utxoDiffChild *externalapi.DomainHash) {
+	uds.utxoDiffStaging[*blockHash] = utxoDiff
 
 	if utxoDiffChild != nil {
 		uds.utxoDiffChildStaging[*blockHash] = utxoDiffChild.Clone()
@@ -55,7 +55,7 @@ func (uds *utxoDiffStore) IsBlockHashStaged(blockHash *externalapi.DomainHash) b
 }
 
 func (uds *utxoDiffStore) Discard() {
-	uds.utxoDiffStaging = make(map[externalapi.DomainHash]*model.UTXODiff)
+	uds.utxoDiffStaging = make(map[externalapi.DomainHash]model.UTXODiff)
 	uds.utxoDiffChildStaging = make(map[externalapi.DomainHash]*externalapi.DomainHash)
 	uds.toDelete = make(map[externalapi.DomainHash]struct{})
 }
@@ -107,13 +107,13 @@ func (uds *utxoDiffStore) Commit(dbTx model.DBTransaction) error {
 }
 
 // UTXODiff gets the utxoDiff associated with the given blockHash
-func (uds *utxoDiffStore) UTXODiff(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*model.UTXODiff, error) {
+func (uds *utxoDiffStore) UTXODiff(dbContext model.DBReader, blockHash *externalapi.DomainHash) (model.UTXODiff, error) {
 	if utxoDiff, ok := uds.utxoDiffStaging[*blockHash]; ok {
-		return utxoDiff.Clone(), nil
+		return utxoDiff, nil
 	}
 
 	if utxoDiff, ok := uds.utxoDiffCache.Get(blockHash); ok {
-		return utxoDiff.(*model.UTXODiff).Clone(), nil
+		return utxoDiff.(model.UTXODiff), nil
 	}
 
 	utxoDiffBytes, err := dbContext.Get(uds.utxoDiffHashAsKey(blockHash))
@@ -126,7 +126,7 @@ func (uds *utxoDiffStore) UTXODiff(dbContext model.DBReader, blockHash *external
 		return nil, err
 	}
 	uds.utxoDiffCache.Add(blockHash, utxoDiff)
-	return utxoDiff.Clone(), nil
+	return utxoDiff, nil
 }
 
 // UTXODiffChild gets the utxoDiff child associated with the given blockHash
@@ -187,16 +187,21 @@ func (uds *utxoDiffStore) utxoDiffChildHashAsKey(hash *externalapi.DomainHash) m
 	return utxoDiffChildBucket.Key(hash[:])
 }
 
-func (uds *utxoDiffStore) serializeUTXODiff(utxoDiff *model.UTXODiff) ([]byte, error) {
-	dbUtxoDiff := serialization.UTXODiffToDBUTXODiff(utxoDiff)
+func (uds *utxoDiffStore) serializeUTXODiff(utxoDiff model.UTXODiff) ([]byte, error) {
+	dbUtxoDiff, err := serialization.UTXODiffToDBUTXODiff(utxoDiff)
+	if err != nil {
+		return nil, err
+	}
+
 	bytes, err := proto.Marshal(dbUtxoDiff)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
+
 	return bytes, nil
 }
 
-func (uds *utxoDiffStore) deserializeUTXODiff(utxoDiffBytes []byte) (*model.UTXODiff, error) {
+func (uds *utxoDiffStore) deserializeUTXODiff(utxoDiffBytes []byte) (model.UTXODiff, error) {
 	dbUTXODiff := &serialization.DbUtxoDiff{}
 	err := proto.Unmarshal(utxoDiffBytes, dbUTXODiff)
 	if err != nil {

domain/consensus/factory.go

@@ -6,8 +6,7 @@ import (
 	"sync"
 
 	"github.com/kaspanet/kaspad/domain/consensus/processes/dagtraversalmanager"
-
-	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
+	"github.com/kaspanet/kaspad/domain/consensus/processes/finalitymanager"
 
 	consensusdatabase "github.com/kaspanet/kaspad/domain/consensus/database"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/acceptancedatastore"
@@ -16,13 +15,13 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/blockstatusstore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/blockstore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/consensusstatestore"
+	"github.com/kaspanet/kaspad/domain/consensus/datastructures/finalitystore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/ghostdagdatastore"
-	"github.com/kaspanet/kaspad/domain/consensus/datastructures/headertipsstore"
+	"github.com/kaspanet/kaspad/domain/consensus/datastructures/headersselectedtipstore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/multisetstore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/pruningstore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/reachabilitydatastore"
 	"github.com/kaspanet/kaspad/domain/consensus/datastructures/utxodiffstore"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/blockbuilder"
@@ -33,7 +32,7 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/processes/dagtopologymanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/difficultymanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/ghostdagmanager"
-	"github.com/kaspanet/kaspad/domain/consensus/processes/headertipsmanager"
+	"github.com/kaspanet/kaspad/domain/consensus/processes/headersselectedtipmanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/mergedepthmanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/pastmediantimemanager"
 	"github.com/kaspanet/kaspad/domain/consensus/processes/pruningmanager"
@@ -42,14 +41,16 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/processes/transactionvalidator"
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	infrastructuredatabase "github.com/kaspanet/kaspad/infrastructure/db/database"
+	"github.com/kaspanet/kaspad/infrastructure/db/database/ldb"
 )
 
 // Factory instantiates new Consensuses
 type Factory interface {
 	NewConsensus(dagParams *dagconfig.Params, db infrastructuredatabase.Database) (externalapi.Consensus, error)
-	NewTestConsensus(dagParams *dagconfig.Params, testName string) (tc testapi.TestConsensus, teardown func(), err error)
+	NewTestConsensus(dagParams *dagconfig.Params, testName string) (
+		tc testapi.TestConsensus, teardown func(keepDataDir bool), err error)
 	NewTestConsensusWithDataDir(dagParams *dagconfig.Params, dataDir string) (
-		tc testapi.TestConsensus, teardown func(), err error)
+		tc testapi.TestConsensus, teardown func(keepDataDir bool), err error)
 }
 
 type factory struct{}
@@ -64,25 +65,25 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 	dbManager := consensusdatabase.New(db)
 
 	// Data Structures
-	storeCacheSize := 200
-	acceptanceDataStore := acceptancedatastore.New(storeCacheSize)
-	blockStore, err := blockstore.New(dbManager, storeCacheSize)
+	acceptanceDataStore := acceptancedatastore.New(200)
+	blockStore, err := blockstore.New(dbManager, 200)
 	if err != nil {
 		return nil, err
 	}
-	blockHeaderStore, err := blockheaderstore.New(dbManager, storeCacheSize)
+	blockHeaderStore, err := blockheaderstore.New(dbManager, 10_000)
 	if err != nil {
 		return nil, err
 	}
-	blockRelationStore := blockrelationstore.New(storeCacheSize)
-	blockStatusStore := blockstatusstore.New(storeCacheSize)
-	multisetStore := multisetstore.New(storeCacheSize)
+	blockRelationStore := blockrelationstore.New(200)
+	blockStatusStore := blockstatusstore.New(200)
+	multisetStore := multisetstore.New(200)
 	pruningStore := pruningstore.New()
-	reachabilityDataStore := reachabilitydatastore.New(storeCacheSize)
-	utxoDiffStore := utxodiffstore.New(storeCacheSize)
+	reachabilityDataStore := reachabilitydatastore.New(200)
+	utxoDiffStore := utxodiffstore.New(200)
 	consensusStateStore := consensusstatestore.New()
-	ghostdagDataStore := ghostdagdatastore.New(storeCacheSize)
-	headerTipsStore := headertipsstore.New()
+	ghostdagDataStore := ghostdagdatastore.New(10_000)
+	headersSelectedTipStore := headersselectedtipstore.New()
+	finalityStore := finalitystore.New(200)
 
 	// Processes
 	reachabilityManager := reachabilitymanager.New(
@@ -92,12 +93,14 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 	dagTopologyManager := dagtopologymanager.New(
 		dbManager,
 		reachabilityManager,
-		blockRelationStore)
+		blockRelationStore,
+		ghostdagDataStore)
 	ghostdagManager := ghostdagmanager.New(
 		dbManager,
 		dagTopologyManager,
 		ghostdagDataStore,
-		model.KType(dagParams.K))
+		blockHeaderStore,
+		dagParams.K)
 	dagTraversalManager := dagtraversalmanager.New(
 		dbManager,
 		dagTopologyManager,
@@ -111,6 +114,10 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		ghostdagDataStore)
 	transactionValidator := transactionvalidator.New(dagParams.BlockCoinbaseMaturity,
 		dagParams.EnableNonNativeSubnetworks,
+		dagParams.MassPerTxByte,
+		dagParams.MassPerScriptPubKeyByte,
+		dagParams.MassPerSigOp,
+		dagParams.MaxCoinbasePayloadLength,
 		dbManager,
 		pastMedianTimeManager,
 		ghostdagDataStore)
@@ -123,26 +130,41 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		dagTraversalManager,
 		dagParams.PowMax,
 		dagParams.DifficultyAdjustmentWindowSize,
-		dagParams.TargetTimePerBlock)
+		dagParams.DisableDifficultyAdjustment,
+		dagParams.TargetTimePerBlock,
+		dagParams.GenesisHash)
 	coinbaseManager := coinbasemanager.New(
 		dbManager,
+		dagParams.SubsidyReductionInterval,
+		dagParams.BaseSubsidy,
+		dagParams.CoinbasePayloadScriptPublicKeyMaxLength,
 		ghostdagDataStore,
 		acceptanceDataStore)
-	headerTipsManager := headertipsmanager.New(dbManager, dagTopologyManager, ghostdagManager, headerTipsStore)
+	headerTipsManager := headersselectedtipmanager.New(dbManager, dagTopologyManager, ghostdagManager, headersSelectedTipStore)
 	genesisHash := dagParams.GenesisHash
+	finalityManager := finalitymanager.New(
+		dbManager,
+		dagTopologyManager,
+		finalityStore,
+		ghostdagDataStore,
+		genesisHash,
+		dagParams.FinalityDepth())
 	mergeDepthManager := mergedepthmanager.New(
-		dagParams.FinalityDepth(),
 		dbManager,
 		dagTopologyManager,
 		dagTraversalManager,
+		finalityManager,
 		ghostdagDataStore)
 	blockValidator := blockvalidator.New(
 		dagParams.PowMax,
 		dagParams.SkipProofOfWork,
 		genesisHash,
 		dagParams.EnableNonNativeSubnetworks,
-		dagParams.DisableDifficultyAdjustment,
-		dagParams.DifficultyAdjustmentWindowSize,
+		dagParams.MaxBlockSize,
+		dagParams.MergeSetSizeLimit,
+		dagParams.MaxBlockParents,
+		dagParams.TimestampDeviationTolerance,
+		dagParams.TargetTimePerBlock,
 
 		dbManager,
 		difficultyManager,
@@ -153,17 +175,23 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		dagTraversalManager,
 		coinbaseManager,
 		mergeDepthManager,
+		reachabilityManager,
 
+		pruningStore,
 		blockStore,
 		ghostdagDataStore,
 		blockHeaderStore,
 		blockStatusStore,
+		reachabilityDataStore,
 	)
 	consensusStateManager, err := consensusstatemanager.New(
 		dbManager,
-		dagParams.FinalityDepth(),
 		dagParams.PruningDepth(),
+		dagParams.MaxMassAcceptedByBlock,
+		dagParams.MaxBlockParents,
+		dagParams.MergeSetSizeLimit,
 		genesisHash,
+
 		ghostdagManager,
 		dagTopologyManager,
 		dagTraversalManager,
@@ -173,6 +201,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		reachabilityManager,
 		coinbaseManager,
 		mergeDepthManager,
+		finalityManager,
 
 		blockStatusStore,
 		ghostdagDataStore,
@@ -183,7 +212,8 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		blockRelationStore,
 		acceptanceDataStore,
 		blockHeaderStore,
-		headerTipsStore)
+		headersSelectedTipStore,
+		pruningStore)
 	if err != nil {
 		return nil, err
 	}
@@ -197,6 +227,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		ghostdagDataStore,
 		pruningStore,
 		blockStatusStore,
+		headersSelectedTipStore,
 		multisetStore,
 		acceptanceDataStore,
 		blockStore,
@@ -208,17 +239,16 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 	syncManager := syncmanager.New(
 		dbManager,
 		genesisHash,
-		dagParams.TargetTimePerBlock.Milliseconds(),
 		dagTraversalManager,
 		dagTopologyManager,
 		ghostdagManager,
-		consensusStateManager,
+		pruningManager,
 
 		ghostdagDataStore,
 		blockStatusStore,
 		blockHeaderStore,
-		headerTipsStore,
-		blockStore)
+		blockStore,
+		pruningStore)
 
 	blockBuilder := blockbuilder.New(
 		dbManager,
@@ -234,7 +264,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 	)
 
 	blockProcessor := blockprocessor.New(
-		dagParams,
+		genesisHash,
 		dbManager,
 		consensusStateManager,
 		pruningManager,
@@ -259,7 +289,8 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		reachabilityDataStore,
 		utxoDiffStore,
 		blockHeaderStore,
-		headerTipsStore)
+		headersSelectedTipStore,
+		finalityStore)
 
 	c := &consensus{
 		lock:            &sync.Mutex{},
@@ -281,19 +312,21 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 		mergeDepthManager:     mergeDepthManager,
 		pruningManager:        pruningManager,
 		reachabilityManager:   reachabilityManager,
+		finalityManager:       finalityManager,
 
-		acceptanceDataStore:   acceptanceDataStore,
-		blockStore:            blockStore,
-		blockHeaderStore:      blockHeaderStore,
-		pruningStore:          pruningStore,
-		ghostdagDataStore:     ghostdagDataStore,
-		blockStatusStore:      blockStatusStore,
-		blockRelationStore:    blockRelationStore,
-		consensusStateStore:   consensusStateStore,
-		headerTipsStore:       headerTipsStore,
-		multisetStore:         multisetStore,
-		reachabilityDataStore: reachabilityDataStore,
-		utxoDiffStore:         utxoDiffStore,
+		acceptanceDataStore:     acceptanceDataStore,
+		blockStore:              blockStore,
+		blockHeaderStore:        blockHeaderStore,
+		pruningStore:            pruningStore,
+		ghostdagDataStore:       ghostdagDataStore,
+		blockStatusStore:        blockStatusStore,
+		blockRelationStore:      blockRelationStore,
+		consensusStateStore:     consensusStateStore,
+		headersSelectedTipStore: headersSelectedTipStore,
+		multisetStore:           multisetStore,
+		reachabilityDataStore:   reachabilityDataStore,
+		utxoDiffStore:           utxoDiffStore,
+		finalityStore:           finalityStore,
 	}
 
 	genesisInfo, err := c.GetBlockInfo(genesisHash)
@@ -302,7 +335,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 	}
 
 	if !genesisInfo.Exists {
-		err = c.ValidateAndInsertBlock(dagParams.GenesisBlock)
+		_, err = c.ValidateAndInsertBlock(dagParams.GenesisBlock)
 		if err != nil {
 			return nil, err
 		}
@@ -312,7 +345,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, db infrastructuredat
 }
 
 func (f *factory) NewTestConsensus(dagParams *dagconfig.Params, testName string) (
-	tc testapi.TestConsensus, teardown func(), err error) {
+	tc testapi.TestConsensus, teardown func(keepDataDir bool), err error) {
 
 	dataDir, err := ioutil.TempDir("", testName)
 	if err != nil {
@@ -323,7 +356,7 @@ func (f *factory) NewTestConsensus(dagParams *dagconfig.Params, testName string)
 }
 
 func (f *factory) NewTestConsensusWithDataDir(dagParams *dagconfig.Params, dataDir string) (
-	tc testapi.TestConsensus, teardown func(), err error) {
+	tc testapi.TestConsensus, teardown func(keepDataDir bool), err error) {
 
 	db, err := ldb.NewLevelDB(dataDir)
 	if err != nil {
@@ -338,16 +371,24 @@ func (f *factory) NewTestConsensusWithDataDir(dagParams *dagconfig.Params, dataD
 
 	testConsensusStateManager := consensusstatemanager.NewTestConsensusStateManager(consensusAsImplementation.consensusStateManager)
 
+	testTransactionValidator := transactionvalidator.NewTestTransactionValidator(consensusAsImplementation.transactionValidator)
+
 	tstConsensus := &testConsensus{
 		consensus:                 consensusAsImplementation,
 		testConsensusStateManager: testConsensusStateManager,
 		testReachabilityManager: reachabilitymanager.NewTestReachabilityManager(consensusAsImplementation.
 			reachabilityManager),
+		testTransactionValidator: testTransactionValidator,
 	}
 	tstConsensus.testBlockBuilder = blockbuilder.NewTestBlockBuilder(consensusAsImplementation.blockBuilder, tstConsensus)
-	teardown = func() {
+	teardown = func(keepDataDir bool) {
 		db.Close()
-		os.RemoveAll(dataDir)
+		if !keepDataDir {
+			err := os.RemoveAll(dataDir)
+			if err != nil {
+				log.Errorf("Error removing data directory for test consensus: %s", err)
+			}
+		}
 	}
 
 	return tstConsensus, teardown, nil

domain/consensus/finality_test.go

@@ -5,7 +5,7 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/model/testapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensusserialization"
+	"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"
@@ -24,7 +24,7 @@ func TestFinality(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error setting up consensus: %+v", err)
 		}
-		defer teardown()
+		defer teardown(false)
 
 		buildAndInsertBlock := func(parentHashes []*externalapi.DomainHash) (*externalapi.DomainBlock, error) {
 			block, _, err := consensus.BuildBlockWithParents(parentHashes, nil, nil)
@@ -32,7 +32,7 @@ func TestFinality(t *testing.T) {
 				return nil, err
 			}
 
-			err = consensus.ValidateAndInsertBlock(block)
+			_, err = consensus.ValidateAndInsertBlock(block)
 			if err != nil {
 				return nil, err
 			}
@@ -47,17 +47,17 @@ func TestFinality(t *testing.T) {
 		for i := uint64(0); i < finalityInterval-1; i++ {
 			mainChainTip, err = buildAndInsertBlock([]*externalapi.DomainHash{mainChainTipHash})
 			if err != nil {
-				t.Fatalf("TestFinality: Failed to process Block #%d: %v", i, err)
+				t.Fatalf("TestFinality: Failed to process Block #%d: %+v", i, err)
 			}
-			mainChainTipHash = consensusserialization.BlockHash(mainChainTip)
+			mainChainTipHash = consensushashing.BlockHash(mainChainTip)
 
 			blockInfo, err := consensus.GetBlockInfo(mainChainTipHash)
 			if err != nil {
-				t.Fatalf("TestFinality: Block #%d failed to get info: %v", i, err)
+				t.Fatalf("TestFinality: Block #%d failed to get info: %+v", i, err)
 			}
-			if blockInfo.BlockStatus != externalapi.StatusValid {
+			if blockInfo.BlockStatus != externalapi.StatusUTXOValid {
 				t.Fatalf("Block #%d in main chain expected to have status '%s', but got '%s'",
-					i, externalapi.StatusValid, blockInfo.BlockStatus)
+					i, externalapi.StatusUTXOValid, blockInfo.BlockStatus)
 			}
 		}
 
@@ -69,7 +69,7 @@ func TestFinality(t *testing.T) {
 			if err != nil {
 				t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
 			}
-			sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
+			sideChainTipHash = consensushashing.BlockHash(sideChainTip)
 
 			blockInfo, err := consensus.GetBlockInfo(sideChainTipHash)
 			if err != nil {
@@ -89,7 +89,7 @@ func TestFinality(t *testing.T) {
 			if err != nil {
 				t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
 			}
-			sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
+			sideChainTipHash = consensushashing.BlockHash(sideChainTip)
 		}
 
 		// Make sure that now the sideChainTip is valid and selectedTip
@@ -99,15 +99,15 @@ func TestFinality(t *testing.T) {
 		} else if !blockInfo.Exists {
 			t.Fatalf("TestFinality: Failed getting block info, doesn't exists")
 		}
-		if blockInfo.BlockStatus != externalapi.StatusValid {
+		if blockInfo.BlockStatus != externalapi.StatusUTXOValid {
 			t.Fatalf("TestFinality: Overtaking block in side-chain expected to have status '%s', but got '%s'",
-				externalapi.StatusValid, blockInfo.BlockStatus)
+				externalapi.StatusUTXOValid, blockInfo.BlockStatus)
 		}
 		selectedTip, err := consensus.GetVirtualSelectedParent()
 		if err != nil {
 			t.Fatalf("TestFinality: Failed getting virtual selectedParent: %v", err)
 		}
-		if *consensusserialization.BlockHash(selectedTip) != *sideChainTipHash {
+		if *consensushashing.BlockHash(selectedTip) != *sideChainTipHash {
 			t.Fatalf("Overtaking block in side-chain is not selectedTip")
 		}
 
@@ -117,10 +117,10 @@ func TestFinality(t *testing.T) {
 			if err != nil {
 				t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
 			}
-			mainChainTipHash = consensusserialization.BlockHash(mainChainTip)
+			mainChainTipHash = consensushashing.BlockHash(mainChainTip)
 		}
 
-		virtualFinality, err := consensus.ConsensusStateManager().VirtualFinalityPoint()
+		virtualFinality, err := consensus.FinalityManager().VirtualFinalityPoint()
 		if err != nil {
 			t.Fatalf("TestFinality: Failed getting the virtual's finality point: %v", err)
 		}
@@ -137,7 +137,7 @@ func TestFinality(t *testing.T) {
 			if err != nil {
 				t.Fatalf("TestFinality: Failed to process sidechain Block #%d: %v", i, err)
 			}
-			sideChainTipHash = consensusserialization.BlockHash(sideChainTip)
+			sideChainTipHash = consensushashing.BlockHash(sideChainTip)
 		}
 
 		// Check that sideChainTip hash higher blue score than the selected parent
@@ -145,7 +145,7 @@ func TestFinality(t *testing.T) {
 		if err != nil {
 			t.Fatalf("TestFinality: Failed getting virtual selectedParent: %v", err)
 		}
-		selectedTipGhostDagData, err := consensus.GHOSTDAGDataStore().Get(consensus.DatabaseContext(), consensusserialization.BlockHash(selectedTip))
+		selectedTipGhostDagData, err := consensus.GHOSTDAGDataStore().Get(consensus.DatabaseContext(), consensushashing.BlockHash(selectedTip))
 		if err != nil {
 			t.Fatalf("TestFinality: Failed getting the ghost dag data of the selected tip: %v", err)
 		}
@@ -155,7 +155,7 @@ func TestFinality(t *testing.T) {
 			t.Fatalf("TestFinality: Failed getting the ghost dag data of the sidechain tip: %v", err)
 		}
 
-		if selectedTipGhostDagData.BlueScore > sideChainTipGhostDagData.BlueScore {
+		if selectedTipGhostDagData.BlueWork().Cmp(sideChainTipGhostDagData.BlueWork()) == 1 {
 			t.Fatalf("sideChainTip is not the bluest tip when it is expected to be")
 		}
 
@@ -190,7 +190,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 				return nil, false // fo some reason go doesn't recognize that t.Fatalf never returns
 			}
 
-			err = consensus.ValidateAndInsertBlock(block)
+			_, err = consensus.ValidateAndInsertBlock(block)
 			if err == nil {
 				return block, false
 			} else if errors.Is(err, ruleerrors.ErrViolatingBoundedMergeDepth) {
@@ -202,7 +202,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 
 		processBlock := func(consensus testapi.TestConsensus, block *externalapi.DomainBlock, name string) {
-			err := consensus.ValidateAndInsertBlock(block)
+			_, err := consensus.ValidateAndInsertBlock(block)
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: %s got unexpected error from ProcessBlock: %+v", name, err)
 
@@ -214,7 +214,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: Failed building block: %v", err)
 			}
-			err = consensus.ValidateAndInsertBlock(block)
+			_, err = consensus.ValidateAndInsertBlock(block)
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: Failed Inserting block to consensus: %v", err)
 			}
@@ -222,7 +222,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 
 		getStatus := func(consensus testapi.TestConsensus, block *externalapi.DomainBlock) externalapi.BlockStatus {
-			blockInfo, err := consensus.GetBlockInfo(consensusserialization.BlockHash(block))
+			blockInfo, err := consensus.GetBlockInfo(consensushashing.BlockHash(block))
 			if err != nil {
 				t.Fatalf("TestBoundedMergeDepth: Failed to get block info: %v", err)
 			} else if !blockInfo.Exists {
@@ -241,32 +241,32 @@ func TestBoundedMergeDepth(t *testing.T) {
 		if err != nil {
 			t.Fatalf("TestBoundedMergeDepth: Error setting up consensus: %+v", err)
 		}
-		defer teardownFunc2()
+		defer teardownFunc2(false)
 
 		// Create a block on top on genesis
 		block1 := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{params.GenesisHash})
 
 		// Create a chain
 		selectedChain := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
-		parent := consensusserialization.BlockHash(block1)
+		parent := consensushashing.BlockHash(block1)
 		// Make sure this is always bigger than `blocksChain2` so it will stay the selected chain
 		for i := 0; i < finalityInterval+2; i++ {
 			block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
 			selectedChain = append(selectedChain, block)
-			parent = consensusserialization.BlockHash(block)
+			parent = consensushashing.BlockHash(block)
 		}
 
 		// Create another chain
 		blocksChain2 := make([]*externalapi.DomainBlock, 0, finalityInterval+1)
-		parent = consensusserialization.BlockHash(block1)
+		parent = consensushashing.BlockHash(block1)
 		for i := 0; i < finalityInterval+1; i++ {
 			block := buildAndInsertBlock(consensusBuild, []*externalapi.DomainHash{parent})
 			blocksChain2 = append(blocksChain2, block)
-			parent = consensusserialization.BlockHash(block)
+			parent = consensushashing.BlockHash(block)
 		}
 
 		// Teardown and assign nil to make sure we use the right DAG from here on.
-		teardownFunc1()
+		teardownFunc1(false)
 		consensusBuild = nil
 
 		// Now test against the real DAG
@@ -284,20 +284,20 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 
 		// submit a block pointing at tip(chain1) and on first block in chain2 directly
-		mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[0]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
+		mergeDepthViolatingBlockBottom, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[0]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
 		if !isViolatingMergeDepth {
 			t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingBlockBottom to violate merge depth")
 		}
 
 		// submit a block pointing at tip(chain1) and tip(chain2) should also obviously violate merge depth (this points at first block in chain2 indirectly)
-		mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[len(blocksChain2)-1]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
+		mergeDepthViolatingTop, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-1]), consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
 		if !isViolatingMergeDepth {
 			t.Fatalf("TestBoundedMergeDepth: Expected mergeDepthViolatingTop to violate merge depth")
 		}
 
 		// the location of the parents in the slices need to be both `-X` so the `selectedChain` one will have higher blueScore (it's a chain longer by 1)
-		kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(blocksChain2[len(blocksChain2)-3]), consensusserialization.BlockHash(selectedChain[len(selectedChain)-3])})
-		kosherizingBlockHash := consensusserialization.BlockHash(kosherizingBlock)
+		kosherizingBlock, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(blocksChain2[len(blocksChain2)-3]), consensushashing.BlockHash(selectedChain[len(selectedChain)-3])})
+		kosherizingBlockHash := consensushashing.BlockHash(kosherizingBlock)
 		if isViolatingMergeDepth {
 			t.Fatalf("TestBoundedMergeDepth: Expected blueKosherizingBlock to not violate merge depth")
 		}
@@ -308,7 +308,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 		// Make sure it's actually blue
 		found := false
-		for _, blue := range virtualGhotDagData.MergeSetBlues {
+		for _, blue := range virtualGhotDagData.MergeSetBlues() {
 			if *blue == *kosherizingBlockHash {
 				found = true
 				break
@@ -318,7 +318,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 			t.Fatalf("TestBoundedMergeDepth: Expected kosherizingBlock to be blue by the virtual")
 		}
 
-		pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])})
+		pointAtBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{kosherizingBlockHash, consensushashing.BlockHash(selectedChain[len(selectedChain)-1])})
 		if isViolatingMergeDepth {
 
 			t.Fatalf("TestBoundedMergeDepth: Expected selectedTip to not violate merge depth")
@@ -329,16 +329,16 @@ func TestBoundedMergeDepth(t *testing.T) {
 			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
 		}
 
-		if *consensusserialization.BlockHash(virtualSelectedParent) != *consensusserialization.BlockHash(pointAtBlueKosherizing) {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensusserialization.BlockHash(pointAtBlueKosherizing), consensusserialization.BlockHash(virtualSelectedParent))
+		if *consensushashing.BlockHash(virtualSelectedParent) != *consensushashing.BlockHash(pointAtBlueKosherizing) {
+			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(pointAtBlueKosherizing), consensushashing.BlockHash(virtualSelectedParent))
 		}
 
 		// Now let's make the kosherizing block red and try to merge again
-		tip := consensusserialization.BlockHash(selectedChain[len(selectedChain)-1])
+		tip := consensushashing.BlockHash(selectedChain[len(selectedChain)-1])
 		// we use k-1 because `kosherizingBlock` points at tip-2, so 2+k-1 = k+1 anticone.
 		for i := 0; i < int(params.K)-1; i++ {
 			block := buildAndInsertBlock(consensusReal, []*externalapi.DomainHash{tip})
-			tip = consensusserialization.BlockHash(block)
+			tip = consensushashing.BlockHash(block)
 		}
 
 		virtualSelectedParent, err = consensusReal.GetVirtualSelectedParent()
@@ -346,8 +346,8 @@ func TestBoundedMergeDepth(t *testing.T) {
 			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
 		}
 
-		if *consensusserialization.BlockHash(virtualSelectedParent) != *tip {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, consensusserialization.BlockHash(virtualSelectedParent))
+		if *consensushashing.BlockHash(virtualSelectedParent) != *tip {
+			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", tip, consensushashing.BlockHash(virtualSelectedParent))
 		}
 
 		virtualGhotDagData, err = consensusReal.GHOSTDAGDataStore().Get(consensusReal.DatabaseContext(), model.VirtualBlockHash)
@@ -356,7 +356,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 		// Make sure it's actually blue
 		found = false
-		for _, blue := range virtualGhotDagData.MergeSetBlues {
+		for _, blue := range virtualGhotDagData.MergeSetBlues() {
 			if *blue == *kosherizingBlockHash {
 				found = true
 				break
@@ -372,7 +372,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 		}
 
 		// Now `pointAtBlueKosherizing` itself is actually still blue, so we can still point at that even though we can't point at kosherizing directly anymore
-		transitiveBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensusserialization.BlockHash(pointAtBlueKosherizing), tip})
+		transitiveBlueKosherizing, isViolatingMergeDepth := checkViolatingMergeDepth(consensusReal, []*externalapi.DomainHash{consensushashing.BlockHash(pointAtBlueKosherizing), tip})
 		if isViolatingMergeDepth {
 			t.Fatalf("TestBoundedMergeDepth: Expected transitiveBlueKosherizing to not violate merge depth")
 		}
@@ -382,19 +382,19 @@ func TestBoundedMergeDepth(t *testing.T) {
 			t.Fatalf("TestBoundedMergeDepth: Failed getting the virtual selected parent %v", err)
 		}
 
-		if *consensusserialization.BlockHash(virtualSelectedParent) != *consensusserialization.BlockHash(transitiveBlueKosherizing) {
-			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensusserialization.BlockHash(transitiveBlueKosherizing), consensusserialization.BlockHash(virtualSelectedParent))
+		if *consensushashing.BlockHash(virtualSelectedParent) != *consensushashing.BlockHash(transitiveBlueKosherizing) {
+			t.Fatalf("TestBoundedMergeDepth: Expected %s to be the selectedTip but found %s instead", consensushashing.BlockHash(transitiveBlueKosherizing), consensushashing.BlockHash(virtualSelectedParent))
 		}
 
 		// Lets validate the status of all the interesting blocks
-		if getStatus(consensusReal, pointAtBlueKosherizing) != externalapi.StatusValid {
-			t.Fatalf("TestBoundedMergeDepth: pointAtBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusValid, getStatus(consensusReal, pointAtBlueKosherizing))
+		if getStatus(consensusReal, pointAtBlueKosherizing) != externalapi.StatusUTXOValid {
+			t.Fatalf("TestBoundedMergeDepth: pointAtBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, pointAtBlueKosherizing))
 		}
 		if getStatus(consensusReal, pointAtRedKosherizing) != externalapi.StatusInvalid {
 			t.Fatalf("TestBoundedMergeDepth: pointAtRedKosherizing expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, pointAtRedKosherizing))
 		}
-		if getStatus(consensusReal, transitiveBlueKosherizing) != externalapi.StatusValid {
-			t.Fatalf("TestBoundedMergeDepth: transitiveBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusValid, getStatus(consensusReal, transitiveBlueKosherizing))
+		if getStatus(consensusReal, transitiveBlueKosherizing) != externalapi.StatusUTXOValid {
+			t.Fatalf("TestBoundedMergeDepth: transitiveBlueKosherizing expected status '%s' but got '%s'", externalapi.StatusUTXOValid, getStatus(consensusReal, transitiveBlueKosherizing))
 		}
 		if getStatus(consensusReal, mergeDepthViolatingBlockBottom) != externalapi.StatusInvalid {
 			t.Fatalf("TestBoundedMergeDepth: mergeDepthViolatingBlockBottom expected status '%s' but got '%s'", externalapi.StatusInvalid, getStatus(consensusReal, mergeDepthViolatingBlockBottom))
@@ -412,8 +412,8 @@ func TestBoundedMergeDepth(t *testing.T) {
 			}
 		}
 		for i, b := range selectedChain {
-			if getStatus(consensusReal, b) != externalapi.StatusValid {
-				t.Fatalf("selectedChain[%d] expected status '%s' but got '%s'", i, externalapi.StatusValid, getStatus(consensusReal, b))
+			if getStatus(consensusReal, b) != externalapi.StatusUTXOValid {
+				t.Fatalf("selectedChain[%d] expected status '%s' but got '%s'", i, externalapi.StatusUTXOValid, getStatus(consensusReal, b))
 			}
 		}
 	})

domain/consensus/log.go

@@ -0,0 +1,7 @@
+package consensus
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.BDAG)

domain/consensus/model/externalapi/blockinfo.go

@@ -4,6 +4,5 @@ package externalapi
 type BlockInfo struct {
 	Exists      bool
 	BlockStatus BlockStatus
-
-	IsBlockInHeaderPruningPointFuture bool
+	BlueScore   uint64
 }

domain/consensus/model/externalapi/blockstatus.go

@@ -12,8 +12,8 @@ const (
 	// StatusInvalid indicates that the block is invalid.
 	StatusInvalid BlockStatus = iota
 
-	// StatusValid indicates that the block has been fully validated.
-	StatusValid
+	// StatusUTXOValid indicates the block is valid from any UTXO related aspects and has passed all the other validations as well.
+	StatusUTXOValid
 
 	// StatusUTXOPendingVerification indicates that the block is pending verification against its past UTXO-Set, either
 	// because it was not yet verified since the block was never in the selected parent chain, or if the
@@ -29,7 +29,7 @@ const (
 
 var blockStatusStrings = map[BlockStatus]string{
 	StatusInvalid:                 "Invalid",
-	StatusValid:                   "Valid",
+	StatusUTXOValid:               "Valid",
 	StatusUTXOPendingVerification: "UTXOPendingVerification",
 	StatusDisqualifiedFromChain:   "DisqualifiedFromChain",
 	StatusHeaderOnly:              "HeaderOnly",

domain/consensus/model/externalapi/consensus.go

@@ -3,7 +3,7 @@ package externalapi
 // Consensus maintains the current core state of the node
 type Consensus interface {
 	BuildBlock(coinbaseData *DomainCoinbaseData, transactions []*DomainTransaction) (*DomainBlock, error)
-	ValidateAndInsertBlock(block *DomainBlock) error
+	ValidateAndInsertBlock(block *DomainBlock) (*BlockInsertionResult, error)
 	ValidateTransactionAndPopulateWithConsensusData(transaction *DomainTransaction) error
 
 	GetBlock(blockHash *DomainHash) (*DomainBlock, error)
@@ -13,9 +13,11 @@ type Consensus interface {
 	GetHashesBetween(lowHash, highHash *DomainHash) ([]*DomainHash, error)
 	GetMissingBlockBodyHashes(highHash *DomainHash) ([]*DomainHash, error)
 	GetPruningPointUTXOSet(expectedPruningPointHash *DomainHash) ([]byte, error)
-	SetPruningPointUTXOSet(serializedUTXOSet []byte) error
+	ValidateAndInsertPruningPoint(newPruningPoint *DomainBlock, serializedUTXOSet []byte) error
 	GetVirtualSelectedParent() (*DomainBlock, error)
-	CreateBlockLocator(lowHash, highHash *DomainHash) (BlockLocator, error)
+	CreateBlockLocator(lowHash, highHash *DomainHash, limit uint32) (BlockLocator, error)
 	FindNextBlockLocatorBoundaries(blockLocator BlockLocator) (lowHash, highHash *DomainHash, err error)
 	GetSyncInfo() (*SyncInfo, error)
+	Tips() ([]*DomainHash, error)
+	GetVirtualInfo() (*VirtualInfo, error)
 }

domain/consensus/model/externalapi/insertblockresult.go

@@ -0,0 +1,12 @@
+package externalapi
+
+// BlockInsertionResult is auxiliary data returned from ValidateAndInsertBlock
+type BlockInsertionResult struct {
+	SelectedParentChainChanges *SelectedParentChainChanges
+}
+
+// SelectedParentChainChanges is the set of changes made to the selected parent chain
+type SelectedParentChainChanges struct {
+	Added   []*DomainHash
+	Removed []*DomainHash
+}

domain/consensus/model/externalapi/sync.go

@@ -1,40 +1,8 @@
 package externalapi
 
-import "fmt"
-
-// Each of the following represent one of the possible sync
-// states of the consensus
-const (
-	SyncStateRelay SyncState = iota
-	SyncStateMissingGenesis
-	SyncStateHeadersFirst
-	SyncStateMissingUTXOSet
-	SyncStateMissingBlockBodies
-)
-
-// SyncState represents the current sync state of the consensus
-type SyncState uint8
-
-func (s SyncState) String() string {
-	switch s {
-	case SyncStateRelay:
-		return "SyncStateRelay"
-	case SyncStateMissingGenesis:
-		return "SyncStateMissingGenesis"
-	case SyncStateHeadersFirst:
-		return "SyncStateHeadersFirst"
-	case SyncStateMissingUTXOSet:
-		return "SyncStateMissingUTXOSet"
-	case SyncStateMissingBlockBodies:
-		return "SyncStateMissingBlockBodies"
-	}
-
-	return fmt.Sprintf("<unknown state (%d)>", s)
-}
-
 // SyncInfo holds info about the current sync state of the consensus
 type SyncInfo struct {
-	State                SyncState
+	IsAwaitingUTXOSet    bool
 	IBDRootUTXOBlockHash *DomainHash
 	HeaderCount          uint64
 	BlockCount           uint64

domain/consensus/model/externalapi/transaction.go

@@ -19,7 +19,7 @@ type DomainTransaction struct {
 	Mass uint64
 
 	// ID is a field that is used to cache the transaction ID.
-	// Always use consensusserialization.TransactionID instead of accessing this field directly
+	// Always use consensushashing.TransactionID instead of accessing this field directly
 	ID *DomainTransactionID
 }
 
@@ -62,7 +62,7 @@ type DomainTransactionInput struct {
 	SignatureScript  []byte
 	Sequence         uint64
 
-	UTXOEntry *UTXOEntry
+	UTXOEntry UTXOEntry
 }
 
 // Clone returns a clone of DomainTransactionInput
@@ -78,7 +78,7 @@ func (input *DomainTransactionInput) Clone() *DomainTransactionInput {
 		PreviousOutpoint: *input.PreviousOutpoint.Clone(),
 		SignatureScript:  signatureScriptClone,
 		Sequence:         input.Sequence,
-		UTXOEntry:        input.UTXOEntry.Clone(),
+		UTXOEntry:        input.UTXOEntry,
 	}
 }
 

domain/consensus/model/externalapi/utxoentry.go

@@ -4,36 +4,9 @@ package externalapi
 // set such as whether or not it was contained in a coinbase tx, the blue
 // score of the block that accepts the tx, its public key script, and how
 // much it pays.
-type UTXOEntry struct {
-	Amount          uint64
-	ScriptPublicKey []byte // The public key script for the output.
-	BlockBlueScore  uint64 // Blue score of the block accepting the tx.
-	IsCoinbase      bool
-}
-
-// Clone returns a clone of UTXOEntry
-func (entry *UTXOEntry) Clone() *UTXOEntry {
-	if entry == nil {
-		return nil
-	}
-
-	scriptPublicKeyClone := make([]byte, len(entry.ScriptPublicKey))
-	copy(scriptPublicKeyClone, entry.ScriptPublicKey)
-
-	return &UTXOEntry{
-		Amount:          entry.Amount,
-		ScriptPublicKey: scriptPublicKeyClone,
-		BlockBlueScore:  entry.BlockBlueScore,
-		IsCoinbase:      entry.IsCoinbase,
-	}
-}
-
-// NewUTXOEntry creates a new utxoEntry representing the given txOut
-func NewUTXOEntry(amount uint64, scriptPubKey []byte, isCoinbase bool, blockBlueScore uint64) *UTXOEntry {
-	return &UTXOEntry{
-		Amount:          amount,
-		ScriptPublicKey: scriptPubKey,
-		BlockBlueScore:  blockBlueScore,
-		IsCoinbase:      isCoinbase,
-	}
+type UTXOEntry interface {
+	Amount() uint64
+	ScriptPublicKey() []byte // The public key script for the output.
+	BlockBlueScore() uint64  // Blue score of the block accepting the tx.
+	IsCoinbase() bool
 }

domain/consensus/model/externalapi/virtual.go

@@ -0,0 +1,8 @@
+package externalapi
+
+// VirtualInfo represents information about the virtual block needed by external components
+type VirtualInfo struct {
+	ParentHashes   []*DomainHash
+	Bits           uint32
+	PastMedianTime int64
+}

domain/consensus/model/ghostdag.go

@@ -1,34 +1,19 @@
 package model
 
-import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+import (
+	"math/big"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
 
 // BlockGHOSTDAGData represents GHOSTDAG data for some block
-type BlockGHOSTDAGData struct {
-	BlueScore          uint64
-	SelectedParent     *externalapi.DomainHash
-	MergeSetBlues      []*externalapi.DomainHash
-	MergeSetReds       []*externalapi.DomainHash
-	BluesAnticoneSizes map[externalapi.DomainHash]KType
-}
-
-// Clone returns a clone of BlockGHOSTDAGData
-func (bgd *BlockGHOSTDAGData) Clone() *BlockGHOSTDAGData {
-	if bgd == nil {
-		return nil
-	}
-
-	bluesAnticoneSizesClone := make(map[externalapi.DomainHash]KType, len(bgd.BluesAnticoneSizes))
-	for hash, size := range bgd.BluesAnticoneSizes {
-		bluesAnticoneSizesClone[hash] = size
-	}
-
-	return &BlockGHOSTDAGData{
-		BlueScore:          bgd.BlueScore,
-		SelectedParent:     bgd.SelectedParent.Clone(),
-		MergeSetBlues:      externalapi.CloneHashes(bgd.MergeSetBlues),
-		MergeSetReds:       externalapi.CloneHashes(bgd.MergeSetReds),
-		BluesAnticoneSizes: bluesAnticoneSizesClone,
-	}
+type BlockGHOSTDAGData interface {
+	BlueScore() uint64
+	BlueWork() *big.Int
+	SelectedParent() *externalapi.DomainHash
+	MergeSetBlues() []*externalapi.DomainHash
+	MergeSetReds() []*externalapi.DomainHash
+	BluesAnticoneSizes() map[externalapi.DomainHash]KType
 }
 
 // KType defines the size of GHOSTDAG consensus algorithm K parameter.

domain/consensus/model/interface_datastructures_consensusstatestore.go

@@ -7,9 +7,9 @@ type ConsensusStateStore interface {
 	Store
 	IsStaged() bool
 
-	StageVirtualUTXODiff(virtualUTXODiff *UTXODiff) error
+	StageVirtualUTXODiff(virtualUTXODiff UTXODiff) error
 	StageVirtualUTXOSet(virtualUTXOSetIterator ReadOnlyUTXOSetIterator) error
-	UTXOByOutpoint(dbContext DBReader, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error)
+	UTXOByOutpoint(dbContext DBReader, outpoint *externalapi.DomainOutpoint) (externalapi.UTXOEntry, error)
 	HasUTXOByOutpoint(dbContext DBReader, outpoint *externalapi.DomainOutpoint) (bool, error)
 	VirtualUTXOSetIterator(dbContext DBReader) (ReadOnlyUTXOSetIterator, error)
 

domain/consensus/model/interface_datastructures_finalitystore.go

@@ -0,0 +1,13 @@
+package model
+
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
+
+// FinalityStore represents a store for finality data
+type FinalityStore interface {
+	Store
+	IsStaged() bool
+	StageFinalityPoint(blockHash *externalapi.DomainHash, finalityPointHash *externalapi.DomainHash)
+	FinalityPoint(dbContext DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
+}

domain/consensus/model/interface_datastructures_ghostdagdatastore.go

@@ -5,7 +5,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 // GHOSTDAGDataStore represents a store of BlockGHOSTDAGData
 type GHOSTDAGDataStore interface {
 	Store
-	Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData *BlockGHOSTDAGData)
+	Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData BlockGHOSTDAGData)
 	IsStaged() bool
-	Get(dbContext DBReader, blockHash *externalapi.DomainHash) (*BlockGHOSTDAGData, error)
+	Get(dbContext DBReader, blockHash *externalapi.DomainHash) (BlockGHOSTDAGData, error)
 }

domain/consensus/model/interface_datastructures_headertipsstore.go

@@ -2,11 +2,11 @@ package model
 
 import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
-// HeaderTipsStore represents a store of the header tips
-type HeaderTipsStore interface {
+// HeaderSelectedTipStore represents a store of the headers selected tip
+type HeaderSelectedTipStore interface {
 	Store
-	Stage(tips []*externalapi.DomainHash)
+	Stage(selectedTip *externalapi.DomainHash)
 	IsStaged() bool
-	Tips(dbContext DBReader) ([]*externalapi.DomainHash, error)
-	HasTips(dbContext DBReader) (bool, error)
+	HeadersSelectedTip(dbContext DBReader) (*externalapi.DomainHash, error)
+	Has(dbContext DBReader) (bool, error)
 }

domain/consensus/model/interface_datastructures_utxodiffstore.go

@@ -5,9 +5,9 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 // UTXODiffStore represents a store of UTXODiffs
 type UTXODiffStore interface {
 	Store
-	Stage(blockHash *externalapi.DomainHash, utxoDiff *UTXODiff, utxoDiffChild *externalapi.DomainHash)
+	Stage(blockHash *externalapi.DomainHash, utxoDiff UTXODiff, utxoDiffChild *externalapi.DomainHash)
 	IsStaged() bool
-	UTXODiff(dbContext DBReader, blockHash *externalapi.DomainHash) (*UTXODiff, error)
+	UTXODiff(dbContext DBReader, blockHash *externalapi.DomainHash) (UTXODiff, error)
 	UTXODiffChild(dbContext DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
 	HasUTXODiffChild(dbContext DBReader, blockHash *externalapi.DomainHash) (bool, error)
 	Delete(blockHash *externalapi.DomainHash)

domain/consensus/model/interface_processes_blockbuilder.go

@@ -6,13 +6,3 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 type BlockBuilder interface {
 	BuildBlock(coinbaseData *externalapi.DomainCoinbaseData, transactions []*externalapi.DomainTransaction) (*externalapi.DomainBlock, error)
 }
-
-// TestBlockBuilder adds to the main BlockBuilder methods required by tests
-type TestBlockBuilder interface {
-	BlockBuilder
-
-	// BuildBlockWithParents builds a block with provided parents, coinbaseData and transactions,
-	// and returns the block together with its past UTXO-diff from the virtual.
-	BuildBlockWithParents(parentHashes []*externalapi.DomainHash, coinbaseData *externalapi.DomainCoinbaseData,
-		transactions []*externalapi.DomainTransaction) (*externalapi.DomainBlock, *UTXODiff, error)
-}

domain/consensus/model/interface_processes_blockprocessor.go

@@ -4,5 +4,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 // BlockProcessor is responsible for processing incoming blocks
 type BlockProcessor interface {
-	ValidateAndInsertBlock(block *externalapi.DomainBlock) error
+	ValidateAndInsertBlock(block *externalapi.DomainBlock) (*externalapi.BlockInsertionResult, error)
+	ValidateAndInsertPruningPoint(newPruningPoint *externalapi.DomainBlock, serializedUTXOSet []byte) error
 }

domain/consensus/model/interface_processes_blockvalidator.go

@@ -1,6 +1,8 @@
 package model
 
-import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+import (
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+)
 
 // BlockValidator exposes a set of validation classes, after which
 // it's possible to determine whether a block is valid
@@ -8,6 +10,6 @@ type BlockValidator interface {
 	ValidateHeaderInIsolation(blockHash *externalapi.DomainHash) error
 	ValidateBodyInIsolation(blockHash *externalapi.DomainHash) error
 	ValidateHeaderInContext(blockHash *externalapi.DomainHash) error
-	ValidateBodyInContext(blockHash *externalapi.DomainHash) error
-	ValidateProofOfWorkAndDifficulty(blockHash *externalapi.DomainHash) error
+	ValidateBodyInContext(blockHash *externalapi.DomainHash, isPruningPoint bool) error
+	ValidatePruningPointViolationAndProofOfWorkAndDifficulty(blockHash *externalapi.DomainHash) error
 }

domain/consensus/model/interface_processes_coinbasemanager.go

@@ -7,4 +7,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 type CoinbaseManager interface {
 	ExpectedCoinbaseTransaction(blockHash *externalapi.DomainHash,
 		coinbaseData *externalapi.DomainCoinbaseData) (*externalapi.DomainTransaction, error)
+	ExtractCoinbaseDataAndBlueScore(coinbaseTx *externalapi.DomainTransaction) (blueScore uint64,
+		coinbaseData *externalapi.DomainCoinbaseData, err error)
 }

domain/consensus/model/interface_processes_consensusstatemanager.go

@@ -4,19 +4,9 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 // ConsensusStateManager manages the node's consensus state
 type ConsensusStateManager interface {
-	AddBlockToVirtual(blockHash *externalapi.DomainHash) error
+	AddBlock(blockHash *externalapi.DomainHash) (*externalapi.SelectedParentChainChanges, error)
 	PopulateTransactionWithUTXOEntries(transaction *externalapi.DomainTransaction) error
-	SetPruningPointUTXOSet(serializedUTXOSet []byte) error
+	UpdatePruningPoint(newPruningPoint *externalapi.DomainBlock, serializedUTXOSet []byte) error
 	RestorePastUTXOSetIterator(blockHash *externalapi.DomainHash) (ReadOnlyUTXOSetIterator, error)
-	HeaderTipsPruningPoint() (*externalapi.DomainHash, error)
-	CalculatePastUTXOAndAcceptanceData(blockHash *externalapi.DomainHash) (*UTXODiff, AcceptanceData, Multiset, error)
-}
-
-// TestConsensusStateManager  adds to the main ConsensusStateManager methods required by tests
-type TestConsensusStateManager interface {
-	ConsensusStateManager
-	AddUTXOToMultiset(multiset Multiset, entry *externalapi.UTXOEntry,
-		outpoint *externalapi.DomainOutpoint) error
-	ResolveBlockStatus(blockHash *externalapi.DomainHash) (externalapi.BlockStatus, error)
-	VirtualFinalityPoint() (*externalapi.DomainHash, error)
+	CalculatePastUTXOAndAcceptanceData(blockHash *externalapi.DomainHash) (UTXODiff, AcceptanceData, Multiset, error)
 }

domain/consensus/model/interface_processes_dagtopologymanager.go

@@ -13,6 +13,7 @@ type DAGTopologyManager interface {
 	IsDescendantOf(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error)
 	IsAncestorOfAny(blockHash *externalapi.DomainHash, potentialDescendants []*externalapi.DomainHash) (bool, error)
 	IsInSelectedParentChainOf(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error)
+	ChildInSelectedParentChainOf(context, highHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
 
 	SetParents(blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash) error
 }

domain/consensus/model/interface_processes_dagtraversalmanager.go

@@ -10,7 +10,7 @@ type DAGTraversalManager interface {
 	SelectedParentIterator(highHash *externalapi.DomainHash) BlockIterator
 	SelectedChildIterator(highHash, lowHash *externalapi.DomainHash) (BlockIterator, error)
 	AnticoneFromContext(context, lowHash *externalapi.DomainHash) ([]*externalapi.DomainHash, error)
-	BlueWindow(highHash *externalapi.DomainHash, windowSize uint64) ([]*externalapi.DomainHash, error)
+	BlueWindow(highHash *externalapi.DomainHash, windowSize int) ([]*externalapi.DomainHash, error)
 	NewDownHeap() BlockHeap
 	NewUpHeap() BlockHeap
 }

domain/consensus/model/interface_processes_finalitymanager.go

@@ -0,0 +1,9 @@
+package model
+
+import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
+// FinalityManager provides method to validate that a block does not violate finality
+type FinalityManager interface {
+	VirtualFinalityPoint() (*externalapi.DomainHash, error)
+	FinalityPoint(blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
+}

domain/consensus/model/interface_processes_ghostdagmanager.go

@@ -6,6 +6,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 type GHOSTDAGManager interface {
 	GHOSTDAG(blockHash *externalapi.DomainHash) error
 	ChooseSelectedParent(blockHashes ...*externalapi.DomainHash) (*externalapi.DomainHash, error)
-	Less(blockHashA *externalapi.DomainHash, ghostdagDataA *BlockGHOSTDAGData,
-		blockHashB *externalapi.DomainHash, ghostdagDataB *BlockGHOSTDAGData) bool
+	Less(blockHashA *externalapi.DomainHash, ghostdagDataA BlockGHOSTDAGData,
+		blockHashB *externalapi.DomainHash, ghostdagDataB BlockGHOSTDAGData) bool
 }

domain/consensus/model/interface_processes_headertipsmanager.go

@@ -2,8 +2,7 @@ package model
 
 import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
-// HeaderTipsManager manages the state of the header tips
-type HeaderTipsManager interface {
+// HeadersSelectedTipManager manages the state of the headers selected tip
+type HeadersSelectedTipManager interface {
 	AddHeaderTip(hash *externalapi.DomainHash) error
-	SelectedTip() (*externalapi.DomainHash, error)
 }

domain/consensus/model/interface_processes_pruningmanager.go

@@ -4,6 +4,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 
 // PruningManager resolves and manages the current pruning point
 type PruningManager interface {
-	FindNextPruningPoint() error
-	PruningPoint() (*externalapi.DomainHash, error)
+	UpdatePruningPointByVirtual() error
+	CalculatePruningPointByHeaderSelectedTip() (*externalapi.DomainHash, error)
 }