Creating a Blockchain: Part 1 — Transport layer

Transport layer

Project setup

ProjectX is the name of our project

We’ll set up the whole architecture here and will change it as per requirements. So, As of now, we will create a Makefile in the root directory(ProjectX) for running scripts

Makefile

build:
    go build -o ./bin/projectx
run: build 
    ./bin/projectx
test: 
    go test -v ./...

File and directory structure looks like this,

We are focusing on a transport layer, which will handle the node connections in the network

Creating network module

go mod network

Transport layer structure

Creating a Transport Interface with needed properties, which will help to derive further networks
Transport interface contains 4 methods:

1. Consume: returns RPC channel (for internal use)
2. Connect: to connect 1 peer to another
3. SendMessage: message to another peer using RPC channel
4. Addr: returns address

network/transport.go

package network

type NetAddr string
type RPC struct {
    From    NetAddr
    Payload []byte
}
type Transport interface {
    Consume() <-chan RPC
    Connect(Transport) error
    SendMessage(NetAddr, []byte) error
    Addr() NetAddr
}

Local transport implementation

Implementing local_transport network,

network/local_transport.go

package network

import (
    "fmt"
    "sync"
)

type LocalTransport struct {
    addr      NetAddr
    consumeCh chan RPC
    lock      sync.RWMutex
    peers     map[NetAddr]*LocalTransport
}

func NewLocalTransport(addr NetAddr) Transport {
    return &LocalTransport{
        addr:      addr,
        consumeCh: make(chan RPC, 1024),
        peers:     make(map[NetAddr]*LocalTransport),
    }
}

Defining needed methods for LocalTransport to implement Transport interface

func (t *LocalTransport) Consume() <-chan RPC {
    return t.consumeCh
}

func (t *LocalTransport) Connect(tr Transport) error {
    t.lock.Lock()
    defer t.lock.Unlock()
    t.peers[tr.Addr()] = tr.(*LocalTransport)
    return nil
}

func (t *LocalTransport) SendMessage(to NetAddr, message []byte) error {
    t.lock.RLock()
    defer t.lock.RUnlock()
    peer, ok := t.peers[to]
    if !ok {
        return fmt.Errorf("%v failed to send message to %v", t.addr, to)
    }
    peer.consumeCh <- RPC{
        From:    t.addr,
        Payload: message,
    }
    return nil
}

func (t *LocalTransport) Addr() NetAddr {
    return t.addr
}

Test transport connection

To check, whether it’s running or not, we are coding the test file

network/local_transport_test.go

package network

import (
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestConnect(t *testing.T) {
    tra := NewLocalTransport("A").(*LocalTransport)
    trb := NewLocalTransport("B").(*LocalTransport)
    tra.Connect(trb)
    trb.Connect(tra)
    assert.Equal(t, tra.peers[trb.addr], trb)
    assert.Equal(t, trb.peers[tra.addr], tra)
}

func TestSendMessage(t *testing.T) {
    tra := NewLocalTransport("A").(*LocalTransport)
    trb := NewLocalTransport("B").(*LocalTransport)
    tra.Connect(trb)
    trb.Connect(tra)
    message := []byte("hello sid!!")
    assert.Nil(t, tra.SendMessage(trb.addr, message))
    rpc := <-trb.Consume()
    assert.Equal(t, rpc.Payload, message)
    assert.Equal(t, rpc.From, tra.addr)
}

run it by,

make test

Server and Logs

Creating Server to contain multiple transports and which also handles other server level activities as well.

Server methods:

1. NewServer: creates server
2. Start: it starts all server service and initialize all transports by calling initTransport method and logs the all RPC messages
3. initTransport: It pipelines all transport layer RPC messages to server level channel

network/server.go

package network

import (
    "fmt"
    "time"
)

type ServerOpts struct {
    Transports []Transport
}

type Server struct {
    ServerOpts
    rpcChan  chan RPC
    quitChan chan struct{}
}

func NewServer(opts ServerOpts) *Server {
    return &Server{
        ServerOpts: opts,
        rpcChan:    make(chan RPC),
        quitChan:   make(chan struct{}, 1),
    }
}

func (s *Server) Start() {
    s.initTransports()
    ticker := time.NewTicker(5 * time.Second)
free:
    for {
        select {
        case rpc := <-s.rpcChan:
            fmt.Println(rpc)
        case <-s.quitChan:
            break free
        case <-ticker.C:
            fmt.Println("Every 5 seconds")
        }
    }
    fmt.Println("Server shut down")
}

func (s *Server) initTransports() {
    for _, tr := range s.Transports {
        go func(tr Transport) {
            for rpc := range tr.Consume() {
                s.rpcChan <- rpc
            }
        }(tr)
    }
}

Send Message (p2p)

Testing all at once from main package,

main.go

package main

import (
    "ProjectX/network"
    "fmt"
    "time"
)

func main() {
    trLocal := network.NewLocalTransport("LOCAL")
    trRemote := network.NewLocalTransport("REMOTE")
    trLocal.Connect(trRemote)
    trRemote.Connect(trLocal)
    go func() {
        for {
            msg := []byte("Hello Local")
            trRemote.SendMessage(trLocal.Addr(), msg)
            time.Sleep(1 * time.Second)
        }
    }()
    opts := network.ServerOpts{
        Transports: []network.Transport{trLocal},
    }
    s := network.NewServer(opts)
    s.Start()
}

Expected output: remote transport send message to local transport every 1 second which will be logged by server, also it will log reminder at every 5 seconds

and here we go,

make run

As expected!!!😉

The following blog post will explore the code related to blocks and transactions.✨

In this blog series, I’ll be sharing code snippets related to blockchain architecture. While the code will be available on my GitHub, I want to highlight that the entire architecture isn’t solely my own. I’m learning as I go, drawing inspiration and knowledge from various sources, including a helpful YouTube playlist that has contributed to my learning process.