From 4f0c0e5cf7944dc0195b960e4d5108034fc2f211 Mon Sep 17 00:00:00 2001
From: achingbrain <alex@achingbrain.net>
Date: Thu, 8 Nov 2018 21:45:19 +0000
Subject: [PATCH] fix: updates ipld-dag-pb dep to version without .cid
 properties

Follows on from https://github.com/ipld/js-ipld-dag-pb/pull/99 and
updates this module to not rely on DAGNodes having knowledge of
their CIDs.
---
 package.json                                 |  16 +-
 src/cli/commands/object/get.js               |  54 +++---
 src/cli/commands/object/links.js             |  11 +-
 src/cli/commands/object/new.js               |  20 ++-
 src/cli/commands/object/patch/add-link.js    |  36 +++-
 src/cli/commands/object/patch/append-data.js |  14 +-
 src/cli/commands/object/patch/rm-link.js     |  20 ++-
 src/cli/commands/object/patch/set-data.js    |  14 +-
 src/cli/commands/object/put.js               |  21 ++-
 src/core/components/dag.js                   |   2 +-
 src/core/components/init.js                  |  13 +-
 src/core/components/object.js                |  80 ++++-----
 src/core/components/pin-set.js               |  81 ++++++---
 src/core/components/pin.js                   | 166 +++++++++++-------
 src/core/index.js                            |   6 +-
 src/core/utils.js                            |  12 +-
 src/http/api/resources/object.js             | 170 +++++++++----------
 test/core/object.spec.js                     |  93 ++++++----
 test/core/pin-set.js                         |  55 +++---
 test/core/pin.js                             |   2 +-
 test/core/preload.spec.js                    | 106 +++++++++---
 test/http-api/object.js                      |  52 ++++--
 22 files changed, 675 insertions(+), 369 deletions(-)

diff --git a/package.json b/package.json
index 3bdaa3b57a..d6295f4aeb 100644
--- a/package.json
+++ b/package.json
@@ -69,8 +69,8 @@
     "execa": "^1.0.0",
     "form-data": "^2.3.3",
     "hat": "0.0.3",
-    "interface-ipfs-core": "~0.84.2",
-    "ipfsd-ctl": "~0.39.5",
+    "interface-ipfs-core": "~0.86.0",
+    "ipfsd-ctl": "ipfs/js-ipfsd-ctl#update-dag-pb-to-not-have-cid-property",
     "ncp": "^2.0.0",
     "qs": "^6.5.2",
     "rimraf": "^2.6.2",
@@ -102,19 +102,19 @@
     "hoek": "^5.0.4",
     "human-to-milliseconds": "^1.0.0",
     "interface-datastore": "~0.6.0",
-    "ipfs-api": "^26.1.0",
+    "ipfs-api": "ipfs/js-ipfs-api",
     "ipfs-bitswap": "~0.21.0",
     "ipfs-block": "~0.8.0",
     "ipfs-block-service": "~0.15.1",
-    "ipfs-http-response": "~0.2.0",
-    "ipfs-mfs": "~0.4.2",
+    "ipfs-http-response": "~0.2.1",
+    "ipfs-mfs": "~0.5.0",
     "ipfs-multipart": "~0.1.0",
     "ipfs-repo": "~0.25.0",
     "ipfs-unixfs": "~0.1.16",
-    "ipfs-unixfs-engine": "~0.33.0",
-    "ipld": "~0.19.3",
+    "ipfs-unixfs-engine": "~0.34.0",
+    "ipld": "~0.20.0",
     "ipld-bitcoin": "~0.1.8",
-    "ipld-dag-pb": "~0.14.11",
+    "ipld-dag-pb": "~0.15.0",
     "ipld-ethereum": "^2.0.1",
     "ipld-git": "~0.2.2",
     "ipld-zcash": "~0.1.6",
diff --git a/src/cli/commands/object/get.js b/src/cli/commands/object/get.js
index 80190d8d96..ccc4b466ab 100644
--- a/src/cli/commands/object/get.js
+++ b/src/cli/commands/object/get.js
@@ -1,6 +1,11 @@
 'use strict'
 
 const print = require('../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 module.exports = {
   command: 'get <key>',
@@ -11,6 +16,10 @@ module.exports = {
     'data-encoding': {
       type: 'string',
       default: 'base64'
+    },
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
     }
   },
 
@@ -19,26 +28,33 @@ module.exports = {
       if (err) {
         throw err
       }
-      const nodeJSON = node.toJSON()
-
-      if (Buffer.isBuffer(node.data)) {
-        nodeJSON.data = node.data.toString(argv['data-encoding'] || undefined)
-      }
-
-      const answer = {
-        Data: nodeJSON.data,
-        Hash: nodeJSON.multihash,
-        Size: nodeJSON.size,
-        Links: nodeJSON.links.map((l) => {
-          return {
-            Name: l.name,
-            Size: l.size,
-            Hash: l.multihash
-          }
-        })
-      }
 
-      print(JSON.stringify(answer))
+      cid(node, (err, result) => {
+        if (err) {
+          throw err
+        }
+
+        let data = node.data
+
+        if (Buffer.isBuffer(data)) {
+          data = node.data.toString(argv.dataEncoding || undefined)
+        }
+
+        const answer = {
+          Data: data,
+          Hash: result.toBaseEncodedString(argv.cidBase),
+          Size: node.size,
+          Links: node.links.map((l) => {
+            return {
+              Name: l.name,
+              Size: l.size,
+              Hash: l.cid.toBaseEncodedString(argv.cidBase)
+            }
+          })
+        }
+
+        print(JSON.stringify(answer))
+      })
     })
   }
 }
diff --git a/src/cli/commands/object/links.js b/src/cli/commands/object/links.js
index d657820fb4..9a3a3e203e 100644
--- a/src/cli/commands/object/links.js
+++ b/src/cli/commands/object/links.js
@@ -7,7 +7,12 @@ module.exports = {
 
   describe: 'Outputs the links pointed to by the specified object',
 
-  builder: {},
+  builder: {
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
+    }
+  },
 
   handler (argv) {
     argv.ipfs.object.links(argv.key, {
@@ -18,9 +23,7 @@ module.exports = {
       }
 
       links.forEach((link) => {
-        link = link.toJSON()
-
-        print(`${link.multihash} ${link.size} ${link.name}`)
+        print(`${link.cid.toBaseEncodedString(argv.cidBase)} ${link.size} ${link.name}`)
       })
     })
   }
diff --git a/src/cli/commands/object/new.js b/src/cli/commands/object/new.js
index f96db85fb2..36ab5a3659 100644
--- a/src/cli/commands/object/new.js
+++ b/src/cli/commands/object/new.js
@@ -4,13 +4,23 @@ const debug = require('debug')
 const log = debug('cli:object')
 log.error = debug('cli:object:error')
 const print = require('../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 module.exports = {
   command: 'new [<template>]',
 
   describe: 'Create new ipfs objects',
 
-  builder: {},
+  builder: {
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
+    }
+  },
 
   handler (argv) {
     argv.ipfs.object.new(argv.template, (err, node) => {
@@ -18,9 +28,13 @@ module.exports = {
         throw err
       }
 
-      const nodeJSON = node.toJSON()
+      cid(node, (err, cid) => {
+        if (err) {
+          throw err
+        }
 
-      print(nodeJSON.multihash)
+        print(cid.toBaseEncodedString(argv.cidBase))
+      })
     })
   }
 }
