DEV Community: Victor Paul Arony

Building a Basic Blockchain Wallet in Go

Victor Paul Arony — Tue, 05 Nov 2024 08:33:52 +0000

## Exploring Basic Wallet Implementation in Golang

Introduction This document aims to help those who are new to blockchain wallet creatinon process become familiar with the basic wallet implementation using Go language. If you use it in combination with the content of this document, you will be able to create your wallet from scratch and understand the underlying technologies better. The wallet stores publick and private keys and interacts with various blockchain networks that allow the users to send or receive digital currencies or tokens within the network. The wallet doesn’t store the coins themselves but keeps track of balances of the addresses.

Key Features of the Basic Wallet:

Generate Keys: The wallet generates the public and private keys using cryptographic algorithms i.e sha256.
Transaction Management: It allows users to create and manage transactions.
Balance Tracking: The wallet helps users to track their balance based on transactions they have done.

Getting Started

Key Components of the Wallet

Wallet and Address Structures Create a sturct for the Wallet and the Address i.e the wallet is represented by a Wallet struct that contains a map of addresses. Each address is represented by the Address struct, which holds the private key, public key, and balance.

type Wallet struct {
    Adresses map[string]*Address
}
type Address struct {
    Privatekey *ecdsa.PrivateKey
    PublicKey  *ecdsa.PublicKey
    Balance    float64
}

Creating a New Wallet

The CreateWallet function initializes a new wallet instance.

func CreateWallet() *Wallet {
    return &Wallet{Adresses: make(map[string]*Address)}
}

Key Generation: Use the crypto/rand and ECDSA (Elliptic Curve Digital Signature Algorithm) packages to generate a secure random private key. The public key is derived from the private key using elliptic curve cryptography.

func (w *Wallet) CreateAddress() string {
    privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        log.Fatalln(privateKey)
    }

    publicKey := privateKey.PublicKey
    publicKeyBytes := append(publicKey.X.Bytes(), publicKey.Y.Bytes()...)
    add := sha256.Sum256(publicKeyBytes)
    address := hex.EncodeToString(add[:])

    w.Adresses[address] = &Address{
        Privatekey: privateKey,
        PublicKey:  &publicKey,
        Balance:    0,
    }
    return address
}

Transferring Funds

The Transfer method allows funds to be transferred between addresses. It first checks if both the sender and receiver addresses exist, then updates their balances according to the actions of either sending or receiving

func (w *Wallet) Transfer(to, from string, amount float64) error {
    addFrom, exist := w.Adresses[from]
    if !exist {
        log.Fatalln(from)
    }

    addTo, exist := w.Adresses[to]
    if !exist {
        log.Fatalln(to)
    }

    if addFrom.Balance < amount {
        return fmt.Errorf("insufficient balance")
    }

    addFrom.Balance -= amount
    addTo.Balance += amount
    return nil
}

Getting Balance

The GetBalance method allows the user to check the balance of a specific address, by retrieving the balance from the wallet.

func (w *Wallet) GetBalance(address string) (float64, error) {
    add, exist := w.Adresses[address]
    if !exist {
        return 0, fmt.Errorf("address not found")
    }
    return add.Balance, nil
}

Putting It All Together

The main function that demonstrate the wallet’s capabilities based on the functions and methods above:

func main() {
    wallet := CreateWallet()

    addr1 := wallet.CreateAddress()
    addr2 := wallet.CreateAddress()

    fmt.Printf("THE FIRST ADDRESS: %s \n", addr1)
    fmt.Printf("THE SECOND ADDRESS: %s\n", addr2)

    wallet.Adresses[addr1].Balance = 136

    fmt.Printf("INITIAL BALANCE FOR FIRST ADDRESS: %f\n", wallet.Adresses[addr1].Balance)
    fmt.Printf("INITIAL BALANCE FOR SECOND ADDRESS: %f\n", wallet.Adresses[addr2].Balance)

    err := wallet.Transfer(addr1, addr2, 25)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Printf("CURRENT BALANCE FOR FIRST ADDRESS: %f\n", wallet.Adresses[addr1].Balance)
    fmt.Printf("CURRENT BALANCE FOR SECOND ADDRESS: %f\n", wallet.Adresses[addr2].Balance)
}

