mst: expose NodeData and TreeEntry types

mst/cbor_gen.go

···
 var _ = math.E
 var _ = sort.Sort
 
-func (t *nodeData) MarshalCBOR(w io.Writer) error {
+func (t *NodeData) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 		return err
 	}
 
-	// t.Entries ([]mst.treeEntry) (slice)
+	// t.Entries ([]mst.TreeEntry) (slice)
 	if len("e") > 1000000 {
 		return xerrors.Errorf("Value in field \"e\" was too long")
 	}
···
 	return nil
 }
 
-func (t *nodeData) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = nodeData{}
+func (t *NodeData) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = NodeData{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("nodeData: map struct too large (%d)", extra)
+		return fmt.Errorf("NodeData: map struct too large (%d)", extra)
 	}
 
 	n := extra
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Entries ([]mst.treeEntry) (slice)
+		// t.Entries ([]mst.TreeEntry) (slice)
 		case "e":
 
 			maj, extra, err = cr.ReadHeader()
···
 			}
 
 			if extra > 0 {
-				t.Entries = make([]treeEntry, extra)
+				t.Entries = make([]TreeEntry, extra)
 			}
 
 			for i := 0; i < int(extra); i++ {
···
 
 	return nil
 }
-func (t *treeEntry) MarshalCBOR(w io.Writer) error {
+func (t *TreeEntry) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 	return nil
 }
 
-func (t *treeEntry) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = treeEntry{}
+func (t *TreeEntry) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = TreeEntry{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("treeEntry: map struct too large (%d)", extra)
+		return fmt.Errorf("TreeEntry: map struct too large (%d)", extra)
 	}
 
 	n := extra

mst/mst.go

···
 // the CBOR codec.
 func CBORTypes() []reflect.Type {
 	return []reflect.Type{
-		reflect.TypeOf(nodeData{}),
-		reflect.TypeOf(treeEntry{}),
+		reflect.TypeOf(NodeData{}),
+		reflect.TypeOf(TreeEntry{}),
 	}
 }
 
 // MST tree node as gets serialized to CBOR. Note that the CBOR fields are all
 // single-character.
-type nodeData struct {
+type NodeData struct {
 	Left    *cid.Cid    `cborgen:"l"` // [nullable] pointer to lower-level subtree to the "left" of this path/key
-	Entries []treeEntry `cborgen:"e"` // ordered list of entries at this node
+	Entries []TreeEntry `cborgen:"e"` // ordered list of entries at this node
 }
 
-// treeEntry are elements of nodeData's Entries.
-type treeEntry struct {
+// TreeEntry are elements of NodeData's Entries.
+type TreeEntry struct {
 	PrefixLen int64    `cborgen:"p"` // count of characters shared with previous path/key in tree
 	KeySuffix []byte   `cborgen:"k"` // remaining part of path/key (appended to "previous key")
 	Val       cid.Cid  `cborgen:"v"` // CID pointer at this path/key
···
 	// otherwise this is a virtual/pointer struct and we need to hydrate from
 	// blockstore before returning entries
 	if mst.pointer != cid.Undef {
-		var nd nodeData
+		var nd NodeData
 		if err := mst.cst.Get(ctx, mst.pointer, &nd); err != nil {
 			return nil, err
 		}
···
 }
 
 // golang-specific helper that calls in to deserializeNodeData
-func entriesFromNodeData(ctx context.Context, nd *nodeData, cst cbor.IpldStore) ([]nodeEntry, error) {
+func entriesFromNodeData(ctx context.Context, nd *NodeData, cst cbor.IpldStore) ([]nodeEntry, error) {
 	layer := -1
 	if len(nd.Entries) > 0 {
 		// NOTE(bnewbold): can compute the layer on the first KeySuffix, because for the first entry that field is a complete key

mst/mst_interop_test.go

···
 		t.Fatal(err)
 	}
 
-	simple_nd := nodeData{
+	simple_nd := NodeData{
 		Left: nil,
-		Entries: []treeEntry{
+		Entries: []TreeEntry{
 			{
 				PrefixLen: 0,
 				KeySuffix: []byte("com.example.record/3jqfcqzm3fo2j"),

mst/mst_util.go

···
 }
 
 // Typescript: deserializeNodeData(storage, data, layer)
-func deserializeNodeData(ctx context.Context, cst cbor.IpldStore, nd *nodeData, layer int) ([]nodeEntry, error) {
+func deserializeNodeData(ctx context.Context, cst cbor.IpldStore, nd *NodeData, layer int) ([]nodeEntry, error) {
 	entries := []nodeEntry{}
 	if nd.Left != nil {
 		// Note: like Typescript, this is actually a lazy load
···
 }
 
 // Typescript: serializeNodeData(entries) -> NodeData
-func serializeNodeData(entries []nodeEntry) (*nodeData, error) {
-	var data nodeData
+func serializeNodeData(entries []nodeEntry) (*NodeData, error) {
+	var data NodeData
 
 	i := 0
 	if len(entries) > 0 && entries[0].isTree() {
···
 		}
 
 		prefixLen := countPrefixLen(lastKey, leaf.Key)
-		data.Entries = append(data.Entries, treeEntry{
+		data.Entries = append(data.Entries, TreeEntry{
 			PrefixLen: int64(prefixLen),
 			KeySuffix: []byte(leaf.Key)[prefixLen:],
 			Val:       leaf.Val,