NAV Navbar
shell toml


Whiteblock is a full-stack blockchain testing platform that helps development teams quickly test and develop high-performing blockchain solutions.

The Whiteblock platform allows users to provision multiple fully-functioning nodes within a private test network over which they have complete control. Transactions, behaviors, and other application and network logic can be automated as nodes interact in real-time, allowing you to observe the performance of protocols, algorithms, decentralized applications, or changes to system infrastructure prior to deployment.

Each node exists within its own Virtual Local Area Network (VLAN) and is assigned a unique IP address. This provides logical separation between nodes. The links between these nodes can be manipulated and configured with latency, packet loss, and other WAN conditions according to user specification in order to replicate real-world performance with high accuracy.

Use Cases


Blockchain Agnostic Choose from a list of supported blockchain systems to build within a private and controlled testing environment.

Bring Your Own Client If the logic of compiling and deploying your client can be defined within a Dockerfile, Whiteblock’s intuitive framework will generate and apply a custom wrapper during the build process to allow you to test your own system in the testing environment.

Automate Genesis Ceremony Quickly provision a functional blockchain network without the additional hassle of editing a configuration file every time a new test network is provisioned.

Account & Wallet Creation Indicate total number of accounts/wallets to be created within test network.

Pre-allocate Funds Fund wallets and accounts with a specified amount of assets. Start testing right away without the need to wait for mining rewards.

Transactional Logic Indicate the value and volume of transactions to automate activity. Measure transactions per second (TPS) and observe the effects of various environmental conditions on throughput.

Network Behavior Configure Wide Area Network (WAN) conditions between nodes, including latency, packet loss, and bandwidth constraints to replicate real-world performance within a safe and controlled environment.

Data Visualization The Whiteblock Explorer provides insight into TPS, uncle rate, and other relevant data points and performance metrics.

Reporting Generate concise reports to summarize your test cases.

Pipeline Integration Whiteblock seamlessly integrates with your CI/CD platform of choice to reduce development overhead.


Whiteblock's netconfig module allows you to configure and manipulate the links between nodes in order to emulate a real-world Wide Area Network (WAN) and replicate the conditions you would expect to encounter in a live production network.

Spec Details
Bandwidth Capabilities 10Kbps -1Gbps
Maximum Nodes >1000
Maximum Latency 10000ms
Packet Loss Models Random, Periodic, Burst, BER, Gilbert-Elliot
Time Accuracy Within .01ms

IP Scheme

Each node is provisioned within its own VLAN and assigned a unique address. These IP addresses can be from within the 10.x.x.x range reserved for private internets.

Since Whiteblock uses IPv4, each address will have 32-bits. Unless your Whiteblock environment has a large amount of nodes, the default IP scheme will assign an IP address of to the first node in the network. The second node will be assigned The third will be assigned and so forth. With each consecutive node, the IP address increments by 4.

Multi-Server Environments

If your Whiteblock instance allows for large numbers of nodes (>1000), the services may span across several separate servers.

Within this topology, each server will be assigned a relatively unique serverId. This uniqueness need only apply to servers within your user space.

3 IP addresses are reserved from each subnet. Nodes within the same VLAN are able to route between each other by default.

For simplicity, the following variables will be used

Note the following rules:

A,B,C, and D must be greater than 0. D must be at least 2.

ceil(log2(A)) + B + C + D <= 32

Formula Detail
(2^B) The maximum number of servers.
(2^C) The number of cluster in a given server.
(2^D - 3) How many nodes are groups together in each cluster.
(2^D - 3) * (2^C) The max number of nodes on a server.
(2^D - 3) * (2^C) * (2^B) The maximum number of nodes that can be provisioned on the Whiteblock platform.


Each cluster corresponds to a subnet, network of nodes, and VLAN. Nodes within the same cluster will have minimal latency applied to them. In the majority of cases it is best to just have one node per cluster, allowing for latency control between all of the nodes.


