proposal-32/diffs/RelayerRegistry.diff

*** diffs/RelayerRegistryOld.sol	2023-10-26 12:52:30.440003652 +0000
--- contracts/RelayerRegistry.sol	2023-10-26 09:36:53.976016132 +0000
***************
*** 9,76 ****
  import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
  import { EnsResolve } from "torn-token/contracts/ENS.sol";
  import { TORN } from "torn-token/contracts/TORN.sol";
! import { TornadoStakingRewards } from "./TornadoStakingRewards.sol";
! 
! interface ITornadoInstance {
!     function token() external view returns (address);
! 
!     function denomination() external view returns (uint256);
! 
!     function deposit(bytes32 commitment) external payable;
! 
!     function withdraw(
!         bytes calldata proof,
!         bytes32 root,
!         bytes32 nullifierHash,
!         address payable recipient,
!         address payable relayer,
!         uint256 fee,
!         uint256 refund
!     ) external payable;
! }
! 
! interface IENS {
!     function owner(bytes32 node) external view returns (address);
! }
! 
! /*
!  * @dev Solidity implementation of the ENS namehash algorithm.
!  *
!  * Warning! Does not normalize or validate names before hashing.
!  * Original version can be found here https://github.com/JonahGroendal/ens-namehash/
!  */
! library ENSNamehash {
!     function namehash(bytes memory domain) internal pure returns (bytes32) {
!         return namehash(domain, 0);
!     }
! 
!     function namehash(bytes memory domain, uint256 i) internal pure returns (bytes32) {
!         if (domain.length <= i) return 0x0000000000000000000000000000000000000000000000000000000000000000;
! 
!         uint256 len = labelLength(domain, i);
! 
!         return keccak256(abi.encodePacked(namehash(domain, i + len + 1), keccak(domain, i, len)));
!     }
! 
!     function labelLength(bytes memory domain, uint256 i) private pure returns (uint256) {
!         uint256 len;
!         while (i + len != domain.length && domain[i + len] != 0x2e) {
!             len++;
!         }
!         return len;
!     }
! 
!     function keccak(bytes memory data, uint256 offset, uint256 len) private pure returns (bytes32 ret) {
!         require(offset + len <= data.length);
!         assembly {
!             ret := keccak256(add(add(data, 32), offset), len)
!         }
!     }
! }
! 
! interface IFeeManager {
!     function instanceFeeWithUpdate(ITornadoInstance _instance) external returns (uint160);
! }
  
  struct RelayerState {
      uint256 balance;
--- 9,19 ----
  import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
  import { EnsResolve } from "torn-token/contracts/ENS.sol";
  import { TORN } from "torn-token/contracts/TORN.sol";
! import { IENS } from "./interfaces/ENS.sol";
! import { IFeeManager } from "./interfaces/FeeManager.sol";
! import { ITornadoInstance } from "./interfaces/TornadoInstance.sol";
! import { ITornadoStakingRewards } from "./interfaces/TornadoStakingRewards.sol";
! import { ENSNamehash } from "./libraries/EnsNamehash.sol";
  
  struct RelayerState {
      uint256 balance;
***************
*** 99,105 ****
      TORN public immutable torn;
      address public immutable governance;
      IENS public immutable ens;
!     TornadoStakingRewards public immutable staking;
      IFeeManager public immutable feeManager;
  
      address public tornadoRouter;
--- 42,48 ----
      TORN public immutable torn;
      address public immutable governance;
      IENS public immutable ens;
!     ITornadoStakingRewards public immutable staking;
      IFeeManager public immutable feeManager;
  
      address public tornadoRouter;
***************
*** 116,121 ****
--- 59,65 ----
      event MinimumStakeAmount(uint256 minStakeAmount);
      event RouterRegistered(address tornadoRouter);
      event RelayerRegistered(bytes32 relayer, string ensName, address relayerAddress, uint256 stakedAmount);
+     event RelayerUnregistered(address relayer);
  
      modifier onlyGovernance() {
          require(msg.sender == governance, "only governance");
***************
*** 136,142 ****
          torn = TORN(_torn);
          governance = _governance;
          ens = IENS(_ens);
!         staking = TornadoStakingRewards(_staking);
          feeManager = IFeeManager(_feeManager);
      }
  
--- 80,86 ----
          torn = TORN(_torn);
          governance = _governance;
          ens = IENS(_ens);
!         staking = ITornadoStakingRewards(_staking);
          feeManager = IFeeManager(_feeManager);
      }
  
***************
*** 186,192 ****
          address[] calldata workersToRegister
      ) internal {
          bytes32 ensHash = bytes(ensName).namehash();
!         require(relayer == ens.owner(ensHash), "only ens owner");
          require(workers[relayer] == address(0), "cant register again");
          RelayerState storage metadata = relayers[relayer];
  
--- 130,140 ----
          address[] calldata workersToRegister
      ) internal {
          bytes32 ensHash = bytes(ensName).namehash();
!         address domainOwner = ens.owner(ensHash);
!         address ensNameWrapper = 0xD4416b13d2b3a9aBae7AcD5D6C2BbDBE25686401;
! 
!         require(domainOwner != ensNameWrapper, "only unwrapped ens domains");
!         require(relayer == domainOwner, "only ens domain owner");
          require(workers[relayer] == address(0), "cant register again");
          RelayerState storage metadata = relayers[relayer];
  
***************
*** 240,245 ****
--- 188,205 ----
      }
  
      /**
+      * @notice This function should allow governance to unregister relayer
+      * @param relayer Address of the relayer
+      *
+      */
+     function unregisterRelayer(address relayer) external onlyGovernance {
+         nullifyBalance(relayer);
+         delete relayers[relayer];
+         delete workers[relayer];
+         emit RelayerUnregistered(relayer);
+     }
+ 
+     /**
       * @notice This function should allow anybody to stake to a relayer more TORN
       * @param relayer Relayer main address to stake to
       * @param stake Stake to be added to relayer
***************
*** 328,334 ****
       * @param relayer address of relayer who's balance is to nullify
       *
       */
!     function nullifyBalance(address relayer) external onlyGovernance {
          address masterAddress = workers[relayer];
          require(relayer == masterAddress, "must be master");
          relayers[masterAddress].balance = 0;
--- 288,294 ----
       * @param relayer address of relayer who's balance is to nullify
       *
       */
!     function nullifyBalance(address relayer) public onlyGovernance {
          address masterAddress = workers[relayer];
          require(relayer == masterAddress, "must be master");
          relayers[masterAddress].balance = 0;