L2Resolver.t.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {Test} from 'forge-std/Test.sol';
import {IERC165} from 'openzeppelin-contracts/interfaces/IERC165.sol';
import {L2Resolver} from 'src/contracts/L2Resolver.sol';

import {IENS} from 'src/interfaces/IENS.sol';
import {IExtendedResolver} from 'src/interfaces/IExtendedResolver.sol';
import {IL2Resolver} from 'src/interfaces/IL2Resolver.sol';
import {INameWrapper} from 'src/interfaces/INameWrapper.sol';

contract UnitL2Resolver is Test {
  L2Resolver internal _l2Resolver;
  address internal _ensRegistry = makeAddr('ENSRegistry');
  address internal _nameWrapper = makeAddr('NameWrapper');
  address internal _reverseAdmin = makeAddr('ReverseAdmin');
  address internal _nodeOwner = makeAddr('NodeOwner');
  bytes32 internal _parentNodeNameHash = keccak256('l2.eth');
  bytes32 internal _reverseLookupNode;
  bytes32 internal _nodeNameHash = keccak256('optimism.l2.eth');
  string internal _key;
  bytes internal _chainIdBytes = hex'00010001010A00';
  string internal _reverseLookupKey;
  bytes internal _reverseLookupValue = abi.encode('optimism.l2.eth');

  function setUp() external {
    _l2Resolver = new L2Resolver(_ensRegistry, _nameWrapper, _reverseAdmin, _parentNodeNameHash);
    _reverseLookupNode = _l2Resolver.REVERSE_LOOKUP_NODE();
    _key = _l2Resolver.CHAIN_IDENTIFIER_EIP7930_KEY();
    _reverseLookupKey = string.concat(_key, 'chainIdBytes');

    vm.etch(address(_ensRegistry), new bytes(0x1));
    vm.etch(address(_nameWrapper), new bytes(0x1));
  }

  function test_ConstructorWhenDeployingTheContract() external view {
    // it sets the ENS registry address
    assertEq(address(_l2Resolver.ENS_REGISTRY()), _ensRegistry);
    // it sets the name wrapper address
    assertEq(address(_l2Resolver.NAME_WRAPPER()), _nameWrapper);
    // it sets the reverse admin address
    assertEq(_l2Resolver.REVERSE_ADMIN(), _reverseAdmin);
    // it sets the parent node namehash
    assertEq(_l2Resolver.PARENT_NODE(), _parentNodeNameHash);
  }

  modifier whenTheNodeIsTheReverseLookupNode() {
    _;
  }

  function test_SetRecordWhenTheCallerIsTheReverseAdmin() external {
    // it emits the RecordSet event
    vm.prank(_reverseAdmin);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_reverseLookupNode, _reverseLookupKey, _reverseLookupValue);
    _l2Resolver.setRecord(_reverseLookupNode, _reverseLookupKey, _reverseLookupValue);

    // it sets the record
    assertEq(_l2Resolver.records(_reverseLookupNode, _reverseLookupKey), _reverseLookupValue);
  }

  function test_SetRecordWhenTheCallerIsNotTheReverseAdmin(address _caller) external {
    vm.assume(_caller != _reverseAdmin);
    // it reverts
    vm.prank(_caller);
    vm.expectRevert(abi.encodeWithSelector(IL2Resolver.NotAuthorized.selector));
    _l2Resolver.setRecord(_reverseLookupNode, _reverseLookupKey, _reverseLookupValue);
  }

  modifier whenTheNodeHasAnENSRegistryOwner(address _owner) {
    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.owner.selector, _nodeNameHash), abi.encode(_owner)
    );
    _;
  }

  function test_SetRecordWhenTheCallerIsTheBeneficialOwner(address _caller)
    external
    whenTheNodeHasAnENSRegistryOwner(_caller)
  {
    vm.assume(_caller != _nameWrapper);
    vm.assume(_caller != address(0));

    // it emits the RecordSet event
    vm.prank(_caller);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsAnENSRegistryApprovedOperator(
    address _owner,
    address _caller
  ) external whenTheNodeHasAnENSRegistryOwner(_owner) {
    vm.assume(_owner != _nameWrapper);
    vm.assume(_owner != address(0));
    vm.assume(_caller != _owner);

    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.isApprovedForAll.selector, _owner, _caller), abi.encode(true)
    );

    // it emits the RecordSet event
    vm.prank(_caller);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsANameWrapperApprovedOperator(
    address _owner,
    address _caller
  ) external whenTheNodeHasAnENSRegistryOwner(_nameWrapper) {
    vm.assume(_owner != address(0));
    vm.assume(_caller != _owner);

    _mockAndExpect(
      address(_nameWrapper), abi.encodeWithSelector(INameWrapper.ownerOf.selector, _nodeNameHash), abi.encode(_owner)
    );
    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.isApprovedForAll.selector, _owner, _caller), abi.encode(false)
    );
    _mockAndExpect(
      address(_nameWrapper),
      abi.encodeWithSelector(INameWrapper.isApprovedForAll.selector, _owner, _caller),
      abi.encode(true)
    );

    // it emits the RecordSet event
    vm.prank(_caller);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsNeitherOwnerNorApproved(
    address _owner,
    address _caller
  ) external whenTheNodeHasAnENSRegistryOwner(_owner) {
    vm.assume(_owner != _caller);
    vm.assume(_owner != address(0));
    vm.assume(_owner != _nameWrapper);

    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.isApprovedForAll.selector, _owner, _caller), abi.encode(false)
    );
    _mockAndExpect(
      address(_nameWrapper),
      abi.encodeWithSelector(INameWrapper.isApprovedForAll.selector, _owner, _caller),
      abi.encode(false)
    );

    // it reverts
    vm.prank(_caller);
    vm.expectRevert(abi.encodeWithSelector(IL2Resolver.NotAuthorized.selector));
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);
  }

  modifier whenTheNodeHasNoENSRegistryOwner() {
    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.owner.selector, _nodeNameHash), abi.encode(address(0))
    );
    _;
  }

  function test_SetRecordWhenTheCallerIsTheParentOwner(address _parentNodeOwner)
    external
    whenTheNodeHasNoENSRegistryOwner
  {
    vm.assume(_parentNodeOwner != address(0));
    vm.assume(_parentNodeOwner != _nameWrapper);

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.owner.selector, _parentNodeNameHash),
      abi.encode(_parentNodeOwner)
    );

    // it emits the RecordSet event
    vm.prank(_parentNodeOwner);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsAnENSregistryApprovedOperatorOfTheParent(
    address _parentNodeOwner,
    address _caller
  ) external whenTheNodeHasNoENSRegistryOwner {
    vm.assume(_parentNodeOwner != address(0));
    vm.assume(_parentNodeOwner != _nameWrapper);
    vm.assume(_caller != _parentNodeOwner);

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.owner.selector, _parentNodeNameHash),
      abi.encode(_parentNodeOwner)
    );

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.isApprovedForAll.selector, _parentNodeOwner, _caller),
      abi.encode(true)
    );

    // it emits the RecordSet event
    vm.prank(_caller);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsANameWrapperApprovedOperatorOfTheParent(
    address _parentNodeOwner,
    address _caller
  ) external whenTheNodeHasNoENSRegistryOwner {
    vm.assume(_parentNodeOwner != address(0));
    vm.assume(_parentNodeOwner != _nameWrapper);
    vm.assume(_caller != _parentNodeOwner);

    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.owner.selector, _parentNodeNameHash), abi.encode(_nameWrapper)
    );
    _mockAndExpect(
      address(_nameWrapper),
      abi.encodeWithSelector(INameWrapper.ownerOf.selector, _parentNodeNameHash),
      abi.encode(_parentNodeOwner)
    );

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.isApprovedForAll.selector, _parentNodeOwner, _caller),
      abi.encode(false)
    );

    _mockAndExpect(
      address(_nameWrapper),
      abi.encodeWithSelector(INameWrapper.isApprovedForAll.selector, _parentNodeOwner, _caller),
      abi.encode(true)
    );

    // it emits the RecordSet event
    vm.prank(_caller);
    vm.expectEmit();
    emit IL2Resolver.RecordSet(_nodeNameHash, _key, _chainIdBytes);
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);

    // it sets the record
    assertEq(_l2Resolver.records(_nodeNameHash, _key), _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsNotAnApprovedOperatorOfTheParent(
    address _parentNodeOwner,
    address _caller
  ) external whenTheNodeHasNoENSRegistryOwner {
    vm.assume(_parentNodeOwner != address(0));
    vm.assume(_parentNodeOwner != _nameWrapper);
    vm.assume(_caller != _parentNodeOwner);

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.owner.selector, _parentNodeNameHash),
      abi.encode(_parentNodeOwner)
    );

    _mockAndExpect(
      address(_ensRegistry),
      abi.encodeWithSelector(IENS.isApprovedForAll.selector, _parentNodeOwner, _caller),
      abi.encode(false)
    );

    _mockAndExpect(
      address(_nameWrapper),
      abi.encodeWithSelector(INameWrapper.isApprovedForAll.selector, _parentNodeOwner, _caller),
      abi.encode(false)
    );

    // it reverts
    vm.prank(_caller);
    vm.expectRevert(abi.encodeWithSelector(IL2Resolver.NotAuthorized.selector));
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);
  }

  function test_SetRecordWhenTheCallerIsNotAuthorizedOnTheParent(
    address _parentNodeOwner,
    address _caller
  ) external whenTheNodeHasNoENSRegistryOwner {
    vm.assume(_parentNodeOwner != address(0));
    vm.assume(_parentNodeOwner != _nameWrapper);
    vm.assume(_caller != _parentNodeOwner);

    _mockAndExpect(
      address(_ensRegistry), abi.encodeWithSelector(IENS.owner.selector, _parentNodeNameHash), abi.encode(address(0))
    );

    // it reverts
    vm.prank(_caller);
    vm.expectRevert(abi.encodeWithSelector(IL2Resolver.NotAuthorized.selector));
    _l2Resolver.setRecord(_nodeNameHash, _key, _chainIdBytes);
  }

  function test_GetRecordWhenTheRecordExists(bytes32 _node, string calldata _recordKey, bytes memory _data) external {
    vm.assume(_node != _reverseLookupNode);

    _setRecord(_node, _recordKey, _data);

    // it returns the stored bytes
    assertEq(_l2Resolver.getRecord(_node, _recordKey), _data);
  }

  function test_GetRecordWhenTheRecordDoesNotExist(bytes32 _node, string calldata _recordKey) external view {
    // it returns empty bytes
    assertEq(_l2Resolver.getRecord(_node, _recordKey), '');
  }

  function test_ChainIdWhenTheChainIdentifierIsSet(bytes calldata _data) external {
    _setRecord(_nodeNameHash, _key, _data);

    // it returns the stored EIP-7930 bytes
    assertEq(_l2Resolver.chainId(_nodeNameHash), _data);
  }

  function test_ChainIdWhenTheChainIdentifierIsNotSet(string calldata _recordKey, bytes calldata _data) external {
    // sets the _data for a different key
    vm.assume(keccak256(bytes(_recordKey)) != keccak256(bytes(_key)));
    _setRecord(_nodeNameHash, _recordKey, _data);

    // it returns empty bytes
    assertEq(_l2Resolver.chainId(_nodeNameHash), '');
  }

  function test_SupportsInterfaceWhenCheckingERC165InterfaceId() external view {
    // it returns true
    assertTrue(_l2Resolver.supportsInterface(type(IERC165).interfaceId));
  }

  function test_SupportsInterfaceWhenCheckingExtendedResolverInterfaceId() external view {
    // it returns true
    assertTrue(_l2Resolver.supportsInterface(type(IExtendedResolver).interfaceId));
  }

  function test_SupportsInterfaceWhenCheckingAnUnsupportedInterfaceId(bytes4 _interfaceId) external view {
    vm.assume(_interfaceId != type(IERC165).interfaceId);
    vm.assume(_interfaceId != type(IExtendedResolver).interfaceId);

    // it returns false
    assertFalse(_l2Resolver.supportsInterface(_interfaceId));
  }

  /**
   * @notice Sets up a mock and expects a call to it
   *
   * @param _receiver The address to have a mock on
   * @param _calldata The calldata to mock and expect
   * @param _returned The data to return from the mocked call
   */
  function _mockAndExpect(address _receiver, bytes memory _calldata, bytes memory _returned) internal {
    vm.mockCall(_receiver, _calldata, _returned);
    vm.expectCall(_receiver, _calldata);
  }

  /**
   * @notice Sets a record for a given node
   * @dev Mocks the _nodeOwner as the owner of the _node in the ENSRegistry
   * @param _node The ENS node to set the record for
   * @param _recordKey The key to set the record for
   * @param _data The data to set the record for
   */
  function _setRecord(bytes32 _node, string memory _recordKey, bytes memory _data) internal {
    _mockAndExpect(address(_ensRegistry), abi.encodeWithSelector(IENS.owner.selector, _node), abi.encode(_nodeOwner));
    vm.prank(_nodeOwner);
    _l2Resolver.setRecord(_node, _recordKey, _data);
  }
}