Deploying a dApp on a Local Private Blockchain

·

Deploying a decentralized application on a private test blockchain is a critical step for developers to test smart contracts and front-end interactions before moving to a live network. This guide covers the essential steps for setting up a local Ethereum-based environment, initializing a private network, and deploying a sample dApp.

Prerequisites and Environment Setup

Before starting, ensure your system meets the basic requirements for running blockchain node software and development tools.

Installing the Go Programming Language

The Go Ethereum client, geth, is built using the Go programming language. You must install Go first.

wget https://golang.org/dl/go1.15.7.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.15.7.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

Installing Geth (Go Ethereum)

With Go installed, you can now compile and install the Go Ethereum client.

  1. Clone the official go-ethereum repository from GitHub.
  2. Navigate into the directory and build the geth executable. Building all tools (make all) is recommended for access to additional utilities like clef.
git clone https://github.com/ethereum/go-ethereum.git
cd go-ethereum
make geth
# Alternatively, build all tools: make all
echo 'export PATH=$PATH:$(pwd)/build/bin' >> ~/.bashrc
source ~/.bashrc

Configuring the Private Network

A private blockchain requires a genesis block configuration to define its initial state and rules.

Creating the Genesis Block

The puppeth tool provides an interactive way to generate a genesis configuration.

  1. Create a dedicated directory for your network and run puppeth.

  2. Follow the prompts to:

    • Specify a network name (e.g., myprivatechain).
    • Choose "Configure new genesis" and then "Create new genesis from scratch".
    • Select a consensus engine (e.g., Ethash for proof-of-work or Clique for proof-of-authority).
    • Pre-fund at least one account address if desired.
    • Set an explicit Chain ID (Network ID).
  3. Export the genesis configuration to JSON files for different clients.

The process will generate a myprivatechain.json file (or your chosen name). This file defines the foundational rules of your new blockchain.

Initialize the Data Directory

Use the generated JSON file to initialize the data directory for your first node. This creates the genesis block.

geth --datadir ./mynode init myprivatechain.json

Creating User Accounts

Each node on the network can manage its own user accounts. These accounts are used for transactions and, if mining, for receiving block rewards.

geth --datadir ./mynode account new
geth --datadir ./mynode account list

Important: Always backup your keyfile and remember your password. Losing them means losing access to any funds in that account.

Starting the Network and Adding Nodes

With the genesis block defined and accounts created, you can start your private network.

Launching the First Node (Bootnode)

Start your initial node with specific flags to configure mining, RPC access, and networking.

geth --networkid 6996 --mine --miner.threads 1 --datadir ./mynode --nodiscover --http --http.addr 0.0.0.0 --http.port 8545 --port 30303 --http.corsdomain "*" --http.api eth,web3,net,personal

Adding Peer Nodes

To create a multi-node network, other instances must connect to the first node.

  1. On the new machine, create a directory and initialize it using the same genesis JSON file.
  2. Create an account on the new node.
  3. Attach to the first node's RPC endpoint to get its enode URL, which is its unique identifier.
geth attach http://<first-node-ip>:8545
> admin.nodeInfo.enode
  1. Start the new node using the --bootnodes flag with the copied enode URL to connect to the network.
geth --datadir ./newnode --bootnodes "enode://...@<first-node-ip>:30303" --networkid 6996 --port 30304 --http --http.port 8546

Deploying a Sample dApp

Once your local network is running with one or more nodes, you can deploy an application.

Cloning and Preparing the dApp Code

For this example, we use a simple token swap dApp.

git clone https://github.com/dappuniversity/eth_swap.git
cd eth_swap
npm install

Compiling and Migrating Smart Contracts

Use Truffle to compile the Solidity smart contracts and deploy (migrate) them to your local network. Ensure your Truffle configuration (truffle-config.js) points to your node's RPC address (e.g., http://192.168.32.69:8545).

truffle migrate --network development

Starting the Front-End Application

Finally, start the development server for the dApp's user interface.

npm run start

👉 Explore more deployment strategies

Interacting with the dApp Using MetaMask

Web browsers cannot natively interact with blockchain networks. The MetaMask browser extension acts as a wallet and a bridge between your browser and the Ethereum node.

Installing and Configuring MetaMask

Importing Accounts into MetaMask

To spend funds on your dApp, you need an account with a balance. Import the account you created with geth and that is receiving mining rewards.

  1. In MetaMask, click "Import account".
  2. Select "JSON File" and navigate to the keystore directory in your node's data folder (./mynode/keystore/).
  3. Select the JSON file for your desired account and enter the password you set when creating it.

The import process can take several minutes as MetaMask decrypts the keyfile. Once imported, you should see the ETH balance from your mining rewards. You can now use your local dApp to execute transactions, such as swapping ETH for a custom token.

Frequently Asked Questions

What is the difference between a public and a private blockchain?
A public blockchain is open for anyone to participate in, read, and write to, like Ethereum Mainnet. A private blockchain is permissioned, typically run by a known set of entities for specific use cases like testing or enterprise solutions, offering greater control and privacy.

Why is a genesis file necessary for a private network?
The genesis file is the first block of the blockchain (block 0). It defines the initial state, consensus rules, and foundational parameters of the network, ensuring all nodes start from an identical and agreed-upon state.

Can I use Ganache instead of a private Geth network?
Yes, Ganache is a popular personal blockchain for rapid development and testing. It's easier to set up but may not replicate the exact multi-node environment and consensus behavior of a Geth-based private net for more complex testing.

My node won't connect to the bootnode. What should I check?
Verify the enode address is correct and that the IP address is accessible from the new node (check firewalls). Ensure both nodes are using the identical --networkid and genesis block configuration.

Why can't my dApp front-end connect to MetaMask?
This is often a configuration issue. Ensure your dApp's web3 provider is correctly configured to connect to MetaMask. Also, check that MetaMask is connected to the correct local network with the right Chain ID.

Transactions are pending forever. How can I resolve this?
If you are not mining, there is no node to process transactions. Ensure at least one node is started with the --mine flag. Also, check that the account you are using in MetaMask has a sufficient ETH balance for gas fees.