removing zk tree usage (#1529)

* wip: removing zk tree usage

* simplify tree

* fix unit tests + update lint version

* fix test and some p2p deps

* disable nft tests for now

* disable nft test

* review comment

Author: mikiquantum

Makefile

@@ -23,7 +23,7 @@ install-deps: ## Install Dependencies
 	@go install github.com/swaggo/swag/cmd/swag
 	@go install github.com/ethereum/go-ethereum/cmd/abigen
 	@git submodule update --init --recursive
-	@command -v golangci-lint >/dev/null 2>&1 || (curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b ${GOPATH}/bin v1.45.2)
+	@command -v golangci-lint >/dev/null 2>&1 || (curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b ${GOPATH}/bin v1.46.2)
 
 lint-check: ## runs linters on go code
 	@golangci-lint run --skip-dirs=build/*  --disable-all --enable=revive --enable=goimports --enable=vet --enable=nakedret \

centchain/api_test.go

@@ -38,11 +38,11 @@ func TestMain(m *testing.M) {
 
 func TestApi_GetMetadataLatest(t *testing.T) {
 	mockSAPI := new(MockSubstrateAPI)
-	mockSAPI.On("GetMetadataLatest").Return(types.NewMetadataV8(), nil).Once()
+	mockSAPI.On("GetMetadataLatest").Return(types.NewMetadataV14(), nil).Once()
 	api := NewAPI(mockSAPI, nil, nil)
 	meta, err := api.GetMetadataLatest()
 	assert.NoError(t, err)
-	assert.Equal(t, types.NewMetadataV8(), meta)
+	assert.Equal(t, types.NewMetadataV14(), meta)
 }
 
 func TestApi_Call(t *testing.T) {

documents/coredocument.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 	"time"
 
+	"golang.org/x/crypto/blake2b"
+
 	coredocumentpb "github.com/centrifuge/centrifuge-protobufs/gen/go/coredocument"
 	"github.com/centrifuge/go-centrifuge/contextutil"
 	"github.com/centrifuge/go-centrifuge/crypto"
@@ -46,9 +48,6 @@ const (
 	// BasicDataRootField represents the basic document data tree root
 	BasicDataRootField = "bd_root"
 
-	// ZKDataRootField represents the zk document data tree root
-	ZKDataRootField = "zkd_root"
-
 	// SignaturesRootField represents the signatures property of a tree
 	SignaturesRootField = "signatures_root"
 
@@ -64,9 +63,6 @@ const (
 	// BasicDataRootPrefix represents the basic document data tree
 	BasicDataRootPrefix = "bdr_tree"
 
-	// ZKDataRootPrefix represents the zk document data tree
-	ZKDataRootPrefix = "zkdr_tree"
-
 	// SigningTreePrefix is the human readable prefix for signing tree props
 	SigningTreePrefix = "signing_tree"
 
@@ -103,8 +99,6 @@ func CompactProperties(key string) []byte {
 		return []byte{0, 0, 0, 10}
 	case BasicDataRootField:
 		return []byte{0, 0, 0, 11}
-	case ZKDataRootField:
-		return []byte{0, 0, 0, 12}
 	case CDTreePrefix:
 		return []byte{1, 0, 0, 0}
 	case SigningTreePrefix:
@@ -115,8 +109,6 @@ func CompactProperties(key string) []byte {
 		return []byte{4, 0, 0, 0}
 	case BasicDataRootPrefix:
 		return []byte{5, 0, 0, 0}
-	case ZKDataRootPrefix:
-		return []byte{6, 0, 0, 0}
 	default:
 		return []byte{}
 	}
@@ -411,49 +403,37 @@ func newRoleWithCollaborators(collaborators ...identity.DID) *coredocumentpb.Rol
 
 // CreateProofs takes document data leaves and list of fields and generates proofs.
 func (cd *CoreDocument) CreateProofs(docType string, dataLeaves []proofs.LeafNode, fields []string) (*DocumentProof, error) {
-	return cd.createProofs(false, docType, dataLeaves, fields)
-}
-
-// CreateProofsFromZKTree takes document data leaves and list of fields and generates proofs from ZK-ready Tree.
-func (cd *CoreDocument) CreateProofsFromZKTree(docType string, dataLeaves []proofs.LeafNode, fields []string) (*DocumentProof, error) {
-	return cd.createProofs(true, docType, dataLeaves, fields)
+	return cd.createProofs(docType, dataLeaves, fields)
 }
 
 // createProofs takes document data tree and list to fields and generates proofs.
 // it will generate proofs from the dataTree and cdTree.
 // It only generates proofs up to the root of the tree/s that correspond to
-func (cd *CoreDocument) createProofs(fromZKTree bool, docType string, dataLeaves []proofs.LeafNode, fields []string) (*DocumentProof, error) {
+func (cd *CoreDocument) createProofs(docType string, dataLeaves []proofs.LeafNode, fields []string) (*DocumentProof, error) {
 	treeProofs := make(map[string]*proofs.DocumentTree, 4)
 	drTree, err := cd.DocumentRootTree(docType, dataLeaves)
 	if err != nil {
 		return nil, err
 	}
 
-	signatureTree, err := cd.GetSignaturesDataTree()
+	signaturesTree, err := cd.GetSignaturesDataTree()
 	if err != nil {
 		return nil, errors.NewTypedError(ErrCDTree, errors.New("failed to generate signatures tree: %v", err))
 	}
 
-	dTrees, sdr, err := cd.SigningDataTrees(docType, dataLeaves)
+	signingTree, err := cd.SigningDataTree(docType, dataLeaves)
 	if err != nil {
 		return nil, errors.NewTypedError(ErrCDTree, errors.New("failed to generate signing data trees: %v", err))
 	}
-	basicDataTree := dTrees[0]
-	zkDataTree := dTrees[1]
 
 	dataPrefix, err := getDataTreePrefix(dataLeaves)
 	if err != nil {
 		return nil, err
 	}
 
-	targetTree := basicDataTree
-	if fromZKTree {
-		targetTree = zkDataTree
-	}
-
-	treeProofs[dataPrefix] = targetTree
+	treeProofs[dataPrefix] = signingTree
 	treeProofs[CDTreePrefix] = treeProofs[dataPrefix]
-	treeProofs[SignaturesTreePrefix] = signatureTree
+	treeProofs[SignaturesTreePrefix] = signaturesTree
 	treeProofs[DRTreePrefix] = drTree
 
 	rawProofs, err := generateProofs(fields, treeProofs)
@@ -463,10 +443,8 @@ func (cd *CoreDocument) createProofs(fromZKTree bool, docType string, dataLeaves
 
 	return &DocumentProof{
 		FieldProofs:    rawProofs,
-		LeftDataRooot:  basicDataTree.RootHash(),
-		RightDataRoot:  zkDataTree.RootHash(),
-		SigningRoot:    sdr,
-		SignaturesRoot: signatureTree.RootHash(),
+		SigningRoot:    signingTree.RootHash(),
+		SignaturesRoot: signaturesTree.RootHash(),
 	}, nil
 }
 
@@ -619,99 +597,34 @@ func (cd *CoreDocument) DocumentRootTree(docType string, dataLeaves []proofs.Lea
 	return tree, nil
 }
 
-func (cd *CoreDocument) basicDataTree(dataLeaves []proofs.LeafNode, cdLeaves []proofs.LeafNode) (tree *proofs.DocumentTree, err error) {
+// SigningDataTree returns the merkle tree + signingRoot Hash for the document data tree provided
+func (cd *CoreDocument) SigningDataTree(docType string, dataLeaves []proofs.LeafNode) (trees *proofs.DocumentTree, err error) {
 	if dataLeaves == nil {
 		return nil, errors.NewTypedError(ErrCDTree, errors.New("data tree is invalid"))
 	}
-	if cdLeaves == nil {
-		return nil, errors.NewTypedError(ErrCDTree, errors.New("cd tree is invalid"))
-	}
-	// create the docDataTrees out of docData and coredoc trees
-	tree, err = cd.DefaultTreeWithPrefix(BasicDataRootPrefix, CompactProperties(BasicDataRootPrefix))
-	if err != nil {
-		return nil, err
-	}
-	err = tree.AddLeaves(append(dataLeaves, cdLeaves...))
-	if err != nil {
-		return nil, err
-	}
-	err = tree.Generate()
+	cdLeaves, err := cd.coredocLeaves(docType)
 	if err != nil {
 		return nil, err
 	}
-	return tree, nil
-}
 
-func (cd *CoreDocument) zkDataTree(dataLeaves []proofs.LeafNode, cdLeaves []proofs.LeafNode) (tree *proofs.DocumentTree, err error) {
-	if dataLeaves == nil {
-		return nil, errors.NewTypedError(ErrCDTree, errors.New("data tree is invalid"))
-	}
-	if cdLeaves == nil {
-		return nil, errors.NewTypedError(ErrCDTree, errors.New("cd tree is invalid"))
-	}
 	// create the docDataTrees out of docData and coredoc trees
-	tree, err = cd.DefaultZTreeWithPrefix(ZKDataRootPrefix, CompactProperties(ZKDataRootPrefix))
+	tree, err := cd.DefaultTreeWithPrefix(SigningTreePrefix, CompactProperties(SigningTreePrefix))
 	if err != nil {
 		return nil, err
 	}
-	err = tree.AddLeaves(append(dataLeaves, cdLeaves...))
-	if err != nil {
-		return nil, err
-	}
-	err = tree.Generate()
-	if err != nil {
-		return nil, err
-	}
-	return tree, nil
-}
 
-// SigningDataTrees returns the merkle trees (basicData and zkData) + signingRoot Hash for the document data tree provided
-func (cd *CoreDocument) SigningDataTrees(docType string, dataLeaves []proofs.LeafNode) (trees []*proofs.DocumentTree, rootHash []byte, err error) {
-	if dataLeaves == nil {
-		return nil, nil, errors.NewTypedError(ErrCDTree, errors.New("data tree is invalid"))
-	}
-	cdLeaves, err := cd.coredocLeaves(docType)
-	if err != nil {
-		return nil, nil, err
-	}
-	// create the docDataTrees out of docData and coredoc trees
-	tree, err := cd.DefaultOrderedTreeWithPrefix(SigningTreePrefix, CompactProperties(SigningTreePrefix))
-	if err != nil {
-		return nil, nil, err
-	}
-	basicTree, err := cd.basicDataTree(dataLeaves, cdLeaves)
+	signingDataLeaves := append(dataLeaves, cdLeaves...)
+	err = tree.AddLeaves(signingDataLeaves)
 	if err != nil {
-		return nil, nil, err
-	}
-	zkTree, err := cd.zkDataTree(dataLeaves, cdLeaves)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// The first leave added is the basic data tree root
-	err = tree.AddLeaf(proofs.LeafNode{
-		Hash:     basicTree.RootHash(),
-		Hashed:   true,
-		Property: NewLeafProperty(fmt.Sprintf("%s.%s", SigningTreePrefix, BasicDataRootField), append(CompactProperties(SigningTreePrefix), CompactProperties(BasicDataRootField)...))})
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// The second leave added is the zkSnarks docData tree root
-	err = tree.AddLeaf(proofs.LeafNode{
-		Hash:     zkTree.RootHash(),
-		Hashed:   true,
-		Property: NewLeafProperty(fmt.Sprintf("%s.%s", SigningTreePrefix, ZKDataRootField), append(CompactProperties(SigningTreePrefix), CompactProperties(ZKDataRootField)...))})
-	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	err = tree.Generate()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	return []*proofs.DocumentTree{basicTree, zkTree}, tree.RootHash(), nil
+	return tree, nil
 }
 
 func (cd *CoreDocument) coredocRawTree(docType string) (*proofs.DocumentTree, error) {
@@ -732,7 +645,11 @@ func (cd *CoreDocument) coredocRawTree(docType string) (*proofs.DocumentTree, er
 		Value:    []byte(docType),
 	}
 
-	err = documentTypeNode.HashNode(sha3.NewLegacyKeccak256(), true)
+	b2b, err := blake2b.New256(nil)
+	if err != nil {
+		return nil, err
+	}
+	err = documentTypeNode.HashNode(b2b, true)
 	if err != nil {
 		return nil, err
 	}
@@ -880,12 +797,12 @@ func (cd *CoreDocument) CalculateDocumentRoot(docType string, dataLeaves []proof
 
 // CalculateSigningRoot calculates the signing root of the core document.
 func (cd *CoreDocument) CalculateSigningRoot(docType string, dataLeaves []proofs.LeafNode) ([]byte, error) {
-	_, treeHash, err := cd.SigningDataTrees(docType, dataLeaves)
+	tree, err := cd.SigningDataTree(docType, dataLeaves)
 	if err != nil {
 		return nil, err
 	}
 
-	return treeHash, nil
+	return tree.RootHash(), nil
 }
 
 // PackCoreDocument prepares the document into a core document.