Claim HNS

Detailed information available in the hs-airdrop README.md file.

UPDATE: Please be careful about using other software or giving away your private key to others. In addition, one should be careful about following instructions on random websites who are not HNS community members as those instructions may incorrectly state that this page is currently outdated or contain other errors; instructions made by those who are not active users or community participants in Handshake likely have not been validated by the Handshake community.

These instructions generates a signed proof of ownership of a public key. Please consider against sending your private keys to third parties to do this process on your behalf, as that results in significant risks. Handshake is an experiment in decentralized allocation of ownership of the network to the open source community, it is believed that open source developers should be one of the primary long-term beneficiaries by owning a necessary resource as the network utility increases. This HNS airdrop is a native limited resource used to register top-level domains and usernames (a limited resource is needed in decentralized naming systems, as a single bad actor would register all useful names in existence if no limited resources existed).

This page explains how github developers with over 15 followers on February 2019, or in the PGP WoT Strong Set can claim HNS. Being able to claim does NOT imply that one is a "top open source developer", this system was optimized for a list of previously scrapeable keys (and could not be modified after the Handshake network launches without a hard fork).

System Setup

Please read through these instructions carefully, as using cryptographic blockchains are a bit unusual.

Make sure you have nodejs and npm installed first. On MacOS, please install homebrew and run "brew install node unbound". On debian/ubuntu, you can run "sudo apt-get install nodejs npm build-essential libunbound-dev". If you run other distributions or OSes, you can probably figure this part out.

Next, install node-gyp: npm install node-gyp

Download

Download hsd, hs-client, and hs-airdrop from https://handshake.org/download/. If downloaded from github, the directory structure is slightly different (hsd-2.4.0/hsd should be replaced with just hsd in these instructions).

Extract hsd, hs-client, and hs-airdrop: tar xvf hs*

You may also verify the asc file if desired.

Install

In one window, change into the hsd directory cd hsd-*/hsd and then run npm install --production

.

In a second window, change into the hs-client directory cd hs-client-*/hs-client and then run npm install --production

Run hsd

hsd is the handshake fullnode and will sync with the network

To connect, in the first window run: ./bin/hsd --log-level info

Get your address

To claim your airdrop, you need an HNS address to send the coins to. To generate one, in the second window run:

./bin/hsw-cli account get default | grep receiveAddress

You should see a string of random looking characters beginning with hs1. The entire string inside the quotes is your public address (this address is public and can be shared). Copy this address and save it

Claim your HNS

In the second window, go to the hs-airdrop directory and install hs-airdrop:

cd hs-airdrop-*/hs-airdrop

Then install the dependencies: npm install --production

Check if your key is in the airdrop. Replace id_rsa with the location of your private key you want to check and the hs1XXXX string with the public address you generated earlier. This will prompt for your key's passphrase if encrypted. Please see the hs-airdrop README.md file for more information.

./bin/hs-airdrop --bare ~/.ssh/id_rsa hs1XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

This may take a while, as it is trying to find and decrypt a message to your key. If successful you should see a base64 string. A NonceError means your key was not included, you can try another key.

If you have a base64 string, you can broadcast it to the network by going back to hs-client (cd hs-client-*/hs-client) and typing (replace BASE64_STRING with the string dumped from hs-airdrop): ./bin/hsd-cli rpc sendrawairdrop BASE64_STRING

You should see it return a hex hash if successful. In an hour or two you should see it propagate over the network. You can see the updated balance by running: ./bin/hsw-cli balance

You can also try searching for your hs1 address balance by googling/searching: hns block explorer in your web browser and pasting in your hs1 address.

You did it! Please read on! Handshake provides tooling on secure naming and by owning the HNS tokens you can use it to bid on names. You can try bidding on some names before playing around with transfers. Handshake deals with scarce resources, namespaces are unique, consider registering a username/handle you like. Many good names are being registered, apologies if your preferred names are taken -- it's hard to mitigate this in a decentralized way. On the principle of understanding the protocol, it could be interesting for software engineers to go through the process of registering a name for themselves.

Bidding on names

It takes about a day before you can do anything. This is a decentralized network without singular leaders or institutions in permanent control, so it will need time to confirm.

After about a day for the redemption to clear on the network, you can use your HNS to register top-level domains (which could also be useful for usernames on systems which use Handshake). Replace NAME with your desired name. Please see the documentation on auctions and protocol summary for more information.

