Custom JSON serialization of TipSetKey for array-of-CIDs

gpbft/chain.go

@@ -4,6 +4,7 @@
 	"bytes"
 	"encoding/base32"
 	"encoding/binary"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -56,6 +57,29 @@
 	Commitments [32]byte
 }
 
+func cidsFromTipSetKey(encoded []byte) ([]cid.Cid, error) {
+	var cids []cid.Cid
+	for nextIdx := 0; nextIdx < len(encoded); {
+		nr, c, err := cid.CidFromBytes(encoded[nextIdx:])
+		if err != nil {
+			return nil, err
+		}
+		cids = append(cids, c)
+		nextIdx += nr
+	}
+	return cids, nil
+}
+
+func tipSetKeyFromCids(cids []cid.Cid) (TipSetKey, error) {
+	var buf bytes.Buffer
+	for _, c := range cids {
+		if _, err := buf.Write(c.Bytes()); err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}
+
 // Validates a tipset.
 // Note the zero value is invalid.
 func (ts *TipSet) Validate() error {
@@ -111,6 +135,42 @@
 	return fmt.Sprintf("%s@%d", encTs[:min(16, len(encTs))], ts.Epoch)
 }
 
+// Custom JSON marshalling for TipSet to achieve a standard TipSetKey
+// representation that presents an array of dag-json CIDs.
+
+func (ts TipSet) MarshalJSON() ([]byte, error) {
+	type TipSetSub TipSet
+	cids, err := cidsFromTipSetKey(ts.Key)
+	if err != nil {
+		return nil, err
+	}
+	return json.Marshal(&struct {
+		Key []cid.Cid
+		TipSetSub
+	}{
+		Key:       cids,
+		TipSetSub: (TipSetSub)(ts),
+	})
+}
+
+func (ts *TipSet) UnmarshalJSON(data []byte) error {
+	type TipSetSub TipSet
+	aux := &struct {
+		Key []cid.Cid
+		*TipSetSub
+	}{
+		TipSetSub: (*TipSetSub)(ts),
+	}
+	var err error
+	if err = json.Unmarshal(data, &aux); err != nil {
+		return err
+	}
+	if ts.Key, err = tipSetKeyFromCids(aux.Key); err != nil {
+		return err
+	}
+	return nil
+}
+
 // A chain of tipsets comprising a base (the last finalised tipset from which the chain extends).
 // and (possibly empty) suffix.
 // Tipsets are assumed to be built contiguously on each other,

gpbft/chain_test.go

@@ -1,9 +1,12 @@
 package gpbft_test
 
 import (
+	"bytes"
+	"encoding/json"
 	"testing"
 
 	"github.com/filecoin-project/go-f3/gpbft"
+	"github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -184,3 +187,58 @@ func TestECChain_Eq(t *testing.T) {
 		})
 	}
 }
+
+func TestTipSetKeySerialization(t *testing.T) {
+	t.Parallel()
+	var (
+		c1  = gpbft.MakeCid([]byte("barreleye1"))
+		c2  = gpbft.MakeCid([]byte("barreleye2"))
+		c3  = gpbft.MakeCid([]byte("barreleye3"))
+		ts1 = gpbft.TipSet{
+			Epoch:       1,
+			Key:         append(append(c1.Bytes(), c2.Bytes()...), c3.Bytes()...),
+			PowerTable:  gpbft.MakeCid([]byte("fish")),
+			Commitments: [32]byte{0x01},
+		}
+		ts2 = gpbft.TipSet{
+			Epoch:       101,
+			Key:         c1.Bytes(),
+			PowerTable:  gpbft.MakeCid([]byte("lobster")),
+			Commitments: [32]byte{0x02},
+		}
+	)
+
+	t.Run("cbor round trip", func(t *testing.T) {
+		req := require.New(t)
+		for _, ts := range []gpbft.TipSet{ts1, ts2} {
+			var buf bytes.Buffer
+			req.NoError(ts.MarshalCBOR(&buf))
+			t.Logf("cbor: %x", buf.Bytes())
+			var rt gpbft.TipSet
+			req.NoError(rt.UnmarshalCBOR(&buf))
+			req.Equal(ts, rt)
+		}
+	})
+
+	t.Run("json round trip", func(t *testing.T) {
+		req := require.New(t)
+		for _, ts := range []gpbft.TipSet{ts1, ts2} {
+			data, err := ts.MarshalJSON()
+			req.NoError(err)
+			t.Logf("json: %s", data)
+			var rt gpbft.TipSet
+			req.NoError(rt.UnmarshalJSON(data))
+			req.Equal(ts, rt)
+
+			// check that we serialized the CIDs in the standard dag-json form
+			var bareMap map[string]interface{}
+			req.NoError(json.Unmarshal(data, &bareMap))
+			keyField, ok := bareMap["Key"].([]interface{})
+			req.True(ok)
+			req.Len(keyField, len(ts.Key)/38)
+			for j, c := range []cid.Cid{c1, c2, c3}[:len(ts.Key)/38] {
+				req.Equal(map[string]interface{}{"/": c.String()}, keyField[j])
+			}
+		}
+	})
+}