diff --git a/.openzeppelin/unknown-114.json b/.openzeppelin/unknown-114.json
index 4335abe..29bebfe 100644
--- a/.openzeppelin/unknown-114.json
+++ b/.openzeppelin/unknown-114.json
@@ -2311,6 +2311,354 @@
           }
         }
       }
+    },
+    "25db4ace7b50465f126d2aafbba71796ffaef09abbc1a3b08e862071c307a2e0": {
+      "address": "0x1626A17a9841b61a4E1ACBa0dab34CEF5551DaCf",
+      "txHash": "0xa1a3d6969cd40a3e8cf97255099ba744f69901f45580aba2049d9a2b21834c3e",
+      "layout": {
+        "solcVersion": "0.8.17",
+        "storage": [
+          {
+            "label": "_initialized",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_uint8",
+            "contract": "Initializable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:63",
+            "retypedFrom": "bool"
+          },
+          {
+            "label": "_initializing",
+            "offset": 1,
+            "slot": "0",
+            "type": "t_bool",
+            "contract": "Initializable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol:68"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "ContextUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol:36"
+          },
+          {
+            "label": "_synchronizer",
+            "offset": 0,
+            "slot": "51",
+            "type": "t_contract(ISynchronizer)4439",
+            "contract": "SynchronizerApplication",
+            "src": "contracts/crosschain/SynchronizerApplication.sol:9"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "52",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "ERC165Upgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol:41"
+          },
+          {
+            "label": "_roles",
+            "offset": 0,
+            "slot": "102",
+            "type": "t_mapping(t_bytes32,t_struct(RoleData)34_storage)",
+            "contract": "AccessControlUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol:62"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "103",
+            "type": "t_array(t_uint256)49_storage",
+            "contract": "AccessControlUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol:260"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "152",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "ERC1967UpgradeUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol:169"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "202",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "UUPSUpgradeable",
+            "src": "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol:111"
+          },
+          {
+            "label": "_registry",
+            "offset": 0,
+            "slot": "252",
+            "type": "t_contract(IRegistry)6770",
+            "contract": "BaseResolver",
+            "src": "contracts/resolver/BaseResolver.sol:19"
+          },
+          {
+            "label": "_mortgage",
+            "offset": 0,
+            "slot": "253",
+            "type": "t_contract(IMortgage)5949",
+            "contract": "BaseResolver",
+            "src": "contracts/resolver/BaseResolver.sol:21"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "254",
+            "type": "t_array(t_uint256)49_storage",
+            "contract": "BaseResolver",
+            "src": "contracts/resolver/BaseResolver.sol:161"
+          },
+          {
+            "label": "_addresses",
+            "offset": 0,
+            "slot": "303",
+            "type": "t_mapping(t_address,t_mapping(t_bytes32,t_address))",
+            "contract": "AddressResolver",
+            "src": "contracts/resolver/profile/AddressResolver.sol:8"
+          },
+          {
+            "label": "_reverseAddresses",
+            "offset": 0,
+            "slot": "304",
+            "type": "t_mapping(t_address,t_bytes_storage)",
+            "contract": "AddressResolver",
+            "src": "contracts/resolver/profile/AddressResolver.sol:9"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "305",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "AddressResolver",
+            "src": "contracts/resolver/profile/AddressResolver.sol:84"
+          },
+          {
+            "label": "_multiCoinAddresses",
+            "offset": 0,
+            "slot": "355",
+            "type": "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_uint256,t_bytes_storage)))",
+            "contract": "MultiCoinAddressResolver",
+            "src": "contracts/resolver/profile/MultiCoinAddressResolver.sol:8"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "356",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "MultiCoinAddressResolver",
+            "src": "contracts/resolver/profile/MultiCoinAddressResolver.sol:54"
+          },
+          {
+            "label": "_nfts",
+            "offset": 0,
+            "slot": "406",
+            "type": "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_uint256,t_struct(NFT)9410_storage)))",
+            "contract": "NFTResolver",
+            "src": "contracts/resolver/profile/NFTResolver.sol:8"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "407",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "NFTResolver",
+            "src": "contracts/resolver/profile/NFTResolver.sol:50"
+          },
+          {
+            "label": "_texts",
+            "offset": 0,
+            "slot": "457",
+            "type": "t_mapping(t_address,t_mapping(t_bytes32,t_string_storage))",
+            "contract": "TextResolver",
+            "src": "contracts/resolver/profile/TextResolver.sol:8"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "458",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "TextResolver",
+            "src": "contracts/resolver/profile/TextResolver.sol:43"
+          },
+          {
+            "label": "_typedTexts",
+            "offset": 0,
+            "slot": "508",
+            "type": "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_bytes32,t_string_storage)))",
+            "contract": "TypedTextResolver",
+            "src": "contracts/resolver/profile/TypedTextResolver.sol:8"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "509",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "TypedTextResolver",
+            "src": "contracts/resolver/profile/TypedTextResolver.sol:43"
+          },
+          {
+            "label": "__gap",
+            "offset": 0,
+            "slot": "559",
+            "type": "t_array(t_uint256)50_storage",
+            "contract": "PublicResolver",
+            "src": "contracts/resolver/PublicResolver.sol:32"
+          }
+        ],
+        "types": {
+          "t_address": {
+            "label": "address",
+            "numberOfBytes": "20"
+          },
+          "t_array(t_uint256)49_storage": {
+            "label": "uint256[49]",
+            "numberOfBytes": "1568"
+          },
+          "t_array(t_uint256)50_storage": {
+            "label": "uint256[50]",
+            "numberOfBytes": "1600"
+          },
+          "t_bool": {
+            "label": "bool",
+            "numberOfBytes": "1"
+          },
+          "t_bytes32": {
+            "label": "bytes32",
+            "numberOfBytes": "32"
+          },
+          "t_bytes_storage": {
+            "label": "bytes",
+            "numberOfBytes": "32"
+          },
+          "t_contract(IMortgage)5949": {
+            "label": "contract IMortgage",
+            "numberOfBytes": "20"
+          },
+          "t_contract(IRegistry)6770": {
+            "label": "contract IRegistry",
+            "numberOfBytes": "20"
+          },
+          "t_contract(ISynchronizer)4439": {
+            "label": "contract ISynchronizer",
+            "numberOfBytes": "20"
+          },
+          "t_mapping(t_address,t_bool)": {
+            "label": "mapping(address => bool)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_bytes_storage)": {
+            "label": "mapping(address => bytes)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_mapping(t_bytes32,t_address))": {
+            "label": "mapping(address => mapping(bytes32 => address))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_bytes32,t_string_storage)))": {
+            "label": "mapping(address => mapping(bytes32 => mapping(bytes32 => string)))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_uint256,t_bytes_storage)))": {
+            "label": "mapping(address => mapping(bytes32 => mapping(uint256 => bytes)))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_mapping(t_bytes32,t_mapping(t_uint256,t_struct(NFT)9410_storage)))": {
+            "label": "mapping(address => mapping(bytes32 => mapping(uint256 => struct INFTResolver.NFT)))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_address,t_mapping(t_bytes32,t_string_storage))": {
+            "label": "mapping(address => mapping(bytes32 => string))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_address)": {
+            "label": "mapping(bytes32 => address)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_mapping(t_bytes32,t_string_storage))": {
+            "label": "mapping(bytes32 => mapping(bytes32 => string))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_mapping(t_uint256,t_bytes_storage))": {
+            "label": "mapping(bytes32 => mapping(uint256 => bytes))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_mapping(t_uint256,t_struct(NFT)9410_storage))": {
+            "label": "mapping(bytes32 => mapping(uint256 => struct INFTResolver.NFT))",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_string_storage)": {
+            "label": "mapping(bytes32 => string)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_bytes32,t_struct(RoleData)34_storage)": {
+            "label": "mapping(bytes32 => struct AccessControlUpgradeable.RoleData)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_uint256,t_bytes_storage)": {
+            "label": "mapping(uint256 => bytes)",
+            "numberOfBytes": "32"
+          },
+          "t_mapping(t_uint256,t_struct(NFT)9410_storage)": {
+            "label": "mapping(uint256 => struct INFTResolver.NFT)",
+            "numberOfBytes": "32"
+          },
+          "t_string_storage": {
+            "label": "string",
+            "numberOfBytes": "32"
+          },
+          "t_struct(NFT)9410_storage": {
+            "label": "struct INFTResolver.NFT",
+            "members": [
+              {
+                "label": "contract_",
+                "type": "t_address",
+                "offset": 0,
+                "slot": "0"
+              },
+              {
+                "label": "tokenId",
+                "type": "t_uint256",
+                "offset": 0,
+                "slot": "1"
+              }
+            ],
+            "numberOfBytes": "64"
+          },
+          "t_struct(RoleData)34_storage": {
+            "label": "struct AccessControlUpgradeable.RoleData",
+            "members": [
+              {
+                "label": "members",
+                "type": "t_mapping(t_address,t_bool)",
+                "offset": 0,
+                "slot": "0"
+              },
+              {
+                "label": "adminRole",
+                "type": "t_bytes32",
+                "offset": 0,
+                "slot": "1"
+              }
+            ],
+            "numberOfBytes": "64"
+          },
+          "t_uint256": {
+            "label": "uint256",
+            "numberOfBytes": "32"
+          },
+          "t_uint8": {
+            "label": "uint8",
+            "numberOfBytes": "1"
+          }
+        }
+      }
     }
   }
 }
diff --git a/contracts/resolver/BaseResolver.sol b/contracts/resolver/BaseResolver.sol
index 2d3ff56..39d5124 100644
--- a/contracts/resolver/BaseResolver.sol
+++ b/contracts/resolver/BaseResolver.sol
@@ -62,8 +62,6 @@ abstract contract BaseResolver is IBaseResolver, Helper, SynchronizerApplication
     bytes32 name_ = keccak256(name);
     bytes32 tld_ = keccak256(tld);
 
-    require(_mortgage.isFulfill(name_, tld_), "DOMAIN_MORTGAGE_NOT_FULFILLED");
-
     bool isSelfAuthorized = _msgSender() == address(this);
     if (isSelfAuthorized) {
       return true;
diff --git a/network.config.ts b/network.config.ts
index bc35558..a6ec665 100644
--- a/network.config.ts
+++ b/network.config.ts
@@ -146,7 +146,6 @@ export const Testnets = [
   Network.CORE_DAO_TESTNET,
   Network.FLARE_COTON_2,
   Network.FLARE_SONGBIRD,
-  Network._HARDHAT_,
 ];
 
 export interface INetworkConfig {
diff --git a/scripts/F_Check_Contracts_Status.ts b/scripts/F_All_Network_Check_Contracts_Status.ts
similarity index 100%
rename from scripts/F_Check_Contracts_Status.ts
rename to scripts/F_All_Network_Check_Contracts_Status.ts
diff --git a/scripts/G_Check_Contracts_Status.ts b/scripts/G_Check_Contracts_Status.ts
new file mode 100644
index 0000000..b9d2394
--- /dev/null
+++ b/scripts/G_Check_Contracts_Status.ts
@@ -0,0 +1,98 @@
+import { Wallet } from "ethers";
+import hre, { ethers } from "hardhat";
+import _ from "lodash";
+import NetworkConfig, { Network, Mainnets, Testnets } from "../network.config";
+import { getRegistrar, getContractsData } from "./src/lib/get-contracts";
+import { getClassicalTlds, getUniversalTlds } from "./src/lib/get-tlds";
+import { v4 as uuidv4 } from "uuid";
+import { IRegistry__factory } from "../typechain/factories/IRegistry__factory";
+import { Registrar__factory, Wrapper__factory } from "../typechain";
+
+async function getStatus(signer: Wallet, network: Network) {
+  const data = await getContractsData(network);
+  if (data?.addresses.Registrar && data?.addresses["Registry.Diamond"] && data.addresses["DefaultWrapper"]) {
+    const registrar = Registrar__factory.connect(data.addresses.Registrar, signer);
+    const registry = IRegistry__factory.connect(data.addresses["Registry.Diamond"], signer);
+    const wrapper = Wrapper__factory.connect(data.addresses["DefaultWrapper"], signer);
+
+    const exec = async (type: string, tld: string) => {
+      try {
+        const [isTldExist, isTldEnabled, isTldAvailable, isDomainAvailable, nftName, nftSymbol, nftUri] = await Promise.all([
+          registry["isExists(bytes32)"](ethers.utils.keccak256(ethers.utils.toUtf8Bytes(tld))),
+          registry.isEnable(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(tld))),
+          registrar["isAvailable(bytes)"](ethers.utils.toUtf8Bytes(tld)),
+          registrar["isAvailable(bytes,bytes)"](ethers.utils.toUtf8Bytes(uuidv4()), ethers.utils.toUtf8Bytes(tld)),
+          wrapper["name"](),
+          wrapper["symbol"](),
+          wrapper["tokenURI"](0),
+        ]);
+        let _getName = "❌";
+        try {
+          await registry["getName(bytes32)"](ethers.utils.keccak256(ethers.utils.toUtf8Bytes(tld)));
+          _getName = "✅";
+        } catch {
+          _getName = "⚠️";
+        }
+        const exist = isTldExist ? "✅" : "❌";
+        const enable = isTldEnabled ? "✅" : "❌";
+        const available = isTldAvailable ? "✅" : "❌";
+        const query = isDomainAvailable ? "✅" : "❌";
+        return {
+          chain: NetworkConfig[network].name,
+          type,
+          exist,
+          enable,
+          available,
+          query,
+          getName: _getName,
+          tld,
+          nftName,
+          nftSymbol,
+          nftUri,
+        };
+      } catch (err) {
+        console.error(err);
+        const x = await signer.provider.getCode(data.addresses["Registry.Diamond"]!);
+        return {
+          chain: NetworkConfig[network].name,
+          type,
+          exist: "⚠️",
+          query: "⚠️",
+          available: "⚠️",
+          getName: "⚠️",
+          tld,
+        };
+      }
+    };
+
+    if (data?.addresses.UniversalRegistrarController) {
+      const classical = await getClassicalTlds(network);
+      const universal = await getUniversalTlds(network);
+      if (classical?.length && universal?.length && registrar) {
+        classical.push("___c_fake___");
+        universal.push("___u_fake___");
+        const q = await Promise.all([...classical.map(async (tld) => await exec("Classical", tld)), ...universal.map(async (tld) => await exec("Universal", tld))]);
+        return q;
+      }
+    } else {
+      const classical = await getClassicalTlds(network);
+      if (classical?.length && registrar) {
+        classical.push("___c_fake___");
+        const q = await Promise.all([...classical.map(async (tld) => await exec("Classical", tld))]);
+        return q;
+      }
+    }
+  } else {
+    console.log("lol");
+  }
+
+  return [];
+}
+
+async function main() {
+  const _signer = new ethers.Wallet(process.env.PRIVATE_KEY!);
+  if (!hre.network.config.chainId) throw new Error("???");
+  console.log(await getStatus(_signer, hre.network.config.chainId));
+}
+
+main();
diff --git a/scripts/test/register-classical-domain.ts b/scripts/test/register-classical-domain.ts
index 9407a0a..93c52e3 100644
--- a/scripts/test/register-classical-domain.ts
+++ b/scripts/test/register-classical-domain.ts
@@ -6,8 +6,9 @@ import * as dotenv from "dotenv";
 import { Network } from "../../network.config";
 dotenv.config();
 
-const NAME = `test-${luxon.DateTime.now().toSeconds().toFixed(0)}`;
-const TLD = "iotex";
+// const NAME = `test-${luxon.DateTime.now().toSeconds().toFixed(0)}`;
+const NAME = "test-12345";
+const TLD = "_coton2";
 const EXPIRY = luxon.DateTime.now().plus({ day: 1 }).toSeconds().toFixed(0);
 
 console.log({ NAME, TLD });
@@ -15,7 +16,7 @@ console.log({ NAME, TLD });
 async function main() {
   if (!process.env.PRIVATE_KEY) throw new Error("Private key is missing");
 
-  const provider = getProvider(Network.IOTEX_TESTNET);
+  const provider = getProvider(Network.FLARE_COTON_2);
   const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
   const contracts = await getContracts(signer);
 
@@ -34,6 +35,15 @@ async function main() {
   );
   await tx1.wait();
   console.log("tx1+", tx1.hash);
+
+  const value1 = await contracts.PublicResolver!.getText(ethers.utils.toUtf8Bytes("@"), ethers.utils.toUtf8Bytes(NAME), ethers.utils.toUtf8Bytes(TLD));
+  console.log({ value1 });
+
+  const tx2 = await contracts.PublicResolver!.setText(ethers.utils.toUtf8Bytes("@"), ethers.utils.toUtf8Bytes(NAME), ethers.utils.toUtf8Bytes(TLD), "hi");
+  console.log("tx2+", tx2.hash);
+
+  const value2 = await contracts.PublicResolver!.getText(ethers.utils.toUtf8Bytes("@"), ethers.utils.toUtf8Bytes(NAME), ethers.utils.toUtf8Bytes(TLD));
+  console.log({ value2 });
 }
 
 main();