Add SumStream to read data from io.Reader

This provides a way to create a CID without having to read all data into memory before passing it into Sum.  Instead, call SumStream passing in an io.Reader.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+ - name: Getting Help on IPFS
+   url: https://ipfs.io/help
+   about: All information about how and where to get help on IPFS.
+ - name: IPFS Official Forum
+   url: https://discuss.ipfs.io
+   about: Please post general questions, support requests, and discussions here.

.github/ISSUE_TEMPLATE/open_an_issue.md

@@ -0,0 +1,19 @@
+---
+name: Open an issue
+about: Only for actionable issues relevant to this repository.
+title: ''
+labels: need/triage
+assignees: ''
+
+---
+<!--
+Hello! To ensure this issue is correctly addressed as soon as possible by the IPFS team, please try to make sure:
+
+- This issue is relevant to this repository's topic or codebase.
+
+- A clear description is provided. It should includes as much relevant information as possible and clear scope for the issue to be actionable.
+
+FOR GENERAL DISCUSSION, HELP OR QUESTIONS, please see the options at https://ipfs.io/help or head directly to https://discuss.ipfs.io.
+
+(you can delete this section after reading)
+-->

.github/config.yml

@@ -0,0 +1,68 @@
+# Configuration for welcome - https://github.com/behaviorbot/welcome
+
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thank you for submitting your first issue to this repository! A maintainer
+  will be here shortly to triage and review.
+
+  In the meantime, please double-check that you have provided all the
+  necessary information to make this process easy! Any information that can
+  help save additional round trips is useful! We currently aim to give
+  initial feedback within **two business days**. If this does not happen, feel
+  free to leave a comment.
+
+  Please keep an eye on how this issue will be labeled, as labels give an
+  overview of priorities, assignments and additional actions requested by the
+  maintainers:
+
+    - "Priority" labels will show how urgent this is for the team.
+    - "Status" labels will show if this is ready to be worked on, blocked, or in progress.
+    - "Need" labels will indicate if additional input or analysis is required.
+
+  Finally, remember to use https://discuss.ipfs.io if you just need general
+  support.
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thank you for submitting this PR!
+
+  A maintainer will be here shortly to review it.
+
+  We are super grateful, but we are also overloaded! Help us by making sure
+  that:
+
+    * The context for this PR is clear, with relevant discussion, decisions
+      and stakeholders linked/mentioned.
+
+    * Your contribution itself is clear (code comments, self-review for the
+      rest) and in its best form. Follow the [code contribution
+      guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines)
+      if they apply.
+
+  Getting other community members to do a review would be great help too on
+  complex PRs (you can ask in the chats/forums). If you are unsure about
+  something, just leave us a comment.
+
+  Next steps:
+
+    * A maintainer will triage and assign priority to this PR, commenting on
+      any missing things and potentially assigning a reviewer for high
+      priority items.
+
+    * The PR gets reviews, discussed and approvals as needed.
+
+    * The PR is merged by maintainers when it has been approved and comments addressed.
+
+  We currently aim to provide initial feedback/triaging within **two business
+  days**. Please keep an eye on any labelling actions, as these will indicate
+  priorities and status of your contribution.
+
+  We are very grateful for your contribution!
+
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+# Comment to be posted to on pull requests merged by a first time user
+# Currently disabled
+#firstPRMergeComment: ""

.gx/lastpubver

@@ -1 +0,0 @@
-0.9.3: QmTbxNB1NwDesLmKTscr4udL2tVP7MaxvXnD1D9yX7g3PN

.travis.yml

@@ -23,7 +23,6 @@ script:
 
 cache:
   directories:
-    - $GOPATH/src/gx
     - $GOPATH/pkg/mod
     - $HOME/.cache/go-build
 

Makefile

@@ -1,16 +1,5 @@
 all: deps
 
-gx:
-	go get github.com/whyrusleeping/gx
-	go get github.com/whyrusleeping/gx-go
-
-covertools:
+deps:
 	go get github.com/mattn/goveralls
 	go get golang.org/x/tools/cmd/cover
-
-deps: gx covertools
-	gx --verbose install --global
-	gx-go rewrite
-
-publish:
-	gx-go rewrite --undo

README.md

