avoid double alloc in NewCidV1

We allocate once via "make([]byte, len)",
and again when that buffer is converted to a string.

Thankfully, since Go 1.10 we have strings.Builder,
designed specifically for this use case.

In a downstream benchmark in go-car,
which needs to reconstruct many CID values,
we see small but nice gains:

    name           old time/op    new time/op    delta
    ReadBlocks-16    1.09ms ± 4%    1.06ms ± 5%   -3.33%  (p=0.007 n=11+11)

    name           old speed      new speed      delta
    ReadBlocks-16   478MB/s ± 4%   494MB/s ± 5%   +3.46%  (p=0.007 n=11+11)

    name           old alloc/op   new alloc/op   delta
    ReadBlocks-16    1.30MB ± 0%    1.25MB ± 0%   -3.86%  (p=0.000 n=12+12)

    name           old allocs/op  new allocs/op  delta
    ReadBlocks-16     9.50k ± 0%     8.45k ± 0%  -11.05%  (p=0.000 n=12+12)

.github/Repo.toml

@@ -1,7 +0,0 @@
-[scopes]
-ci = [".github/workflows"]
-config = [".github", "codecov.yml", "go.mod", "go.sum", "Makefile", "version.json"]
-docs = ["README.md", "LICENSE"]
-tests = ["*_test.go", "fuzz-data"]
-research = ["_rsrch"]
-core = ["cid.go", "builder.go", "set.go", "varint.go", "cid_fuzz.go", "deprecated.go"]

.github/dependabot.yml

@@ -1,8 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: gomod
-  directory: "/"
-  schedule:
-    interval: weekly
-    time: "11:00"
-  open-pull-requests-limit: 10

.github/workflows/automerge.yml

@@ -0,0 +1,53 @@
+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+# Automatically merge pull requests opened by web3-bot, as soon as (and only if) all tests pass.
+# This reduces the friction associated with updating with our workflows.
+
+on: [ pull_request ]
+name: Automerge
+
+jobs:
+  automerge-check:
+    if: github.event.pull_request.user.login == 'web3-bot'
+    runs-on: ubuntu-latest
+    outputs:
+      status: ${{ steps.should-automerge.outputs.status }}
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - name: Check if we should automerge
+      id: should-automerge
+      run: |
+        for commit in $(git rev-list --first-parent origin/${{ github.event.pull_request.base.ref }}..${{ github.event.pull_request.head.sha }}); do
+          committer=$(git show --format=$'%ce' -s $commit)
+          echo "Committer: $committer"
+          if [[ "$committer" != "web3-bot@users.noreply.github.com" ]]; then
+            echo "Commit $commit wasn't committed by web3-bot, but by $committer."
+            echo "::set-output name=status::false"
+            exit
+          fi
+        done
+        echo "::set-output name=status::true"
+  automerge:
+    needs: automerge-check
+    runs-on: ubuntu-latest
+    # The check for the user is redundant here, as this job depends on the automerge-check job,
+    # but it prevents this job from spinning up, just to be skipped shortly after.
+    if: github.event.pull_request.user.login == 'web3-bot' && needs.automerge-check.outputs.status == 'true'
+    steps:
+    - name: Wait on tests
+      uses: lewagon/wait-on-check-action@bafe56a6863672c681c3cf671f5e10b20abf2eaa # v0.2
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        wait-interval: 10
+        running-workflow-name: 'automerge' # the name of this job
+    - name: Merge PR
+      uses: pascalgn/automerge-action@741c311a47881be9625932b0a0de1b0937aab1ae # v0.13.1
+      env:
+        GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        MERGE_LABELS: ""
+        MERGE_METHOD: "squash"
+        MERGE_DELETE_BRANCH: true

.github/workflows/generated-pr.yml

@@ -1,14 +0,0 @@
-name: Close Generated PRs
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    uses: ipdxco/unified-github-workflows/.github/workflows/reusable-generated-pr.yml@v1

.github/workflows/go-check.yml

@@ -1,18 +1,74 @@
+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+on: [push, pull_request]
 name: Go Checks
 
-on:
-  pull_request:
-  push:
-    branches: ["master"]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'push' && github.sha || github.ref }}
-  cancel-in-progress: true
-
 jobs:
