Replace custom serialization and asn.1 with Canoto

api.go

@@ -46,8 +46,8 @@ type BlockBuilder interface {
 
 type Storage interface {
 	Height() uint64
-	Retrieve(seq uint64) (Block, FinalizationCertificate, bool)
-	Index(block Block, certificate FinalizationCertificate)
+	Retrieve(seq uint64) (Block, Quorum, bool)
+	Index(block Block, certificate Quorum)
 }
 
 type Communication interface {
@@ -95,12 +95,15 @@ type BlockDeserializer interface {
 	DeserializeBlock(bytes []byte) (Block, error)
 }
 
-// Signature encodes a signature and the node that signed it, without the message it was signed on.
-type Signature struct {
-	// Signer is the NodeID of the creator of the signature.
-	Signer NodeID
-	// Value is the byte representation of the signature.
-	Value []byte
+// QuorumCertificate is equivalent to a collection of signatures from a quorum of nodes,
+type QuorumCertificate interface {
+	// Signers returns who participated in creating this QuorumCertificate.
+	Signers() []NodeID
+	// Verify checks whether the nodes participated in creating this QuorumCertificate,
+	// signed the given message.
+	Verify(msg []byte) error
+	// Bytes returns a raw representation of the given QuorumCertificate.
+	Bytes() []byte
 }
 
 // QCDeserializer deserializes QuorumCertificates according to formatting

encoding_test.go

@@ -6,120 +6,70 @@ package simplex
 import (
 	"crypto/rand"
 	"crypto/sha256"
-	"simplex/record"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-func TestBlockRecord(t *testing.T) {
-	bh := BlockHeader{
-		ProtocolMetadata: ProtocolMetadata{
-			Version: 1,
-			Round:   2,
-			Seq:     3,
-			Epoch:   4,
-		},
-	}
-
-	_, err := rand.Read(bh.Prev[:])
-	require.NoError(t, err)
-
-	_, err = rand.Read(bh.Digest[:])
-	require.NoError(t, err)
-
-	payload := []byte{11, 12, 13, 14, 15, 16}
-
-	record := blockRecord(bh, payload)
-
-	md2, payload2, err := blockFromRecord(record)
-	require.NoError(t, err)
-
-	require.Equal(t, bh, md2)
-	require.Equal(t, payload, payload2)
-}
-
-func FuzzBlockRecord(f *testing.F) {
-	f.Fuzz(func(t *testing.T, version uint8, round, seq, epoch uint64, prevPreimage, digestPreimage []byte, payload []byte) {
-		prev := sha256.Sum256(prevPreimage)
-		digest := sha256.Sum256(digestPreimage)
-		bh := BlockHeader{
-			ProtocolMetadata: ProtocolMetadata{
-				Version: version,
-				Round:   round,
-				Seq:     seq,
-				Epoch:   epoch,
-				Prev:    prev,
-			},
-			Digest: digest,
-		}
-
-		record := blockRecord(bh, payload)
-
-		md2, payload2, err := blockFromRecord(record)
-		require.NoError(t, err)
-
-		require.Equal(t, bh, md2)
-		require.Equal(t, payload, payload2)
-	})
-}
-
 func TestNotarizationRecord(t *testing.T) {
 	sig := make([]byte, 64)
 	_, err := rand.Read(sig)
 	require.NoError(t, err)
 
-	vote := ToBeSignedVote{
-		BlockHeader{
-			ProtocolMetadata: ProtocolMetadata{
-				Version: 1,
-				Round:   2,
-				Seq:     3,
-				Epoch:   4,
-			},
+	vote := BlockHeader{
+		ProtocolMetadata: ProtocolMetadata{
+			Round: 2,
+			Seq:   3,
+			Epoch: 4,
 		},
 	}
 
 	_, err = rand.Read(vote.Prev[:])
 	require.NoError(t, err)
 
-	_, err = rand.Read(vote.Prev[:])
+	_, err = rand.Read(vote.Digest[:])
 	require.NoError(t, err)
 
-	record := quorumRecord([]byte{1, 2, 3}, vote.Bytes(), record.NotarizationRecordType)
-	qc, vote2, err := NotarizationFromRecord(record)
-	require.NoError(t, err)
-	require.Equal(t, []byte{1, 2, 3}, qc)
-	require.Equal(t, vote, vote2)
+	record := Record{
+		Notarization: &Quorum{
+			Header: vote,
+			QC:     []byte{1, 2, 3},
+		},
+	}
+	recordBytes := record.MarshalCanoto()
+
+	var parsedRecord Record
+	require.NoError(t, parsedRecord.UnmarshalCanoto(recordBytes))
+	require.True(t, vote.Equals(&parsedRecord.Notarization.Header))
+	require.Equal(t, []byte{1, 2, 3}, parsedRecord.Notarization.QC)
 }
 
 func FuzzNotarizationRecord(f *testing.F) {
-	f.Fuzz(func(t *testing.T, version uint8, round uint64, seq uint64, epoch uint64, prevPreimage, digestPreimage []byte, sig []byte, signer1, signer2 []byte) {
+	f.Fuzz(func(t *testing.T, round uint64, seq uint64, epoch uint64, prevPreimage, digestPreimage []byte, sig []byte, signer1, signer2 []byte) {
 		prev := sha256.Sum256(prevPreimage)
 		digest := sha256.Sum256(digestPreimage)
 
-		vote := ToBeSignedVote{
-			BlockHeader{
-				ProtocolMetadata: ProtocolMetadata{
-					Version: version,
-					Round:   round,
-					Seq:     seq,
-					Epoch:   epoch,
-					Prev:    prev,
-				},
-				Digest: digest,
+		vote := BlockHeader{
+			ProtocolMetadata: ProtocolMetadata{
+				Round: round,
+				Seq:   seq,
+				Epoch: epoch,
+				Prev:  prev,
 			},
+			Digest: digest,
 		}
 
-		var signers []NodeID
-		for _, signer := range [][]byte{signer1, signer2} {
-			signers = append(signers, signer)
+		record := Record{
+			Notarization: &Quorum{
+				Header: vote,
+				QC:     []byte{1, 2, 3},
+			},
 		}
+		recordBytes := record.MarshalCanoto()
 
-		record := quorumRecord([]byte{1, 2, 3}, vote.Bytes(), record.NotarizationRecordType)
-		qc, vote2, err := NotarizationFromRecord(record)
-		require.NoError(t, err)
-		require.Equal(t, []byte{1, 2, 3}, qc)
-		require.Equal(t, vote, vote2)
+		var parsedRecord Record
+		require.NoError(t, parsedRecord.UnmarshalCanoto(recordBytes))
+		require.True(t, vote.Equals(&parsedRecord.Notarization.Header))
+		require.Equal(t, []byte{1, 2, 3}, parsedRecord.Notarization.QC)
 	})
 }