@@ -88,7 +88,7 @@ if c1.Equals(c2) {
 ```go
 // To check if some data matches a given cid, 
 // Get your CIDs prefix, and use that to sum the data in question:
-other, err := c.Prefix().Sum(mydata)
+other, err := c.Prefix().SumStream(myFile)
 if err != nil {...}
 
 if !c.Equals(other) {

builder.go

@@ -1,6 +1,8 @@
 package cid
 
 import (
+	"io"
+
 	mh "github.com/multiformats/go-multihash"
 )
 
@@ -41,6 +43,14 @@ func (p V0Builder) Sum(data []byte) (Cid, error) {
 	return Cid{string(hash)}, nil
 }
 
+func (p V0Builder) SumStream(r io.Reader) (Cid, error) {
+	hash, err := mh.SumStream(r, mh.SHA2_256, -1)
+	if err != nil {
+		return Undef, err
+	}
+	return Cid{string(hash)}, nil
+}
+
 func (p V0Builder) GetCodec() uint64 {
 	return DagProtobuf
 }
@@ -64,6 +74,18 @@ func (p V1Builder) Sum(data []byte) (Cid, error) {
 	return NewCidV1(p.Codec, hash), nil
 }
 
+func (p V1Builder) SumStream(r io.Reader) (Cid, error) {
+	mhLen := p.MhLength
+	if mhLen <= 0 {
+		mhLen = -1
+	}
+	hash, err := mh.SumStream(r, p.MhType, mhLen)
+	if err != nil {
+		return Undef, err
+	}
+	return NewCidV1(p.Codec, hash), nil
+}
+
 func (p V1Builder) GetCodec() uint64 {
 	return p.Codec
 }

builder_test.go

@@ -1,6 +1,7 @@
 package cid
 
 import (
+	"bytes"
 	"testing"
 
 	mh "github.com/multiformats/go-multihash"
@@ -16,6 +17,15 @@ func TestV0Builder(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	reader := bytes.NewReader(data)
+	c1a, err := format.SumStream(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !c1a.Equals(c1) {
+		t.Fatal("Sum and SumStream create different cids")
+	}
+
 	// Construct c2
 	hash, err := mh.Sum(data, mh.SHA2_256, -1)
 	if err != nil {
@@ -29,6 +39,16 @@ func TestV0Builder(t *testing.T) {
 	if c1.Prefix() != c2.Prefix() {
 		t.Fatal("prefixes mismatch")
 	}
+
+	reader.Seek(0, 0)
+	hash, err = mh.SumStream(reader, mh.SHA2_256, -1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c2 = NewCidV0(hash)
+	if !c1.Equals(c2) {
+		t.Fatal("Sum and SumStream create different cids")
+	}
 }
 
 func TestV1Builder(t *testing.T) {
@@ -41,6 +61,15 @@ func TestV1Builder(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	reader := bytes.NewReader(data)
+	c1a, err := format.SumStream(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !c1a.Equals(c1) {
+		t.Fatal("Sum and SumStream create different cids")
+	}
+
 	// Construct c2
 	hash, err := mh.Sum(data, mh.SHA2_256, -1)
 	if err != nil {
@@ -65,9 +94,29 @@ func TestCodecChange(t *testing.T) {
 		p := Prefix{Version: 1, Codec: DagProtobuf, MhType: mh.SHA2_256, MhLength: mh.DefaultLengths[mh.SHA2_256]}
 		testCodecChange(t, p)
 	})
+	t.Run("Prefix-NoChange", func(t *testing.T) {
+		p := Prefix{Version: 0, Codec: DagProtobuf, MhType: mh.SHA2_256, MhLength: mh.DefaultLengths[mh.SHA2_256]}
+		if p.GetCodec() != DagProtobuf {
+			t.Fatal("original builder not using Protobuf codec")
+		}
+		pn := p.WithCodec(DagProtobuf)
+		if pn != p {
+			t.Fatal("should have returned same builder")
+		}
+	})
 	t.Run("V0Builder", func(t *testing.T) {
 		testCodecChange(t, V0Builder{})
 	})
+	t.Run("V0Builder-NoChange", func(t *testing.T) {
+		b := V0Builder{}
+		if b.GetCodec() != DagProtobuf {
+			t.Fatal("original builder not using Protobuf codec")
+		}
+		bn := b.WithCodec(DagProtobuf)
+		if bn != b {
+			t.Fatal("should have returned same builder")
+		}
+	})
 	t.Run("V1Builder", func(t *testing.T) {
 		testCodecChange(t, V1Builder{Codec: DagProtobuf, MhType: mh.SHA2_256})
 	})

cid.go

@@ -22,29 +22,21 @@ package cid
 import (
 	"bytes"
 	"encoding"
-	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"strings"
 
 	mbase "github.com/multiformats/go-multibase"
 	mh "github.com/multiformats/go-multihash"
+	varint "github.com/multiformats/go-varint"
 )
 
 // UnsupportedVersionString just holds an error message
 const UnsupportedVersionString = "<unsupported cid version>"
 
 var (
-	// ErrVarintBuffSmall means that a buffer passed to the cid parser was not
-	// long enough, or did not contain an invalid cid
-	ErrVarintBuffSmall = errors.New("reading varint: buffer too small")
-
-	// ErrVarintTooBig means that the varint in the given cid was above the
-	// limit of 2^64
-	ErrVarintTooBig = errors.New("reading varint: varint bigger than 64bits" +
-		" and not supported")
-
 	// ErrCidTooShort means that the cid passed to decode was not long
 	// enough to be a valid Cid
 	ErrCidTooShort = errors.New("cid too short")
@@ -66,75 +58,84 @@ const (
 
 	GitRaw = 0x78
 
-	EthBlock           = 0x90
-	EthBlockList       = 0x91
-	EthTxTrie          = 0x92
-	EthTx              = 0x93
-	EthTxReceiptTrie   = 0x94
-	EthTxReceipt       = 0x95
-	EthStateTrie       = 0x96
-	EthAccountSnapshot = 0x97
-	EthStorageTrie     = 0x98
-	BitcoinBlock       = 0xb0
-	BitcoinTx          = 0xb1
-	ZcashBlock         = 0xc0
-	ZcashTx            = 0xc1
-	DecredBlock        = 0xe0
-	DecredTx           = 0xe1
-	DashBlock          = 0xf0
-	DashTx             = 0xf1
+	DagJOSE               = 0x85
+	EthBlock              = 0x90
+	EthBlockList          = 0x91
+	EthTxTrie             = 0x92
+	EthTx                 = 0x93
+	EthTxReceiptTrie      = 0x94
+	EthTxReceipt          = 0x95
+	EthStateTrie          = 0x96
+	EthAccountSnapshot    = 0x97
+	EthStorageTrie        = 0x98
+	BitcoinBlock          = 0xb0
+	BitcoinTx             = 0xb1
+	ZcashBlock            = 0xc0
+	ZcashTx               = 0xc1
+	DecredBlock           = 0xe0
+	DecredTx              = 0xe1
+	DashBlock             = 0xf0
+	DashTx                = 0xf1
+	FilCommitmentUnsealed = 0xf101
+	FilCommitmentSealed   = 0xf102
 )
 
 // Codecs maps the name of a codec to its type
 var Codecs = map[string]uint64{
-	"v0":                   DagProtobuf,
-	"raw":                  Raw,
-	"protobuf":             DagProtobuf,
-	"cbor":                 DagCBOR,
-	"libp2p-key":           Libp2pKey,
-	"git-raw":              GitRaw,
-	"eth-block":            EthBlock,
-	"eth-block-list":       EthBlockList,
-	"eth-tx-trie":          EthTxTrie,
-	"eth-tx":               EthTx,
-	"eth-tx-receipt-trie":  EthTxReceiptTrie,
-	"eth-tx-receipt":       EthTxReceipt,
-	"eth-state-trie":       EthStateTrie,
-	"eth-account-snapshot": EthAccountSnapshot,
-	"eth-storage-trie":     EthStorageTrie,
-	"bitcoin-block":        BitcoinBlock,
-	"bitcoin-tx":           BitcoinTx,
-	"zcash-block":          ZcashBlock,
-	"zcash-tx":             ZcashTx,
-	"decred-block":         DecredBlock,
-	"decred-tx":            DecredTx,
-	"dash-block":           DashBlock,
-	"dash-tx":              DashTx,
+	"v0":                      DagProtobuf,
+	"raw":                     Raw,
+	"protobuf":                DagProtobuf,
+	"cbor":                    DagCBOR,
+	"libp2p-key":              Libp2pKey,
+	"git-raw":                 GitRaw,
+	"eth-block":               EthBlock,
+	"eth-block-list":          EthBlockList,
+	"eth-tx-trie":             EthTxTrie,
+	"eth-tx":                  EthTx,
+	"eth-tx-receipt-trie":     EthTxReceiptTrie,
+	"eth-tx-receipt":          EthTxReceipt,
+	"eth-state-trie":          EthStateTrie,
+	"eth-account-snapshot":    EthAccountSnapshot,
+	"eth-storage-trie":        EthStorageTrie,
+	"bitcoin-block":           BitcoinBlock,
+	"bitcoin-tx":              BitcoinTx,
+	"zcash-block":             ZcashBlock,
+	"zcash-tx":                ZcashTx,
+	"decred-block":            DecredBlock,
+	"decred-tx":               DecredTx,
+	"dash-block":              DashBlock,
+	"dash-tx":                 DashTx,
+	"fil-commitment-unsealed": FilCommitmentUnsealed,
+	"fil-commitment-sealed":   FilCommitmentSealed,
+	"dag-jose":                DagJOSE,
 }
 
 // CodecToStr maps the numeric codec to its name
 var CodecToStr = map[uint64]string{
-	Raw:                "raw",
-	DagProtobuf:        "protobuf",
-	DagCBOR:            "cbor",
-	GitRaw:             "git-raw",
-	EthBlock:           "eth-block",
-	EthBlockList:       "eth-block-list",
-	EthTxTrie:          "eth-tx-trie",
-	EthTx:              "eth-tx",
-	EthTxReceiptTrie:   "eth-tx-receipt-trie",
-	EthTxReceipt:       "eth-tx-receipt",
-	EthStateTrie:       "eth-state-trie",
-	EthAccountSnapshot: "eth-account-snapshot",
-	EthStorageTrie:     "eth-storage-trie",
-	BitcoinBlock:       "bitcoin-block",
-	BitcoinTx:          "bitcoin-tx",
-	ZcashBlock:         "zcash-block",
-	ZcashTx:            "zcash-tx",
-	DecredBlock:        "decred-block",
-	DecredTx:           "decred-tx",
-	DashBlock:          "dash-block",
-	DashTx:             "dash-tx",
+	Raw:                   "raw",
+	DagProtobuf:           "protobuf",
+	DagCBOR:               "cbor",
+	GitRaw:                "git-raw",
+	EthBlock:              "eth-block",
+	EthBlockList:          "eth-block-list",
+	EthTxTrie:             "eth-tx-trie",
+	EthTx:                 "eth-tx",
+	EthTxReceiptTrie:      "eth-tx-receipt-trie",
+	EthTxReceipt:          "eth-tx-receipt",
+	EthStateTrie:          "eth-state-trie",
+	EthAccountSnapshot:    "eth-account-snapshot",
+	EthStorageTrie:        "eth-storage-trie",
+	BitcoinBlock:          "bitcoin-block",
+	BitcoinTx:             "bitcoin-tx",
+	ZcashBlock:            "zcash-block",
+	ZcashTx:               "zcash-tx",
+	DecredBlock:           "decred-block",
+	DecredTx:              "decred-tx",
+	DashBlock:             "dash-block",
+	DashTx:                "dash-tx",
+	FilCommitmentUnsealed: "fil-commitment-unsealed",
+	FilCommitmentSealed:   "fil-commitment-sealed",
+	DagJOSE:               "dag-jose",
 }
 
 // tryNewCidV0 tries to convert a multihash into a CIDv0 CID and returns an
@@ -173,9 +174,9 @@ func NewCidV0(mhash mh.Multihash) Cid {
 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)
+	buf := make([]byte, 1+varint.UvarintSize(codecType)+hashlen)
+	n := varint.PutUvarint(buf, 1)
+	n += varint.PutUvarint(buf[n:], codecType)
 	cn := copy(buf[n:], mhash)
 	if cn != hashlen {
 		panic("copy hash length is inconsistent")
@@ -281,17 +282,6 @@ func ExtractEncoding(v string) (mbase.Encoding, error) {
 	return encoding, nil
 }
 
-func uvError(read int) error {
-	switch {
-	case read == 0:
-		return ErrVarintBuffSmall
-	case read < 0:
-		return ErrVarintTooBig
-	default:
-		return nil
-	}
-}
-
 // Cast takes a Cid data slice, parses it and returns a Cid.
 // For CidV1, the data buffer is in the form:
 //
@@ -351,14 +341,14 @@ func (c Cid) Type() uint64 {
 	if c.Version() == 0 {
 		return DagProtobuf
 	}
-	_, n := uvarint(c.str)
-	codec, _ := uvarint(c.str[n:])
+	_, 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.
+// Cid. Currently, Base32 is used for CIDV1 as the encoding for the
+// multibase string, Base58 is used for CIDV0.
 func (c Cid) String() string {
 	switch c.Version() {
 	case 0:
@@ -414,9 +404,9 @@ func (c Cid) Hash() mh.Multihash {
 	}
 
 	// skip version length
-	_, n1 := binary.Uvarint(bytes)
+	_, n1, _ := varint.FromUvarint(bytes)
 	// skip codec length
-	_, n2 := binary.Uvarint(bytes[n1:])
+	_, n2, _ := varint.FromUvarint(bytes[n1:])
 
 	return mh.Multihash(bytes[n1+n2:])
 }
@@ -428,6 +418,30 @@ func (c Cid) Bytes() []byte {
 	return []byte(c.str)
 }
 
+// ByteLen returns the length of the CID in bytes.
+// It's equivalent to `len(c.Bytes())`, but works without an allocation,
+// and should therefore be preferred.
+//
+// (See also the WriteTo method for other important operations that work without allocation.)
+func (c Cid) ByteLen() int {
+	return len(c.str)
+}
+
+// WriteBytes writes the CID bytes to the given writer.
+// This method works without incurring any allocation.
+//
+// (See also the ByteLen method for other important operations that work without allocation.)
+func (c Cid) WriteBytes(w io.Writer) (int, error) {
+	n, err := io.WriteString(w, c.str)
+	if err != nil {
+		return n, err
+	}
+	if n != len(c.str) {
+		return n, fmt.Errorf("failed to write entire cid string")
+	}
+	return n, nil
+}
+
 // MarshalBinary is equivalent to Bytes(). It implements the
 // encoding.BinaryMarshaler interface.
 func (c Cid) MarshalBinary() ([]byte, error) {
@@ -507,12 +521,29 @@ func (c Cid) Loggable() map[string]interface{} {
 
 // 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
+	if c.Version() == 0 {
+		return Prefix{
+			MhType:   mh.SHA2_256,
+			MhLength: 32,
+			Version:  0,
+			Codec:    DagProtobuf,
+		}
+	}
+
+	offset := 0
+	version, n, _ := uvarint(c.str[offset:])
+	offset += n
+	codec, n, _ := uvarint(c.str[offset:])
+	offset += n
+	mhtype, n, _ := uvarint(c.str[offset:])
+	offset += n
+	mhlen, _, _ := uvarint(c.str[offset:])
+
 	return Prefix{
-		MhType:   dec.Code,
-		MhLength: dec.Length,
-		Version:  c.Version(),
-		Codec:    c.Type(),
+		MhType:   mhtype,
+		MhLength: int(mhlen),
+		Version:  version,
+		Codec:    codec,
 	}
 }
 
@@ -558,38 +589,76 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
 	}
 }
 
+// SumStream uses the information in a prefix, and data read from a io.Reader,
+// to perform a multihash.SumStream() and return a newly constructed Cid with
+// the resulting multihash.
+func (p Prefix) SumStream(r io.Reader) (Cid, error) {
+	length := p.MhLength
+	if p.MhType == mh.ID {
+		length = -1
+	}
+
+	if p.Version == 0 && (p.MhType != mh.SHA2_256 ||
+		(p.MhLength != 32 && p.MhLength != -1)) {
+
+		return Undef, fmt.Errorf("invalid v0 prefix")
+	}
+
+	hash, err := mh.SumStream(r, p.MhType, length)
+	if err != nil {
+		return Undef, err
+	}
+
+	switch p.Version {
+	case 0:
+		return NewCidV0(hash), nil
+	case 1:
+		return NewCidV1(p.Codec, hash), nil
+	default:
+		return Undef, fmt.Errorf("invalid cid version")
+	}
+}
+
 // Bytes returns a byte representation of a Prefix. It looks like:
 //
 //     <version><codec><mh-type><mh-length>
 func (p Prefix) Bytes() []byte {
-	buf := make([]byte, 4*binary.MaxVarintLen64)
-	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]
+	size := varint.UvarintSize(p.Version)
+	size += varint.UvarintSize(p.Codec)
+	size += varint.UvarintSize(p.MhType)
+	size += varint.UvarintSize(uint64(p.MhLength))
+
+	buf := make([]byte, size)
+	n := varint.PutUvarint(buf, p.Version)
+	n += varint.PutUvarint(buf[n:], p.Codec)
+	n += varint.PutUvarint(buf[n:], p.MhType)
+	n += varint.PutUvarint(buf[n:], uint64(p.MhLength))
+	if n != size {
+		panic("size mismatch")
+	}
+	return buf
 }
 
 // PrefixFromBytes parses a Prefix-byte representation onto a
 // Prefix.
 func PrefixFromBytes(buf []byte) (Prefix, error) {
 	r := bytes.NewReader(buf)
-	vers, err := binary.ReadUvarint(r)
+	vers, err := varint.ReadUvarint(r)
 	if err != nil {
 		return Prefix{}, err
 	}
 
-	codec, err := binary.ReadUvarint(r)
+	codec, err := varint.ReadUvarint(r)
 	if err != nil {
 		return Prefix{}, err
 	}
 
-	mhtype, err := binary.ReadUvarint(r)
+	mhtype, err := varint.ReadUvarint(r)
 	if err != nil {
 		return Prefix{}, err
 	}
 
-	mhlen, err := binary.ReadUvarint(r)
+	mhlen, err := varint.ReadUvarint(r)
 	if err != nil {
 		return Prefix{}, err
 	}
@@ -616,8 +685,8 @@ func CidFromBytes(data []byte) (int, Cid, error) {
 		return 34, Cid{string(h)}, nil
 	}
 
-	vers, n := binary.Uvarint(data)
-	if err := uvError(n); err != nil {
+	vers, n, err := varint.FromUvarint(data)
+	if err != nil {
 		return 0, Undef, err
 	}
 
@@ -625,8 +694,8 @@ func CidFromBytes(data []byte) (int, Cid, error) {
 		return 0, Undef, fmt.Errorf("expected 1 as the cid version number, got: %d", vers)
 	}
 
-	_, cn := binary.Uvarint(data[n:])
-	if err := uvError(cn); err != nil {
+	_, cn, err := varint.FromUvarint(data[n:])
+	if err != nil {
 		return 0, Undef, err
 	}
 

cid_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"math/rand"
+	"reflect"
 	"strings"
 	"testing"
 
@@ -16,28 +17,31 @@ import (
 // https://github.com/multiformats/go-multihash/blob/7aa9f26a231c6f34f4e9fad52bf580fd36627285/multihash_test.go#L13
 // Makes it so changing the table accidentally has to happen twice.
 var tCodecs = map[uint64]string{
-	Raw:                "raw",
-	DagProtobuf:        "protobuf",
-	DagCBOR:            "cbor",
-	Libp2pKey:          "libp2p-key",
-	GitRaw:             "git-raw",
-	EthBlock:           "eth-block",
-	EthBlockList:       "eth-block-list",
-	EthTxTrie:          "eth-tx-trie",
-	EthTx:              "eth-tx",
-	EthTxReceiptTrie:   "eth-tx-receipt-trie",
-	EthTxReceipt:       "eth-tx-receipt",
-	EthStateTrie:       "eth-state-trie",
-	EthAccountSnapshot: "eth-account-snapshot",
-	EthStorageTrie:     "eth-storage-trie",
-	BitcoinBlock:       "bitcoin-block",
-	BitcoinTx:          "bitcoin-tx",
-	ZcashBlock:         "zcash-block",
-	ZcashTx:            "zcash-tx",
-	DecredBlock:        "decred-block",
-	DecredTx:           "decred-tx",
-	DashBlock:          "dash-block",
-	DashTx:             "dash-tx",
+	Raw:                   "raw",
+	DagProtobuf:           "protobuf",
+	DagCBOR:               "cbor",
+	Libp2pKey:             "libp2p-key",
+	GitRaw:                "git-raw",
+	EthBlock:              "eth-block",
+	EthBlockList:          "eth-block-list",
+	EthTxTrie:             "eth-tx-trie",
+	EthTx:                 "eth-tx",
+	EthTxReceiptTrie:      "eth-tx-receipt-trie",
+	EthTxReceipt:          "eth-tx-receipt",
+	EthStateTrie:          "eth-state-trie",
+	EthAccountSnapshot:    "eth-account-snapshot",
+	EthStorageTrie:        "eth-storage-trie",
+	BitcoinBlock:          "bitcoin-block",
+	BitcoinTx:             "bitcoin-tx",
+	ZcashBlock:            "zcash-block",
+	ZcashTx:               "zcash-tx",
+	DecredBlock:           "decred-block",
+	DecredTx:              "decred-tx",
+	DashBlock:             "dash-block",
+	DashTx:                "dash-tx",
+	FilCommitmentUnsealed: "fil-commitment-unsealed",
+	FilCommitmentSealed:   "fil-commitment-sealed",
+	DagJOSE:               "dag-jose",
 }
 
 func assertEqual(t *testing.T, a, b Cid) {
@@ -182,8 +186,32 @@ func TestBasesMarshaling(t *testing.T) {
 		}
 		s2 := cid.Encode(encoder)
 		if s != s2 {
-			t.Fatalf("'%s' != '%s'", s, s2)
+			t.Fatalf("%q != %q", s, s2)
 		}
+
+		ee, err := ExtractEncoding(s)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ee != b {
+			t.Fatalf("could not properly determine base (got %v)", ee)
+		}
+	}
+
+	ee, err := ExtractEncoding("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ee != mbase.Base58BTC {
+		t.Fatalf("expected Base58BTC from Qm string (got %v)", ee)
+	}
+
+	ee, err = ExtractEncoding("1")
+	if err == nil {
+		t.Fatal("expected too-short error from ExtractEncoding")
+	}
+	if ee != -1 {
+		t.Fatal("expected -1 from too-short ExtractEncoding")
 	}
 }
 
@@ -192,18 +220,32 @@ func TestBinaryMarshaling(t *testing.T) {
 	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
 	c := NewCidV1(DagCBOR, hash)
 	var c2 Cid
+	var c3 Cid
 
 	data, err := c.MarshalBinary()
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = c2.UnmarshalBinary(data)
-	if err != nil {
+	if err = c2.UnmarshalBinary(data); err != nil {
 		t.Fatal(err)
 	}
 	if !c.Equals(c2) {
 		t.Errorf("cids should be the same: %s %s", c, c2)
 	}
+	var buf bytes.Buffer
+	wrote, err := c.WriteBytes(&buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if wrote != 36 {
+		t.Fatalf("expected 36 bytes written (got %d)", wrote)
+	}
+	if err = c3.UnmarshalBinary(data); err != nil {
+		t.Fatal(err)
+	}
+	if !c.Equals(c3) {
+		t.Errorf("cids should be the same: %s %s", c, c3)
+	}
 }
 
 func TestTextMarshaling(t *testing.T) {
@@ -216,13 +258,16 @@ func TestTextMarshaling(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = c2.UnmarshalText(data)
-	if err != nil {
+	if err = c2.UnmarshalText(data); err != nil {
 		t.Fatal(err)
 	}
 	if !c.Equals(c2) {
 		t.Errorf("cids should be the same: %s %s", c, c2)
 	}
+
+	if c.KeyString() != string(c.Bytes()) {
+		t.Errorf("got unexpected KeyString() result")
+	}
 }
 
 func TestEmptyString(t *testing.T) {
@@ -252,6 +297,11 @@ func TestV0Handling(t *testing.T) {
 		t.Fatal("marshaling roundtrip failed")
 	}
 
+	byteLen := cid.ByteLen()
+	if byteLen != 34 {
+		t.Fatalf("expected V0 ByteLen to be 34 (got %d)", byteLen)
+	}
+
 	new, err := cid.StringOfBase(mbase.Base58BTC)
 	if err != nil {
 		t.Fatal(err)
@@ -267,6 +317,11 @@ func TestV0Handling(t *testing.T) {
 	if cid.Encode(encoder) != old {
 		t.Fatal("Encode roundtrip failed")
 	}
+
+	_, err = cid.StringOfBase(mbase.Base32)
+	if err != ErrInvalidEncoding {
+		t.Fatalf("expected ErrInvalidEncoding for V0 StringOfBase(Base32) (got %v)", err)
+	}
 }
 
 func TestV0ErrorCases(t *testing.T) {
@@ -367,7 +422,14 @@ func TestInvalidV0Prefix(t *testing.T) {
 			t.Fatalf("should error (index %d)", i)
 		}
 	}
+}
 
+func TestBadPrefix(t *testing.T) {
+	p := Prefix{Version: 3, Codec: DagProtobuf, MhType: mh.SHA2_256, MhLength: 3}
+	_, err := p.Sum([]byte{0x00, 0x01, 0x03})
+	if err == nil {
+		t.Fatalf("expected error on v3 prefix Sum")
+	}
 }
 
 func TestPrefixRoundtrip(t *testing.T) {
@@ -399,6 +461,25 @@ func TestPrefixRoundtrip(t *testing.T) {
 	}
 }
 
+func TestBadPrefixFromBytes(t *testing.T) {
+	_, err := PrefixFromBytes([]byte{0x80})
+	if err == nil {
+		t.Fatal("expected error for bad byte 0")
+	}
+	_, err = PrefixFromBytes([]byte{0x01, 0x80})
+	if err == nil {
+		t.Fatal("expected error for bad byte 1")
+	}
+	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x80})
+	if err == nil {
+		t.Fatal("expected error for bad byte 2")
+	}
+	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x01, 0x80})
+	if err == nil {
+		t.Fatal("expected error for bad byte 3")
+	}
+}
+
 func Test16BytesVarint(t *testing.T) {
 	data := []byte("this is some test content")
 	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
@@ -446,7 +527,7 @@ func TestParse(t *testing.T) {
 			return err
 		}
 		if cid.Version() != 0 {
-			return fmt.Errorf("expected version 0, got %s", string(cid.Version()))
+			return fmt.Errorf("expected version 0, got %d", cid.Version())
 		}
 		actual := cid.Hash().B58String()
 		if actual != expected {
@@ -460,8 +541,7 @@ func TestParse(t *testing.T) {
 	}
 
 	for _, args := range assertions {
-		err := assert(args[0], args[1].(string))
-		if err != nil {
+		if err := assert(args[0], args[1].(string)); err != nil {
 			t.Fatal(err)
 		}
 	}
@@ -495,8 +575,7 @@ func TestFromJson(t *testing.T) {
 	cval := "bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm"
 	jsoncid := []byte(`{"/":"` + cval + `"}`)
 	var c Cid
-	err := json.Unmarshal(jsoncid, &c)
-	if err != nil {
+	if err := json.Unmarshal(jsoncid, &c); err != nil {
 		t.Fatal(err)
 	}
 
@@ -506,6 +585,7 @@ func TestFromJson(t *testing.T) {
 }
 
 func TestJsonRoundTrip(t *testing.T) {
+	expectedJSON := `{"/":"bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm"}`
 	exp, err := Decode("bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm")
 	if err != nil {
 		t.Fatal(err)
@@ -517,21 +597,50 @@ func TestJsonRoundTrip(t *testing.T) {
 		t.Fatal(err)
 	}
 	var actual Cid
-	err = json.Unmarshal(enc, &actual)
+	if err = json.Unmarshal(enc, &actual); err != nil {
+		t.Fatal(err)
+	}
 	if !exp.Equals(actual) {
 		t.Fatal("cids not equal for *Cid")
 	}
 
+	if string(enc) != expectedJSON {
+		t.Fatalf("did not get expected JSON form (got %q)", string(enc))
+	}
+
 	// Verify it works for a Cid.
 	enc, err = json.Marshal(exp)
 	if err != nil {
 		t.Fatal(err)
 	}
 	var actual2 Cid
-	err = json.Unmarshal(enc, &actual2)
+	if err = json.Unmarshal(enc, &actual2); err != nil {
+		t.Fatal(err)
+	}
 	if !exp.Equals(actual2) {
 		t.Fatal("cids not equal for Cid")
 	}
+
+	if err = actual2.UnmarshalJSON([]byte("1")); err == nil {
+		t.Fatal("expected error for too-short JSON")
+	}
+
+	if err = actual2.UnmarshalJSON([]byte(`{"nope":"nope"}`)); err == nil {
+		t.Fatal("expected error for bad CID JSON")
+	}
+
+	if err = actual2.UnmarshalJSON([]byte(`bad "" json!`)); err == nil {
+		t.Fatal("expected error for bad JSON")
+	}
+
+	var actual3 Cid
+	enc, err = actual3.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(enc) != "null" {
+		t.Fatalf("expected 'null' string for undefined CID (got %q)", string(enc))
+	}
 }
 
 func BenchmarkStringV1(b *testing.B) {
@@ -554,6 +663,7 @@ func BenchmarkStringV1(b *testing.B) {
 func TestReadCidsFromBuffer(t *testing.T) {
 	cidstr := []string{
 		"bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm",
+		"k2cwueckqkibutvhkr4p2ln2pjcaxaakpd9db0e7j7ax1lxhhxy3ekpv",
 		"Qmf5Qzp6nGBku7CEn2UQx4mgN8TW69YUok36DrGa6NN893",
 		"zb2rhZi1JR4eNc2jBGaRYJKYM8JEB4ovenym8L1CmFsRAytkz",
 	}
@@ -585,6 +695,52 @@ func TestReadCidsFromBuffer(t *testing.T) {
 	}
 }
 
+func TestBadCidFromBytes(t *testing.T) {
+	l, c, err := CidFromBytes([]byte{mh.SHA2_256, 32, 0x00})
+	if err == nil {
+		t.Fatal("expected not-enough-bytes for V0 CidFromBytes")
+	}
+	if l != 0 {
+		t.Fatal("expected length=0 from bad CidFromBytes")
+	}
+	if c != Undef {
+		t.Fatal("expected Undef CID from bad CidFromBytes")
+	}
+
+	c, err = Decode("bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	byts := make([]byte, c.ByteLen())
+	copy(byts, c.Bytes())
+	byts[1] = 0x80 // bad codec varint
+	byts[2] = 0x00
+	l, c, err = CidFromBytes(byts)
+	if err == nil {
+		t.Fatal("expected not-enough-bytes for V1 CidFromBytes")
+	}
+	if l != 0 {
+		t.Fatal("expected length=0 from bad CidFromBytes")
+	}
+	if c != Undef {
+		t.Fatal("expected Undef CID from bad CidFromBytes")
+	}
+
+	copy(byts, c.Bytes())
+	byts[2] = 0x80 // bad multihash varint
+	byts[3] = 0x00
+	l, c, err = CidFromBytes(byts)
+	if err == nil {
+		t.Fatal("expected not-enough-bytes for V1 CidFromBytes")
+	}
+	if l != 0 {
+		t.Fatal("expected length=0 from bad CidFromBytes")
+	}
+	if c != Undef {
+		t.Fatal("expected Undef CID from bad CidFromBytes")
+	}
+}
+
 func TestBadParse(t *testing.T) {
 	hash, err := mh.Sum([]byte("foobar"), mh.SHA3_256, -1)
 	if err != nil {
@@ -595,3 +751,16 @@ func TestBadParse(t *testing.T) {
 		t.Fatal("expected to fail to parse an invalid CIDv1 CID")
 	}
 }
+
+func TestLoggable(t *testing.T) {
+	c, err := Decode("bafkreie5qrjvaw64n4tjm6hbnm7fnqvcssfed4whsjqxzslbd3jwhsk3mm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := c.Loggable()
+	expected := make(map[string]interface{})
+	expected["cid"] = c
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("did not get expected loggable form (got %v)", actual)
+	}
+}

go.mod

@@ -1,8 +1,9 @@
 module github.com/ipfs/go-cid
 
 require (
-	github.com/multiformats/go-multibase v0.0.1
-	github.com/multiformats/go-multihash v0.0.10
+	github.com/multiformats/go-multibase v0.0.3
+	github.com/multiformats/go-multihash v0.0.16-0.20210406191223-75ae3688857d
+	github.com/multiformats/go-varint v0.0.6
 )
 
-go 1.13
+go 1.15

go.sum

@@ -1,28 +1,29 @@
+github.com/klauspost/cpuid/v2 v2.0.4 h1:g0I61F2K2DjRHz1cnxlkNSBIaePVoJIjjnHui8QHbiw=
+github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
-github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771 h1:MHkK1uRtFbVqvAgvWxafZe54+5uBxLluGylDiKgdhwo=
-github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
-github.com/mr-tron/base58 v1.1.0 h1:Y51FGVJ91WBqCEabAi5OPUz38eAx8DakuAm5svLcsfQ=
+github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g=
+github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM=
 github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
-github.com/mr-tron/base58 v1.1.2 h1:ZEw4I2EgPKDJ2iEw0cNmLB3ROrEmkOtXIkaG7wZg+78=
-github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
+github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
 github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
-github.com/multiformats/go-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmrJR+ubhT9qA=
-github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
-github.com/multiformats/go-multihash v0.0.8 h1:wrYcW5yxSi3dU07n5jnuS5PrNwyHy0zRHGVoUugWvXg=
-github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
-github.com/multiformats/go-multihash v0.0.9 h1:aoijQXYYl7Xtb2pUUP68R+ys1TlnlR3eX6wmozr0Hp4=
-github.com/multiformats/go-multihash v0.0.9/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
-github.com/multiformats/go-multihash v0.0.10 h1:lMoNbh2Ssd9PUF74Nz008KGzGPlfeV6wH3rit5IIGCM=
-github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
-github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
-github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4=
+github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM=
+github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
+github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
+github.com/multiformats/go-multihash v0.0.16-0.20210406191223-75ae3688857d h1:xUl/JcLVtafS0n5X8guAExxDS/mJUGoL31p/FlNtC8o=
+github.com/multiformats/go-multihash v0.0.16-0.20210406191223-75ae3688857d/go.mod h1:D6aZrWNLFTV/ynMpKsNtB40mJzmCl4jb1alC0OvHiHg=
+github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
+github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8 h1:1wopBVtVdWnn03fZelqdXTqk7U7zPQCb+T4rbU9ZEoU=
-golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
+golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

package.json

@@ -1,30 +0,0 @@
-{
-  "author": "whyrusleeping",
-  "bugs": {
-    "url": "https://github.com/ipfs/go-cid"
-  },
-  "gx": {
-    "dvcsimport": "github.com/ipfs/go-cid"
-  },
-  "gxDependencies": [
-    {
-      "author": "whyrusleeping",
-      "hash": "QmerPMzPk1mJVowm8KgmoknWa4yCYvvugMPsgWmDNUvDLW",
-      "name": "go-multihash",
-      "version": "1.0.9"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmekxXDhCxCJRNuzmHreuaT3BsuJcsjcXWNrtV9C8DRHtd",
-      "name": "go-multibase",
-      "version": "0.3.0"
-    }
-  ],
-  "gxVersion": "0.8.0",
-  "language": "go",
-  "license": "MIT",
-  "name": "go-cid",
-  "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
-  "version": "0.9.3"
-}
-

varint.go

@@ -1,6 +1,10 @@
 package cid
 
-// Version of varint function that work with a string rather than
+import (
+	"github.com/multiformats/go-varint"
+)
+
+// Version of varint function that works with a string rather than
 // []byte to avoid unnecessary allocation
 
 // Copyright 2011 The Go Authors. All rights reserved.
@@ -8,27 +12,26 @@ package cid
 // 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) {
+// number of bytes read (> 0). If an error occurred, then 0 is
+// returned for both the value and the number of bytes read, and an
+// error is returned.
+func uvarint(buf string) (uint64, int, error) {
 	var x uint64
 	var s uint
-	// we have a binary string so we can't use a range loope
+	// we have a binary string so we can't use a range loop
 	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 0, 0, varint.ErrOverflow
 			}
-			return x | uint64(b)<<s, i + 1
+			if b == 0 && i > 0 {
+				return 0, 0, varint.ErrNotMinimal
+			}
+			return x | uint64(b)<<s, i + 1, nil
 		}
 		x |= uint64(b&0x7f) << s
 		s += 7
 	}
-	return 0, 0
+	return 0, 0, varint.ErrUnderflow
 }

varint_test.go

@@ -1,17 +1,25 @@
 package cid
 
 import (
-	"encoding/binary"
 	"testing"
+
+	"github.com/multiformats/go-varint"
 )
 
 func TestUvarintRoundTrip(t *testing.T) {
 	testCases := []uint64{0, 1, 2, 127, 128, 129, 255, 256, 257, 1<<63 - 1}
 	for _, tc := range testCases {
+		t.Log("testing", tc)
 		buf := make([]byte, 16)
-		binary.PutUvarint(buf, tc)
-		v, l1 := uvarint(string(buf))
-		_, l2 := binary.Uvarint(buf)
+		varint.PutUvarint(buf, tc)
+		v, l1, err := uvarint(string(buf))
+		if err != nil {
+			t.Fatalf("%v: %s", buf, err)
+		}
+		_, l2, err := varint.FromUvarint(buf)
+		if err != nil {
+			t.Fatal(err)
+		}
 		if tc != v {
 			t.Errorf("roundtrip failed expected %d but got %d", tc, v)
 		}
@@ -20,3 +28,29 @@ func TestUvarintRoundTrip(t *testing.T) {
 		}
 	}
 }
+
+func TestUvarintEdges(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []byte
+		want  error
+	}{
+		{"ErrNotMinimal", []byte{0x01 | 0x80, 0}, varint.ErrNotMinimal},
+		{"ErrOverflow", []byte{0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01}, varint.ErrOverflow},
+		{"ErrUnderflow", []byte{0x80}, varint.ErrUnderflow},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			v, l1, err := uvarint(string(test.input))
+			if err != test.want {
+				t.Fatalf("error case (%v) should return varint.%s (got: %v)", test.input, test.name, err)
+			}
+			if v != 0 {
+				t.Fatalf("error case (%v) should return 0 value (got %d)", test.input, v)
+			}
+			if l1 != 0 {
+				t.Fatalf("error case (%v) should return 0 length (got %d)", test.input, l1)
+			}
+		})
+	}
+}