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)
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