-  go-check:
+  unit:
-    uses: ipdxco/unified-github-workflows/.github/workflows/go-check.yml@v1.0
+    runs-on: ubuntu-latest
+    name: All
+    env:
+      RUNGOGENERATE: false
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - uses: actions/setup-go@v2
+        with:
+          go-version: "1.17.x"
+      - name: Run repo-specific setup
+        uses: ./.github/actions/go-check-setup
+        if: hashFiles('./.github/actions/go-check-setup') != ''
+      - name: Read config
+        if: hashFiles('./.github/workflows/go-check-config.json') != ''
+        run: |
+          if jq -re .gogenerate ./.github/workflows/go-check-config.json; then
+            echo "RUNGOGENERATE=true" >> $GITHUB_ENV
+          fi
+      - name: Install staticcheck
+        run: go install honnef.co/go/tools/cmd/staticcheck@df71e5d0e0ed317ebf43e6e59cf919430fa4b8f2 # 2021.1.1 (v0.2.1)
+      - 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()) && env.RUNGOGENERATE == 'true'
+        with:
+          run: |
+            git clean -fd # make sure there aren't untracked files / directories
+            go generate ./...
+            # 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
+

.github/workflows/go-test.yml

@@ -1,20 +1,55 @@
+# File managed by web3-bot. DO NOT EDIT.
+# See https://github.com/protocol/.github/ for details.
+
+on: [push, pull_request]
 name: Go Test
 
-on:
-  pull_request:
-  push:
-    branches: ["master"]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.event_name == 'push' && github.sha || github.ref }}
-  cancel-in-progress: true
-
 jobs:
-  go-test:
+  unit:
-    uses: ipdxco/unified-github-workflows/.github/workflows/go-test.yml@v1.0
+    strategy:
-    secrets:
+      fail-fast: false
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      matrix:
+        os: [ "ubuntu", "windows", "macos" ]
+        go: [ "1.16.x", "1.17.x" ]
+    env:
+      COVERAGES: ""
+    runs-on: ${{ matrix.os }}-latest
+    name: ${{ matrix.os}} (go ${{ matrix.go }})
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Go information
+        run: |
+          go version
+          go env
+      - name: Run repo-specific setup
+        uses: ./.github/actions/go-test-setup
+        if: hashFiles('./.github/actions/go-test-setup') != ''
+      - name: Run tests
+        uses: protocol/multiple-go-modules@v1.2
+        with:
+          run: go test -v -coverprofile module-coverage.txt ./...
+      - name: Run tests (32 bit)
+        if: ${{ matrix.os != 'macos' }} # can't run 32 bit tests on OSX.
+        uses: protocol/multiple-go-modules@v1.2
+        env:
+          GOARCH: 386
+        with:
+          run: go test -v ./...
+      - name: Run tests with race detector
+        if: ${{ matrix.os == 'ubuntu' }} # speed things up. Windows and OSX VMs are slow
+        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@51d810878be5422784e86451c0e7c14e5860ec47 # v2.0.2
+        with:
+          files: '${{ env.COVERAGES }}'
+          env_vars: OS=${{ matrix.os }}, GO=${{ matrix.go }}

.github/workflows/release-check.yml

@@ -1,19 +0,0 @@
-name: Release Checker
-
-on:
-  pull_request_target:
-    paths: [ 'version.json' ]
-    types: [ opened, synchronize, reopened, labeled, unlabeled ]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  release-check:
-    uses: ipdxco/unified-github-workflows/.github/workflows/release-check.yml@v1.0

.github/workflows/releaser.yml

@@ -1,17 +0,0 @@
-name: Releaser
-
-on:
-  push:
-    paths: [ 'version.json' ]
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.sha }}
-  cancel-in-progress: true
-
-jobs:
-  releaser:
-    uses: ipdxco/unified-github-workflows/.github/workflows/releaser.yml@v1.0

.github/workflows/stale.yml

@@ -1,14 +0,0 @@
-name: Close Stale Issues
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    uses: ipdxco/unified-github-workflows/.github/workflows/reusable-stale-issue.yml@v1

.github/workflows/tagpush.yml

