Beispiel #1
0
func CreateReceipt(dbo interfaces.DBOverlay, entryID interfaces.IHash) (*Receipt, error) {
	receipt := new(Receipt)
	receipt.Entry = new(JSON)
	receipt.Entry.Key = entryID.String()

	//EBlock

	hash, err := dbo.FetchIncludedIn(entryID)
	if err != nil {
		return nil, err
	}

	if hash == nil {
		return nil, fmt.Errorf("Block containing entry not found")
	}

	eBlock, err := dbo.FetchEBlock(hash)
	if err != nil {
		return nil, err
	}

	if eBlock == nil {
		return nil, fmt.Errorf("EBlock not found")
	}

	hash = eBlock.DatabasePrimaryIndex()
	receipt.EntryBlockKeyMR = hash.(*primitives.Hash)

	entries := eBlock.GetEntryHashes()
	//fmt.Printf("eBlock entries - %v\n\n", entries)
	branch := primitives.BuildMerkleBranchForEntryHash(entries, entryID, true)
	blockNode := new(primitives.MerkleNode)
	left, err := eBlock.HeaderHash()
	if err != nil {
		return nil, err
	}
	blockNode.Left = left.(*primitives.Hash)
	blockNode.Right = eBlock.BodyKeyMR().(*primitives.Hash)
	blockNode.Top = hash.(*primitives.Hash)
	//fmt.Printf("eBlock blockNode - %v\n\n", blockNode)
	branch = append(branch, blockNode)
	receipt.MerkleBranch = append(receipt.MerkleBranch, branch...)

	//str, _ := eBlock.JSONString()
	//fmt.Printf("eBlock - %v\n\n", str)

	//DBlock

	hash, err = dbo.FetchIncludedIn(hash)
	if err != nil {
		return nil, err
	}

	if hash == nil {
		return nil, fmt.Errorf("Block containing EBlock not found")
	}

	dBlock, err := dbo.FetchDBlock(hash)
	if err != nil {
		return nil, err
	}

	if dBlock == nil {
		return nil, fmt.Errorf("DBlock not found")
	}

	//str, _ = dBlock.JSONString()
	//fmt.Printf("dBlock - %v\n\n", str)

	entries = dBlock.GetEntryHashesForBranch()
	//fmt.Printf("dBlock entries - %v\n\n", entries)

	//merkleTree := primitives.BuildMerkleTreeStore(entries)
	//fmt.Printf("dBlock merkleTree - %v\n\n", merkleTree)

	branch = primitives.BuildMerkleBranchForEntryHash(entries, receipt.EntryBlockKeyMR, true)
	blockNode = new(primitives.MerkleNode)
	left, err = dBlock.HeaderHash()
	if err != nil {
		return nil, err
	}
	blockNode.Left = left.(*primitives.Hash)
	blockNode.Right = dBlock.BodyKeyMR().(*primitives.Hash)
	blockNode.Top = hash.(*primitives.Hash)
	//fmt.Printf("dBlock blockNode - %v\n\n", blockNode)
	branch = append(branch, blockNode)
	receipt.MerkleBranch = append(receipt.MerkleBranch, branch...)

	//DirBlockInfo

	hash = dBlock.DatabasePrimaryIndex()
	receipt.DirectoryBlockKeyMR = hash.(*primitives.Hash)

	dirBlockInfo, err := dbo.FetchDirBlockInfoByKeyMR(hash)
	if err != nil {
		return nil, err
	}

	if dirBlockInfo != nil {
		dbi := dirBlockInfo.(*dbInfo.DirBlockInfo)

		receipt.BitcoinTransactionHash = dbi.BTCTxHash.(*primitives.Hash)
		receipt.BitcoinBlockHash = dbi.BTCBlockHash.(*primitives.Hash)
	}

	return receipt, nil
}
Beispiel #2
0
func CopyDB(dbase1, dbase2 interfaces.DBOverlay) {
	processing := ""
	defer func() {
		if r := recover(); r != nil {
			err := fmt.Errorf("Error processing: %v", processing)
			panic(err)
		}
	}()

	dBlocks, err := dbase1.FetchAllDBlocks()
	if err != nil {
		panic(err)
	}
	prevECHash := primitives.NewZeroHash()
	for _, dBlock := range dBlocks {
		dbase2.StartMultiBatch()

		err := dbase2.ProcessDBlockMultiBatch(dBlock)
		if err != nil {
			panic(err)
		}

		for _, dbEntry := range dBlock.GetDBEntries() {
			switch dbEntry.GetChainID().String() {
			case "000000000000000000000000000000000000000000000000000000000000000a":
				aBlock, err := dbase1.FetchABlock(dbEntry.GetKeyMR())
				if err != nil {
					panic(err)
				}
				err = dbase2.ProcessABlockMultiBatch(aBlock)
				if err != nil {
					panic(err)
				}
				break
			case "000000000000000000000000000000000000000000000000000000000000000c":
				ecBlock, err := dbase1.FetchECBlock(dbEntry.GetKeyMR())
				if err != nil {
					panic(err)
				}

				if ecBlock.GetHeader().GetPrevHeaderHash().IsSameAs(prevECHash) == false {
					prev, err := dbase1.FetchECBlock(ecBlock.GetHeader().GetPrevHeaderHash())
					if err != nil {
						panic(err)
					}
					err = dbase2.ProcessECBlockMultiBatch(prev, true)
					if err != nil {
						panic(err)
					}
				}

				err = dbase2.ProcessECBlockMultiBatch(ecBlock, true)
				if err != nil {
					panic(err)
				}
				prevECHash = dbEntry.GetKeyMR()
				break
			case "000000000000000000000000000000000000000000000000000000000000000f":
				fBlock, err := dbase1.FetchFBlock(dbEntry.GetKeyMR())
				if err != nil {
					panic(err)
				}
				err = dbase2.ProcessFBlockMultiBatch(fBlock)
				if err != nil {
					panic(err)
				}
				break
			default:
				processing = fmt.Sprintf("%v - %v - %v", dBlock.GetKeyMR().String(), dbEntry.GetChainID().String(), dbEntry.GetKeyMR().String())
				eBlock, err := dbase1.FetchEBlock(dbEntry.GetKeyMR())
				if err != nil {
					panic(err)
				}
				err = dbase2.ProcessEBlockMultiBatch(eBlock, true)
				if err != nil {
					panic(err)
				}
				for _, h := range eBlock.GetEntryHashes() {
					entry, err := dbase1.FetchEntry(h)
					if err != nil {
						panic(err)
					}
					err = dbase2.InsertEntryMultiBatch(entry)
					if err != nil {
						panic(err)
					}
				}
				break
			}
		}
		if err := dbase2.ExecuteMultiBatch(); err != nil {
			panic(err)
		}
		if dBlock.GetDatabaseHeight()%1000 == 0 {
			fmt.Printf("Processed block #%v\n", dBlock.GetDatabaseHeight())
		}
	}
}
Beispiel #3
0
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
		}
	}
}