Name status (check a name is available): ./bin/hsd-cli rpc getnameinfo NAME

If it says "info": null, then the name is available

Open for bidding: ./bin/hsw-cli rpc sendopen NAME

After sending an open transaction, it will take around 6 hours for bidding to open. You will have around 5 days to submit a bid before bidding closes.

Send bid (150 is an example bid amount and 500 is your blinding mask, see documentation): ./bin/hsw-cli rpc sendbid NAME 150 500

You should set a very high blinding mask as it can dissuade people from outbidding you, the blinding mask is public, you will reveal your actual bid after bidding closes. Choose whatever bid and blinding mask you think makes sense for you. Note that the bid is a "Second-Price Auction", meaning setting a higher value will not result in higher payment unless there is someone else willing to pay that amount.

Reveal bid (YOU MUST REVEAL AFTER BIDDING IS CLOSED WITHIN 10-BLOCK-DAYS OR YOU WILL LOSE THE COINS YOU ALLOCATED TO BID FROM THE sendbid TRANSACTION, SEE DOCUMENTATION): ./bin/hsw-cli rpc sendreveal NAME

If lost auction, refund coins back to yourself: ./bin/hsw-cli rpc sendredeem

See the documentation on more commands, such as renewals which must be made at least every two years.

Try googling/searching for hns block explorer or looking on an HNS Exchange for a list of bid blinds and bid status of names.

The state of auctions are as follows: OPEN (first ~six hours, cannot bid), BID (~five days, anyone can place bids), REVEAL (~ten days, you MUST reveal your bid or you lose your bid HNS), REDEEM/REGISTER (refund your money or update the DNS record, no time limit for REDEEM). This takes a long time to secure the network, while it is possible to make it fast, true decentralized systems must "confirm" chain states over time and therefore HNS biases towards security and correctness. Selecting instant redemption would be a foolish endeavor (as someone can claim high-value names cheaply) and fast auctions would prove inaccurate or increased vulnerability towards censorship attacks.

Handshake enables authenticated proofs, think SSH keys without needing to verify the fingerprint. Just type in the right name and the chain proof provides verified association between the public key and the name/server. Right now, the most common method is to trust a third party (SSL Cert Authorities) to sign off and one is trusting them to act honestly and competently. Handshake is an attempt to explore an alternative to these constructions. Decentralized authenticated connections require a secure decentralized root of trust which starts with names.

Backing Up

If you want to store your coins in the event Handshake's utility and valuation increases in the future via greater development in the open, then you should back up your keys to maintain access to your coins and name for the future.

Write down the 12 or 24 words on a piece of paper. These words can recover your names and funds at any time. There is no other backup and no third party can restore it on your behalf without these words. You are interacting with a p2p network, and hence there is no recovery functionality built-in (as this would require updating all nodes on the p2p network):

./bin/hsw-cli master

Summary

Handshake is rooted in the culture of open source and the majority ownership of initial coins are claimable by open source developers with available scrapeable keys. The original intent was that the free and open source community has inufficient recognition in the long-term benefit in systems. When systems become more popular, the FOSS community does not receive the benefits. If Handshake becomes more popular with better tooling and applications, members of the FOSS community benefits. It's believed that this aligned incentive creates benefit for all, with recognition via higher network valuation and utility in the future if this method works. Certain kinds of decentralized systems were not historically possible as some entities could overwhelm the network and claim all the resources (in this case, register all names). Handshake is an experiment in distributing majority ownership to the open source community of this network as a method to bootstrap a decentralized network with limited resources, to prevent griefers taking up all the resources. It is hoped that this system could be used as a method wherever decentralized key authentication of names is needed (e.g. decentralized web applications where an association between a name and a cryptographic key proving ownership of that name). In other words, an association between keys and names create the potential for the decentralized web by allocating cryptographically provable resources to names. This could be used to prove the owner of a name published a document, and distributed across a decentralized network. The more applications using this system to secure/prove documents in a decentralized way, the higher the useful aggregate economic/social value of registered names on Handshake (Metcalfe's Law).

The Handshake community is in active development of authenticated proof of names/resources, decentralized social coordination tooling, and developing for decentralized web efforts.

If you have questions or are looking to see how to contribute to improve the usability of the network, get in touch with the wider community. There is no official foundation or organization, on HNS you aren't connected to a central server in full control of the network, so there are many community groups. For starters, you can try one of the IRC or telegram channels.

IRC: #[email protected]