This document presents a short user guide for the initial DarkFi
testnet. In it, we cover basic setup of the
darkfid node daemon,
initializing a wallet, and interacting with the money contract,
which provides infrastructure for payments and atomic swaps.
Since this is still an early phase, we will not be installing any of the software system-wide. Instead, we'll be running all the commands from the git repository, so we're able to easily pull any necessary updates.
Refer to the main README file for instructions on how to install Rust and necessary deps.
Once you have the repository in place, and everything is installed, we
can compile the
darkfid node and the
drk wallet CLI:
$ make darkfid drk
This process will now compile the node and the wallet CLI tool.
When finished, we can begin using the network. Run
darkfid once so
that it spawns its config file on your system. This config file will
be used by
darkfid in order to configure itself. The defaults are
already preset for using the testnet network.
$ ./darkfid Config file created in "~/.config/darkfi/darkfid_config.toml". Please review it and try again.
Once that's in place, you can run it again and
darkfid will start,
create necessary keys for validation of blocks and transactions, and
begin syncing the blockchain. Keep it running, and you should see a
Blockchain is synced! message after some time.
Now it's time to initialize your wallet. For this we use a separate wallet CLI which is created to interface with the smart contract used for payments and swaps.
We simply have to initialize a wallet, and create a keypair:
$ ./drk wallet --initialize $ ./drk wallet --keygen
The second command will print out your new DarkFi address where you can receive payments. Take note of it. Alternatively, you can always retrieve it using:
$ ./drk wallet --address
In order to receive incoming coins, you'll need to use the
tool to subscribe on
darkfid so you can receive notifications for
incoming blocks. The blocks have to be scanned for transactions,
and to find coins that are intended for you. In another terminal,
you can run the following commands to first scan the blockchain,
and then to subscribe to new blocks:
$ ./drk scan $ ./drk subscribe
Now you can leave the subscriber running. In case you stop it, just
drk scan again until the chain is fully scanned, and then you
should be able to subscribe again.
Now you have your wallet set up. Let's proceed with getting some
tokens from the faucet. The testnet has a running faucet which is
able to airdrop arbitrary tokens. For example purposes, we'll use
the tokens called
So let's airdrop some of these into our wallet:
$ ./drk airdrop 42.69 DARKfZX1utGbz8ZpnvtCH6i46nSDZEEGa5fMnhoubWPq $ ./drk airdrop 13.37 BobvfQrDaf32VNhVtX6Adyi3WGfPpPYZPJBn6rnrxHKm
There is a limit of 100 for testnet airdrops currently.
Note: you have wait some minutes between airdrops since they're rate-limited.
On success, you should see a transaction ID. If successful,
the airdrop transactions will how be in the consensus' mempool,
waiting for inclusion in the next block. Depending on the network,
finalization of the blocks could take some time. You'll have to wait
for this to happen. If your
drk subscribe is running, then after
some time your balance should be in your wallet.
You can check your wallet balance using
$ ./drk wallet --balance
Using the tokens we got, we can make payments to other addresses. Let's
try to send some
$ ./drk transfer 2.69 DARKfZX1utGbz8ZpnvtCH6i46nSDZEEGa5fMnhoubWPq \ 8sRwB7AwBTKEkyTW6oMyRoJWZhJwtqGTf7nyHwuJ74pj > payment_tx
The above command will create a transfer transaction and place it into
the file called
payment_tx. Then we can broadcast this transaction
to the network:
$ ./drk broadcast < payment_tx
On success we'll see a transaction ID. Now again the same finalization
process has to occur and
will receive the tokens you've sent.
We can see the spent coin in our wallet.
$ ./drk wallet --coins
We have to wait until the next block to see our change balance reappear in our wallet.
$ ./drk wallet --balance
In order to do an atomic swap with someone, you will
first have to come to consensus on what tokens you wish to
swap. For example purposes, let's say you want to swap
DARKfZX1utGbz8ZpnvtCH6i46nSDZEEGa5fMnhoubWPq (which is the balance
you should have left over after doing the above payment) for your
To protect your anonymity from the counterparty, the swap can only send entire coins. To create a smaller coin denomination, send yourself the amount you want to swap. Then check you have a spendable coin to swap with:
$ ./drk wallet --coins
You'll have to initiate the swap and build your half of the swap tx:
$ ./drk otc init -v 40.0:20.0 \ -t DARKfZX1utGbz8ZpnvtCH6i46nSDZEEGa5fMnhoubWPq:AcABG4fnmBuT5vuXV8TLdEV8panhk5SdtBZxCCLqQxyL \ > half_swap
Then you can send this
half_swap file to your counterparty and they
can create the other half by running:
$ ./drk otc join < half_swap > full_swap
They will sign the full_swap file and send it back to you. Finally, to make the swap transaction valid, you need so sign it as well, and broadcast it:
$ ./drk otc sign < full_swap > signed_swap $ ./drk broadcast < signed_swap
On success, you should see a transaction ID. This transaction will now also be in the mempool, so you should wait again until it's finalized.
After a while you should see the change in balances in your wallet:
$ ./drk wallet --balance
If you see your counterparty's tokens, that means the swap was successful. In case you still see your old tokens, that could mean that the swap transaction has not yet been finalized.
On the testnet, we are also able to create an anonymous DAO. Using
drk CLI tool, we have a
dao subcommand that can perform the
necessary operations. Let's create a DAO with the following parameters:
- Proposer limit:
- Approval ratio:
- Governance token:
You can see what these parameters mean with the
$ ./drk help dao create
Lets create our DAO.
$ ./drk dao create 90 10 0.67 A7f1RKsCUUHrSXA7a9ogmwg8p3bs6F47ggsW826HD4yd > dao.dat $ ./drk dao view < dao.dat
The view command will show us the parameters. If everything looks fine, we can now import it into our wallet:
./drk dao import MiladyMakerDAO < dao.dat ./drk dao list ./drk dao list 1
If parameters are shown, this means the DAO was successfully imported
into our wallet. The DAO's index in our wallet is
1, so we'll use
that to reference it. Now we can create a transaction that will mint
the DAO on-chain, and broadcast it:
./drk dao mint 1 > dao_mint_tx ./drk broadcast < dao_mint_tx
Now the transaction is broadcasted to the network. Wait for it to
finalize, and if your
drk is subscribed, after finalization you
should see a
leaf_position and a transaction ID when running
dao list 1.
Let's send some tokens to the DAO's treasury so we're able to make
a proposal to send those somewhere. First find the DAO bulla and the
DAO public key with
dao list and then create a transfer transaction:
$ ./drk dao list 1 $ ./drk transfer 10 BNBZ9YprWvEGMYHW4dFvbLuLfHnN9Bs64zuTFQAbw9Dy \ 6BwyxvNut6jrPaQ5YPcMVgM3nhwNxvdFhVT4CwQHwJgN \ --dao CvnfwNHGLEL42mpjETtWknt7ZEQhoJCACGZ9rVFscFw4 > dao_transfer $ ./drk broadcast < dao_transfer
Wait for it to finalize, and if subscribed, you should see the DAO receive the funds:
$ ./drk dao balance 1
Now that the DAO has something in their treasury, we can create a
proposal to send it somewhere. Let's send 5 of the 10 tokens to our
address (we can find that with
drk wallet --address).
Since we chose
90 as the governance token proposal limit, let's
just airdrop that into our wallet first:
$ ./drk airdrop 90 A7f1RKsCUUHrSXA7a9ogmwg8p3bs6F47ggsW826HD4yd
Then create the proposal:
$ ./drk dao propose 1 ChgNSmpp6pCstPsvYNNT1686fuj1PPobo1C4qWXubr3r \ 5 BNBZ9YprWvEGMYHW4dFvbLuLfHnN9Bs64zuTFQAbw9Dy > proposal_tx $ ./drk broadcast < proposal_tx
Once finalized and scanned, the proposal should be viewable in the
wallet. We can see this with the
$ ./drk dao proposals 1 $ ./drk dao proposal 1 1
NOTE: vote & exec is todo, check src/contract/dao/ for code.