Expected Output

When you run the program, you should see the initial balances for both addresses and the updated balances after the transfer:

go run main.go

Output

THE FIRST ADDRESS: <address_1> 
THE SECOND ADDRESS: <address_2>
INITIAL BALANCE FOR FIRST ADDRESS: 136.000000
INITIAL BALANCE FOR SECOND ADDRESS: 0.000000
CURRENT BALANCE FOR FIRST ADDRESS: 111.000000
CURRENT BALANCE FOR SECOND ADDRESS: 25.000000

Challenges and Lessons Learned

Throughout this project, I encountered several challenges, including understanding ECDSA key generation and managing balance updates accurately. This experience has reinforced the importance of security in blockchain applications and the necessity of robust error handling to ensure smooth operations.

Conclusion

Building a basic blockchain wallet in Go has been an enlightening experience that has deepened my understanding of blockchain fundamentals. This project serves as a foundation for more complex applications and showcases the capabilities of the Go programming language in blockchain development. I encourage you to explore and expand upon this code, perhaps integrating more features like transaction history or additional security measures. Happy coding!
full code at https://github.com/VictorPaulArony/Blockchain-golang/tree/main/basic-wallet

Introduction to Blockchain Development Using Go Language(golang)

Victor Paul Arony — Wed, 16 Oct 2024 19:18:28 +0000

Introduction

What is Blockchain?

A blockchain is a distributed, decentralized digital ledger that keeps track of transactions across several computers in a way that makes it impossible to change the data without also altering all further blocks and the network's consensus. It is essentially a mechanism for safely keeping data that is shared by numerous individuals, all of whom concur on the material's validity.

What Are Blocks?

A block on a blockchain is a digital piece of data that is composed of three primary components:

Data: The actual information that is being kept on file, such as transaction details like sender, recipient, amount, etc.
Hash: The block's unique identification, akin to a fingerprint. The hash of each block is produced using its data. The hash changes if the data does.
The previous block's hash: This creates a chain of blocks by connecting the current block to the block before it. Because changing one block would necessitate recalculating the hash for every following block, this linkage guarantees the security of the entire chain.

How Do Blocks Work?

In a blockchain, every block has multiple purposes:

Records Data: Blocks securely and verifiably hold data (such as contracts and transactions).
Preserve Order: By using hashes to link blocks in a particular order, each new block is guaranteed to have a reference to the one that came before it. This facilitates tracking down the data's history.
Assure Security: Each block's cryptographic hashing contributes to the chain's overall security. If one block's data were altered, the chain would be broken and participants would be made aware of the tampering.
Turn on Consensus: To make sure that only valid transactions are appended to the blockchain, the network must verify each new block (using consensus techniques like Proof of Work or Proof of Stake).

What Constitutes a Blockchain?

The blocks that make up a blockchain are joined in a particular order to form a chain. Each component of a blockchain is made up of the following:

Nodes: These are computers or other blockchain-connected devices that keep a copy of the blockchain and verify newly added blocks.
Transactions: The information being tracked (for example, Bitcoin payment information).
Consensus Mechanism: A procedure whereby every node (participant) in the blockchain concurs that new transactions and blocks are legitimate. Proof of Stake (PoS) and Proof of Work (PoW) are popular techniques.
Cryptography: To protect data and guarantee that blocks cannot be altered, blockchain employs cryptographic techniques (such as hashing and digital signatures).

Why Use Blockchain Technology?

Blockchain technology was created to address problems with record-keeping security, transparency, and trust. Conventional systems depend on a central authority, such as the government or a bank, which may be controlled, ineffective, or prone to mistakes. By enabling direct, secure, and verifiable communication between participants, blockchain removes the need for middlemen.

What Does Blockchain Do?

Provides Security: Since every block is linked to the previous one and secured with cryptographic hashes, it is very difficult to alter the data.
Enables Trust: Blockchain creates trust among parties that may not trust each other directly. Since everyone has access to the same data, they can verify it independently.
Facilitates Decentralized Transactions: Instead of relying on a central authority like a bank or government, blockchain allows people to interact directly and trust the data without intermediaries.
Creates Transparency: Everyone on the blockchain network has access to the same information, making it easier to track data, ensure accountability, and prevent fraud.

