Mission Statement

Decentralizing the registry

It is now becoming absolutely clear that once open internet is increasingly suffering from censorship and excessive regulations on the one hand and total control by the Big Tech and the likes on the other hand. Russia closing Linkedin and Telegram, Trump banning TikTok in the US, Apple removing Fortnite from the App store and many more incidents go completely against the very core values of the free and open Web. Web 3.0 is being built on the new decentralization paradigm, however currently not all parts of the ecosystem operate by the new principles.

The ODAR initiative is aiming to create a fully decentralized alternative to the existing Domain Registry system. The Dapp Hashtag registry links Dapp Hashtags (equivalent of domain names) with online or downloadable dapps as well as dapps' metadata. The Dapp File Registry links .dapp file SHA256 checksums with Dapp Hashtags for authenticating the dapps and version control. Fully decentralized, without censorship or approvals, with real time data control only by the developers, the approach allows building Dapp ecosystem in the truly free an open way, the way the original Internet was once designed.

Contract Addresses & ABI

Hashtag registry

Contract address 0xefa93054c9cd0394cf7f76c7ca7250900899861c on the Ethereum Mainnet
Hasghtag registry contract ABI

Dapp file registry

Contract address 0xae96906c976f0a38e1febfe84bf5c0316d4120c9 on the Ethereum Mainnet
Dapp file registry contract ABI

Built-in Economics

Incentivizing the parties and ensuring quality content

Some of the ODAR services are paid. These are all related to the blockchain state-changing modifications (i.e. writing) to the registries. All fees are one-time, there's no ongoing fees for maintaining the records. Accessing and reading the information is free as long it remains so in the core Ethereum network. The primary reason of making some functionality paid is providing an economic incentive for various involved parties (like dapp stores) to develop and maintain the ODAR initiative. In addition, paid services introduce proof-of-stake model for the unregulated registry, ensuring quality of content. E.g. shorter hashtags are more expensive, thus investing into those makes economic sense only to higher quality dapps/developers that either invest more or have a stronger dapp model.

Paid services are:
- Registering Hashtags.
- Updating Hashtag information.
- Transferring Hashtags to new owners.
- Registering .dapp file version/checksum.

Please refer to Hashtags and Files sections for specific pricing information.

Dapp Hashtags

Uniqueness

All hashtags are unique and registered on first come first serve basis. All hashtags are converted to lower-case at registration, to ensure case-insensitive uniqueness.

Data fields

The following data fields are registered along with the hashtag:
Hashtag – any string up to 32 characters long, like “MyAppName”, “Blue Shield” or “Response247”. It is advisable not to include space or any special characters, though any string acceptable as “string” data type in Solidity will work.
Dapp locator – URL or any other locator of the dapp, including protocol. It could be an URL, IP address, magnet link or anything else. The dapp registry itself supports any string, it is up to the specific dapp store / dapp browser to support the protocol.
Dapp metadata locator – URL or any other locator of the dapp metadata JSON file, including protocol. The suggested metadata JSON basic format is here, but it could be extended to support a specific dapp store or for any other purpose.
Registration timestamp – UNIX timestamp of the registration.
Update timestamp – UNIX timestamp of the last hashtag update (e.g. URL or other data field).
Owner – Ethereum address, from which the hashtag has been registered, or transferred to. Only the owner can update hashtag information (such as URL, etc.) and transfer the hashtag to another Ethereum address.

Dapp Metadata

Dapp Metadata is a URL for JSON file contaning dapp metadata information, such as developer information, icon and screenshot URLs and so on. A sample suggested JSON is here.

At least the following fields should be presented:
- Full dapp name
- Dapp icon URL
- Dapp description

Different dapp stores can support different additional fields, please check the documentation there.

[!] Although dapp stores can copy and regularly update the metadata, it is suggested to ensure that any external resources (such as image files) are always online, so that e.g. decentralized downloadable dapp stores can hotlink to them.

Hashtag pricing

