Block store

go.mod

@@ -3,19 +3,20 @@ module github.com/lazyledger/optimint
 go 1.15
 
 require (
-	github.com/fortytw2/leaktest v1.3.0
+	github.com/dgraph-io/badger/v3 v3.2011.1
 	github.com/go-kit/kit v0.10.0
 	github.com/gogo/protobuf v1.3.2
 	github.com/ipfs/go-log v1.0.4
 	github.com/lazyledger/lazyledger-core v0.0.0-20210219190522-0eccfb24e2aa
 	github.com/libp2p/go-libp2p v0.13.0
 	github.com/libp2p/go-libp2p-core v0.8.5
-	github.com/libp2p/go-libp2p-crypto v0.1.0
 	github.com/libp2p/go-libp2p-discovery v0.5.0
 	github.com/libp2p/go-libp2p-kad-dht v0.11.1
 	github.com/libp2p/go-libp2p-pubsub v0.4.1
+	github.com/minio/sha256-simd v0.1.1
 	github.com/multiformats/go-multiaddr v0.3.1
 	github.com/prometheus/client_golang v1.8.0
 	github.com/stretchr/testify v1.7.0
 	go.uber.org/multierr v1.6.0
+	golang.org/x/crypto v0.0.0-20210415154028-4f45737414dc // indirect
 )

node/node.go