Bearing in mind the variables described in previous sections, given a node number X and a serverId of Y, Let Z be the cluster number, and I be the generated IP in big-endian:

Z = floor(X / (2^D - 3))) I = (A * 2^(B+C+D) ) + ( Y * 2^(B+C) ) + (Z * 2^C) + (X % (2^D - 3) + 2)

if Z == (2^C - 1) then I = I - 2


After identifying the cluster of which the node is a member, the IP is calculated one segment at a time through addition. Due to the restrictions, each piece will fit neatly into place without overlap or risk of collision. Finally, we check if it is not the last cluster on the server and add 1 to the ip address if this is true.


Within the Whiteblock platform, nodes are provided as application containers. The core of the node engine implements an intelligent wrapper for Docker containers in combination with a suite of proprietary testing libraries and additional logic engines.

This pattern allows the Whiteblock platform to provide a highly configurable environment without the resource intensive overhead associated with tradtional virtual machines. However, it's important to note that although the core engine of Whiteblock does rely on certain components mounted as Kernel-based Virtual Machines (KVM), the nodes themselves are not in KVM, but a slightly more robust and complex Docker container than you may be used to.

Naming Conventions

By default, each node is named whiteblock-node*N* where N indicates the node number. The Whiteblock platform uses zero-based numbering where the first node in the system is assigned an index of 0 rather than 1 in the sequence of nodes. As such, the first node in the network will be named whiteblock-node0, the second node in the network will consecutively be named whiteblock-node1, and so forth.

User Access

After the onboarding process, you will be provided a private key and IP address for your private Whiteblock environment. This will allow you to securely access the CLI application via Secure Shell (SSH) session.

SSH Access

Once you've been provided with your private key, place it in the appropriate directory and access the platform using the standard ssh command.

$ ssh <ip address>

Linux/Unix users can SSH into the Whiteblock environment using the standard ssh command. Alternatively, you can use an SSH client of your choice. Windows users should refer to the provided Windows documentation to install OpenSSH and do whatever it is Windows users are supposed to do.

If you’ve never used an SSH client before or have limited terminal experience, there are several open-source utilities available. PuTTY is a free and reliable client. Another alternative is MobaXterm but it is not free.

Command Line Interface

After establishing an SSH connection, you will be greeted with the following output. Try getting started with the whiteblock build command!

---- The Scalable Blockchain Testing Platform ----
          _     _ _       _     _            _
