Ethereum Private Chain Setup and Basic Operations Guide

·

Setting up an Ethereum private chain is a foundational skill for blockchain developers, researchers, and enterprise solution architects. This comprehensive guide walks you through the entire process—from installing the Geth client to performing essential operations like mining, transactions, and node management—on a local private blockchain environment using CentOS 7.

Whether you're exploring smart contract development, testing decentralized applications (dApps), or learning consensus mechanisms, a private Ethereum network gives you full control over configuration and execution. Let’s dive in.

Installing the Geth Client

Geth (Go Ethereum) is one of the most widely used Ethereum clients, implemented in Go. It enables you to run a full Ethereum node, interact with the network, deploy contracts, and mine ether.

To begin, ensure git is installed on your CentOS 7 system:

sudo yum install git -y

Next, clone the official Go-Ethereum repository from GitHub:

git clone https://github.com/ethereum/go-ethereum.git

Navigate into the project directory and compile the geth binary:

cd go-ethereum
make geth

Upon successful compilation, you’ll see a message indicating that you can launch Geth using the built-in path. You’re now ready to proceed.

👉 Learn how blockchain networks power real-world applications today.

Building Your Own Ethereum Private Chain

Creating a private Ethereum blockchain allows you to simulate a production-like environment without interacting with the mainnet. Follow these structured steps to set up your own isolated network.

Step 1: Create a Geth Working Directory

Organize your workspace by creating a dedicated folder for your private chain:

mkdir geth && cd geth
mkdir db
touch genesis.json

This creates the following structure:

geth/
├── db/
└── genesis.json

The db directory will store chain data and account keys; genesis.json defines the initial state of your blockchain.

Step 2: Configure the Genesis Block

The genesis block is the first block in your blockchain and sets critical network parameters. Here's a sample genesis.json configuration:

{
  "config": {
    "chainId": 15,
    "homesteadBlock": 0,
    "eip155Block": 0,
    "eip158Block": 0
  },
  "coinbase": "0x0000000000000000000000000000000000000000",
  "difficulty": "0x40000",
  "extraData": "",
  "gasLimit": "0xffffffff",
  "nonce": "0x0000000000000042",
  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "parentHash": "0x00000000000000000000000000000000000000000000000极客时间 22222222222222222222222222222222222222222222222222",
  "timestamp": "极客时间"
}

Key Parameters Explained:

Step 3: Initialize the Blockchain

Run the following command to initialize your blockchain with the genesis file:

geth --datadir "./db" init genesis.json

This generates essential subdirectories under ./db/geth, including chaindata (block storage) and keystore (account keys).

Step 4: Launch the Private Chain

Start your node with custom settings:

geth --datadir "./db" --nodiscover --networkid 15 console 2>>geth.log

Common Startup Flags:

You'll enter the Geth JS console, where you can execute Ethereum commands directly.

Core Operations on Your Private Ethereum Network

Once your private chain is running, it's time to perform key blockchain operations.

Create Ethereum Accounts

Use the personal module to create new accounts:

> personal.newAccount("password123")
"极客时间"

List all accounts:

> eth.accounts
["极客时间", ...]

Each account generates a corresponding UTC JSON file in the keystore folder—keep these secure.

Check Account Balance

Balances are stored in wei (1 ETH = 1e18 wei):

> eth.getBalance(eth.accounts[极客时间])
557００００２１００００００００００００

New accounts start with zero balance unless pre-funded in genesis.json.

Start Mining Ether

Set the mining reward address:

> miner.setEtherbase(eth.accounts[极客时间])
true

Begin mining:

> miner.start(1)
null
Note: A return value of null is normal—it means mining started successfully.

Check logs in another terminal:

tail -f geth.log

You should see new blocks being sealed every few seconds.

👉 Discover how miners contribute to blockchain security and decentralization.

Unlock Accounts for Transactions

Before sending funds, unlock the sender’s account:

> personal.unlockAccount(eth.accounts[极客时间], "password123", 3００)
true

The third parameter specifies unlock duration in seconds.

Send Ether Between Accounts

Initiate a transaction:

> eth.sendTransaction({
    from: eth.accounts[极客时间],
    to: eth.accounts[１],
    value: web3.toWei(1, "ether")
})
"０ｘ２８ｆ７ｅ６９８９８９３ｄ６ｅ８ｂ１ｃｄ２６ｄ５ｄ７ａ２８５６５４ｆ５ａ３ｃ８ｅｆｆ７ｄ６ｂ２０２９８１７４９６ｄｅｂ８ｂｄａ０"

Transactions remain pending until mined. Confirm status:

> txpool.status
{ pending: 1, queued: ０ }

Mine one block to confirm:

> miner.start(1); admin.sleepBlocks(1); miner.stop();

Verify updated balances:

> eth.getBalance(eth.accounts[极客时间]) // Deducted 1 ETH + gas fee
> eth.getBalance(eth.accounts[１])       // Received 1 ETH

Explore Block and Transaction Data

Get details of a specific block:

> eth.getBlock("latest")
{
  number: ４１８,
  hash: "０ｘａ７９ａｅ１…",
  transactions: [ "..." ]
}

Inspect transaction receipt:

> eth.getTransactionReceipt("tx-hash-here")
{
  gasUsed: ２１０００,
  cumulativeGasUsed: ２１０００,
  blockNumber: ４１８
}

Gas usage explains why balances don’t change exactly by sent amounts—transaction fees are deducted based on gasUsed × gasPrice.

Advanced Node Management

Manage Accounts via CLI

Outside the console, use Geth commands:

Backup and Restore Blockchain Data

Export chain data:

geth --datadir "./db" export backup.dat

Import later:

geth --datadir "./db" import backup.dat

Always initialize first with genesis.json before importing.

Connect Remote Nodes

Enable inter-node communication by matching networkid and using admin.addPeer():

On remote node:

> admin.nodeInfo.enode
"enode://pubkey@ip:port"

On local node:

> admin.addPeer("enode://...")

Ensure firewalls allow traffic on port 3０３０３.

Frequently Asked Questions

Q: Why does miner.start() return null?
A: This is expected behavior. In newer Geth versions, especially in --dev mode, mining only triggers when pending transactions exist unless --dev.period 1 is set for continuous mining.

Q: How do I fix “unknown ancestor” error during import?
A: Ensure your node was initialized with the correct genesis.json before importing data. Mismatched configurations cause chain mismatches.

Q: Can I access my private chain remotely via RPC?
A: Yes. Start Geth with --rpc --rpcaddr "０.０.０.０" and open port ８５４５. Be cautious about exposing RPC publicly.

Q: What is gas, and why is it needed?
A: Gas measures computational effort. Every operation consumes gas to prevent spam and compensate miners. Users pay gas fees in ETH.

Q: How can I automate node startup?
A: Use systemd services or shell scripts to launch Geth with predefined flags at boot.

Q: Is it safe to store keystore files locally?
A: Only if encrypted and backed up securely. Never expose private keys or unencrypted keystores.

Final Thoughts

Building and managing an Ethereum private chain unlocks hands-on learning for developers diving into Web3 technologies. From configuring genesis blocks to executing transactions and connecting nodes, each step builds deeper understanding of decentralized systems.

As you advance, consider integrating tools like Truffle, Hardhat, or MetaMask for enhanced development workflows.

👉 Explore how modern platforms streamline blockchain development and deployment.