@@ -17,6 +17,7 @@ import (
 	"github.com/lazyledger/optimint/config"
 	"github.com/lazyledger/optimint/mempool"
 	"github.com/lazyledger/optimint/p2p"
+	"github.com/lazyledger/optimint/store"
 )
 
 type Node struct {
@@ -34,6 +35,8 @@ type Node struct {
 	mempoolIDs *mempoolIDs
 	incomingTxCh chan *p2p.Tx
 
+	BlockStore store.BlockStore
+
 	// keep context here only because of API compatibility
 	// - it's used in `OnStart` (defined in service.Service interface)
 	ctx context.Context
@@ -68,6 +71,7 @@ func NewNode(ctx context.Context, conf config.NodeConfig, nodeKey crypto.PrivKey
  Mempool: mp,
  mempoolIDs: newMempoolIDs(),
  incomingTxCh: make(chan *p2p.Tx),
+ BlockStore: store.NewBlockStore(),
  ctx: ctx,
 	}
 	node.BaseService = *service.NewBaseService(logger, "Node", node)

rpcclient/local.go

@@ -293,8 +293,33 @@ func (l *Local) TxSearch(ctx context.Context, query string, prove bool, page, pe
 }
 
 func (l *Local) Status(ctx context.Context) (*ctypes.ResultStatus, error) {
-	// needs block store, P2P layer
-	panic("Status - not implemented!")
+	latest, err := l.node.BlockStore.LoadBlock(l.node.BlockStore.Height())
+	if err != nil {
+ // TODO(tzdybal): extract error
+ return nil, fmt.Errorf("failed to find latest block: %w", err)
+	}
+
+	latestBlockHash := latest.Header.DataHash
+	latestAppHash := latest.Header.AppHash
+	latestHeight := latest.Header.Height
+	latestBlockTimeNano := latest.Header.Time
+
+	result := &ctypes.ResultStatus{
+ // TODO(tzdybal): NodeInfo, ValidatorInfo
+ SyncInfo: ctypes.SyncInfo{
+ LatestBlockHash: latestBlockHash[:],
+ LatestAppHash: latestAppHash[:],
+ LatestBlockHeight: int64(latestHeight),
+ LatestBlockTime: time.Unix(0, int64(latestBlockTimeNano)),
+ // TODO(tzdybal): add missing fields
+ //EarliestBlockHash: earliestBlockHash,
+ //EarliestAppHash: earliestAppHash,
+ //EarliestBlockHeight: earliestBlockHeight,
+ //EarliestBlockTime: time.Unix(0, earliestBlockTimeNano),
+ //CatchingUp: env.ConsensusReactor.WaitSync(),
+ },
+	}
+	return result, nil
 }
 
 func (l *Local) BroadcastEvidence(ctx context.Context, evidence types.Evidence) (*ctypes.ResultBroadcastEvidence, error) {

store/badger.go

@@ -0,0 +1,39 @@
+package store
+
+import "github.com/dgraph-io/badger/v3"
+
+var _ KVStore = &BadgerKV{}
+
+type BadgerKV struct {
+	db *badger.DB
+}
+
+func (b *BadgerKV) Get(key []byte) ([]byte, error) {
+	txn := b.db.NewTransaction(false)
+	defer txn.Discard()
+	item, err := txn.Get(key)
+	if err != nil {
+ return nil, err
+	}
+	return item.ValueCopy(nil)
+}
+
+func (b *BadgerKV) Set(key []byte, value []byte) error {
+	txn := b.db.NewTransaction(true)
+	err := txn.Set(key, value)
+	if err != nil {
+ txn.Discard()
+ return err
+	}
+	return txn.Commit()
+}
+
+func (b *BadgerKV) Delete(key []byte) error {
+	txn := b.db.NewTransaction(true)
+	err := txn.Delete(key)
+	if err != nil {
+ txn.Discard()
+ return err
+	}
+	return txn.Commit()
+}

store/blockstore.go

@@ -0,0 +1,121 @@
+package store
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/gob"
+	"sync"
+
+	"github.com/lazyledger/optimint/types"
+	"github.com/minio/sha256-simd"
+	"go.uber.org/multierr"
+)
+
+var (
+	blockPrefix = [1]byte{1}
+	indexPrefix = [1]byte{2}
+)
+
+type DefaultBlockStore struct {
+	db KVStore
+
+	height uint64
+
+	// mtx protects height
+	mtx sync.RWMutex
+}
+
+var _ BlockStore = &DefaultBlockStore{}
+
+func NewBlockStore() BlockStore {
+	return &DefaultBlockStore{db: NewInMemoryKVStore()}
+}
+
+func (bs *DefaultBlockStore) Height() uint64 {
+	bs.mtx.RLock()
+	defer bs.mtx.RUnlock()
+	return bs.height
+}
+
+func (bs *DefaultBlockStore) SaveBlock(block *types.Block) error {
+	// TODO(tzdybal): proper serialization & hashing
+	hash, err := getHash(block)
+	if err != nil {
+ return err
+	}
+	key := append(blockPrefix[:], hash[:]...)
+
+	height := make([]byte, 8)
+	binary.LittleEndian.PutUint64(height, block.Header.Height)
+	ikey := append(indexPrefix[:], height[:]...)
+
+	var value bytes.Buffer
+	enc := gob.NewEncoder(&value)
+	err = enc.Encode(block)
+	if err != nil {
+ return err
+	}
+
+	bs.mtx.Lock()
+	defer bs.mtx.Unlock()
+	// TODO(tzdybal): use transaction for consistency of DB
+	err = multierr.Append(err, bs.db.Set(key, value.Bytes()))
+	err = multierr.Append(err, bs.db.Set(ikey, hash[:]))
+
+	if block.Header.Height > bs.height {
+ bs.height = block.Header.Height
+	}
+
+	return err
+}
+
+// TODO(tzdybal): what is more common access pattern? by height or by hash?
+// currently, we're indexing height->hash, and store blocks by hash, but we might as well store by height
+// and index hash->height
+func (bs *DefaultBlockStore) LoadBlock(height uint64) (*types.Block, error) {
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, height)
+	ikey := append(indexPrefix[:], buf[:]...)
+
+	hash, err := bs.db.Get(ikey)
+
+	if err != nil {
+ return nil, err
+	}
+
+	// TODO(tzdybal): any better way to convert slice to array?
+	var h [32]byte
+	copy(h[:], hash)
+	return bs.LoadBlockByHash(h)
+}
+
+func (bs *DefaultBlockStore) LoadBlockByHash(hash [32]byte) (*types.Block, error) {
+	key := append(blockPrefix[:], hash[:]...)
+
+	blockData, err := bs.db.Get(key)
+
+	if err != nil {
+ return nil, err
+	}
+
+	dec := gob.NewDecoder(bytes.NewReader(blockData))
+	var block types.Block
+	err = dec.Decode(&block)
+	if err != nil {
+ return nil, err
+	}
+
+	return &block, nil
+}
+
+// TODO(tzdybal): replace with proper hashing mechanism
+func getHash(block *types.Block) ([32]byte, error) {
+	var header bytes.Buffer
+	enc := gob.NewEncoder(&header)
+	err := enc.Encode(block.Header)
+	if err != nil {
+ return [32]byte{}, err
+	}
+
+	return sha256.Sum256(header.Bytes()), nil
+}