fix: dnslink resolver under js-ipfs

js-ipfs v0.34 does not support DNSLinks in ipfs*resolve methods:
ipfs/js-ipfs#1918

This temporary workaround detects known errors and falls back to
using path from DNSLink cache. It won't be as fresh as original,
but at least resolv will work.

Author: lidel

add-on/src/lib/copier.js

@@ -40,8 +40,8 @@ function createCopier (notify, ipfsPathValidator) {
     },
 
     async copyRawCid (context, contextType) {
+      const url = await findValueForContext(context, contextType)
       try {
-        const url = await findValueForContext(context, contextType)
         const cid = await ipfsPathValidator.resolveToCid(url)
         await copyTextToClipboard(cid, notify)
       } catch (error) {

add-on/src/lib/ipfs-path.js

@@ -2,6 +2,7 @@
 /* eslint-env browser */
 
 const IsIpfs = require('is-ipfs')
+const isFQDN = require('is-fqdn')
 
 function normalizedIpfsPath (urlOrPath) {
   let result = urlOrPath
@@ -74,7 +75,6 @@ function createIpfsPathValidator (getState, getIpfs, dnslinkResolver) {
 
     // Test if actions such as 'copy URL', 'pin/unpin' should be enabled for the URL
     isIpfsPageActionsContext (url) {
-      console.log(url)
       return Boolean(url && !url.startsWith(getState().apiURLString) && (
         IsIpfs.url(url) ||
         IsIpfs.subdomain(url) ||
@@ -147,7 +147,34 @@ function createIpfsPathValidator (getState, getIpfs, dnslinkResolver) {
         const labels = path.split('/')
         // We resolve /ipns/<fqdn> as value in DNSLink cache may be out of date
         const ipnsRoot = `/ipns/${labels[2]}`
-        const result = await getIpfs().name.resolve(ipnsRoot, { recursive: true, nocache: false })
+
+        // js-ipfs v0.34 does not support DNSLinks in ipfs.name.resolve: https://github.com/ipfs/js-ipfs/issues/1918
+        // TODO: remove ipfsNameResolveWithDnslinkFallback when js-ipfs implements DNSLink support in ipfs.name.resolve
+        const ipfsNameResolveWithDnslinkFallback = async (resolve) => {
+          try {
+            return await resolve()
+          } catch (err) {
+            const fqdn = ipnsRoot.replace(/^.*\/ipns\/([^/]+).*/, '$1')
+            console.log('fqdn:' + ipnsRoot, fqdn)
+            if (err.message === 'Non-base58 character' && isFQDN(fqdn)) {
+              // js-ipfs without dnslink support, fallback to the value read from DNSLink
+              const dnslink = dnslinkResolver.readAndCacheDnslink(fqdn)
+              if (dnslink) {
+                // swap problematic /ipns/{fqdn} with /ipfs/{cid} and retry lookup
+                const safePath = trimDoubleSlashes(ipnsRoot.replace(/^.*(\/ipns\/[^/]+)/, dnslink))
+                if (ipnsRoot !== safePath) {
+                  return ipfsPathValidator.resolveToImmutableIpfsPath(safePath)
+                }
+              }
+            }
+            throw err
+          }
+        }
+        const result = await ipfsNameResolveWithDnslinkFallback(async () =>
+          // dhtt/dhtrc optimize for lookup time
+          getIpfs().name.resolve(ipnsRoot, { recursive: true, dhtt: '5s', dhtrc: 1 })
+        )
+
         // Old API returned object, latest one returns string ¯\_(ツ)_/¯
         const ipfsRoot = result.Path ? result.Path : result
         // Return original path with swapped root (keeps pathname + ?search + #hash)
@@ -157,27 +184,53 @@ function createIpfsPathValidator (getState, getIpfs, dnslinkResolver) {
       return path
     },
 
-    // TODO: add description and tests
     // Resolve URL or path to a raw CID:
     // - Result is the direct CID
     // - Ignores ?search and #hash from original URL
     // - Returns null if no CID can be produced
+    // The purpose of this resolver is to return direct CID without anything else.
     async resolveToCid (urlOrPath) {
       const path = ipfsPathValidator.resolveToIpfsPath(urlOrPath)
       // Fail fast if no IPFS Path
       if (!path) return null
-      // Resolve to raw CID
+      // Drop unused parts
       const rawPath = trimHashAndSearch(path)
-      const result = await getIpfs().resolve(rawPath, { recursive: true, dhtt: '5s', dhtrc: 1 })
-      const directCid = result.split('/')[2]
+
+      // js-ipfs v0.34 does not support DNSLinks in ipfs.resolve: https://github.com/ipfs/js-ipfs/issues/1918
+      // TODO: remove ipfsResolveWithDnslinkFallback when js-ipfs implements DNSLink support in ipfs.resolve
+      const ipfsResolveWithDnslinkFallback = async (resolve) => {
+        try {
+          return await resolve()
+        } catch (err) {
+          const fqdn = rawPath.replace(/^.*\/ipns\/([^/]+).*/, '$1')
+          if (err.message === 'resolve non-IPFS names is not implemented' && isFQDN(fqdn)) {
+            // js-ipfs without dnslink support, fallback to the value read from DNSLink
+            const dnslink = dnslinkResolver.readAndCacheDnslink(fqdn)
+            if (dnslink) {
+              // swap problematic /ipns/{fqdn} with /ipfs/{cid} and retry lookup
+              const safePath = trimDoubleSlashes(rawPath.replace(/^.*(\/ipns\/[^/]+)/, dnslink))
+              if (rawPath !== safePath) {
+                const result = await ipfsPathValidator.resolveToCid(safePath)
+                // return in format of ipfs.resolve()
+                return IsIpfs.cid(result) ? `/ipfs/${result}` : result
+              }
+            }
+          }
+          throw err
+        }
+      }
+      const result = await ipfsResolveWithDnslinkFallback(async () =>
+        // dhtt/dhtrc optimize for lookup time
+        getIpfs().resolve(rawPath, { recursive: true, dhtt: '5s', dhtrc: 1 })
+      )
+
+      const directCid = IsIpfs.ipfsPath(result) ? result.split('/')[2] : result
       return directCid
     }
-
   }
 
   return ipfsPathValidator
 }
-
 exports.createIpfsPathValidator = createIpfsPathValidator
 
 function validIpfsOrIpnsUrl (url, dnsLink) {

add-on/src/popup/browser-action/store.js

@@ -322,6 +322,6 @@ async function resolveToPinPath (ipfs, url) {
   // https://github.com/ipfs-shipyard/ipfs-companion/issues/567
   // https://github.com/ipfs/ipfs-companion/issues/303
   const pathValidator = await getIpfsPathValidator()
-  const pinPath = trimHashAndSearch(pathValidator.resolveToImmutableIpfsPath(url))
+  const pinPath = trimHashAndSearch(await pathValidator.resolveToImmutableIpfsPath(url))
   return pinPath
 }

test/functional/lib/ipfs-path.test.js

@@ -1,6 +1,6 @@
 'use strict'
 const { stub } = require('sinon')
-const { describe, it, beforeEach } = require('mocha')
+const { describe, it, beforeEach, afterEach } = require('mocha')
 const { expect } = require('chai')
 const { URL } = require('url')
 const { normalizedIpfsPath, createIpfsPathValidator } = require('../../../add-on/src/lib/ipfs-path')
@@ -10,14 +10,12 @@ const { optionDefaults } = require('../../../add-on/src/lib/options')
 const { spoofCachedDnslink } = require('./dnslink.test.js')
 
 function spoofIpnsRecord (ipfs, ipnsPath, value) {
-  if (ipfs.name.resolve.reset) ipfs.name.resolve.reset()
   const resolve = stub(ipfs.name, 'resolve')
   resolve.withArgs(ipnsPath).resolves(value)
   resolve.throws((arg) => new Error(`Unexpected stubbed call ipfs.name.resolve(${arg})`))
 }
 
 function spoofIpfsResolve (ipfs, path, value) {
-  if (ipfs.resolve.reset) ipfs.resolve.reset()
   const resolve = stub(ipfs, 'resolve')
   resolve.withArgs(path).resolves(value)
   resolve.throws((arg) => new Error(`Unexpected stubbed call ipfs.resolve(${arg})`))
@@ -44,6 +42,11 @@ describe('ipfs-path.js', function () {
     ipfsPathValidator = createIpfsPathValidator(() => state, () => ipfs, dnslinkResolver)
   })
 
+  afterEach(function () {
+    if (ipfs.name.resolve.reset) ipfs.name.resolve.reset()
+    if (ipfs.resolve.reset) ipfs.resolve.reset()
+  })
+
   describe('normalizedIpfsPath', function () {
     it('should detect /ipfs/ path in URL from a public gateway', function () {
       const url = 'https://ipfs.io/ipfs/QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR/foo/bar'
@@ -338,6 +341,22 @@ describe('ipfs-path.js', function () {
       spoofIpnsRecord(ipfs, `/ipns/${hostname}`, ipnsPointer)
       expect(await ipfsPathValidator.resolveToImmutableIpfsPath(url)).to.equal(ipnsPointer + '/guides/concepts/dnslink/?argTest#hashTest')
     })
+    // TODO: remove when https://github.com/ipfs/js-ipfs/issues/1918 is addressed
+    it('should resolve URL of a DNSLink website to the immutable /ipfs/ address behind mutable /ipns/ DNSLink in cache (js-ipfs fallback)', async function () {
+      const url = 'https://docs.ipfs.io/guides/concepts/dnslink/?argTest#hashTest'
+      // Use IPNS in DNSLINK to ensure resolveToImmutableIpfsPath does resursive resolv to immutable address
+      const dnslinkValue = '/ipns/QmRV5iNhGoxBaAcbucMAW9WtVHbeehXhAdr5CZQDhL55Xk'
+      const ipnsPointer = '/ipfs/QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR'
+      const { hostname } = new URL(url)
+      spoofCachedDnslink(hostname, dnslinkResolver, dnslinkValue)
+      // js-ipfs v0.34 does not support DNSLinks in ipfs.name.resolve: https://github.com/ipfs/js-ipfs/issues/1918
+      const resolve = stub(ipfs.name, 'resolve')
+      resolve.withArgs(`/ipns/${hostname}`).throws(new Error('Non-base58 character'))
+      // until it is implemented, we have a workaround that falls back to value from dnslink
+      resolve.withArgs(dnslinkValue).resolves(ipnsPointer)
+      resolve.throws((arg) => new Error(`Unexpected stubbed call ipfs.name.resolve(${arg})`))
+      expect(await ipfsPathValidator.resolveToImmutableIpfsPath(url)).to.equal(ipnsPointer + '/guides/concepts/dnslink/?argTest#hashTest')
+    })
     it('should resolve to null if input is an invalid path', async function () {
       const path = '/foo/bar/?argTest#hashTest'
       expect(await ipfsPathValidator.resolveToImmutableIpfsPath(path)).to.equal(null)
@@ -398,6 +417,24 @@ describe('ipfs-path.js', function () {
       spoofIpfsResolve(ipfs, `/ipns/docs.ipfs.io/guides/concepts/dnslink/`, `/ipfs/${expectedCid}`)
       expect(await ipfsPathValidator.resolveToCid(url)).to.equal(expectedCid)
     })
+    // TODO: remove when https://github.com/ipfs/js-ipfs/issues/1918 is addressed
+    it('should resolve URL of a DNSLink website if DNSLink is in cache (js-ipfs fallback)', async function () {
+      const url = 'https://docs.ipfs.io/guides/concepts/dnslink/?argTest#hashTest'
+      // Use IPNS in DNSLINK to ensure resolveToImmutableIpfsPath does resursive resolv to immutable address
+      const expectedCid = 'QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR'
+      const dnslinkValue = '/ipns/QmRV5iNhGoxBaAcbucMAW9WtVHbeehXhAdr5CZQDhL55Xk'
+      const { hostname } = new URL(url)
+      spoofCachedDnslink(hostname, dnslinkResolver, dnslinkValue)
+      // Note the DNSLink value is ignored, and /ipns/<fqdn> is passed to ipfs.resolv internally
+      // This ensures the latest pointer is returned, instead of stale value from DNSLink cache
+      // js-ipfs v0.34 does not support DNSLinks in ipfs.name.resolve: https://github.com/ipfs/js-ipfs/issues/1918
+      const resolve = stub(ipfs, 'resolve')
+      resolve.withArgs(`/ipns/docs.ipfs.io/guides/concepts/dnslink/`).throws(new Error('resolve non-IPFS names is not implemented'))
+      // until it is implemented, we have a workaround that falls back to value from dnslink
+      resolve.withArgs('/ipns/QmRV5iNhGoxBaAcbucMAW9WtVHbeehXhAdr5CZQDhL55Xk/guides/concepts/dnslink/').resolves(`/ipfs/${expectedCid}`)
+      resolve.throws((arg) => new Error(`Unexpected stubbed call ipfs.resolve(${arg})`))
+      expect(await ipfsPathValidator.resolveToCid(url)).to.equal(expectedCid)
+    })
     it('should resolve to null if input is an invalid path', async function () {
       const path = '/foo/bar/?argTest#hashTest'
       expect(await ipfsPathValidator.resolveToCid(path)).to.equal(null)