diff --git a/.gx/lastpubver b/.gx/lastpubver
index 3d7db28..1401252 100644
--- a/.gx/lastpubver
+++ b/.gx/lastpubver
@@ -1 +1 @@
-0.8.0: QmZFbDTY9jfSBms2MchvYM9oYRbAF19K7Pby47yDBfpPrb
+0.9.0: QmPSQnBKM9g7BaUcZCvswUJVscQ1ipjmwxN5PXCjkp9EQ7
diff --git a/builder.go b/builder.go
index af33aac..a168832 100644
--- a/builder.go
+++ b/builder.go
@@ -5,7 +5,7 @@ import (
 )
 
 type Builder interface {
-	Sum(data []byte) (*Cid, error)
+	Sum(data []byte) (Cid, error)
 	GetCodec() uint64
 	WithCodec(uint64) Builder
 }
@@ -33,10 +33,10 @@ func (p Prefix) WithCodec(c uint64) Builder {
 	return p
 }
 
-func (p V0Builder) Sum(data []byte) (*Cid, error) {
+func (p V0Builder) Sum(data []byte) (Cid, error) {
 	hash, err := mh.Sum(data, mh.SHA2_256, -1)
 	if err != nil {
-		return nil, err
+		return Undef, err
 	}
 	return NewCidV0(hash), nil
 }
@@ -52,14 +52,14 @@ func (p V0Builder) WithCodec(c uint64) Builder {
 	return V1Builder{Codec: c, MhType: mh.SHA2_256}
 }
 
-func (p V1Builder) Sum(data []byte) (*Cid, error) {
+func (p V1Builder) Sum(data []byte) (Cid, error) {
 	mhLen := p.MhLength
 	if mhLen <= 0 {
 		mhLen = -1
 	}
 	hash, err := mh.Sum(data, p.MhType, mhLen)
 	if err != nil {
-		return nil, err
+		return Undef, err
 	}
 	return NewCidV1(p.Codec, hash), nil
 }
diff --git a/cid.go b/cid.go
index 6bf2aa5..cfcbcde 100644
--- a/cid.go
+++ b/cid.go
@@ -132,36 +132,54 @@ var CodecToStr = map[uint64]string{
 // They exist to allow IPFS to work with Cids while keeping
 // compatibility with the plain-multihash format used used in IPFS.
 // NewCidV1 should be used preferentially.
-func NewCidV0(mhash mh.Multihash) *Cid {
-	return &Cid{
-		version: 0,
-		codec:   DagProtobuf,
-		hash:    mhash,
+func NewCidV0(mhash mh.Multihash) Cid {
+	// Need to make sure hash is valid for CidV0 otherwise we will
+	// incorrectly detect it as CidV1 in the Version() method
+	dec, err := mh.Decode(mhash)
+	if err != nil {
+		panic(err)
+	}
+	if dec.Code != mh.SHA2_256 || dec.Length != 32 {
+		panic("invalid hash for cidv0")
 	}
+	return Cid{string(mhash)}
 }
 
 // NewCidV1 returns a new Cid using the given multicodec-packed
 // content type.
-func NewCidV1(codecType uint64, mhash mh.Multihash) *Cid {
-	return &Cid{
-		version: 1,
-		codec:   codecType,
-		hash:    mhash,
+func NewCidV1(codecType uint64, mhash mh.Multihash) Cid {
+	hashlen := len(mhash)
+	// two 8 bytes (max) numbers plus hash
+	buf := make([]byte, 2*binary.MaxVarintLen64+hashlen)
+	n := binary.PutUvarint(buf, 1)
+	n += binary.PutUvarint(buf[n:], codecType)
+	cn := copy(buf[n:], mhash)
+	if cn != hashlen {
+		panic("copy hash length is inconsistent")
 	}
+
+	return Cid{string(buf[:n+hashlen])}
 }
 
 // Cid represents a self-describing content adressed
 // identifier. It is formed by a Version, a Codec (which indicates
 // a multicodec-packed content type) and a Multihash.
-type Cid struct {
-	version uint64
-	codec   uint64
-	hash    mh.Multihash
+type Cid struct{ str string }
+
+// Undef can be used to represent a nil or undefined Cid, using Cid{}
+// directly is also acceptable.
+var Undef = Cid{}
+
+// Defined returns true if a Cid is defined
+// Calling any other methods on an undefined Cid will result in
+// undefined behavior.
+func (c Cid) Defined() bool {
+	return c.str != ""
 }
 
 // Parse is a short-hand function to perform Decode, Cast etc... on
 // a generic interface{} type.
-func Parse(v interface{}) (*Cid, error) {
+func Parse(v interface{}) (Cid, error) {
 	switch v2 := v.(type) {
 	case string:
 		if strings.Contains(v2, "/ipfs/") {
@@ -172,10 +190,10 @@ func Parse(v interface{}) (*Cid, error) {
 		return Cast(v2)
 	case mh.Multihash:
 		return NewCidV0(v2), nil
-	case *Cid:
+	case Cid:
 		return v2, nil
 	default:
-		return nil, fmt.Errorf("can't parse %+v as Cid", v2)
+		return Undef, fmt.Errorf("can't parse %+v as Cid", v2)
 	}
 }
 
@@ -191,15 +209,15 @@ func Parse(v interface{}) (*Cid, error) {
 // Decode will also detect and parse CidV0 strings. Strings
 // starting with "Qm" are considered CidV0 and treated directly
 // as B58-encoded multihashes.
-func Decode(v string) (*Cid, error) {
+func Decode(v string) (Cid, error) {
 	if len(v) < 2 {
-		return nil, ErrCidTooShort
+		return Undef, ErrCidTooShort
 	}
 
 	if len(v) == 46 && v[:2] == "Qm" {
 		hash, err := mh.FromB58String(v)
 		if err != nil {
-			return nil, err
+			return Undef, err
 		}
 
 		return NewCidV0(hash), nil
@@ -207,7 +225,7 @@ func Decode(v string) (*Cid, error) {
 
 	_, data, err := mbase.Decode(v)
 	if err != nil {
-		return nil, err
+		return Undef, err
 	}
 
 	return Cast(data)
@@ -257,61 +275,66 @@ func uvError(read int) error {
 //
 // Please use decode when parsing a regular Cid string, as Cast does not
 // expect multibase-encoded data. Cast accepts the output of Cid.Bytes().
-func Cast(data []byte) (*Cid, error) {
+func Cast(data []byte) (Cid, error) {
 	if len(data) == 34 && data[0] == 18 && data[1] == 32 {
 		h, err := mh.Cast(data)
 		if err != nil {
-			return nil, err
+			return Undef, err
 		}
 
-		return &Cid{
-			codec:   DagProtobuf,
-			version: 0,
-			hash:    h,
-		}, nil
+		return NewCidV0(h), nil
 	}
 
 	vers, n := binary.Uvarint(data)
 	if err := uvError(n); err != nil {
-		return nil, err
+		return Undef, err
 	}
 
-	if vers != 0 && vers != 1 {
-		return nil, fmt.Errorf("invalid cid version number: %d", vers)
+	if vers != 1 {
+		return Undef, fmt.Errorf("expected 1 as the cid version number, got: %d", vers)
 	}
 
-	codec, cn := binary.Uvarint(data[n:])
+	_, cn := binary.Uvarint(data[n:])
 	if err := uvError(cn); err != nil {
-		return nil, err
+		return Undef, err
 	}
 
 	rest := data[n+cn:]
 	h, err := mh.Cast(rest)
 	if err != nil {
-		return nil, err
+		return Undef, err
 	}
 
-	return &Cid{
-		version: vers,
-		codec:   codec,
-		hash:    h,
-	}, nil
+	return Cid{string(data[0 : n+cn+len(h)])}, nil
+}
+
+// Version returns the Cid version.
+func (c Cid) Version() uint64 {
+	if len(c.str) == 34 && c.str[0] == 18 && c.str[1] == 32 {
+		return 0
+	}
+	return 1
 }
 
 // Type returns the multicodec-packed content type of a Cid.
-func (c *Cid) Type() uint64 {
-	return c.codec
+func (c Cid) Type() uint64 {
+	if c.Version() == 0 {
+		return DagProtobuf
+	}
+	_, n := uvarint(c.str)
+	codec, _ := uvarint(c.str[n:])
+	return codec
 }
 
 // String returns the default string representation of a
 // Cid. Currently, Base58 is used as the encoding for the
 // multibase string.
-func (c *Cid) String() string {
-	switch c.version {
+func (c Cid) String() string {
+	switch c.Version() {
 	case 0:
-		return c.hash.B58String()
+		return c.Hash().B58String()
 	case 1:
-		mbstr, err := mbase.Encode(mbase.Base58BTC, c.bytesV1())
+		mbstr, err := mbase.Encode(mbase.Base58BTC, c.Bytes())
 		if err != nil {
 			panic("should not error with hardcoded mbase: " + err.Error())
 		}
@@ -324,15 +347,15 @@ func (c *Cid) String() string {
 
 // String returns the string representation of a Cid
 // encoded is selected base
-func (c *Cid) StringOfBase(base mbase.Encoding) (string, error) {
-	switch c.version {
+func (c Cid) StringOfBase(base mbase.Encoding) (string, error) {
+	switch c.Version() {
 	case 0:
 		if base != mbase.Base58BTC {
 			return "", ErrInvalidEncoding
 		}
-		return c.hash.B58String(), nil
+		return c.Hash().B58String(), nil
 	case 1:
-		return mbase.Encode(base, c.bytesV1())
+		return mbase.Encode(base, c.Bytes())
 	default:
 		panic("not possible to reach this point")
 	}
@@ -341,60 +364,45 @@ func (c *Cid) StringOfBase(base mbase.Encoding) (string, error) {
 // Encode return the string representation of a Cid in a given base
 // when applicable.  Version 0 Cid's are always in Base58 as they do
 // not take a multibase prefix.
-func (c *Cid) Encode(base mbase.Encoder) string {
-	switch c.version {
+func (c Cid) Encode(base mbase.Encoder) string {
+	switch c.Version() {
 	case 0:
-		return c.hash.B58String()
+		return c.Hash().B58String()
 	case 1:
-		return base.Encode(c.bytesV1())
+		return base.Encode(c.Bytes())
 	default:
 		panic("not possible to reach this point")
 	}
 }
 
 // Hash returns the multihash contained by a Cid.
-func (c *Cid) Hash() mh.Multihash {
-	return c.hash
-}
+func (c Cid) Hash() mh.Multihash {
+	bytes := c.Bytes()
 
-// Bytes returns the byte representation of a Cid.
-// The output of bytes can be parsed back into a Cid
-// with Cast().
-func (c *Cid) Bytes() []byte {
-	switch c.version {
-	case 0:
-		return c.bytesV0()
-	case 1:
-		return c.bytesV1()
-	default:
-		panic("not possible to reach this point")
+	if c.Version() == 0 {
+		return mh.Multihash(bytes)
 	}
-}
 
-func (c *Cid) bytesV0() []byte {
-	return []byte(c.hash)
-}
+	// skip version length
+	_, n1 := binary.Uvarint(bytes)
+	// skip codec length
+	_, n2 := binary.Uvarint(bytes[n1:])
 
-func (c *Cid) bytesV1() []byte {
-	// two 8 bytes (max) numbers plus hash
-	buf := make([]byte, 2*binary.MaxVarintLen64+len(c.hash))
-	n := binary.PutUvarint(buf, c.version)
-	n += binary.PutUvarint(buf[n:], c.codec)
-	cn := copy(buf[n:], c.hash)
-	if cn != len(c.hash) {
-		panic("copy hash length is inconsistent")
-	}
+	return mh.Multihash(bytes[n1+n2:])
+}
 
-	return buf[:n+len(c.hash)]
+// Bytes returns the byte representation of a Cid.
+// The output of bytes can be parsed back into a Cid
+// with Cast().
+func (c Cid) Bytes() []byte {
+	return []byte(c.str)
 }
 
 // Equals checks that two Cids are the same.
 // In order for two Cids to be considered equal, the
 // Version, the Codec and the Multihash must match.
-func (c *Cid) Equals(o *Cid) bool {
-	return c.codec == o.codec &&
-		c.version == o.version &&
-		bytes.Equal(c.hash, o.hash)
+func (c Cid) Equals(o Cid) bool {
+	return c == o
 }
 
 // UnmarshalJSON parses the JSON representation of a Cid.
@@ -405,10 +413,15 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 	obj := struct {
 		CidTarget string `json:"/"`
 	}{}
-	err := json.Unmarshal(b, &obj)
+	objptr := &obj
+	err := json.Unmarshal(b, &objptr)
 	if err != nil {
 		return err
 	}
+	if objptr == nil {
+		*c = Cid{}
+		return nil
+	}
 
 	if obj.CidTarget == "" {
 		return fmt.Errorf("cid was incorrectly formatted")
@@ -419,9 +432,8 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	c.version = out.version
-	c.hash = out.hash
-	c.codec = out.codec
+	*c = out
+
 	return nil
 }
 
@@ -432,30 +444,33 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 // Note that this formatting comes from the IPLD specification
 // (https://github.com/ipld/specs/tree/master/ipld)
 func (c Cid) MarshalJSON() ([]byte, error) {
+	if !c.Defined() {
+		return []byte("null"), nil
+	}
 	return []byte(fmt.Sprintf("{\"/\":\"%s\"}", c.String())), nil
 }
 
-// KeyString casts the result of cid.Bytes() as a string, and returns it.
-func (c *Cid) KeyString() string {
-	return string(c.Bytes())
+// KeyString returns the binary representation of the Cid as a string
+func (c Cid) KeyString() string {
+	return c.str
 }
 
 // Loggable returns a Loggable (as defined by
 // https://godoc.org/github.com/ipfs/go-log).
-func (c *Cid) Loggable() map[string]interface{} {
+func (c Cid) Loggable() map[string]interface{} {
 	return map[string]interface{}{
 		"cid": c,
 	}
 }
 
 // Prefix builds and returns a Prefix out of a Cid.
-func (c *Cid) Prefix() Prefix {
-	dec, _ := mh.Decode(c.hash) // assuming we got a valid multiaddr, this will not error
+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,
+		Version:  c.Version(),
+		Codec:    c.Type(),
 	}
 }
 
@@ -474,10 +489,10 @@ type Prefix struct {
 
 // Sum uses the information in a prefix to perform a multihash.Sum()
 // and return a newly constructed Cid with the resulting multihash.
-func (p Prefix) Sum(data []byte) (*Cid, error) {
+func (p Prefix) Sum(data []byte) (Cid, error) {
 	hash, err := mh.Sum(data, p.MhType, p.MhLength)
 	if err != nil {
-		return nil, err
+		return Undef, err
 	}
 
 	switch p.Version {
@@ -486,7 +501,7 @@ func (p Prefix) Sum(data []byte) (*Cid, error) {
 	case 1:
 		return NewCidV1(p.Codec, hash), nil
 	default:
-		return nil, fmt.Errorf("invalid cid version")
+		return Undef, fmt.Errorf("invalid cid version")
 	}
 }
 
diff --git a/cid_fuzz.go b/cid_fuzz.go
index 357e907..99842b5 100644
--- a/cid_fuzz.go
+++ b/cid_fuzz.go
@@ -23,7 +23,7 @@ func Fuzz(data []byte) int {
 	if err != nil {
 		panic(err.Error())
 	}
-	cid2 := &Cid{}
+	cid2 := Cid{}
 	err = cid2.UnmarshalJSON(json)
 	if err != nil {
 		panic(err.Error())
diff --git a/cid_test.go b/cid_test.go
index 97294c0..1b1e9c4 100644
--- a/cid_test.go
+++ b/cid_test.go
@@ -37,16 +37,16 @@ var tCodecs = map[uint64]string{
 	DecredTx:           "decred-tx",
 }
 
-func assertEqual(t *testing.T, a, b *Cid) {
-	if a.codec != b.codec {
+func assertEqual(t *testing.T, a, b Cid) {
+	if a.Type() != b.Type() {
 		t.Fatal("mismatch on type")
 	}
 
-	if a.version != b.version {
+	if a.Version() != b.Version() {
 		t.Fatal("mismatch on version")
 	}
 
-	if !bytes.Equal(a.hash, b.hash) {
+	if !bytes.Equal(a.Hash(), b.Hash()) {
 		t.Fatal("multihash mismatch")
 	}
 }
@@ -77,11 +77,7 @@ func TestBasicMarshaling(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cid := &Cid{
-		codec:   7,
-		version: 1,
-		hash:    h,
-	}
+	cid := NewCidV1(7, h)
 
 	data := cid.Bytes()
 
@@ -107,11 +103,7 @@ func TestBasesMarshaling(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cid := &Cid{
-		codec:   7,
-		version: 1,
-		hash:    h,
-	}
+	cid := NewCidV1(7, h)
 
 	data := cid.Bytes()
 
@@ -179,12 +171,12 @@ func TestV0Handling(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if cid.version != 0 {
+	if cid.Version() != 0 {
 		t.Fatal("should have gotten version 0 cid")
 	}
 
-	if cid.hash.B58String() != old {
-		t.Fatal("marshaling roundtrip failed")
+	if cid.Hash().B58String() != old {
+		t.Fatalf("marshaling roundtrip failed: %s != %s", cid.Hash().B58String(), old)
 	}
 
 	if cid.String() != old {
@@ -306,9 +298,7 @@ func TestPrefixRoundtrip(t *testing.T) {
 func Test16BytesVarint(t *testing.T) {
 	data := []byte("this is some test content")
 	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
-	c := NewCidV1(DagCBOR, hash)
-
-	c.codec = 1 << 63
+	c := NewCidV1(1<<63, hash)
 	_ = c.Bytes()
 }
 
@@ -351,8 +341,8 @@ func TestParse(t *testing.T) {
 		if err != nil {
 			return err
 		}
-		if cid.version != 0 {
-			return fmt.Errorf("expected version 0, got %s", string(cid.version))
+		if cid.Version() != 0 {
+			return fmt.Errorf("expected version 0, got %s", string(cid.Version()))
 		}
 		actual := cid.Hash().B58String()
 		if actual != expected {
@@ -424,18 +414,18 @@ func TestJsonRoundTrip(t *testing.T) {
 	}
 	var actual Cid
 	err = json.Unmarshal(enc, &actual)
-	if !exp.Equals(&actual) {
+	if !exp.Equals(actual) {
 		t.Fatal("cids not equal for *Cid")
 	}
 
 	// Verify it works for a Cid.
-	enc, err = json.Marshal(*exp)
+	enc, err = json.Marshal(exp)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var actual2 Cid
 	err = json.Unmarshal(enc, &actual2)
-	if !exp.Equals(&actual2) {
+	if !exp.Equals(actual2) {
 		t.Fatal("cids not equal for Cid")
 	}
 }
@@ -444,7 +434,10 @@ func BenchmarkStringV1(b *testing.B) {
 	data := []byte("this is some test content")
 	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
 	cid := NewCidV1(Raw, hash)
+
+	b.ReportAllocs()
 	b.ResetTimer()
+
 	count := 0
 	for i := 0; i < b.N; i++ {
 		count += len(cid.String())
diff --git a/package.json b/package.json
index 8b821c4..7d9a6c4 100644
--- a/package.json
+++ b/package.json
@@ -15,9 +15,9 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmSbvata2WqNkqGtZNg8MR3SKwnB8iQ7vTPJgWqB8bC5kR",
+      "hash": "QmekxXDhCxCJRNuzmHreuaT3BsuJcsjcXWNrtV9C8DRHtd",
       "name": "go-multibase",
-      "version": "0.2.7"
+      "version": "0.3.0"
     }
   ],
   "gxVersion": "0.8.0",
@@ -25,6 +25,6 @@
   "license": "MIT",
   "name": "go-cid",
   "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
-  "version": "0.8.0"
+  "version": "0.9.0"
 }
 
diff --git a/set.go b/set.go
index 7f68657..eb3b3f0 100644
--- a/set.go
+++ b/set.go
@@ -3,28 +3,28 @@ package cid
 // Set is a implementation of a set of Cids, that is, a structure
 // to which holds a single copy of every Cids that is added to it.
 type Set struct {
-	set map[string]struct{}
+	set map[Cid]struct{}
 }
 
 // NewSet initializes and returns a new Set.
 func NewSet() *Set {
-	return &Set{set: make(map[string]struct{})}
+	return &Set{set: make(map[Cid]struct{})}
 }
 
 // Add puts a Cid in the Set.
-func (s *Set) Add(c *Cid) {
-	s.set[string(c.Bytes())] = struct{}{}
+func (s *Set) Add(c Cid) {
+	s.set[c] = struct{}{}
 }
 
 // Has returns if the Set contains a given Cid.
-func (s *Set) Has(c *Cid) bool {
-	_, ok := s.set[string(c.Bytes())]
+func (s *Set) Has(c Cid) bool {
+	_, ok := s.set[c]
 	return ok
 }
 
 // Remove deletes a Cid from the Set.
-func (s *Set) Remove(c *Cid) {
-	delete(s.set, string(c.Bytes()))
+func (s *Set) Remove(c Cid) {
+	delete(s.set, c)
 }
 
 // Len returns how many elements the Set has.
@@ -33,18 +33,17 @@ func (s *Set) Len() int {
 }
 
 // Keys returns the Cids in the set.
-func (s *Set) Keys() []*Cid {
-	out := make([]*Cid, 0, len(s.set))
+func (s *Set) Keys() []Cid {
+	out := make([]Cid, 0, len(s.set))
 	for k := range s.set {
-		c, _ := Cast([]byte(k))
-		out = append(out, c)
+		out = append(out, k)
 	}
 	return out
 }
 
 // Visit adds a Cid to the set only if it is
 // not in it already.
-func (s *Set) Visit(c *Cid) bool {
+func (s *Set) Visit(c Cid) bool {
 	if !s.Has(c) {
 		s.Add(c)
 		return true
@@ -55,9 +54,8 @@ func (s *Set) Visit(c *Cid) bool {
 
 // ForEach allows to run a custom function on each
 // Cid in the set.
-func (s *Set) ForEach(f func(c *Cid) error) error {
-	for cs := range s.set {
-		c, _ := Cast([]byte(cs))
+func (s *Set) ForEach(f func(c Cid) error) error {
+	for c := range s.set {
 		err := f(c)
 		if err != nil {
 			return err
@@ -65,4 +63,3 @@ func (s *Set) ForEach(f func(c *Cid) error) error {
 	}
 	return nil
 }
-
diff --git a/set_test.go b/set_test.go
index 38d7317..fa553d0 100644
--- a/set_test.go
+++ b/set_test.go
@@ -8,7 +8,7 @@ import (
 	mh "github.com/multiformats/go-multihash"
 )
 
-func makeRandomCid(t *testing.T) *Cid {
+func makeRandomCid(t *testing.T) Cid {
 	p := make([]byte, 256)
 	_, err := rand.Read(p)
 	if err != nil {
@@ -20,11 +20,7 @@ func makeRandomCid(t *testing.T) *Cid {
 		t.Fatal(err)
 	}
 
-	cid := &Cid{
-		codec:   7,
-		version: 1,
-		hash:    h,
-	}
+	cid := NewCidV1(7, h)
 
 	return cid
 }
@@ -54,8 +50,8 @@ func TestSet(t *testing.T) {
 		t.Error("visit should return false")
 	}
 
-	foreach := []*Cid{}
-	foreachF := func(c *Cid) error {
+	foreach := []Cid{}
+	foreachF := func(c Cid) error {
 		foreach = append(foreach, c)
 		return nil
 	}
@@ -68,7 +64,7 @@ func TestSet(t *testing.T) {
 		t.Error("ForEach should have visited 1 element")
 	}
 
-	foreachErr := func(c *Cid) error {
+	foreachErr := func(c Cid) error {
 		return errors.New("test")
 	}
 
diff --git a/varint.go b/varint.go
new file mode 100644
index 0000000..391c1f4
--- /dev/null
+++ b/varint.go
@@ -0,0 +1,34 @@
+package cid
+
+// Version of varint function that work with a string rather than
+// []byte to avoid unnecessary allocation
+
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license as given at https://golang.org/LICENSE
+
+// uvarint decodes a uint64 from buf and returns that value and the
+// number of characters read (> 0). If an error occurred, the value is 0
+// and the number of bytes n is <= 0 meaning:
+//
+// 	n == 0: buf too small
+// 	n  < 0: value larger than 64 bits (overflow)
+// 	        and -n is the number of bytes read
+//
+func uvarint(buf string) (uint64, int) {
+	var x uint64
+	var s uint
+	// we have a binary string so we can't use a range loope
+	for i := 0; i < len(buf); i++ {
+		b := buf[i]
+		if b < 0x80 {
+			if i > 9 || i == 9 && b > 1 {
+				return 0, -(i + 1) // overflow
+			}
+			return x | uint64(b)<<s, i + 1
+		}
+		x |= uint64(b&0x7f) << s
+		s += 7
+	}
+	return 0, 0
+}
diff --git a/varint_test.go b/varint_test.go
new file mode 100644
index 0000000..47bb061
--- /dev/null
+++ b/varint_test.go
@@ -0,0 +1,22 @@
+package cid
+
+import (
+	"encoding/binary"
+	"testing"
+)
+
+func TestUvarintRoundTrip(t *testing.T) {
+	testCases := []uint64{0, 1, 2, 127, 128, 129, 255, 256, 257, 1<<63 - 1}
+	for _, tc := range testCases {
+		buf := make([]byte, 16)
+		binary.PutUvarint(buf, tc)
+		v, l1 := uvarint(string(buf))
+		_, l2 := binary.Uvarint(buf)
+		if tc != v {
+			t.Errorf("roundtrip failed expected %d but got %d", tc, v)
+		}
+		if l1 != l2 {
+			t.Errorf("length incorrect expected %d but got %d", l2, l1)
+		}
+	}
+}