Implementing a Celo-Based Decentralized Domain Name System


In today’s digital world, domain names play a crucial role in identifying and accessing websites. Traditionally, domain name management has been centralized, relying on trusted third-party registrars and DNS providers. However, with the advent of blockchain technology, it is now possible to create decentralized domain name systems that provide greater security, ownership, and censorship resistance.

In this tutorial, we will explore how to implement a decentralized domain name system on the Celo Blockchain. We will cover the creation of smart contracts for domain registration, transfer, and dispute resolution. By the end of this tutorial, developers will possess the knowledge and skills necessary to build a robust system for efficient domain name management.

Here is the source code to our project


To follow along with this tutorial, you should have the following prerequisites in place:

  • Basic understanding of blockchain concepts and smart contracts
  • Familiarity with Solidity programming language
  • Knowledge of the Celo Blockchain ecosystem
  • Development environment with Celo-compatible tools and libraries (e.g., Truffle, Remix, Celo SDK)
  • Web development skills (HTML, CSS, JavaScript) for creating a simple front-end (optional but recommended)

If you are new to any of these topics, it is recommended to explore the basics before diving into this tutorial. Additionally, ensure that you have the necessary software and dependencies installed to facilitate a smooth development experience.


The following will be required in Implementing a Celo-Based Decentralized Domain Name System

  • Visual Studio Code: It is a well-liked option for creating smart contracts on the Celo Blockchain because it has a wide range of Solidity and blockchain development extensions accessible.

  • Install Node.js: Celo development relies on Node.js, so make sure you have it installed. You can download the latest version from the official Node.js website.

  • Install Celo tools: Celo provides a suite of command-line tools for development. Install the Celo Command Line Interface (CLI) globally using npm:

Deep dive into Implementing a Decentralized Domain Name System

Understanding Decentralized Domain Name Systems

Before we delve into the implementation details, let’s gain a solid understanding of decentralized domain name systems (DNS) and their advantages over traditional centralized systems.

A decentralized DNS leverages blockchain technology to provide a trustless and censorship-resistant alternative to traditional DNS systems. In a decentralized DNS, domain names are registered, transferred, and resolved through smart contracts on a blockchain. This ensures transparent ownership, reduces the risk of domain theft or loss, and eliminates the reliance on centralized authorities.

By using a decentralized DNS, developers can create a more resilient internet infrastructure that is resistant to censorship, domain hijacking, and DDoS attacks. Furthermore, it enables domain owners to have full control and ownership of their domains, allowing for seamless transfer and dispute resolution without the need for intermediaries.

In the following sections, we will walk through the step-by-step process of implementing a Celo-based decentralized domain name system.

Setting up the Celo Development Environment

Before we start coding, we need to set up our development environment for Celo.

Install Node.js: Celo development relies on Node.js, so make sure you have it installed. You can download the latest version from the official Node.js website.

Install Celo tools: Celo provides a suite of command-line tools for development. Install the Celo Command Line Interface (CLI) globally using npm:


npm install -g celocli

Set up a Celo network: To interact with the Celo Blockchain, we need a local development network. Use the following command to set up a local Celo network:


celocli init --network=development

Test the network: Ensure that the Celo network is running correctly by executing the following command:


celocli network:status

With our development environment ready, we can now proceed to create the smart contracts for domain registration, transfer, and dispute resolution.

Creating the Domain Registration Smart Contract

In this section, we will create a Solidity smart contract that enables domain registration on the Celo Blockchain. The contract will store domain ownership information and provide functions to register and retrieve domain details.

Let’s create a new file named DomainRegistry.sol and add the following code:


