bubble up getLeftRightHash err

core/trie/proof.go

@@ -63,11 +63,11 @@
 	proofs := [2][]ProofNode{}
 	leftProof, err := GetProof(leftBoundary, tri)
 	if err != nil {
 		return proofs, err
 	}
 	rightProof, err := GetProof(rightBoundary, tri)
 	if err != nil {
 		return proofs, err
 	}
 	proofs[0] = leftProof
 	proofs[1] = rightProof
@@ -219,18 +219,18 @@
 ) (bool, error) {
 	// Step 0: checks
 	if len(keys) != len(values) {
 		return false, fmt.Errorf("inconsistent proof data, number of keys: %d, number of values: %d", len(keys), len(values))
 	}
 
 	// Ensure all keys are monotonic increasing
 	if err := ensureMonotonicIncreasing(proofKeys, keys); err != nil {
 		return false, err
 	}
 
 	// Ensure the inner values contain no deletions
 	for _, value := range values {
 		if value.Equal(&felt.Zero) {
 			return false, errors.New("range contains deletion")
 		}
 	}
 
@@ -240,12 +240,12 @@
 	for i := 0; i < 2; i++ {
 		if proofs[i] != nil {
 			if !VerifyProof(root, proofKeys[i], proofValues[i], proofs[i], hash) {
 				return false, fmt.Errorf("invalid proof for key %x", proofKeys[i].String())
 			}
 
 			proofPaths[i], err = ProofToPath(proofs[i], proofKeys[i], hash)
 			if err != nil {
 				return false, err
 			}
 		}
 	}
@@ -253,16 +253,16 @@
 	// Step 2: Build trie from proofPaths and keys
 	tmpTrie, err := BuildTrie(proofPaths[0], proofPaths[1], keys, values)
 	if err != nil {
 		return false, err
 	}
 
 	// Verify that the recomputed root hash matches the provided root hash
 	recomputedRoot, err := tmpTrie.Root()
 	if err != nil {
 		return false, err
 	}
 	if !recomputedRoot.Equal(root) {
 		return false, errors.New("root hash mismatch")
 	}
 
 	return true, nil
@@ -272,19 +272,19 @@
 	if proofKeys[0] != nil {
 		leftProofFelt := proofKeys[0].Felt()
 		if leftProofFelt.Cmp(keys[0]) >= 0 {
 			return errors.New("range is not monotonically increasing")
 		}
 	}
 	if proofKeys[1] != nil {
 		rightProofFelt := proofKeys[1].Felt()
 		if keys[len(keys)-1].Cmp(&rightProofFelt) >= 0 {
 			return errors.New("range is not monotonically increasing")
 		}
 	}
 	if len(keys) >= 2 {
 		for i := 0; i < len(keys)-1; i++ {
 			if keys[i].Cmp(keys[i+1]) >= 0 {
 				return errors.New("range is not monotonically increasing")
 			}
 		}
 	}
@@ -312,7 +312,7 @@
 		if parent.Binary.LeftHash.Equal(childHash) || parent.Binary.RightHash.Equal(childHash) {
 			return 1, child.Edge.Path.len, nil
 		} else {
 			return 0, 0, errors.New("can't determine the child hash from the parent and child")
 		}
 	}
 
