kaspad/domain/consensus/datastructures/finalitystore/finality_store.go

package finalitystore

import (
	"github.com/kaspanet/kaspad/domain/consensus/database"
	"github.com/kaspanet/kaspad/domain/consensus/model"
	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
	"github.com/kaspanet/kaspad/domain/consensus/utils/lrucache"
)

var bucket = database.MakeBucket([]byte("finality-points"))

type finalityStore struct {
	cache *lrucache.LRUCache
}

// New instantiates a new FinalityStore
func New(cacheSize int, preallocate bool) model.FinalityStore {
	return &finalityStore{
		cache: lrucache.New(cacheSize, preallocate),
	}
}

func (fs *finalityStore) StageFinalityPoint(stagingArea *model.StagingArea, blockHash *externalapi.DomainHash, finalityPointHash *externalapi.DomainHash) {
	stagingShard := fs.stagingShard(stagingArea)

	stagingShard.toAdd[*blockHash] = finalityPointHash
}

func (fs *finalityStore) FinalityPoint(dbContext model.DBReader, stagingArea *model.StagingArea, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
	stagingShard := fs.stagingShard(stagingArea)

	if finalityPointHash, ok := stagingShard.toAdd[*blockHash]; ok {
		return finalityPointHash, nil
	}

	if finalityPointHash, ok := fs.cache.Get(blockHash); ok {
		return finalityPointHash.(*externalapi.DomainHash), nil
	}

	finalityPointHashBytes, err := dbContext.Get(fs.hashAsKey(blockHash))
	if err != nil {
		return nil, err
	}
	finalityPointHash, err := externalapi.NewDomainHashFromByteSlice(finalityPointHashBytes)
	if err != nil {
		return nil, err
	}

	fs.cache.Add(blockHash, finalityPointHash)
	return finalityPointHash, nil
}

func (fs *finalityStore) IsStaged(stagingArea *model.StagingArea) bool {
	return fs.stagingShard(stagingArea).isStaged()
}

func (fs *finalityStore) hashAsKey(hash *externalapi.DomainHash) model.DBKey {
	return bucket.Key(hash.ByteSlice())
}