Why Do We Need Blockchains?

Trust Without Intermediaries: In traditional systems, intermediaries (like banks or payment processors) are needed to create trust between two parties. Blockchain removes this need, allowing for peer-to-peer transactions that are secure and transparent.
Secure and Immutable: Once data is added to the blockchain, it is almost impossible to change. This makes it ideal for storing critical information like financial transactions, medical records, or supply chain data.
Transparency and Accountability: Since everyone in the blockchain network has access to the same data, it’s easier to track and verify transactions or changes. This can improve trust in systems like voting, supply chains, or charity donations.
Efficiency: By eliminating intermediaries, blockchain can reduce transaction times and costs. This is especially useful in cross-border payments or industries with complex supply chains. In sectors like finance and supply chain, blockchain reduces the time and paperwork required for transactions.
Double Spending: In digital currencies, there is a risk of spending the same coin twice. Blockchain prevents this by keeping a shared ledger of all transactions.
Fraud: With blockchain, it's difficult for anyone to alter or falsify records without being detected.
High Costs: Blockchain can reduce the need for intermediaries, such as banks, by allowing people to transact directly with each other.

Why Develop Blockchain using Go (Golang)?

Google created the contemporary programming language Go (or Golang), which has become incredibly popular due to its ease of use, speed, and ability to handle concurrency. In terms of blockchain development, Go is among the greatest options for creating blockchain systems due to its many benefits. Go is frequently chosen for blockchain development for the following reasons:

Performance:
- Go is a compiled language, which results in faster execution times compared to interpreted languages.
- Efficient memory management and garbage collection enhance performance for resource-intensive applications like blockchain.
Concurrency Support:
- Go’s goroutines and channels simplify concurrent programming.
- This is crucial for blockchain, where multiple processes (transactions, block mining) can occur simultaneously.
Simplicity and Readability:
- Go's syntax is clean and straightforward, making it easier to read and maintain code.
- This reduces the learning curve for new developers and facilitates collaboration.
Strong Standard Library:
- Go has a robust standard library that simplifies tasks like networking, cryptography, and data handling.
- This is particularly useful for blockchain projects that require secure communication and data storage.
Cross-Platform Compatibility:
- Go binaries can be compiled for various operating systems (Windows, macOS, Linux) without modification.
- This makes deployment easier across different environments.
Strong Community and Ecosystem:
- An active community contributes to a growing ecosystem of libraries and frameworks.
- Projects like Hyperledger Fabric and Tendermint are built using Go, providing established frameworks for developers.

Cons of Go in Blockchain Development

Limited Libraries for Specific Use Cases:
- While Go has a strong standard library, it may lack specialized libraries for certain blockchain functionalities compared to languages like JavaScript or Python.
- Developers might need to build certain features from scratch.
Verbose Error Handling:
- Go's error handling can be seen as verbose and cumbersome compared to exceptions in other languages.
- This may lead to more boilerplate code, making it less elegant.
No Generics (Until Recently):
- Earlier versions of Go did not support generics, which could lead to code duplication and reduced flexibility.
- While generics were introduced in Go 1.18, some legacy projects may still face challenges.
Steeper Learning Curve for Advanced Features:
- While Go is simple, mastering concurrency models and advanced features can take time.
- Developers coming from different programming backgrounds may find it challenging initially.
Dependency Management:
- Although Go has improved its dependency management with Go Modules, some developers still find it less intuitive than package managers in other languages.
- This can complicate project setup and maintenance.
Less Adoption in Certain Blockchain Sectors:
- While Go is popular in certain blockchain projects, other languages like Solidity (for Ethereum) or JavaScript (for DApps) dominate specific areas.
- This may limit job opportunities or community support in certain niches.

Conclusion

Go stands out as a powerful language for blockchain development, offering numerous advantages, including performance, concurrency support, simplicity, and a strong standard library. Its cross-platform compatibility and vibrant community further enhance its appeal. However, developers should also consider the challenges, such as limited specialized libraries and verbosity in error handling.

