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.

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

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.

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:

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:

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 → to understand how minting works upstream.

Still have questions? Reach out in our dev community →