Match known hashes in pollard

utreexo/pollard.go

@@ -18,8 +18,8 @@ func (p *Pollard) Modify(adds []LeafTXO, dels []uint64) error {
 }
 
 func (p *Pollard) Stats() string {
-	s := fmt.Sprintf("pol nl %d tops %d phe %d he %d re %d ow %d \n",
-		p.numLeaves, len(p.tops), p.proofHashesEver, p.hashesEver, p.rememberEver, p.overWire)
+	s := fmt.Sprintf("pol nl %d tops %d prhe %d phe %d he %d re %d ow %d \n",
+		p.numLeaves, len(p.tops), p.proofResolveHashesEver, p.proofHashesEver, p.hashesEver, p.rememberEver, p.overWire)
 	return s
 }
 
@@ -374,7 +374,7 @@ func (p *Pollard) descendToPos(pos uint64) ([]*polNode, []*polNode, error) {
 		n = n.niece[lr]
 
 		if n == nil && h != 0 {
-			return nil, nil, fmt.Errorf(
+			return proofs, sibs, fmt.Errorf(
 				"descend pos %d nil neice at height %d", pos, h)
 		}
 

utreexo/pollard_test.go

@@ -38,7 +38,7 @@ func pollardRandomRemember(blocks int32) error {
 	sn.durationMask = 0x0f
 	sn.lookahead = 4
 	for b := int32(0); b < blocks; b++ {
-		adds, delHashes := sn.NextBlock(rand.Uint32() & 0x03)
+		adds, delHashes := sn.NextBlock(rand.Uint32() & 0x77)
 
 		fmt.Printf("\t\t\tblock %d del %d add %d - %s\n",
 			sn.blockHeight, len(delHashes), len(adds), p.Stats())

utreexo/pollardproof.go

@@ -95,14 +95,11 @@ func (p *Pollard) VerifyBlockProof(
 		return false, proofmap
 	}
 
-	knownHashes, err := p.matchKnownData(proofmap, bp)
+	proofmap, err = p.matchKnownData(proofmap, bp)
 	if err != nil {
 		fmt.Printf("VerifyBlockProof matchKnownData ERROR %s\n", err.Error())
 		return false, proofmap
 	}
-	for k, v := range knownHashes {
-		proofmap[k] = v
-	}
 
 	//	fmt.Printf("Reconstruct complete\n")
 	topposs, topheights := getTopsReverse(p.numLeaves, height)
@@ -206,10 +203,10 @@ func (p *Pollard) VerifyBlockProof(
 func (p *Pollard) matchKnownData(
 	rec map[uint64]Hash,
 	bp BlockProof) (map[uint64]Hash, error) {
-	proofmap := map[uint64]Hash{}
+	proofmap := rec
 
 	height := p.height()
-	fmt.Printf("Targets: %v\n", bp.Targets)
+	/*fmt.Printf("Targets: %v\n", bp.Targets)
 	fmt.Printf("Num leaves: %d\n", p.numLeaves)
 	for pos, hash := range rec {
 		fmt.Printf("rec[%d] = %x\n", pos, hash[:4])
@@ -222,65 +219,101 @@ func (p *Pollard) matchKnownData(
 		fmt.Printf("%x ", th[:4])
 	}
 	fmt.Printf("\n")
-
+	*/
 	var left, right uint64
 
 	for _, t := range bp.Targets {
 
-		fmt.Printf("Processing %d\n", t)
+		//fmt.Printf("Processing %d\n", t)
 		// Fetch whatever is in the pollard on the path to
 		// this leaf
-		nodes, _, _ := p.descendToPos(t)
-
-		for i, n := range nodes {
-			if n != nil {
-				fmt.Printf("nodes[%d] = %x\n", i, n.data[:4])
-			} else {
-				fmt.Printf("nodes[%d] = nil\n", i)
+		_, sibs, err := p.descendToPos(t)
+		/*
+			if err != nil {
+				fmt.Printf("Error descendToPos: %s\n", err)
 			}
-		}
+
+			for i, s := range sibs {
+				if s != nil {
+					fmt.Printf("sibs[%d] = %x\n", i, s.data[:4])
+				} else {
+					fmt.Printf("sibs[%d] = nil\n", i)
+				}
+			}*/
 
 		subH := detectSubTreeHeight(t, p.numLeaves, height)
-		fmt.Printf("Subtree height for [%d] is [%d]\n", left, subH)
+		//fmt.Printf("Subtree height for [%d] is [%d]\n", left, subH)
 		pos := up1(t, height)
-		fmt.Printf("We are at position [%d]\n", pos)
+		//fmt.Printf("We are at position [%d]\n", pos)
 		right = t | 1
 		left = right ^ 1
 		leftHash, rightHash := rec[left], rec[right]
 
 		found := false
-		for h := uint8(1); h < subH; h++ { // < or <=?  I think <
-			if !found || nodes[h] == nil {
-				fmt.Printf("pos %d: Parent(%x, %x) -> ", pos, leftHash[:4], rightHash[:4])
-				hash := Parent(leftHash, rightHash)
-				fmt.Printf("%x\n", hash[:4])
-				p.hashesEver++
-				p.proofHashesEver++
-				if nodes[h] != nil {
-					if nodes[h].data == hash {
-						fmt.Printf("Found matching hash in nodes[%d]\n", h)
-						found = true
+		for h := uint8(1); h <= subH; h++ { // < or <=?  I think <
+			_, ok := proofmap[pos]
+			if !ok {
+				if !found || sibs[h] == nil {
+					//fmt.Printf("pos %d: Parent(%x, %x) -> ", pos, leftHash[:4], rightHash[:4])
+					hash := Parent(leftHash, rightHash)
+					//fmt.Printf("%x\n", hash[:4])
+					p.hashesEver++
+					p.proofHashesEver++
+					if sibs[h] != nil {
+						if sibs[h].data == hash {
+							//fmt.Printf("Found matching hash in nodes[%d]\n", h)
+							found = true
+						}
 					}
+					proofmap[pos] = hash
+				} else {
+					//fmt.Printf("Using cached data after intersecting with pollard for %d\n", pos)
+					proofmap[pos] = sibs[h].data
 				}
-				proofmap[pos] = hash
-			} else {
-				fmt.Printf("Using cached data after intersecting with pollard for %d\n", pos)
-				proofmap[pos] = nodes[h].data
+			}
+			if h == subH {
+				break
 			}
 
-			if !found {
+			if !found || sibs[h+1] == nil {
+				hashes := map[uint64]Hash{}
+				ok := false
 				if pos&1 == 0 {
-					fmt.Printf("Left pos (calculated): [%d] - Right pos (from proof): [%d]\n", pos, pos^1)
+					//fmt.Printf("Left pos (calculated): [%d] - Right pos (from proof): [%d]\n", pos, pos^1)
+					rightHash, ok = proofmap[pos^1]
+					if !ok {
+						rightHash, hashes, err = ResolveNode(proofmap, pos^1, height)
+						for p, h := range hashes {
+							proofmap[p] = h
+						}
+						if err != nil {
+							return nil, err
+						}
+						p.hashesEver += uint64(len(hashes))
+						p.proofHashesEver += uint64(len(hashes))
+						p.proofResolveHashesEver += uint64(len(hashes))
+					}
 					leftHash = proofmap[pos]
-					rightHash = rec[pos^1]
 				} else {
-					fmt.Printf("Left pos (from proof): [%d] - Right pos (calculated): [%d]\n", pos^1, pos)
+					//fmt.Printf("Left pos (from proof): [%d] - Right pos (calculated): [%d]\n", pos^1, pos)
+					leftHash, ok = proofmap[pos^1]
+					if !ok {
+						leftHash, hashes, err = ResolveNode(proofmap, pos^1, height)
+						for p, h := range hashes {
+							proofmap[p] = h
+						}
+						if err != nil {
+							return nil, err
+						}
+						p.hashesEver += uint64(len(hashes))
+						p.proofHashesEver += uint64(len(hashes))
+						p.proofResolveHashesEver += uint64(len(hashes))
+					}
 					rightHash = proofmap[pos]
-					leftHash = rec[pos^1]
 				}
 			}
 			pos = up1(pos, height)
-			fmt.Printf("We are at [%d]\n", pos)
+			//fmt.Printf("We are at [%d]\n", pos)
 		}
 	}
 

utreexo/pollarutil.go

@@ -15,7 +15,7 @@ type Pollard struct {
 	// BUT THEY'RE WEIRD!  The left / right children are actual children,
 	// not neices as they are in every lower level.
 
-	proofHashesEver, hashesEver, rememberEver, overWire uint64
+	proofResolveHashesEver, proofHashesEver, hashesEver, rememberEver, overWire uint64
 
 	//	Lookahead int32  // remember leafs below this TTL
 	//	Minleaves uint64 // remember everything below this leaf count

utreexo/utils.go

@@ -395,3 +395,45 @@ func U64tB(i uint64) []byte {
 	binary.Write(&buf, binary.BigEndian, i)
 	return buf.Bytes()
 }
+
+// ResolveNode will try to get a node at a given pos from a known set of nodes/leaves
+// if not present, it will descend to calculate it from known data further down.
+// should optimize this to return all the hashes it calculated so the caller can add it
+// to its cache/knownData
+func ResolveNode(knownData map[uint64]Hash, pos uint64, forestHeight uint8) (Hash, map[uint64]Hash, error) {
+	calculatedHashes := map[uint64]Hash{}
+	// First check if the node is in here
+	n, ok := knownData[pos]
+	if ok {
+		return n, calculatedHashes, nil
+	}
+
+	// If not, check if we're at a leaf. If so, we can't fix this.
+	if detectHeight(pos, forestHeight) == 0 {
+		return Hash{}, calculatedHashes, fmt.Errorf("Could not find leaf %d", pos)
+	}
+
+	// Otherwise, find if the children are known and hash them
+	leftPos := child(pos, forestHeight)
+	rightPos := leftPos ^ 1
+
+	left, leftHashes, err := ResolveNode(knownData, leftPos, forestHeight)
+	for pos, hash := range leftHashes {
+		calculatedHashes[pos] = hash
+	}
+
+	if err != nil {
+		return Hash{}, calculatedHashes, err
+	}
+
+	right, rightHashes, err := ResolveNode(knownData, rightPos, forestHeight)
+	for pos, hash := range rightHashes {
+		calculatedHashes[pos] = hash
+	}
+
+	if err != nil {
+		return Hash{}, calculatedHashes, err
+	}
+	calculatedHashes[pos] = Parent(left, right)
+	return calculatedHashes[pos], calculatedHashes, nil
+}