Ultimately, Go’s strengths make it a solid choice for building scalable, efficient, and maintainable blockchain applications. As the blockchain ecosystem continues to grow, Go is likely to play an increasingly pivotal role in shaping its future. Whether you are a seasoned developer or new to the blockchain space, Go provides the tools and capabilities needed to succeed in this exciting field.

Simple Blockchain Implementation in Go

Victor Paul Arony — Sat, 12 Oct 2024 01:38:49 +0000

Overview

This project demonstrates a simplified version of a blockchain implemented in Go. It showcases the fundamental concepts of blockchain technology, including blocks, hashing, and proof of work (PoW). The implementation allows users to create a chain of blocks, each containing data, a timestamp, a reference to the previous block, and a cryptographic hash.

What is a Blockchain?
Key Components
How the Code Works
- Block Structure
- Blockchain Structure
- Creating the Genesis Block
- Adding Blocks
- Hashing and Validating Blocks
Running the Code
Conclusion

What is a Blockchain?

A blockchain is a decentralized digital ledger that records transactions across many computers in such a way that the registered transactions cannot be altered retroactively. Each block contains a list of transactions and is linked to the previous block, forming a chain. This structure makes blockchains resistant to modification and fraud.

Key Components

Block: The fundamental unit of a blockchain that contains data, a timestamp, a hash of the previous block, and its own hash.
Blockchain: A collection of blocks that are linked together in a specific order.
Hashing: The process of generating a fixed-size string of characters (a hash) from data, which serves as a unique identifier for that data.
Proof of Work (PoW): A consensus mechanism used to validate new blocks by requiring computational effort to generate a valid hash.

How the Code Works

Block Structure

The Block struct represents an individual block in the blockchain with the following fields:

ID: The unique identifier for the block.
Data: The information stored in the block.
TimeStamp: The time at which the block was created.
PreHash: The hash of the previous block in the chain.
Hash: The hash of the current block.
Nonce: A variable used in the PoW algorithm to find a valid hash.

Blockchain Structure

The Blockchain struct holds a slice of Block objects and a mutex for safe concurrent access:

type Blockchain struct {
    Blocks []Block
    mu     sync.Mutex
}

Creating the Genesis Block

The first block in the blockchain is called the "genesis block." It is created with a specific structure and serves as the foundation for the subsequent blocks:

func GenesisBlock() Block {
    genesis := Block{0, "Genesis Block", time.Now().String(), "", "", 0}
    genesis.Hash = genesis.CreateHash()
    return genesis
}

Adding Blocks

New blocks can be added to the blockchain using the AddBlock method. This method performs the following steps:

Locks the blockchain for safe concurrent access.
Creates a new block based on the previous block's hash.
Uses a nonce to find a valid hash that meets the PoW requirement (in this case, the hash must start with five zeros).
Validates the new block and appends it to the blockchain.

Hashing and Validating Blocks

The CreateHash method generates a hash for the block using SHA-256, and the IsValidHash function checks if the hash meets the criteria for PoW.

func (b *Block) CreateHash() string {
    res := strconv.Itoa(b.ID) + b.Data + b.TimeStamp + b.PreHash + b.Hash
    hash := sha256.Sum256([]byte(res))
    return hex.EncodeToString(hash[:])
}

Running the Code

To run the blockchain implementation, follow these steps:

Install Go: Ensure you have Go installed on your machine. If not, you can download it from golang.org.
Create a new Go file: Copy the provided code into a new file named main.go. Run the application:
Open a terminal and navigate to the directory containing your main.go file. Run the following command:

go run main.go

Expected output

Index: 0
Timestamp: 2024-10-12 04:07:46.335461011 +0300 EAT m=+0.000031916
Data: Genesis Block
PrevHash: 
Hash: ca1dd92e0c1abbdeb695d9f526bac0e8c2b23d2471eeb255098aaa5b1b36773b
Nonce: 0

Index: 1
Timestamp: 2024-10-12 04:07:46.335570999 +0300 EAT m=+0.000141904
Data: second block
PrevHash: ca1dd92e0c1abbdeb695d9f526bac0e8c2b23d2471eeb255098aaa5b1b36773b
Hash: 00000b52fe5bf3c81f1474d738dd8d299c35d2075987d80457780b8af18c1cb9
Nonce: 4401865

