x/sync -- Use proto for sending Change Proofs

x/merkledb/codec.go

@@ -41,52 +41,44 @@ const (
 )
 
 var (
-	_ EncoderDecoder = (*codecImpl)(nil)
+	_ encoderDecoder = (*codecImpl)(nil)
 
 	trueBytes  = []byte{trueByte}
 	falseBytes = []byte{falseByte}
 
-	errUnknownVersion         = errors.New("unknown codec version")
-	errEncodeNil              = errors.New("can't encode nil pointer or interface")
-	errDecodeNil              = errors.New("can't decode nil")
-	errNegativeProofPathNodes = errors.New("negative proof path length")
-	errNegativeNumChildren    = errors.New("number of children is negative")
-	errTooManyChildren        = fmt.Errorf("length of children list is larger than branching factor of %d", NodeBranchFactor)
-	errChildIndexTooLarge     = fmt.Errorf("invalid child index. Must be less than branching factor of %d", NodeBranchFactor)
-	errNegativeNibbleLength   = errors.New("nibble length is negative")
-	errNegativeNumKeyValues   = errors.New("negative number of key values")
-	errIntTooLarge            = errors.New("integer too large to be decoded")
-	errLeadingZeroes          = errors.New("varint has leading zeroes")
-	errInvalidBool            = errors.New("decoded bool is neither true nor false")
-	errNonZeroNibblePadding   = errors.New("nibbles should be padded with 0s")
-	errExtraSpace             = errors.New("trailing buffer space")
-	errNegativeSliceLength    = errors.New("negative slice length")
-	errInvalidCodecVersion    = errors.New("invalid codec version")
+	errUnknownVersion       = errors.New("unknown codec version")
+	errEncodeNil            = errors.New("can't encode nil pointer or interface")
+	errDecodeNil            = errors.New("can't decode nil")
+	errNegativeNumChildren  = errors.New("number of children is negative")
+	errTooManyChildren      = fmt.Errorf("length of children list is larger than branching factor of %d", NodeBranchFactor)
+	errChildIndexTooLarge   = fmt.Errorf("invalid child index. Must be less than branching factor of %d", NodeBranchFactor)
+	errNegativeNibbleLength = errors.New("nibble length is negative")
+	errIntTooLarge          = errors.New("integer too large to be decoded")
+	errLeadingZeroes        = errors.New("varint has leading zeroes")
+	errInvalidBool          = errors.New("decoded bool is neither true nor false")
+	errNonZeroNibblePadding = errors.New("nibbles should be padded with 0s")
+	errExtraSpace           = errors.New("trailing buffer space")
+	errNegativeSliceLength  = errors.New("negative slice length")
+	errInvalidCodecVersion  = errors.New("invalid codec version")
 )
 
-// EncoderDecoder defines the interface needed by merkleDB to marshal
+// encoderDecoder defines the interface needed by merkleDB to marshal
 // and unmarshal relevant types.
