Transaction Mempool and Efficient Tx Encoding

Synchronization of data

We'd implemented blockchain data structure but we have to look after the situation that whenever data is going to be fetched ow written from blockchain, it should be on latest blochchain state.

To take care of that, we implemented mutex,

core/blockchain.go

package core

import (
    "fmt"
    "sync"

    "github.com/sirupsen/logrus"
)

type Blockchain struct {
    // other properties
    lock sync.RWMutex
}

func (bc *Blockchain) GetHeader(height uint32) (*Header, error){

    if height > bc.Height(){
        return nil, fmt.Errorf("given height %d is too high", height)
    }
    bc.lock.Lock()
    defer bc.lock.Unlock()

    return bc.headers[height], nil
}

func (bc *Blockchain) addBlockWithoutValidation(b *Block) error {
    bc.lock.Lock()
    defer bc.lock.Unlock()
    bc.headers = append(bc.headers,b.Header)

    logrus.WithFields(logrus.Fields{
        "height": b.Height, 
        "hash": b.Hash(BlockHasher{}),
    }).Info("adding new block")

    return bc.store.Put(b)
}
func (bc *Blockchain) Height() uint32 {
    bc.lock.RLock()
    defer bc.lock.RUnlock()
    return uint32(len(bc.headers) - 1)
}

// other methods of blockchain

we updated only necessary functions.

Modifications

Before, we go ahead, we did some changes in previous code to decrease overhead of small changes while implementing important and useful code.

Generally we found this changes while coding future parts, but to make sequence of code in blog more understandable, we modified the code first.

Make Key in Public Key accessible to other code

crypto/keypair.go

type PublicKey struct {
    Key *ecdsa.PublicKey
}

type Signature struct {
    R,S *big.Int
}
//also, updated the code which has used Public key and Signature 
//with Capital letters starting Key in Public Key and R , S in Signature.

RandomTransaction and RandomBlock

core/transaction_test.go

added assert.Nil to make sure tx.sign runs successfully.

func randomTxWithSignature(t *testing.T) *Transaction { 
    privKey := crypto.GeneratePrivateKey()

    tx := &Transaction{
        Data: []byte("tx data"),
    }
    assert.Nil(t, tx.Sign(privKey));
    return tx;
}

due to changes in randomTxWithSignature, few other code should be update which use randomTxWithSignature function in their code,

core/block_test.go

func randomBlock(height uint32, prevBlockHash types.Hash) *Block {
    header := &Header{
        Version: 1,
        PrevBlockHash: prevBlockHash,
        Timestamp: time.Now().UnixNano(),
        Height: height,
    }
    return NewBlock(header, []Transaction{})
}

func randomBlockWithSignature(t *testing.T, height uint32, prevBlockHash types.Hash) *Block {
    privKey := crypto.GeneratePrivateKey()

    b := randomBlock(height, prevBlockHash)
    tx := randomTxWithSignature(t)
    b.AddTransaction(tx)
    assert.Nil(t, b.Sign(privKey))

    return b
}

Encoding and Decoding of Transactions

In previous code, we left encoding and decoding part but now it's time to make it work so it can be useful in transaction pool implementation.

Interface Definitions:
- Encoder[T] and Decoder[T] are interfaces that define methods for encoding and decoding data of type T.
- Encode(T) error is a method that takes an object of type T and encodes it, returning an error if any issue occurs.
- Decode(T) error is a method that takes an empty object of type T, decodes data into it, and returns an error if any issue occurs.
GobTxEncoder:
- GobTxEncoder is a struct that implements the Encoder interface for transactions using the Gob encoding format.
- It has a writer (w) where the encoded data will be written.
- NewGobTxEncoder(w io.Writer) is a constructor that initializes a new GobTxEncoder with a specified writer.
- Encode(tx *Transaction) error encodes a transaction using Gob and writes the encoded data to the specified writer.
GobTxDecoder:
- GobTxDecoder is a struct that implements the Decoder interface for transactions using the Gob encoding format.
- It has a reader (r) from which the encoded data will be read.
- NewGobTxDecoder(r io.Reader) is a constructor that initializes a new GobTxDecoder with a specified reader.
- Decode(tx *Transaction) error decodes data from the specified reader using Gob and populates the provided transaction object.

core/encoding.go

package core

import (
    "crypto/elliptic"
    "encoding/gob"
    "io"
)

type Encoder[T any] interface{
    Encode(T) error
}

type Decoder[T any] interface{
    Decode(T) error
}

type GobTxEncoder struct {
    w io.Writer
}

func NewGobTxEncoder(w io.Writer) *GobTxEncoder {
    gob.Register(elliptic.P256())
    return &GobTxEncoder{
        w : w,
    }
}

func (e *GobTxEncoder) Encode(tx *Transaction) error {
    return gob.NewEncoder(e.w).Encode(tx)
}

type GobTxDecoder struct {
    r io.Reader
}

func NewGobTxDecoder(r io.Reader) *GobTxDecoder {
    gob.Register(elliptic.P256())
    return &GobTxDecoder{
        r : r,
    }
}

func (d *GobTxDecoder) Decode(tx *Transaction) error {
    return gob.NewDecoder(d.r).Decode(tx)
}

As we've changed Encoder and Decoder interface, we've to also update affected portion of code as well as use code.

core/block.go

func (b *Block) Encode(enc Encoder[*Block]) error{
    return enc.Encode(b)
}
func (b *Block) Decode(dec Decoder[*Block]) error{
    return dec.Decode(b)
}

core/transactions

func (t *Transaction) Encode(enc Encoder[*Transaction]) error{
    return enc.Encode(t)
}
func (t *Transaction) Decode(dec Decoder[*Transaction]) error{
    return dec.Decode(t)
}

Testing of Transaction encoding and decoding,

core/transaction_test.go

func TestEncodeDecodeTransact(t *testing.T){
    tx := randomTxWithSignature(t)
    buf := &bytes.Buffer{}
    assert.Nil(t, tx.Encode(NewGobTxEncoder(buf)))

    txDecoded := new(Transaction)
    assert.Nil(t, txDecoded.Decode(NewGobTxDecoder(buf)))
    assert.Equal(t, tx, txDecoded)
}

make test

It worked!!

Transaction Hashing and First Seen

Hasher : For hashing the transaction, it accepts hasher of interface Hasher[*Transaction] .

firstSeen : firstSeen for transaction mempool purposes, it denotes the value of appearance of particular transaction in local node's tx pool. It'll be required in transaction pool code.

firstSeen and SetFirstSeen are getter and setter function of that transaction

core/transaction.go

type Transaction struct {
// other
    firstSeen int64
}

func (t *Transaction) Hash(hasher Hasher[*Transaction]) types.Hash {
    if t.hash.IsZero() {
        t.hash = hasher.Hash(t)
    }
    return t.hash
}

func NewTransaction(data []byte) *Transaction {
    return &Transaction{
        Data: data,
    }
}

func (t *Transaction) SetFirstSeen(val int64) {
    t.firstSeen = val;
}

func (t *Transaction) FirstSeen() int64 {
    return t.firstSeen;
}
//other remaining functions

core/hasher.go


type TxHasher struct{}

func (TxHasher) Hash(tx *Transaction) types.Hash {
    return types.Hash(sha256.Sum256(tx.Data))
}