Build a Simple Blockchain in Go: Step‑by‑Step Guide with Code

Introduction

As blockchain technology matures, projects like Bitcoin and Ethereum attract attention, and many developers choose Go for its efficiency and simplicity. This guide shows how to build a foundational blockchain framework in Go and discusses related techniques.

Blockchain Basic Concepts

A blockchain is a decentralized distributed database where data is stored in blocks linked by cryptographic hashes, ensuring security and immutability. Each block contains transaction data and the hash of the previous block, forming an ever‑growing chain widely used in cryptocurrencies and beyond.

Building a Blockchain with Go

Install Go

Download the Go toolchain for your OS from the official site, install it, and verify with go version.

Create the Block Structure

type Block struct {
    Index     int
    Timestamp string
    Data      string
    PrevHash  string
    Hash      string
}

This struct stores the block index, timestamp, transaction data, previous block hash, and its own hash.

Implement the Blockchain

type Blockchain struct {
    Blocks []*Block
}

Methods can be added to append new blocks, compute hashes, and verify integrity.

Calculate Block Hash

import (
    "crypto/sha256"
    "encoding/hex"
)

func calculateHash(block *Block) string {
    record := string(block.Index) + block.Timestamp + block.Data + block.PrevHash
    h := sha256.New()
    h.Write([]byte(record))
    hashed := h.Sum(nil)
    return hex.EncodeToString(hashed)
}

This function returns the SHA‑256 hash of a block’s contents.

Add a New Block

func (bc *Blockchain) addBlock(data string) {
    prevBlock := bc.Blocks[len(bc.Blocks)-1]
    newBlock := &Block{
        Index:     prevBlock.Index + 1,
        Timestamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
    }
    newBlock.Hash = calculateHash(newBlock)
    bc.Blocks = append(bc.Blocks, newBlock)
}

The method creates a new block based on the last block and appends it to the chain.

Validate the Chain

func (bc *Blockchain) isChainValid() bool {
    for i := 1; i < len(bc.Blocks); i++ {
        currentBlock := bc.Blocks[i]
        prevBlock := bc.Blocks[i-1]
        if currentBlock.Hash != calculateHash(currentBlock) {
            return false
        }
        if currentBlock.PrevHash != prevBlock.Hash {
            return false
        }
    }
    return true
}

This routine checks each block’s hash and its link to the previous block.

Case Studies

Case 1: Simple Cryptocurrency

Extend the basic structures with wallets, transaction verification, and signatures to create a minimal cryptocurrency.

Case 2: Supply‑Chain Management System

Leverage blockchain’s immutability and transparency, combined with smart‑contract concepts, to build a Go‑based supply‑chain platform for secure data sharing among participants.

Case 3: Digital Asset Trading Platform

Use Go’s performance and blockchain’s distributed ledger to develop a platform for secure trading and settlement of digital assets, ensuring transparent and traceable transaction records.

Conclusion

The guide covered defining block structures, implementing a blockchain, computing hashes, adding blocks, and validating the chain, followed by three practical applications. Readers are encouraged to explore deeper blockchain details and build more sophisticated systems.