wire: add p2p mixing messages

These messages implement the stages of a cspp mix.  Messages will be
broadcast to all full nodes and all peers participating in mixing
through inventory messages.

wire/common.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/decred/dcrd/chaincfg/chainhash"
+	"github.com/decred/dcrd/crypto/blake256"
 )
 
 const (
@@ -322,6 +323,30 @@ func readElement(r io.Reader, element interface{}) error {
 		}
 		return nil
 
+	// Mix signature
+	case *[64]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// sntrup4591651 ciphertext
+	case *[1047]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// sntrup4591651 public key
+	case *[1218]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case *ServiceFlag:
 		rv, err := binarySerializer.Uint64(r, littleEndian)
 		if err != nil {
@@ -377,6 +402,20 @@ func writeElement(w io.Writer, element interface{}) error {
 	// Attempt to write the element based on the concrete type via fast
 	// type assertions first.
 	switch e := element.(type) {
+	case uint8:
+		err := binarySerializer.PutUint8(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint16:
+		err := binarySerializer.PutUint16(w, littleEndian, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case int32:
 		err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
@@ -441,13 +480,44 @@ func writeElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
+	case *[32]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case *chainhash.Hash:
 		_, err := w.Write(e[:])
 		if err != nil {
 			return err
 		}
 		return nil
 
+	// Mix signature
+	case *[64]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// sntrup4591761 ciphertext
+	case *[1047]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// sntrup4591761 public key
+	case *[1218]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case ServiceFlag:
 		err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
 		if err != nil {
@@ -765,3 +835,16 @@ func isStrictAscii(s string) bool {
 
 	return true
 }
+
+// mustHash returns the hash of the serialized message.  If message
+// serialization errors, it panics with a wrapped error.
+func mustHash(msg Message, pver uint32) chainhash.Hash {
+	h := blake256.New()
+	err := msg.BtcEncode(h, pver)
+	if err != nil {
+		err := fmt.Errorf("hash of %T failed due to serialization "+
+			"error: %w", msg, err)
+		panic(err)
+	}
+	return *(*chainhash.Hash)(h.Sum(nil))
+}

wire/error.go

@@ -133,6 +133,18 @@ const (
 	// ErrTooManyTSpends is returned when the number of tspend hashes
 	// exceeds the maximum allowed.
 	ErrTooManyTSpends
+
+	// ErrMixPRScriptClassTooLong is returned when a mixing script class
+	// type string is longer than allowed by the protocol.
+	ErrMixPRScriptClassTooLong
+
+	// ErrTooManyMixPRUTXOs is returned when a MixPR message contains
+	// more UTXOs than allowed by the protocol.
+	ErrTooManyMixPRUTXOs
+
+	// ErrTooManyPrevMixMsgs is returned when too many previous messages of
+	// a mix run are referenced by a message.
+	ErrTooManyPrevMixMsgs
 )
 
 // Map of ErrorCode values back to their constant names for pretty printing.
@@ -168,6 +180,9 @@ var errorCodeStrings = map[ErrorCode]string{
 	ErrTooManyInitStateTypes:         "ErrTooManyInitStateTypes",
 	ErrInitStateTypeTooLong:          "ErrInitStateTypeTooLong",
 	ErrTooManyTSpends:                "ErrTooManyTSpends",
+	ErrMixPRScriptClassTooLong:       "ErrMixPRScriptClassTooLong",
+	ErrTooManyMixPRUTXOs:             "ErrTooManyMixPRUTXOs",
+	ErrTooManyPrevMixMsgs:            "ErrTooManyPrevMixMsgs",
 }
 
 // String returns the ErrorCode as a human-readable name.

wire/go.mod

@@ -7,4 +7,4 @@ require (
 	github.com/decred/dcrd/chaincfg/chainhash v1.0.2
 )
 
-require github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
+require github.com/decred/dcrd/crypto/blake256 v1.0.0

wire/message.go

@@ -58,6 +58,12 @@ const (
 	CmdCFilterV2      = "cfilterv2"
 	CmdGetInitState   = "getinitstate"
 	CmdInitState      = "initstate"
+	CmdMixPR          = "mixpr"
+	CmdMixKE          = "mixke"
+	CmdMixCT          = "mixct"
+	CmdMixSR          = "mixsr"
+	CmdMixDC          = "mixdc"
+	CmdMixCM          = "mixcm"
 )
 
 // Message is an interface that describes a Decred message.  A type that
@@ -168,6 +174,24 @@ func makeEmptyMessage(command string) (Message, error) {
 	case CmdInitState:
 		msg = &MsgInitState{}
 
+	case CmdMixPR:
+		msg = &MsgMixPR{}
+
+	case CmdMixKE:
+		msg = &MsgMixKE{}
+
+	case CmdMixCT:
+		msg = &MsgMixCT{}
+
+	case CmdMixSR:
+		msg = &MsgMixSR{}
+
+	case CmdMixDC:
+		msg = &MsgMixDC{}
+
+	case CmdMixCM:
+		msg = &MsgMixCM{}
+
 	default:
 		str := fmt.Sprintf("unhandled command [%s]", command)
 		return nil, messageError(op, ErrUnknownCmd, str)