Hashtag pricing depends on the length of the hashtag:

  • 6 characters or more: 0.001 ETH (1000000000000000 Wei)
  • 5 characters: 0.01 ETH (10000000000000000 Wei)
  • 4 characters: 0.1 ETH (100000000000000000 Wei)
  • 3 characters: 1 ETH (1000000000000000000 Wei)
  • 2 characters: 10 ETH (10000000000000000000 Wei)
  • 1 characters: 100 ETH (100000000000000000000 Wei)
For convenience, Hashtag Registry Smart Contract has hashtag availability and price estimation function getHashtagPrice(hashtag), where hashtag is the string to check.

Solidity Hashtag Registry Smart Contract code:
getHashtagPrice(string memory new_hashtag) public view returns (uint256 hashtag_reg_price_wei)

The function will return “0” price for already registered hashtags and registration price (in Wei) otherwise.

Commission

ODAR provides an economic incentive for dapp stores or any other parties by paying 50% commission of the registration, update and ownership transfer fees. Payment is done immediately on transactions, the commission Ethereum address is passed to smart contract’s functions (registration, update and ownership transfer) along with other registration information.

Calling hashtag registration function

To register a new hashtag, the registerHashtag() function is called and the value equal to the hashtag price is sent (see the Hashtag pricing section for details on the pricing and hashtag price estimation).

[!] Ethereum address, from which the hashtag registration function is called, becomes the owner of the hashtag. Any updates or transfer of the hashtag to the new owner can later be done only from the owner Ethereum address. Therefore when registering a new hashtag, the initiating Ethereum address should be noted and securely stored for later transactions.

Solidity Hashtag Registry Smart Contract code:
function function registerHashtag( string memory new_hashtag, string memory new_dapp_url, string memory new_metadata_url, address payable comm_address ) public payable

The following parameters are passed:
- hashtag (string)
- dapp locator (string)
- dapp metadata (string)
- commission address (Ethereum address, where 50% registration commission will be sent)

