Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-03-30 15:08:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

[NOD-1475] Implement stage/discard/commit functionality for data structures (#962)

Browse Source 
* [NOD-1475] Add Stage, Discard, and Commit methods to all stores.

* [NOD-1475] Simplify interfaces for processes.

* [NOD-1475] Fix GHOSTDAGManager.

* [NOD-1475] Simplify ChooseSelectedParent.

* [NOD-1475] Remove errors from Stage functions.

* [NOD-1475] Add IsStaged to all data structures.

* [NOD-1475] Remove isDisqualified from CalculateConsensusStateChanges.

* [NOD-1475] Add dependency from ConsensusStateManager to BlockStatusStore.

* [NOD-1475] Fix a comment.

* [NOD-1475] Add ReachabilityReindexRoot to reachabilityDataStore.

* [NOD-1475] Fix a comment.

* [NOD-1475] Rename IsStaged to IsAnythingStaged.
This commit is contained in:
stasatdaglabs 2020-10-21 12:37:22 +03:00 committed by GitHub
parent 4c1f24da82
commit 45882343e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 282 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
domain/consensus/datastructures/acceptancedatastore/acceptancedatastore.go
View File

@ -14,9 +14,21 @@ func New() model.AcceptanceDataStore {
return &acceptanceDataStore{}
}
// Insert inserts the given acceptanceData for the given blockHash
func (ads *acceptanceDataStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, acceptanceData *model.BlockAcceptanceData) error {
return nil
// Stage stages the given acceptanceData for the given blockHash
func (ads *acceptanceDataStore) Stage(blockHash *externalapi.DomainHash, acceptanceData *model.BlockAcceptanceData) {
panic("implement me")
}
func (ads *acceptanceDataStore) IsStaged() bool {
panic("implement me")
}
func (ads *acceptanceDataStore) Discard() {
panic("implement me")
}
func (ads *acceptanceDataStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Get gets the acceptanceData associated with the given blockHash

18
domain/consensus/datastructures/blockrelationstore/blockrelationstore.go
View File

@ -14,9 +14,21 @@ func New() model.BlockRelationStore {
return &blockRelationStore{}
}
// Insert inserts the given blockRelationData for the given blockHash
func (brs *blockRelationStore) Update(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash) error {
return nil
// Stage stages the given blockRelationData for the given blockHash
func (brs *blockRelationStore) Stage(blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash) {
panic("implement me")
}
func (brs *blockRelationStore) IsStaged() bool {
panic("implement me")
}
func (brs *blockRelationStore) Discard() {
panic("implement me")
}
func (brs *blockRelationStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Get gets the blockRelationData associated with the given blockHash

18
domain/consensus/datastructures/blockstatusstore/blockstatusstore.go
View File

@ -14,9 +14,21 @@ func New() model.BlockStatusStore {
return &blockStatusStore{}
}
// Insert inserts the given blockStatus for the given blockHash
func (bss *blockStatusStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, blockStatus model.BlockStatus) error {
return nil
// Stage stages the given blockStatus for the given blockHash
func (bss *blockStatusStore) Stage(blockHash *externalapi.DomainHash, blockStatus model.BlockStatus) {
panic("implement me")
}
func (bss *blockStatusStore) IsStaged() bool {
panic("implement me")
}
func (bss *blockStatusStore) Discard() {
panic("implement me")
}
func (bss *blockStatusStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Get gets the blockStatus associated with the given blockHash

18
domain/consensus/datastructures/blockstore/blockstore.go
View File

@ -14,9 +14,21 @@ func New() model.BlockStore {
return &blockStore{}
}
// Insert inserts the given block for the given blockHash
func (bms *blockStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, msgBlock *externalapi.DomainBlock) error {
return nil
// Stage stages the given block for the given blockHash
func (bms *blockStore) Stage(blockHash *externalapi.DomainHash, block *externalapi.DomainBlock) {
panic("implement me")
}
func (bms *blockStore) IsStaged() bool {
panic("implement me")
}
func (bms *blockStore) Discard() {
panic("implement me")
}
func (bms *blockStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Block gets the block associated with the given blockHash

18
domain/consensus/datastructures/consensusstatestore/consensusstatestore.go
View File

@ -14,9 +14,21 @@ func New() model.ConsensusStateStore {
return &consensusStateStore{}
}
// Update updates the store with the given consensusStateChanges
func (css *consensusStateStore) Update(dbTx model.DBTxProxy, consensusStateChanges *model.ConsensusStateChanges) error {
return nil
// Stage stages the store with the given consensusStateChanges
func (css *consensusStateStore) Stage(consensusStateChanges *model.ConsensusStateChanges) {
panic("implement me")
}
func (css *consensusStateStore) IsStaged() bool {
panic("implement me")
}
func (css *consensusStateStore) Discard() {
panic("implement me")
}
func (css *consensusStateStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// UTXOByOutpoint gets the utxoEntry associated with the given outpoint

18
domain/consensus/datastructures/ghostdagdatastore/ghostdagdatastore.go
View File

@ -14,9 +14,21 @@ func New() model.GHOSTDAGDataStore {
return &ghostdagDataStore{}
}
// Insert inserts the given blockGHOSTDAGData for the given blockHash
func (gds *ghostdagDataStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, blockGHOSTDAGData *model.BlockGHOSTDAGData) error {
return nil
// Stage stages the given blockGHOSTDAGData for the given blockHash
func (gds *ghostdagDataStore) Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData *model.BlockGHOSTDAGData) {
panic("implement me")
}
func (gds *ghostdagDataStore) IsStaged() bool {
panic("implement me")
}
func (gds *ghostdagDataStore) Discard() {
panic("implement me")
}
func (gds *ghostdagDataStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Get gets the blockGHOSTDAGData associated with the given blockHash

18
domain/consensus/datastructures/multisetstore/multisetstore.go
View File

@ -14,9 +14,21 @@ func New() model.MultisetStore {
return &multisetStore{}
}
// Insert inserts the given multiset for the given blockHash
func (ms *multisetStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, multiset model.Multiset) error {
return nil
// Stage stages the given multiset for the given blockHash
func (ms *multisetStore) Stage(blockHash *externalapi.DomainHash, multiset model.Multiset) {
panic("implement me")
}
func (ms *multisetStore) IsStaged() bool {
panic("implement me")
}
func (ms *multisetStore) Discard() {
panic("implement me")
}
func (ms *multisetStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// Get gets the multiset associated with the given blockHash

18
domain/consensus/datastructures/pruningstore/pruningstore.go
View File

@ -14,9 +14,21 @@ func New() model.PruningStore {
return &pruningStore{}
}
// Update updates the pruning state
func (pps *pruningStore) Update(dbTx model.DBTxProxy, pruningPointBlockHash *externalapi.DomainHash, pruningPointUTXOSet model.ReadOnlyUTXOSet) error {
return nil
// Stage stages the pruning state
func (pps *pruningStore) Stage(pruningPointBlockHash *externalapi.DomainHash, pruningPointUTXOSet model.ReadOnlyUTXOSet) {
panic("implement me")
}
func (pps *pruningStore) IsStaged() bool {
panic("implement me")
}
func (pps *pruningStore) Discard() {
panic("implement me")
}
func (pps *pruningStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// PruningPoint gets the current pruning point

36
domain/consensus/datastructures/reachabilitydatastore/reachabilitydatastore.go
View File

@ -14,12 +14,36 @@ func New() model.ReachabilityDataStore {
return &reachabilityDataStore{}
}
// Insert inserts the given reachabilityData for the given blockHash
func (rds *reachabilityDataStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, reachabilityData *model.ReachabilityData) error {
return nil
// StageReachabilityData stages the given reachabilityData for the given blockHash
func (rds *reachabilityDataStore) StageReachabilityData(blockHash *externalapi.DomainHash, reachabilityData *model.ReachabilityData) {
panic("implement me")
}
// Get gets the reachabilityData associated with the given blockHash
func (rds *reachabilityDataStore) Get(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*model.ReachabilityData, error) {
return nil, nil
// StageReachabilityReindexRoot stages the given reachabilityReindexRoot
func (rds *reachabilityDataStore) StageReachabilityReindexRoot(reachabilityReindexRoot *externalapi.DomainHash) {
panic("implement me")
}
func (rds *reachabilityDataStore) IsAnythingStaged() bool {
panic("implement me")
}
func (rds *reachabilityDataStore) Discard() {
panic("implement me")
}
func (rds *reachabilityDataStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// ReachabilityData returns the reachabilityData associated with the given blockHash
func (rds *reachabilityDataStore) ReachabilityData(dbContext model.DBContextProxy,
blockHash *externalapi.DomainHash) (*model.ReachabilityData, error) {
panic("implement me")
}
// ReachabilityReindexRoot returns the current reachability reindex root
func (rds *reachabilityDataStore) ReachabilityReindexRoot(dbContext model.DBContextProxy) (*externalapi.DomainHash, error) {
panic("implement me")
}

18
domain/consensus/datastructures/utxodiffstore/utxodiffstore.go
View File

@ -14,9 +14,21 @@ func New() model.UTXODiffStore {
return &utxoDiffStore{}
}
// Insert inserts the given utxoDiff for the given blockHash
func (uds *utxoDiffStore) Insert(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash, utxoDiff *model.UTXODiff, utxoDiffChild *externalapi.DomainHash) error {
return nil
// Stage stages the given utxoDiff for the given blockHash
func (uds *utxoDiffStore) Stage(blockHash *externalapi.DomainHash, utxoDiff *model.UTXODiff, utxoDiffChild *externalapi.DomainHash) {
panic("implement me")
}
func (uds *utxoDiffStore) IsStaged() bool {
panic("implement me")
}
func (uds *utxoDiffStore) Discard() {
panic("implement me")
}
func (uds *utxoDiffStore) Commit(dbTx model.DBTxProxy) error {
panic("implement me")
}
// UTXODiff gets the utxoDiff associated with the given blockHash

3
domain/consensus/factory.go
View File

@ -78,7 +78,8 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
multisetStore,
blockStore,
ghostdagManager,
acceptanceManager)
acceptanceManager,
blockStatusStore)
pruningManager := pruningmanager.New(
dagTraversalManager,
pruningStore,

5
domain/consensus/model/interface_datastructures_acceptancedatastore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// AcceptanceDataStore represents a store of AcceptanceData
type AcceptanceDataStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, acceptanceData *BlockAcceptanceData) error
Stage(blockHash *externalapi.DomainHash, acceptanceData *BlockAcceptanceData)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*BlockAcceptanceData, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
}

5
domain/consensus/model/interface_datastructures_block.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// BlockStore represents a store of blocks
type BlockStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, block *externalapi.DomainBlock) error
Stage(blockHash *externalapi.DomainHash, block *externalapi.DomainBlock)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Block(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error)
Blocks(dbContext DBContextProxy, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlock, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error

5
domain/consensus/model/interface_datastructures_blockrelationstore.go
View File

@ -4,6 +4,9 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// BlockRelationStore represents a store of BlockRelations
type BlockRelationStore interface {
Update(dbTx DBTxProxy, blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash) error
Stage(blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*BlockRelations, error)
}

5
domain/consensus/model/interface_datastructures_blockstatusstore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// BlockStatusStore represents a store of BlockStatuses
type BlockStatusStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, blockStatus BlockStatus) error
Stage(blockHash *externalapi.DomainHash, blockStatus BlockStatus)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (BlockStatus, error)
Exists(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (bool, error)
}

5
domain/consensus/model/interface_datastructures_consensusstatestore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// ConsensusStateStore represents a store for the current consensus state
type ConsensusStateStore interface {
Update(dbTx DBTxProxy, consensusStateChanges *ConsensusStateChanges) error
Stage(consensusStateChanges *ConsensusStateChanges)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
UTXOByOutpoint(dbContext DBContextProxy, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error)
Tips(dbContext DBContextProxy) ([]*externalapi.DomainHash, error)
}

5
domain/consensus/model/interface_datastructures_ghostdagdatastore.go
View File

@ -4,6 +4,9 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// GHOSTDAGDataStore represents a store of BlockGHOSTDAGData
type GHOSTDAGDataStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, blockGHOSTDAGData *BlockGHOSTDAGData) error
Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData *BlockGHOSTDAGData)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*BlockGHOSTDAGData, error)
}

5
domain/consensus/model/interface_datastructures_multisetstore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// MultisetStore represents a store of Multisets
type MultisetStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, multiset Multiset) error
Stage(blockHash *externalapi.DomainHash, multiset Multiset)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (Multiset, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
}

5
domain/consensus/model/interface_datastructures_pruningstore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// PruningStore represents a store for the current pruning state
type PruningStore interface {
Update(dbTx DBTxProxy, pruningPointBlockHash *externalapi.DomainHash, pruningPointUTXOSet ReadOnlyUTXOSet) error
Stage(pruningPointBlockHash *externalapi.DomainHash, pruningPointUTXOSet ReadOnlyUTXOSet)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
PruningPoint(dbContext DBContextProxy) (*externalapi.DomainHash, error)
PruningPointSerializedUTXOSet(dbContext DBContextProxy) ([]byte, error)
}

9
domain/consensus/model/interface_datastructures_reachabilitydatastore.go
View File

@ -4,6 +4,11 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// ReachabilityDataStore represents a store of ReachabilityData
type ReachabilityDataStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, reachabilityData *ReachabilityData) error
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*ReachabilityData, error)
StageReachabilityData(blockHash *externalapi.DomainHash, reachabilityData *ReachabilityData)
StageReachabilityReindexRoot(reachabilityReindexRoot *externalapi.DomainHash)
IsAnythingStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
ReachabilityData(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*ReachabilityData, error)
ReachabilityReindexRoot(dbContext DBContextProxy) (*externalapi.DomainHash, error)
}

5
domain/consensus/model/interface_datastructures_utxodiffstore.go
View File

@ -4,7 +4,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// UTXODiffStore represents a store of UTXODiffs
type UTXODiffStore interface {
Insert(dbTx DBTxProxy, blockHash *externalapi.DomainHash, utxoDiff *UTXODiff, utxoDiffChild *externalapi.DomainHash) error
Stage(blockHash *externalapi.DomainHash, utxoDiff *UTXODiff, utxoDiffChild *externalapi.DomainHash)
IsStaged() bool
Discard()
Commit(dbTx DBTxProxy) error
UTXODiff(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*UTXODiff, error)
UTXODiffChild(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error

4
domain/consensus/model/interface_processes_acceptancemanager.go
View File

@ -1,7 +1,9 @@
package model
import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// AcceptanceManager manages transaction acceptance
// and related data
type AcceptanceManager interface {
CalculateAcceptanceDataAndUTXOMultiset(blockGHOSTDAGData *BlockGHOSTDAGData) (*BlockAcceptanceData, Multiset, error)
CalculateAcceptanceDataAndUTXOMultiset(blockHash *externalapi.DomainHash) error
}

12
domain/consensus/model/interface_processes_blockvalidator.go
View File

@ -5,10 +5,10 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// BlockValidator exposes a set of validation classes, after which
// it's possible to determine whether a block is valid
type BlockValidator interface {
ValidateHeaderInIsolation(block *externalapi.DomainBlock) error
ValidateBodyInIsolation(block *externalapi.DomainBlock) error
ValidateHeaderInContext(block *externalapi.DomainBlock) error
ValidateBodyInContext(block *externalapi.DomainBlock) error
ValidateAgainstPastUTXO(block *externalapi.DomainBlock) error
ValidateFinality(block *externalapi.DomainBlock) error
ValidateHeaderInIsolation(blockHash *externalapi.DomainHash) error
ValidateBodyInIsolation(blockHash *externalapi.DomainHash) error
ValidateHeaderInContext(blockHash *externalapi.DomainHash) error
ValidateBodyInContext(blockHash *externalapi.DomainHash) error
ValidateAgainstPastUTXO(blockHash *externalapi.DomainHash) error
ValidateFinality(blockHash *externalapi.DomainHash) error
}

4
domain/consensus/model/interface_processes_consensusstatemanager.go
View File

@ -4,9 +4,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// ConsensusStateManager manages the node's consensus state
type ConsensusStateManager interface {
UTXOByOutpoint(outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error)
CalculateConsensusStateChanges(block *externalapi.DomainBlock, isDisqualified bool) (stateChanges *ConsensusStateChanges,
utxoDiffChanges *UTXODiffChanges, virtualGHOSTDAGData *BlockGHOSTDAGData, err error)
CalculateConsensusStateChanges(blockHash *externalapi.DomainHash) error
VirtualData() (medianTime int64, blueScore uint64, err error)
RestorePastUTXOSet(blockHash *externalapi.DomainHash) (ReadOnlyUTXOSet, error)
RestoreDiffFromVirtual(utxoDiff *UTXODiff, virtualDiffParentHash *externalapi.DomainHash) (*UTXODiff, error)

2
domain/consensus/model/interface_processes_difficultymanager.go
View File

@ -5,5 +5,5 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// DifficultyManager provides a method to resolve the
// difficulty value of a block
type DifficultyManager interface {
RequiredDifficulty(parents []*externalapi.DomainHash) (uint32, error)
RequiredDifficulty(blockHash *externalapi.DomainHash) (uint32, error)
}

7
domain/consensus/model/interface_processes_ghostdagmanager.go
View File

@ -4,9 +4,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// GHOSTDAGManager resolves and manages GHOSTDAG block data
type GHOSTDAGManager interface {
GHOSTDAG(blockParents []*externalapi.DomainHash) (*BlockGHOSTDAGData, error)
BlockData(blockHash *externalapi.DomainHash) (*BlockGHOSTDAGData, error)
ChooseSelectedParent(
blockHashA *externalapi.DomainHash, blockAGHOSTDAGData *BlockGHOSTDAGData,
blockHashB *externalapi.DomainHash, blockBGHOSTDAGData *BlockGHOSTDAGData) *externalapi.DomainHash
GHOSTDAG(blockHash *externalapi.DomainHash) error
ChooseSelectedParent(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (*externalapi.DomainHash, error)
}

4
domain/consensus/model/interface_processes_pastmediantimemanager.go
View File

@ -1,7 +1,9 @@
package model
import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// PastMedianTimeManager provides a method to resolve the
// past median time of a block
type PastMedianTimeManager interface {
PastMedianTime(blockGHOSTDAGData *BlockGHOSTDAGData) (int64, error)
PastMedianTime(blockHash *externalapi.DomainHash) (int64, error)
}

3
domain/consensus/model/interface_processes_pruningmanager.go
View File

@ -4,8 +4,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// PruningManager resolves and manages the current pruning point
type PruningManager interface {
FindNextPruningPoint(blockGHOSTDAGData *BlockGHOSTDAGData) (found bool,
newPruningPoint *externalapi.DomainHash, newPruningPointUTXOSet ReadOnlyUTXOSet, err error)
FindNextPruningPoint(blockHash *externalapi.DomainHash) error
PruningPoint() (*externalapi.DomainHash, error)
SerializedUTXOSet() ([]byte, error)
}

2
domain/consensus/model/interface_processes_reachabilitytree.go
View File

@ -5,7 +5,7 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// ReachabilityTree maintains a structure that allows to answer
// reachability queries in sub-linear time
type ReachabilityTree interface {
AddBlock(blockHash *externalapi.DomainHash) error
IsReachabilityTreeAncestorOf(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error)
IsDAGAncestorOf(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error)
ReachabilityChangeset(blockHash *externalapi.DomainHash, blockGHOSTDAGData *BlockGHOSTDAGData) (*ReachabilityChangeset, error)
}

1
domain/consensus/model/interface_processes_utxodiffmanager.go
View File

@ -5,7 +5,6 @@ import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// UTXODiffManager provides methods to access
// and store UTXO diffs
type UTXODiffManager interface {
StoreUTXODiff(blockHash *externalapi.DomainHash, utxoDiff *UTXODiff) error
RestoreBlockDiffFromVirtualDiffParent(blockHash *externalapi.DomainHash) (utxoDiff *UTXODiff,
virtualDiffParentHash *externalapi.DomainHash, err error)
}

10
domain/consensus/model/reachabilitychangeset.go
View File

@ -1,10 +0,0 @@
package model
import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// ReachabilityChangeset holds the set of changes to make to a
// reachability tree to insert a new reachability node
type ReachabilityChangeset struct {
TreeNodeChanges map[*externalapi.DomainHash]*ReachabilityTreeNode
FutureCoveringSetChanges map[*externalapi.DomainHash]FutureCoveringTreeNodeSet
}

5
domain/consensus/processes/acceptancemanager/acceptancemanager.go
View File

@ -2,6 +2,7 @@ package acceptancemanager
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)
// AcceptanceManager manages transaction acceptance
@ -17,8 +18,6 @@ func New(utxoDiffManager model.UTXODiffManager) model.AcceptanceManager {
}
}
func (a *acceptanceManager) CalculateAcceptanceDataAndUTXOMultiset(blockGHOSTDAGData *model.BlockGHOSTDAGData) (
*model.BlockAcceptanceData, model.Multiset, error) {
func (a *acceptanceManager) CalculateAcceptanceDataAndUTXOMultiset(blockHash *externalapi.DomainHash) error {
panic("implement me")
}

12
domain/consensus/processes/blockvalidator/blockvalidator.go
View File

@ -37,34 +37,34 @@ func New(
// ValidateHeaderInIsolation validates block headers in isolation from the current
// consensus state
func (v *blockValidator) ValidateHeaderInIsolation(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateHeaderInIsolation(blockHash *externalapi.DomainHash) error {
return nil
}
// ValidateHeaderInContext validates block headers in the context of the current
// consensus state
func (v *blockValidator) ValidateHeaderInContext(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateHeaderInContext(blockHash *externalapi.DomainHash) error {
return nil
}
// ValidateBodyInIsolation validates block bodies in isolation from the current
// consensus state
func (v *blockValidator) ValidateBodyInIsolation(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateBodyInIsolation(blockHash *externalapi.DomainHash) error {
return nil
}
// ValidateBodyInContext validates block bodies in the context of the current
// consensus state
func (v *blockValidator) ValidateBodyInContext(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateBodyInContext(blockHash *externalapi.DomainHash) error {
return nil
}
// ValidateAgainstPastUTXO validates the block against the UTXO of its past
func (v *blockValidator) ValidateAgainstPastUTXO(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateAgainstPastUTXO(blockHash *externalapi.DomainHash) error {
return nil
}
// ValidateFinality makes sure the block does not violate finality
func (v *blockValidator) ValidateFinality(block *externalapi.DomainBlock) error {
func (v *blockValidator) ValidateFinality(blockHash *externalapi.DomainHash) error {
return nil
}

17
domain/consensus/processes/consensusstatemanager/consensusstatemanager.go
View File

@ -17,6 +17,7 @@ type consensusStateManager struct {
blockStore model.BlockStore
ghostdagManager model.GHOSTDAGManager
acceptanceManager model.AcceptanceManager
blockStatusStore model.BlockStatusStore
}
// New instantiates a new ConsensusStateManager
@ -27,7 +28,8 @@ func New(
multisetStore model.MultisetStore,
blockStore model.BlockStore,
ghostdagManager model.GHOSTDAGManager,
acceptanceManager model.AcceptanceManager) model.ConsensusStateManager {
acceptanceManager model.AcceptanceManager,
blockStatusStore model.BlockStatusStore) model.ConsensusStateManager {
return &consensusStateManager{
dagParams: dagParams,
@ -38,21 +40,14 @@ func New(
blockStore: blockStore,
ghostdagManager: ghostdagManager,
acceptanceManager: acceptanceManager,
blockStatusStore: blockStatusStore,
}
}
// UTXOByOutpoint returns a UTXOEntry matching the given outpoint
func (csm *consensusStateManager) UTXOByOutpoint(outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error) {
return nil, nil
}
// CalculateConsensusStateChanges returns a set of changes that must occur in order
// to transition the current consensus state into the one including the given block
func (csm *consensusStateManager) CalculateConsensusStateChanges(block *externalapi.DomainBlock, isDisqualified bool) (
stateChanges *model.ConsensusStateChanges, utxoDiffChanges *model.UTXODiffChanges,
virtualGHOSTDAGData *model.BlockGHOSTDAGData, err error) {
return nil, nil, nil, nil
func (csm *consensusStateManager) CalculateConsensusStateChanges(blockHash *externalapi.DomainHash) error {
return nil
}
// VirtualData returns the medianTime and blueScore of the current virtual block

2
domain/consensus/processes/difficultymanager/difficultymanager.go
View File

@ -19,6 +19,6 @@ func New(ghostdagManager model.GHOSTDAGManager) model.DifficultyManager {
}
// RequiredDifficulty returns the difficulty required for some block
func (dm *difficultyManager) RequiredDifficulty(parents []*externalapi.DomainHash) (uint32, error) {
func (dm *difficultyManager) RequiredDifficulty(blockHash *externalapi.DomainHash) (uint32, error) {
return 0, nil
}

34
domain/consensus/processes/ghostdagmanager/compare.go
View File

@ -1,7 +1,6 @@
package ghostdagmanager
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)
@ -23,35 +22,38 @@ func (gm *ghostdagManager) findSelectedParent(parentHashes []*externalapi.Domain
return selectedParent, nil
}
func (gm *ghostdagManager) less(blockA, blockB *externalapi.DomainHash) (bool, error) {
blockAGHOSTDAGData, err := gm.ghostdagDataStore.Get(gm.databaseContext, blockA)
func (gm *ghostdagManager) less(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error) {
chosenSelectedParent, err := gm.ChooseSelectedParent(blockHashA, blockHashB)
if err != nil {
return false, err
}
blockBGHOSTDAGData, err := gm.ghostdagDataStore.Get(gm.databaseContext, blockB)
if err != nil {
return false, err
}
chosenSelectedParent := gm.ChooseSelectedParent(blockA, blockAGHOSTDAGData, blockB, blockBGHOSTDAGData)
return chosenSelectedParent == blockB, nil
return chosenSelectedParent == blockHashB, nil
}
func (gm *ghostdagManager) ChooseSelectedParent(
blockHashA *externalapi.DomainHash, blockAGHOSTDAGData *model.BlockGHOSTDAGData,
blockHashB *externalapi.DomainHash, blockBGHOSTDAGData *model.BlockGHOSTDAGData) *externalapi.DomainHash {
func (gm *ghostdagManager) ChooseSelectedParent(blockHashA *externalapi.DomainHash,
blockHashB *externalapi.DomainHash) (*externalapi.DomainHash, error) {
blockAGHOSTDAGData, err := gm.ghostdagDataStore.Get(gm.databaseContext, blockHashA)
if err != nil {
return nil, err
}
blockBGHOSTDAGData, err := gm.ghostdagDataStore.Get(gm.databaseContext, blockHashB)
if err != nil {
return nil, err
}
blockABlueScore := blockAGHOSTDAGData.BlueScore
blockBBlueScore := blockBGHOSTDAGData.BlueScore
if blockABlueScore == blockBBlueScore {
if hashesLess(blockHashA, blockHashB) {
return blockHashB
return blockHashB, nil
}
return blockHashA
return blockHashA, nil
}
if blockABlueScore < blockBBlueScore {
return blockHashB
return blockHashB, nil
}
return blockHashA
return blockHashA, nil
}
func hashesLess(a, b *externalapi.DomainHash) bool {

17
domain/consensus/processes/ghostdagmanager/ghostdag.go
View File

@ -24,27 +24,31 @@ import (
// BluesAnticoneSizes.
//
// For further details see the article https://eprint.iacr.org/2018/104.pdf
func (gm *ghostdagManager) GHOSTDAG(blockParents []*externalapi.DomainHash) (*model.BlockGHOSTDAGData, error) {
func (gm *ghostdagManager) GHOSTDAG(blockHash *externalapi.DomainHash) error {
newBlockData := &model.BlockGHOSTDAGData{
MergeSetBlues: make([]*externalapi.DomainHash, 0),
MergeSetReds: make([]*externalapi.DomainHash, 0),
BluesAnticoneSizes: make(map[externalapi.DomainHash]model.KType),
}
blockParents, err := gm.dagTopologyManager.Parents(blockHash)
if err != nil {
return err
}
selectedParent, err := gm.findSelectedParent(blockParents)
if err != nil {
return nil, err
return err
}
newBlockData.SelectedParent = selectedParent
mergeSet, err := gm.mergeSet(newBlockData.SelectedParent, blockParents)
if err != nil {
return nil, err
return err
}
for _, blueCandidate := range mergeSet {
isBlue, candidateAnticoneSize, candidateBluesAnticoneSizes, err := gm.checkBlueCandidate(newBlockData, blueCandidate)
if err != nil {
return nil, err
return err
}
if isBlue {
@ -61,11 +65,12 @@ func (gm *ghostdagManager) GHOSTDAG(blockParents []*externalapi.DomainHash) (*mo
selectedParentGHOSTDAGData, err := gm.ghostdagDataStore.Get(gm.databaseContext, newBlockData.SelectedParent)
if err != nil {
return nil, err
return err
}
newBlockData.BlueScore = selectedParentGHOSTDAGData.BlueScore + uint64(len(newBlockData.MergeSetBlues))
return newBlockData, nil
gm.ghostdagDataStore.Stage(blockHash, newBlockData)
return nil
}
type chainBlockData struct {

7
domain/consensus/processes/ghostdagmanager/ghostdagmanager.go
View File

@ -3,7 +3,6 @@ package ghostdagmanager
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/infrastructure/db/dbaccess"
)
@ -29,9 +28,3 @@ func New(
k: k,
}
}
// BlockData returns previously calculated GHOSTDAG data for
// the given blockHash
func (gm *ghostdagManager) BlockData(blockHash *externalapi.DomainHash) (*model.BlockGHOSTDAGData, error) {
return gm.ghostdagDataStore.Get(gm.databaseContext, blockHash)
}

3
domain/consensus/processes/pastmediantimemanager/pastmediantimemanager.go
View File

@ -2,6 +2,7 @@ package pastmediantimemanager
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)
// pastMedianTimeManager provides a method to resolve the
@ -18,6 +19,6 @@ func New(ghostdagManager model.GHOSTDAGManager) model.PastMedianTimeManager {
}
// PastMedianTime returns the past median time for some block
func (pmtm *pastMedianTimeManager) PastMedianTime(blockGHOSTDAGData *model.BlockGHOSTDAGData) (int64, error) {
func (pmtm *pastMedianTimeManager) PastMedianTime(blockHash *externalapi.DomainHash) (int64, error) {
return 0, nil
}

8
domain/consensus/processes/pruningmanager/pruningmanager.go
View File

@ -31,11 +31,9 @@ func New(
}
// FindNextPruningPoint finds the next pruning point from the
// given blockHash. If none found, returns false
func (pm *pruningManager) FindNextPruningPoint(blockGHOSTDAGData *model.BlockGHOSTDAGData) (found bool,
newPruningPoint *externalapi.DomainHash, newPruningPointUTXOSet model.ReadOnlyUTXOSet, err error) {
return false, nil, nil, nil
// given blockHash
func (pm *pruningManager) FindNextPruningPoint(blockHash *externalapi.DomainHash) error {
return nil
}
// PruningPoint returns the hash of the current pruning point

13
domain/consensus/processes/reachabilitytree/reachabilitytree.go
View File

@ -22,6 +22,11 @@ func New(
}
}
// AddBlock adds the block with the given blockHash into the reachability tree.
func (rt *reachabilityTree) AddBlock(blockHash *externalapi.DomainHash) error {
return nil
}
// IsReachabilityTreeAncestorOf returns true if blockHashA is an
// ancestor of blockHashB in the reachability tree. Note that this
// does not necessarily mean that it isn't its ancestor in the DAG.
@ -34,11 +39,3 @@ func (rt *reachabilityTree) IsReachabilityTreeAncestorOf(blockHashA *externalapi
func (rt *reachabilityTree) IsDAGAncestorOf(blockHashA *externalapi.DomainHash, blockHashB *externalapi.DomainHash) (bool, error) {
return false, nil
}
// ReachabilityChangeset returns a set of changes that need to occur
// in order to add the given blockHash into the reachability tree.
func (rt *reachabilityTree) ReachabilityChangeset(blockHash *externalapi.DomainHash,
blockGHOSTDAGData *model.BlockGHOSTDAGData) (*model.ReachabilityChangeset, error) {
return nil, nil
}

5
domain/consensus/processes/utxodiffmanager/utxodiffmanager.go
View File

@ -18,11 +18,6 @@ func New(utxoDiffStore model.UTXODiffStore) model.UTXODiffManager {
}
}
// StoreUTXODiff stores the given utxoDiff for the given blockHash
func (u *utxoDiffManager) StoreUTXODiff(blockHash *externalapi.DomainHash, utxoDiff *model.UTXODiff) error {
panic("implement me")
}
// RestoreBlockDiffFromVirtualDiffParent restores the UTXO diff of
// the block for the given blockHash.
func (u *utxoDiffManager) RestoreBlockDiffFromVirtualDiffParent(blockHash *externalapi.DomainHash) (utxoDiff *model.UTXODiff, virtualDiffParentHash *externalapi.DomainHash, err error) {