@@ -325,7 +325,7 @@
 	childInd := i + compressedParent + 1
 	childKey, err := getChildKey(childInd, parentKey, leafKey, nilKey, proofNodes, hashF)
 	if err != nil {
 		return nil, err
 	}
 	if leafKey.Test(leafKey.len - parentKey.len - 1) {
 		parentNode.Right = childKey
@@ -361,16 +361,16 @@
 		// Set the key of the current node
 		compressParent, compressParentOffset, err := compressNode(i, proofNodes, hashF)
 		if err != nil {
 			return nil, err
 		}
 		parentKey, err = getParentKey(i, compressParentOffset, leafKey, pNode, pathNodes, proofNodes)
 		if err != nil {
 			return nil, err
 		}
 
 		// Don't store leafs along proof paths
 		if parentKey.len == 251 { //nolint:gomnd
 			break
 		}
 
 		// Set the value of the current node
@@ -379,12 +379,14 @@
 		// Set the child key of the current node.
 		childKey, err := assignChild(i, compressParent, &parentNode, &nilKey, leafKey, parentKey, proofNodes, hashF)
 		if err != nil {
 			return nil, err
 		}
 
 		// Set the LeftHash and RightHash values
-		parentNode.LeftHash, parentNode.RightHash = getLeftRightHash(i, proofNodes)
-
+		parentNode.LeftHash, parentNode.RightHash, err = getLeftRightHash(i, proofNodes)
+		if err != nil {
+			return nil, err
+		}
 		pathNodes = append(pathNodes, StorageNode{key: parentKey, node: &parentNode})
 
 		// break early since we don't store leafs along proof paths, or if no more nodes exist along the proof paths
@@ -410,12 +412,15 @@
 	return false
 }
 
-func getLeftRightHash(parentInd int, proofNodes []ProofNode) (*felt.Felt, *felt.Felt) {
+func getLeftRightHash(parentInd int, proofNodes []ProofNode) (*felt.Felt, *felt.Felt, error) {
 	parent := &proofNodes[parentInd]
 	if parent.Binary == nil {
+		if parentInd+1 > len(proofNodes)-1 {
+			return nil, nil, errors.New("cant get hash of children from proof node, out of range")
+		}
 		parent = &proofNodes[parentInd+1]
 	}
-	return parent.Binary.LeftHash, parent.Binary.RightHash
+	return parent.Binary.LeftHash, parent.Binary.RightHash, nil
 }
 
 func getParentKey(idx int, compressedParentOffset uint8, leafKey *Key,
@@ -427,7 +432,7 @@
 	var height uint8
 	if len(pathNodes) > 0 {
 		if proofNodes[idx].Edge != nil {
 			height = pathNodes[len(pathNodes)-1].key.len + proofNodes[idx].Edge.Path.len
 		} else {
 			height = pathNodes[len(pathNodes)-1].key.len + 1
 		}
@@ -450,7 +455,7 @@
 
 	compressChild, compressChildOffset, err := compressNode(childIdx, proofNodes, hashF)
 	if err != nil {
 		return nil, err
 	}
 
 	if crntKey.len+uint8(compressChild)+compressChildOffset == 251 { //nolint:gomnd
@@ -464,7 +469,7 @@
 func BuildTrie(leftProofPath, rightProofPath []StorageNode, keys, values []*felt.Felt) (*Trie, error) { //nolint:gocyclo
 	tempTrie, err := NewTriePedersen(newMemStorage(), 251) //nolint:gomnd
 	if err != nil {
 		return nil, err
 	}
 
 	// merge proof paths
@@ -472,40 +477,40 @@
 		// Can't store nil keys so stop merging
 		if leftProofPath[i].node.Left == nil || leftProofPath[i].node.Right == nil ||
 			rightProofPath[i].node.Left == nil || rightProofPath[i].node.Right == nil {
 			break
 		}
 		if leftProofPath[i].key.Equal(rightProofPath[i].key) {
 			leftProofPath[i].node.Right = rightProofPath[i].node.Right
 			rightProofPath[i].node.Left = leftProofPath[i].node.Left
 		} else {
 			break
 		}
 	}
 
 	for _, sNode := range leftProofPath {
 		if sNode.node.Left == nil || sNode.node.Right == nil {
 			break
 		}
 		_, err := tempTrie.PutInner(sNode.key, sNode.node)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	for _, sNode := range rightProofPath {
 		if sNode.node.Left == nil || sNode.node.Right == nil {
 			break
 		}
 		_, err := tempTrie.PutInner(sNode.key, sNode.node)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	for i := range len(keys) {
 		_, err := tempTrie.PutWithProof(keys[i], values[i], leftProofPath, rightProofPath)
 		if err != nil {
 			return nil, err
 		}
 	}
 	return tempTrie, nil