Example:
registerHashtag(“mydappname”, “https://mydapp.com/index.html”, “https://mydapp.com/res/dappmetadata.json”, “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”)

Updating hashtag information

Updating hashtag information can be done only by the owner, therefore update transaction must be called from the Ethereum address, which the hashtag has been registered originally from. The cost of updating hashtag data is 0.001 ETH, 50% commission is paid to the provided in the function call Ethereum address.

Solidity Hashtag Registry Smart Contract code:
function updateHashtag( string memory hashtag_to_update, string memory new_dapp_url, string memory new_metadata_url, address payable comm_address ) public payable

The parameters are the same as in the registerHashtag() function.

Example:
updateHashtag(“mydappname”, “https://mydapp.com/index.html”, “https://mydapp.com/res/dappmetadata.json”, “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”)

Changing hashtag owner

Hashtag owner can transfer the ownership to any Ethereum address (should the original address be compromised, or if the owner wants to sell his/her hashtag, etc.). Only the existing owner can transfer the ownership, so the function must be called using the owner’s Ethereum address, otherwise the function generates an error. The cost of changing hashtag owner is 0.001 ETH, 50% commission is paid to the Ethereum address provided in the function call.

The Hashtag Registry Smart Contract function transferHashtag() should be called with 3 parameters:
- Hashtag
- Ethereum address of the new owner
- Ethereum address for commission

Solidity Hashtag Registry Smart Contract code:
transferHashtag(string memory hashtag_for_transfer, address payable new_owner, address payable commission_address) public payable

Example:
transferHashtag(“mydappname”, “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”, “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”)

Retrieving hashtag information

All hashtag information can be retrieved by reading hashtag[] public variable. The variable is accessed in the same way as reading any other Ethereum blockchain contracts public variables. Please refer to ABI for the details on the variables.

For example, hashtag[“myhashtag”].owner returns “myhashtag” owner’s Ethereum address. The following data can be read from the hashtag[] variable:

  • hashtag[HASHTAG].owner (Ethereum address)
  • hashtag[HASHTAG].dapp_url
  • hashtag[HASHTAG].metadata_url
  • hashtag[HASHTAG].timestamp_registered
  • hashtag[HASHTAG].timestamp_updated
  • hashtag[HASHTAG].id

[!] Bear in mind, that all hashtags are stored in lower case (converted to lower case at registration). Therefore any attempts to access an existing hashtag using capital letter(s) will return empty data.

Retrieving registered hashtags

Reading all registered hashtags with their metadata can be done in 2 simple steps

- public variable current_id stores the ID of the last registered hashtag. As all hashtags are registered sequentially, the last hashtag ID also shows the total number of registered hashtags.

- public variable hashtag_id[ID] stores hashtag with the index ID. By sequentially requesting hashtags with ID 1 to current_id, it is possible to build a list of all registered hashtags.

File Registry

The File Registry links .dapp file SHA256 checksum with a dapp Hashtag. In addition, it stores file version, original file name and file registration date. This allows authentication of .dapp files that could be distributed across any media.

Distributing downloadable dapps

  • Register a dapp hashtag, e.g. "mydapp".
  • Build a .dapp file.
  • Get SHA256 checksum for the .dapp file.
  • Register the SHA256 checksum with ODAR File Registry Smart Contract. Registration will link your SHA256 checksum with your "mydapp" dapp hashtag.
  • Distribute your .dapp file across any media (send over email, upload to web, distribute via torrents, USB keys, etc.).
  • Dapp browsers will independently build your file's SHA256 checksum, check the ODAR File Registry for the checksum and authenticate the file as belonging to "mydapp".

File registration pricing

File registration price is 3000000000000000 Wei, it is stored in File Registry Smart Contract variable price_wei.

File registration commission

ODAR provides an economic incentive for dapp stores or any other registration parties by paying 50% commission of the file registration price. Payment is done immediately on registration, the commission Ethereum address is passed to smart contract’s file registration function along with the other registration information.

Calling file registration function

To link a file to a hashtag, registerFile() function is called and the value equal to the file registration price transferred (see the pricing section).

[!] Only the owner of a hashtag can link a file to the hashtag. When registering files, please make sure that the registration is done using the Ethereum address that matches hashtag owner in the Hashtag Registry.

Solidity File Registration Smart Contract code:
registerFile ( string memory hashtag, string memory new_checksum, string memory new_file_name, string memory new_version, address payable comm_address ) public payable

The following parameters are passed:
- dapp hashtag (string)
- SHA256 checksum (string)
- .dapp file name, including the .dapp extension (string)
- version (string)
- commission address (Ethereum address, where 50% registration commission will be sent)

Example:
registerFile(“games”, “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”, "gamesv1.dapp", "1.12d" “0x3CF0e35869f19262a62143D6B85B74878Bb6b838”)

Retrieving file information

All file information can be retrieved by reading file[] public variable. The variable is accessed in the same way as reading any other Ethereum blockchain contracts public variables. Please refer to ABI for the details on the variables. For example, file[CHECKSUM].hashtag will return the dapp hashtag that the file is linked to. The following data can be read from the file[] variable:

  • file[CHECKSUM].hashtag
  • file[CHECKSUM].file_name
  • file[CHECKSUM].version
  • file[CHECKSUM].added

Retrieving the latest file version

File Registry Smart Contract variable latest_version[HASHTAG] stores the checksum of the latest version of a file. This is convenient if you want to automatically check if you're opening the latest version of a .dapp file (and retrieving the latest if you detect that it is available).The following logic should be followed:

  • Calculate SHA256 for the .dapp file
  • Retrieve dapp hashtag that the file checksum corresponds to
  • Check if the latest_version[HASHTAG] is the same (i.e. latest_version[HASHTAG] = CHECKSUM)
  • If the checksum is the same, you have the latest .dapp file version
  • If a different checksum is returned, download the latest .dapp file (or link to the online dapp URL), specified in the Hashtag Registry