feat: implementing pip-15

go.mod

@@ -3,6 +3,7 @@ module github.com/pactus-project/pactus
 go 1.21
 
 require (
+	github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4
 	github.com/fxamacker/cbor/v2 v2.5.0
 	github.com/google/uuid v1.4.0
 	github.com/gorilla/handlers v1.5.1

go.sum

@@ -59,6 +59,8 @@ github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDD
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg=
+github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds=
 github.com/elastic/gosigar v0.12.0/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 github.com/elastic/gosigar v0.14.2 h1:Dg80n8cr90OZ7x+bAax/QjoW/XqTI11RmA79ZwIm9/4=
 github.com/elastic/gosigar v0.14.2/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=

node/node.go

@@ -61,7 +61,8 @@ func NewNode(genDoc *genesis.Genesis, conf *config.Config,
 	txPool := txpool.NewTxPool(conf.TxPool, messageCh)
 
 	// TODO implement dequeue for recent transaction
-	str, err := store.NewStore(conf.Store)
+	str, err := store.NewStore(conf.Store,
+		genDoc.Params().TransactionToLiveInterval, genDoc.Params().SortitionInterval)
 	if err != nil {
 		return nil, err
 	}

sandbox/sandbox.go

@@ -277,18 +277,14 @@ func (sb *sandbox) PowerDelta() int64 {
 
 // VerifyProof verifies proof of a sortition transaction.
 func (sb *sandbox) VerifyProof(blockHeight uint32, proof sortition.Proof, val *validator.Validator) bool {
-	committedBlock, err := sb.store.Block(blockHeight)
-	if err != nil {
-		return false
-	}
-	// TODO: improvement:
-	// We can get the sortition seed without parsing the block
-	blk, err := committedBlock.ToBlock()
-	if err != nil {
+	sb.lk.RLock()
+	defer sb.lk.RUnlock()
+
+	seed := sb.store.SortitionSeed(blockHeight, sb.height+1)
+	if seed == nil {
 		return false
 	}
-	seed := blk.Header().SortitionSeed()
-	return sortition.VerifyProof(seed, proof, val.PublicKey(), sb.totalPower, val.Power())
+	return sortition.VerifyProof(*seed, proof, val.PublicKey(), sb.totalPower, val.Power())
 }
 
 func (sb *sandbox) CommitTransaction(trx *tx.Tx) {

store/account.go

@@ -1,73 +1,96 @@
 package store
 
 import (
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/pactus-project/pactus/crypto"
 	"github.com/pactus-project/pactus/types/account"
 	"github.com/pactus-project/pactus/util/logger"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
+const (
+	accLruCacheSize = 1024
+)
+
 type accountStore struct {
-	db         *leveldb.DB
-	addressMap map[crypto.Address]*account.Account
-	total      int32
+	db        *leveldb.DB
+	addrCache *lru.Cache[crypto.Address, *account.Account]
+	total     int32
 }
 
 func accountKey(addr crypto.Address) []byte { return append(accountPrefix, addr.Bytes()...) }
 
 func newAccountStore(db *leveldb.DB) *accountStore {
 	total := int32(0)
-	numberMap := make(map[int32]*account.Account)
-	addressMap := make(map[crypto.Address]*account.Account)
+	addrLruCache, err := lru.New[crypto.Address, *account.Account](accLruCacheSize)
+	if err != nil {
+		logger.Panic("unable to create new instance of lru cache", "error", err)
+	}
+
 	r := util.BytesPrefix(accountPrefix)
 	iter := db.NewIterator(r, nil)
 	for iter.Next() {
-		key := iter.Key()
-		value := iter.Value()
-
-		acc, err := account.FromBytes(value)
-		if err != nil {
-			logger.Panic("unable to decode account", "error", err)
-		}
-
-		var addr crypto.Address
-		copy(addr[:], key[1:])
-
-		numberMap[acc.Number()] = acc
-		addressMap[addr] = acc
 		total++
 	}
 	iter.Release()
 
 	return &accountStore{
-		db:         db,
-		total:      total,
-		addressMap: addressMap,
+		db:        db,
+		total:     total,
+		addrCache: addrLruCache,
 	}
 }
 
 func (as *accountStore) hasAccount(addr crypto.Address) bool {
-	_, ok := as.addressMap[addr]
+	ok := as.addrCache.Contains(addr)
+	if !ok {
+		ok = tryHas(as.db, accountKey(addr))
+	}
 	return ok
 }
 
 func (as *accountStore) account(addr crypto.Address) (*account.Account, error) {
-	acc, ok := as.addressMap[addr]
+	acc, ok := as.addrCache.Get(addr)
 	if ok {
 		return acc.Clone(), nil
 	}
 
-	return nil, ErrNotFound
+	rawData, err := tryGet(as.db, accountKey(addr))
+	if err != nil {
+		return nil, err
+	}
+
+	acc, err = account.FromBytes(rawData)
+	if err != nil {
+		return nil, err
+	}
+
+	as.addrCache.Add(addr, acc)
+	return acc, nil
 }
 
 func (as *accountStore) iterateAccounts(consumer func(crypto.Address, *account.Account) (stop bool)) {
-	for addr, acc := range as.addressMap {
+	r := util.BytesPrefix(accountPrefix)
+	iter := as.db.NewIterator(r, nil)
+	for iter.Next() {
+		key := iter.Key()
+		value := iter.Value()
+
+		acc, err := account.FromBytes(value)
+		if err != nil {
+			logger.Panic("unable to decode account", "error", err)
+		}
+
+		var addr crypto.Address
+		copy(addr[:], key[1:])
+
 		stopped := consumer(addr, acc.Clone())
 		if stopped {
 			return
 		}
 	}
+	iter.Release()
 }
 
 // This function takes ownership of the account pointer.
@@ -81,7 +104,7 @@ func (as *accountStore) updateAccount(batch *leveldb.Batch, addr crypto.Address,
 	if !as.hasAccount(addr) {
 		as.total++
 	}
-	as.addressMap[addr] = acc
+	as.addrCache.Add(addr, acc)
 
 	batch.Put(accountKey(addr), data)
 }

store/account_test.go

@@ -57,7 +57,7 @@ func TestAccountBatchSaving(t *testing.T) {
 
 	t.Run("Close and load db", func(t *testing.T) {
 		td.store.Close()
-		store, _ := NewStore(td.store.config)
+		store, _ := NewStore(td.store.config, 8640, 17)
 		assert.Equal(t, store.TotalAccounts(), total)
 	})
 }
@@ -93,7 +93,7 @@ func TestAccountByAddress(t *testing.T) {
 
 	t.Run("Reopen the store", func(t *testing.T) {
 		td.store.Close()
-		store, _ := NewStore(td.store.config)
+		store, _ := NewStore(td.store.config, 8640, 17)
 
 		acc, err := store.Account(lastAddr)
 		assert.NoError(t, err)
@@ -140,5 +140,7 @@ func TestAccountDeepCopy(t *testing.T) {
 
 	acc2, _ := td.store.Account(addr)
 	acc2.AddToBalance(1)
-	assert.NotEqual(t, td.store.accountStore.addressMap[addr].Hash(), acc2.Hash())
+
+	expectedAcc, _ := td.store.accountStore.addrCache.Get(addr)
+	assert.NotEqual(t, expectedAcc.Hash(), acc2.Hash())
 }

store/block.go

@@ -5,9 +5,11 @@ import (
 
 	"github.com/pactus-project/pactus/crypto"
 	"github.com/pactus-project/pactus/crypto/hash"
+	"github.com/pactus-project/pactus/sortition"
 	"github.com/pactus-project/pactus/types/block"
 	"github.com/pactus-project/pactus/util"
 	"github.com/pactus-project/pactus/util/encoding"
+	"github.com/pactus-project/pactus/util/linkedlist"
 	"github.com/pactus-project/pactus/util/logger"
 	"github.com/syndtr/goleveldb/leveldb"
 )
@@ -22,12 +24,16 @@ func blockHashKey(h hash.Hash) []byte {
 }
 
 type blockStore struct {
-	db *leveldb.DB
+	db                 *leveldb.DB
+	sortitionSeedCache *linkedlist.LinkedList[*sortition.VerifiableSeed]
+	sortitionInterval  uint32
 }
 
-func newBlockStore(db *leveldb.DB) *blockStore {
+func newBlockStore(db *leveldb.DB, sortitionInterval uint32) *blockStore {
 	return &blockStore{
-		db: db,
+		db:                 db,
+		sortitionSeedCache: linkedlist.New[*sortition.VerifiableSeed](),
+		sortitionInterval:  sortitionInterval,
 	}
 }
 
@@ -93,6 +99,9 @@ func (bs *blockStore) saveBlock(batch *leveldb.Batch, height uint32, blk *block.
 	batch.Put(blockKey, w.Bytes())
 	batch.Put(blockHashKey, util.Uint32ToSlice(height))
 
+	sortitionSeed := blk.Header().SortitionSeed()
+	bs.saveToCache(sortitionSeed)
+
 	return regs
 }
 
@@ -113,18 +122,27 @@ func (bs *blockStore) blockHeight(h hash.Hash) uint32 {
 	return util.SliceToUint32(data)
 }
 
-func (bs *blockStore) hasBlock(height uint32) bool {
-	has, err := bs.db.Has(blockKey(height), nil)
-	if err != nil {
-		return false
+func (bs *blockStore) sortitionSeed(blockHeight, currentHeight uint32) *sortition.VerifiableSeed {
+	index := currentHeight - blockHeight
+	if index > bs.sortitionInterval {
+		return nil
 	}
-	return has
+
+	index = uint32(bs.sortitionSeedCache.Length()) - index
+	return bs.sortitionSeedCache.Get(int(index))
+}
+
+func (bs *blockStore) hasBlock(height uint32) bool {
+	return tryHas(bs.db, blockKey(height))
 }
 
 func (bs *blockStore) hasPublicKey(addr crypto.Address) bool {
-	has, err := bs.db.Has(publicKeyKey(addr), nil)
-	if err != nil {
-		return false
+	return tryHas(bs.db, publicKeyKey(addr))
+}
+
+func (bs *blockStore) saveToCache(sortitionSeed sortition.VerifiableSeed) {
+	bs.sortitionSeedCache.InsertAtTail(&sortitionSeed)
+	if bs.sortitionSeedCache.Length() > int(bs.sortitionInterval) {
+		bs.sortitionSeedCache.DeleteAtHead()
 	}
-	return has
 }

store/interface.go

@@ -4,6 +4,7 @@ import (
 	"github.com/pactus-project/pactus/crypto"
 	"github.com/pactus-project/pactus/crypto/bls"
 	"github.com/pactus-project/pactus/crypto/hash"
+	"github.com/pactus-project/pactus/sortition"
 	"github.com/pactus-project/pactus/types/account"
 	"github.com/pactus-project/pactus/types/block"
 	"github.com/pactus-project/pactus/types/certificate"
@@ -81,6 +82,7 @@ type Reader interface {
 	Block(height uint32) (*CommittedBlock, error)
 	BlockHeight(h hash.Hash) uint32
 	BlockHash(height uint32) hash.Hash
+	SortitionSeed(currentHeight, height uint32) *sortition.VerifiableSeed
 	Transaction(id tx.ID) (*CommittedTx, error)
 	AnyRecentTransaction(id tx.ID) bool
 	PublicKey(addr crypto.Address) (*bls.PublicKey, error)

store/mock.go

@@ -6,6 +6,7 @@ import (
 	"github.com/pactus-project/pactus/crypto"
 	"github.com/pactus-project/pactus/crypto/bls"
 	"github.com/pactus-project/pactus/crypto/hash"
+	"github.com/pactus-project/pactus/sortition"
 	"github.com/pactus-project/pactus/types/account"
 	"github.com/pactus-project/pactus/types/block"
 	"github.com/pactus-project/pactus/types/certificate"
@@ -65,6 +66,11 @@ func (m *MockStore) BlockHeight(h hash.Hash) uint32 {
 	return 0
 }
 
+func (m *MockStore) SortitionSeed(_, _ uint32) *sortition.VerifiableSeed {
+	// TODO implement me
+	panic("implement me")
+}
+
 func (m *MockStore) PublicKey(addr crypto.Address) (*bls.PublicKey, error) {
 	for _, block := range m.Blocks {
 		for _, trx := range block.Transactions() {