fix(blob)!: update the blob.Proof to return a proof to the data root

api/docgen/exampledata/blobProof.json

@@ -1,31 +1,53 @@
-[
-  {
-    "end": 8,
-    "nodes": [
-      "/////////////////////////////////////////////////////////////////////////////wuxStDHcZ7+b5byNQMVLJbzBT3wmObsThoQ0sCTjTCP"
+{
+  "ShareToRowRootProof": [
+    {
+      "start": 3,
+      "end": 4,
+      "nodes": [
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ72eTVOUxB9THxFjAEwtTePJQA1b0xcz2f6TJc400Uw",
+        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBD0CYbGYoGN4q9VfSmeGZeg/h1NDBA/jtXjZrrKRHE6",
+        "/////////////////////////////////////////////////////////////////////////////8KDE4JDf0N2lZB7DW1Fpasdk/wz4jHOxuBPAk5Vf5ZI"
+      ]
+    },
+    {
+      "end": 1,
+      "nodes": [
+        "//////////////////////////////////////7//////////////////////////////////////plEqgR/c4IAVkNdYRWOYOAESD4whneKR54Dz5Dfe4p2",
+        "//////////////////////////////////////7//////////////////////////////////////lrD0qJ9dspxSO1Yl8NDioZfgOm8Yj63Y+BGDRHlKCRj",
+        "/////////////////////////////////////////////////////////////////////////////xQyI+g89aM6rhy9rl2eKr0Uc2NPauf3fkLY3Z+gBtuM"
+      ]
+    }
+  ],
+  "RowProof": {
+    "row_roots": [
+      "00000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000808080808080808BC517066A5A8C81E2A4353DB500EBB3410047A93D2EE8ADF0B6797B9A5519557",
+      "0000000000000000000000000000000000000000000808080808080808FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE015AB6AAC6FAF0ABF26F9453AF390FDA3B39EB384F0B71D0170D84CF69CBA2BC"
     ],
-    "is_max_namespace_ignored": true
-  },
-  {
-    "end": 8,
-    "nodes": [
-      "//////////////////////////////////////////////////////////////////////////////n1NeJxPU2bZUAccKZZ+LAu2Wj5ajbVYURV9ojhSKwp"
+    "proofs": [
+      {
+        "total": 16,
+        "index": 1,
+        "leaf_hash": "lJek/BHnKH6PyRB8jlk69F6EY9Tfx2LRanaF74JVciU=",
+        "aunts": [
+          "bLjvftajE6jVsgQQBkV4RUPESRc+v4bhP0Ljf36858Q=",
+          "QaF9mNskaURxk98S3BExB1PzRAjOqVydrDLvUu0B5/M=",
+          "K2xW8JJ3Ff4FvtbfZi5ZD/ygnswaNCNIKXsSzbO2Jrc=",
+          "uySRG/gINLAgGgywJCTiXMlFkfQivF1O1zLg5+RRUP8="
+        ]
+      },
+      {
+        "total": 16,
+        "index": 2,
+        "leaf_hash": "h+4ND52kT4qkc9nWW22dIMAK/4YjkC6fBoD01WF0+Uo=",
+        "aunts": [
+          "2x8OISRBMLYJRV8NfTNtVvZUg2F7MtCK5xCZuE9fQwQ=",
+          "Xvr5IalE2y3pxHjxh5kcHFSRaz4g5MxdOj4NIGwRXY0=",
+          "K2xW8JJ3Ff4FvtbfZi5ZD/ygnswaNCNIKXsSzbO2Jrc=",
+          "uySRG/gINLAgGgywJCTiXMlFkfQivF1O1zLg5+RRUP8="
+        ]
+      }
     ],
-    "is_max_namespace_ignored": true
-  },
-  {
-    "end": 8,
-    "nodes": [
-      "/////////////////////////////////////////////////////////////////////////////0xK8BKnzDmwK0HR4ZJvyB4kh3jPPXGxaGPFoga8vPxF"
-    ],
-    "is_max_namespace_ignored": true
-  },
-  {
-    "end": 7,
-    "nodes": [
-      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJ/xGlNMdEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwn/EaU0x0UTO9HUGKjyjcv5U2gHeSjJ8S1rftqv6k8kxlVWW8e/7",
-      "/////////////////////////////////////////////////////////////////////////////wexh4khLQ9HQ2X6nh9wU5B+m6r+LWwPTEDTa5/CosDF"
-    ],
-    "is_max_namespace_ignored": true
+    "start_row": 1,
+    "end_row": 3
   }
-]
+}

blob/blob.go

@@ -6,7 +6,10 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/tendermint/tendermint/crypto/merkle"
+	"github.com/tendermint/tendermint/pkg/consts"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	coretypes "github.com/tendermint/tendermint/types"
 
 	"github.com/celestiaorg/celestia-app/pkg/appconsts"
 	"github.com/celestiaorg/celestia-app/pkg/shares"
@@ -16,42 +19,70 @@ import (
 	"github.com/celestiaorg/celestia-node/share"
 )
 
+//nolint:unused
 var errEmptyShares = errors.New("empty shares")
 
-// The Proof is a set of nmt proofs that can be verified only through
-// the included method (due to limitation of the nmt https://github.com/celestiaorg/nmt/issues/218).
-// Proof proves the WHOLE namespaced data to the row roots.
-// TODO (@vgonkivs): rework `Proof` in order to prove a particular blob.
-// https://github.com/celestiaorg/celestia-node/issues/2303
-type Proof []*nmt.Proof
-
-func (p Proof) Len() int { return len(p) }
+// Proof constructs the proof of a blob to the data root.
+type Proof struct {
+	// ShareToRowRootProof the proofs of the shares to the row roots they belong to.
+	// If the blob spans across multiple rows, then this will contain multiple proofs.
+	ShareToRowRootProof []*tmproto.NMTProof
+	// RowProof the proofs of the row roots containing the blob shares
+	// to the data root.
+	RowProof coretypes.RowProof
+}
 
-// equal is a temporary method that compares two proofs.
-// should be removed in BlobService V1.
-func (p Proof) equal(input Proof) error {
-	if p.Len() != input.Len() {
-		return ErrInvalidProof
+// Verify takes a blob and a data root and verifies if the
+// provided blob was committed to by the data root.
+func (p *Proof) Verify(blob *Blob, dataRoot []byte) (bool, error) {
+	blobCommitment, err := types.CreateCommitment(ToAppBlobs(blob)[0])
+	if err != nil {
+		return false, err
+	}
+	if !blob.Commitment.Equal(blobCommitment) {
+		return false, fmt.Errorf("%w: generated commitment does not match the provided blob commitment", ErrInvalidProof)
 	}
+	rawShares, err := BlobsToShares(blob)
+	if err != nil {
+		return false, err
+	}
+	return p.VerifyShares(rawShares, blob.namespace, dataRoot)
+}
 
-	for i, proof := range p {
-		pNodes := proof.Nodes()
-		inputNodes := input[i].Nodes()
-		for i, node := range pNodes {
-			if !bytes.Equal(node, inputNodes[i]) {
-				return ErrInvalidProof
-			}
-		}
+// VerifyShares takes a set of shares, a namespace and a data root, and verifies if the
+// provided shares are committed to by the data root.
+func (p *Proof) VerifyShares(rawShares [][]byte, namespace share.Namespace, dataRoot []byte) (bool, error) {
+	// verify the row proof
+	if !p.RowProof.VerifyProof(dataRoot) {
+		return false, fmt.Errorf("%w: invalid row root to data root proof", ErrInvalidProof)
+	}
 
-		if proof.Start() != input[i].Start() || proof.End() != input[i].End() {
-			return ErrInvalidProof
+	// verify the share proof
+	ns := append([]byte{namespace.Version()}, namespace.ID()...)
+	cursor := int32(0)
+	for i, proof := range p.ShareToRowRootProof {
+		nmtProof := nmt.NewInclusionProof(
+			int(proof.Start),
+			int(proof.End),
+			proof.Nodes,
+			true,
+		)
+		sharesUsed := proof.End - proof.Start
+		if len(rawShares) < int(sharesUsed+cursor) {
+			return false, fmt.Errorf("%w: invalid number of shares", ErrInvalidProof)
 		}
-
-		if !bytes.Equal(proof.LeafHash(), input[i].LeafHash()) {
-			return ErrInvalidProof
+		valid := nmtProof.VerifyInclusion(
+			consts.NewBaseHashFunc(),
+			ns,
+			rawShares[cursor:sharesUsed+cursor],
+			p.RowProof.RowRoots[i],
+		)
+		if !valid {
+			return false, ErrInvalidProof
 		}
+		cursor += sharesUsed
 	}
-	return nil
+	return true, nil
 }
 
 // Blob represents any application-specific binary data that anyone can submit to Celestia.
@@ -172,3 +203,10 @@ func (b *Blob) UnmarshalJSON(data []byte) error {
 	b.index = blob.Index
 	return nil
 }
+
+// proveRowRootsToDataRoot creates a set of binary merkle proofs for all the
+// roots defined by the range [start, end).
+func proveRowRootsToDataRoot(roots [][]byte, start, end int) []*merkle.Proof {
+	_, proofs := merkle.ProofsFromByteSlices(roots)
+	return proofs[start:end]
+}

blob/helper.go

@@ -39,7 +39,7 @@ func BlobsToShares(blobs ...*Blob) ([]share.Share, error) {
 
 // ToAppBlobs converts node's blob type to the blob type from celestia-app.
 func ToAppBlobs(blobs ...*Blob) []*apptypes.Blob {
-	appBlobs := make([]*apptypes.Blob, 0, len(blobs))
+	appBlobs := make([]*apptypes.Blob, len(blobs))
 	for i := range blobs {
 		appBlobs[i] = &blobs[i].Blob
 	}

blob/parser.go

@@ -21,6 +21,8 @@ type parser struct {
 
 // set tries to find the first blob's share by skipping padding shares and
 // sets the metadata of the blob(index and length)
+//
+//nolint:unused
 func (p *parser) set(index int, shrs []shares.Share) ([]shares.Share, error) {
 	if len(shrs) == 0 {
 		return nil, errEmptyShares
@@ -113,6 +115,8 @@ func (p *parser) parse() (*Blob, error) {
 
 // skipPadding iterates through the shares until non-padding share will be found. It guarantees that
 // the returned set of shares will start with non-padding share(or empty set of shares).
+//
+//nolint:unused
 func (p *parser) skipPadding(shares []shares.Share) ([]shares.Share, error) {
 	if len(shares) == 0 {
 		return nil, errEmptyShares
@@ -144,6 +148,7 @@ func (p *parser) verify(blob *Blob) bool {
 	return p.verifyFn(blob)
 }
 
+//nolint:unused
 func (p *parser) isEmpty() bool {
 	return p.index == 0 && p.length == 0 && len(p.shares) == 0
 }