Index: 2
Timestamp: 2024-10-12 04:07:50.532612884 +0300 EAT m=+4.197183785
Data: third block
PrevHash: 00000b52fe5bf3c81f1474d738dd8d299c35d2075987d80457780b8af18c1cb9
Hash: 00000b5e6a6532387b11944a3b03bc62a46b340deb1844acbf0ba33100a4024c
Nonce: 143744

Index: 3
Timestamp: 2024-10-12 04:07:50.668087703 +0300 EAT m=+4.332658603
Data: forth block
PrevHash: 00000b5e6a6532387b11944a3b03bc62a46b340deb1844acbf0ba33100a4024c
Hash: 00000d179317e613a7fe14ca5cc2f5718709f747011a2eb5560754e5ee737593
Nonce: 148455

Index: 4
Timestamp: 2024-10-12 04:07:50.818969364 +0300 EAT m=+4.483540279
Data: fifth block
PrevHash: 00000d179317e613a7fe14ca5cc2f5718709f747011a2eb5560754e5ee737593
Hash: 0000015aeda3c490f10ffed0639fd39c9e570a8ad7208512a45372111304eecc
Nonce: 671069

Index: 5
Timestamp: 2024-10-12 04:07:51.492424149 +0300 EAT m=+5.156995064
Data: sixth block
PrevHash: 0000015aeda3c490f10ffed0639fd39c9e570a8ad7208512a45372111304eecc
Hash: 00000d5d3d9163702726ccbf967d2b99208c9f03b419788a826262e7a94b09ba
Nonce: 946880

Index: 6
Timestamp: 2024-10-12 04:07:52.478948177 +0300 EAT m=+6.143519089
Data: seventh block
PrevHash: 00000d5d3d9163702726ccbf967d2b99208c9f03b419788a826262e7a94b09ba
Hash: 00000c2bdb09d84493235c36058d4776fa35bafce141d4b095ab3af90fbcb10d
Nonce: 256130

Conclusion

This simple blockchain implementation in Go demonstrates the core principles of blockchain technology, including block creation, hashing, and proof of work. While this example is simplified, it provides a foundational understanding of how blockchains work and can be expanded with additional features such as transaction handling, network protocols, and consensus mechanisms.

full Code

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "log"
    "strconv"
    "sync"
    "time"
)

type Block struct {
    ID        int
    Data      string
    TimeStamp string
    PreHash   string
    Hash      string
    Nonce     int
}

type Blockchain struct {
    Blocks []Block
    mu     sync.Mutex
}

// function to create the hashing function
func (b *Block) CreateHash() string {
    res := strconv.Itoa(b.ID) + b.Data + b.TimeStamp + b.PreHash + b.Hash
    hash := sha256.Sum256([]byte(res))
    return hex.EncodeToString(hash[:])
}

// function to add a block for the blockchain
func (bc *Blockchain) AddBlock(data string) {
    bc.mu.Lock()
    defer bc.mu.Unlock()

    prevBlock := bc.Blocks[len(bc.Blocks)-1]
    newBlock := Block{
        ID:        prevBlock.ID + 1,
        Data:      data,
        TimeStamp: time.Now().String(),
        PreHash:   prevBlock.Hash,
    }

    for {
        newBlock.Hash = newBlock.CreateHash()
        if IsValidHash(newBlock.Hash) {
            break
        }
        newBlock.Nonce++
    }

    if bc.IsValidBlock(newBlock) {
        bc.Blocks = append(bc.Blocks, newBlock)
    } else {
        log.Fatalln("Invalid Block")
    }
}

// function to verify the PoW
func IsValidHash(hash string) bool {
    return hash[:5] == "00000"
}

// function to create genesis block
func GenesisBlock() Block {
    genesis := Block{0, "Genesis Block", time.Now().String(), "", "", 0}
    genesis.Hash = genesis.CreateHash()
    return genesis
}

// function to create a new blockchain
func CreateBlockchain() Blockchain {
    genesis := GenesisBlock()
    return Blockchain{Blocks: []Block{genesis}}
}