diff --git a/src/cli/commands/object/patch/add-link.js b/src/cli/commands/object/patch/add-link.js
index eb4530ed72..28982d1bcf 100644
--- a/src/cli/commands/object/patch/add-link.js
+++ b/src/cli/commands/object/patch/add-link.js
@@ -3,13 +3,23 @@
 const dagPB = require('ipld-dag-pb')
 const DAGLink = dagPB.DAGLink
 const print = require('../../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 module.exports = {
   command: 'add-link <root> <name> <ref>',
 
   describe: 'Add a link to a given object',
 
-  builder: {},
+  builder: {
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
+    }
+  },
 
   handler (argv) {
     const ipfs = argv.ipfs
@@ -20,16 +30,28 @@ module.exports = {
         throw err
       }
 
-      const link = new DAGLink(argv.name, nodeA.size, nodeA.multihash)
-
-      ipfs.object.patch.addLink(argv.root, link, {
-        enc: 'base58'
-      }, (err, nodeB) => {
+      cid(nodeA, (err, result) => {
         if (err) {
           throw err
         }
 
-        print(nodeB.toJSON().multihash)
+        const link = new DAGLink(argv.name, nodeA.size, result)
+
+        ipfs.object.patch.addLink(argv.root, link, {
+          enc: 'base58'
+        }, (err, nodeB) => {
+          if (err) {
+            throw err
+          }
+
+          cid(nodeB, (err, result) => {
+            if (err) {
+              throw err
+            }
+
+            print(result.toBaseEncodedString(argv.cidBase))
+          })
+        })
       })
     })
   }
diff --git a/src/cli/commands/object/patch/append-data.js b/src/cli/commands/object/patch/append-data.js
index e13722b13c..a2428a196d 100644
--- a/src/cli/commands/object/patch/append-data.js
+++ b/src/cli/commands/object/patch/append-data.js
@@ -6,6 +6,11 @@ const debug = require('debug')
 const log = debug('cli:object')
 log.error = debug('cli:object:error')
 const print = require('../../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 function appendData (key, data, ipfs) {
   ipfs.object.patch.appendData(key, data, {
@@ -14,9 +19,14 @@ function appendData (key, data, ipfs) {
     if (err) {
       throw err
     }
-    const nodeJSON = node.toJSON()
 
-    print(nodeJSON.multihash)
+    cid(node, (err, cid) => {
+      if (err) {
+        throw err
+      }
+
+      print(cid.toBaseEncodedString())
+    })
   })
 }
 
diff --git a/src/cli/commands/object/patch/rm-link.js b/src/cli/commands/object/patch/rm-link.js
index dde69c30f8..ec36dfaf57 100644
--- a/src/cli/commands/object/patch/rm-link.js
+++ b/src/cli/commands/object/patch/rm-link.js
@@ -4,13 +4,23 @@ const debug = require('debug')
 const log = debug('cli:object')
 log.error = debug('cli:object:error')
 const print = require('../../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 module.exports = {
   command: 'rm-link <root> <link>',
 
   describe: 'Remove a link from an object',
 
-  builder: {},
+  builder: {
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
+    }
+  },
 
   handler (argv) {
     argv.ipfs.object.patch.rmLink(argv.root, { name: argv.link }, {
@@ -20,9 +30,13 @@ module.exports = {
         throw err
       }
 
-      const nodeJSON = node.toJSON()
+      cid(node, (err, cid) => {
+        if (err) {
+          throw err
+        }
 
-      print(nodeJSON.multihash)
+        print(cid.toBaseEncodedString(argv.cidBase))
+      })
     })
   }
 }
diff --git a/src/cli/commands/object/patch/set-data.js b/src/cli/commands/object/patch/set-data.js
index 4bfa4e0834..0e9d064d5b 100644
--- a/src/cli/commands/object/patch/set-data.js
+++ b/src/cli/commands/object/patch/set-data.js
@@ -6,6 +6,11 @@ const debug = require('debug')
 const log = debug('cli:object')
 log.error = debug('cli:object:error')
 const print = require('../../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 function parseAndAddNode (key, data, ipfs) {
   ipfs.object.patch.setData(key, data, {
@@ -14,9 +19,14 @@ function parseAndAddNode (key, data, ipfs) {
     if (err) {
       throw err
     }
-    const nodeJSON = node.toJSON()
 
-    print(nodeJSON.multihash)
+    cid(node, (err, cid) => {
+      if (err) {
+        throw err
+      }
+
+      print(cid.toBaseEncodedString())
+    })
   })
 }
 
diff --git a/src/cli/commands/object/put.js b/src/cli/commands/object/put.js
index 98617080df..23521e1f4c 100644
--- a/src/cli/commands/object/put.js
+++ b/src/cli/commands/object/put.js
@@ -3,16 +3,25 @@
 const bl = require('bl')
 const fs = require('fs')
 const print = require('../../utils').print
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
-function putNode (buf, enc, ipfs) {
+function putNode (buf, enc, ipfs, cidEnc) {
   ipfs.object.put(buf, { enc: enc }, (err, node) => {
     if (err) {
       throw err
     }
 
-    const nodeJSON = node.toJSON()
+    cid(node, (err, cid) => {
+      if (err) {
+        throw err
+      }
 
-    print(`added ${nodeJSON.multihash}`)
+      print(`added ${cid.toBaseEncodedString(cidEnc)}`)
+    })
   })
 }
 
@@ -25,6 +34,10 @@ module.exports = {
     'input-enc': {
       type: 'string',
       default: 'json'
+    },
+    'cid-base': {
+      default: 'base58btc',
+      describe: 'CID base to use.'
     }
   },
 
@@ -40,7 +53,7 @@ module.exports = {
         throw err
       }
 
-      putNode(input, argv.inputEnc, ipfs)
+      putNode(input, argv.inputEnc, ipfs, argv.cidBase)
     }))
   }
 }