contract DomainRegistry {
  struct Domain {
    address owner;
    string domainName;
    string ipfsHash;

  mapping(string => Domain) private domains;

  event DomainRegistered(address indexed owner, string domainName, string ipfsHash);

  function registerDomain(string memory domainName, string memory ipfsHash) external {
    require(domains[domainName].owner == address(0), "Domain already registered");
    domains[domainName] = Domain(msg.sender, domainName, ipfsHash);
    emit DomainRegistered(msg.sender, domainName, ipfsHash);

  function getDomain(string memory domainName) external view returns (address owner, string memory ipfsHash) {
    Domain memory domain = domains[domainName];
    require(domain.owner != address(0), "Domain not found");
    return (domain.owner, domain.ipfsHash);

In this smart contract, we define a Domain struct that stores the owner’s address, the domain name, and an IPFS hash representing additional domain details (e.g., website content). We use a mapping to associate domain names with their respective Domain struct.

The registerDomain function allows anyone to register a domain by providing the domain name and the IPFS hash. We check if the domain is already registered before assigning ownership to the caller’s address.

The getDomain function enables querying the details of a registered domain by providing the domain name. If the domain is found, it returns the owner’s address and the IPFS hash.

Compile and deploy this smart contract to your local Celo network using Truffle, Remix, or your preferred development tool.

With the domain registration contract in place, let’s proceed to implement the functionality for domain transfer.

Implementing Domain Transfer Functionality

Domain transfers are an essential part of domain name management. In this section, we will enhance our existing DomainRegistry smart contract to support domain transfers between different owners.

Update the DomainRegistry.sol file with the following changes:


contract DomainRegistry {

  event DomainTransferred(address indexed from, address indexed to, string domainName);

  function transferDomain(string memory domainName, address to) external {
    Domain storage domain = domains[domainName];
    require(domain.owner == msg.sender, "Only the owner can transfer the domain");
    require(to != address(0), "Invalid recipient");

    domain.owner = to;
    emit DomainTransferred(msg.sender, to, domainName);

In this updated contract, we introduce the transferDomain function. It allows the current owner of a domain to transfer ownership to a new address. We perform necessary checks to ensure that the caller is the rightful owner and that the recipient address is valid.

Compile and redeploy the updated contract to your Celo network.

Resolving Domain Disputes with Smart Contracts

Dispute resolution is an essential component of any domain name system. In this section, we will extend our DomainRegistry smart contract to handle disputes that may arise during domain ownership.

Update the DomainRegistry.sol file with the following changes:


// ...

contract DomainRegistry {
  // ...

  mapping(string => address) private disputeResolvers;

  event DisputeStarted(string domainName, address indexed resolver);
  event DisputeResolved(string domainName, address indexed resolver, address indexed newOwner);

  modifier onlyResolver(string memory domainName) {
    require(disputeResolvers[domainName] == msg.sender, "Only the assigned resolver can resolve the dispute");

  function startDispute(string memory domainName) external {
    require(domains[domainName].owner != address(0), "Domain not found");
    require(disputeResolvers[domainName] == address(0), "Dispute already in progress");

    disputeResolvers[domainName] = msg.sender;
    emit DisputeStarted(domainName, msg.sender);

  function resolveDispute(string memory domainName, address newOwner) external onlyResolver(domainName) {
    Domain storage domain = domains[domainName];
    require(newOwner != address(0), "Invalid new owner");

    address previousOwner = domain.owner;
    domain.owner = newOwner;
    delete disputeResolvers[domainName];

    emit DisputeResolved(domainName, msg.sender, newOwner);
    emit DomainTransferred(previousOwner, newOwner, domainName);

In this updated contract, we introduce a new mapping called disputeResolvers. It associates domain names with addresses of dispute resolvers. We also define a modifier onlyResolver to restrict certain functions to be executed only by the assigned resolver.

The startDispute function allows anyone to initiate a dispute by providing the domain name. The contract ensures that the domain exists and that no dispute is already in progress. Upon successful initiation, the resolver’s address is stored, and the DisputeStarted event is emitted.

The resolveDispute function can only be executed by the assigned resolver for a specific domain. It allows the resolver to transfer ownership to a new address. After resolving the dispute, the resolver’s address is removed, and the DisputeResolved and DomainTransferred events are emitted.

Compile and redeploy the updated contract to your Celo network.

Domain Management and Administration

Domain management and administration involve additional functionality such as revoking domain ownership, managing domain fees, and implementing administrative controls. These aspects go beyond the scope of this tutorial, but it’s important to consider them when building a complete domain name system.

Depending on your specific requirements, you may need to extend the DomainRegistry smart contract or develop additional smart contracts to cater to the administrative aspects of your decentralized domain name system.

Integrating with the Domain Name System (DNS)

To make the decentralized domain name system usable in real-world scenarios, integration with the traditional DNS infrastructure is crucial. DNS resolution in web browsers and other internet applications relies on centralized DNS servers. However, with appropriate integration, we can bridge the gap between decentralized and centralized systems.

There are various approaches to integrate decentralized DNS with traditional DNS:

  • Developing browser extensions or plugins that interact with decentralized DNS protocols and translate domain queries.
  • Building custom DNS resolvers that query both decentralized and centralized DNS servers to provide consistent results.
  • Collaborating with DNS service providers to integrate decentralized DNS protocols into their systems.
  • The choice of integration approach depends on your use case and the level of adoption you aim to achieve. Regardless of the approach, coordination with DNS stakeholders is vital to ensure a smooth transition and interoperability.

Strengthening Internet Infrastructure with Decentralized DNS

Decentralized DNS has the potential to revolutionize internet infrastructure by providing enhanced security, ownership, and censorship resistance. As developers, it is our responsibility to explore and contribute to the evolution of decentralized systems.

By implementing a Celo-based decentralized domain name system, we have taken a significant step towards building a more robust and resilient internet. However, Continued research, development, and collaboration will drive the adoption of decentralized DNS and its integration into the fabric of the internet.


In this tutorial, we have covered the implementation of a Celo-based decentralized domain name system. We explored the creation of smart contracts for domain registration, transfer, and dispute resolution. We also discussed the importance of integrating decentralized DNS with traditional DNS infrastructure to make it accessible to a wider audience.

By following this tutorial, you have gained the knowledge and proficiency to create a system for efficient domain name management. Remember to consider additional aspects such as domain administration, fees, and security when building a complete decentralized domain name system.

Decentralized DNS is a powerful concept with the potential to reshape the internet landscape. As developers, let’s continue pushing the boundaries and building a decentralized future.

About the Author

Michael Diagbare is a Software Engineer with expertise in Web, Blockchain development and content creation, certified by Cisco and MongoDB university. He is passionate about building software, problem solving and helping programmers deal with complicated tasks and challenges.

Connect with me on LinkedIn


Celo Developer Documentation
Solidity Documentation
IPFS Documentation


Nice idea


Looking forward to this


@Micholn I look forward to seeing how plan to implement the Domain name system in solidity. I hope to learn from it.


Fantastic news! Your proposal has landed in this week’s top voted list. As you begin your project journey, remember to align with our community and technical guidelines, ensuring a high quality platform for our developers. Congratulations! :mortar_board: :seedling:


@Celo_Academy Thanks


Congrats @Micholn seeing that this is advanced, i’d be very interested in learning a thing or two from it. Goodluck mate.

1 Like

@Micholn I am curious to know why this tutorial was tagged as advanced, seems to me by the technical nature of it, begginer to intermediate devs could benefit greatly from it to be honest. Also i am not aware of the use of advanced solidity features by going through the code here, so i am quite curious to know if i could have missed something.


@emmanuelikwuoma7 It’s worth noting that the complexity of a tutorial can be subjective, and what may be considered advanced for one person could be considered intermediate for another.


@emmanuelikwuoma7 However, I intend releasing a part 2 of it diving deep into the deeper concepts, this here is a preparatory step to the main thing, Just as learning to crawl is as imperative as learning to walk before running. Thanks for pointing out a few things here to me, “I can’t know it all”; you’re already doing me the job of a reviewer…Lol


all good mate, nice concept by the way. kudos on putting this out there.

1 Like

Hi @Micholn ,

Thumbs up for the job done. If I may ask, is there any special solidity-based library in Celo SDK for implementing a Domain system? According to what the title says that it is Celo-based: Implementing a Celo-Based Decentralized Domain Name System. But it is what you implemented yourself. Would you mind providing a short clarity?


I really do not think this needs a second part when it comes to the Domain system. I implemented it once and could have just done everything in this post since the post is less wordy. To make it more professional, you could edit it to add more information and perhaps employ the use of external battle-tested libraries such as OZ’s. They provide a more professional implementation of Domain systems.


@bobelr I’m still working on it, it isn’t finished yet.

Ok good. I anticipate it.


I am going to review this

1 Like