From 83cd36dfc3e45e5835e863da0b5b74dfd5471df2 Mon Sep 17 00:00:00 2001
From: Felipe Mendes <zo.fmendes@gmail.com>
Date: Wed, 5 Apr 2023 11:48:56 -0300
Subject: [PATCH] feat: design ens verification flow (#193)

* wip: add base solidity functions to try ens validation

* chore: add hardhat fork setup with env variable

* wip: setup ens verification for FleekERC721

* wip: add ens namehash generation

* chore: gas report setting

* feat: add ens verification on setTokenENS function

* test: hardhat transfer ens owner to set new ens

* test: fix foundry tests to enable ens validation

* refactor: change back ens to calldata and split out a public function for namehash testing

* refactor: move FleekENS.sol to util folder

* test: add ens validation tests for not owner attempts

* chore: add mainnet api key env in ci

* chore: fix .env.example

* fix: remove extra unused file
---
 .github/workflows/contract.yml                |  2 +
 contracts/.env.example                        | 11 +++-
 contracts/.gitignore                          |  3 +-
 contracts/contracts/FleekERC721.sol           | 11 ++--
 contracts/contracts/util/FleekENS.sol         | 32 +++++++++++
 contracts/foundry.toml                        |  5 ++
 contracts/hardhat.config.ts                   | 12 +++-
 contracts/package.json                        |  6 +-
 .../foundry/FleekERC721/AccessControl.t.sol   |  5 +-
 .../test/foundry/FleekERC721/Constants.sol    |  3 -
 contracts/test/foundry/FleekERC721/ENS.t.sol  | 32 +++++++++++
 .../test/foundry/FleekERC721/GetToken.t.sol   |  9 +--
 contracts/test/foundry/FleekERC721/Mint.t.sol |  4 ++
 .../test/foundry/FleekERC721/TestBase.sol     | 11 ++++
 .../test/foundry/FleekERC721/TokenURI.t.sol   |  6 +-
 contracts/test/foundry/FleekERC721/Utils.sol  | 16 ++++++
 .../hardhat/contracts/FleekERC721/ens.t.ts    | 56 +++++++++++++++++++
 .../contracts/FleekERC721/helpers/errors.ts   |  1 +
 .../contracts/FleekERC721/helpers/fixture.ts  |  3 +
 .../contracts/FleekERC721/helpers/utils.ts    | 29 ++++++++++
 .../FleekERC721/update-properties.t.ts        |  8 ++-
 contracts/yarn.lock                           | 49 ++++++++++++++++
 22 files changed, 291 insertions(+), 23 deletions(-)
 create mode 100644 contracts/contracts/util/FleekENS.sol
 create mode 100644 contracts/test/foundry/FleekERC721/ENS.t.sol
 create mode 100644 contracts/test/foundry/FleekERC721/Utils.sol
 create mode 100644 contracts/test/hardhat/contracts/FleekERC721/ens.t.ts

diff --git a/.github/workflows/contract.yml b/.github/workflows/contract.yml
index dfa087c..3acf54a 100644
--- a/.github/workflows/contract.yml
+++ b/.github/workflows/contract.yml
@@ -11,6 +11,8 @@ on:
 jobs:
   test-contracts:
     runs-on: ubuntu-latest
+    env:
+      MAINNET_API_KEY: ${{ secrets.MAINNET_API_KEY }}
 
     defaults:
       run:
diff --git a/contracts/.env.example b/contracts/.env.example
index f4e6b94..a6e0467 100644
--- a/contracts/.env.example
+++ b/contracts/.env.example
@@ -9,4 +9,13 @@ PRIVATE_KEY=
 POLYSCAN_API=https://mumbai.polygonscan.com/
 
 # The address of the deployed contract on the blockchain
-CONTRACT_ADDRESS=
\ No newline at end of file
+CONTRACT_ADDRESS=
+
+# Alchemy or Infura API key to fork the mainnet on tests (e.g. https://eth-mainnet.g.alchemy.com/v2/your-api-key)
+MAINNET_API_KEY=
+
+# Enable gas report on hardhat tests
+REPORT_GAS=true
+
+# The CoinMarketCap API key to get the price of the token for gas report
+COINMARKETCAP_KEY=
\ No newline at end of file
diff --git a/contracts/.gitignore b/contracts/.gitignore
index c5dce6a..b9e5676 100644
--- a/contracts/.gitignore
+++ b/contracts/.gitignore
@@ -2,10 +2,11 @@
 cache
 artifacts
 deployments/hardhat
+gas-report
 
 # Foundry
 out
 forge-cache
 
 # OpenZeppelin
-.openzeppelin/unknown-*.json
+.openzeppelin/unknown-*.json
\ No newline at end of file
diff --git a/contracts/contracts/FleekERC721.sol b/contracts/contracts/FleekERC721.sol
index dc7a85a..d42bf78 100644
--- a/contracts/contracts/FleekERC721.sol
+++ b/contracts/contracts/FleekERC721.sol
@@ -9,6 +9,7 @@ import "./FleekAccessControl.sol";
 import "./FleekBilling.sol";
 import "./FleekPausable.sol";
 import "./FleekAccessPoints.sol";
+import "./util/FleekENS.sol";
 import "./util/FleekStrings.sol";
 import "./IERCX.sol";
 
@@ -104,7 +105,7 @@ contract FleekERC721 is
         string memory name,
         string memory description,
         string memory externalURL,
-        string memory ENS,
+        string calldata ens,
         string memory commitHash,
         string memory gitRepository,
         string memory logo,
@@ -112,6 +113,7 @@ contract FleekERC721 is
         bool accessPointAutoApproval,
         address verifier
     ) public payable requirePayment(Billing.Mint) returns (uint256) {
+        FleekENS.requireENSOwner(ens);
         uint256 tokenId = _appIds;
         _mint(to, tokenId);
 
@@ -121,7 +123,7 @@ contract FleekERC721 is
         app.name = name;
         app.description = description;
         app.externalURL = externalURL;
-        app.ENS = ENS;
+        app.ENS = ens;
         app.logo = logo;
         app.color = color;
 
@@ -134,7 +136,7 @@ contract FleekERC721 is
             name,
             description,
             externalURL,
-            ENS,
+            ens,
             commitHash,
             gitRepository,
             logo,
@@ -274,8 +276,9 @@ contract FleekERC721 is
      */
     function setTokenENS(
         uint256 tokenId,
-        string memory _tokenENS
+        string calldata _tokenENS
     ) public virtual requireTokenRole(tokenId, TokenRoles.Controller) {
+        FleekENS.requireENSOwner(_tokenENS);
         _requireMinted(tokenId);
         _apps[tokenId].ENS = _tokenENS;
         emit MetadataUpdate(tokenId, "ENS", _tokenENS, msg.sender);
diff --git a/contracts/contracts/util/FleekENS.sol b/contracts/contracts/util/FleekENS.sol
new file mode 100644
index 0000000..d101849
--- /dev/null
+++ b/contracts/contracts/util/FleekENS.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.7;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {ENS} from "@ensdomains/ens-contracts/contracts/registry/ENS.sol";
+import {Resolver} from "@ensdomains/ens-contracts/contracts/resolvers/Resolver.sol";
+
+error MustBeENSOwner();
+
+library FleekENS {
+    ENS internal constant _ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
+
+    /**
+     * @dev Reverts if the sender is not the owner of the ENS node.
+     */
+    function requireENSOwner(string calldata name) internal view {
+        if (_ens.owner(namehash(bytes(name), 0)) != msg.sender) revert MustBeENSOwner();
+    }
+
+    /**
+     * @dev Processes the name and returns the ENS node hash.
+     */
+    function namehash(bytes calldata name, uint256 index) internal view returns (bytes32) {
+        for (uint256 i = index; i < name.length; i++) {
+            if (name[i] == ".") {
+                return keccak256(abi.encodePacked(namehash(name, i + 1), keccak256(name[index:i])));
+            }
+        }
+        return keccak256(abi.encodePacked(bytes32(0x0), keccak256(name[index:name.length])));
+    }
+}
diff --git a/contracts/foundry.toml b/contracts/foundry.toml
index db698f2..65fa18e 100644
--- a/contracts/foundry.toml
+++ b/contracts/foundry.toml
@@ -4,3 +4,8 @@ out = 'out'
 libs = ['node_modules', 'lib']
 test = 'test/foundry'
 cache_path  = 'forge-cache'
+via_ir = true
+
+[rpc_endpoints]
+mainnet = "${MAINNET_API_KEY}"
+
diff --git a/contracts/hardhat.config.ts b/contracts/hardhat.config.ts
index bfeb00f..f46936b 100644
--- a/contracts/hardhat.config.ts
+++ b/contracts/hardhat.config.ts
@@ -18,6 +18,8 @@ const {
   PRIVATE_KEY,
   REPORT_GAS,
   POLYGONSCAN_KEY,
+  MAINNET_API_KEY,
+  COINMARKETCAP_KEY,
 } = process.env;
 
 const config: HardhatUserConfig = {
@@ -25,6 +27,12 @@ const config: HardhatUserConfig = {
   networks: {
     hardhat: {
       chainId: 31337,
+      forking: MAINNET_API_KEY
+        ? {
+            url: MAINNET_API_KEY,
+            blockNumber: 16876149,
+          }
+        : undefined,
     },
     mumbai: {
       url: API_URL,
@@ -35,9 +43,9 @@ const config: HardhatUserConfig = {
   gasReporter: {
     enabled: REPORT_GAS === 'true' || false,
     currency: 'USD',
-    outputFile: 'gas-report.txt',
+    outputFile: 'gas-report',
     noColors: true,
-    // coinmarketcap: process.env.COINMARKETCAP_API_KEY,
+    coinmarketcap: COINMARKETCAP_KEY,
   },
   contractSizer: {
     runOnCompile: false,
diff --git a/contracts/package.json b/contracts/package.json
index 70ccae0..fe8b160 100644
--- a/contracts/package.json
+++ b/contracts/package.json
@@ -4,8 +4,8 @@
   "description": "",
   "private": "false",
   "scripts": {
-    "test": "hardhat test && forge test --via-ir",
-    "test:foundry": "forge test --via-ir -vvv",
+    "test": "yarn test:hardhat && yarn test:foundry",
+    "test:foundry": "forge test -vvv --fork-url mainnet --fork-block-number 16876149",
     "test:hardhat": "hardhat test",
     "format": "prettier --write \"./**/*.{js,json,sol,ts}\"",
     "node:hardhat": "hardhat node",
@@ -25,6 +25,8 @@
   },
   "homepage": "https://github.com/fleekxyz/non-fungible-apps#readme",
   "devDependencies": {
+    "@ensdomains/ens-contracts": "^0.0.20",
+    "@ensdomains/eth-ens-namehash": "^2.0.15",
     "@nomicfoundation/hardhat-chai-matchers": "^1.0.5",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.7",
     "@nomicfoundation/hardhat-toolbox": "^2.0.0",
diff --git a/contracts/test/foundry/FleekERC721/AccessControl.t.sol b/contracts/test/foundry/FleekERC721/AccessControl.t.sol
index 08c9167..71fdb29 100644
--- a/contracts/test/foundry/FleekERC721/AccessControl.t.sol
+++ b/contracts/test/foundry/FleekERC721/AccessControl.t.sol
@@ -162,6 +162,7 @@ contract Test_FleekERC721_AccessControl is Test_FleekERC721_Base, Test_FleekERC7
 
     function test_mint() public {
         // Anyone can mint
+        transferENS(TestConstants.APP_ENS, anyAddress);
         vm.startPrank(anyAddress);
         mintDefault(address(99));
         vm.stopPrank();
@@ -201,7 +202,7 @@ contract Test_FleekERC721_AccessControl is Test_FleekERC721_Base, Test_FleekERC7
     }
 
     function test_setTokenENS() public {
-        string memory ens = "ens";
+        string memory ens = "ens.eth";
 
         // ColletionOwner
         vm.prank(collectionOwner);
@@ -214,10 +215,12 @@ contract Test_FleekERC721_AccessControl is Test_FleekERC721_Base, Test_FleekERC7
         CuT.setTokenENS(tokenId, ens);
 
         // TokenOwner
+        transferENS(ens, tokenOwner);
         vm.prank(tokenOwner);
         CuT.setTokenENS(tokenId, ens);
 
         // TokenController
+        transferENS(ens, tokenController);
         vm.prank(tokenController);
         CuT.setTokenENS(tokenId, ens);
 
diff --git a/contracts/test/foundry/FleekERC721/Constants.sol b/contracts/test/foundry/FleekERC721/Constants.sol
index 00dcd17..bd89a10 100644
--- a/contracts/test/foundry/FleekERC721/Constants.sol
+++ b/contracts/test/foundry/FleekERC721/Constants.sol
@@ -24,7 +24,4 @@ library TestConstants {
 
     string public constant LOGO_1 =
         "data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMTAwMCAxMDAwIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxMDAwIDEwMDAiIHhtbDpzcGFjZT0icHJlc2VydmUiPgo8Zz48cGF0aCBkPSJNNTAwLDEwQzIyOS40LDEwLDEwLDIyOS40LDEwLDUwMGMwLDI3MC42LDIxOS40LDQ5MCw0OTAsNDkwYzI3MC42LDAsNDkwLTIxOS40LDQ5MC00OTBDOTkwLDIyOS40LDc3MC42LDEwLDUwMCwxMHogTTgxNSw4MTVjLTQwLjksNDAuOS04OC42LDczLjEtMTQxLjYsOTUuNWMtNTQuOSwyMy4yLTExMy4yLDM1LTE3My40LDM1Yy02MC4yLDAtMTE4LjUtMTEuOC0xNzMuNC0zNUMyNzMuNiw4ODgsMjI1LjksODU1LjksMTg1LDgxNXMtNzMtODguNi05NS41LTE0MS42Yy0yMy4yLTU0LjktMzUtMTEzLjItMzUtMTczLjRjMC02MC4yLDExLjgtMTE4LjUsMzUtMTczLjRjMjIuNC01Myw1NC42LTEwMC43LDk1LjUtMTQxLjZzODguNi03MywxNDEuNi05NS41YzU0LjktMjMuMiwxMTMuMi0zNSwxNzMuNC0zNWM2MC4yLDAsMTE4LjUsMTEuOCwxNzMuNCwzNWM1MywyMi40LDEwMC43LDU0LjYsMTQxLjYsOTUuNWM0MC45LDQwLjksNzMsODguNiw5NS41LDE0MS42YzIzLjIsNTQuOSwzNSwxMTMuMiwzNSwxNzMuNGMwLDYwLjItMTEuOCwxMTguNS0zNSwxNzMuNEM4ODgsNzI2LjQsODU1LjksNzc0LjEsODE1LDgxNXoiLz48L2c+Cjwvc3ZnPg==";
-
-    string public constant DEFAULT_TOKEN_URI =
-        "data:application/json;base64,{"name":"New App Name","description":"New description for the app.","owner":"0x34a1d3fff3958843c43ad80f30b94c510645c316","external_url":"https://new-url.com","image":"data:image/svg+xml;base64,<svg width="1065" height="1065" viewBox="0 0 1065 1065" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><style type="text/css">@import url("https://fonts.googleapis.com/css2?family=Inter:wght@500;600");</style><rect width="1065" height="1065" fill="url(#background)" /><rect opacity="0.2" width="1065" height="1065" fill="url(#background-radial)" /><g filter="url(#diskette-shadow)"><path d="M857.231 279.712L902.24 286.675C910.547 287.96 917.915 292.721 922.5 299.768L938.894 324.964C942.249 330.12 943.311 336.437 941.827 342.406L937.798 358.615L924.049 356.65L919.416 374.084L934.068 376.24L791.947 922.152C788.109 936.896 773.694 946.308 758.651 943.893L179.636 850.928C162.318 848.147 151.215 830.987 155.776 814.051L160.478 796.59L704.315 879.574L857.231 279.712Z" fill="#050505" /></g><path d="M840.231 240.712L885.24 247.675C893.547 248.961 900.915 253.722 905.5 260.768L921.894 285.965C925.249 291.12 926.311 297.437 924.827 303.406L920.798 319.616L907.049 317.65L902.416 335.084L917.068 337.241L774.947 883.152C771.109 897.896 756.694 907.308 741.651 904.893L162.636 811.928C145.318 809.147 134.215 791.987 138.776 775.051L143.478 757.59L687.315 840.574L840.231 240.712Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="#131316" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="url(#diskette-gradient)" fill-opacity="0.2" /><path d="M335.38 208.113C335.922 208.198 336.417 207.686 336.283 207.179L330.39 184.795C330.249 184.261 329.529 184.148 329.129 184.597L312.358 203.411C311.978 203.838 312.174 204.458 312.716 204.544L317.962 205.37C318.357 205.432 318.595 205.796 318.493 206.183L314.7 220.551C314.597 220.938 314.835 221.302 315.231 221.364L324.539 222.83C324.935 222.893 325.338 222.629 325.44 222.242L329.233 207.875C329.336 207.488 329.739 207.224 330.135 207.286L335.38 208.113Z" fill="url(#main)" /><path d="M319.282 269.087C319.824 269.173 320.319 268.661 320.186 268.154L314.292 245.77C314.151 245.236 313.431 245.123 313.031 245.572L296.261 264.386C295.88 264.812 296.076 265.433 296.618 265.518L301.864 266.344C302.259 266.407 302.497 266.771 302.395 267.158L298.602 281.526C298.5 281.913 298.737 282.277 299.133 282.339L308.441 283.805C308.837 283.867 309.24 283.604 309.343 283.217L313.136 268.849C313.238 268.462 313.641 268.199 314.037 268.261L319.282 269.087Z" fill="black" fill-opacity="0.5" /><path d="M303.184 330.062C303.726 330.148 304.221 329.636 304.088 329.128L298.194 306.745C298.053 306.211 297.333 306.098 296.933 306.547L280.163 325.361C279.782 325.787 279.979 326.408 280.52 326.493L285.766 327.319C286.161 327.382 286.399 327.746 286.297 328.133L282.504 342.501C282.402 342.888 282.639 343.252 283.035 343.314L292.344 344.78C292.739 344.842 293.142 344.579 293.245 344.192L297.038 329.824C297.14 329.437 297.543 329.174 297.939 329.236L303.184 330.062Z" fill="black" fill-opacity="0.5" /><path stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M290.109 463.418C292.358 454.902 301.233 449.11 309.933 450.48L771.07 523.096C779.77 524.467 785 532.48 782.752 540.996L692.086 884.418L199.443 806.84L290.109 463.418Z" fill="black" fill-opacity="0.14" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M787.589 237.349L460.354 185.818L406.325 390.469C403.872 399.759 409.578 408.501 419.069 409.996L711.934 456.114C721.425 457.609 731.107 451.29 733.56 442L787.589 237.349ZM660.269 245.01C655.523 244.263 650.682 247.423 649.456 252.068L607.386 411.418C606.16 416.063 609.013 420.434 613.759 421.181L682.499 432.006C687.245 432.753 692.086 429.594 693.312 424.949L735.382 265.599C736.608 260.954 733.755 256.583 729.01 255.835L660.269 245.01Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M864.643 283.937C865.186 283.605 865.708 284.257 865.239 284.683L844.268 303.719C843.938 304.018 844.093 304.517 844.526 304.548L853.726 305.207C854.184 305.24 854.321 305.787 853.942 306.071L833.884 321.112C833.506 321.396 833.643 321.943 834.101 321.976L844.007 322.685C844.491 322.72 844.605 323.319 844.177 323.58L797.752 351.954C797.209 352.286 796.687 351.634 797.156 351.209L818.403 331.922C818.733 331.622 818.577 331.123 818.145 331.092L808.748 330.42C808.292 330.387 808.154 329.843 808.529 329.558L828.054 314.744C828.43 314.459 828.291 313.915 827.835 313.882L818.389 313.206C817.904 313.171 817.79 312.572 818.218 312.311L864.643 283.937Z" fill="white" /><g transform="matrix(0.987827 0.155557 -0.255261 0.966872 250 735)"><text font-family="Inter, sans-serif" font-weight="bold" font-size="42" fill="#E5E7F8">New App Name</text><text font-family="Inter, sans-serif" font-weight="normal" y="40" font-size="22" fill="#7F8192">new-ens.eth</text></g><image width="167" height="167" transform="matrix(0.987827 0.155557 -0.255261 0.966872 444.117 524.17)" href="data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMTAwMCAxMDAwIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxMDAwIDEwMDAiIHhtbDpzcGFjZT0icHJlc2VydmUiPgo8Zz48cGF0aCBkPSJNNTAwLDEwQzIyOS40LDEwLDEwLDIyOS40LDEwLDUwMGMwLDI3MC42LDIxOS40LDQ5MCw0OTAsNDkwYzI3MC42LDAsNDkwLTIxOS40LDQ5MC00OTBDOTkwLDIyOS40LDc3MC42LDEwLDUwMCwxMHogTTgxNSw4MTVjLTQwLjksNDAuOS04OC42LDczLjEtMTQxLjYsOTUuNWMtNTQuOSwyMy4yLTExMy4yLDM1LTE3My40LDM1Yy02MC4yLDAtMTE4LjUtMTEuOC0xNzMuNC0zNUMyNzMuNiw4ODgsMjI1LjksODU1LjksMTg1LDgxNXMtNzMtODguNi05NS41LTE0MS42Yy0yMy4yLTU0LjktMzUtMTEzLjItMzUtMTczLjRjMC02MC4yLDExLjgtMTE4LjUsMzUtMTczLjRjMjIuNC01Myw1NC42LTEwMC43LDk1LjUtMTQxLjZzODguNi03MywxNDEuNi05NS41YzU0LjktMjMuMiwxMTMuMi0zNSwxNzMuNC0zNWM2MC4yLDAsMTE4LjUsMTEuOCwxNzMuNCwzNWM1MywyMi40LDEwMC43LDU0LjYsMTQxLjYsOTUuNWM0MC45LDQwLjksNzMsODguNiw5NS41LDE0MS42YzIzLjIsNTQuOSwzNSwxMTMuMiwzNSwxNzMuNGMwLDYwLjItMTEuOCwxMTguNS0zNSwxNzMuNEM4ODgsNzI2LjQsODU1LjksNzc0LjEsODE1LDgxNXoiLz48L2c+Cjwvc3ZnPg==" /><defs><filter id="diskette-shadow" x="70.7489" y="195.712" width="955.733" height="832.558" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" /><feBlend in="SourceGraphic" /><feGaussianBlur stdDeviation="42" /></filter><linearGradient id="background" x1="532.5" y1="0" x2="532.5" y2="1065" gradientUnits="userSpaceOnUse"><stop /><stop offset="1" stop-color="#131313" /></linearGradient><radialGradient id="background-radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(532.5 532.5) rotate(89.961) scale(735)"><stop stop-color="#654321" /><stop offset="1" stop-color="#654321" stop-opacity="0" /></radialGradient><linearGradient id="diskette-gradient" x1="925.626" y1="256.896" x2="136.779" y2="800.203" gradientUnits="userSpaceOnUse"><stop stop-color="#654321" /><stop offset="1" stop-color="#2C313F" /></linearGradient><linearGradient id="main"><stop stop-color="#654321" /></linearGradient></defs></svg>","access_point_auto_approval":false,"verified":false,"attributes": [{"trait_type": "ENS", "value":"new-ens.eth"},{"trait_type": "Commit Hash", "value":"ce1a3fc141e29f8e1d00a654e156c4982d7711bf"},{"trait_type": "Repository", "value":"https://github.com/other/repo"},{"trait_type": "Version", "value":"1"},{"trait_type": "Color", "value":"#654321"}]}";
 }
diff --git a/contracts/test/foundry/FleekERC721/ENS.t.sol b/contracts/test/foundry/FleekERC721/ENS.t.sol
new file mode 100644
index 0000000..280d929
--- /dev/null
+++ b/contracts/test/foundry/FleekERC721/ENS.t.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "./TestBase.sol";
+import {Utils} from "./Utils.sol";
+
+contract Test_FleekERC721_ENS is Test_FleekERC721_Base {
+    function expectRevertWithMustBeENSOwner() internal {
+        vm.expectRevert(MustBeENSOwner.selector);
+    }
+
+    function setUp() public {
+        baseSetUp();
+    }
+
+    function testFuzz_cannotMintIfNotENSOwner(address account) public {
+        vm.assume(deployer != account);
+        vm.prank(account);
+        expectRevertWithMustBeENSOwner();
+        mintDefault(account);
+    }
+
+    function testFuzz_cannotSetTokenENSIfNotENSOwner(address account) public {
+        vm.assume(deployer != account);
+        mintDefault(account);
+
+        vm.prank(account);
+        expectRevertWithMustBeENSOwner();
+        CuT.setTokenENS(0, TestConstants.APP_ENS);
+    }
+}
diff --git a/contracts/test/foundry/FleekERC721/GetToken.t.sol b/contracts/test/foundry/FleekERC721/GetToken.t.sol
index 4cd2234..dfcce32 100644
--- a/contracts/test/foundry/FleekERC721/GetToken.t.sol
+++ b/contracts/test/foundry/FleekERC721/GetToken.t.sol
@@ -18,7 +18,7 @@ contract Test_FleekERC721_GetToken is Test_FleekERC721_Base {
             string memory name,
             string memory description,
             string memory externalURL,
-            string memory ENS,
+            string memory ens,
             uint256 currentBuild,
             string memory logo,
             uint24 color
@@ -28,7 +28,7 @@ contract Test_FleekERC721_GetToken is Test_FleekERC721_Base {
         assertEq(externalURL, TestConstants.APP_EXTERNAL_URL);
         assertEq(logo, TestConstants.LOGO_0);
         assertEq(color, TestConstants.APP_COLOR);
-        assertEq(ENS, TestConstants.APP_ENS);
+        assertEq(ens, TestConstants.APP_ENS);
         assertEq(currentBuild, 0);
     }
 
@@ -45,6 +45,7 @@ contract Test_FleekERC721_GetToken is Test_FleekERC721_Base {
         CuT.setTokenName(tokenId, newAppName);
         CuT.setTokenDescription(tokenId, newDescription);
         CuT.setTokenExternalURL(tokenId, newExternalURL);
+        transferENS(newENS, deployer);
         CuT.setTokenENS(tokenId, newENS);
         CuT.setTokenBuild(tokenId, newCommitHash, newRepository);
         CuT.setTokenLogoAndColor(tokenId, newLogo, newColor);
@@ -53,7 +54,7 @@ contract Test_FleekERC721_GetToken is Test_FleekERC721_Base {
             string memory name,
             string memory description,
             string memory externalURL,
-            string memory ENS,
+            string memory ens,
             uint256 currentBuild,
             string memory logo,
             uint24 color
@@ -63,7 +64,7 @@ contract Test_FleekERC721_GetToken is Test_FleekERC721_Base {
         assertEq(externalURL, newExternalURL);
         assertEq(logo, newLogo);
         assertEq(color, newColor);
-        assertEq(ENS, newENS);
+        assertEq(ens, newENS);
         assertEq(currentBuild, 1);
     }
 
diff --git a/contracts/test/foundry/FleekERC721/Mint.t.sol b/contracts/test/foundry/FleekERC721/Mint.t.sol
index 01e94e9..e66d637 100644
--- a/contracts/test/foundry/FleekERC721/Mint.t.sol
+++ b/contracts/test/foundry/FleekERC721/Mint.t.sol
@@ -26,6 +26,8 @@ contract Test_FleekERC721_Mint is Test_FleekERC721_Base {
 
     function test_mintTwoTokensForTwoAddresses() public {
         uint256 firstMint = mintDefault(deployer);
+
+        transferENS("fleek.eth", deployer);
         uint256 secondMint = CuT.mint(
             address(12),
             "Different App Name",
@@ -45,6 +47,7 @@ contract Test_FleekERC721_Mint is Test_FleekERC721_Base {
     }
 
     function test_mintWithAutoApprovalAPsOn() public {
+        transferENS("fleek.eth", deployer);
         uint256 mint = CuT.mint(
             address(12),
             "Different App Name",
@@ -83,6 +86,7 @@ contract Test_FleekERC721_Mint is Test_FleekERC721_Base {
         bool autoApprovalAp
     ) public {
         vm.assume(to != address(0));
+        transferENS(ens, deployer);
         uint256 tokenId = CuT.mint(
             to,
             appName,
diff --git a/contracts/test/foundry/FleekERC721/TestBase.sol b/contracts/test/foundry/FleekERC721/TestBase.sol
index 3fa55aa..27cb5d3 100644
--- a/contracts/test/foundry/FleekERC721/TestBase.sol
+++ b/contracts/test/foundry/FleekERC721/TestBase.sol
@@ -5,6 +5,7 @@ pragma solidity ^0.8.17;
 import "forge-std/Test.sol";
 import "contracts/FleekERC721.sol";
 import {TestConstants} from "./Constants.sol";
+import {Utils} from "./Utils.sol";
 
 abstract contract Test_FleekERC721_Assertions is Test {
     function expectRevertWithTokenRole(uint256 tokenId, FleekAccessControl.TokenRoles role) public {
@@ -47,6 +48,7 @@ abstract contract Test_FleekERC721_Assertions is Test {
 abstract contract Test_FleekERC721_Base is Test, Test_FleekERC721_Assertions {
     FleekERC721 internal CuT; // Contract Under Test
     address internal deployer;
+    ENS internal constant _ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
 
     function deployUninitialized() internal returns (FleekERC721) {
         FleekERC721 _contract = new FleekERC721();
@@ -59,6 +61,15 @@ abstract contract Test_FleekERC721_Base is Test, Test_FleekERC721_Assertions {
         CuT = deployUninitialized();
         CuT.initialize("Test Contract", "FLKAPS", new uint256[](0));
         deployer = address(this);
+        transferENS(TestConstants.APP_ENS, deployer);
+    }
+
+    function transferENS(string memory ens, address newOwner) public {
+        bytes32 node = Utils.namehash(ens);
+        address ensOwner = _ens.owner(node);
+        vm.deal(ensOwner, 100000000000);
+        vm.prank(ensOwner);
+        _ens.setOwner(node, newOwner);
     }
 
     function mintDefault(address to) internal returns (uint256) {
diff --git a/contracts/test/foundry/FleekERC721/TokenURI.t.sol b/contracts/test/foundry/FleekERC721/TokenURI.t.sol
index a44b402..8204502 100644
--- a/contracts/test/foundry/FleekERC721/TokenURI.t.sol
+++ b/contracts/test/foundry/FleekERC721/TokenURI.t.sol
@@ -47,7 +47,7 @@ contract Test_FleekERC721_TokenURI is Test_FleekERC721_Base, Test_FleekERC721_To
         string memory uri = CuT.tokenURI(tokenId);
         assertEq(
             uri,
-            "data:application/json;base64,{"name":"Foundry Test App","description":"This is a test application submitted by foundry tests.","owner":"0x34a1d3fff3958843c43ad80f30b94c510645c316","external_url":"https://foundry.test","image":"data:image/svg+xml;base64,<svg width="1065" height="1065" viewBox="0 0 1065 1065" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><style type="text/css">@import url("https://fonts.googleapis.com/css2?family=Inter:wght@500;600");</style><rect width="1065" height="1065" fill="url(#background)" /><rect opacity="0.2" width="1065" height="1065" fill="url(#background-radial)" /><g filter="url(#diskette-shadow)"><path d="M857.231 279.712L902.24 286.675C910.547 287.96 917.915 292.721 922.5 299.768L938.894 324.964C942.249 330.12 943.311 336.437 941.827 342.406L937.798 358.615L924.049 356.65L919.416 374.084L934.068 376.24L791.947 922.152C788.109 936.896 773.694 946.308 758.651 943.893L179.636 850.928C162.318 848.147 151.215 830.987 155.776 814.051L160.478 796.59L704.315 879.574L857.231 279.712Z" fill="#050505" /></g><path d="M840.231 240.712L885.24 247.675C893.547 248.961 900.915 253.722 905.5 260.768L921.894 285.965C925.249 291.12 926.311 297.437 924.827 303.406L920.798 319.616L907.049 317.65L902.416 335.084L917.068 337.241L774.947 883.152C771.109 897.896 756.694 907.308 741.651 904.893L162.636 811.928C145.318 809.147 134.215 791.987 138.776 775.051L143.478 757.59L687.315 840.574L840.231 240.712Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="#131316" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="url(#diskette-gradient)" fill-opacity="0.2" /><path d="M335.38 208.113C335.922 208.198 336.417 207.686 336.283 207.179L330.39 184.795C330.249 184.261 329.529 184.148 329.129 184.597L312.358 203.411C311.978 203.838 312.174 204.458 312.716 204.544L317.962 205.37C318.357 205.432 318.595 205.796 318.493 206.183L314.7 220.551C314.597 220.938 314.835 221.302 315.231 221.364L324.539 222.83C324.935 222.893 325.338 222.629 325.44 222.242L329.233 207.875C329.336 207.488 329.739 207.224 330.135 207.286L335.38 208.113Z" fill="url(#main)" /><path d="M319.282 269.087C319.824 269.173 320.319 268.661 320.186 268.154L314.292 245.77C314.151 245.236 313.431 245.123 313.031 245.572L296.261 264.386C295.88 264.812 296.076 265.433 296.618 265.518L301.864 266.344C302.259 266.407 302.497 266.771 302.395 267.158L298.602 281.526C298.5 281.913 298.737 282.277 299.133 282.339L308.441 283.805C308.837 283.867 309.24 283.604 309.343 283.217L313.136 268.849C313.238 268.462 313.641 268.199 314.037 268.261L319.282 269.087Z" fill="black" fill-opacity="0.5" /><path d="M303.184 330.062C303.726 330.148 304.221 329.636 304.088 329.128L298.194 306.745C298.053 306.211 297.333 306.098 296.933 306.547L280.163 325.361C279.782 325.787 279.979 326.408 280.52 326.493L285.766 327.319C286.161 327.382 286.399 327.746 286.297 328.133L282.504 342.501C282.402 342.888 282.639 343.252 283.035 343.314L292.344 344.78C292.739 344.842 293.142 344.579 293.245 344.192L297.038 329.824C297.14 329.437 297.543 329.174 297.939 329.236L303.184 330.062Z" fill="black" fill-opacity="0.5" /><path stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M290.109 463.418C292.358 454.902 301.233 449.11 309.933 450.48L771.07 523.096C779.77 524.467 785 532.48 782.752 540.996L692.086 884.418L199.443 806.84L290.109 463.418Z" fill="black" fill-opacity="0.14" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M787.589 237.349L460.354 185.818L406.325 390.469C403.872 399.759 409.578 408.501 419.069 409.996L711.934 456.114C721.425 457.609 731.107 451.29 733.56 442L787.589 237.349ZM660.269 245.01C655.523 244.263 650.682 247.423 649.456 252.068L607.386 411.418C606.16 416.063 609.013 420.434 613.759 421.181L682.499 432.006C687.245 432.753 692.086 429.594 693.312 424.949L735.382 265.599C736.608 260.954 733.755 256.583 729.01 255.835L660.269 245.01Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M864.643 283.937C865.186 283.605 865.708 284.257 865.239 284.683L844.268 303.719C843.938 304.018 844.093 304.517 844.526 304.548L853.726 305.207C854.184 305.24 854.321 305.787 853.942 306.071L833.884 321.112C833.506 321.396 833.643 321.943 834.101 321.976L844.007 322.685C844.491 322.72 844.605 323.319 844.177 323.58L797.752 351.954C797.209 352.286 796.687 351.634 797.156 351.209L818.403 331.922C818.733 331.622 818.577 331.123 818.145 331.092L808.748 330.42C808.292 330.387 808.154 329.843 808.529 329.558L828.054 314.744C828.43 314.459 828.291 313.915 827.835 313.882L818.389 313.206C817.904 313.171 817.79 312.572 818.218 312.311L864.643 283.937Z" fill="white" /><g transform="matrix(0.987827 0.155557 -0.255261 0.966872 250 735)"><text font-family="Inter, sans-serif" font-weight="bold" font-size="42" fill="#E5E7F8">Foundry Test App</text><text font-family="Inter, sans-serif" font-weight="normal" y="40" font-size="22" fill="#7F8192">foundry.eth</text></g><image width="167" height="167" transform="matrix(0.987827 0.155557 -0.255261 0.966872 444.117 524.17)" href="data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjI1MDAiIHdpZHRoPSIyMTgzIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjQgMTQxLjUzMTk5OTk5OTk5OTk4Ij48cGF0aCBkPSJNMTAuMzgzIDEyNi44OTRMMCAwbDEyNCAuMjU1LTEwLjk3OSAxMjYuNjM5LTUwLjU1MyAxNC42Mzh6IiBmaWxsPSIjZTM0ZjI2Ii8+PHBhdGggZD0iTTYyLjQ2OCAxMjkuMjc3VjEyLjA4NWw1MS4wNjQuMTctOS4xMDYgMTA0Ljg1MXoiIGZpbGw9IiNlZjY1MmEiLz48cGF0aCBkPSJNOTkuNDkgNDEuMzYybDEuNDQ2LTE1LjQ5SDIyLjM4M2w0LjM0IDQ3LjQ5aDU0LjIxM0w3OC44MSA5My42MTdsLTE3LjM2MiA0LjY4LTE3LjYxNy01LjEwNi0uOTM2LTEyLjA4NUgyNy4zMTlsMi4xMjggMjQuNjgxIDMyIDguOTM2IDMyLjI1NS04LjkzNiA0LjM0LTQ4LjE3SDQxLjEwN0wzOS40OSA0MS4zNjJ6IiBmaWxsPSIjZmZmIi8+PC9zdmc+" /><defs><filter id="diskette-shadow" x="70.7489" y="195.712" width="955.733" height="832.558" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" /><feBlend in="SourceGraphic" /><feGaussianBlur stdDeviation="42" /></filter><linearGradient id="background" x1="532.5" y1="0" x2="532.5" y2="1065" gradientUnits="userSpaceOnUse"><stop /><stop offset="1" stop-color="#131313" /></linearGradient><radialGradient id="background-radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(532.5 532.5) rotate(89.961) scale(735)"><stop stop-color="#123456" /><stop offset="1" stop-color="#123456" stop-opacity="0" /></radialGradient><linearGradient id="diskette-gradient" x1="925.626" y1="256.896" x2="136.779" y2="800.203" gradientUnits="userSpaceOnUse"><stop stop-color="#123456" /><stop offset="1" stop-color="#2C313F" /></linearGradient><linearGradient id="main"><stop stop-color="#123456" /></linearGradient></defs></svg>","access_point_auto_approval":false,"verified":false,"attributes": [{"trait_type": "ENS", "value":"foundry.eth"},{"trait_type": "Commit Hash", "value":"afff3f6"},{"trait_type": "Repository", "value":"https://github.com/fleekxyz/non-fungible-apps"},{"trait_type": "Version", "value":"0"},{"trait_type": "Color", "value":"#123456"}]}"
+            "data:application/json;base64,{"name":"Foundry Test App","description":"This is a test application submitted by foundry tests.","owner":"0x90193c961a926261b756d1e5bb255e67ff9498a1","external_url":"https://foundry.test","image":"data:image/svg+xml;base64,<svg width="1065" height="1065" viewBox="0 0 1065 1065" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><style type="text/css">@import url("https://fonts.googleapis.com/css2?family=Inter:wght@500;600");</style><rect width="1065" height="1065" fill="url(#background)" /><rect opacity="0.2" width="1065" height="1065" fill="url(#background-radial)" /><g filter="url(#diskette-shadow)"><path d="M857.231 279.712L902.24 286.675C910.547 287.96 917.915 292.721 922.5 299.768L938.894 324.964C942.249 330.12 943.311 336.437 941.827 342.406L937.798 358.615L924.049 356.65L919.416 374.084L934.068 376.24L791.947 922.152C788.109 936.896 773.694 946.308 758.651 943.893L179.636 850.928C162.318 848.147 151.215 830.987 155.776 814.051L160.478 796.59L704.315 879.574L857.231 279.712Z" fill="#050505" /></g><path d="M840.231 240.712L885.24 247.675C893.547 248.961 900.915 253.722 905.5 260.768L921.894 285.965C925.249 291.12 926.311 297.437 924.827 303.406L920.798 319.616L907.049 317.65L902.416 335.084L917.068 337.241L774.947 883.152C771.109 897.896 756.694 907.308 741.651 904.893L162.636 811.928C145.318 809.147 134.215 791.987 138.776 775.051L143.478 757.59L687.315 840.574L840.231 240.712Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="#131316" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="url(#diskette-gradient)" fill-opacity="0.2" /><path d="M335.38 208.113C335.922 208.198 336.417 207.686 336.283 207.179L330.39 184.795C330.249 184.261 329.529 184.148 329.129 184.597L312.358 203.411C311.978 203.838 312.174 204.458 312.716 204.544L317.962 205.37C318.357 205.432 318.595 205.796 318.493 206.183L314.7 220.551C314.597 220.938 314.835 221.302 315.231 221.364L324.539 222.83C324.935 222.893 325.338 222.629 325.44 222.242L329.233 207.875C329.336 207.488 329.739 207.224 330.135 207.286L335.38 208.113Z" fill="url(#main)" /><path d="M319.282 269.087C319.824 269.173 320.319 268.661 320.186 268.154L314.292 245.77C314.151 245.236 313.431 245.123 313.031 245.572L296.261 264.386C295.88 264.812 296.076 265.433 296.618 265.518L301.864 266.344C302.259 266.407 302.497 266.771 302.395 267.158L298.602 281.526C298.5 281.913 298.737 282.277 299.133 282.339L308.441 283.805C308.837 283.867 309.24 283.604 309.343 283.217L313.136 268.849C313.238 268.462 313.641 268.199 314.037 268.261L319.282 269.087Z" fill="black" fill-opacity="0.5" /><path d="M303.184 330.062C303.726 330.148 304.221 329.636 304.088 329.128L298.194 306.745C298.053 306.211 297.333 306.098 296.933 306.547L280.163 325.361C279.782 325.787 279.979 326.408 280.52 326.493L285.766 327.319C286.161 327.382 286.399 327.746 286.297 328.133L282.504 342.501C282.402 342.888 282.639 343.252 283.035 343.314L292.344 344.78C292.739 344.842 293.142 344.579 293.245 344.192L297.038 329.824C297.14 329.437 297.543 329.174 297.939 329.236L303.184 330.062Z" fill="black" fill-opacity="0.5" /><path stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M290.109 463.418C292.358 454.902 301.233 449.11 309.933 450.48L771.07 523.096C779.77 524.467 785 532.48 782.752 540.996L692.086 884.418L199.443 806.84L290.109 463.418Z" fill="black" fill-opacity="0.14" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M787.589 237.349L460.354 185.818L406.325 390.469C403.872 399.759 409.578 408.501 419.069 409.996L711.934 456.114C721.425 457.609 731.107 451.29 733.56 442L787.589 237.349ZM660.269 245.01C655.523 244.263 650.682 247.423 649.456 252.068L607.386 411.418C606.16 416.063 609.013 420.434 613.759 421.181L682.499 432.006C687.245 432.753 692.086 429.594 693.312 424.949L735.382 265.599C736.608 260.954 733.755 256.583 729.01 255.835L660.269 245.01Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M864.643 283.937C865.186 283.605 865.708 284.257 865.239 284.683L844.268 303.719C843.938 304.018 844.093 304.517 844.526 304.548L853.726 305.207C854.184 305.24 854.321 305.787 853.942 306.071L833.884 321.112C833.506 321.396 833.643 321.943 834.101 321.976L844.007 322.685C844.491 322.72 844.605 323.319 844.177 323.58L797.752 351.954C797.209 352.286 796.687 351.634 797.156 351.209L818.403 331.922C818.733 331.622 818.577 331.123 818.145 331.092L808.748 330.42C808.292 330.387 808.154 329.843 808.529 329.558L828.054 314.744C828.43 314.459 828.291 313.915 827.835 313.882L818.389 313.206C817.904 313.171 817.79 312.572 818.218 312.311L864.643 283.937Z" fill="white" /><g transform="matrix(0.987827 0.155557 -0.255261 0.966872 250 735)"><text font-family="Inter, sans-serif" font-weight="bold" font-size="42" fill="#E5E7F8">Foundry Test App</text><text font-family="Inter, sans-serif" font-weight="normal" y="40" font-size="22" fill="#7F8192">foundry.eth</text></g><image width="167" height="167" transform="matrix(0.987827 0.155557 -0.255261 0.966872 444.117 524.17)" href="data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjI1MDAiIHdpZHRoPSIyMTgzIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjQgMTQxLjUzMTk5OTk5OTk5OTk4Ij48cGF0aCBkPSJNMTAuMzgzIDEyNi44OTRMMCAwbDEyNCAuMjU1LTEwLjk3OSAxMjYuNjM5LTUwLjU1MyAxNC42Mzh6IiBmaWxsPSIjZTM0ZjI2Ii8+PHBhdGggZD0iTTYyLjQ2OCAxMjkuMjc3VjEyLjA4NWw1MS4wNjQuMTctOS4xMDYgMTA0Ljg1MXoiIGZpbGw9IiNlZjY1MmEiLz48cGF0aCBkPSJNOTkuNDkgNDEuMzYybDEuNDQ2LTE1LjQ5SDIyLjM4M2w0LjM0IDQ3LjQ5aDU0LjIxM0w3OC44MSA5My42MTdsLTE3LjM2MiA0LjY4LTE3LjYxNy01LjEwNi0uOTM2LTEyLjA4NUgyNy4zMTlsMi4xMjggMjQuNjgxIDMyIDguOTM2IDMyLjI1NS04LjkzNiA0LjM0LTQ4LjE3SDQxLjEwN0wzOS40OSA0MS4zNjJ6IiBmaWxsPSIjZmZmIi8+PC9zdmc+" /><defs><filter id="diskette-shadow" x="70.7489" y="195.712" width="955.733" height="832.558" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" /><feBlend in="SourceGraphic" /><feGaussianBlur stdDeviation="42" /></filter><linearGradient id="background" x1="532.5" y1="0" x2="532.5" y2="1065" gradientUnits="userSpaceOnUse"><stop /><stop offset="1" stop-color="#131313" /></linearGradient><radialGradient id="background-radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(532.5 532.5) rotate(89.961) scale(735)"><stop stop-color="#123456" /><stop offset="1" stop-color="#123456" stop-opacity="0" /></radialGradient><linearGradient id="diskette-gradient" x1="925.626" y1="256.896" x2="136.779" y2="800.203" gradientUnits="userSpaceOnUse"><stop stop-color="#123456" /><stop offset="1" stop-color="#2C313F" /></linearGradient><linearGradient id="main"><stop stop-color="#123456" /></linearGradient></defs></svg>","access_point_auto_approval":false,"verified":false,"attributes": [{"trait_type": "ENS", "value":"foundry.eth"},{"trait_type": "Commit Hash", "value":"afff3f6"},{"trait_type": "Repository", "value":"https://github.com/fleekxyz/non-fungible-apps"},{"trait_type": "Version", "value":"0"},{"trait_type": "Color", "value":"#123456"}]}"
         );
     }
 
@@ -55,6 +55,7 @@ contract Test_FleekERC721_TokenURI is Test_FleekERC721_Base, Test_FleekERC721_To
         CuT.setTokenName(tokenId, "New App Name");
         CuT.setTokenDescription(tokenId, "New description for the app.");
         CuT.setTokenExternalURL(tokenId, "https://new-url.com");
+        transferENS("new-ens.eth", deployer);
         CuT.setTokenENS(tokenId, "new-ens.eth");
         CuT.setTokenBuild(tokenId, "ce1a3fc141e29f8e1d00a654e156c4982d7711bf", "https://github.com/other/repo");
         CuT.setTokenLogoAndColor(tokenId, TestConstants.LOGO_1, 0x654321);
@@ -63,7 +64,7 @@ contract Test_FleekERC721_TokenURI is Test_FleekERC721_Base, Test_FleekERC721_To
         string memory uri = CuT.tokenURI(tokenId);
         assertEq(
             uri,
-            "data:application/json;base64,{"name":"New App Name","description":"New description for the app.","owner":"0x34a1d3fff3958843c43ad80f30b94c510645c316","external_url":"https://new-url.com","image":"data:image/svg+xml;base64,<svg width="1065" height="1065" viewBox="0 0 1065 1065" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><style type="text/css">@import url("https://fonts.googleapis.com/css2?family=Inter:wght@500;600");</style><rect width="1065" height="1065" fill="url(#background)" /><rect opacity="0.2" width="1065" height="1065" fill="url(#background-radial)" /><g filter="url(#diskette-shadow)"><path d="M857.231 279.712L902.24 286.675C910.547 287.96 917.915 292.721 922.5 299.768L938.894 324.964C942.249 330.12 943.311 336.437 941.827 342.406L937.798 358.615L924.049 356.65L919.416 374.084L934.068 376.24L791.947 922.152C788.109 936.896 773.694 946.308 758.651 943.893L179.636 850.928C162.318 848.147 151.215 830.987 155.776 814.051L160.478 796.59L704.315 879.574L857.231 279.712Z" fill="#050505" /></g><path d="M840.231 240.712L885.24 247.675C893.547 248.961 900.915 253.722 905.5 260.768L921.894 285.965C925.249 291.12 926.311 297.437 924.827 303.406L920.798 319.616L907.049 317.65L902.416 335.084L917.068 337.241L774.947 883.152C771.109 897.896 756.694 907.308 741.651 904.893L162.636 811.928C145.318 809.147 134.215 791.987 138.776 775.051L143.478 757.59L687.315 840.574L840.231 240.712Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="#131316" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="url(#diskette-gradient)" fill-opacity="0.2" /><path d="M335.38 208.113C335.922 208.198 336.417 207.686 336.283 207.179L330.39 184.795C330.249 184.261 329.529 184.148 329.129 184.597L312.358 203.411C311.978 203.838 312.174 204.458 312.716 204.544L317.962 205.37C318.357 205.432 318.595 205.796 318.493 206.183L314.7 220.551C314.597 220.938 314.835 221.302 315.231 221.364L324.539 222.83C324.935 222.893 325.338 222.629 325.44 222.242L329.233 207.875C329.336 207.488 329.739 207.224 330.135 207.286L335.38 208.113Z" fill="url(#main)" /><path d="M319.282 269.087C319.824 269.173 320.319 268.661 320.186 268.154L314.292 245.77C314.151 245.236 313.431 245.123 313.031 245.572L296.261 264.386C295.88 264.812 296.076 265.433 296.618 265.518L301.864 266.344C302.259 266.407 302.497 266.771 302.395 267.158L298.602 281.526C298.5 281.913 298.737 282.277 299.133 282.339L308.441 283.805C308.837 283.867 309.24 283.604 309.343 283.217L313.136 268.849C313.238 268.462 313.641 268.199 314.037 268.261L319.282 269.087Z" fill="black" fill-opacity="0.5" /><path d="M303.184 330.062C303.726 330.148 304.221 329.636 304.088 329.128L298.194 306.745C298.053 306.211 297.333 306.098 296.933 306.547L280.163 325.361C279.782 325.787 279.979 326.408 280.52 326.493L285.766 327.319C286.161 327.382 286.399 327.746 286.297 328.133L282.504 342.501C282.402 342.888 282.639 343.252 283.035 343.314L292.344 344.78C292.739 344.842 293.142 344.579 293.245 344.192L297.038 329.824C297.14 329.437 297.543 329.174 297.939 329.236L303.184 330.062Z" fill="black" fill-opacity="0.5" /><path stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M290.109 463.418C292.358 454.902 301.233 449.11 309.933 450.48L771.07 523.096C779.77 524.467 785 532.48 782.752 540.996L692.086 884.418L199.443 806.84L290.109 463.418Z" fill="black" fill-opacity="0.14" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M787.589 237.349L460.354 185.818L406.325 390.469C403.872 399.759 409.578 408.501 419.069 409.996L711.934 456.114C721.425 457.609 731.107 451.29 733.56 442L787.589 237.349ZM660.269 245.01C655.523 244.263 650.682 247.423 649.456 252.068L607.386 411.418C606.16 416.063 609.013 420.434 613.759 421.181L682.499 432.006C687.245 432.753 692.086 429.594 693.312 424.949L735.382 265.599C736.608 260.954 733.755 256.583 729.01 255.835L660.269 245.01Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M864.643 283.937C865.186 283.605 865.708 284.257 865.239 284.683L844.268 303.719C843.938 304.018 844.093 304.517 844.526 304.548L853.726 305.207C854.184 305.24 854.321 305.787 853.942 306.071L833.884 321.112C833.506 321.396 833.643 321.943 834.101 321.976L844.007 322.685C844.491 322.72 844.605 323.319 844.177 323.58L797.752 351.954C797.209 352.286 796.687 351.634 797.156 351.209L818.403 331.922C818.733 331.622 818.577 331.123 818.145 331.092L808.748 330.42C808.292 330.387 808.154 329.843 808.529 329.558L828.054 314.744C828.43 314.459 828.291 313.915 827.835 313.882L818.389 313.206C817.904 313.171 817.79 312.572 818.218 312.311L864.643 283.937Z" fill="white" /><g transform="matrix(0.987827 0.155557 -0.255261 0.966872 250 735)"><text font-family="Inter, sans-serif" font-weight="bold" font-size="42" fill="#E5E7F8">New App Name</text><text font-family="Inter, sans-serif" font-weight="normal" y="40" font-size="22" fill="#7F8192">new-ens.eth</text></g><image width="167" height="167" transform="matrix(0.987827 0.155557 -0.255261 0.966872 444.117 524.17)" href="data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMTAwMCAxMDAwIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxMDAwIDEwMDAiIHhtbDpzcGFjZT0icHJlc2VydmUiPgo8Zz48cGF0aCBkPSJNNTAwLDEwQzIyOS40LDEwLDEwLDIyOS40LDEwLDUwMGMwLDI3MC42LDIxOS40LDQ5MCw0OTAsNDkwYzI3MC42LDAsNDkwLTIxOS40LDQ5MC00OTBDOTkwLDIyOS40LDc3MC42LDEwLDUwMCwxMHogTTgxNSw4MTVjLTQwLjksNDAuOS04OC42LDczLjEtMTQxLjYsOTUuNWMtNTQuOSwyMy4yLTExMy4yLDM1LTE3My40LDM1Yy02MC4yLDAtMTE4LjUtMTEuOC0xNzMuNC0zNUMyNzMuNiw4ODgsMjI1LjksODU1LjksMTg1LDgxNXMtNzMtODguNi05NS41LTE0MS42Yy0yMy4yLTU0LjktMzUtMTEzLjItMzUtMTczLjRjMC02MC4yLDExLjgtMTE4LjUsMzUtMTczLjRjMjIuNC01Myw1NC42LTEwMC43LDk1LjUtMTQxLjZzODguNi03MywxNDEuNi05NS41YzU0LjktMjMuMiwxMTMuMi0zNSwxNzMuNC0zNWM2MC4yLDAsMTE4LjUsMTEuOCwxNzMuNCwzNWM1MywyMi40LDEwMC43LDU0LjYsMTQxLjYsOTUuNWM0MC45LDQwLjksNzMsODguNiw5NS41LDE0MS42YzIzLjIsNTQuOSwzNSwxMTMuMiwzNSwxNzMuNGMwLDYwLjItMTEuOCwxMTguNS0zNSwxNzMuNEM4ODgsNzI2LjQsODU1LjksNzc0LjEsODE1LDgxNXoiLz48L2c+Cjwvc3ZnPg==" /><defs><filter id="diskette-shadow" x="70.7489" y="195.712" width="955.733" height="832.558" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" /><feBlend in="SourceGraphic" /><feGaussianBlur stdDeviation="42" /></filter><linearGradient id="background" x1="532.5" y1="0" x2="532.5" y2="1065" gradientUnits="userSpaceOnUse"><stop /><stop offset="1" stop-color="#131313" /></linearGradient><radialGradient id="background-radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(532.5 532.5) rotate(89.961) scale(735)"><stop stop-color="#654321" /><stop offset="1" stop-color="#654321" stop-opacity="0" /></radialGradient><linearGradient id="diskette-gradient" x1="925.626" y1="256.896" x2="136.779" y2="800.203" gradientUnits="userSpaceOnUse"><stop stop-color="#654321" /><stop offset="1" stop-color="#2C313F" /></linearGradient><linearGradient id="main"><stop stop-color="#654321" /></linearGradient></defs></svg>","access_point_auto_approval":false,"verified":true,"attributes": [{"trait_type": "ENS", "value":"new-ens.eth"},{"trait_type": "Commit Hash", "value":"ce1a3fc141e29f8e1d00a654e156c4982d7711bf"},{"trait_type": "Repository", "value":"https://github.com/other/repo"},{"trait_type": "Version", "value":"1"},{"trait_type": "Color", "value":"#654321"}]}"
+            "data:application/json;base64,{"name":"New App Name","description":"New description for the app.","owner":"0x90193c961a926261b756d1e5bb255e67ff9498a1","external_url":"https://new-url.com","image":"data:image/svg+xml;base64,<svg width="1065" height="1065" viewBox="0 0 1065 1065" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><style type="text/css">@import url("https://fonts.googleapis.com/css2?family=Inter:wght@500;600");</style><rect width="1065" height="1065" fill="url(#background)" /><rect opacity="0.2" width="1065" height="1065" fill="url(#background-radial)" /><g filter="url(#diskette-shadow)"><path d="M857.231 279.712L902.24 286.675C910.547 287.96 917.915 292.721 922.5 299.768L938.894 324.964C942.249 330.12 943.311 336.437 941.827 342.406L937.798 358.615L924.049 356.65L919.416 374.084L934.068 376.24L791.947 922.152C788.109 936.896 773.694 946.308 758.651 943.893L179.636 850.928C162.318 848.147 151.215 830.987 155.776 814.051L160.478 796.59L704.315 879.574L857.231 279.712Z" fill="#050505" /></g><path d="M840.231 240.712L885.24 247.675C893.547 248.961 900.915 253.722 905.5 260.768L921.894 285.965C925.249 291.12 926.311 297.437 924.827 303.406L920.798 319.616L907.049 317.65L902.416 335.084L917.068 337.241L774.947 883.152C771.109 897.896 756.694 907.308 741.651 904.893L162.636 811.928C145.318 809.147 134.215 791.987 138.776 775.051L143.478 757.59L687.315 840.574L840.231 240.712Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="#131316" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" d="M319.847 161.502C310.356 160.007 300.674 166.326 298.221 175.616L138.724 779.758C136.271 789.048 141.977 797.79 151.468 799.285L740.061 891.973C749.553 893.467 759.235 887.148 761.687 877.858L902.405 344.854L889.158 342.768L898.872 305.972L912.119 308.059L913.733 301.946C914.837 297.762 914.309 293.476 912.251 289.927L893.484 257.569C891.153 253.549 887.063 250.823 882.221 250.061L828.205 241.554C822.224 240.613 815.869 242.783 811.427 247.284L805.686 253.103C804.205 254.603 802.087 255.326 800.093 255.013L783.611 252.417L734.3 439.196C731.439 450.035 720.143 457.407 709.07 455.663L328.847 395.788C317.774 394.045 311.117 383.845 313.978 373.007L366.528 173.962L366.533 173.941C367.234 171.24 365.572 168.702 362.81 168.267L319.847 161.502ZM369.392 174.414L368.652 177.217L316.843 373.458C314.39 382.748 320.096 391.49 329.587 392.985L709.81 452.86C719.301 454.354 728.983 448.035 731.436 438.745L780.747 251.966L783.245 242.504L783.985 239.701L369.392 174.414Z" fill="url(#diskette-gradient)" fill-opacity="0.2" /><path d="M335.38 208.113C335.922 208.198 336.417 207.686 336.283 207.179L330.39 184.795C330.249 184.261 329.529 184.148 329.129 184.597L312.358 203.411C311.978 203.838 312.174 204.458 312.716 204.544L317.962 205.37C318.357 205.432 318.595 205.796 318.493 206.183L314.7 220.551C314.597 220.938 314.835 221.302 315.231 221.364L324.539 222.83C324.935 222.893 325.338 222.629 325.44 222.242L329.233 207.875C329.336 207.488 329.739 207.224 330.135 207.286L335.38 208.113Z" fill="url(#main)" /><path d="M319.282 269.087C319.824 269.173 320.319 268.661 320.186 268.154L314.292 245.77C314.151 245.236 313.431 245.123 313.031 245.572L296.261 264.386C295.88 264.812 296.076 265.433 296.618 265.518L301.864 266.344C302.259 266.407 302.497 266.771 302.395 267.158L298.602 281.526C298.5 281.913 298.737 282.277 299.133 282.339L308.441 283.805C308.837 283.867 309.24 283.604 309.343 283.217L313.136 268.849C313.238 268.462 313.641 268.199 314.037 268.261L319.282 269.087Z" fill="black" fill-opacity="0.5" /><path d="M303.184 330.062C303.726 330.148 304.221 329.636 304.088 329.128L298.194 306.745C298.053 306.211 297.333 306.098 296.933 306.547L280.163 325.361C279.782 325.787 279.979 326.408 280.52 326.493L285.766 327.319C286.161 327.382 286.399 327.746 286.297 328.133L282.504 342.501C282.402 342.888 282.639 343.252 283.035 343.314L292.344 344.78C292.739 344.842 293.142 344.579 293.245 344.192L297.038 329.824C297.14 329.437 297.543 329.174 297.939 329.236L303.184 330.062Z" fill="black" fill-opacity="0.5" /><path stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M290.109 463.418C292.358 454.902 301.233 449.11 309.933 450.48L771.07 523.096C779.77 524.467 785 532.48 782.752 540.996L692.086 884.418L199.443 806.84L290.109 463.418Z" fill="black" fill-opacity="0.14" /><path fill-rule="evenodd" clip-rule="evenodd" stroke="url(#main)" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" d="M787.589 237.349L460.354 185.818L406.325 390.469C403.872 399.759 409.578 408.501 419.069 409.996L711.934 456.114C721.425 457.609 731.107 451.29 733.56 442L787.589 237.349ZM660.269 245.01C655.523 244.263 650.682 247.423 649.456 252.068L607.386 411.418C606.16 416.063 609.013 420.434 613.759 421.181L682.499 432.006C687.245 432.753 692.086 429.594 693.312 424.949L735.382 265.599C736.608 260.954 733.755 256.583 729.01 255.835L660.269 245.01Z" fill="url(#main)" /><path fill-rule="evenodd" clip-rule="evenodd" d="M864.643 283.937C865.186 283.605 865.708 284.257 865.239 284.683L844.268 303.719C843.938 304.018 844.093 304.517 844.526 304.548L853.726 305.207C854.184 305.24 854.321 305.787 853.942 306.071L833.884 321.112C833.506 321.396 833.643 321.943 834.101 321.976L844.007 322.685C844.491 322.72 844.605 323.319 844.177 323.58L797.752 351.954C797.209 352.286 796.687 351.634 797.156 351.209L818.403 331.922C818.733 331.622 818.577 331.123 818.145 331.092L808.748 330.42C808.292 330.387 808.154 329.843 808.529 329.558L828.054 314.744C828.43 314.459 828.291 313.915 827.835 313.882L818.389 313.206C817.904 313.171 817.79 312.572 818.218 312.311L864.643 283.937Z" fill="white" /><g transform="matrix(0.987827 0.155557 -0.255261 0.966872 250 735)"><text font-family="Inter, sans-serif" font-weight="bold" font-size="42" fill="#E5E7F8">New App Name</text><text font-family="Inter, sans-serif" font-weight="normal" y="40" font-size="22" fill="#7F8192">new-ens.eth</text></g><image width="167" height="167" transform="matrix(0.987827 0.155557 -0.255261 0.966872 444.117 524.17)" href="data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMTAwMCAxMDAwIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxMDAwIDEwMDAiIHhtbDpzcGFjZT0icHJlc2VydmUiPgo8Zz48cGF0aCBkPSJNNTAwLDEwQzIyOS40LDEwLDEwLDIyOS40LDEwLDUwMGMwLDI3MC42LDIxOS40LDQ5MCw0OTAsNDkwYzI3MC42LDAsNDkwLTIxOS40LDQ5MC00OTBDOTkwLDIyOS40LDc3MC42LDEwLDUwMCwxMHogTTgxNSw4MTVjLTQwLjksNDAuOS04OC42LDczLjEtMTQxLjYsOTUuNWMtNTQuOSwyMy4yLTExMy4yLDM1LTE3My40LDM1Yy02MC4yLDAtMTE4LjUtMTEuOC0xNzMuNC0zNUMyNzMuNiw4ODgsMjI1LjksODU1LjksMTg1LDgxNXMtNzMtODguNi05NS41LTE0MS42Yy0yMy4yLTU0LjktMzUtMTEzLjItMzUtMTczLjRjMC02MC4yLDExLjgtMTE4LjUsMzUtMTczLjRjMjIuNC01Myw1NC42LTEwMC43LDk1LjUtMTQxLjZzODguNi03MywxNDEuNi05NS41YzU0LjktMjMuMiwxMTMuMi0zNSwxNzMuNC0zNWM2MC4yLDAsMTE4LjUsMTEuOCwxNzMuNCwzNWM1MywyMi40LDEwMC43LDU0LjYsMTQxLjYsOTUuNWM0MC45LDQwLjksNzMsODguNiw5NS41LDE0MS42YzIzLjIsNTQuOSwzNSwxMTMuMiwzNSwxNzMuNGMwLDYwLjItMTEuOCwxMTguNS0zNSwxNzMuNEM4ODgsNzI2LjQsODU1LjksNzc0LjEsODE1LDgxNXoiLz48L2c+Cjwvc3ZnPg==" /><defs><filter id="diskette-shadow" x="70.7489" y="195.712" width="955.733" height="832.558" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" /><feBlend in="SourceGraphic" /><feGaussianBlur stdDeviation="42" /></filter><linearGradient id="background" x1="532.5" y1="0" x2="532.5" y2="1065" gradientUnits="userSpaceOnUse"><stop /><stop offset="1" stop-color="#131313" /></linearGradient><radialGradient id="background-radial" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(532.5 532.5) rotate(89.961) scale(735)"><stop stop-color="#654321" /><stop offset="1" stop-color="#654321" stop-opacity="0" /></radialGradient><linearGradient id="diskette-gradient" x1="925.626" y1="256.896" x2="136.779" y2="800.203" gradientUnits="userSpaceOnUse"><stop stop-color="#654321" /><stop offset="1" stop-color="#2C313F" /></linearGradient><linearGradient id="main"><stop stop-color="#654321" /></linearGradient></defs></svg>","access_point_auto_approval":false,"verified":true,"attributes": [{"trait_type": "ENS", "value":"new-ens.eth"},{"trait_type": "Commit Hash", "value":"ce1a3fc141e29f8e1d00a654e156c4982d7711bf"},{"trait_type": "Repository", "value":"https://github.com/other/repo"},{"trait_type": "Version", "value":"1"},{"trait_type": "Color", "value":"#654321"}]}"
         );
     }
 
@@ -88,6 +89,7 @@ contract Test_FleekERC721_TokenURI is Test_FleekERC721_Base, Test_FleekERC721_To
         expectMetadataUpdate(tokenId, "externalURL", "https://new-url.com", deployer);
         CuT.setTokenExternalURL(tokenId, "https://new-url.com");
 
+        transferENS("new-ens.eth", deployer);
         expectMetadataUpdate(tokenId, "ENS", "new-ens.eth", deployer);
         CuT.setTokenENS(tokenId, "new-ens.eth");
 
diff --git a/contracts/test/foundry/FleekERC721/Utils.sol b/contracts/test/foundry/FleekERC721/Utils.sol
new file mode 100644
index 0000000..2ae0176
--- /dev/null
+++ b/contracts/test/foundry/FleekERC721/Utils.sol
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import {FleekENS} from "contracts/util/FleekENS.sol";
+
+library Utils {
+    /**
+     * @dev This function is copyed from `FleekENS.sol`.
+     * It changes the `internal` modifier to `public` allowing it
+     * to be used in tests applying memory values
+     */
+    function namehash(string calldata name) public view returns (bytes32) {
+        return FleekENS.namehash(bytes(name), 0);
+    }
+}
diff --git a/contracts/test/hardhat/contracts/FleekERC721/ens.t.ts b/contracts/test/hardhat/contracts/FleekERC721/ens.t.ts
new file mode 100644
index 0000000..bc60c8a
--- /dev/null
+++ b/contracts/test/hardhat/contracts/FleekERC721/ens.t.ts
@@ -0,0 +1,56 @@
+import { expect } from 'chai';
+import { TestConstants, Fixtures, Errors, transferENSNode } from './helpers';
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
+const { MintParams } = TestConstants;
+
+describe('FleekERC721.ENS', () => {
+  let fixture: Awaited<ReturnType<typeof Fixtures.default>>;
+
+  beforeEach(async () => {
+    fixture = await loadFixture(Fixtures.default);
+  });
+
+  it('should not allow mint if not ENS owner', async () => {
+    const { contract, owner } = fixture;
+
+    await expect(
+      contract.mint(
+        owner.address,
+        MintParams.name,
+        MintParams.description,
+        MintParams.externalUrl,
+        'app.eth',
+        MintParams.commitHash,
+        MintParams.gitRepository,
+        MintParams.logo,
+        MintParams.color,
+        MintParams.accessPointAutoApprovalSettings,
+        owner.address
+      )
+    ).to.be.revertedWithCustomError(contract, Errors.MustBeENSOwner);
+  });
+
+  it('should not allow set ENS if not ENS owner', async () => {
+    const { contract, owner } = fixture;
+
+    await transferENSNode('app.eth', owner);
+
+    await contract.mint(
+      owner.address,
+      MintParams.name,
+      MintParams.description,
+      MintParams.externalUrl,
+      'app.eth',
+      MintParams.commitHash,
+      MintParams.gitRepository,
+      MintParams.logo,
+      MintParams.color,
+      MintParams.accessPointAutoApprovalSettings,
+      owner.address
+    );
+
+    await expect(
+      contract.setTokenENS(0, 'subdomain.app.eth')
+    ).to.be.revertedWithCustomError(contract, Errors.MustBeENSOwner);
+  });
+});
diff --git a/contracts/test/hardhat/contracts/FleekERC721/helpers/errors.ts b/contracts/test/hardhat/contracts/FleekERC721/helpers/errors.ts
index c7ef534..82b6b5d 100644
--- a/contracts/test/hardhat/contracts/FleekERC721/helpers/errors.ts
+++ b/contracts/test/hardhat/contracts/FleekERC721/helpers/errors.ts
@@ -15,4 +15,5 @@ export const Errors = Object.freeze({
   PausableIsSetTo: 'PausableIsSetTo',
   ThereIsNoTokenMinted: 'ThereIsNoTokenMinted',
   RequiredPayment: 'RequiredPayment',
+  MustBeENSOwner: 'MustBeENSOwner',
 });
diff --git a/contracts/test/hardhat/contracts/FleekERC721/helpers/fixture.ts b/contracts/test/hardhat/contracts/FleekERC721/helpers/fixture.ts
index f16d5e0..7e82e64 100644
--- a/contracts/test/hardhat/contracts/FleekERC721/helpers/fixture.ts
+++ b/contracts/test/hardhat/contracts/FleekERC721/helpers/fixture.ts
@@ -1,11 +1,14 @@
 import { ethers, upgrades } from 'hardhat';
 import { TestConstants } from './constants';
+import { transferENSNode } from './utils';
 
 export abstract class Fixtures {
   static async default() {
     // Contracts are deployed using the first signer/account by default
     const [owner, otherAccount] = await ethers.getSigners();
 
+    await transferENSNode(TestConstants.MintParams.ens, owner);
+
     const libraries = {
       FleekSVG: (await (await ethers.getContractFactory('FleekSVG')).deploy())
         .address,
diff --git a/contracts/test/hardhat/contracts/FleekERC721/helpers/utils.ts b/contracts/test/hardhat/contracts/FleekERC721/helpers/utils.ts
index c040691..ceed2e9 100644
--- a/contracts/test/hardhat/contracts/FleekERC721/helpers/utils.ts
+++ b/contracts/test/hardhat/contracts/FleekERC721/helpers/utils.ts
@@ -1,3 +1,10 @@
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import { ethers, upgrades } from 'hardhat';
+import { TestConstants } from './constants';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const namehash = require('@ensdomains/eth-ens-namehash');
+
 export const parseTokenURI = (tokenURI: string) => {
   const tokenURIDecoded = Buffer.from(
     tokenURI.replace('data:application/json;base64,', ''),
@@ -6,3 +13,25 @@ export const parseTokenURI = (tokenURI: string) => {
 
   return JSON.parse(tokenURIDecoded);
 };
+
+export const getENSNode = (name: string) => {
+  return namehash.hash(namehash.normalize(name));
+};
+
+export const transferENSNode = async (name: string, to: SignerWithAddress) => {
+  const ens = await ethers.getContractAt(
+    'ENS',
+    '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'
+  );
+
+  const ensNode = getENSNode(name);
+
+  const ensOwner = await ethers.getImpersonatedSigner(await ens.owner(ensNode));
+
+  await to.sendTransaction({
+    to: ensOwner.address,
+    value: ethers.utils.parseEther('1000'),
+  });
+
+  await ens.connect(ensOwner).setOwner(ensNode, to.address);
+};
diff --git a/contracts/test/hardhat/contracts/FleekERC721/update-properties.t.ts b/contracts/test/hardhat/contracts/FleekERC721/update-properties.t.ts
index 3e21895..57db432 100644
--- a/contracts/test/hardhat/contracts/FleekERC721/update-properties.t.ts
+++ b/contracts/test/hardhat/contracts/FleekERC721/update-properties.t.ts
@@ -1,6 +1,6 @@
 import { loadFixture } from '@nomicfoundation/hardhat-network-helpers';
 import { expect } from 'chai';
-import { TestConstants, Fixtures, Events } from './helpers';
+import { TestConstants, Fixtures, Events, transferENSNode } from './helpers';
 
 const {
   Logos: { 1: Logo1 },
@@ -25,9 +25,11 @@ describe('FleekERC721.UpdateProperties', () => {
   it('should emit event for ens change', async () => {
     const { contract, tokenId, owner } = fixture;
 
-    await expect(contract.setTokenENS(tokenId, 'app.eth'))
+    await transferENSNode('subdomain.app.eth', owner);
+
+    await expect(contract.setTokenENS(tokenId, 'subdomain.app.eth'))
       .to.emit(contract, Events.MetadataUpdate.string)
-      .withArgs(tokenId, 'ENS', 'app.eth', owner.address);
+      .withArgs(tokenId, 'ENS', 'subdomain.app.eth', owner.address);
   });
 
   it('should emit event for name change', async () => {
diff --git a/contracts/yarn.lock b/contracts/yarn.lock
index f8b90dc..f201b03 100644
--- a/contracts/yarn.lock
+++ b/contracts/yarn.lock
@@ -14,6 +14,33 @@
   dependencies:
     "@jridgewell/trace-mapping" "0.3.9"
 
+"@ensdomains/buffer@^0.1.1":
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/@ensdomains/buffer/-/buffer-0.1.1.tgz#6c275ba7e457e935405b67876f1f0d980c8baa63"
+  integrity sha512-92SfSiNS8XorgU7OUBHo/i1ZU7JV7iz/6bKuLPNVsMxV79/eI7fJR6jfJJc40zAHjs3ha+Xo965Idomlq3rqnw==
+
+"@ensdomains/ens-contracts@^0.0.20":
+  version "0.0.20"
+  resolved "https://registry.yarnpkg.com/@ensdomains/ens-contracts/-/ens-contracts-0.0.20.tgz#346eac70d666a7864142287ce1759b0f44bd8a5e"
+  integrity sha512-lAHQBVj2WtgbchcrE8ZuFI6DFq+O33wkLAGqsO2gcnn0EUJb65OJIdTqUfvfULKGJjkB2pyHfS/RgMSIW6h1Pw==
+  dependencies:
+    "@ensdomains/buffer" "^0.1.1"
+    "@ensdomains/solsha1" "0.0.3"
+    "@openzeppelin/contracts" "^4.1.0"
+    dns-packet "^5.3.0"
+
+"@ensdomains/eth-ens-namehash@^2.0.15":
+  version "2.0.15"
+  resolved "https://registry.yarnpkg.com/@ensdomains/eth-ens-namehash/-/eth-ens-namehash-2.0.15.tgz#5e5f2f24ba802aff8bc19edd822c9a11200cdf4a"
+  integrity sha512-JRDFP6+Hczb1E0/HhIg0PONgBYasfGfDheujmfxaZaAv/NAH4jE6Kf48WbqfRZdxt4IZI3jl3Ri7sZ1nP09lgw==
+
+"@ensdomains/solsha1@0.0.3":
+  version "0.0.3"
+  resolved "https://registry.yarnpkg.com/@ensdomains/solsha1/-/solsha1-0.0.3.tgz#fd479da9d40aadb59ff4fb4ec50632e7d2275a83"
+  integrity sha512-uhuG5LzRt/UJC0Ux83cE2rCKwSleRePoYdQVcqPN1wyf3/ekMzT/KZUF9+v7/AG5w9jlMLCQkUM50vfjr0Yu9Q==
+  dependencies:
+    hash-test-vectors "^1.3.2"
+
 "@ethereumjs/common@2.5.0":
   version "2.5.0"
   resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.5.0.tgz#ec61551b31bef7a69d1dc634d8932468866a4268"
@@ -398,6 +425,11 @@
     "@jridgewell/resolve-uri" "^3.0.3"
     "@jridgewell/sourcemap-codec" "^1.4.10"
 
+"@leichtgewicht/ip-codec@^2.0.1":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz#b2ac626d6cb9c8718ab459166d4bb405b8ffa78b"
+  integrity sha512-Hcv+nVC0kZnQ3tD9GVu5xSMR4VVYOteQIr/hwFPVEvPdlXqgGEuRjiheChHgdM+JyqdgNcmzZOX/tnl0JOiI7A==
+
 "@metamask/eth-sig-util@^4.0.0":
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz#3ad61f6ea9ad73ba5b19db780d40d9aae5157088"
@@ -700,6 +732,11 @@
   resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.8.1.tgz#363f7dd08f25f8f77e16d374350c3d6b43340a7a"
   integrity sha512-1wTv+20lNiC0R07jyIAbHU7TNHKRwGiTGRfiNnA8jOWjKT98g5OgLpYWOi40Vgpk8SPLA9EvfJAbAeIyVn+7Bw==
 
+"@openzeppelin/contracts@^4.1.0":
+  version "4.8.2"
+  resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.8.2.tgz#d815ade0027b50beb9bcca67143c6bcc3e3923d6"
+  integrity sha512-kEUOgPQszC0fSYWpbh2kT94ltOJwj1qfT2DWo+zVttmGmf97JZ99LspePNaeeaLhCImaHVeBbjaQFZQn7+Zc5g==
+
 "@openzeppelin/contracts@^4.7.3":
   version "4.8.1"
   resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.8.1.tgz#709cfc4bbb3ca9f4460d60101f15dac6b7a2d5e4"
@@ -2155,6 +2192,13 @@ dir-glob@^3.0.1:
   dependencies:
     path-type "^4.0.0"
 
+dns-packet@^5.3.0:
+  version "5.4.0"
+  resolved "https://registry.yarnpkg.com/dns-packet/-/dns-packet-5.4.0.tgz#1f88477cf9f27e78a213fb6d118ae38e759a879b"
+  integrity sha512-EgqGeaBB8hLiHLZtp/IbaDQTL8pZ0+IvwzSHA6d7VyMDM+B9hgddEMa9xjK5oYnw0ci0JQ6g2XCD7/f6cafU6g==
+  dependencies:
+    "@leichtgewicht/ip-codec" "^2.0.1"
+
 dom-walk@^0.1.0:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/dom-walk/-/dom-walk-0.1.2.tgz#0c548bef048f4d1f2a97249002236060daa3fd84"
@@ -3302,6 +3346,11 @@ hash-base@^3.0.0:
     readable-stream "^3.6.0"
     safe-buffer "^5.2.0"
 
+hash-test-vectors@^1.3.2:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/hash-test-vectors/-/hash-test-vectors-1.3.2.tgz#f050fde1aff46ec28dcf4f70e4e3238cd5000f4c"
+  integrity sha512-PKd/fitmsrlWGh3OpKbgNLE04ZQZsvs1ZkuLoQpeIKuwx+6CYVNdW6LaPIS1QAdZvV40+skk0w4YomKnViUnvQ==
+
 hash.js@1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.3.tgz#340dedbe6290187151c1ea1d777a3448935df846"