// function to verify the blocks
func (bc *Blockchain) IsValidBlock(block Block) bool {
    prevBlock := bc.Blocks[len(bc.Blocks)-1]
    if len(bc.Blocks) == 0 {
        return false
    }
    return prevBlock.Hash == block.PreHash
}

func main() {
    blockchain := CreateBlockchain()

    blockchain.AddBlock("second block")
    blockchain.AddBlock("third block")
    blockchain.AddBlock("forth block")
    blockchain.AddBlock("fifth block")
    blockchain.AddBlock("sixth block")
    blockchain.AddBlock("seventh block")

    for _, block := range blockchain.Blocks {
        fmt.Printf("Index: %d\n", block.ID)
        fmt.Printf("Timestamp: %s\n", block.TimeStamp)
        fmt.Printf("Data: %s\n", block.Data)
        fmt.Printf("PrevHash: %s\n", block.PreHash)
        fmt.Printf("Hash: %s\n", block.Hash)
        fmt.Printf("Nonce: %d\n", block.Nonce)
        fmt.Println()
    }
}

Simple Blockchain Implementation in Go

Victor Paul Arony — Wed, 17 Jul 2024 14:07:31 +0000

Simple Blockchain Implementation in Go

This documentation provides an overview and detailed explanation of a simple blockchain implementation in Go. The code is divided into sections for clarity and ease of understanding.

Introduction
Block Structure
Blockchain Structure
Hash Function
Creating the Genesis Block
Adding New Blocks
Main Function
Complete Code

Introduction

A blockchain is a series of blocks, each of which carries data and is connected to the ones before it by a cryptographic hash. The basic ideas of blockchain, such as block creation, hashing, and block linking, are illustrated by this implementation.

Block Structure

Each block in the blockchain has the following attributes:

ID: A unique identifier for the block.
TimeStamp: The time when the block was created.
Data: The data contained in the block.
PrevHash: The hash of the previous block.
Hash: The hash of the current block.

type Block struct {
    ID        int
    TimeStamp string
    Data      string
    PrevHash  string
    Hash      string
}

Blockchain Structure

The blockchain itself is a slice of blocks. It starts with a genesis block, and new blocks are added to it.

type Blockchain struct {
    blocks []Block
}

Hash Function

The CreateHash function generates a cryptographic hash for a block using its ID, timestamp, data, and previous hash. The MD5 algorithm is used for hashing in this example.

func CreateHash(b *Block) string {
    res := strconv.Itoa(b.ID) + b.TimeStamp + b.Data + b.PrevHash
    h := md5.New()
    h.Write([]byte(res))
    hashed := h.Sum(nil)
    return hex.EncodeToString(hashed)
}

Creating the Genesis Block

The genesis block is the first block in the blockchain and is created with predefined data. It does not have a previous hash.

func CreateGenesis() Block {
    genesis := Block{ID: 0, TimeStamp: time.Now().String(), Data: "Genesis Block"}
    genesis.Hash = CreateHash(&genesis)
    return genesis
}

Adding New Blocks

New blocks are added to the blockchain with the AddBlock method. Each new block contains data, the current timestamp, and the hash of the previous block.

func (bc *Blockchain) AddBlock(data string) {
    prevBlock := bc.blocks[len(bc.blocks)-1]
    newBlock := Block{
        ID:        prevBlock.ID + 1,
        TimeStamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
    }
    newBlock.Hash = CreateHash(&newBlock)
    bc.blocks = append(bc.blocks, newBlock)
}

Main Function

The main function initializes the blockchain with a genesis block and adds a few more blocks. It then prints the details of each block in the blockchain.

func main() {
    genesisBlock := CreateGenesis()
    blockchain := Blockchain{[]Block{genesisBlock}}

    blockchain.AddBlock("second block")
    blockchain.AddBlock("third block")
    blockchain.AddBlock("fourth block")

    for _, block := range blockchain.blocks {
        fmt.Printf("ID: %d\n", block.ID)
        fmt.Printf("TimeStamp: %s\n", block.TimeStamp)
        fmt.Printf("Data: %s\n", block.Data)
        fmt.Printf("Previous Hash: %s\n", block.PrevHash)
        fmt.Printf("Hash: %s\n", block.Hash)
    }
}

