> ## Documentation Index
> Fetch the complete documentation index at: https://elysium-names.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Developer Documentation Overview

Elysium Names is an onchain naming protocol built to provide human-readable `.ely` names that can be registered, owned, transferred and resolved to wallet addresses.

Each registered name is represented by an ERC-721 NFT. The protocol provides smart contract interfaces for registration, renewal, ownership management, name resolution, partner programmes, referrals and marketplace royalties.

This section explains how developers, wallets, applications and other ecosystem projects can interact with the protocol.

## 1. What Developers Can Build

Developers can integrate `.ely` names into applications and services across the Elysium ecosystem.

Examples include:

* **Wallet integrations:** Allow users to send assets to a human-readable `.ely` name instead of entering a full wallet address.
* **Name resolution:** Resolve a registered name to its associated wallet address.
* **Identity and profiles:** Display a user's `.ely` name as their onchain identity.
* **NFT integrations:** Read ownership information, display name NFTs and support compatible transfers.
* **Marketplace integrations:** Support trading of `.ely` NFTs and retrieve royalty information through ERC-2981.
* **Partner integrations:** Verify eligibility for configured partner programmes and benefits.
* **DeFi integrations:** Use `.ely` names as readable identifiers within supported applications and interfaces.

The exact functionality available to an integration depends on the contract interfaces it uses and the features supported by the application.

## 2. Protocol Architecture

Elysium Names is organised around three primary smart contracts.

### ElyNamesMainnet

The core ERC-721 name contract.

It manages:

* NFT ownership and transfers.
* Name expiry information.
* Address records.
* Text records.
* Primary-name settings.
* Manager permissions.
* Name resolution.
* ERC-2981 royalty information.

Each registered name has a corresponding NFT, and ownership of that NFT determines who owns the name.

### ElyControllerMain

The registration and protocol-management contract.

It handles:

* Name registration.
* Commit-reveal registration protection.
* Registration pricing.
* Renewals.
* Expiry and grace-period rules.
* Expired-name premiums.
* Referral accounting.
* Registration discounts.
* Partner programme configuration and eligibility.
* Reserved-name registration.
* Payment routing.

The controller interacts with the core name contract to complete registration and manage the protocol's registration-related operations.

### ElyAuction

The auction contract handles the distribution of reserved single-character names.

It manages:

* Auction scheduling.
* Bidding.
* Minimum bid increases.
* Outbid refunds.
* Auction settlement.
* Winning-bid registration.
* Auction proceeds.

The auction contract interacts with the name protocol to register successfully auctioned names.

## 3. How the Contracts Work Together

The contracts divide responsibilities while working together as one naming system.

For example, when a user registers a name:

1. The user prepares a registration commitment.
2. The controller validates the commitment and registration conditions.
3. The controller processes the registration payment.
4. The core name contract creates the corresponding NFT and assigns ownership to the intended receiving wallet.
5. The registered name becomes available through the protocol's resolution and record interfaces.

For a single-character name, the auction contract handles the bidding process and coordinates registration for the winning bidder.

This separation keeps the core NFT and identity functionality distinct from registration, payment and auction operations.

## 4. Name Resolution

Applications can resolve a `.ely` name to its associated wallet address using the core contract.

The `resolve(string label)` function accepts the name label without the `.ely` suffix.

For example, an application resolving `yourname.ely` passes `yourname` to the function.

The contract returns the associated wallet address when the name is valid and active. If the name is not registered or is no longer active, resolution returns the zero address.

The protocol also provides a reverse lookup through `primaryNameOf(address account)`, which returns the account's primary `.ely` name when one is set.

See **Name Resolution** for the relevant functions and integration considerations.

## 5. Ownership and Records

Because each name is an ERC-721 NFT, developers can use standard ERC-721 interfaces to inspect ownership and support compatible NFT operations.

The protocol also provides name-specific functionality for:

* Reading and updating address records.
* Reading and updating text records.
* Checking the assigned manager.
* Checking expiry information.
* Reading the primary name associated with a wallet.

A name's NFT owner, its resolved address and its appointed manager are distinct concepts. Integrations should use the appropriate interface rather than assume they are always the same.

## 6. Network and Development Environment

Elysium Names is designed for the EVM-compatible Elysium network.

The protocol uses HYPE for registration payments and other applicable protocol transactions, in addition to the network's required gas fees.

The Elysium testnet configuration previously used during development includes:

| Network setting | Value |
| :- | :- |
| Network | Elysium Testnet |
| Chain ID | `99801` |
| RPC endpoint | `https://testnet-rpc.elysium.kinetiq.xyz` |
| Payment token | HYPE |

These are testnet details, not mainnet configuration.

For mainnet integrations, developers should use the official network parameters and deployed contract addresses published for the public deployment. Do not reuse testnet addresses or configuration when connecting to mainnet.

## 7. Developer Resources

The following resources provide additional information and access to the protocol's implementation.

* **Website:** [https://elysiumnameservice.xyz/](https://elysiumnameservice.xyz/)
* **Developer reference:** [https://elysiumnameservice.xyz/developers.html](https://elysiumnameservice.xyz/developers.html)
* **GitHub repository:** [https://github.com/bonaventure001/ely-names](https://github.com/bonaventure001/ely-names)
* **X:** [https://x.com/elysiumNames](https://x.com/elysiumNames)

The source repository contains the protocol's smart contract implementation, scripts and tests.

Developers should inspect the relevant contract interfaces and verify the deployed contract addresses before building production integrations.

## 8. Where to Go Next

This documentation is organised to help developers understand the protocol before integrating it.

* **Name Resolution:** Learn how to resolve `.ely` names and retrieve associated records.
* **Smart Contract Architecture:** Explore the responsibilities and relationships of the protocol contracts.
* **Integration Guide:** Learn how applications can interact with the protocol.
* **Contract Administration:** Understand ownership, permissions and administrative configuration.
* **Security & Testing:** Review the protocol's testing approach and security considerations.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.