Fix resolve method on L1Resolver (#84)

* Fix  method on L1Resolver

* Use public RPC for forking

* Lint

* Fix typos in natspec

* Remove inline comment in function args

src/L1/L1Resolver.sol

@@ -164,7 +164,7 @@ contract L1Resolver is IExtendedResolver, ERC165, Ownable {
     function resolve(bytes calldata name, bytes calldata data) external view override returns (bytes memory) {
         // Check for base.eth resolution, and resolve return early if so
         if (keccak256(BASE_ETH_NAME) == keccak256(name)) {
-            return IExtendedResolver(rootResolver).resolve(name, data);
+            return _resolve(name, data);
         }
 
         bytes memory callData = abi.encodeWithSelector(IExtendedResolver.resolve.selector, name, data);
@@ -207,6 +207,28 @@ contract L1Resolver is IExtendedResolver, ERC165, Ownable {
             || ERC165(rootResolver).supportsInterface(interfaceID);
     }
 
+    /// @notice Internal method for completing `resolve` intended for the `rootResolver`.
+    ///
+    /// @dev The `PublicResolver` located at `rootResolver` does not implement the `resolve(bytes,bytes)` method.
+    ///     This method completes the resolution request by staticcalling `rootResolver` with the resolve request.
+    ///     Implementation matches the ENS `ExtendedResolver:resolve(bytes,bytes)` method with the exception that it `staticcall`s the
+    ///     the `rootResolver` instead of `address(this)`.
+    ///
+    /// @param data The ABI encoded data for the underlying resolution function (Eg, addr(bytes32), text(bytes32,string), etc).
+    ///
+    /// @return The return data, ABI encoded identically to the underlying function.
+    function _resolve(bytes memory, bytes memory data) internal view returns (bytes memory) {
+        (bool success, bytes memory result) = rootResolver.staticcall(data);
+        if (success) {
+            return result;
+        } else {
+            // Revert with the reason provided by the call
+            assembly {
+                revert(add(result, 0x20), mload(result))
+            }
+        }
+    }
+
     /// @notice Generic handler for requests to the `rootResolver`
     ///
     /// @dev Inspired by the passthrough logic of proxy contracts, but leveraging `call` instead of `delegatecall`

test/L1Resolver/L1ResolverMainnet.t.sol

@@ -0,0 +1,45 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test, console} from "forge-std/Test.sol";
+import {L1Resolver} from "src/L1/L1Resolver.sol";
+import {ENS} from "ens-contracts/registry/ENS.sol";
+import {IExtendedResolver} from "ens-contracts/resolvers/profiles/IExtendedResolver.sol";
+import "src/util/Constants.sol";
+import "ens-contracts/resolvers/profiles/IAddrResolver.sol";
+
+contract L1ResolverMainnet is Test {
+    address signer = 0x14536667Cd30e52C0b458BaACcB9faDA7046E056;
+    ENS public ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
+    address rootResolver = 0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41;
+    address addrRoot;
+    address l1resolver;
+
+    string constant URL = "TEST_URL";
+
+    function setUp() public {
+        uint256 forkId = vm.createFork("https://eth.llamarpc.com");
+        vm.selectFork(forkId);
+
+        address[] memory signers = new address[](1);
+        signers[0] = signer;
+        l1resolver = address(new L1Resolver(URL, signers, signer, rootResolver));
+
+        vm.startPrank(signer);
+        ens.setResolver(BASE_ETH_NODE, l1resolver);
+        assertEq(ens.resolver(BASE_ETH_NODE), l1resolver);
+        addrRoot = IAddrResolver(rootResolver).addr(BASE_ETH_NODE);
+    }
+
+    function test_resolves_addr() public view {
+        address resolvedAddress = IAddrResolver(l1resolver).addr(BASE_ETH_NODE);
+        assertEq(resolvedAddress, addrRoot);
+    }
+
+    function test_resolves_resolve() public view {
+        bytes memory data = abi.encodeWithSelector(IAddrResolver.addr.selector, BASE_ETH_NODE);
+        bytes memory response = IExtendedResolver(l1resolver).resolve(BASE_ETH_NAME, data);
+        (address resolvedAddress) = abi.decode(response, (address));
+        assertEq(resolvedAddress, addrRoot);
+    }
+}