Setup Rubix Node and Joining the Testnet

Faucet tokens are premined tokens available for users to test and interact with the Rubix testnet.

When a new node joins the testnet, it will have 0 tokens to start with. To help users get started, the Rubix testnet provides a faucet service where users can request premined test tokens. These tokens are not earned through validation but are instead distributed for testing and development purposes.

To request test tokens, users must first create a node in the Rubix testnet and generate a Decentralized Identifier (DID). The DID is then submitted to the faucet, which transfers requested amount of tokens to the users DID. The faucet have kept a limit on amount of token per node per day inorder to avoid spam requests.

Test tokens are free and allow users to experiment with the testnet’s functionality, such as performing token transfers, validating token chains, testing smart contracts etc. Unlike mainnet tokens, test tokens do not hold any real-world value and cannot be transferred to the main network.

Pre-requisites

1. Install Go

Any computer or personal laptop with 8GB of RAM and a stable internet connection can seamlessly run Rubix for token transfers / become validator.

Download the latest Go binary package for your operating system from Go’s official site.
Follow the installation instructions for your OS.
Verify the installation and ensure the Go version is correct:
```
go version
```

2. Download and Extract IPFS Kubo (v19)

Visit IPFS Kubo releases and download version 19 suitable for your operating system.
Locate the IPFS executable in the extracted files and verify if it has executable permissions.

3. Clone the RubixGoPlatform Repository

Clone the repository:

git clone https://github.com/rubixchain/rubixgoplatform.git

Navigate to the repository directory and checkout to the development branch
```
cd rubixgoplatform
git checkout development
```

4. Build the RubixGoPlatform Executable

For Linux :
```
make compile-linux
```
For Windows :
```
make compile-windows
```
For MAC :
```
make compile-mac
```

Upon successful compilation, the “rubixgoplatform” executable will be created in a folder corresponding to your operating system. For example, on Linux (build directory), it will be located in the ./linux directory.

5. Prepare the Necessary Files

Ensure the following files are in the build directory:

rubixgoplatform executable
ipfs executable (from Kubo v19, extract and copy in the build folder)
testswarm.key (Its already part of executable. Copy it to the build directory)

Joining the Testnet

Start a Rubix Node

Open a terminal and navigate to the directory containing the rubixgoplatform executable. This will already be present in the build directory.
```
cd /path/to/rubixgoplatform
```
Start a Rubix node with the following command:
```
./rubixgoplatform run -s -testNet -p <node_name> -n <node_number> -grpcPort <grpc_port>
```
Example
```
./rubixgoplatform run -s -testNet -p node0 -n 0 -grpcPort 10500
```
This will start the node in port 20000. The port number where the node starts will be 20000+(node_number)
Replace the placeholders:
- <node_name>: A unique name for your node.
- <node_number>: Numeric identifier for the node.
- <grpc_port>: Port number for gRPC communication.

Confirm the node is operational and connected to the testnet. Check for below in the logs.

Bootstrap connection check

Create a DID (Decentralized Identifier) for the Node and register the DID

Once the node is running, open a new tab in terminal while being in the same build path, create a DID by executing:
```
./rubixgoplatform createdid -didType 4 -port <port_number>
```
Example
```
./rubixgoplatform createdid -didType 4 -port 20000
```
Copy the mnemonic file somewhere safe. This will help with node recovery. To get the mnemonic file, go to below location:
```
cd /path/to/buildFolder/<Node_Name>/Rubix/TestNetDID/<did_generated>
```

./rubixgoplatform registerdid -did <did_created> -port <port_number>

Example

./rubixgoplatform registerdid -did bafybmicfvpln2j5yfjeokmafjsefz7ykibvtsg2swxmnr6nhvflj6qvo34 -port 20000

Generate Test RBT Tokens

To get test RBTs (Rubix Blockchain Test Tokens):

Open the faucet webpage in browser
In the address field, provide your DID created above to receive test tokens for your node, and submit DID.

Verification

Validate token generation by checking the node’s token balance. To check balance of a particular DID:

./rubixgoplatform getaccountinfo -did <did> -port <port_number>

Example bash ./rubixgoplatform getaccountinfo -did bafybmicfvpln2j5yfjeokmafjsefz7ykibvtsg2swxmnr6nhvflj6qvo34 -port 20000 You should see one RBT as below. Account Info Congratulations! You have successfully joined the Rubix testnet. You can now use the node for testing and development purposes.

Next Steps

Now that you have successfully joined the Rubix testnet, you can:

Explore Rubix’s testnet functionality, such as smart contracts and other APIs to get information related to rubix node etc.
Use the Rubix Explorer to monitor transactions and node activity.
Contact the Rubix team for further support.

Latest Releases

Subscribe to rubixgoplatform repository to be notified on new releases.

For help regarding getting notified for releases see documentation