@@ -1,18 +0,0 @@
-name: Tag Push Checker
-
-on:
-  push:
-    tags:
-      - v*
-
-permissions:
-  contents: read
-  issues: write
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  releaser:
-    uses: ipdxco/unified-github-workflows/.github/workflows/tagpush.yml@v1.0

README.md

@@ -5,7 +5,7 @@ go-cid
 [![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
 [![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
 [![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
-[![GoDoc](https://godoc.org/code.sonr.org/go/cid?status.svg)](https://godoc.org/code.sonr.org/go/cid)
+[![GoDoc](https://godoc.org/github.com/ipfs/go-cid?status.svg)](https://godoc.org/github.com/ipfs/go-cid)
 [![Coverage Status](https://coveralls.io/repos/github/ipfs/go-cid/badge.svg?branch=master)](https://coveralls.io/github/ipfs/go-cid?branch=master)
 [![Travis CI](https://travis-ci.org/ipfs/go-cid.svg?branch=master)](https://travis-ci.org/ipfs/go-cid)
 
@@ -31,7 +31,7 @@ It is used in `go-ipfs` and related packages to refer to a typed hunk of data.
 `go-cid` is a standard Go module which can be installed with:
 
 ```sh
-go get code.sonr.org/go/cid
+go get github.com/ipfs/go-cid
 ```
 
 ## Usage
@@ -59,17 +59,10 @@ fmt.Println("Got CID: ", c)
 #### Creating a CID from scratch
 
 ```go
-
-import (
-  cid "code.sonr.org/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
 }

_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

_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_CidStr-8          100000             16317 ns/op
-//	BenchmarkCidMap_CidIface-8        100000             20516 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_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_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_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{}

_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

_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

benchmark_test.go

@@ -1,61 +0,0 @@
-package cid_test
-
-import (
-	"math/rand"
-	"testing"
-
-	"code.sonr.org/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")
-				}
-			}
-		})
-	})
-}

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
@@ -37,53 +37,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:
+// These are multicodec-packed content types. The should match
-// <https://code.sonr.org/go/cid/pull/137>
+// the codes described in the authoritative document:
-// Modern code should use consts from go-multicodec instead:
+// https://github.com/multiformats/multicodec/blob/master/table.csv
-// <https://github.com/multiformats/go-multicodec>
 const (
-	// common ones
+	Raw = 0x55
-	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
 
-	// other
+	DagProtobuf = 0x70
-	GitRaw                = 0x78
+	DagCBOR     = 0x71
-	DagJOSE               = 0x85 // https://ipld.io/specs/codecs/dag-jose/spec/
+	Libp2pKey   = 0x72
+
+	GitRaw = 0x78
+
+	DagJOSE               = 0x85
 	EthBlock              = 0x90
 	EthBlockList          = 0x91
 	EthTxTrie             = 0x92
@@ -105,6 +81,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 +146,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
 }
@@ -199,23 +233,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 +257,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 +265,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 +287,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 +296,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 +307,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 +425,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)
 }
 
@@ -456,7 +475,7 @@ func (c Cid) Equals(o Cid) bool {
 // UnmarshalJSON parses the JSON representation of a Cid.
 func (c *Cid) UnmarshalJSON(b []byte) error {
 	if len(b) < 2 {
-		return ErrInvalidCid{fmt.Errorf("invalid cid json blob")}
+		return fmt.Errorf("invalid cid json blob")
 	}
 	obj := struct {
 		CidTarget string `json:"/"`
@@ -464,7 +483,7 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 	objptr := &obj
 	err := json.Unmarshal(b, &objptr)
 	if err != nil {
-		return ErrInvalidCid{err}
+		return err
 	}
 	if objptr == nil {
 		*c = Cid{}
@@ -472,12 +491,12 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 	}
 
 	if obj.CidTarget == "" {
-		return ErrInvalidCid{fmt.Errorf("cid was incorrectly formatted")}
+		return fmt.Errorf("cid was incorrectly formatted")
 	}
 
 	out, err := Decode(obj.CidTarget)
 	if err != nil {
-		return ErrInvalidCid{err}
+		return err
 	}
 
 	*c = out
@@ -487,7 +506,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 +563,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
@@ -564,12 +582,12 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
 	if p.Version == 0 && (p.MhType != mh.SHA2_256 ||
 		(p.MhLength != 32 && p.MhLength != -1)) {
 
-		return Undef, ErrInvalidCid{fmt.Errorf("invalid v0 prefix")}
+		return Undef, fmt.Errorf("invalid v0 prefix")
 	}
 
 	hash, err := mh.Sum(data, p.MhType, length)
 	if err != nil {
-		return Undef, ErrInvalidCid{err}
+		return Undef, err
 	}
 
 	switch p.Version {
@@ -578,13 +596,13 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
 	case 1:
 		return NewCidV1(p.Codec, hash), nil
 	default:
-		return Undef, ErrInvalidCid{fmt.Errorf("invalid cid version")}
+		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)
@@ -608,22 +626,22 @@ func PrefixFromBytes(buf []byte) (Prefix, error) {
 	r := bytes.NewReader(buf)
 	vers, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, ErrInvalidCid{err}
+		return Prefix{}, err
 	}
 
 	codec, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, ErrInvalidCid{err}
+		return Prefix{}, err
 	}
 
 	mhtype, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, ErrInvalidCid{err}
+		return Prefix{}, err
 	}
 
 	mhlen, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, ErrInvalidCid{err}
+		return Prefix{}, err
 	}
 
 	return Prefix{
@@ -637,12 +655,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,21 +668,21 @@ 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
@@ -717,9 +735,6 @@ func (r *bufByteReader) ReadByte() (byte, error) {
 // 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.
-//
-// If the Reader is found to yield zero bytes, an io.EOF error is returned directly, in all
-// other error cases, an ErrInvalidCid, wrapping the original error, is returned.
 func CidFromReader(r io.Reader) (int, Cid, error) {
 	// 64 bytes is enough for any CIDv0,
 	// and it's enough for most CIDv1s in practice.
@@ -730,37 +745,32 @@ func CidFromReader(r io.Reader) (int, Cid, error) {
 	// The varint package wants a io.ByteReader, so we must wrap our io.Reader.
 	vers, err := varint.ReadUvarint(br)
 	if err != nil {
-		if err == io.EOF {
+		return len(br.dst), Undef, err
-			// First-byte read in ReadUvarint errors with io.EOF, so reader has no data.
-			// Subsequent reads with an EOF will return io.ErrUnexpectedEOF and be wrapped here.
-			return 0, Undef, err
-		}
-		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}
+			return len(br.dst) + n, Undef, 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), Undef, 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)}
+		return len(br.dst), Undef, 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}
+		return len(br.dst), Undef, err
 	}
 
 	// We could replace most of the code below with go-multihash's ReadMultihash.
@@ -771,19 +781,19 @@ func CidFromReader(r io.Reader) (int, Cid, error) {
 	// Multihash hash function code.
 	_, err = varint.ReadUvarint(br)
 	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
+		return len(br.dst), Undef, err
 	}
 
 	// Multihash digest length.
 	mhl, err := varint.ReadUvarint(br)
 	if err != nil {
-		return len(br.dst), Undef, ErrInvalidCid{err}
+		return len(br.dst), Undef, 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)}
+		return len(br.dst), Undef, fmt.Errorf("refusing to allocate %d bytes for a digest", mhl)
 	}
 
 	// Fine to convert mhl to int, given maxDigestAlloc.
@@ -802,7 +812,7 @@ func CidFromReader(r io.Reader) (int, Cid, error) {
 	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}
+		return prefixLength + n, Undef, err
 	}
 
 	// This simply ensures the multihash is valid.
@@ -810,7 +820,7 @@ func CidFromReader(r io.Reader) (int, Cid, error) {
 	// 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), Undef, err
 	}
 
 	return len(br.dst), Cid{string(br.dst)}, nil

cid_fuzz.go

@@ -1,4 +1,5 @@
 //go:build gofuzz
+// +build gofuzz
 
 package cid
 

cid_test.go

@@ -2,9 +2,7 @@ package cid
 
 import (
 	"bytes"
-	crand "crypto/rand"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"math/rand"
@@ -17,6 +15,37 @@ import (
 	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,9 +60,29 @@ 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://code.sonr.org/go/cid/issues/83
+	// Tests: https://github.com/ipfs/go-cid/issues/83
 	for _, hashfun := range []uint64{
 		mh.IDENTITY, mh.SHA3, mh.SHA2_256,
 	} {
@@ -163,9 +212,6 @@ func TestBasesMarshaling(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected too-short error from ExtractEncoding")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 	if ee != -1 {
 		t.Fatal("expected -1 from too-short ExtractEncoding")
 	}
@@ -231,9 +277,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) {
@@ -289,9 +332,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) {
@@ -382,9 +422,6 @@ func TestInvalidV0Prefix(t *testing.T) {
 		if err == nil {
 			t.Fatalf("should error (index %d)", i)
 		}
-		if !errors.Is(err, ErrInvalidCid{}) {
-			t.Fatal("expected error to be ErrInvalidCid")
-		}
 	}
 }
 
@@ -394,9 +431,6 @@ func TestBadPrefix(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected error on v3 prefix Sum")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 }
 
 func TestPrefixRoundtrip(t *testing.T) {
@@ -433,30 +467,18 @@ func TestBadPrefixFromBytes(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for bad byte 0")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 1")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 2")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 3")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 }
 
 func Test16BytesVarint(t *testing.T) {
@@ -470,7 +492,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])
 	}
 }
@@ -483,9 +505,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)
@@ -603,29 +622,17 @@ func TestJsonRoundTrip(t *testing.T) {
 		t.Fatal("cids not equal for Cid")
 	}
 
-	err = actual2.UnmarshalJSON([]byte("1"))
+	if err = actual2.UnmarshalJSON([]byte("1")); err == nil {
-	if err == nil {
 		t.Fatal("expected error for too-short JSON")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 
-	err = actual2.UnmarshalJSON([]byte(`{"nope":"nope"}`))
+	if err = actual2.UnmarshalJSON([]byte(`{"nope":"nope"}`)); err == nil {
-	if err == nil {
 		t.Fatal("expected error for bad CID JSON")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 
-	err = actual2.UnmarshalJSON([]byte(`bad "" json!`))
+	if err = actual2.UnmarshalJSON([]byte(`bad "" json!`)); err == nil {
-	if err == nil {
 		t.Fatal("expected error for bad JSON")
 	}
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("expected error to be ErrInvalidCid")
-	}
 
 	var actual3 Cid
 	enc, err = actual3.MarshalJSON()
@@ -783,30 +790,6 @@ func TestBadCidInput(t *testing.T) {
 	}
 }
 
-func TestFromReaderNoData(t *testing.T) {
-	// Reading no data from io.Reader should return io.EOF, not ErrInvalidCid.
-	n, cid, err := CidFromReader(bytes.NewReader(nil))
-	if err != io.EOF {
-		t.Fatal("Expected io.EOF error")
-	}
-	if cid != Undef {
-		t.Fatal("Expected Undef CID")
-	}
-	if n != 0 {
-		t.Fatal("Expected 0 data")
-	}
-
-	// Read byte indicatiing more data to and check error is ErrInvalidCid.
-	_, _, err = CidFromReader(bytes.NewReader([]byte{0x80}))
-	if !errors.Is(err, ErrInvalidCid{}) {
-		t.Fatal("Expected ErrInvalidCid error")
-	}
-	// Check for expected wrapped error.
-	if !errors.Is(err, io.ErrUnexpectedEOF) {
-		t.Fatal("Expected error", io.ErrUnexpectedEOF)
-	}
-}
-
 func TestBadParse(t *testing.T) {
 	hash, err := mh.Sum([]byte("foobar"), mh.SHA3_256, -1)
 	if err != nil {
@@ -816,9 +799,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) {
@@ -833,80 +813,3 @@ func TestLoggable(t *testing.T) {
 		t.Fatalf("did not get expected loggable form (got %v)", actual)
 	}
 }
-
-func TestErrInvalidCidIs(t *testing.T) {
-	for i, test := range []struct {
-		err    error
-		target error
-	}{
-		{&ErrInvalidCid{}, ErrInvalidCid{}},
-		{ErrInvalidCid{}, &ErrInvalidCid{}},
-		{ErrInvalidCid{}, ErrInvalidCid{}},
-		{&ErrInvalidCid{}, &ErrInvalidCid{}},
-	} {
-		if !errors.Is(test.err, test.target) {
-			t.Fatalf("expected error to be ErrInvalidCid, case %d", i)
-		}
-	}
-}
-
-func TestErrInvalidCid(t *testing.T) {
-	run := func(err error) {
-		if err == nil {
-			t.Fatal("expected error")
-		}
-
-		if !strings.HasPrefix(err.Error(), "invalid cid: ") {
-			t.Fatal(`expected error message to contain "invalid cid: "`)
-		}
-
-		is := errors.Is(err, ErrInvalidCid{})
-		if !is {
-			t.Fatal("expected error to be ErrInvalidCid")
-		}
-
-		if !errors.Is(err, &ErrInvalidCid{}) {
-			t.Fatal("expected error to be &ErrInvalidCid")
-		}
-	}
-
-	_, err := Decode("")
-	run(err)
-
-	_, err = Decode("not-a-cid")
-	run(err)
-
-	_, err = Decode("bafyInvalid")
-	run(err)
-
-	_, err = Decode("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zIII")
-	run(err)
-
-	_, err = Cast([]byte("invalid"))
-	run(err)
-
-	_, err = Parse("not-a-cid")
-	run(err)
-
-	_, err = Parse("bafyInvalid")
-	run(err)
-
-	_, err = Parse("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zIII")
-	run(err)
-
-	_, err = Parse(123)
-	run(err)
-
-	_, _, err = CidFromBytes([]byte("invalid"))
-	run(err)
-
-	_, err = Prefix{}.Sum([]byte("data"))
-	run(err)
-
-	_, err = PrefixFromBytes([]byte{0x80})
-	run(err)
-
-	_, err = ExtractEncoding("invalid ")
-	run(err)
-
-}

go.mod

@@ -1,21 +1,10 @@
-module code.sonr.org/go/cid
+module github.com/ipfs/go-cid
 
 require (
-	github.com/multiformats/go-multibase v0.2.0
+	github.com/multiformats/go-multibase v0.0.3
-	github.com/multiformats/go-multihash v0.2.3
+	github.com/multiformats/go-multihash v0.0.15
-	github.com/multiformats/go-varint v0.1.0
+	github.com/multiformats/go-varint v0.0.6
+	golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf // indirect
 )
 
-require (
+go 1.16
-	github.com/klauspost/cpuid/v2 v2.0.9 // 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
-	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	golang.org/x/crypto v0.45.0 // indirect
-	golang.org/x/sys v0.38.0 // indirect
-	lukechampine.com/blake3 v1.1.6 // indirect
-)
-
-go 1.24.0

go.sum

@@ -1,25 +1,35 @@
+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/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
 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.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-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.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g=
+github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
-github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk=
+github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
-github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U=
+github.com/multiformats/go-multihash v0.0.15 h1:hWOPdrNqDjwHDx82vsYGSDZNyktOJJ2dzZJzFkOV1jM=
-github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
+github.com/multiformats/go-multihash v0.0.15/go.mod h1:D6aZrWNLFTV/ynMpKsNtB40mJzmCl4jb1alC0OvHiHg=
-github.com/multiformats/go-varint v0.1.0 h1:i2wqFp4sdl3IcIxfAonHQV9qU5OsZ4Ts9IOoETFs5dI=
+github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
-github.com/multiformats/go-varint v0.1.0/go.mod h1:5KVAVXegtfmNQQm/lCY+ATvDzvJJhSkUlGQV9wgObdI=
+github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
-github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf h1:B2n+Zi5QeYRDAEodEu72OS36gmTWjgpXr2+cWcBW90o=
-golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/crypto v0.0.0-20210506145944-38f3c27a63bf/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
-golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-lukechampine.com/blake3 v1.1.6 h1:H3cROdztr7RCfoaTpGZFQsrqvweFLrqS73j7L7cmR5c=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-lukechampine.com/blake3 v1.1.6/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/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/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

version.json

@@ -1,3 +0,0 @@
-{
-  "version": "v0.6.0"
-}