In the human world, we don't have an expectation that our own names are universally unique or "owned" by us. For example, there are many Johns and Vitaliks in the world, but usually we can manage OK anyway.

This project is an experiment that explores a concept where names are shared, duplicated, local, and dynamic. Rather than having names (and what they refer to) imposed on you by a central authority, you choose and maintain your own view of the world. Of course, you can't maintain everything in the world, so it would be nice to be able to delegate portions of the namespace to people you respect or trust, (and allow them to delegate too, recursively).

What it does

In our web-app, users create and maintain their own personal tree of names and associated data, and can publish this to the world. We call these trees zones. In order to authenticate the data in them, zones are hashed and these hashes are stored on the Ethereum blockchain. Along with various types of data like URLs, Ethereum addresses, and comments, users can also create special items called overlays. These are entries that mount somebody else's tree (or a sub-tree thereof) into your own namespace (technical inspiration for the name: OverlayFS).

The important and special part of overlays is that adding one does not simply copy a static snapshot of the data into your tree. Instead, it adds a reference to another address. When the owner of this other address modifies the portion of the sub-tree that you've mounted in, your own view updates instantly to match.

How we built it

We created a very simple smart contract that allows users to associate and update hashes of their zones with their ethereum address, and then deployed it to the Goerli test-net.

Next we created a C++ server that stores and retrieves zone data using a websockets API and an LMDB database.

Finally, we built a react web UI that allows users to create, maintain, and browse their zones.

Challenges we ran into

We didn't have enough time to finish the merkle proof system we planned. When complete, this will enable a client such as the web UI to verify that individual items (or ranges of items) retrieved from the server are in-fact included in the desired zone, and that they haven't been tampered with.

Accomplishments that we're proud of

We have built enough of the system to demonstrate the concept of "self-sovereign" naming systems. The UI code is definitely not pretty, but it shows the essential elements of the system:

  • Building up a tree of names and their corresponding values
  • The tree is hashed and this is embedded onto the blockchain so anybody can authenticate it
  • Adding an overlay from somebody else's namespace to your own splices it into your tree
    • Elements that come from other addresses are coloured differently than your own (and a blockie icon is added to show where each one comes from)
    • Names don't need to be unique! Two values can share the same key, and they are all shown together when clicked on so the user can decide which they need

What we learned

Every time we talked with anybody about our idea, they suggested new ideas and use-cases for this naming system that we hadn't considered, for example:

  • Corporate contact lists where records are delegated to each department
  • Bittorrent directories
  • Certificate revocation lists

It seems there is a lot of potential for this type of collaborative, authenticated data-structure!

Live Demo

Visit our website to checkout a live demo.

  • Make sure you are on the Goerli test-net
  • Try tracking the address 0x00E21f272A5829c842702d0bA92D99A8727D6207 to get started

What's next for Overlay Namespaces

  • The UI needs a big overhaul
  • Merkle proofs! Clients should not have to trust the servers.
  • Curated zones of zones to help people discover trees they'd like to overlay
  • Search

Built With

Share this project: