As soon as we finish importing our wallet, we’ll be taken straight to the wallet page. You will notice straight away that we have the correct details because it’s showing both the balance and the pre-mine transaction in the transaction list.

Let’s give it a test. Hitting the “Send” button at the top-right, we’ll be presented with a new popup form. For now, we will just send a transaction to ourselves. Start typing “Genesis” into the recipient field and choose our wallet from the drop-down list. Enter an amount, and fill in the Smartbridge field (if you wish). Unless you chose to enable dynamic fees, we will stick with the default static fee here (may also differ if you changed your static fees).

Finally, fill in your passphrase (or encrypted password) and press “Next”.

On the next screen, we will see confirmation of all our details. Assuming you are happy, press “Send”.

Now, if we check the logs of our Testnet server we will see our transaction get picked up and forged!

$ ./bridgechain.sh logs-core

We can also take a look on Explorer and see our transaction successfully get processed.

So this is good news! We have confirmed that not only have we successfully launched a Testnet and Explorer. We’ve also been able to add the new network to our desktop wallet and send a transaction to the network.

Adding a Forging Delegate to the Network

Now, it’s all great with getting this far. But we’re only using a single server to manage all of the delegates. We need to make sure we can add additional delegates to the network, outside of the genesis delegates. The best way to do this is to add a new server into the mix, which will be used for forging a completely separate delegate.

Storing core on Git

The easiest way to do this is to store the core changes in a Git repository. On your existing server, head to the root folder of your new Core installation and check Git’s current status for that folder:

$ cd ~/core-bridgechain/

$ git status

Assuming you didn’t use the --git-commit parameter, you will get output similar to the above. This is basically showing that we have made some changes to files that need to be updated. We need to do the following steps:

Fork our ARK Core v2 on GitHub

Go to https://github.com/ArkEcosystem/core and click on the “Fork” button at the top-right of the page (don’t forget to star it as well 😊).

“Fork” button in the top-right.

Then choose the repository/user where you want to create the fork.

This will begin creating the forked repository and will automatically refresh when finished.

Change the Git Remote URL

If you’ve not run Git on the server before, you will need to set up the commit user’s name and email address (ignore this if you already have these details):

$ git config --global user.name "ARK Deployer"

$ git config --global user.email "support@ark.io"

Now, with our newly created fork, we can update the “origin” of our codebase on the server.

On the home screen of the forked repository, on GitHub, there is a “Clone or download” button on the right, just above the list of files. Depending on whether you’re using SSH keys from your machine or not, you can opt to copy the SSH URL or the HTTPS URL (click the text “Use HTTPS” to switch).

Now that you have the URL for the origin, run the below command on your server (replacing the URL with your own):



$ git remote -v $ git remote set-url origin git@github.com :alexbarnsley/core.git$ git remote -v

The second command will output the new origin URLs, just as a confirmation.

Before we continue, let’s make sure there were no new changes made between us installing and us forking the core repository. You can do this simply by pulling any changes down:

$ git pull

Pull changes from our forked repo.

Commit & push the changes

Now, all we need to do is add all the files to the staging area, and commit them. To do this, we run:

$ cd ~/core-bridgechain

$ git add .

$ git commit -m "chore: new network config"

The output from our commit command.

Finally, push your changes to your new repository:

$ git push

Output confirming that our changes have been pushed to our forked repository.

Set up new nodes to run your delegate

In order to have a functioning network with multiple nodes, we must have more than 2 nodes on the Testnet network. This value is much higher on Mainnet and Devnet, due to how critical these networks are. In order to continue, we must have a total of 3 nodes on our Testnet network because that is the minimum in order for it to continue forging. It is possible for the seed node to forge on its own because that is running in “test” mode, which allows forging on the same machine regardless of peers on the network.

So, what we will need to do at this point is set up our 2 new nodes. We’ll call these delegate-1 and relay-1 . The easiest way to go about adding these new nodes to the network is to run the core Deployer process (from the very first step in this guide) but on the new servers. Go ahead and do that now until you have installed core on both, but don’t yet start core on either.

Switching config details to our forked repository

Now that we have 2 newly deployed nodes ready for our network, we need to update the codebase to use our forked repository which we set up in our previous step.

Change the origin to match the GitHub repo. As all GitHub forks are made public automatically, you can simply use the HTTPS URL unless you plan on making code changes directly on the new servers.



$ git remote set-url origin

$ git fetch --all

$ git checkout packages

$ git pull $ cd ~/core-bridgechain$ git remote set-url origin https://github.com/alexbarnsley/core.git $ git fetch --all$ git checkout packages$ git pull

Now we’ve updated our files, we need to rebuild Core. This is important to make sure the new config files are used:

$ yarn setup

The successful output of Core setup.

Register a delegate on the network

Now that we are ready with the codebase, we need to register our delegate with the network.

In the Desktop Wallet, create a new wallet. You do this by going to the Wallet List (the wallet icon in the sidebar) and clicking “Create wallet”. Choose an address (refresh until you find one you like), and click “Next”. Write your passphrase down, and press “Next”. Fill in the 3 missing words and continue to the next step. Encrypt the wallet passphrase if you want to, and on the final step, choose a name.

Once you press “Done” to save your wallet, you will be taken to the wallet page. What we need to do first, however, is go back to the Genesis Wallet we set up earlier in this guide and send us some tokens so we can register our own delegate name. We’ve covered that also, so head to the Genesis Wallet and click “Send”. Make sure you select the new delegate wallet as the recipient:

The number of tokens shouldn’t matter too much, but we will just send over 5000 for now.