Delegatable resolver registrar

contracts/resolvers/DelegatableResolverRegistrar.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.4;
+import "./IDelegatableResolverRegistrar.sol";
+import "./DelegatableResolver.sol";
+import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * A delegated resolver registrar that allows anyone to register subname
+ */
+contract DelegatableResolverRegistrar is IDelegatableResolverRegistrar, ERC165 {
+    DelegatableResolver public resolver;
+
+    constructor(DelegatableResolver _resolver) {
+        resolver = _resolver;
+    }
+
+    /**
+     * @dev Approve an operator to be able to updated records on a node.
+     */
+    function register(bytes memory name, address operator) external {
+        bytes32 node = bytes32(0);
+        bool authorized = false;
+        (node, authorized) = resolver.getAuthorisedNode(name, 0, operator);
+        resolver.approve(name, operator, true);
+    }
+
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view override returns (bool) {
+        return
+            interfaceId == type(IDelegatableResolverRegistrar).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+}

contracts/resolvers/IDelegatableResolverRegistrar.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.4;
+
+interface IDelegatableResolverRegistrar {
+    function register(bytes memory name, address operator) external;
+}

test/resolvers/TestDelegatableResolver.js

@@ -2,6 +2,9 @@ const DelegatableResolverFactory = artifacts.require(
   'DelegatableResolverFactory.sol',
 )
 const DelegatableResolver = artifacts.require('DelegatableResolver.sol')
+const DelegatableResolverRegistrar = artifacts.require(
+  'DelegatableResolverRegistrar.sol',
+)
 const { encodeName, namehash } = require('../test-utils/ens')
 const { exceptions } = require('../test-utils')
 const { expect } = require('chai')
@@ -204,4 +207,51 @@ contract('DelegatableResolver', function (accounts) {
       assert.equal(args.approved, true)
     })
   })
+
+  describe('DelegatableResolverRegistrar', async () => {
+    let registrar
+    beforeEach(async () => {
+      registrar = await DelegatableResolverRegistrar.new(resolver.address)
+    })
+    it('approves users to update record for the given subname', async () => {
+      const basename = encodeName('')
+      const name = `foo.bar.eth`
+      const encodedsubname = encodeName(name)
+      const encodedsubnode = namehash(name)
+
+      const operator2Resolver = await (
+        await ethers.getContractFactory('DelegatableResolver')
+      )
+        .attach(resolver.address)
+        .connect(operator2Signer)
+
+      await exceptions.expectFailure(
+        operator2Resolver['setAddr(bytes32,address)'](
+          encodedsubnode,
+          operator2,
+        ),
+      )
+
+      await resolver.approve(basename, registrar.address, true)
+      await registrar.register(encodedsubname, operator2)
+      assert.equal(
+        (await resolver.getAuthorisedNode(encodedsubname, 0, operator2))[1],
+        true,
+      )
+
+      await operator2Resolver['setAddr(bytes32,address)'](
+        encodedsubnode,
+        operator2,
+      )
+      assert.equal(
+        await operator2Resolver['addr(bytes32)'](encodedsubnode),
+        operator2,
+      )
+    })
+
+    it('should support interface', async () => {
+      expect(await registrar.supportsInterface('0x01ffc9a7')).to.equal(true) // ERC-165 support
+      expect(await registrar.supportsInterface('0xa99e7e29')).to.equal(true) // IDelegatableResolverRegistrar
+    })
+  })
 })