diff --git a/src/core/components/dag.js b/src/core/components/dag.js
index 5b33ee8214..dc9ef2bdf5 100644
--- a/src/core/components/dag.js
+++ b/src/core/components/dag.js
@@ -163,7 +163,7 @@ module.exports = function dag (self) {
         if (err) { return callback(err) }
 
         mapAsync(res.value.links, (link, cb) => {
-          self.dag._getRecursive(link.multihash, options, cb)
+          self.dag._getRecursive(link.cid, options, cb)
         }, (err, nodes) => {
           // console.log('nodes:', nodes)
           if (err) return callback(err)
diff --git a/src/core/components/init.js b/src/core/components/init.js
index 3473516b9f..51c197e977 100644
--- a/src/core/components/init.js
+++ b/src/core/components/init.js
@@ -7,6 +7,10 @@ const promisify = require('promisify-es6')
 const defaultsDeep = require('@nodeutils/defaults-deep')
 const defaultConfig = require('../runtime/config-nodejs.js')
 const Keychain = require('libp2p-keychain')
+const {
+  DAGNode
+} = require('ipld-dag-pb')
+const UnixFs = require('ipfs-unixfs')
 
 const IPNS = require('../ipns')
 const OfflineDatastore = require('../ipns/routing/offline-datastore')
@@ -125,8 +129,13 @@ module.exports = function init (self) {
         const tasks = [
           (cb) => {
             waterfall([
-              (cb) => self.object.new('unixfs-dir', cb),
-              (emptyDirNode, cb) => self._ipns.initializeKeyspace(privateKey, emptyDirNode.toJSON().multihash, cb)
+              (cb) => DAGNode.create(new UnixFs('directory').marshal(), cb),
+              (node, cb) => self.dag.put(node, {
+                version: 0,
+                format: 'dag-pb',
+                hashAlg: 'sha2-256'
+              }, cb),
+              (cid, cb) => self._ipns.initializeKeyspace(privateKey, cid.toBaseEncodedString(), cb)
             ], cb)
           }
         ]
diff --git a/src/core/components/object.js b/src/core/components/object.js
index 41ad06f1cd..2bc91d3026 100644
--- a/src/core/components/object.js
+++ b/src/core/components/object.js
@@ -1,6 +1,7 @@
 'use strict'
 
 const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
 const setImmediate = require('async/setImmediate')
 const promisify = require('promisify-es6')
 const dagPB = require('ipld-dag-pb')
@@ -20,6 +21,8 @@ function normalizeMultihash (multihash, enc) {
     return Buffer.from(multihash, enc)
   } else if (Buffer.isBuffer(multihash)) {
     return multihash
+  } else if (CID.isCID(multihash)) {
+    return multihash.buffer
   } else {
     throw new Error('unsupported multihash')
   }
@@ -84,9 +87,11 @@ module.exports = function object (self) {
               return cb(err)
             }
 
-            const cid = new CID(node.multihash)
-
-            self._ipld.put(node, { cid }, (err) => {
+            self._ipld.put(node, {
+              version: 0,
+              hashAlg: 'sha2-256',
+              format: 'dag-pb'
+            }, (err, cid) => {
               if (err) return cb(err)
 
               if (options.preload !== false) {
@@ -132,9 +137,11 @@ module.exports = function object (self) {
           return callback(err)
         }
 
-        const cid = new CID(node.multihash)
-
-        self._ipld.put(node, { cid }, (err) => {
+        self._ipld.put(node, {
+          version: 0,
+          hashAlg: 'sha2-256',
+          format: 'dag-pb'
+        }, (err, cid) => {
           if (err) {
             return callback(err)
           }
@@ -176,7 +183,7 @@ module.exports = function object (self) {
             next()
           })
         }
-      } else if (obj.multihash) {
+      } else if (DAGNode.isDAGNode(obj)) {
         // already a dag node
         node = obj
         next()
@@ -193,20 +200,18 @@ module.exports = function object (self) {
       }
 
       function next () {
-        let cid
-
-        try {
-          cid = new CID(node.multihash)
-        } catch (err) {
-          return setImmediate(() => callback(errCode(err, 'ERR_INVALID_CID')))
-        }
-
-        self._ipld.put(node, { cid }, (err) => {
+        self._ipld.put(node, {
+          version: 0,
+          hashAlg: 'sha2-256',
+          format: 'dag-pb'
+        }, (err, cid) => {
           if (err) {
             return callback(err)
           }
 
-          self.object.get(node.multihash, { preload: options.preload }, callback)
+          self.object.get(cid, {
+            preload: options.preload
+          }, callback)
         })
       }
     }),
@@ -246,9 +251,7 @@ module.exports = function object (self) {
           return callback(err)
         }
 
-        const node = result.value
-
-        callback(null, node)
+        callback(null, result.value)
       })
     }),
 
@@ -288,29 +291,30 @@ module.exports = function object (self) {
         options = {}
       }
 
-      self.object.get(multihash, options, (err, node) => {
+      waterfall([
+        (cb) => self.object.get(multihash, options, cb),
+        (node, cb) => {
+          parallel({
+            serialized: (next) => dagPB.util.serialize(node, next),
+            cid: (next) => dagPB.util.cid(node, next),
+            node: (next) => next(null, node)
+          }, cb)
+        }
+      ], (err, result) => {
         if (err) {
           return callback(err)
         }
 
-        dagPB.util.serialize(node, (err, serialized) => {
-          if (err) {
-            return callback(err)
-          }
-
-          const blockSize = serialized.length
-          const linkLength = node.links.reduce((a, l) => a + l.size, 0)
+        const blockSize = result.serialized.length
+        const linkLength = result.node.links.reduce((a, l) => a + l.size, 0)
 
-          const nodeJSON = node.toJSON()
-
-          callback(null, {
-            Hash: nodeJSON.multihash,
-            NumLinks: node.links.length,
-            BlockSize: blockSize,
-            LinksSize: blockSize - node.data.length,
-            DataSize: node.data.length,
-            CumulativeSize: blockSize + linkLength
-          })
+        callback(null, {
+          Hash: result.cid.toBaseEncodedString(),
+          NumLinks: result.node.links.length,
+          BlockSize: blockSize,
+          LinksSize: blockSize - result.node.data.length,
+          DataSize: result.node.data.length,
+          CumulativeSize: blockSize + linkLength
         })
       })
     }),
diff --git a/src/core/components/pin-set.js b/src/core/components/pin-set.js
index 1f31697825..91f72bf90b 100644
--- a/src/core/components/pin-set.js
+++ b/src/core/components/pin-set.js
@@ -61,6 +61,7 @@ exports = module.exports = function (dag) {
     // should this be part of `object` API?
     hasDescendant: (root, childhash, callback) => {
       const seen = {}
+
       if (CID.isCID(childhash) || Buffer.isBuffer(childhash)) {
         childhash = toB58String(childhash)
       }
@@ -68,33 +69,53 @@ exports = module.exports = function (dag) {
       return searchChildren(root, callback)
 
       function searchChildren (root, cb) {
-        some(root.links, ({ multihash }, someCb) => {
-          const bs58Link = toB58String(multihash)
-          if (bs58Link === childhash) { return someCb(null, true) }
-          if (bs58Link in seen) { return someCb(null, false) }
+        some(root.links, ({ cid }, done) => {
+          const bs58Link = toB58String(cid)
+
+          if (bs58Link === childhash) {
+            return done(null, true)
+          }
+
+          if (bs58Link in seen) {
+            return done(null, false)
+          }
 
           seen[bs58Link] = true
 
-          dag.get(multihash, '', { preload: false }, (err, res) => {
-            if (err) { return someCb(err) }
-            searchChildren(res.value, someCb)
+          dag.get(cid, '', { preload: false }, (err, res) => {
+            if (err) {
+              return done(err)
+            }
+
+            searchChildren(res.value, done)
           })
         }, cb)
       }
     },
 
     storeSet: (keys, callback) => {
-      const pins = keys.map(key => ({
-        key: key,
-        data: null
-      }))
+      const pins = keys.map(key => {
+        if (typeof key === 'string' || Buffer.isBuffer(key)) {
+          key = new CID(key)
+        }
+
+        return {
+          key: key,
+          data: null
+        }
+      })
 
       pinSet.storeItems(pins, (err, rootNode) => {
         if (err) { return callback(err) }
-        const opts = { cid: new CID(rootNode.multihash), preload: false }
-        dag.put(rootNode, opts, (err, cid) => {
-          if (err) { return callback(err) }
-          callback(null, rootNode)
+
+        dag.put(rootNode, {
+          version: 0,
+          format: 'dag-pb',
+          hashAlg: 'sha2-256',
+          preload: false
+        }, (err, cid) => {
+          if (err) { return callback(err, cid) }
+          callback(null, { node: rootNode, cid })
         })
       })
     },
@@ -118,12 +139,14 @@ exports = module.exports = function (dag) {
 
         if (pins.length <= maxItems) {
           const nodes = pins
-            .map(item => ({
-              link: new DAGLink('', 1, item.key),
-              data: item.data || Buffer.alloc(0)
-            }))
+            .map(item => {
+              return ({
+                link: new DAGLink('', 1, item.key),
+                data: item.data || Buffer.alloc(0)
+              })
+            })
             // sorting makes any ordering of `pins` produce the same DAGNode
-            .sort((a, b) => Buffer.compare(a.link.multihash, b.link.multihash))
+            .sort((a, b) => Buffer.compare(a.link.cid.buffer, b.link.cid.buffer))
 
           const rootLinks = fanoutLinks.concat(nodes.map(item => item.link))
           const rootData = Buffer.concat(
@@ -169,10 +192,16 @@ exports = module.exports = function (dag) {
         function storeChild (err, child, binIdx, cb) {
           if (err) { return cb(err) }
 
-          const opts = { cid: new CID(child.multihash), preload: false }
-          dag.put(child, opts, err => {
+          const opts = {
+            version: 0,
+            hashAlg: 'sha2-256',
+            format: 'dag-pb',
+            preload: false
+          }
+
+          dag.put(child, opts, (err, cid) => {
             if (err) { return cb(err) }
-            fanoutLinks[binIdx] = new DAGLink('', child.size, child.multihash)
+            fanoutLinks[binIdx] = new DAGLink('', child.size, cid)
             cb(null)
           })
         }
@@ -185,10 +214,10 @@ exports = module.exports = function (dag) {
         return callback(new Error('No link found with name ' + name))
       }
 
-      dag.get(link.multihash, '', { preload: false }, (err, res) => {
+      dag.get(link.cid, '', { preload: false }, (err, res) => {
         if (err) { return callback(err) }
         const keys = []
-        const step = link => keys.push(link.multihash)
+        const step = link => keys.push(link.cid.buffer)
         pinSet.walkItems(res.value, step, err => {
           if (err) { return callback(err) }
           return callback(null, keys)
@@ -208,7 +237,7 @@ exports = module.exports = function (dag) {
         if (idx < pbh.header.fanout) {
           // the first pbh.header.fanout links are fanout bins
           // if a fanout bin is not 'empty', dig into and walk its DAGLinks
-          const linkHash = link.multihash
+          const linkHash = link.cid.buffer
 
           if (!emptyKey.equals(linkHash)) {
             // walk the links of this fanout bin
diff --git a/src/core/components/pin.js b/src/core/components/pin.js
index 39e8765ca0..e89c9f3fad 100644
--- a/src/core/components/pin.js
+++ b/src/core/components/pin.js
@@ -2,7 +2,7 @@
 'use strict'
 
 const promisify = require('promisify-es6')
-const { DAGNode, DAGLink } = require('ipld-dag-pb')
+const { DAGNode, DAGLink, util } = require('ipld-dag-pb')
 const CID = require('cids')
 const map = require('async/map')
 const mapSeries = require('async/mapSeries')
@@ -10,11 +10,10 @@ const series = require('async/series')
 const parallel = require('async/parallel')
 const eachLimit = require('async/eachLimit')
 const waterfall = require('async/waterfall')
-const someLimit = require('async/someLimit')
+const detectLimit = require('async/detectLimit')
 const setImmediate = require('async/setImmediate')
 const { Key } = require('interface-datastore')
 const errCode = require('err-code')
-
 const createPinSet = require('./pin-set')
 const { resolvePath } = require('../utils')
 
@@ -54,15 +53,23 @@ module.exports = (self) => {
     const indirectKeys = new Set()
     eachLimit(recursiveKeys(), concurrencyLimit, (multihash, cb) => {
       dag._getRecursive(multihash, (err, nodes) => {
-        if (err) { return cb(err) }
+        if (err) {
+          return cb(err)
+        }
 
-        nodes
-          .map(({ multihash }) => toB58String(multihash))
-          // recursive pins pre-empt indirect pins
-          .filter(key => !recursivePins.has(key))
-          .forEach(key => indirectKeys.add(key))
+        map(nodes, (node, cb) => util.cid(node, cb), (err, cids) => {
+          if (err) {
+            return cb(err)
+          }
+
+          cids
+            .map(cids => cids.toBaseEncodedString())
+            // recursive pins pre-empt indirect pins
+            .filter(key => !recursivePins.has(key))
+            .forEach(key => indirectKeys.add(key))
 
-        cb()
+          cb()
+        })
       })
     }, (err) => {
       if (err) { return callback(err) }
@@ -79,28 +86,43 @@ module.exports = (self) => {
       // create a DAGLink to the node with direct pins
       cb => waterfall([
         cb => pinset.storeSet(directKeys(), cb),
-        (node, cb) => DAGLink.create(types.direct, node.size, node.multihash, cb),
+        ({ node, cid }, cb) => DAGLink.create(types.direct, node.size, cid, cb),
         (link, cb) => { dLink = link; cb(null) }
       ], cb),
 
       // create a DAGLink to the node with recursive pins
       cb => waterfall([
         cb => pinset.storeSet(recursiveKeys(), cb),
-        (node, cb) => DAGLink.create(types.recursive, node.size, node.multihash, cb),
+        ({ node, cid }, cb) => DAGLink.create(types.recursive, node.size, cid, cb),
         (link, cb) => { rLink = link; cb(null) }
       ], cb),
 
       // the pin-set nodes link to a special 'empty' node, so make sure it exists
       cb => DAGNode.create(Buffer.alloc(0), (err, empty) => {
         if (err) { return cb(err) }
-        dag.put(empty, { cid: new CID(empty.multihash), preload: false }, cb)
+        dag.put(empty, {
+          version: 0,
+          hashAlg: 'sha2-256',
+          format: 'dag-pb',
+          preload: false
+        }, cb)
       }),
 
       // create a root node with DAGLinks to the direct and recursive DAGs
       cb => DAGNode.create(Buffer.alloc(0), [dLink, rLink], (err, node) => {
         if (err) { return cb(err) }
         root = node
-        dag.put(root, { cid: new CID(root.multihash), preload: false }, cb)
+        dag.put(root, {
+          version: 0,
+          hashAlg: 'sha2-256',
+          format: 'dag-pb',
+          preload: false
+        }, (err, cid) => {
+          if (!err) {
+            root.multihash = cid.buffer
+          }
+          cb(err)
+        })
       }),
 
       // hack for CLI tests
@@ -261,34 +283,35 @@ module.exports = (self) => {
 
       if (paths) {
         // check the pinned state of specific hashes
-        resolvePath(self.object, paths, (err, mhs) => {
-          if (err) { return callback(err) }
+        waterfall([
+          (cb) => resolvePath(self.object, paths, cb),
+          (hashes, cb) => mapSeries(hashes, (hash, done) => pin._isPinnedWithType(hash, types.all, done), cb),
+          (results, cb) => {
+            results = results
+              .filter(result => result.pinned)
+              .map(({ key, reason }) => {
+                switch (reason) {
+                  case types.direct:
+                  case types.recursive:
+                    return {
+                      hash: key,
+                      type: reason
+                    }
+                  default:
+                    return {
+                      hash: key,
+                      type: `${types.indirect} through ${reason}`
+                    }
+                }
+              })
 
-          mapSeries(mhs, (multihash, cb) => {
-            pin._isPinnedWithType(multihash, types.all, (err, res) => {
-              if (err) { return cb(err) }
-              const { pinned, reason } = res
-              const key = toB58String(multihash)
-              if (!pinned) {
-                return cb(new Error(`Path ${key} is not pinned`))
-              }
-
-              switch (reason) {
-                case types.direct:
-                case types.recursive:
-                  return cb(null, {
-                    hash: key,
-                    type: reason
-                  })
-                default:
-                  return cb(null, {
-                    hash: key,
-                    type: `${types.indirect} through ${reason}`
-                  })
-              }
-            })
-          }, callback)
-        })
+            if (!results.length) {
+              return cb(new Error(`Path is not pinned`))
+            }
+
+            cb(null, results)
+          }
+        ], callback)
       } else {
         // show all pinned items of type
         let pins = []
@@ -333,40 +356,53 @@ module.exports = (self) => {
     _isPinnedWithType: promisify((multihash, type, callback) => {
       const key = toB58String(multihash)
       const { recursive, direct, all } = types
+
       // recursive
       if ((type === recursive || type === all) && recursivePins.has(key)) {
-        return callback(null, { pinned: true, reason: recursive })
+        return callback(null, {
+          key,
+          pinned: true,
+          reason: recursive
+        })
       }
-      if ((type === recursive)) {
-        return callback(null, { pinned: false })
+
+      if (type === recursive) {
+        return callback(null, {
+          key,
+          pinned: false
+        })
       }
+
       // direct
       if ((type === direct || type === all) && directPins.has(key)) {
-        return callback(null, { pinned: true, reason: direct })
+        return callback(null, {
+          key,
+          pinned: true,
+          reason: direct
+        })
       }
-      if ((type === direct)) {
-        return callback(null, { pinned: false })
+
+      if (type === direct) {
+        return callback(null, {
+          key,
+          pinned: false
+        })
       }
 
       // indirect (default)
       // check each recursive key to see if multihash is under it
       // arbitrary limit, enables handling 1000s of pins.
-      let foundPin
-      someLimit(recursiveKeys(), concurrencyLimit, (key, cb) => {
-        dag.get(new CID(key), (err, res) => {
-          if (err) { return cb(err) }
-
-          pinset.hasDescendant(res.value, multihash, (err, has) => {
-            if (has) {
-              foundPin = toB58String(res.value.multihash)
-            }
-            cb(err, has)
-          })
-        })
-      }, (err, found) => {
-        if (err) { return callback(err) }
-        return callback(null, { pinned: found, reason: foundPin })
-      })
+      detectLimit(recursiveKeys().map(key => new CID(key)), concurrencyLimit, (cid, cb) => {
+        waterfall([
+          (done) => dag.get(cid, '', { preload: false }, done),
+          (result, done) => done(null, result.value),
+          (node, done) => pinset.hasDescendant(node, key, done)
+        ], cb)
+      }, (err, cid) => callback(err, {
+        key,
+        pinned: Boolean(cid),
+        reason: cid
+      }))
     }),
 
     _load: promisify(callback => {
@@ -376,7 +412,9 @@ module.exports = (self) => {
         (_, cb) => repo.datastore.has(pinDataStoreKey, cb),
         (has, cb) => has ? cb() : cb(new Error('No pins to load')),
         (cb) => repo.datastore.get(pinDataStoreKey, cb),
-        (mh, cb) => dag.get(new CID(mh), '', { preload: false }, cb)
+        (mh, cb) => {
+          dag.get(new CID(mh), '', { preload: false }, cb)
+        }
       ], (err, pinRoot) => {
         if (err) {
           if (err.message === 'No pins to load') {
diff --git a/src/core/index.js b/src/core/index.js
index 93ff3431d8..0d53a21342 100644
--- a/src/core/index.js
+++ b/src/core/index.js
@@ -185,7 +185,11 @@ class IPFS extends EventEmitter {
     }
 
     // ipfs.files
-    const mfs = components.mfs(this)
+    const mfs = components.mfs({
+      ipld: this._ipld,
+      repo: this._repo,
+      repoOwner: (this._options.mfs && this._options.mfs.repoOwner) || true
+    })
 
     Object.keys(mfs).forEach(key => {
       this.files[key] = mfs[key]
diff --git a/src/core/utils.js b/src/core/utils.js
index 152f582202..24fcd68edb 100644
--- a/src/core/utils.js
+++ b/src/core/utils.js
@@ -105,31 +105,33 @@ const resolvePath = promisify(function (objectAPI, ipfsPaths, callback) {
 
     const rootHash = new CID(parsedPath.hash)
     const rootLinks = parsedPath.links
+
     if (!rootLinks.length) {
       return cb(null, rootHash.buffer)
     }
 
-    objectAPI.get(rootHash.multihash, follow.bind(null, rootLinks))
+    objectAPI.get(rootHash, follow.bind(null, rootHash, rootLinks))
 
     // recursively follow named links to the target node
-    function follow (links, err, obj) {
+    function follow (cid, links, err, obj) {
       if (err) {
         return cb(err)
       }
+
       if (!links.length) {
         // done tracing, obj is the target node
-        return cb(null, obj.multihash)
+        return cb(null, cid.buffer)
       }
 
       const linkName = links[0]
       const nextObj = obj.links.find(link => link.name === linkName)
       if (!nextObj) {
         return cb(new Error(
-          `no link named "${linkName}" under ${obj.toJSON().multihash}`
+          `no link named "${linkName}" under ${cid.toBaseEncodedString()}`
         ))
       }
 
-      objectAPI.get(nextObj.multihash, follow.bind(null, links.slice(1)))
+      objectAPI.get(nextObj.cid, follow.bind(null, nextObj.cid, links.slice(1)))
     }
   }, callback)
 })
diff --git a/src/http/api/resources/object.js b/src/http/api/resources/object.js
index dc68c71251..5d970dc1ae 100644
--- a/src/http/api/resources/object.js
+++ b/src/http/api/resources/object.js
@@ -6,7 +6,6 @@ const dagPB = require('ipld-dag-pb')
 const DAGLink = dagPB.DAGLink
 const DAGNode = dagPB.DAGNode
 const waterfall = require('async/waterfall')
-const series = require('async/series')
 const debug = require('debug')
 const log = debug('jsipfs:http-api:object')
 log.error = debug('jsipfs:http-api:object:error')
@@ -36,7 +35,10 @@ exports.new = (request, reply) => {
   const ipfs = request.server.app.ipfs
   const template = request.query.arg
 
-  ipfs.object.new(template, (err, node) => {
+  waterfall([
+    (cb) => ipfs.object.new(template, cb),
+    (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+  ], (err, results) => {
     if (err) {
       log.error(err)
       return reply({
@@ -45,17 +47,17 @@ exports.new = (request, reply) => {
       }).code(500)
     }
 
-    const nodeJSON = node.toJSON()
+    const nodeJSON = results.node.toJSON()
 
     const answer = {
       Data: nodeJSON.data,
-      Hash: nodeJSON.multihash,
+      Hash: results.cid.toBaseEncodedString(),
       Size: nodeJSON.size,
       Links: nodeJSON.links.map((l) => {
         return {
           Name: l.name,
           Size: l.size,
-          Hash: l.multihash
+          Hash: l.cid
         }
       })
     }
@@ -74,7 +76,10 @@ exports.get = {
     const enc = request.query.enc || 'base58'
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.get(key, { enc: enc }, (err, node) => {
+    waterfall([
+      (cb) => ipfs.object.get(key, { enc: enc }, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
         return reply({
@@ -83,21 +88,21 @@ exports.get = {
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
-      if (Buffer.isBuffer(node.data)) {
-        nodeJSON.data = node.data.toString(request.query['data-encoding'] || undefined)
+      if (Buffer.isBuffer(results.node.data)) {
+        nodeJSON.data = results.node.data.toString(request.query['data-encoding'] || undefined)
       }
 
       const answer = {
         Data: nodeJSON.data,
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Size: nodeJSON.size,
         Links: nodeJSON.links.map((l) => {
           return {
             Name: l.name,
             Size: l.size,
-            Hash: l.multihash
+            Hash: l.cid
           }
         })
       }
@@ -128,25 +133,28 @@ exports.put = {
       // TODO fix: stream is not emitting the 'end' event
       stream.on('data', (data) => {
         if (enc === 'protobuf') {
-          dagPB.util.deserialize(data, (err, node) => {
+          waterfall([
+            (cb) => dagPB.util.deserialize(data, cb),
+            (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+          ], (err, results) => {
             if (err) {
               return reply({
-                Message: 'Failed to receive protobuf encoded: ' + err,
+                Message: 'Failed to put object: ' + err,
                 Code: 0
               }).code(500).takeover()
             }
 
-            const nodeJSON = node.toJSON()
+            const nodeJSON = results.node.toJSON()
 
             const answer = {
               Data: nodeJSON.data,
-              Hash: nodeJSON.multihash,
+              Hash: results.cid.toBaseEncodedString(),
               Size: nodeJSON.size,
               Links: nodeJSON.links.map((l) => {
                 return {
                   Name: l.name,
                   Size: l.size,
-                  Hash: l.multihash
+                  Hash: l.cid
                 }
               })
             }
@@ -190,18 +198,11 @@ exports.put = {
     const ipfs = request.server.app.ipfs
     let node = request.pre.args.node
 
-    series([
-      (cb) => {
-        DAGNode.create(Buffer.from(node.Data), node.Links, (err, _node) => {
-          if (err) {
-            return cb(err)
-          }
-          node = _node
-          cb()
-        })
-      },
-      (cb) => ipfs.object.put(node, cb)
-    ], (err) => {
+    waterfall([
+      (cb) => DAGNode.create(Buffer.from(node.Data), node.Links, cb),
+      (node, cb) => ipfs.object.put(node, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { cid, node }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
 
@@ -211,17 +212,17 @@ exports.put = {
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
       const answer = {
         Data: nodeJSON.data,
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Size: nodeJSON.size,
         Links: nodeJSON.links.map((l) => {
           return {
             Name: l.name,
             Size: l.size,
-            Hash: l.multihash
+            Hash: l.cid
           }
         })
       }
@@ -244,7 +245,7 @@ exports.stat = {
       if (err) {
         log.error(err)
         return reply({
-          Message: 'Failed to get object: ' + err,
+          Message: 'Failed to stat object: ' + err,
           Code: 0
         }).code(500)
       }
@@ -267,7 +268,7 @@ exports.data = {
       if (err) {
         log.error(err)
         return reply({
-          Message: 'Failed to get object: ' + err,
+          Message: 'Failed to get object data: ' + err,
           Code: 0
         }).code(500)
       }
@@ -286,24 +287,27 @@ exports.links = {
     const key = request.pre.args.key
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.get(key, (err, node) => {
+    waterfall([
+      (cb) => ipfs.object.get(key, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
         return reply({
-          Message: 'Failed to get object: ' + err,
+          Message: 'Failed to get object links: ' + err,
           Code: 0
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
       return reply({
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Links: nodeJSON.links.map((l) => {
           return {
             Name: l.name,
             Size: l.size,
-            Hash: l.multihash
+            Hash: l.cid
           }
         })
       })
@@ -360,27 +364,30 @@ exports.patchAppendData = {
     const data = request.pre.args.data
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.patch.appendData(key, data, (err, node) => {
+    waterfall([
+      (cb) => ipfs.object.patch.appendData(key, data, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
 
         return reply({
-          Message: 'Failed to apend data to object: ' + err,
+          Message: 'Failed to append data to object: ' + err,
           Code: 0
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
       const answer = {
         Data: nodeJSON.data,
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Size: nodeJSON.size,
         Links: nodeJSON.links.map((l) => {
           return {
             Name: l.name,
             Size: l.size,
-            Hash: l.multihash
+            Hash: l.cid
           }
         })
       }
@@ -400,20 +407,23 @@ exports.patchSetData = {
     const data = request.pre.args.data
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.patch.setData(key, data, (err, node) => {
+    waterfall([
+      (cb) => ipfs.object.patch.setData(key, data, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
 
         return reply({
-          Message: 'Failed to apend data to object: ' + err,
+          Message: 'Failed to set data on object: ' + err,
           Code: 0
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
       return reply({
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Links: nodeJSON.links
       })
     })
@@ -464,50 +474,35 @@ exports.patchAddLink = {
     const ref = request.pre.args.ref
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.get(ref, (err, linkedObj) => {
+    waterfall([
+      (cb) => ipfs.object.get(ref, cb),
+      (node, cb) => ipfs.object.patch.addLink(root, new DAGLink(name, node.size, ref), cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
         return reply({
-          Message: 'Failed to get linked object: ' + err,
+          Message: 'Failed to add link to object: ' + err,
           Code: 0
         }).code(500)
       }
 
-      waterfall([
-        (cb) => {
-          const link = new DAGLink(
-            name,
-            linkedObj.size,
-            linkedObj.multihash)
-          cb(null, link)
-        },
-        (link, cb) => ipfs.object.patch.addLink(root, link, cb)
-      ], (err, node) => {
-        if (err) {
-          log.error(err)
-          return reply({
-            Message: 'Failed to get linked object: ' + err,
-            Code: 0
-          }).code(500)
-        }
+      const nodeJSON = results.node.toJSON()
 
-        const nodeJSON = node.toJSON()
-
-        const answer = {
-          Data: nodeJSON.data,
-          Hash: nodeJSON.multihash,
-          Size: nodeJSON.size,
-          Links: nodeJSON.links.map((l) => {
-            return {
-              Name: l.name,
-              Size: l.size,
-              Hash: l.multihash
-            }
-          })
-        }
+      const answer = {
+        Data: nodeJSON.data,
+        Hash: results.cid.toBaseEncodedString(),
+        Size: nodeJSON.size,
+        Links: nodeJSON.links.map((l) => {
+          return {
+            Name: l.name,
+            Size: l.size,
+            Hash: l.cid
+          }
+        })
+      }
 
-        return reply(answer)
-      })
+      return reply(answer)
     })
   }
 }
@@ -547,7 +542,10 @@ exports.patchRmLink = {
     const link = request.pre.args.link
     const ipfs = request.server.app.ipfs
 
-    ipfs.object.patch.rmLink(root, { name: link }, (err, node) => {
+    waterfall([
+      (cb) => ipfs.object.patch.rmLink(root, { name: link }, cb),
+      (node, cb) => dagPB.util.cid(node, (err, cid) => cb(err, { node, cid }))
+    ], (err, results) => {
       if (err) {
         log.error(err)
         return reply({
@@ -556,17 +554,17 @@ exports.patchRmLink = {
         }).code(500)
       }
 
-      const nodeJSON = node.toJSON()
+      const nodeJSON = results.node.toJSON()
 
       const answer = {
         Data: nodeJSON.data,
-        Hash: nodeJSON.multihash,
+        Hash: results.cid.toBaseEncodedString(),
         Size: nodeJSON.size,
         Links: nodeJSON.links.map((l) => {
           return {
             Name: l.name,
             Size: l.size,
-            Hash: l.multihash
+            Hash: l.cid
           }
         })
       }
diff --git a/test/core/object.spec.js b/test/core/object.spec.js
index 6dc0c10fb7..ab1d0eea85 100644
--- a/test/core/object.spec.js
+++ b/test/core/object.spec.js
@@ -9,7 +9,13 @@ chai.use(dirtyChai)
 const hat = require('hat')
 const IPFSFactory = require('ipfsd-ctl')
 const auto = require('async/auto')
+const waterfall = require('async/waterfall')
 const IPFS = require('../../src/core')
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 describe('object', () => {
   let ipfsd, ipfs
@@ -52,23 +58,19 @@ describe('object', () => {
       ipfs.object.put(Buffer.from(hat()), (err, dagNode) => {
         expect(err).to.not.exist()
 
-        ipfs.object.get(dagNode.multihash, null, (err) => {
+        cid(dagNode, (err, result) => {
           expect(err).to.not.exist()
-          done()
+
+          ipfs.object.get(result, null, (err) => {
+            expect(err).to.not.exist()
+            done()
+          })
         })
       })
     })
   })
 
   describe('put', () => {
-    it('should callback with error for invalid CID input', (done) => {
-      ipfs.object.put({ multihash: 'INVALID CID' }, (err) => {
-        expect(err).to.exist()
-        expect(err.code).to.equal('ERR_INVALID_CID')
-        done()
-      })
-    })
-
     it('should not error when passed null options', (done) => {
       ipfs.object.put(Buffer.from(hat()), null, (err) => {
         expect(err).to.not.exist()
@@ -80,18 +82,28 @@ describe('object', () => {
   describe('patch.addLink', () => {
     it('should not error when passed null options', (done) => {
       auto({
-        a: (cb) => ipfs.object.put(Buffer.from(hat()), cb),
-        b: (cb) => ipfs.object.put(Buffer.from(hat()), cb)
-      }, (err, nodes) => {
+        a: (cb) => {
+          waterfall([
+            (done) => ipfs.object.put(Buffer.from(hat()), done),
+            (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+          ], cb)
+        },
+        b: (cb) => {
+          waterfall([
+            (done) => ipfs.object.put(Buffer.from(hat()), done),
+            (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+          ], cb)
+        }
+      }, (err, results) => {
         expect(err).to.not.exist()
 
         const link = {
-          name: nodes.b.name,
-          multihash: nodes.b.multihash,
-          size: nodes.b.size
+          name: 'link-name',
+          cid: results.b.cid,
+          size: results.b.node.size
         }
 
-        ipfs.object.patch.addLink(nodes.a.multihash, link, null, (err) => {
+        ipfs.object.patch.addLink(results.a.cid, link, null, (err) => {
           expect(err).to.not.exist()
           done()
         })
@@ -102,20 +114,33 @@ describe('object', () => {
   describe('patch.rmLink', () => {
     it('should not error when passed null options', (done) => {
       auto({
-        nodeA: (cb) => ipfs.object.put(Buffer.from(hat()), cb),
-        nodeB: (cb) => ipfs.object.put(Buffer.from(hat()), cb),
+        nodeA: (cb) => {
+          waterfall([
+            (done) => ipfs.object.put(Buffer.from(hat()), done),
+            (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+          ], cb)
+        },
+        nodeB: (cb) => {
+          waterfall([
+            (done) => ipfs.object.put(Buffer.from(hat()), done),
+            (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+          ], cb)
+        },
         nodeAWithLink: ['nodeA', 'nodeB', (res, cb) => {
-          ipfs.object.patch.addLink(res.nodeA.multihash, {
-            name: res.nodeB.name,
-            multihash: res.nodeB.multihash,
-            size: res.nodeB.size
-          }, cb)
+          waterfall([
+            (done) => ipfs.object.patch.addLink(res.nodeA.cid, {
+              name: res.nodeB.node.name,
+              multihash: res.nodeB.cid,
+              size: res.nodeB.node.size
+            }, done),
+            (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+          ], cb)
         }]
       }, (err, res) => {
         expect(err).to.not.exist()
 
-        const link = res.nodeAWithLink.links[0]
-        ipfs.object.patch.rmLink(res.nodeAWithLink.multihash, link, null, (err) => {
+        const link = res.nodeAWithLink.node.links[0]
+        ipfs.object.patch.rmLink(res.nodeAWithLink.cid, link, null, (err) => {
           expect(err).to.not.exist()
           done()
         })
@@ -128,9 +153,13 @@ describe('object', () => {
       ipfs.object.put(Buffer.from(hat()), null, (err, dagNode) => {
         expect(err).to.not.exist()
 
-        ipfs.object.patch.appendData(dagNode.multihash, Buffer.from(hat()), null, (err) => {
+        cid(dagNode, (err, result) => {
           expect(err).to.not.exist()
-          done()
+
+          ipfs.object.patch.appendData(result, Buffer.from(hat()), null, (err) => {
+            expect(err).to.not.exist()
+            done()
+          })
         })
       })
     })
@@ -141,9 +170,13 @@ describe('object', () => {
       ipfs.object.put(Buffer.from(hat()), null, (err, dagNode) => {
         expect(err).to.not.exist()
 
-        ipfs.object.patch.setData(dagNode.multihash, Buffer.from(hat()), null, (err) => {
+        cid(dagNode, (err, result) => {
           expect(err).to.not.exist()
-          done()
+
+          ipfs.object.patch.setData(result, Buffer.from(hat()), null, (err) => {
+            expect(err).to.not.exist()
+            done()
+          })
         })
       })
     })
diff --git a/test/core/pin-set.js b/test/core/pin-set.js
index 5207bd48ad..ece713d61c 100644
--- a/test/core/pin-set.js
+++ b/test/core/pin-set.js
@@ -9,8 +9,12 @@ chai.use(dirtyChai)
 
 const parallelLimit = require('async/parallelLimit')
 const series = require('async/series')
-const { fromB58String } = require('multihashes')
-const { DAGNode } = require('ipld-dag-pb')
+const {
+  util: {
+    cid
+  },
+  DAGNode
+} = require('ipld-dag-pb')
 const CID = require('cids')
 
 const IPFS = require('../../src/core')
@@ -31,7 +35,7 @@ function createNodes (num, callback) {
   const items = []
   for (let i = 0; i < num; i++) {
     items.push(cb =>
-      createNode(String(i), (err, node) => cb(err, node.multihash))
+      createNode(String(i), (err, res) => cb(err, res.cid.toBaseEncodedString()))
     )
   }
 
@@ -44,7 +48,18 @@ function createNode (data, links = [], callback) {
     links = []
   }
 
-  DAGNode.create(data, links, callback)
+  DAGNode.create(data, links, (err, node) => {
+    if (err) {
+      return callback(err)
+    }
+
+    cid(node, (err, result) => {
+      callback(err, {
+        node,
+        cid: result
+      })
+    })
+  })
 }
 
 describe('pinSet', function () {
@@ -73,17 +88,16 @@ describe('pinSet', function () {
     it('generates a root node with links and hash', function (done) {
       const expectedRootHash = 'QmcLiSTjcjoVC2iuGbk6A2PVcWV3WvjZT4jxfNis1vjyrR'
 
-      createNode('data', (err, node) => {
+      createNode('data', (err, result) => {
         expect(err).to.not.exist()
-        const nodeHash = node.multihash
+        const nodeHash = result.cid.toBaseEncodedString()
         pinSet.storeSet([nodeHash], (err, rootNode) => {
           expect(err).to.not.exist()
-          const node = rootNode.toJSON()
-          expect(node.multihash).to.eql(expectedRootHash)
-          expect(node.links).to.have.length(defaultFanout + 1)
+          expect(rootNode.cid.toBaseEncodedString()).to.eql(expectedRootHash)
+          expect(rootNode.node.links).to.have.length(defaultFanout + 1)
 
-          const lastLink = node.links[node.links.length - 1]
-          const mhash = fromB58String(lastLink.multihash)
+          const lastLink = rootNode.node.links[rootNode.node.links.length - 1]
+          const mhash = lastLink.cid.toBaseEncodedString()
           expect(mhash).to.eql(nodeHash)
           done()
         })
@@ -96,23 +110,22 @@ describe('pinSet', function () {
       this.timeout(19 * 1000)
       const expectedHash = 'QmbvhSy83QWfgLXDpYjDmLWBFfGc8utoqjcXHyj3gYuasT'
       const count = maxItems + 1
-      createNodes(count, (err, nodes) => {
+      createNodes(count, (err, cids) => {
         expect(err).to.not.exist()
-        pinSet.storeSet(nodes, (err, node) => {
+        pinSet.storeSet(cids, (err, result) => {
           expect(err).to.not.exist()
 
-          node = node.toJSON()
-          expect(node.size).to.eql(3184696)
-          expect(node.links).to.have.length(defaultFanout)
-          expect(node.multihash).to.eql(expectedHash)
+          expect(result.node.size).to.eql(3184696)
+          expect(result.node.links).to.have.length(defaultFanout)
+          expect(result.cid.toBaseEncodedString()).to.eql(expectedHash)
 
-          pinSet.loadSet(node, '', (err, loaded) => {
+          pinSet.loadSet(result.node, '', (err, loaded) => {
             expect(err).to.not.exist()
             expect(loaded).to.have.length(30)
             const hashes = loaded.map(l => new CID(l).toBaseEncodedString())
 
             // just check the first node, assume all are children if successful
-            pinSet.hasDescendant(node, hashes[0], (err, has) => {
+            pinSet.hasDescendant(result.node, hashes[0], (err, has) => {
               expect(err).to.not.exist()
               expect(has).to.eql(true)
               done()
@@ -174,10 +187,10 @@ describe('pinSet', function () {
       createNodes(defaultFanout, (err, nodes) => {
         expect(err).to.not.exist()
 
-        pinSet.storeSet(nodes, (err, node) => {
+        pinSet.storeSet(nodes, (err, result) => {
           expect(err).to.not.exist()
 
-          pinSet.walkItems(node, walker, err => {
+          pinSet.walkItems(result.node, walker, err => {
             expect(err).to.not.exist()
             expect(seen).to.have.length(defaultFanout)
             expect(seen[0].idx).to.eql(defaultFanout)
diff --git a/test/core/pin.js b/test/core/pin.js
index f99ded2548..6cfb57a49f 100644
--- a/test/core/pin.js
+++ b/test/core/pin.js
@@ -126,7 +126,7 @@ describe('pin', function () {
       return pin._isPinnedWithType(pins.mercuryWiki, pinTypes.indirect)
         .then(result => {
           expect(result.pinned).to.eql(true)
-          expect(result.reason).to.eql(pins.root)
+          expect(result.reason.toBaseEncodedString()).to.eql(pins.root)
         })
     })
 
diff --git a/test/core/preload.spec.js b/test/core/preload.spec.js
index 37528b81fe..8af0743880 100644
--- a/test/core/preload.spec.js
+++ b/test/core/preload.spec.js
@@ -3,13 +3,17 @@
 'use strict'
 
 const hat = require('hat')
-const CID = require('cids')
 const parallel = require('async/parallel')
 const waterfall = require('async/waterfall')
 const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 const expect = chai.expect
 chai.use(dirtyChai)
+const {
+  util: {
+    cid
+  }
+} = require('ipld-dag-pb')
 
 const MockPreloadNode = require('../utils/mock-preload-node')
 const IPFS = require('../../src')
@@ -157,8 +161,11 @@ describe('preload', () => {
     ipfs.object.new((err, node) => {
       expect(err).to.not.exist()
 
-      const cid = new CID(node.multihash)
-      MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+      cid(node, (err, result) => {
+        expect(err).to.not.exist()
+
+        MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+      })
     })
   })
 
@@ -166,27 +173,43 @@ describe('preload', () => {
     ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, (err, node) => {
       expect(err).to.not.exist()
 
-      const cid = new CID(node.multihash)
-      MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+      cid(node, (err, result) => {
+        expect(err).to.not.exist()
+
+        MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+      })
     })
   })
 
   it('should preload content added with object.patch.addLink', (done) => {
     parallel({
-      parent: (cb) => ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, cb),
-      link: (cb) => ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, cb)
-    }, (err, nodes) => {
+      parent: (cb) => {
+        waterfall([
+          (done) => ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, done),
+          (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+        ], cb)
+      },
+      link: (cb) => {
+        waterfall([
+          (done) => ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, done),
+          (node, done) => cid(node, (err, cid) => done(err, { node, cid }))
+        ], cb)
+      }
+    }, (err, result) => {
       expect(err).to.not.exist()
 
-      ipfs.object.patch.addLink(nodes.parent.multihash, {
+      ipfs.object.patch.addLink(result.parent.cid, {
         name: 'link',
-        multihash: nodes.link.multihash,
-        size: nodes.link.size
+        cid: result.link.cid,
+        size: result.link.node.size
       }, (err, node) => {
         expect(err).to.not.exist()
 
-        const cid = new CID(node.multihash)
-        MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+        cid(node, (err, result) => {
+          expect(err).to.not.exist()
+
+          MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+        })
       })
     })
   })
@@ -194,24 +217,32 @@ describe('preload', () => {
   it('should preload content added with object.patch.rmLink', (done) => {
     waterfall([
       (cb) => ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, cb),
-      (link, cb) => {
+      (node, cb) => cid(node, (err, cid) => cb(err, { node, cid })),
+      ({ node, cid }, cb) => {
         ipfs.object.put({
           Data: Buffer.from(hat()),
           Links: [{
             name: 'link',
-            multihash: link.multihash,
-            size: link.size
+            cid: cid,
+            size: node.size
           }]
         }, cb)
       }
     ], (err, parent) => {
       expect(err).to.not.exist()
 
-      ipfs.object.patch.rmLink(parent.multihash, { name: 'link' }, (err, node) => {
+      cid(parent, (err, result) => {
         expect(err).to.not.exist()
 
-        const cid = new CID(node.multihash)
-        MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+        ipfs.object.patch.rmLink(result, { name: 'link' }, (err, node) => {
+          expect(err).to.not.exist()
+
+          cid(node, (err, result) => {
+            expect(err).to.not.exist()
+
+            MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+          })
+        })
       })
     })
   })
@@ -220,11 +251,18 @@ describe('preload', () => {
     ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, (err, node) => {
       expect(err).to.not.exist()
 
-      ipfs.object.patch.setData(node.multihash, Buffer.from(hat()), (err, node) => {
+      cid(node, (err, result) => {
         expect(err).to.not.exist()
 
-        const cid = new CID(node.multihash)
-        MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+        ipfs.object.patch.setData(result, Buffer.from(hat()), (err, node) => {
+          expect(err).to.not.exist()
+
+          cid(node, (err, result) => {
+            expect(err).to.not.exist()
+
+            MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+          })
+        })
       })
     })
   })
@@ -233,11 +271,18 @@ describe('preload', () => {
     ipfs.object.put({ Data: Buffer.from(hat()), Links: [] }, (err, node) => {
       expect(err).to.not.exist()
 
-      ipfs.object.patch.appendData(node.multihash, Buffer.from(hat()), (err, node) => {
+      cid(node, (err, result) => {
         expect(err).to.not.exist()
 
-        const cid = new CID(node.multihash)
-        MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+        ipfs.object.patch.appendData(result, Buffer.from(hat()), (err, node) => {
+          expect(err).to.not.exist()
+
+          cid(node, (err, result) => {
+            expect(err).to.not.exist()
+
+            MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+          })
+        })
       })
     })
   })
@@ -245,10 +290,15 @@ describe('preload', () => {
   it('should preload content retrieved with object.get', (done) => {
     ipfs.object.new(null, { preload: false }, (err, node) => {
       expect(err).to.not.exist()
-      ipfs.object.get(node.multihash, (err) => {
+
+      cid(node, (err, result) => {
         expect(err).to.not.exist()
-        const cid = new CID(node.multihash)
-        MockPreloadNode.waitForCids(cid.toBaseEncodedString(), done)
+
+        ipfs.object.get(result, (err) => {
+          expect(err).to.not.exist()
+
+          MockPreloadNode.waitForCids(result.toBaseEncodedString(), done)
+        })
       })
     })
   })
diff --git a/test/http-api/object.js b/test/http-api/object.js
index a056ad95cd..39482e9961 100644
--- a/test/http-api/object.js
+++ b/test/http-api/object.js
@@ -45,10 +45,14 @@ describe('object endpoint', () => {
     it('.new', (done) => {
       ipfs.object.new(asJson((err, res) => {
         expect(err).to.not.exist()
-        expect(res.multihash)
-          .to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
         expect(res.links).to.be.eql([])
-        done()
+
+        dagPB.util.cid(res, (err, cid) => {
+          expect(err).to.not.exist()
+          expect(cid.toBaseEncodedString())
+            .to.equal('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n')
+          done()
+        })
       }))
     })
 
@@ -91,10 +95,9 @@ describe('object endpoint', () => {
         const filePath = fs.readFileSync('test/fixtures/test-data/node.json')
         const expectedResult = {
           data: Buffer.from('another'),
-          multihash: 'QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm',
           links: [{
             name: 'some link',
-            multihash: 'QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V',
+            cid: 'QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V',
             size: 8
           }],
           size: 68
@@ -103,7 +106,13 @@ describe('object endpoint', () => {
         ipfs.object.put(filePath, { enc: 'json' }, asJson((err, res) => {
           expect(err).to.not.exist()
           expect(res).to.eql(expectedResult)
-          done()
+
+          dagPB.util.cid(res, (err, cid) => {
+            expect(err).to.not.exist()
+            expect(cid.toBaseEncodedString())
+              .to.equal('QmZZmY4KCu9r3e7M2Pcn46Fc5qbn6NpzaAGaYb22kbfTqm')
+            done()
+          })
         }))
       })
     })
@@ -179,7 +188,7 @@ describe('object endpoint', () => {
       it('returns value', (done) => {
         const expectedResult = {
           name: 'some link',
-          multihash: 'QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V',
+          cid: 'QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V',
           size: 8
         }
 
@@ -213,7 +222,6 @@ describe('object endpoint', () => {
         const filePath = 'test/fixtures/test-data/badnode.json'
         const expectedResult = {
           data: fs.readFileSync(filePath),
-          multihash: 'QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6',
           links: [],
           size: 19
         }
@@ -221,7 +229,13 @@ describe('object endpoint', () => {
         ipfs.object.patch.appendData(key, filePath, { enc: 'base58' }, asJson((err, res) => {
           expect(err).to.not.exist()
           expect(res).to.eql(expectedResult)
-          done()
+
+          dagPB.util.cid(res, (err, cid) => {
+            expect(err).to.not.exist()
+            expect(cid.toBaseEncodedString())
+              .to.equal('QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6')
+            done()
+          })
         }))
       })
     })
@@ -248,7 +262,6 @@ describe('object endpoint', () => {
         const filePath = 'test/fixtures/test-data/badnode.json'
         const expectedResult = {
           data: fs.readFileSync(filePath),
-          multihash: 'QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6',
           links: [],
           size: 19
         }
@@ -256,7 +269,13 @@ describe('object endpoint', () => {
         ipfs.object.patch.setData(key, filePath, { enc: 'base58' }, asJson((err, res) => {
           expect(err).to.not.exist()
           expect(res).to.eql(expectedResult)
-          done()
+
+          dagPB.util.cid(res, (err, cid) => {
+            expect(err).to.not.exist()
+            expect(cid.toBaseEncodedString())
+              .to.equal('QmfY37rjbPCZRnhvvJuQ46htW3VCAWziVB991P79h6WSv6')
+            done()
+          })
         }))
       })
     })
@@ -294,13 +313,18 @@ describe('object endpoint', () => {
         const link = new DAGLink(name, 10, ref)
         ipfs.object.patch.addLink(root, link, { enc: 'base58' }, asJson((err, res) => {
           expect(err).not.to.exist()
-          expect(res.multihash).to.equal('QmdVHE8fUD6FLNLugtNxqDFyhaCgdob372hs6BYEe75VAK')
           expect(res.links[0]).to.eql({
             name: 'foo',
-            multihash: 'QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn',
+            cid: 'QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn',
             size: 4
           })
-          done()
+
+          dagPB.util.cid(res, (err, cid) => {
+            expect(err).to.not.exist()
+            expect(cid.toBaseEncodedString())
+              .to.equal('QmdVHE8fUD6FLNLugtNxqDFyhaCgdob372hs6BYEe75VAK')
+            done()
+          })
         }))
       })
     })