chore(deps): upgrade to celestia-app v2.0.0-rc2

api/gateway/share.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/gorilla/mux"
 
-	"github.com/celestiaorg/celestia-app/pkg/shares"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/share"
 )

api/gateway/share_test.go

@@ -5,10 +5,10 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	coretypes "github.com/tendermint/tendermint/types"
 
-	"github.com/celestiaorg/celestia-app/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/pkg/shares"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	"github.com/celestiaorg/go-square/blob"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/share/sharetest"
 )
@@ -23,13 +23,13 @@ func Test_dataFromShares(t *testing.T) {
 	ns := sharetest.RandV0Namespace()
 	sss := shares.NewSparseShareSplitter()
 	for _, data := range testData {
-		b := coretypes.Blob{
+		b := blob.Blob{
 			Data:             data,
-			NamespaceID:      ns.ID(),
-			NamespaceVersion: ns.Version(),
-			ShareVersion:     appconsts.ShareVersionZero,
+			NamespaceId:      ns.ID(),
+			NamespaceVersion: uint32(ns.Version()),
+			ShareVersion:     uint32(appconsts.ShareVersionZero),
 		}
-		err := sss.Write(b)
+		err := sss.Write(&b)
 		require.NoError(t, err)
 	}
 

blob/blob.go

@@ -6,10 +6,12 @@ import (
 	"errors"
 	"fmt"
 
-	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/crypto/merkle"
 
-	"github.com/celestiaorg/celestia-app/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/x/blob/types"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	v1 "github.com/celestiaorg/celestia-app/v2/pkg/appconsts/v1"
+	"github.com/celestiaorg/go-square/blob"
+	"github.com/celestiaorg/go-square/inclusion"
 	"github.com/celestiaorg/nmt"
 
 	"github.com/celestiaorg/celestia-node/share"
@@ -69,7 +71,7 @@ func (p Proof) equal(input Proof) error {
 
 // Blob represents any application-specific binary data that anyone can submit to Celestia.
 type Blob struct {
-	types.Blob `json:"blob"`
+	*blob.Blob `json:"blob"`
 
 	Commitment Commitment `json:"commitment"`
 
@@ -97,18 +99,18 @@ func NewBlob(shareVersion uint8, namespace share.Namespace, data []byte) (*Blob,
 		return nil, err
 	}
 
-	blob := tmproto.Blob{
+	blob := blob.Blob{
 		NamespaceId:      namespace.ID(),
 		Data:             data,
 		ShareVersion:     uint32(shareVersion),
 		NamespaceVersion: uint32(namespace.Version()),
 	}
 
-	com, err := types.CreateCommitment(&blob)
+	com, err := inclusion.CreateCommitment(&blob, merkle.HashFromByteSlices, appconsts.SubtreeRootThreshold(v1.Version))
 	if err != nil {
 		return nil, err
 	}
-	return &Blob{Blob: blob, Commitment: com, namespace: namespace, index: -1}, nil
+	return &Blob{Blob: &blob, Commitment: com, namespace: namespace, index: -1}, nil
 }
 
 // Namespace returns blob's namespace.
@@ -146,18 +148,19 @@ func (b *Blob) MarshalJSON() ([]byte, error) {
 }
 
 func (b *Blob) UnmarshalJSON(data []byte) error {
-	var blob jsonBlob
-	err := json.Unmarshal(data, &blob)
+	var jsonBlob jsonBlob
+	err := json.Unmarshal(data, &jsonBlob)
 	if err != nil {
 		return err
 	}
 
-	b.Blob.NamespaceVersion = uint32(blob.Namespace.Version())
-	b.Blob.NamespaceId = blob.Namespace.ID()
-	b.Blob.Data = blob.Data
-	b.Blob.ShareVersion = blob.ShareVersion
-	b.Commitment = blob.Commitment
-	b.namespace = blob.Namespace
-	b.index = blob.Index
+	b.Blob = &blob.Blob{}
+	b.Blob.NamespaceVersion = uint32(jsonBlob.Namespace.Version())
+	b.Blob.NamespaceId = jsonBlob.Namespace.ID()
+	b.Blob.Data = jsonBlob.Data
+	b.Blob.ShareVersion = jsonBlob.ShareVersion
+	b.Commitment = jsonBlob.Commitment
+	b.namespace = jsonBlob.Namespace
+	b.index = jsonBlob.Index
 	return nil
 }

blob/blob_test.go

@@ -2,13 +2,19 @@ package blob
 
 import (
 	"bytes"
+	"fmt"
+	"math"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/types"
 
-	apptypes "github.com/celestiaorg/celestia-app/x/blob/types"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	v1 "github.com/celestiaorg/celestia-app/v2/pkg/appconsts/v1"
+	apptypes "github.com/celestiaorg/celestia-app/v2/x/blob/types"
+	"github.com/celestiaorg/go-square/blob"
+	"github.com/celestiaorg/go-square/inclusion"
+	"github.com/celestiaorg/go-square/merkle"
 
 	"github.com/celestiaorg/celestia-node/blob/blobtest"
 )
@@ -35,7 +41,11 @@ func TestBlob(t *testing.T) {
 		{
 			name: "compare commitments",
 			expectedRes: func(t *testing.T) {
-				comm, err := apptypes.CreateCommitment(&blob[0].Blob)
+				comm, err := inclusion.CreateCommitment(
+					blob[0].Blob,
+					merkle.HashFromByteSlices,
+					appconsts.SubtreeRootThreshold(v1.Version),
+				)
 				require.NoError(t, err)
 				assert.Equal(t, blob[0].Commitment, Commitment(comm))
 			},
@@ -69,7 +79,7 @@ func TestBlob(t *testing.T) {
 
 				newBlob := &Blob{}
 				require.NoError(t, newBlob.UnmarshalJSON(data))
-				require.True(t, bytes.Equal(blob[0].Blob.Data, newBlob.Data))
+				require.True(t, bytes.Equal(blob[0].Blob.GetData(), newBlob.Data))
 				require.True(t, bytes.Equal(blob[0].Commitment, newBlob.Commitment))
 			},
 		},
@@ -80,10 +90,13 @@ func TestBlob(t *testing.T) {
 	}
 }
 
-func convertBlobs(appBlobs ...types.Blob) ([]*Blob, error) {
+func convertBlobs(appBlobs ...*blob.Blob) ([]*Blob, error) {
 	blobs := make([]*Blob, 0, len(appBlobs))
-	for _, b := range appBlobs {
-		blob, err := NewBlob(b.ShareVersion, append([]byte{b.NamespaceVersion}, b.NamespaceID...), b.Data)
+	for _, appBlob := range appBlobs {
+		if shareVersion := appBlob.GetShareVersion(); shareVersion > math.MaxUint8 {
+			return nil, fmt.Errorf("share version %d is greater than max share version %d", shareVersion, math.MaxUint8)
+		}
+		blob, err := NewBlob(uint8(appBlob.GetShareVersion()), appBlob.Namespace().Bytes(), appBlob.GetData())
 		if err != nil {
 			return nil, err
 		}

blob/blobtest/testing.go

@@ -2,30 +2,30 @@ package blobtest
 
 import (
 	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/types"
 
-	"github.com/celestiaorg/celestia-app/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/pkg/shares"
-	"github.com/celestiaorg/celestia-app/test/util/testfactory"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	"github.com/celestiaorg/celestia-app/v2/test/util/testfactory"
+	"github.com/celestiaorg/go-square/blob"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/share"
 )
 
 // GenerateV0Blobs is a test utility producing v0 share formatted blobs with the
 // requested size and random namespaces.
-func GenerateV0Blobs(sizes []int, sameNamespace bool) ([]types.Blob, error) {
-	blobs := make([]types.Blob, 0, len(sizes))
+func GenerateV0Blobs(sizes []int, sameNamespace bool) ([]*blob.Blob, error) {
+	blobs := make([]*blob.Blob, 0, len(sizes))
 
 	for _, size := range sizes {
 		size := rawBlobSize(appconsts.FirstSparseShareContentSize * size)
 		appBlob := testfactory.GenerateRandomBlob(size)
 		if !sameNamespace {
-			nid, err := share.NewBlobNamespaceV0(tmrand.Bytes(7))
+			namespace, err := share.NewBlobNamespaceV0(tmrand.Bytes(7))
 			if err != nil {
 				return nil, err
 			}
-			appBlob.NamespaceVersion = nid[0]
-			appBlob.NamespaceID = nid[1:]
+			appBlob.NamespaceVersion = uint32(namespace[0])
+			appBlob.NamespaceId = namespace[1:]
 		}
 
 		blobs = append(blobs, appBlob)

blob/helper.go

@@ -4,29 +4,27 @@ import (
 	"bytes"
 	"sort"
 
-	"github.com/tendermint/tendermint/types"
-
-	"github.com/celestiaorg/celestia-app/pkg/shares"
-	apptypes "github.com/celestiaorg/celestia-app/x/blob/types"
+	squareblob "github.com/celestiaorg/go-square/blob"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/share"
 )
 
 // BlobsToShares accepts blobs and convert them to the Shares.
-func BlobsToShares(blobs ...*Blob) ([]share.Share, error) {
-	b := make([]types.Blob, len(blobs))
-	for i, blob := range blobs {
-		namespace := blob.Namespace()
-		b[i] = types.Blob{
-			NamespaceVersion: namespace[0],
-			NamespaceID:      namespace[1:],
-			Data:             blob.Data,
-			ShareVersion:     uint8(blob.ShareVersion),
+func BlobsToShares(nodeBlobs ...*Blob) ([]share.Share, error) {
+	b := make([]*squareblob.Blob, len(nodeBlobs))
+	for i, nodeBlob := range nodeBlobs {
+		namespace := nodeBlob.Namespace()
+		b[i] = &squareblob.Blob{
+			NamespaceVersion: uint32(namespace[0]),
+			NamespaceId:      namespace[1:],
+			Data:             nodeBlob.Data,
+			ShareVersion:     nodeBlob.ShareVersion,
 		}
 	}
 
 	sort.Slice(b, func(i, j int) bool {
-		val := bytes.Compare(b[i].NamespaceID, b[j].NamespaceID)
+		val := bytes.Compare(b[i].Namespace().Bytes(), b[j].Namespace().Bytes())
 		return val < 0
 	})
 
@@ -37,11 +35,11 @@ func BlobsToShares(blobs ...*Blob) ([]share.Share, error) {
 	return shares.ToBytes(rawShares), nil
 }
 
-// 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))
+// ToAppBlobs converts node's blob type to the blob type from go-square.
+func ToAppBlobs(blobs ...*Blob) []*squareblob.Blob {
+	appBlobs := make([]*squareblob.Blob, 0, len(blobs))
 	for i := range blobs {
-		appBlobs[i] = &blobs[i].Blob
+		appBlobs[i] = blobs[i].Blob
 	}
 	return appBlobs
 }

blob/parser.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/celestiaorg/celestia-app/pkg/shares"
+	"github.com/celestiaorg/go-square/shares"
 )
 
 // parser helps to collect shares and transform them into a blob.

blob/service.go

@@ -14,7 +14,7 @@ import (
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/trace"
 
-	"github.com/celestiaorg/celestia-app/pkg/shares"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/header"
 	"github.com/celestiaorg/celestia-node/libs/utils"
@@ -69,15 +69,15 @@ func NewService(
 func (s *Service) Submit(ctx context.Context, blobs []*Blob, txConfig *SubmitOptions) (uint64, error) {
 	log.Debugw("submitting blobs", "amount", len(blobs))
 
-	appblobs := make([]*state.Blob, len(blobs))
+	squareBlobs := make([]*state.Blob, len(blobs))
 	for i := range blobs {
 		if err := blobs[i].Namespace().ValidateForBlob(); err != nil {
 			return 0, err
 		}
-		appblobs[i] = &blobs[i].Blob
+		squareBlobs[i] = blobs[i].Blob
 	}
 
-	resp, err := s.blobSubmitter.SubmitPayForBlob(ctx, appblobs, txConfig)
+	resp, err := s.blobSubmitter.SubmitPayForBlob(ctx, squareBlobs, txConfig)
 	if err != nil {
 		return 0, err
 	}

blob/service_test.go

@@ -17,10 +17,10 @@ import (
 	"github.com/stretchr/testify/require"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 
-	"github.com/celestiaorg/celestia-app/pkg/appconsts"
-	appns "github.com/celestiaorg/celestia-app/pkg/namespace"
-	"github.com/celestiaorg/celestia-app/pkg/shares"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
 	"github.com/celestiaorg/go-header/store"
+	squarens "github.com/celestiaorg/go-square/namespace"
+	"github.com/celestiaorg/go-square/shares"
 
 	"github.com/celestiaorg/celestia-node/blob/blobtest"
 	"github.com/celestiaorg/celestia-node/header"
@@ -343,7 +343,7 @@ func TestBlobService_Get(t *testing.T) {
 		{
 			name: "empty result and err when blobs were not found ",
 			doFn: func() (interface{}, error) {
-				nid, err := share.NewBlobNamespaceV0(tmrand.Bytes(appns.NamespaceVersionZeroIDSize))
+				nid, err := share.NewBlobNamespaceV0(tmrand.Bytes(squarens.NamespaceVersionZeroIDSize))
 				require.NoError(t, err)
 				return service.GetAll(ctx, 1, []share.Namespace{nid})
 			},
@@ -628,8 +628,8 @@ func TestSkipPaddingsAndRetrieveBlob(t *testing.T) {
 
 	appBlob, err := blobtest.GenerateV0Blobs([]int{6}, true)
 	require.NoError(t, err)
-	appBlob[0].NamespaceVersion = nid[0]
-	appBlob[0].NamespaceID = nid[1:]
+	appBlob[0].NamespaceVersion = uint32(nid[0])
+	appBlob[0].NamespaceId = nid[1:]
 
 	blobs, err := convertBlobs(appBlob...)
 	require.NoError(t, err)

cmd/cel-key/main.go

@@ -12,8 +12,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/spf13/cobra"
 
-	"github.com/celestiaorg/celestia-app/app"
-	"github.com/celestiaorg/celestia-app/app/encoding"
+	"github.com/celestiaorg/celestia-app/v2/app"
+	"github.com/celestiaorg/celestia-app/v2/app/encoding"
 )
 
 var encodingConfig = encoding.MakeConfig(app.ModuleEncodingRegisters...)

cmd/start.go

@@ -10,8 +10,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/spf13/cobra"
 
-	"github.com/celestiaorg/celestia-app/app"
-	"github.com/celestiaorg/celestia-app/app/encoding"
+	"github.com/celestiaorg/celestia-app/v2/app"
+	"github.com/celestiaorg/celestia-app/v2/app/encoding"
 
 	"github.com/celestiaorg/celestia-node/nodebuilder"
 )

core/eds.go

@@ -8,11 +8,11 @@ import (
 	"github.com/filecoin-project/dagstore"
 	"github.com/tendermint/tendermint/types"
 
-	"github.com/celestiaorg/celestia-app/app"
-	"github.com/celestiaorg/celestia-app/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/pkg/shares"
-	"github.com/celestiaorg/celestia-app/pkg/square"
-	"github.com/celestiaorg/celestia-app/pkg/wrapper"
+	"github.com/celestiaorg/celestia-app/v2/app"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	"github.com/celestiaorg/celestia-app/v2/pkg/wrapper"
+	"github.com/celestiaorg/go-square/shares"
+	"github.com/celestiaorg/go-square/square"
 	"github.com/celestiaorg/nmt"
 	"github.com/celestiaorg/rsmt2d"
 
@@ -32,7 +32,11 @@ func extendBlock(data types.Data, appVersion uint64, options ...nmt.Option) (*rs
 	}
 
 	// Construct the data square from the block's transactions
-	dataSquare, err := square.Construct(data.Txs.ToSliceOfBytes(), appVersion, appconsts.SquareSizeUpperBound(appVersion))
+	dataSquare, err := square.Construct(
+		data.Txs.ToSliceOfBytes(),
+		appconsts.SquareSizeUpperBound(appVersion),
+		appconsts.SubtreeRootThreshold(appVersion),
+	)
 	if err != nil {
 		return nil, err
 	}