__      _| |__ (_) |_ ___| |__ | | ___   ___| | __
\ \ /\ / /  _ \| | __/ _ \ '_ \| |/ _ \ / __| |/ /
 \ V  V /| | | | | ||  __/ |_) | | (_) | (__|   <
  \_/\_/ |_| |_|_|\__\___|_.__/|_|\___/ \___|_|\_\

--------------- Whiteblock v.1.0 -----------------
Support: [email protected]
Last login: Sat Jan 3 18:15:05 2009 from

[email protected]:~$

The CLI application allows you to interact and send commands to the Whiteblock platform through your computer's terminal or command-line shell. A variety of commands are available to help you easily deploy a private blockchain test network within the Whiteblock testing environment and control or automate processes, behaviors, and actions. It has been designed to provide an intuitive user experience without requiring complex commands or advanced engineering knowledge.

CLI Reference

`$ whiteblock [COMMAND] [SUBCOMMAND] [FLAG] `
Commands Details
build provisions nodes running selected blockchain client, peers nodes, configures blockchain network, generates accounts, funds wallets, and automates various actions like genesis ceremony, depending on client specified.
netconfig network emulation engine that applies network conditions and impairments to the links between nodes.
get shows various statistics related to network/blockchain performance; block count, transactions per second, uncle rate, etc.
iperf network performance measurement tool that measures IP throughput between nodes, measures bandwidth capacity, and packet loss.
ping sends ICMP ping command between two nodes to measure round-trip time and check if they’re able to respond to each other.
scp securely copies a file between Whiteblock master environment and node(s).
ssh logs in to nodes CLI to execute remote commands.
solc utility for compiling and deploying EVM smart contracts to a blockchain network.
version displays current version of Whiteblock CLI application.


whiteblock build <subcommand> <flags>

The build command allows you to create and deploy a blockchain with a specified number of nodes that are each running the client of your choice. You can also indicate the amount of computational resources that should be reserved for each node consumes and also customize the configuration parameters for the blockchain client they're running.

Required Parameters

In order to successfully execute, the build commands requires that you at least define the type of blockchain and the number of nodes you'd like to build in the network. If these values aren't explicitly provided, you won't be able to do anything and your own lack of creation will leave you trapped in a lifeless world.

Parameter Valid Arguments
Blockchain Ethereum, Syscoin, Rchain, EOS, Monero, NEM, Fabric, Quorum, or Custom
Nodes An integer value to indicate the number of nodes that will be built in the network. This number is limited by the Genesis plan to which you're subscribed.

There are two ways to specify build values: Command line flags or Build Wizard. Both of these methods are described as follows.

Command Line Flags

For example, the following command would build an Ethereum network with 100 nodes, each with 4 CPUs and 30GB RAM:

whiteblock build -b ethereum -n 100 -c 4 -m

The build commands accepts command line flags that allow you to define parameters.

You can indicate the value of these variables by appending the appropriate flag to the whiteblock build command.

whiteblock build <flags>

Flags Type Details
-b, --blockchain string blockchain client each node will run.
-n, --nodes int number of nodes that will be provisioned within the network.
-c, --cpus int number of vCPUs that will be assigned to each node.
-f, --file string path to blockchain client's custom configuration file.
-m, --memory int amount of RAM that will be assigned to each node.
-v, --validators int set the number of validators.
-y, --yes accepts all prompts and defers to default settings.

Use $ whiteblock build [command] --help for more information about a command.

Build Wizard

[email protected]:~$ whiteblock build
Blockchain: <string value>
Nodes: <integer value>
RAM: <integer value>
CPUs: <integer value>
Config: (0 for default): <string value>

The Build Wizard is an interactive module that allows you to indicate the values that will be used when building the blockchain network. If you run the build command without additional flags or if you neglect to indicate every required parameter needed in the build process, you will be dropped into the Build Wizard to define those parameters.

The values expected by the Build Wizard may change based on the blockchain client you've indicated. These details will be included in each client's respective section in this documentation.

Build Process

The output of the build command will help you keep track of the build process and display a percentage to indicate the current step in the build progress and a percentage for completion.

2019/01/18 00:19:52 build:  Build in Progress
Configuring Network 11.718750% completed

After configuring the parameters with the build command, the build process will begin. This process could take several minutes, depending on the client that you're building and the computational resources that are available within your environment and assigned to each node. Whiteblock will be provisioning the nodes, configuring the client, creating and funding wallets/accounts, peering nodes, and automating other blockchain critical processes so you don't have to.

The output will indicate a percentage which indicates build progress. During this time period, it's recommended that you avoid clearing the terminal and maybe grab a snack, watch a video on YouTube, or go over your test plan.


$ whiteblock netconfig <command> <argument>

The Whiteblock netconfig module is a high-performing network emulation engine which forwards packets, routes TCP/IP traffic between nodes and their respective VLANs, and can apply common network impairments to these links.

Command Details
delay sets up to 10,000ms in network latency
loss sets percentage of packet loss in network
bw sets bandwidth capacity between nodes
on turns emulation engine on
off turns emulation engine off


Delay Command:

$ whiteblock netconfig delay <amount> 


$ whiteblock netconfig delay 100

The delay subcommand specifies the amount of latency that will be added to the network. Latency is represented in milliseconds and the expected argument is expected as an integer value.

$ whiteblock netconfig delay <amount>

The provided example command tells the netconfig module to apply 100ms latency to the network.

Packet Loss

Packet Loss Command:

$ whiteblock netconfig loss <amount> 


$ whiteblock netconfig loss 0.01 

The loss subcommand specifies the amount of packet loss that will be added to the network. Packet loss is represented as a percentage and the expected argument expects a decimal value where 0.1 would represent a value of 0.1% packet loss.

$ whiteblock netconfig loss 0.01

The provided example command tells the netconfig module to apply 0.01% packet loss to the network.


Bandwidth Command:

$ whiteblock netconfig bw <amount> <value>


$ whiteblock netconfig bw 100 mbps

The bw subcommand specifies the maximum bandwidth speeds for the links between nodes. This should be specified as an integer and can be represented as either bps, Kbps, Mbps, and Gbps values between 1bps and 1Gbps in 1bps increments.

$ whiteblock netconfig bw <amount> <value>

The provided example tells the netconfig module to configure 500Mbps bandwidth speeds within the network.

Turning On/Off

After hitting the enter key to commit any one of these previous netconfig commands, the specified configurations will not be applied to the network until you explicitly turn the module on, so once you’re ready, you will need to turn the netconfig module on. This can be done by using the command below.

$ whiteblock netconfig on

Turn the netconfig module on:

$ whiteblock netconfig on

Turn the netconfig module off:

$ whiteblock netconfig off

The netconfig module will then continue to run and the network conditions will persist until the module is turned off. If you would like to make any changes to the netconfig module, you will have to turn it off, apply those changes, and then turn it back on again. Netconfig can be turned off using the command below:

$ whiteblock netconfig off


To ping node 3 from node 6:

$ whiteblock ping 6 3

The ping command is a simple implementation of the standard network diagnostic tool of the same name that's found on many computer. It's used to send an Internet Control Message Protocol (ICMP) Echo Request to a specific interface on a network in order to determine whether it is available, responsive, and can accept requests. In the context of the Whiteblock platform, the ping command allows one node to check and see if it can communicate with another node. More imperatively, you can use ping to measure the amount of latency or packet loss between nodes.

whiteblock ping <requesting node> <responding node>

To ping between nodes, simply indicate the requesting and responding node numbers as an integer value.


To measure bandwidth between node 3 and node 6:

$ whiteblock iperf 6 3

The iperf configures the specified nodes in the network to act as client/server between one another in order to measure the maximum bandwidth between them and report MSS/MTU size. The syntax of this command is similar to the ping command where both node numbers are specified by number.

whiteblock iperf <client node> <server node>

When running, the iperf command will configure the specified nodes as client/server. The default IP protocol is IPv4. The data stream packets can be either Transmission Control Protocol (TCP) or User Diagram Protocol (UDP). Use this tool to diagnose and measure the links between nodes.


To send a file named hello.sol from the a directory named /contracts in the master environment to the root directory of node 6:

$ whiteblock scp 6 /contracts/hello.sol /

The scp command allows you to securely copy files from the Whiteblock master environment to a specified node in the network.

whiteblock scp <node number> </file/to/send/path> </destination/path>

This command is useful for providing specific configuration files for individual nodes or deploying smart contracts.


The ssh command allows you to access the command line console for a specific node or provide a command you'd like a node to execute.

Access Command Line Console

To remotely access the command line console for node 1:

$ whiteblock ssh 1
$ Welcome to Ubuntu 18.04.1 LTS (GNU/Linux 4.15.0-1026-gcp x86_64)
$ [email protected]:~#

To log in to the the command line console for a specific node, simply specify the node number after the ssh command.

whiteblock ssh <node number>

Sending Remote Commands

To remotely execute a command on node 3 that deploys a smart contract in Rchain:

$ whiteblock ssh 3 rnode deploy --phlo-limit 2000 --pholo-price 1000 /contracts/dupe.rho file>

To send a command that you would like a specific node to execute, provide the command after the ssh command.

whiteblock ssh <node number> <command>

As of Whiteblock v.1.0, there are no known limitations for the command you can provide.


The get command offers several general subcommands which output network and performance data.

$ whiteblock get <command> [FLAGS]

Command Description
account displays account information.
block displays block data.
default displays default configuration for the blockchain client.
log dumps data logs for a specific node.
nodes lists all nodes in the network.
running Will check if a test is running.
stats displays performance stastics.
tx outputs transactional data.


Get information about the accounts

Get account information

$ whiteblock get account info
    "account": "0x4dac3fdbb96e8089c762d783968ae7a4dbf1f067",
    "balance": "3364062500000000000000",
    "txCount": "0"
    "account": "0xcb901724d34fcccc44b373981f02546d521e8faf",
    "balance": "3470000000000000000000",
    "txCount": "0"
    "account": "0xb4ddf0482f5132e82100c48b0338bc9c02cf4f6f",
    "balance": "3781250000000000000000",
    "txCount": "0"

Usage: $ whiteblock get account [command]

Available command:


Get all information about the blocks

Example get block info

$ whiteblock get block info 12
  "difficulty": "0x20240",
  "extraData": "0xd883010900846765746888676f312e31302e34856c696e7578",
  "gasLimit": "0x3dc106",
  "gasUsed": "0",
  "hash": "0xf9f8198c5427c1dbaf3891e19314ec44418623af41ad14e8d66a94e01f813206",
  "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "miner": "0xb4ddf0482f5132e82100c48b0338bc9c02cf4f6f",
  "nonce": "0x4c253a8291b6d5b0",
  "number": "0xc",
  "parentHash": "0xf4b8b07069bbf167921c645c1ff904abaad7355f6a90dbb0ccd35d848b75fb41",
  "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
  "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
  "size": "0x218",
  "stateRoot": "0x09ca7da6f50ed5794ecb900785245d9fb60ad6d6951e8757ab427f4c576b1ce9",
  "timestamp": "0x5c3fe8e2",
  "totalDifficulty": "0x199260",
  "transactions": [],
  "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
  "uncles": []

Example get block number

$ whiteblock get block number

Usage: $ whiteblock get block [command]

Available commands:


Example response:

$ whiteblock get default ethereum
  "chainId": 15468,
  "difficulty": 100000,
  "eip155Block": 0,
  "eip158Block": 0,
  "gasLimit": 4000000,
  "homesteadBlock": 0,
  "initBalance": 100000000000000000000,
  "maxPeers": 1000,
  "networkId": 15468

Get the blockchain specific parameters for a deployed blockchain.

Usage: $ whiteblock get default <blockchain> [flags]

Response: The params as a list of key value params, of name and type respectively


-h, --help help for default


Get stdout and stderr from a node.

Params: node number Response: stdout and stderr of the blockchain process

Example response:

$ whiteblock get log 0

Usage: $ whiteblock get log <node number> [flags]


-h, --help help for log


Example response:

$ whiteblock get nodes
    "cpu": 251.2,
    "name": "whiteblock-node0",
    "server": 1,
    "up": true
    "cpu": 257.3,
    "name": "whiteblock-node1",
    "server": 1,
    "up": true
    "cpu": 240.3,
    "name": "whiteblock-node2",
    "server": 1,
    "up": true

nodes will output all of the nodes in the current network.

Usage: $ whiteblock get nodes [flags]

Aliases: nodes, node



Running will check whether or not a test or process is running. If true, it will output the test's name and information.

Response: true or false, on whether or not a test is running; The name of the test or nothing if there is not a test running.

Example response:

$ whiteblock get running

Usage: $ whiteblock get running [flags]



Stats will allow the user to get statistics regarding the network.

Example response

$ whiteblock get stats all
  "blockTime": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "difficulty": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "gasLimit": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "gasUsed": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "totalDifficulty": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "tps": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "transactionCount": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0
  "uncleCount": {
    "max": 0,
    "mean": 0,
    "standardDeviation": 0

Response: JSON representation of network statistics

Commands Details:
all Will get all statistics of a blockchain
block Will get statistics of a blockchain
past Will get statistics of a blockchain from the past x blocks
time Will get statistics by time

Usage: $ whiteblock get stats <command> [FLAGS]

Example using -h flag

$ whiteblock get stats all -h

Stats all will allow the user to get all the statistics regarding the network.

Response: JSON representation of network statistics

  whiteblock get stats all [flags]

  -h, --help                 help for all
  -a, --server-addr string   server address with port 5000 (default "localhost:5000")



Get a transaction by its hash. The user can find the transaction hash by viewing block information.

To view block information, the command 'get block info [block number]' can be used.

Params: The transaction hash

Response: JSON representation of the transaction.

Usage: $ whiteblock get tx [command]

Example get transaction info

$ whiteblock get tx info 0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b
 "hash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
 "nonce": 2,
 "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
 "blockNumber": 3,
 "transactionIndex": 0,
 "from": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
 "to": "0x6295ee1b4f6dd65047762f924ecd367c17eabf8f",
 "value": BigNumber,
 "gas": 314159,
 "gasPrice": BigNumber,
 "input": "0x57cb2fc4"

Available commands:


The version command allows you to check which version of Whiteblock Genesis you're currently running.

$ whiteblock version

Example response:

$ whiteblock version
whiteblock 1.0.4


RChain is a blockchain platform for distributed applications which implements a Proof of Stake consensus algorithm. RChain also presents Rholang, a unique smart contract programming language based on [Rho calculus]. More information on the technical aspects of this system can be found in the RChain developer portal.

Whiteblock's implementation of the RChain client is built on v0.8.2 and an example test plan using the Whiteblock platform can be found in the RChain GitHub.


Building Rchain with flags:

$ whiteblock build -b rchain -v <number of validators> -n <number of nodes>

Provisioning 10 validator nodes within the network using flags:

$ whiteblock build -b rchain -v 10

Static nodes that are not performing as validators can be specified using the -n flag.

Provisioning 10 validator nodes and 5 static nodes with flags:

$ whiteblock build -b rchain -v 10 -n 5

Build using default parameters:

[email protected]:~$ whiteblock build -b rchain -v 10 -n 5
Use default parameters? (y/n) y
2019/01/13 07:13:21  Build in Progress
Setting up services    24.411817% 

When building the network, Whiteblock will automate several processes, including the following:

The number of validators should be specified with the -v flag. The first among the provisioned nodes will be assigned the role of validator. For example, if you've specified a number of 10 validators in a network of 50 total nodes, nodes 0 - 10 will be delegated the role of validators.


An example of Whiteblock's default rnode.toml file:

host = "localhost"
port = 44010
http-port = 44011
no-upnp = false
default-timeout = 5000
bootstrap = "rnode://<address>@<ip>protocol=40400&discovery=40404"
standalone = false
data-dir = "/RChain/data"
map-size = 200000000
in-memory-store = false

host = "grpc"
port = 44012

certificate = "/RChain/ssl/node.certificate.pem"
key = "/RChain/ssl/node.key.pem"

# [validators]
# count = 5
# bonds-file = "/validator/bonds"
# known = "v1"
# public-key = "88888"
# private-key = "99999"
# sig-algorithm = "ed25519"
# wallets-file = "/validator/wallet"

The RNode application refers to an rnode.toml file for configuring different functions and processes.

Whiteblock automatically generates an rnode.toml file during the build process. This configuration file does not persist between builds. An example configuration file is provided in the right-hand column.

If you would like to define your own values to populate the configuration file, you can do so through the Build Wizard by providing n as your response when prompted.

Use default parameters? (y/n) y

By responding with n, you can define these parameters on your own and will then be prompted to provide values for each entry.

Alternatively, you can provide your own configuration file using the -f flag to indicate the path to the configuration file.

whiteblock build -b rchain -v 5 -n 10 -f /home/master/custom-rchain.toml

For example, the above command would build an RChain network with 5 validators and 10 static nodes that would each refer to the custom-rchain.toml file located in the home directory of the Whiteblock master environment.

Deploying Contracts

Deploying a smart contract from a specific node can be done using the ssh command and there are two ways to go about doing so. The first option would be directly connecting to a node's terminal and manually deploying the contract using the appropriate command.

Deploying the dupe.rho contract via node 4:

$ whiteblock ssh 4 rnode deploy --phlo-limit 1000 --pholo-price 500 rchain/rholang/examples/dupe.rho

The second option would be providing the RNode command after indicating the node number in the ssh command.

$ whiteblock ssh <node number> rnode deploy --phlo-limit <value> --pholo-price <value> <path to .rho file>



Build using previous configurations:

$ whiteblock build previous

To start the build process, use the following command:

$ whiteblock build -b eos 


Build using -b flag:

$ whiteblock build -b eos

Type the number of nodes and y to use default parameters:

nodes (30): 30
Use default parameters? (y/n) y

Type the number of nodes and type y to use default parameters >>>


[email protected]:~$ whiteblock build -b eos
nodes: 30
Use default parameters? (y/n) y
2019/01/13 07:13:21  Build in Progress
Setting up services    45.411817% 

Progress bar >>>

During this build process, the Whiteblock framework is deploying the nodes, peering them with one another, configuring VLANs, generating and funding accounts and wallets, and initializing the blockchain.

In the process of initializing the EOS system, a single node acts as the master of ceremonies to generate the genesis block that starts the blockchain. Afterwards, this node steps down and the rest of the nodes in the network need to vote on which of the 21 amongst them will be elected block producers. Every node in the network that wants to vote is required to do so using SYS, which is the symbol for the native EOS token.

Once this process is complete, block producers will immediately begin minting blocks and you can start changing network conditions, automating transactions, deploying smart contracts, and testing however you see fit using the eos command.

Custom Parameters

Example build

$ whiteblock build -b eos -n 30
Use default parameters? (y/n) n
userAccounts (int):
blockProducers (int):
accountCPUStake (int):
accountRAMStake (int):
accountNetStake (int):
accountFunds (int):
bpCpuStake (int):
bpNetStake (int):
bpRamStake (int):
bpFunds (int):
maxBlockNetUsage (int):
targetBlockNetUsagePct (int):
maxTransactionNetUsage (int):
basePerTransactionNetUsage (int):
netUsageLeeway (int):
contextFreeDiscountNetUsageNum (int):
contextFreeDiscountNetUsageDen (int):
maxBlockCpuUsage (int):
targetBlockCpuUsagePct (int):
maxTransactionCpuUsage (int):
minTransactionCpuUsage (int):
maxTransactionLifetime (int):
deferredTrxExpirationWindow (int):
maxTransactionDelay (int):
maxInlineActionSize (int):
maxInlineActionDepth (int):
maxAuthorityDepth (int):
initialChainId (string):
chainStateDbSizeMb (int):
reversibleBlocksDbSizeMb (int):
contractsConsole (bool):
p2pMaxNodesPerHost (int):
allowedConnection (string):
maxClients (int):
connectionCleanupPeriod (int):
syncFetchSpan (int):
maxImplicitRequest (int):
pauseOnStartup (bool):
maxTransactionTime (int):
maxIrreversibleBlockAge (int):
keosdProviderTimeout (int):
txnReferenceBlockLag (int):
plugins ([]string):
2019/01/16 21:55:24 build:  Build in Progress
Sending build context to Whiteblock

If you don't want to use the provided default parameters during your build and would instead like to specify your own, simply indicate the values you would like to specify by typing n when prompted. Alternatively, you can provide your own custom configuration file and specify the path to this configuration file using the -f flag.

Start the build process with eos and 30 nodes:

$ whiteblock build -b eos -n 30

Use default parameters? (y/n) n

Example build with -y flag

$ whiteblock build -b eos -n 30 -y
2019/01/16 21:55:24 build:  Build in Progress
Sending build context to Whiteblock

You will be prompted to input the parameters that you still need to provide to start building. In order to build with default settings, use flag -y

$ whiteblock build -b eos -n 30 -y