gx publish 0.7.0

.gx/lastpubver

@@ -1 +1 @@
-0.5.1: QmUrECr5NauzkUaofvUnCFGjZ4Wevt76n79uv6BhEkuyn3
+0.7.0: QmbTGYCo96Z9hiG37D9zeErFo5GjrEPcqdh7PJX1HTM73E

cid.go

@@ -5,8 +5,8 @@ import (
 	"encoding/binary"
 	"fmt"
 
-	mh "github.com/jbenet/go-multihash"
 	mbase "github.com/multiformats/go-multibase"
+	mh "github.com/multiformats/go-multihash"
 )
 
 const UnsupportedVersionString = "<unsupported cid version>"
@@ -16,6 +16,10 @@ const (
 	CBOR     = 0x71
 	Raw      = 0x72
 	JSON     = 0x73
+
+	EthereumBlock = 0x90
+	EthereumTx    = 0x91
+	Bitcoin       = 0xb0
 )
 
 func NewCidV0(h mh.Multihash) *Cid {
@@ -174,3 +178,76 @@ func (c *Cid) Loggable() map[string]interface{} {
 		"cid": c,
 	}
 }
+
+func (c *Cid) Prefix() Prefix {
+	dec, _ := mh.Decode(c.hash) // assuming we got a valid multiaddr, this will not error
+	return Prefix{
+		MhType:   dec.Code,
+		MhLength: dec.Length,
+		Version:  c.version,
+		Codec:    c.codec,
+	}
+}
+
+// Prefix represents all the metadata of a cid, minus any actual content information
+type Prefix struct {
+	Version  uint64
+	Codec    uint64
+	MhType   int
+	MhLength int
+}
+
+func (p Prefix) Sum(data []byte) (*Cid, error) {
+	hash, err := mh.Sum(data, p.MhType, p.MhLength)
+	if err != nil {
+		return nil, err
+	}
+
+	switch p.Version {
+	case 0:
+		return NewCidV0(hash), nil
+	case 1:
+		return NewCidV1(p.Codec, hash), nil
+	default:
+		return nil, fmt.Errorf("invalid cid version")
+	}
+}
+
+func (p Prefix) Bytes() []byte {
+	buf := make([]byte, 16)
+	n := binary.PutUvarint(buf, p.Version)
+	n += binary.PutUvarint(buf[n:], p.Codec)
+	n += binary.PutUvarint(buf[n:], uint64(p.MhType))
+	n += binary.PutUvarint(buf[n:], uint64(p.MhLength))
+	return buf[:n]
+}
+
+func PrefixFromBytes(buf []byte) (Prefix, error) {
+	r := bytes.NewReader(buf)
+	vers, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	codec, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	mhtype, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	mhlen, err := binary.ReadUvarint(r)
+	if err != nil {
+		return Prefix{}, err
+	}
+
+	return Prefix{
+		Version:  vers,
+		Codec:    codec,
+		MhType:   int(mhtype),
+		MhLength: int(mhlen),
+	}, nil
+}

cid_test.go

@@ -2,9 +2,10 @@ package cid
 
 import (
 	"bytes"
+	"math/rand"
 	"testing"
 
-	mh "github.com/jbenet/go-multihash"
+	mh "github.com/multiformats/go-multihash"
 )
 
 func assertEqual(t *testing.T, a, b *Cid) {
@@ -79,3 +80,41 @@ func TestV0ErrorCases(t *testing.T) {
 		t.Fatal("should have failed to decode that ref")
 	}
 }
+
+func TestPrefixRoundtrip(t *testing.T) {
+	data := []byte("this is some test content")
+	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
+	c := NewCidV1(CBOR, hash)
+
+	pref := c.Prefix()
+
+	c2, err := pref.Sum(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !c.Equals(c2) {
+		t.Fatal("output didnt match original")
+	}
+
+	pb := pref.Bytes()
+
+	pref2, err := PrefixFromBytes(pb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if pref.Version != pref2.Version || pref.Codec != pref2.Codec ||
+		pref.MhType != pref2.MhType || pref.MhLength != pref2.MhLength {
+		t.Fatal("input prefix didnt match output")
+	}
+}
+
+func TestFuzzCid(t *testing.T) {
+	buf := make([]byte, 128)
+	for i := 0; i < 200; i++ {
+		s := rand.Intn(128)
+		rand.Read(buf[:s])
+		_, _ = Cast(buf[:s])
+	}
+}

package.json

@@ -25,6 +25,6 @@
   "license": "",
   "name": "go-cid",
   "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
-  "version": "0.5.1"
+  "version": "0.7.0"
 }
 

set.go

@@ -26,7 +26,7 @@ func (s *Set) Len() int {
 }
 
 func (s *Set) Keys() []*Cid {
-	var out []*Cid
+	out := make([]*Cid, 0, len(s.set))
 	for k, _ := range s.set {
 		c, _ := Cast([]byte(k))
 		out = append(out, c)
@@ -42,3 +42,14 @@ func (s *Set) Visit(c *Cid) bool {
 
 	return false
 }
+
+func (s *Set) ForEach(f func(c *Cid) error) error {
+	for cs, _ := range s.set {
+		c, _ := Cast([]byte(cs))
+		err := f(c)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}