Default reverse resolver (#33)

* Change ens-contracts to use default-reverse-resolver * Add suport for DefaultReverseResolver * Add hexToAddress to extract address * Add faulback to name function * Add fallback for text * Use imported IDefaultReverseResolver * Update bun.lockb and README * Update comment * Move DefaultReverseResolver * Add DefaultReverseResolver * Update bun.lockb * Add support for resolve on DefaultReverseResolver * Deployed new contracts * Add setdefaultname * Update README.md * Update README.md * Remove console.log * Point to default-reverse-resolver-2 * Reswitch to default-reverse-resolver * Update bun.ockb * Add whitespace * Check if invalid address * Override .text * Fix TypeError: ambiguous function error * Re-point to default-reverse-resolver * Added wait * Update storage location after removing Owner * Added wait on crosschain resolver * Use L2ReverseRevolver and fix broken test * Update ens-contracts branch * Eip 5559 support (#34) * Add IResolverSetter * Simplify metadata function * Fix failing tests * Add test for EIP 5559 * Added wait * Rename from IResolverSetter to IAddrSetter * Add resolveDeferral * Store chainId directly * Rename from resolveDeferral to setAddr
ensdomains · Apr 11, 2024 · 2bf86e9 · 2bf86e9
1 parent 5f93840
commit 2bf86e9
Show file tree

Hide file tree

Showing 27 changed files with 1,742 additions and 506 deletions.
diff --git a/README.md b/README.md
@@ -95,4 +95,27 @@ This repository also contains the end-to-end tests for the entire stack.
 An instantiation of `evm-gateway` that targets Optimism. Combined with `op-verifier`, makes it possible for L1 contracts to fetch contract state data from Optimism.
 
 ### [op-verifier](/op-verifier/)
-A complete Solidity library that facilitates sending CCIP-Read requests for Optimism state, and verifying the responses.
+A complete Solidity library that facilitates sending CCIP-Read requests for Optimism state, and verifying the responses.
+
+
+## How to setup locally
+
+```
+gh repo clone ensdomains/evmgateway
+bun install # `@ensdomains/@ensdomains` not found error will be thrown
+bun run workspace evm-gateway build
+bun install
+bun run test
+```
+
+## Troubleshooting
+
+### Error HH12: Trying to use a non-local installation of Hardhat, which is not supported.
+
+`yarn test` spawns `hardhat test` in the forked process. When `hardhat` command is installed under the node_modules of under each workspace, it complains that it's using locally installed hardhat. Remove hardhat from local node_modules and make sure it's only installed under the root `node_modules`
+
+```
+rm -rf *-*/node_modules/hardhat
+rm bun.lockb
+bun install
+```
diff --git a/bun.lockb b/bun.lockb
diff --git a/crosschain-resolver/contracts/IAddrSetter.sol b/crosschain-resolver/contracts/IAddrSetter.sol
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+interface IAddrSetter{
+    function setAddr(bytes calldata name, address _addr) external view returns (bytes memory result);
+}
+
diff --git a/crosschain-resolver/contracts/IMetadataResolver.sol b/crosschain-resolver/contracts/IMetadataResolver.sol
@@ -6,27 +6,15 @@ interface IMetadataResolver {
      * @notice Get metadata about the CCIP Resolver ENSIP 16 https://docs.ens.domains/ens-improvement-proposals/ensip-16-offchain-metadata
      * @dev This function provides metadata about the CCIP Resolver, including its name, coin type, GraphQL URL, storage type, and encoded information.
      * @param name The domain name in format (dnsEncoded)
-     * @return coinType The cointype of the chain the target contract locates such as Optimism, Base, Arb, etc
      * @return graphqlUrl The GraphQL URL used by the resolver
-     * @return storageType 0 = EVM, 1 = Non blockchain, 2 = Starknet
-     * @return storageLocation The storage identifier. For EVM chains, this is the address of the resolver contract.
-     * @return context. An identifier used by l2 graph indexer for Domain schema id (`context-namehash`) allowing multiple resolver contracts to have own namespace.
      *
      */
     function metadata(bytes calldata name) external view returns (
-        uint256 coinType,
-        string memory graphqlUrl,
-        uint8 storageType,
-        bytes memory storageLocation,
-        bytes memory context
+        string memory graphqlUrl
     );
 
     event MetadataChanged(
         bytes name,
-        uint256 coinType,
-        string graphqlUrl,
-        uint8 storageType,
-        bytes storageLocation,
-        bytes context
+        string graphqlUrl
     );
 }
diff --git a/crosschain-resolver/contracts/L1Resolver.sol b/crosschain-resolver/contracts/L1Resolver.sol
@@ -15,8 +15,9 @@ import "@ensdomains/ens-contracts/contracts/resolvers/profiles/IExtendedResolver
 import {ITargetResolver} from './ITargetResolver.sol';
 import {IMetadataResolver} from './IMetadataResolver.sol';
 import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import { IAddrSetter } from './IAddrSetter.sol';
 
-contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExtendedResolver, ERC165 {
+contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExtendedResolver, IAddrSetter, ERC165 {
     using EVMFetcher for EVMFetcher.EVMFetchRequest;
     using BytesUtils for bytes;
     IEVMVerifier public immutable verifier;
@@ -29,7 +30,7 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
     uint256 constant VERSIONABLE_HASHES_SLOT = 3;
     uint256 constant VERSIONABLE_TEXTS_SLOT = 10;
     string  public   graphqlUrl;
-    uint256 public   l2ResolverCoinType;
+    uint256 public   l2ChainId;
 
     event TargetSet(bytes name, address target);
     function isAuthorised(bytes32 node) internal view returns (bool) {
@@ -45,19 +46,29 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
         return owner == msg.sender;
     }
 
+    /**
+     * @dev EIP-5559 - Error to raise when mutations are being deferred to an L2.
+     * @param chainId Chain ID to perform the deferred mutation to.
+     * @param contractAddress Contract Address at which the deferred mutation should transact with.
+     */
+    error StorageHandledByL2(
+        uint256 chainId,
+        address contractAddress
+    );
+
     /**
      * @param _verifier     The chain verifier address
      * @param _ens          The ENS registry address
      * @param _nameWrapper  The ENS name wrapper address
      * @param _graphqlUrl   The offchain/l2 graphql endpoint url
-     * @param _l2ResolverCoinType The chainId at which the resolver resolves data from. 0 if storageLocation is offChain
+     * @param _l2ChainId    The chainId at which the resolver resolves data from
      */
     constructor(
       IEVMVerifier _verifier,
       ENS _ens,
       INameWrapper _nameWrapper,
       string memory _graphqlUrl,
-      uint256 _l2ResolverCoinType
+      uint256 _l2ChainId
     ){
       require(address(_nameWrapper) != address(0), "Name Wrapper address must be set");
       require(address(_verifier) != address(0), "Verifier address must be set");
@@ -66,7 +77,7 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
       ens = _ens;
       nameWrapper = _nameWrapper;
       graphqlUrl = _graphqlUrl;
-      l2ResolverCoinType = _l2ResolverCoinType;
+      l2ChainId = _l2ChainId;
     }
 
     /**
@@ -79,19 +90,9 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
       require(isAuthorised(node));
       targets[node] = target;
       emit TargetSet(name, target);
-      (
-        ,,
-        uint8 storageType,
-        bytes memory storageLocation,
-        bytes memory context
-      ) = metadata(name);
       emit MetadataChanged(
         name,
-        l2ResolverCoinType,
-        graphqlUrl,
-        storageType,
-        storageLocation,
-        context
+        graphqlUrl
       );
     }
 
@@ -163,6 +164,17 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
         }
     }
 
+    /** 
+     * @dev Resolve and throws an EIP 3559 compliant error
+     * @param name DNS encoded ENS name to query
+     * @param _addr The actual calldata
+     * @return result result of the call
+     */
+    function setAddr(bytes calldata name, address _addr) external view returns (bytes memory result) {
+        (, address target) = _getTarget(name, 0);
+        _writeDeferral(target);
+    }
+
     function _addr(bytes32 node, address target) private view returns (bytes memory) {
         EVMFetcher.newFetchRequest(verifier, target)
             .getStatic(RECORD_VERSIONS_SLOT)
@@ -246,23 +258,13 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
      * @notice Get metadata about the L1 Resolver
      * @dev This function provides metadata about the L1 Resolver, including its name, coin type, GraphQL URL, storage type, and encoded information.
      * @param name The domain name in format (dnsEncoded)
-     * @return coinType The cointype of the chain the target contract locates such as Optimism, Base, Arb, etc
      * @return graphqlUrl The GraphQL URL used by the resolver
-     * @return storageType Storage Type (0 for EVM)
-     * @return storageLocation The storage identifier. For EVM chains, this is the address of the resolver contract.
-     * @return context. An identifier used by l2 graph indexer for Domain schema id (`context-namehash`) allowing multiple resolver contracts to have own namespace.
      */
     function metadata(
         bytes calldata name
-    ) public view returns (uint256, string memory, uint8, bytes memory, bytes memory) {
-        (, address target) = getTarget(name);
-
+    ) public view returns (string memory) {
         return (
-            l2ResolverCoinType,
-            graphqlUrl,
-            uint8(0), // storage Type 0 => EVM
-            abi.encodePacked(address(target)), // storage location => l2 resolver address
-            abi.encodePacked(address(target))  // context => l2 resolver address
+            graphqlUrl
         );
     }
 
@@ -273,6 +275,14 @@ contract L1Resolver is EVMFetchTarget, ITargetResolver, IMetadataResolver, IExte
             interfaceId == type(IExtendedResolver).interfaceId ||
             interfaceId == type(ITargetResolver).interfaceId ||
             interfaceId == type(IMetadataResolver).interfaceId ||
+            interfaceId == type(IAddrSetter).interfaceId ||
             super.supportsInterface(interfaceId);
     }
+
+    function _writeDeferral(address target) internal view {
+        revert StorageHandledByL2(
+            l2ChainId,
+            target
+        );
+    }
 }
diff --git a/crosschain-resolver/contracts/deps.sol b/crosschain-resolver/contracts/deps.sol
@@ -7,7 +7,7 @@ import {ReverseRegistrar} from "@ensdomains/ens-contracts/contracts/reverseRegis
 import {PublicResolver} from "@ensdomains/ens-contracts/contracts/resolvers/PublicResolver.sol";
 import {DelegatableResolverFactory} from "@ensdomains/ens-contracts/contracts/resolvers/DelegatableResolverFactory.sol";
 import {DelegatableResolver} from "@ensdomains/ens-contracts/contracts/resolvers/DelegatableResolver.sol";
-import {L2ReverseRegistrar} from '@ensdomains/ens-contracts/contracts/reverseRegistrar/L2ReverseRegistrar.sol';
+import {L2ReverseResolver} from '@ensdomains/ens-contracts/contracts/reverseRegistrar/L2ReverseResolver.sol';
 // Storage slot
 // ┌────────────────────────────┬──────────────────────────────┬──────────────┬
 // │      contract              │        state_variable        │ storage_slot │ 

diff --git a/crosschain-resolver/deploy_l1/10_l1resolver.ts b/crosschain-resolver/deploy_l1/10_l1resolver.ts
@@ -22,12 +22,11 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const CHAIN_NAME = process.env.CHAIN_NAME
 
   if(!['Op', 'Base', 'Arb'].includes(CHAIN_NAME)) throw ('Set $CHAIN_NAME to Op, Base, or Arb')
-  const L2_COINTYPE = convertEVMChainIdToCoinType(parseInt(L2_CHAIN_ID))
-  console.log({VERIFIER_ADDRESS,ENS_ADDRESS, WRAPPER_ADDRESS,L2_GRAPHQL_URL,L2_COINTYPE})
+  console.log({VERIFIER_ADDRESS,ENS_ADDRESS, WRAPPER_ADDRESS,L2_GRAPHQL_URL,L2_CHAIN_ID})
   await deploy(`${CHAIN_NAME}L1Resolver`, {
     from: deployer,
     contract: 'L1Resolver',
-    args: [VERIFIER_ADDRESS,ENS_ADDRESS,WRAPPER_ADDRESS,L2_GRAPHQL_URL,L2_COINTYPE],
+    args: [VERIFIER_ADDRESS,ENS_ADDRESS,WRAPPER_ADDRESS,L2_GRAPHQL_URL,parseInt(L2_CHAIN_ID)],
     log: true,
   });
 };

diff --git a/crosschain-resolver/test/testResolver.ts b/crosschain-resolver/test/testResolver.ts
@@ -15,12 +15,12 @@ import { ethers } from 'hardhat';
 import { EthereumProvider } from 'hardhat/types';
 import request from 'supertest';
 import packet from 'dns-packet';
-import {convertEVMChainIdToCoinType} from '@ensdomains/address-encoder'
+import { L2ChainID } from '@eth-optimism/sdk';
 const labelhash = (label) => ethers.keccak256(ethers.toUtf8Bytes(label))
 const encodeName = (name) => '0x' + packet.name.encode(name).toString('hex')
 
 const l2graphqlUrl = 'http://graphql'
-const l2ResolverCoinType = convertEVMChainIdToCoinType(420) // Optimism Goerli
+const chainId = L2ChainID.OPTIMISM_SEPOLIA
 
 const name = 'foo.eth'
 const node = ethers.namehash(name)
@@ -30,6 +30,12 @@ const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
 const EMPTY_BYTES32 =
   '0x0000000000000000000000000000000000000000000000000000000000000000'
 
+// looks like there are time dependencies for verification to success, hence adding a dalay
+const wait = async x => {
+  return new Promise(resolve => {
+    setTimeout(resolve, 3000, 2 * x);
+  });
+};
 
 type ethersObj = typeof ethersT &
   Omit<HardhatEthersHelpers, 'provider'> & {
@@ -148,7 +154,7 @@ describe('Crosschain Resolver', () => {
       signer
     );
     const verifierAddress = await verifier.getAddress()
-    target = await testL1Factory.deploy(verifierAddress, ensAddress, wrapperAddress, l2graphqlUrl, l2ResolverCoinType);
+    target = await testL1Factory.deploy(verifierAddress, ensAddress, wrapperAddress, l2graphqlUrl, chainId);
 
     // Mine an empty block so we have something to prove against
     await provider.send('evm_mine', []);
@@ -217,7 +223,7 @@ describe('Crosschain Resolver', () => {
     const result = await l2contract['addr(bytes32)'](node)
     expect(ethers.getAddress(result)).to.equal(addr);
     await provider.send("evm_mine", []);
-
+    await wait(1);
     const i = new ethers.Interface(["function addr(bytes32) returns(address)"])
     const calldata = i.encodeFunctionData("addr", [node])
     const result2 = await target.resolve(encodedname, calldata, { enableCcipRead: true })
@@ -233,9 +239,9 @@ describe('Crosschain Resolver', () => {
     const result = await l2contract['addr(bytes32)'](node)
     expect(ethers.getAddress(result)).to.equal(addr);
     await provider.send("evm_mine", []);
-
     const i = new ethers.Interface(["function addr(bytes32) returns(address)"])
     const calldata = i.encodeFunctionData("addr", [node])
+    await wait(1);
     const result2 = await target.resolve(encodedname, calldata, { enableCcipRead: true })
     const decoded = i.decodeFunctionResult("addr", result2)
     expect(decoded[0]).to.equal(addr);
@@ -252,6 +258,7 @@ describe('Crosschain Resolver', () => {
     const result = await l2contract['addr(bytes32)'](subnode)
     expect(ethers.getAddress(result)).to.equal(addr);
     await provider.send("evm_mine", []);
+    await wait(1);
     const i = new ethers.Interface(["function addr(bytes32) returns(address)"])
     const calldata = i.encodeFunctionData("addr", [subnode])
 
@@ -261,13 +268,14 @@ describe('Crosschain Resolver', () => {
   })
 
   it("should resolve non ETH Address", async() => {
+
     await target.setTarget(encodedname, resolverAddress)
     const addr = '0x76a91462e907b15cbf27d5425399ebf6f0fb50ebb88f1888ac'
     const coinType = 0 // BTC
     await l2contract.clearRecords(node)
     await l2contract['setAddr(bytes32,uint256,bytes)'](node, coinType, addr)
     await provider.send("evm_mine", []);
-
+    await wait(1);
     const i = new ethers.Interface(["function addr(bytes32,uint256) returns(bytes)"])
     const calldata = i.encodeFunctionData("addr", [node, coinType])
     const result2 = await target.resolve(encodedname, calldata, { enableCcipRead: true })
@@ -282,7 +290,7 @@ describe('Crosschain Resolver', () => {
     await l2contract.clearRecords(node)
     await l2contract.setText(node, key, value)
     await provider.send("evm_mine", []);
-
+    await wait(1);
     const i = new ethers.Interface(["function text(bytes32,string) returns(string)"])
     const calldata = i.encodeFunctionData("text", [node, key])
     const result2 = await target.resolve(encodedname, calldata, { enableCcipRead: true })
@@ -296,7 +304,7 @@ describe('Crosschain Resolver', () => {
     await l2contract.clearRecords(node)
     await l2contract.setContenthash(node, contenthash)
     await provider.send("evm_mine", []);
-
+    await wait(1);
     const i = new ethers.Interface(["function contenthash(bytes32) returns(bytes)"])
     const calldata = i.encodeFunctionData("contenthash", [node])
     const result2 = await target.resolve(encodedname, calldata, { enableCcipRead: true })
@@ -309,31 +317,30 @@ describe('Crosschain Resolver', () => {
     expect(await target.supportsInterface('0x9061b923')).to.equal(true) // IExtendedResolver
     expect(await target.supportsInterface('0x8a596ebe')).to.equal(true) // IMetadataResolver
     expect(await target.supportsInterface('0x01ffc9a7')).to.equal(true) // ERC-165 support
+    expect(await target.supportsInterface('0xf00eebf4')).to.equal(true) // IAddrSetter support
   })
 
+  describe('EIP 5559', () => {
+    it('throws StorageHandledByL2 error', async () => {
+      await target.setTarget(encodedname, resolverAddress)
+      await expect(target.setAddr(encodedname, EMPTY_ADDRESS)).to.be
+        .revertedWithCustomError(target, 'StorageHandledByL2')
+        .withArgs(chainId, resolverAddress)
+    });
+  });
+
   describe('Metadata', () => {
     it('returns metadata', async () => {
-      await target.setTarget(encodedname, signerAddress)
-
-      const [coinType, graphqlUrl, storageType, storageLocation, context] = await target.metadata(encodedname);
-      expect(parseInt(coinType)).to.equal(l2ResolverCoinType);
-      expect(graphqlUrl).to.equal(l2graphqlUrl);
-      expect(storageType).to.equal(storageType);
-      expect(ethers.getAddress(storageLocation)).to.equal(signerAddress);
-      expect(ethers.getAddress(context)).to.equal(signerAddress);
+      expect(await target.metadata(encodedname)).to.equal(l2graphqlUrl);
     });
 
     it('emits a MetadataChanged event', async () => {
       const tx = await target.setTarget(encodedname, signerAddress)
       await tx.wait()
       const logs = await target.queryFilter("MetadataChanged")
-      const [name, coinType, graphqlUrl, storageType, storageLocation, context] = logs[0].args
+      const [name, graphqlUrl] = logs[0].args
       expect(name).to.equal(encodedname);
-      expect(parseInt(coinType)).to.equal(l2ResolverCoinType);
       expect(graphqlUrl).to.equal(l2graphqlUrl);
-      expect(storageType).to.equal(storageType);
-      expect(ethers.getAddress(storageLocation)).to.equal(signerAddress);
-      expect(ethers.getAddress(context)).to.equal(signerAddress);
     });
   });
 });