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.
2021-04-07 12:45:16 -07:00
22 changed files with 333 additions and 674 deletions
--- a/.github/workflows/automerge.yml
+++ b/.github/workflows/automerge.yml
@@ -1,11 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-name: Automerge
-on: [ pull_request ]
-
-jobs:
-  automerge:
-    uses: protocol/.github/.github/workflows/automerge.yml@master
-    with:
-      job: 'automerge'
--- a/.github/workflows/go-check.yml
+++ b/.github/workflows/go-check.yml
@@ -1,67 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-on: [push, pull_request]
-name: Go Checks
-
-jobs:
-  unit:
-    runs-on: ubuntu-latest
-    name: All
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - id: config
-        uses: protocol/.github/.github/actions/read-config@master
-      - uses: actions/setup-go@v3
-        with:
-          go-version: 1.20.x
-      - name: Run repo-specific setup
-        uses: ./.github/actions/go-check-setup
-        if: hashFiles('./.github/actions/go-check-setup') != ''
-      - name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@4970552d932f48b71485287748246cf3237cebdf # 2023.1 (v0.4.0)
-      - name: Check that go.mod is tidy
-        uses: protocol/multiple-go-modules@v1.2
-        with:
-          run: |
-            go mod tidy
-            if [[ -n $(git ls-files --other --exclude-standard --directory -- go.sum) ]]; then
-              echo "go.sum was added by go mod tidy"
-              exit 1
-            fi
-            git diff --exit-code -- go.sum go.mod
-      - name: gofmt
-        if: success() || failure() # run this step even if the previous one failed
-        run: |
-          out=$(gofmt -s -l .)
-          if [[ -n "$out" ]]; then
-            echo $out | awk '{print "::error file=" $0 ",line=0,col=0::File is not gofmt-ed."}'
-            exit 1
-          fi
-      - name: go vet
-        if: success() || failure() # run this step even if the previous one failed
-        uses: protocol/multiple-go-modules@v1.2
-        with:
-          run: go vet ./...
-      - name: staticcheck
-        if: success() || failure() # run this step even if the previous one failed
-        uses: protocol/multiple-go-modules@v1.2
-        with:
-          run: |
-            set -o pipefail
-            staticcheck ./... | sed -e 's@\(.*\)\.go@./\1.go@g'
-      - name: go generate
-        uses: protocol/multiple-go-modules@v1.2
-        if: (success() || failure()) && fromJSON(steps.config.outputs.json).gogenerate == true
-        with:
-          run: |
-            git clean -fd # make sure there aren't untracked files / directories
-            go generate -x ./...
-            # check if go generate modified or added any files
-            if ! $(git add . && git diff-index HEAD --exit-code --quiet); then
-              echo "go generated caused changes to the repository:"
-              git status --short
-              exit 1
-            fi
--- a/.github/workflows/go-test.yml
+++ b/.github/workflows/go-test.yml
@@ -1,76 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-on: [push, pull_request]
-name: Go Test
-
-jobs:
-  unit:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ "ubuntu", "windows", "macos" ]
-        go: ["1.19.x","1.20.x"]
-    env:
-      COVERAGES: ""
-    runs-on: ${{ fromJSON(vars[format('UCI_GO_TEST_RUNNER_{0}', matrix.os)] || format('"{0}-latest"', matrix.os)) }}
-    name: ${{ matrix.os }} (go ${{ matrix.go }})
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - id: config
-        uses: protocol/.github/.github/actions/read-config@master
-      - uses: actions/setup-go@v3
-        with:
-          go-version: ${{ matrix.go }}
-      - name: Go information
-        run: |
-          go version
-          go env
-      - name: Use msys2 on windows
-        if: matrix.os == 'windows'
-        shell: bash
-        # The executable for msys2 is also called bash.cmd
-        #   https://github.com/actions/virtual-environments/blob/main/images/win/Windows2019-Readme.md#shells
-        # If we prepend its location to the PATH
-        #   subsequent 'shell: bash' steps will use msys2 instead of gitbash
-        run: echo "C:/msys64/usr/bin" >> $GITHUB_PATH
-      - name: Run repo-specific setup
-        uses: ./.github/actions/go-test-setup
-        if: hashFiles('./.github/actions/go-test-setup') != ''
-      - name: Run tests
-        if: contains(fromJSON(steps.config.outputs.json).skipOSes, matrix.os) == false
-        uses: protocol/multiple-go-modules@v1.2
-        with:
-          # Use -coverpkg=./..., so that we include cross-package coverage.
-          # If package ./A imports ./B, and ./A's tests also cover ./B,
-          # this means ./B's coverage will be significantly higher than 0%.
-          run: go test -v -shuffle=on -coverprofile=module-coverage.txt -coverpkg=./... ./...
-      - name: Run tests (32 bit)
-        # can't run 32 bit tests on OSX.
-        if: matrix.os != 'macos' &&
-          fromJSON(steps.config.outputs.json).skip32bit != true &&
-          contains(fromJSON(steps.config.outputs.json).skipOSes, matrix.os) == false
-        uses: protocol/multiple-go-modules@v1.2
-        env:
-          GOARCH: 386
-        with:
-          run: |
-            export "PATH=$PATH_386:$PATH"
-            go test -v -shuffle=on ./...
-      - name: Run tests with race detector
-        # speed things up. Windows and OSX VMs are slow
-        if: matrix.os == 'ubuntu' &&
-          contains(fromJSON(steps.config.outputs.json).skipOSes, matrix.os) == false
-        uses: protocol/multiple-go-modules@v1.2
-        with:
-          run: go test -v -race ./...
-      - name: Collect coverage files
-        shell: bash
-        run: echo "COVERAGES=$(find . -type f -name 'module-coverage.txt' | tr -s '\n' ',' | sed 's/,$//')" >> $GITHUB_ENV
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@d9f34f8cd5cb3b3eb79b3e4b5dae3a16df499a70 # v3.1.1
-        with:
-          files: '${{ env.COVERAGES }}'
-          env_vars: OS=${{ matrix.os }}, GO=${{ matrix.go }}
--- a/.github/workflows/release-check.yml
+++ b/.github/workflows/release-check.yml
@@ -1,13 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-name: Release Checker
-on:
-  pull_request_target:
-    paths: [ 'version.json' ]
-
-jobs:
-  release-check:
-    uses: protocol/.github/.github/workflows/release-check.yml@master
-    with:
-      go-version: 1.20.x
--- a/.github/workflows/releaser.yml
+++ b/.github/workflows/releaser.yml
@@ -1,11 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-name: Releaser
-on:
-  push:
-    paths: [ 'version.json' ]
-
-jobs:
-  releaser:
-    uses: protocol/.github/.github/workflows/releaser.yml@master
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -1,26 +0,0 @@
-name: Close and mark stale issue
-
-on:
-  schedule:
-  - cron: '0 0 * * *'
-
-jobs:
-  stale:
-
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-
-    steps:
-    - uses: actions/stale@v3
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'Oops, seems like we needed more information for this issue, please comment with more details or this issue will be closed in 7 days.'
-        close-issue-message: 'This issue was closed because it is missing author input.'
-        stale-issue-label: 'kind/stale'
-        any-of-labels: 'need/author-input'
-        exempt-issue-labels: 'need/triage,need/community-input,need/maintainer-input,need/maintainers-input,need/analysis,status/blocked,status/in-progress,status/ready,status/deferred,status/inactive'
-        days-before-issue-stale: 6
-        days-before-issue-close: 7
-        enable-statistics: true
--- a/.github/workflows/tagpush.yml
+++ b/.github/workflows/tagpush.yml
@@ -1,12 +0,0 @@
-# File managed by web3-bot. DO NOT EDIT.
-# See https://github.com/protocol/.github/ for details.
-
-name: Tag Push Checker
-on:
-  push:
-    tags:
-      - v*
-
-jobs:
-  releaser:
-    uses: protocol/.github/.github/workflows/tagpush.yml@master
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,30 @@
+os:
+  - linux
+
+language: go
+
+go:
+  - 1.11.x
+
+env:
+  global:
+    - GOTFLAGS="-race"
+  matrix:
+    - BUILD_DEPTYPE=gomod
+
+
+# disable travis install
+install:
+  - true
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+
+cache:
+  directories:
+    - $GOPATH/pkg/mod
+    - $HOME/.cache/go-build
+
+notifications:
+  email: false
--- a/README.md
+++ b/README.md
@@ -59,17 +59,10 @@ fmt.Println("Got CID: ", c)
 #### Creating a CID from scratch

 ```go
-
-import (
-  cid "github.com/ipfs/go-cid"
-  mc "github.com/multiformats/go-multicodec"
-  mh "github.com/multiformats/go-multihash"
-)
-
 // Create a cid manually by specifying the 'prefix' parameters
 pref := cid.Prefix{
 	Version: 1,
-	Codec: uint64(mc.Raw),
+	Codec: cid.Raw,
 	MhType: mh.SHA2_256,
 	MhLength: -1, // default length
 }
@@ -95,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) {
--- a/_rsrch/cidiface/cid.go
+++ b/_rsrch/cidiface/cid.go
@@ -39,8 +39,7 @@ type Cid interface {
 // and the Multihash length. It does not contains
 // any actual content information.
 // NOTE: The use -1 in MhLength to mean default length is deprecated,
-//
-//	use the V0Builder or V1Builder structures instead
+//   use the V0Builder or V1Builder structures instead
 type Prefix struct {
 	Version  uint64
 	Codec    uint64
--- a/_rsrch/cidiface/cidBoxingBench_test.go
+++ b/_rsrch/cidiface/cidBoxingBench_test.go
@@ -12,14 +12,14 @@ import (
 //
 // Sample results on linux amd64 go1.11beta:
 //
-//	BenchmarkCidMap_CidStr-8          100000             16317 ns/op
-//	BenchmarkCidMap_CidIface-8        100000             20516 ns/op
+//   BenchmarkCidMap_CidStr-8          100000             16317 ns/op
+//   BenchmarkCidMap_CidIface-8        100000             20516 ns/op
 //
 // With benchmem on:
 //
-//	BenchmarkCidMap_CidStr-8          100000             15579 ns/op           11223 B/op        207 allocs/op
-//	BenchmarkCidMap_CidIface-8        100000             19500 ns/op           12824 B/op        307 allocs/op
-//	BenchmarkCidMap_StrPlusHax-8      200000             10451 ns/op            7589 B/op        202 allocs/op
+//   BenchmarkCidMap_CidStr-8          100000             15579 ns/op           11223 B/op        207 allocs/op
+//   BenchmarkCidMap_CidIface-8        100000             19500 ns/op           12824 B/op        307 allocs/op
+//   BenchmarkCidMap_StrPlusHax-8      200000             10451 ns/op            7589 B/op        202 allocs/op
 //
 // We can see here that the impact of interface boxing is significant:
 // it increases the time taken to do the inserts to 133%, largely because
@@ -36,6 +36,7 @@ import (
 // re-arranges itself, it involves more or less an O(n) copy of the content
 // in addition to the alloc itself).  This isn't topical to the question of
 // whether or not interfaces are a good idea; just for contextualizing.
+//
 func BenchmarkCidMap_CidStr(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		mp := map[CidStr]int{}
--- a/_rsrch/cidiface/cidString.go
+++ b/_rsrch/cidiface/cidString.go
@@ -114,7 +114,7 @@ func NewCidStr(version uint64, codecType uint64, mhash mh.Multihash) CidStr {
 //
 // For CidV1, the data buffer is in the form:
 //
-//	<version><codec-type><multihash>
+//     <version><codec-type><multihash>
 //
 // CidV0 are also supported. In particular, data buffers starting
 // with length 34 bytes, which starts with bytes [18,32...] are considered
--- a/_rsrch/cidiface/cidStruct.go
+++ b/_rsrch/cidiface/cidStruct.go
@@ -110,7 +110,7 @@ func (c CidStruct) Prefix() Prefix {
 //
 // For CidV1, the data buffer is in the form:
 //
-//	<version><codec-type><multihash>
+//     <version><codec-type><multihash>
 //
 // CidV0 are also supported. In particular, data buffers starting
 // with length 34 bytes, which starts with bytes [18,32...] are considered
--- a/benchmark_test.go
+++ b/benchmark_test.go
@@ -1,61 +0,0 @@
-package cid_test
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
-)
-
-// BenchmarkIdentityCheck benchmarks two ways of checking whether a CIDv1 has multihash.IDENTITY
-// code:
-//  1. Cid.Prefix(), and
-//  2. decoding the Cid.Hash().
-//
-// This benchmark illustrates that using Cid.Prefix is more efficient than multihash.Decode.
-// Users wishing to perform such a check should use Cid.Prefix.
-//
-// Consider that `Cid.Prefix` is already efficient enough and introducing a dedicated API for
-// performing this check will likely result in small gains.
-func BenchmarkIdentityCheck(b *testing.B) {
-	rng := rand.New(rand.NewSource(1413))
-
-	data := make([]byte, rng.Intn(100)+1024)
-	if _, err := rng.Read(data); err != nil {
-		b.Fatal(err)
-	}
-	mh, err := multihash.Sum(data, multihash.IDENTITY, -1)
-	if err != nil {
-		b.Fatal(err)
-	}
-	cv1 := cid.NewCidV1(cid.Raw, mh)
-
-	b.SetBytes(int64(cv1.ByteLen()))
-	b.ReportAllocs()
-	b.ResetTimer()
-
-	b.Run("Prefix", func(b *testing.B) {
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				if cv1.Prefix().MhType != multihash.IDENTITY {
-					b.Fatal("expected IDENTITY CID")
-				}
-			}
-		})
-	})
-
-	b.Run("MultihashDecode", func(b *testing.B) {
-		b.RunParallel(func(pb *testing.PB) {
-			for pb.Next() {
-				dmh, err := multihash.Decode(cv1.Hash())
-				if err != nil {
-					b.Fatal(err)
-				}
-				if dmh.Code != multihash.IDENTITY {
-					b.Fatal("expected IDENTITY CID")
-				}
-			}
-		})
-	})
-}
--- a/builder.go
+++ b/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
 }
--- a/builder_test.go
+++ b/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 {
--- a/cid.go
+++ b/cid.go
@@ -10,7 +10,7 @@
 //
 // A CIDv1 has four parts:
 //
-//	<cidv1> ::= <multibase-prefix><cid-version><multicodec-packed-content-type><multihash-content-address>
+//     <cidv1> ::= <multibase-prefix><cid-version><multicodec-packed-content-type><multihash-content-address>
 //
 // As shown above, the CID implementation relies heavily on Multiformats,
 // particularly Multibase
@@ -22,7 +22,6 @@ package cid
 import (
 	"bytes"
 	"encoding"
-	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -37,53 +36,29 @@ import (
 // UnsupportedVersionString just holds an error message
 const UnsupportedVersionString = "<unsupported cid version>"

-// ErrInvalidCid is an error that indicates that a CID is invalid.
-type ErrInvalidCid struct {
-	Err error
-}
-
-func (e ErrInvalidCid) Error() string {
-	return fmt.Sprintf("invalid cid: %s", e.Err)
-}
-
-func (e ErrInvalidCid) Unwrap() error {
-	return e.Err
-}
-
-func (e ErrInvalidCid) Is(err error) bool {
-	switch err.(type) {
-	case ErrInvalidCid, *ErrInvalidCid:
-		return true
-	default:
-		return false
-	}
-}
-
 var (
 	// ErrCidTooShort means that the cid passed to decode was not long
 	// enough to be a valid Cid
-	ErrCidTooShort = ErrInvalidCid{errors.New("cid too short")}
+	ErrCidTooShort = errors.New("cid too short")

 	// ErrInvalidEncoding means that selected encoding is not supported
 	// by this Cid version
 	ErrInvalidEncoding = errors.New("invalid base encoding")
 )

-// Consts below are DEPRECATED and left only for legacy reasons:
-// <https://github.com/ipfs/go-cid/pull/137>
-// Modern code should use consts from go-multicodec instead:
-// <https://github.com/multiformats/go-multicodec>
+// These are multicodec-packed content types. The should match
+// the codes described in the authoritative document:
+// https://github.com/multiformats/multicodec/blob/master/table.csv
 const (
-	// common ones
-	Raw         = 0x55
-	DagProtobuf = 0x70   // https://ipld.io/docs/codecs/known/dag-pb/
-	DagCBOR     = 0x71   // https://ipld.io/docs/codecs/known/dag-cbor/
-	DagJSON     = 0x0129 // https://ipld.io/docs/codecs/known/dag-json/
-	Libp2pKey   = 0x72   // https://github.com/libp2p/specs/blob/master/peer-ids/peer-ids.md#peer-ids
+	Raw = 0x55

-	// other
-	GitRaw                = 0x78
-	DagJOSE               = 0x85 // https://ipld.io/specs/codecs/dag-jose/spec/
+	DagProtobuf = 0x70
+	DagCBOR     = 0x71
+	Libp2pKey   = 0x72
+
+	GitRaw = 0x78
+
+	DagJOSE               = 0x85
 	EthBlock              = 0x90
 	EthBlockList          = 0x91
 	EthTxTrie             = 0x92
@@ -105,6 +80,64 @@ const (
 	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,
+	"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",
+	FilCommitmentUnsealed: "fil-commitment-unsealed",
+	FilCommitmentSealed:   "fil-commitment-sealed",
+	DagJOSE:               "dag-jose",
+}
+
 // tryNewCidV0 tries to convert a multihash into a CIDv0 CID and returns an
 // error on failure.
 func tryNewCidV0(mhash mh.Multihash) (Cid, error) {
@@ -112,10 +145,10 @@ func tryNewCidV0(mhash mh.Multihash) (Cid, error) {
 	// incorrectly detect it as CidV1 in the Version() method
 	dec, err := mh.Decode(mhash)
 	if err != nil {
-		return Undef, ErrInvalidCid{err}
+		return Undef, err
 	}
 	if dec.Code != mh.SHA2_256 || dec.Length != 32 {
-		return Undef, ErrInvalidCid{fmt.Errorf("invalid hash for cidv0 %d-%d", dec.Code, dec.Length)}
+		return Undef, fmt.Errorf("invalid hash for cidv0 %d-%d", dec.Code, dec.Length)
 	}
 	return Cid{string(mhash)}, nil
 }
@@ -140,32 +173,22 @@ func NewCidV0(mhash mh.Multihash) Cid {
 // Panics if the multihash is invalid.
 func NewCidV1(codecType uint64, mhash mh.Multihash) Cid {
 	hashlen := len(mhash)
-
-	// Two 8 bytes (max) numbers plus hash.
-	// We use strings.Builder to only allocate once.
-	var b strings.Builder
-	b.Grow(1 + varint.UvarintSize(codecType) + hashlen)
-
-	b.WriteByte(1)
-
-	var buf [binary.MaxVarintLen64]byte
-	n := varint.PutUvarint(buf[:], codecType)
-	b.Write(buf[:n])
-
-	cn, _ := b.Write(mhash)
+	// two 8 bytes (max) numbers plus hash
+	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")
 	}

-	return Cid{b.String()}
+	return Cid{string(buf[:n+hashlen])}
 }

-var (
-	_ encoding.BinaryMarshaler   = Cid{}
-	_ encoding.BinaryUnmarshaler = (*Cid)(nil)
-	_ encoding.TextMarshaler     = Cid{}
-	_ encoding.TextUnmarshaler   = (*Cid)(nil)
-)
+var _ encoding.BinaryMarshaler = Cid{}
+var _ encoding.BinaryUnmarshaler = (*Cid)(nil)
+var _ encoding.TextMarshaler = Cid{}
+var _ encoding.TextUnmarshaler = (*Cid)(nil)

 // Cid represents a self-describing content addressed
 // identifier. It is formed by a Version, a Codec (which indicates
@@ -199,23 +222,14 @@ func Parse(v interface{}) (Cid, error) {
 	case Cid:
 		return v2, nil
 	default:
-		return Undef, ErrInvalidCid{fmt.Errorf("can't parse %+v as Cid", v2)}
+		return Undef, fmt.Errorf("can't parse %+v as Cid", v2)
 	}
 }

-// MustParse calls Parse but will panic on error.
-func MustParse(v interface{}) Cid {
-	c, err := Parse(v)
-	if err != nil {
-		panic(err)
-	}
-	return c
-}
-
 // Decode parses a Cid-encoded string and returns a Cid object.
 // For CidV1, a Cid-encoded string is primarily a multibase string:
 //
-//	<multibase-type-code><base-encoded-string>
+//     <multibase-type-code><base-encoded-string>
 //
 // The base-encoded string represents a:
 //
@@ -232,7 +246,7 @@ func Decode(v string) (Cid, error) {
 	if len(v) == 46 && v[:2] == "Qm" {
 		hash, err := mh.FromB58String(v)
 		if err != nil {
-			return Undef, ErrInvalidCid{err}
+			return Undef, err
 		}

 		return tryNewCidV0(hash)
@@ -240,7 +254,7 @@ func Decode(v string) (Cid, error) {

 	_, data, err := mbase.Decode(v)
 	if err != nil {
-		return Undef, ErrInvalidCid{err}
+		return Undef, err
 	}

 	return Cast(data)
@@ -262,7 +276,7 @@ func ExtractEncoding(v string) (mbase.Encoding, error) {
 	// check encoding is valid
 	_, err := mbase.NewEncoder(encoding)
 	if err != nil {
-		return -1, ErrInvalidCid{err}
+		return -1, err
 	}

 	return encoding, nil
@@ -271,7 +285,7 @@ func ExtractEncoding(v string) (mbase.Encoding, error) {
 // Cast takes a Cid data slice, parses it and returns a Cid.
 // For CidV1, the data buffer is in the form:
 //
-//	<version><codec-type><multihash>
+//     <version><codec-type><multihash>
 //
 // CidV0 are also supported. In particular, data buffers starting
 // with length 34 bytes, which starts with bytes [18,32...] are considered
@@ -282,11 +296,11 @@ func ExtractEncoding(v string) (mbase.Encoding, error) {
 func Cast(data []byte) (Cid, error) {
 	nr, c, err := CidFromBytes(data)
 	if err != nil {
-		return Undef, ErrInvalidCid{err}
+		return Undef, err
 	}

 	if nr != len(data) {
-		return Undef, ErrInvalidCid{fmt.Errorf("trailing bytes in data buffer passed to cid Cast")}
+		return Undef, fmt.Errorf("trailing bytes in data buffer passed to cid Cast")
 	}

 	return c, nil
@@ -400,13 +414,7 @@ func (c Cid) Hash() mh.Multihash {
 // Bytes returns the byte representation of a Cid.
 // The output of bytes can be parsed back into a Cid
 // with Cast().
-//
-// If c.Defined() == false, it return a nil slice and may not
-// be parsable with Cast().
 func (c Cid) Bytes() []byte {
-	if !c.Defined() {
-		return nil
-	}
 	return []byte(c.str)
 }

@@ -487,7 +495,7 @@ func (c *Cid) UnmarshalJSON(b []byte) error {

 // MarshalJSON procudes a JSON representation of a Cid, which looks as follows:
 //
-//	{ "/": "<cid-string>" }
+//    { "/": "<cid-string>" }
 //
 // Note that this formatting comes from the IPLD specification
 // (https://github.com/ipld/specs/tree/master/ipld)
@@ -544,8 +552,7 @@ func (c Cid) Prefix() Prefix {
 // and the Multihash length. It does not contains
 // any actual content information.
 // NOTE: The use -1 in MhLength to mean default length is deprecated,
-//
-//	use the V0Builder or V1Builder structures instead
+//   use the V0Builder or V1Builder structures instead
 type Prefix struct {
 	Version  uint64
 	Codec    uint64
@@ -557,7 +564,7 @@ type Prefix struct {
 // and return a newly constructed Cid with the resulting multihash.
 func (p Prefix) Sum(data []byte) (Cid, error) {
 	length := p.MhLength
-	if p.MhType == mh.IDENTITY {
+	if p.MhType == mh.ID {
 		length = -1
 	}

@@ -582,9 +589,39 @@ 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>
+//     <version><codec><mh-type><mh-length>
 func (p Prefix) Bytes() []byte {
 	size := varint.UvarintSize(p.Version)
 	size += varint.UvarintSize(p.Codec)
@@ -637,12 +674,12 @@ func PrefixFromBytes(buf []byte) (Prefix, error) {
 func CidFromBytes(data []byte) (int, Cid, error) {
 	if len(data) > 2 && data[0] == mh.SHA2_256 && data[1] == 32 {
 		if len(data) < 34 {
-			return 0, Undef, ErrInvalidCid{fmt.Errorf("not enough bytes for cid v0")}
+			return 0, Undef, fmt.Errorf("not enough bytes for cid v0")
 		}

 		h, err := mh.Cast(data[:34])
 		if err != nil {
-			return 0, Undef, ErrInvalidCid{err}
+			return 0, Undef, err
 		}

 		return 34, Cid{string(h)}, nil
@@ -650,160 +687,24 @@ func CidFromBytes(data []byte) (int, Cid, error) {

 	vers, n, err := varint.FromUvarint(data)
 	if err != nil {
-		return 0, Undef, ErrInvalidCid{err}
+		return 0, Undef, err
 	}

 	if vers != 1 {
-		return 0, Undef, ErrInvalidCid{fmt.Errorf("expected 1 as the cid version number, got: %d", vers)}
+		return 0, Undef, fmt.Errorf("expected 1 as the cid version number, got: %d", vers)
 	}

 	_, cn, err := varint.FromUvarint(data[n:])
 	if err != nil {
-		return 0, Undef, ErrInvalidCid{err}
+		return 0, Undef, err
 	}

 	mhnr, _, err := mh.MHFromBytes(data[n+cn:])
 	if err != nil {
-		return 0, Undef, ErrInvalidCid{err}
+		return 0, Undef, err
 	}

 	l := n + cn + mhnr

 	return l, Cid{string(data[0:l])}, nil
 }
-
-func toBufByteReader(r io.Reader, dst []byte) *bufByteReader {
-	// If the reader already implements ByteReader, use it directly.
-	// Otherwise, use a fallback that does 1-byte Reads.
-	if br, ok := r.(io.ByteReader); ok {
-		return &bufByteReader{direct: br, dst: dst}
-	}
-	return &bufByteReader{fallback: r, dst: dst}
-}
-
-type bufByteReader struct {
-	direct   io.ByteReader
-	fallback io.Reader
-
-	dst []byte
-}
-
-func (r *bufByteReader) ReadByte() (byte, error) {
-	// The underlying reader has ReadByte; use it.
-	if br := r.direct; br != nil {
-		b, err := br.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		r.dst = append(r.dst, b)
-		return b, nil
-	}
-
-	// Fall back to a one-byte Read.
-	// TODO: consider reading straight into dst,
-	// once we have benchmarks and if they prove that to be faster.
-	var p [1]byte
-	if _, err := io.ReadFull(r.fallback, p[:]); err != nil {
-		return 0, err
-	}
-	r.dst = append(r.dst, p[0])
-	return p[0], nil
-}
-
-// CidFromReader reads a precise number of bytes for a CID from a given reader.
-// It returns the number of bytes read, the CID, and any error encountered.
-// The number of bytes read is accurate even if a non-nil error is returned.
-//
-// It's recommended to supply a reader that buffers and implements io.ByteReader,
-// as CidFromReader has to do many single-byte reads to decode varints.
-// If the argument only implements io.Reader, single-byte Read calls are used instead.
-func CidFromReader(r io.Reader) (int, Cid, error) {
-	// 64 bytes is enough for any CIDv0,
-	// and it's enough for most CIDv1s in practice.
-	// If the digest is too long, we'll allocate more.
-	br := toBufByteReader(r, make([]byte, 0, 64))
-
-	// We read the first varint, to tell if this is a CIDv0 or a CIDv1.
-	// The varint package wants a io.ByteReader, so we must wrap our io.Reader.
-	vers, err := varint.ReadUvarint(br)
-	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
-	}
-
-	// If we have a CIDv0, read the rest of the bytes and cast the buffer.
-	if vers == mh.SHA2_256 {
-		if n, err := io.ReadFull(r, br.dst[1:34]); err != nil {
-			return len(br.dst) + n, Undef, ErrInvalidCid{err}
-		}
-
-		br.dst = br.dst[:34]
-		h, err := mh.Cast(br.dst)
-		if err != nil {
-			return len(br.dst), Undef, ErrInvalidCid{err}
-		}
-
-		return len(br.dst), Cid{string(h)}, nil
-	}
-
-	if vers != 1 {
-		return len(br.dst), Undef, ErrInvalidCid{fmt.Errorf("expected 1 as the cid version number, got: %d", vers)}
-	}
-
-	// CID block encoding multicodec.
-	_, err = varint.ReadUvarint(br)
-	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
-	}
-
-	// We could replace most of the code below with go-multihash's ReadMultihash.
-	// Note that it would save code, but prevent reusing buffers.
-	// Plus, we already have a ByteReader now.
-	mhStart := len(br.dst)
-
-	// Multihash hash function code.
-	_, err = varint.ReadUvarint(br)
-	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
-	}
-
-	// Multihash digest length.
-	mhl, err := varint.ReadUvarint(br)
-	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
-	}
-
-	// Refuse to make large allocations to prevent OOMs due to bugs.
-	const maxDigestAlloc = 32 << 20 // 32MiB
-	if mhl > maxDigestAlloc {
-		return len(br.dst), Undef, ErrInvalidCid{fmt.Errorf("refusing to allocate %d bytes for a digest", mhl)}
-	}
-
-	// Fine to convert mhl to int, given maxDigestAlloc.
-	prefixLength := len(br.dst)
-	cidLength := prefixLength + int(mhl)
-	if cidLength > cap(br.dst) {
-		// If the multihash digest doesn't fit in our initial 64 bytes,
-		// efficiently extend the slice via append+make.
-		br.dst = append(br.dst, make([]byte, cidLength-len(br.dst))...)
-	} else {
-		// The multihash digest fits inside our buffer,
-		// so just extend its capacity.
-		br.dst = br.dst[:cidLength]
-	}
-
-	if n, err := io.ReadFull(r, br.dst[prefixLength:cidLength]); err != nil {
-		// We can't use len(br.dst) here,
-		// as we've only read n bytes past prefixLength.
-		return prefixLength + n, Undef, ErrInvalidCid{err}
-	}
-
-	// This simply ensures the multihash is valid.
-	// TODO: consider removing this bit, as it's probably redundant;
-	// for now, it helps ensure consistency with CidFromBytes.
-	_, _, err = mh.MHFromBytes(br.dst[mhStart:])
-	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
-	}
-
-	return len(br.dst), Cid{string(br.dst)}, nil
-}
--- a/cid_fuzz.go
+++ b/cid_fuzz.go
@@ -1,9 +1,10 @@
-//go:build gofuzz
+// +build gofuzz

 package cid

 func Fuzz(data []byte) int {
 	cid, err := Cast(data)
+
 	if err != nil {
 		return 0
 	}
--- a/cid_test.go
+++ b/cid_test.go
@@ -2,21 +2,48 @@ package cid

 import (
 	"bytes"
-	crand "crypto/rand"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"math/rand"
 	"reflect"
 	"strings"
 	"testing"
-	"testing/iotest"

 	mbase "github.com/multiformats/go-multibase"
 	mh "github.com/multiformats/go-multihash"
 )

+// Copying the "silly test" idea from
+// 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",
+	FilCommitmentUnsealed: "fil-commitment-unsealed",
+	FilCommitmentSealed:   "fil-commitment-sealed",
+	DagJOSE:               "dag-jose",
+}
+
 func assertEqual(t *testing.T, a, b Cid) {
 	if a.Type() != b.Type() {
 		t.Fatal("mismatch on type")
@@ -31,11 +58,31 @@ func assertEqual(t *testing.T, a, b Cid) {
 	}
 }

+func TestTable(t *testing.T) {
+	if len(tCodecs) != len(Codecs)-1 {
+		t.Errorf("Item count mismatch in the Table of Codec. Should be %d, got %d", len(tCodecs)+1, len(Codecs))
+	}
+
+	for k, v := range tCodecs {
+		if Codecs[v] != k {
+			t.Errorf("Table mismatch: 0x%x %s", k, v)
+		}
+	}
+}
+
+// The table returns cid.DagProtobuf for "v0"
+// so we test it apart
+func TestTableForV0(t *testing.T) {
+	if Codecs["v0"] != DagProtobuf {
+		t.Error("Table mismatch: Codecs[\"v0\"] should resolve to DagProtobuf (0x70)")
+	}
+}
+
 func TestPrefixSum(t *testing.T) {
 	// Test creating CIDs both manually and with Prefix.
 	// Tests: https://github.com/ipfs/go-cid/issues/83
 	for _, hashfun := range []uint64{
-		mh.IDENTITY, mh.SHA3, mh.SHA2_256,
+		mh.ID, mh.SHA3, mh.SHA2_256,
 	} {
 		h1, err := mh.Sum([]byte("TEST"), hashfun, -1)
 		if err != nil {
@@ -228,9 +275,6 @@ func TestEmptyString(t *testing.T) {
 	if err == nil {
 		t.Fatal("shouldnt be able to parse an empty cid")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("error must be ErrInvalidCid")
-	}
 }

 func TestV0Handling(t *testing.T) {
@@ -286,9 +330,6 @@ func TestV0ErrorCases(t *testing.T) {
 	if err == nil {
 		t.Fatal("should have failed to decode that ref")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("error must be ErrInvalidCid")
-	}
 }

 func TestNewPrefixV1(t *testing.T) {
@@ -347,6 +388,7 @@ func TestNewPrefixV0(t *testing.T) {
 	if c1.Prefix() != c2.Prefix() {
 		t.Fatal("prefixes mismatch")
 	}
+
 }

 func TestInvalidV0Prefix(t *testing.T) {
@@ -449,7 +491,7 @@ func TestFuzzCid(t *testing.T) {
 	buf := make([]byte, 128)
 	for i := 0; i < 200; i++ {
 		s := rand.Intn(128)
-		crand.Read(buf[:s])
+		rand.Read(buf[:s])
 		_, _ = Cast(buf[:s])
 	}
 }
@@ -462,9 +504,6 @@ func TestParse(t *testing.T) {
 	if !strings.Contains(err.Error(), "can't parse 123 as Cid") {
 		t.Fatalf("expected int error, got %s", err.Error())
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatalf("expected ErrInvalidCid, got %s", err.Error())
-	}

 	theHash := "QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n"
 	h, err := mh.FromB58String(theHash)
@@ -473,13 +512,13 @@ func TestParse(t *testing.T) {
 	}

 	assertions := [][]interface{}{
-		{NewCidV0(h), theHash},
-		{NewCidV0(h).Bytes(), theHash},
-		{h, theHash},
-		{theHash, theHash},
-		{"/ipfs/" + theHash, theHash},
-		{"https://ipfs.io/ipfs/" + theHash, theHash},
-		{"http://localhost:8080/ipfs/" + theHash, theHash},
+		[]interface{}{NewCidV0(h), theHash},
+		[]interface{}{NewCidV0(h).Bytes(), theHash},
+		[]interface{}{h, theHash},
+		[]interface{}{theHash, theHash},
+		[]interface{}{"/ipfs/" + theHash, theHash},
+		[]interface{}{"https://ipfs.io/ipfs/" + theHash, theHash},
+		[]interface{}{"http://localhost:8080/ipfs/" + theHash, theHash},
 	}

 	assert := func(arg interface{}, expected string) error {
@@ -627,7 +666,6 @@ func TestReadCidsFromBuffer(t *testing.T) {
 		"k2cwueckqkibutvhkr4p2ln2pjcaxaakpd9db0e7j7ax1lxhhxy3ekpv",
 		"Qmf5Qzp6nGBku7CEn2UQx4mgN8TW69YUok36DrGa6NN893",
 		"zb2rhZi1JR4eNc2jBGaRYJKYM8JEB4ovenym8L1CmFsRAytkz",
-		"bafkqarjpmzuwyzltorxxezjpkvcfgqkfjfbfcvslivje2vchkzdu6rckjjcfgtkolaze6mssjqzeyn2ekrcfatkjku2vowseky3fswkfkm2deqkrju3e2",
 	}

 	var cids []Cid
@@ -655,98 +693,51 @@ func TestReadCidsFromBuffer(t *testing.T) {
 	if cur != len(buf) {
 		t.Fatal("had trailing bytes")
 	}
-
-	// The same, but now with CidFromReader.
-	// In multiple forms, to catch more io interface bugs.
-	for _, r := range []io.Reader{
-		// implements io.ByteReader
-		bytes.NewReader(buf),
-
-		// tiny reads, no io.ByteReader
-		iotest.OneByteReader(bytes.NewReader(buf)),
-	} {
-		cur = 0
-		for _, expc := range cids {
-			n, c, err := CidFromReader(r)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if c != expc {
-				t.Fatal("cids mismatched")
-			}
-			cur += n
-		}
-		if cur != len(buf) {
-			t.Fatal("had trailing bytes")
-		}
-	}
 }

-func TestBadCidInput(t *testing.T) {
-	for _, name := range []string{
-		"FromBytes",
-		"FromReader",
-	} {
-		t.Run(name, func(t *testing.T) {
-			usingReader := name == "FromReader"
+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")
+	}

-			fromBytes := CidFromBytes
-			if usingReader {
-				fromBytes = func(data []byte) (int, Cid, error) {
-					return CidFromReader(bytes.NewReader(data))
-				}
-			}
+	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")
+	}

-			l, c, err := fromBytes([]byte{mh.SHA2_256, 32, 0x00})
-			if err == nil {
-				t.Fatal("expected not-enough-bytes for V0 CID")
-			}
-			if !usingReader && l != 0 {
-				t.Fatal("expected length==0 from bad CID")
-			} else if usingReader && l == 0 {
-				t.Fatal("expected length!=0 from bad CID")
-			}
-			if c != Undef {
-				t.Fatal("expected Undef CID from bad CID")
-			}
-
-			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 = fromBytes(byts)
-			if err == nil {
-				t.Fatal("expected not-enough-bytes for V1 CID")
-			}
-			if !usingReader && l != 0 {
-				t.Fatal("expected length==0 from bad CID")
-			} else if usingReader && l == 0 {
-				t.Fatal("expected length!=0 from bad CID")
-			}
-			if c != Undef {
-				t.Fatal("expected Undef CID from bad CID")
-			}
-
-			copy(byts, c.Bytes())
-			byts[2] = 0x80 // bad multihash varint
-			byts[3] = 0x00
-			l, c, err = fromBytes(byts)
-			if err == nil {
-				t.Fatal("expected not-enough-bytes for V1 CID")
-			}
-			if !usingReader && l != 0 {
-				t.Fatal("expected length==0 from bad CID")
-			} else if usingReader && l == 0 {
-				t.Fatal("expected length!=0 from bad CID")
-			}
-			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")
 	}
 }

@@ -759,9 +750,6 @@ func TestBadParse(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected to fail to parse an invalid CIDv1 CID")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("error must be ErrInvalidCid")
-	}
 }

 func TestLoggable(t *testing.T) {
@@ -776,15 +764,3 @@ func TestLoggable(t *testing.T) {
 		t.Fatalf("did not get expected loggable form (got %v)", actual)
 	}
 }
-
-func TestErrInvalidCid(t *testing.T) {
-	_, err := Decode("not-a-cid")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-
-	is := errors.Is(err, ErrInvalidCid{})
-	if !is {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
-}
--- a/go.mod
+++ b/go.mod
@@ -2,19 +2,8 @@ module github.com/ipfs/go-cid

 require (
 	github.com/multiformats/go-multibase v0.0.3
-	github.com/multiformats/go-multihash v0.0.15
+	github.com/multiformats/go-multihash v0.0.16-0.20210406191223-75ae3688857d
 	github.com/multiformats/go-varint v0.0.6
 )

-require (
-	github.com/klauspost/cpuid/v2 v2.0.4 // indirect
-	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 // indirect
-	github.com/minio/sha256-simd v1.0.0 // indirect
-	github.com/mr-tron/base58 v1.2.0 // indirect
-	github.com/multiformats/go-base32 v0.0.3 // indirect
-	github.com/multiformats/go-base36 v0.1.0 // indirect
-	golang.org/x/crypto v0.1.0 // indirect
-	golang.org/x/sys v0.1.0 // indirect
-)
-
-go 1.19
+go 1.15
--- a/go.sum
+++ b/go.sum
@@ -13,19 +13,17 @@ github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ8
 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.15 h1:hWOPdrNqDjwHDx82vsYGSDZNyktOJJ2dzZJzFkOV1jM=
-github.com/multiformats/go-multihash v0.0.15/go.mod h1:D6aZrWNLFTV/ynMpKsNtB40mJzmCl4jb1alC0OvHiHg=
+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-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU=
-golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
 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-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/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 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=
--- a/version.json
+++ b/version.json
@@ -1,3 +0,0 @@
-{
-  "version": "v0.3.2"
-}