> For the complete documentation index, see [llms.txt](https://docs.dothype.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.dothype.io/architecture/how-it-all-works/dothype-smart-contracts/registry-contract.md). # Registry Contract Every `.hype` name is an NFT—minted and stored using this registry. It’s compliant with ERC-721, but also includes extensions to manage lifecycle events like renewal, expiration, and status tracking in a way that fits naming infrastructure. This page explains how the registry works and what matters for developers or curious users. ### 📘 What It Does The Registry contract is responsible for: * Minting `.hype` names as NFTs * Assigning expiration timestamps * Enforcing availability logic (e.g. what counts as expired) * Preventing transfers of expired names * Handling metadata for display All minting and renewing must come through the **Controller contract**, which acts as a gatekeeper. That ensures pricing and access logic can be upgraded independently. > You can think of the Registry as the final source of truth for who owns what and for how long. ### ⏳ Expiration & Renewal Rules Each name is registered for a fixed period, starting from the time of mint. Once that period ends, the name enters a **30-day grace period**. During this window: * The owner can still renew the name * But it can’t be transferred or sold After the grace period ends: * The name becomes available to others * It can be re-registered by anyone To ensure meaningful durations, **all registrations must last at least 28 days**. ### 🔐 Availability Logic A name is considered **available** if: * It has never been registered * OR its expiration + grace period has passed This logic ensures names can’t be accidentally or maliciously re-claimed too early. Builders can use the `available()` function to check status. ```solidity function available(string calldata name) external view returns (bool); ``` ### 🔁 Minting & Renewal Process (Simplified) Names are minted and renewed through the Controller. The Registry handles the actual recording. When a name is registered: 1. A token ID is created using the **namehash** algorithm 2. An expiration time is assigned 3. An NFT is minted to the user When renewed: * The expiration is extended based on the original expiry (not the current time) * If the name is expired but within the grace period, it can still be renewed ```solidity function register(string calldata name, address owner, uint256 duration) external onlyController returns (uint256 expiresAt); function renew(string calldata name, uint256 duration) external onlyController returns (uint256 expiresAt); ``` ### 🧠 Token ID Generation Each `.hype` name is converted into a token ID using a standard **namehash** algorithm—similar to ENS. This ensures uniqueness and predictability. ```solidity function nameToTokenId(string calldata name) public pure returns (uint256); ``` The algorithm: * Hashes the domain label using keccak256 * Combines it with a root `.hype` identifier * Outputs a 256-bit integer as the token ID This process ensures all names are deterministically derived and collision-resistant. ### 🖼 Metadata & Status Queries Each name has a metadata URI, which can be customized using an external metadata provider. This lets you: * Display profile cards, avatars, or status in apps * Serve dynamic visuals for first 1K mints or milestone names The Registry also exposes read-only status functions: ```solidity function expiresAt(uint256 tokenId) external view returns (uint256); function expiry(string calldata name) external view returns (uint256); function isExpired(uint256 tokenId) external view returns (bool); ``` ### 🚫 Transfer Restrictions Expired names (outside the grace period) **cannot be transferred**. This is enforced at the contract level no UI trickery. The Registry overrides the `_update()` function to block transfers of expired tokens unless they are first renewed. This protects users and prevents accidental loss of names post-expiration. ### 🛠 Admin Controls Some functions are reserved for the protocol owner or multisig governance: ```solidity function setController(address _controller) external onlyOwner; function setMetadataProvider(address _metadataProvider) external onlyOwner; ``` These allow future upgrades or metadata format changes **without touching the core Registry logic**. ### 🔎 For Developers If you’re building an integration and want to: * Check if a name is expired * Query expiration time * Display metadata or avatars ...the Registry is your go-to source. It’s not where minting logic lives—that happens in the Controller. But it’s where final ownership, expiration, and display logic is confirmed. > See the [Controller Contract →](/architecture/how-it-all-works/dothype-smart-contracts/controller-contract.md) to understand how minting works upstream. Still have questions? Reach out in our [dev community →](/official-links.md) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.dothype.io/architecture/how-it-all-works/dothype-smart-contracts/registry-contract.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.