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 } } }