Complete Code

Here is the complete code for the simple blockchain implementation:

package main

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "strconv"
    "time"
)

type Block struct {
    ID        int
    TimeStamp string
    Data      string
    PrevHash  string
    Hash      string
}

type Blockchain struct {
    blocks []Block
}

func CreateHash(b *Block) string {
    res := strconv.Itoa(b.ID) + b.TimeStamp + b.Data + b.PrevHash
    h := md5.New()
    h.Write([]byte(res))
    hashed := h.Sum(nil)
    return hex.EncodeToString(hashed)
}

func CreateGenesis() Block {
    genesis := Block{ID: 0, TimeStamp: time.Now().String(), Data: "Genesis Block"}
    genesis.Hash = CreateHash(&genesis)
    return genesis
}

func (bc *Blockchain) AddBlock(data string) {
    prevBlock := bc.blocks[len(bc.blocks)-1]
    newBlock := Block{
        ID:        prevBlock.ID + 1,
        TimeStamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
    }
    newBlock.Hash = CreateHash(&newBlock)
    bc.blocks = append(bc.blocks, newBlock)
}

func main() {
    genesisBlock := CreateGenesis()
    blockchain := Blockchain{[]Block{genesisBlock}}

    blockchain.AddBlock("second block")
    blockchain.AddBlock("third block")
    blockchain.AddBlock("fourth block")

    for _, block := range blockchain.blocks {
        fmt.Printf("ID: %d\n", block.ID)
        fmt.Printf("TimeStamp: %s\n", block.TimeStamp)
        fmt.Printf("Data: %s\n", block.Data)
        fmt.Printf("Previous Hash: %s\n", block.PrevHash)
        fmt.Printf("Hash: %s\n", block.Hash)
    }
}

output

ID: 0   TimeStamp: 2024-07-17 16:48:14.299038516 +0300 EAT m=+0.000026802       Data: Genesis Block  Previous Hash:   Hash: 3849ac0e830963c34fe18b18ea3d945a 
ID: 1   TimeStamp: 2024-07-17 16:48:14.299127941 +0300 EAT m=+0.000116227       Data: second Block   Previous Hash: 3849ac0e830963c34fe18b18ea3d945a  Hash: fedb1d4405b0330e0e2049e69ccce0de 
ID: 2   TimeStamp: 2024-07-17 16:48:14.299135028 +0300 EAT m=+0.000123316       Data: third Block    Previous Hash: fedb1d4405b0330e0e2049e69ccce0de  Hash: dbcfa81389c07da02b9dbaa429d9eed1 
ID: 3   TimeStamp: 2024-07-17 16:48:14.299139949 +0300 EAT m=+0.000128236       Data: forth Block    Previous Hash: dbcfa81389c07da02b9dbaa429d9eed1  Hash: 62e57c727a2b48d23c28b1d6db08f85b

This documentation provides a detailed explanation of each part of the blockchain code, ensuring a clear understanding of how the implementation works.

DEV Community: Victor Paul Arony

Building a Basic Blockchain Wallet in Go

Key Features of the Basic Wallet:

Getting Started

Key Components of the Wallet

Challenges and Lessons Learned

Conclusion

Introduction to Blockchain Development Using Go Language(golang)

Introduction

What is Blockchain?

What Are Blocks?

How Do Blocks Work?

What Constitutes a Blockchain?

Why Use Blockchain Technology?

What Does Blockchain Do?

Why Do We Need Blockchains?

Why Develop Blockchain using Go (Golang)?

Cons of Go in Blockchain Development

Conclusion

Simple Blockchain Implementation in Go

Overview

Table of Contents

What is a Blockchain?

Key Components

How the Code Works

Block Structure

Blockchain Structure

Creating the Genesis Block

Adding Blocks

Hashing and Validating Blocks

Running the Code

Expected output

Conclusion

full Code

Simple Blockchain Implementation in Go

Simple Blockchain Implementation in Go

Table of Contents

Introduction

Block Structure

Blockchain Structure

Hash Function

Creating the Genesis Block

Adding New Blocks

Main Function

Complete Code

output