-type EncoderDecoder interface {
-	Encoder
-	Decoder
+type encoderDecoder interface {
+	encoder
+	decoder
 }
 
-type Encoder interface {
-	EncodeProof(version uint16, p *Proof) ([]byte, error)
-	EncodeChangeProof(version uint16, p *ChangeProof) ([]byte, error)
-
+type encoder interface {
 	encodeDBNode(version uint16, n *dbNode) ([]byte, error)
 	encodeHashValues(version uint16, hv *hashValues) ([]byte, error)
 }
 
-type Decoder interface {
-	DecodeProof(bytes []byte, p *Proof) (uint16, error)
-	DecodeChangeProof(bytes []byte, p *ChangeProof) (uint16, error)
-
+type decoder interface {
 	decodeDBNode(bytes []byte, n *dbNode) (uint16, error)
 }
 
-func newCodec() (EncoderDecoder, uint16) {
+func newCodec() (encoderDecoder, uint16) {
 	return &codecImpl{
 		varIntPool: sync.Pool{
 			New: func() interface{} {
@@ -100,65 +92,6 @@ type codecImpl struct {
 	varIntPool sync.Pool
 }
 
-func (c *codecImpl) EncodeProof(version uint16, proof *Proof) ([]byte, error) {
-	if proof == nil {
-		return nil, errEncodeNil
-	}
-
-	if version != codecVersion {
-		return nil, fmt.Errorf("%w: %d", errUnknownVersion, version)
-	}
-
-	buf := &bytes.Buffer{}
-	if err := c.encodeInt(buf, int(version)); err != nil {
-		return nil, err
-	}
-	if err := c.encodeProofPath(buf, proof.Path); err != nil {
-		return nil, err
-	}
-	if err := c.encodeByteSlice(buf, proof.Key); err != nil {
-		return nil, err
-	}
-	if err := c.encodeMaybeByteSlice(buf, proof.Value); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-func (c *codecImpl) EncodeChangeProof(version uint16, proof *ChangeProof) ([]byte, error) {
-	if proof == nil {
-		return nil, errEncodeNil
-	}
-
-	if version != codecVersion {
-		return nil, fmt.Errorf("%w: %d", errUnknownVersion, version)
-	}
-
-	buf := &bytes.Buffer{}
-
-	if err := c.encodeInt(buf, int(version)); err != nil {
-		return nil, err
-	}
-	if err := c.encodeBool(buf, proof.HadRootsInHistory); err != nil {
-		return nil, err
-	}
-	if err := c.encodeProofPath(buf, proof.StartProof); err != nil {
-		return nil, err
-	}
-	if err := c.encodeProofPath(buf, proof.EndProof); err != nil {
-		return nil, err
-	}
-	if err := c.encodeInt(buf, len(proof.KeyChanges)); err != nil {
-		return nil, err
-	}
-	for _, kv := range proof.KeyChanges {
-		if err := c.encodeKeyChange(kv, buf); err != nil {
-			return nil, err
-		}
-	}
-	return buf.Bytes(), nil
-}
-
 func (c *codecImpl) encodeDBNode(version uint16, n *dbNode) ([]byte, error) {
 	if n == nil {
 		return nil, errEncodeNil
@@ -237,92 +170,6 @@ func (c *codecImpl) encodeHashValues(version uint16, hv *hashValues) ([]byte, er
 	return buf.Bytes(), nil
 }
 
-func (c *codecImpl) DecodeProof(b []byte, proof *Proof) (uint16, error) {
-	if proof == nil {
-		return 0, errDecodeNil
-	}
-	if minProofLen > len(b) {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	var (
-		err error
-		src = bytes.NewReader(b)
-	)
-	gotCodecVersion, err := c.decodeInt(src)
-	if err != nil {
-		return 0, err
-	}
-	if codecVersion != gotCodecVersion {
-		return 0, fmt.Errorf("%w: %d", errInvalidCodecVersion, gotCodecVersion)
-	}
-	if proof.Path, err = c.decodeProofPath(src); err != nil {
-		return 0, err
-	}
-	if proof.Key, err = c.decodeByteSlice(src); err != nil {
-		return 0, err
-	}
-	if proof.Value, err = c.decodeMaybeByteSlice(src); err != nil {
-		return 0, err
-	}
-	if src.Len() != 0 {
-		return 0, errExtraSpace
-	}
-	return codecVersion, nil
-}
-
-func (c *codecImpl) DecodeChangeProof(b []byte, proof *ChangeProof) (uint16, error) {
-	if proof == nil {
-		return 0, errDecodeNil
-	}
-	if minChangeProofLen > len(b) {
-		return 0, io.ErrUnexpectedEOF
-	}
-
-	var (
-		src = bytes.NewReader(b)
-		err error
-	)
-
-	gotCodecVersion, err := c.decodeInt(src)
-	if err != nil {
-		return 0, err
-	}
-	if gotCodecVersion != codecVersion {
-		return 0, fmt.Errorf("%w: %d", errInvalidCodecVersion, gotCodecVersion)
-	}
-	if proof.HadRootsInHistory, err = c.decodeBool(src); err != nil {
-		return 0, err
-	}
-	if proof.StartProof, err = c.decodeProofPath(src); err != nil {
-		return 0, err
-	}
-	if proof.EndProof, err = c.decodeProofPath(src); err != nil {
-		return 0, err
-	}
-
-	numKeyChanges, err := c.decodeInt(src)
-	if err != nil {
-		return 0, err
-	}
-	if numKeyChanges < 0 {
-		return 0, errNegativeNumKeyValues
-	}
-	if numKeyChanges > src.Len()/minKeyChangeLen {
-		return 0, io.ErrUnexpectedEOF
-	}
-	proof.KeyChanges = make([]KeyChange, numKeyChanges)
-	for i := range proof.KeyChanges {
-		if proof.KeyChanges[i], err = c.decodeKeyChange(src); err != nil {
-			return 0, err
-		}
-	}
-	if src.Len() != 0 {
-		return 0, errExtraSpace
-	}
-	return codecVersion, nil
-}
-
 func (c *codecImpl) decodeDBNode(b []byte, n *dbNode) (uint16, error) {
 	if n == nil {
 		return 0, errDecodeNil
@@ -392,34 +239,6 @@ func (c *codecImpl) decodeDBNode(b []byte, n *dbNode) (uint16, error) {
 	return codecVersion, err
 }
 
-func (c *codecImpl) decodeKeyChange(src *bytes.Reader) (KeyChange, error) {
-	if minKeyChangeLen > src.Len() {
-		return KeyChange{}, io.ErrUnexpectedEOF
-	}
-
-	var (
-		result KeyChange
-		err    error
-	)
-	if result.Key, err = c.decodeByteSlice(src); err != nil {
-		return result, err
-	}
-	if result.Value, err = c.decodeMaybeByteSlice(src); err != nil {
-		return result, err
-	}
-	return result, nil
-}
-
-func (c *codecImpl) encodeKeyChange(kv KeyChange, dst io.Writer) error {
-	if err := c.encodeByteSlice(dst, kv.Key); err != nil {
-		return err
-	}
-	if err := c.encodeMaybeByteSlice(dst, kv.Value); err != nil {
-		return err
-	}
-	return nil
-}
-
 func (*codecImpl) encodeBool(dst io.Writer, value bool) error {
 	bytesValue := falseBytes
 	if value {
@@ -584,125 +403,6 @@ func (*codecImpl) decodeID(src *bytes.Reader) (ids.ID, error) {
 	return id, nil
 }
 
-// Assumes a proof path has > 0 nodes.
-func (c *codecImpl) decodeProofPath(src *bytes.Reader) ([]ProofNode, error) {
-	if minProofPathLen > src.Len() {
-		return nil, io.ErrUnexpectedEOF
-	}
-
-	numProofNodes, err := c.decodeInt(src)
-	if err != nil {
-		return nil, err
-	}
-	if numProofNodes < 0 {
-		return nil, errNegativeProofPathNodes
-	}
-	if numProofNodes > src.Len()/minProofNodeLen {
-		return nil, io.ErrUnexpectedEOF
-	}
-	result := make([]ProofNode, numProofNodes)
-	for i := 0; i < numProofNodes; i++ {
-		if result[i], err = c.decodeProofNode(src); err != nil {
-			return nil, err
-		}
-	}
-	return result, nil
-}
-
-// Invariant: len(path) > 0.
-func (c *codecImpl) encodeProofPath(dst io.Writer, path []ProofNode) error {
-	if err := c.encodeInt(dst, len(path)); err != nil {
-		return err
-	}
-	for _, proofNode := range path {
-		if err := c.encodeProofNode(proofNode, dst); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *codecImpl) decodeProofNode(src *bytes.Reader) (ProofNode, error) {
-	if minProofNodeLen > src.Len() {
-		return ProofNode{}, io.ErrUnexpectedEOF
-	}
-
-	var (
-		result ProofNode
-		err    error
-	)
-	if result.KeyPath, err = c.decodeSerializedPath(src); err != nil {
-		return result, err
-	}
-	if result.ValueOrHash, err = c.decodeMaybeByteSlice(src); err != nil {
-		return result, err
-	}
-	numChildren, err := c.decodeInt(src)
-	if err != nil {
-		return result, err
-	}
-	switch {
-	case numChildren < 0:
-		return result, errNegativeNumChildren
-	case numChildren > NodeBranchFactor:
-		return result, errTooManyChildren
-	case numChildren > src.Len()/minProofNodeChildLen:
-		return result, io.ErrUnexpectedEOF
-	}
-
-	result.Children = make(map[byte]ids.ID, numChildren)
-	previousChild := -1
-	for addedEntries := 0; addedEntries < numChildren; addedEntries++ {
-		index, err := c.decodeInt(src)
-		if err != nil {
-			return result, err
-		}
-		if index <= previousChild || index >= NodeBranchFactor {
-			return result, errChildIndexTooLarge
-		}
-		previousChild = index
-
-		childID, err := c.decodeID(src)
-		if err != nil {
-			return result, err
-		}
-		result.Children[byte(index)] = childID
-	}
-	return result, nil
-}
-
-func (c *codecImpl) encodeProofNode(pn ProofNode, dst io.Writer) error {
-	if err := c.encodeSerializedPath(pn.KeyPath, dst); err != nil {
-		return err
-	}
-	if err := c.encodeMaybeByteSlice(dst, pn.ValueOrHash); err != nil {
-		return err
-	}
-	if err := c.encodeInt(dst, len(pn.Children)); err != nil {
-		return err
-	}
-	// ensure this is in order
-	childrenCount := 0
-	for index := byte(0); index < NodeBranchFactor; index++ {
-		childID, ok := pn.Children[index]
-		if !ok {
-			continue
-		}
-		childrenCount++
-		if err := c.encodeInt(dst, int(index)); err != nil {
-			return err
-		}
-		if _, err := dst.Write(childID[:]); err != nil {
-			return err
-		}
-	}
-	// there are children present with index >= NodeBranchFactor
-	if childrenCount != len(pn.Children) {
-		return errChildIndexTooLarge
-	}
-	return nil
-}
-
 func (c *codecImpl) encodeSerializedPath(s SerializedPath, dst io.Writer) error {
 	if err := c.encodeInt(dst, s.NibbleLength); err != nil {
 		return err