func (list *DBStateList) NewDBState(isNew bool,
directoryBlock interfaces.IDirectoryBlock,
adminBlock interfaces.IAdminBlock,
factoidBlock interfaces.IFBlock,
entryCreditBlock interfaces.IEntryCreditBlock,
eBlocks []interfaces.IEntryBlock,
entries []interfaces.IEBEntry) *DBState {
dbState := new(DBState)
dbState.DBHash = directoryBlock.DatabasePrimaryIndex()
dbState.ABHash = adminBlock.DatabasePrimaryIndex()
dbState.FBHash = factoidBlock.DatabasePrimaryIndex()
dbState.ECHash = entryCreditBlock.DatabasePrimaryIndex()
dbState.isNew = isNew
dbState.DirectoryBlock = directoryBlock
dbState.AdminBlock = adminBlock
dbState.FactoidBlock = factoidBlock
dbState.EntryCreditBlock = entryCreditBlock
dbState.EntryBlocks = eBlocks
dbState.Entries = entries
// If we actually add this to the list, return the dbstate.
if list.Put(dbState) {
return dbState
}
// Failed, so return nil
return nil
}
func CreateAnchorRecordFromDBlock(dBlock interfaces.IDirectoryBlock) *AnchorRecord {
ar := new(AnchorRecord)
ar.AnchorRecordVer = 1
ar.DBHeight = dBlock.GetHeader().GetDBHeight()
ar.KeyMR = dBlock.DatabasePrimaryIndex().String()
ar.RecordHeight = ar.DBHeight
return ar
}
// NewDirBlockInfoFromDirBlock creates a DirDirBlockInfo from DirectoryBlock
func NewDirBlockInfoFromDirBlock(dirBlock interfaces.IDirectoryBlock) *DirBlockInfo {
dbic := new(DirBlockInfo)
dbic.DBHash = dirBlock.GetHash()
dbic.DBHeight = dirBlock.GetDatabaseHeight()
dbic.DBMerkleRoot = dirBlock.GetKeyMR()
dbic.Timestamp = int64(dirBlock.GetHeader().GetTimestamp()) // * 60 ???
dbic.BTCTxHash = primitives.NewZeroHash()
dbic.BTCBlockHash = primitives.NewZeroHash()
dbic.BTCConfirmed = false
return dbic
}
// Validate this directory block given the next Directory Block. Need to check the
// signatures as being from the authority set, and valid. Also check that this DBState holds
// a previous KeyMR that matches the previous DBState KeyMR.
//
// Return a -1 on failure.
//
func (d *DBState) ValidNext(state interfaces.IState, dirblk interfaces.IDirectoryBlock) int {
dbheight := dirblk.GetHeader().GetDBHeight()
if dbheight == 0 {
// The genesis block is valid by definition.
return 1
}
if d == nil || !d.Saved {
// Must be out of order. Can't make the call if valid or not yet.
return 0
}
// Get the keymr of the Previous DBState
pkeymr := d.DirectoryBlock.GetKeyMR()
// Get the Previous KeyMR pointer in the possible new Directory Block
prevkeymr := dirblk.GetHeader().GetPrevKeyMR()
if !pkeymr.IsSameAs(prevkeymr) {
// If not the same, this is a bad new Directory Block
return -1
}
return 1
}
func NewDirectoryBlock(prev interfaces.IDirectoryBlock) interfaces.IDirectoryBlock {
newdb := new(DirectoryBlock)
newdb.Header = new(DBlockHeader)
newdb.Header.SetVersion(constants.VERSION_0)
if prev != nil {
newdb.GetHeader().SetPrevFullHash(prev.GetFullHash())
newdb.GetHeader().SetPrevKeyMR(prev.GetKeyMR())
newdb.GetHeader().SetDBHeight(prev.GetHeader().GetDBHeight() + 1)
} else {
newdb.Header.SetPrevFullHash(primitives.NewZeroHash())
newdb.Header.SetPrevKeyMR(primitives.NewZeroHash())
newdb.GetHeader().SetDBHeight(0)
}
newdb.SetDBEntries(make([]interfaces.IDBEntry, 0))
newdb.AddEntry(primitives.NewHash(constants.ADMIN_CHAINID), primitives.NewZeroHash())
newdb.AddEntry(primitives.NewHash(constants.EC_CHAINID), primitives.NewZeroHash())
newdb.AddEntry(primitives.NewHash(constants.FACTOID_CHAINID), primitives.NewZeroHash())
return newdb
}
func CheckBlockPairIntegrity(block interfaces.IDirectoryBlock, prev interfaces.IDirectoryBlock) error {
if block == nil {
return fmt.Errorf("No block specified")
}
if prev == nil {
if block.GetHeader().GetPrevKeyMR().IsZero() == false {
return fmt.Errorf("Invalid PrevKeyMR")
}
if block.GetHeader().GetPrevFullHash().IsZero() == false {
return fmt.Errorf("Invalid PrevFullHash")
}
if block.GetHeader().GetDBHeight() != 0 {
return fmt.Errorf("Invalid DBHeight")
}
} else {
if block.GetHeader().GetPrevKeyMR().IsSameAs(prev.GetKeyMR()) == false {
return fmt.Errorf("Invalid PrevKeyMR")
}
if block.GetHeader().GetPrevFullHash().IsSameAs(prev.GetFullHash()) == false {
return fmt.Errorf("Invalid PrevFullHash")
}
if block.GetHeader().GetDBHeight() != (prev.GetHeader().GetDBHeight() + 1) {
return fmt.Errorf("Invalid DBHeight")
}
}
return nil
}
// Control Panel shows the last 100 entry and factoid transactions. This will look into the past if we do not
// currently have 100 of each transaction type. A checkpoint is set each time we check a new height, so we will
// not check a directory block in the past twice.
func getPastEntries(last interfaces.IDirectoryBlock, eNeeded int, fNeeded int) {
height := last.GetHeader().GetDBHeight()
next := last.GetHeader().GetPrevKeyMR()
zero := primitives.NewZeroHash()
newCheckpoint := height
for height > RecentTransactions.LastHeightChecked && (eNeeded > 0 || fNeeded > 0) {
if next.IsSameAs(zero) {
break
}
dbase := StatePointer.GetAndLockDB()
dblk, err := dbase.FetchDBlock(next)
StatePointer.UnlockDB()
if err != nil || dblk == nil {
break
}
height = dblk.GetHeader().GetDBHeight()
ents := dblk.GetDBEntries()
if len(ents) > 3 && eNeeded > 0 {
for _, eblock := range ents[3:] {
dbase := StatePointer.GetAndLockDB()
eblk, err := dbase.FetchEBlock(eblock.GetKeyMR())
StatePointer.UnlockDB()
if err != nil || eblk == nil {
break
}
for _, hash := range eblk.GetEntryHashes() {
if RecentTransactions.ContainsEntry(hash) {
continue
}
e := getEntry(hash.String())
if e != nil && eNeeded > 0 {
eNeeded--
RecentTransactions.Entries = append(RecentTransactions.Entries, *e)
//RecentTransactions.Entries = append([]EntryHolder{*e}, RecentTransactions.Entries...)
}
}
}
}
if fNeeded > 0 {
fChain := primitives.NewHash(constants.FACTOID_CHAINID)
for _, entry := range ents {
if entry.GetChainID().IsSameAs(fChain) {
dbase := StatePointer.GetAndLockDB()
fblk, err := dbase.FetchFBlock(entry.GetKeyMR())
StatePointer.UnlockDB()
if err != nil || fblk == nil {
break
}
transList := fblk.GetTransactions()
for _, trans := range transList {
if RecentTransactions.ContainsTrans(trans.GetSigHash()) {
continue
}
if trans != nil {
input, err := trans.TotalInputs()
if err != nil || input == 0 {
continue
}
totalInputs := len(trans.GetInputs())
totalOutputs := len(trans.GetECOutputs())
totalOutputs = totalOutputs + len(trans.GetOutputs())
inputStr := fmt.Sprintf("%f", float64(input)/1e8)
fNeeded--
RecentTransactions.FactoidTransactions = append(RecentTransactions.FactoidTransactions, struct {
TxID string
Hash string
TotalInput string
Status string
TotalInputs int
TotalOutputs int
}{trans.GetSigHash().String(), trans.GetHash().String(), inputStr, "Confirmed", totalInputs, totalOutputs})
}
}
}
}
}
next = dblk.GetHeader().GetPrevKeyMR()
}
DisplayStateMutex.Lock()
if newCheckpoint < DisplayState.CurrentEBDBHeight && newCheckpoint > RecentTransactions.LastHeightChecked {
RecentTransactions.LastHeightChecked = newCheckpoint
}
DisplayStateMutex.Unlock()
}
func CheckDBlockEntries(dBlock interfaces.IDirectoryBlock, dbo interfaces.DBOverlay) {
entries := dBlock.GetDBEntries()
for {
missing := 0
for _, e := range entries {
HashMap[e.GetKeyMR().String()] = "OK"
switch e.GetChainID().String() {
case "000000000000000000000000000000000000000000000000000000000000000a":
aBlock, err := dbo.FetchABlock(e.GetKeyMR())
if err != nil {
panic(err)
}
if aBlock != nil {
break
}
fmt.Printf("Found missing aBlock in #%v\n", dBlock.GetDatabaseHeight())
missing++
aBlock, err = GetABlock(e.GetKeyMR().String())
if err != nil {
panic(err)
}
err = dbo.ProcessABlockBatchWithoutHead(aBlock)
if err != nil {
panic(err)
}
break
case "000000000000000000000000000000000000000000000000000000000000000f":
fBlock, err := dbo.FetchFBlock(e.GetKeyMR())
if err != nil {
panic(err)
}
if fBlock != nil {
break
}
fmt.Printf("Found missing fBlock in #%v\n", dBlock.GetDatabaseHeight())
missing++
fBlock, err = GetFBlock(e.GetKeyMR().String())
if err != nil {
panic(err)
}
err = dbo.ProcessFBlockBatchWithoutHead(fBlock)
if err != nil {
panic(err)
}
break
case "000000000000000000000000000000000000000000000000000000000000000c":
ecBlock, err := dbo.FetchECBlock(e.GetKeyMR())
if err != nil {
panic(err)
}
if ecBlock != nil {
break
}
fmt.Printf("Found missing ecBlock in #%v\n", dBlock.GetDatabaseHeight())
missing++
ecBlock, err = GetECBlock(e.GetKeyMR().String())
if err != nil {
panic(err)
}
err = dbo.ProcessECBlockBatchWithoutHead(ecBlock, true)
if err != nil {
panic(err)
}
break
default:
eBlock, err := dbo.FetchEBlock(e.GetKeyMR())
if err != nil {
if err.Error() != "EOF" {
panic(err)
}
}
if eBlock == nil {
fmt.Printf("Found missing eBlock in #%v\n", dBlock.GetDatabaseHeight())
missing++
eBlock, err = GetEBlock(e.GetKeyMR().String())
if err != nil {
panic(err)
}
err = dbo.ProcessEBlockBatchWithoutHead(eBlock, true)
if err != nil {
panic(err)
}
}
eBlockEntries := eBlock.GetEntryHashes()
for _, eHash := range eBlockEntries {
if eHash.IsMinuteMarker() == true {
continue
}
entry, err := dbo.FetchEntry(eHash)
if err != nil {
panic(err)
}
if entry == nil {
fmt.Printf("Found missing entry in #%v\n", dBlock.GetDatabaseHeight())
missing++
entry, err := GetEntry(eHash.String())
if err != nil {
fmt.Printf("Problem getting entry `%v` from block %v\n", eHash.String(), e.GetKeyMR().String())
panic(err)
}
err = dbo.InsertEntry(entry)
if err != nil {
panic(err)
}
}
}
break
}
}
if missing == 0 {
break
}
}
}