Merge pull request #303 from ensdomains/fix/universal-resolver-http-e…

…rror

fix: universal resolver http error

contracts/utils/UniversalResolver.sol

@@ -594,11 +594,10 @@ contract UniversalResolver is ERC165, Ownable {
     function _checkResolveSingle(Result memory result) internal pure {
         if (!result.success) {
             if (bytes4(result.returnData) == HttpError.selector) {
-                (, HttpErrorItem[] memory errors) = abi.decode(
-                    result.returnData,
-                    (bytes4, HttpErrorItem[])
-                );
-                revert HttpError(errors);
+                bytes memory returnData = result.returnData;
+                assembly {
+                    revert(add(returnData, 32), mload(returnData))
+                }
             }
             revert ResolverError(result.returnData);
         }

test/utils/TestUniversalResolver.js

@@ -262,15 +262,12 @@ contract('UniversalResolver', function (accounts) {
         [namehash.hash('no-resolver.test.other')],
       )
 
-      try {
-        await universalResolver['resolve(bytes,bytes)'](
+      await expect(
+        universalResolver['resolve(bytes,bytes)'](
           dns.hexEncodeName('no-resolver.test.other'),
           data,
-        )
-        expect(false).to.be.true
-      } catch (e) {
-        expect(e.errorName).to.equal('ResolverNotFound')
-      }
+        ),
+      ).to.be.revertedWith('ResolverNotFound')
     })
 
     it('should throw if a resolver is not a contract', async () => {
@@ -279,15 +276,12 @@ contract('UniversalResolver', function (accounts) {
         [namehash.hash('non-contract-resolver.test.eth')],
       )
 
-      try {
-        await universalResolver['resolve(bytes,bytes)'](
+      await expect(
+        universalResolver['resolve(bytes,bytes)'](
           dns.hexEncodeName('non-contract-resolver.test.eth'),
           data,
-        )
-        expect(false).to.be.true
-      } catch (e) {
-        expect(e.errorName).to.equal('ResolverNotContract')
-      }
+        ),
+      ).to.be.revertedWith('ResolverNotContract')
     })
 
     it('should throw with revert data if resolver reverts', async () => {
@@ -326,14 +320,12 @@ contract('UniversalResolver', function (accounts) {
         [namehash.hash('no-resolver.test.eth')],
       )
 
-      try {
-        await universalResolver['resolve(bytes,bytes)'](
+      await expect(
+        universalResolver['resolve(bytes,bytes)'](
           dns.hexEncodeName('no-resolver.test.eth'),
           data,
-        )
-      } catch (e) {
-        expect(e.errorName).to.equal('ResolverWildcardNotSupported')
-      }
+        ),
+      ).to.be.revertedWith('ResolverWildcardNotSupported')
     })
 
     it('should resolve a record if `supportsInterface` throws', async () => {
@@ -386,6 +378,7 @@ contract('UniversalResolver', function (accounts) {
           dns.hexEncodeName('test2.eth'),
           data,
         )
+        expect(false).to.be.true
       } catch (e) {
         expect(e.errorName).to.equal('ResolverError')
         expect(e.errorSignature).to.equal('ResolverError(bytes)')
@@ -421,6 +414,7 @@ contract('UniversalResolver', function (accounts) {
           dns.hexEncodeName('offchain.test.eth'),
           data,
         )
+        expect(false).to.be.true
       } catch (e) {
         expect(e.errorName).to.equal('OffchainLookup')
         expect(e.errorArgs.sender).to.equal(universalResolver.address)
@@ -449,6 +443,7 @@ contract('UniversalResolver', function (accounts) {
           data,
           ['https://custom-offchain-resolver.local/'],
         )
+        expect(false).to.be.true
       } catch (e) {
         expect(e.errorArgs.urls).to.deep.equal([
           'https://custom-offchain-resolver.local/',
@@ -517,6 +512,7 @@ contract('UniversalResolver', function (accounts) {
             dns.hexEncodeName('offchain.test.eth'),
             [textData, addrData],
           )
+          expect(false).to.be.true
         } catch (e) {
           expect(e.errorName).to.equal('OffchainLookup')
           expect(e.errorArgs.callData).to.equal(callData)
@@ -560,6 +556,45 @@ contract('UniversalResolver', function (accounts) {
       )
       expect(addrRet).to.equal(dummyOffchainResolver.address)
     })
+    it('should propagate HttpError', async () => {
+      const urWithHttpErrorAbi = new ethers.Contract(
+        universalResolver.address,
+        [
+          ...universalResolver.interface.fragments,
+          'error HttpError((uint16,string)[])',
+        ],
+        ethers.provider,
+      )
+      const errorData = urWithHttpErrorAbi.interface.encodeErrorResult(
+        'HttpError',
+        [[[404, 'Not Found']]],
+      )
+      const extraData = ethers.utils.defaultAbiCoder.encode(
+        ['bool', 'address', 'string[]', 'bytes', '(bytes4,bytes)[]'],
+        [
+          false,
+          dummyOffchainResolver.address,
+          ['http://universal-offchain-resolver.local/'],
+          '0x',
+          [[resolveCallbackSig, errorData]],
+        ],
+      )
+      const responses = batchGateway.encodeFunctionResult('query', [
+        [true],
+        [errorData],
+      ])
+
+      try {
+        await urWithHttpErrorAbi.callStatic.resolveSingleCallback(
+          responses,
+          extraData,
+        )
+        expect(false).to.be.true
+      } catch (e) {
+        expect(e.errorName).to.equal('HttpError')
+        expect(e.errorArgs).to.deep.equal([[[404, 'Not Found']]])
+      }
+    })
   })
   describe('resolveCallback', () => {
     it('should resolve records via a callback from offchain lookup', async () => {
@@ -723,6 +758,7 @@ contract('UniversalResolver', function (accounts) {
       ])
       try {
         await universalResolver.callStatic.reverseCallback(responses, extraData)
+        expect(false).to.be.true
       } catch (e) {
         expect(e.errorName).to.equal('OffchainLookup')
         const extraDataReturned = ethers.utils.defaultAbiCoder.decode(