fork-det: Add function for serializing update batch

This CR adds a function to serialize an update batch
The intention is to use this for computing hash
of the update batch.

FAB-14598 #done

Change-Id: I4c73dca59aebe8588d10f6346f9055f9649f750c
Signed-off-by: manish <manish.sethi@gmail.com>
(cherry picked from commit 4b03bd0)
(cherry picked from commit 8a7a431)

Author: manish-sethi

core/ledger/kvledger/txmgmt/privacyenabledstate/db.go

@@ -157,6 +157,18 @@ func (nsb nsBatch) GetCollectionNames() []string {
 	return nsb.GetUpdatedNamespaces()
 }
 
+func (nsb nsBatch) getCollectionUpdates(collName string) map[string]*statedb.VersionedValue {
+	return nsb.GetUpdates(collName)
+}
+
+func (b UpdateMap) getUpdatedNamespaces() []string {
+	namespaces := []string{}
+	for ns := range b {
+		namespaces = append(namespaces, ns)
+	}
+	return namespaces
+}
+
 func (b UpdateMap) getOrCreateNsBatch(ns string) nsBatch {
 	batch, ok := b[ns]
 	if !ok {

core/ledger/kvledger/txmgmt/privacyenabledstate/update_batch.pb.go

@@ -0,0 +1,23 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+syntax = "proto3";
+
+option go_package = "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/privacyenabledstate";
+
+package privacyenabledstate;
+
+message KVWriteProto {
+    string namespace = 1;
+    string collection = 2;
+    bytes key = 3;
+    bool isDelete = 4;
+    bytes value = 5;
+    bytes version_bytes = 6;
+}
+
+message KVWritesBatchProto {
+    repeated KVWriteProto kvwrites = 1;
+}

core/ledger/kvledger/txmgmt/privacyenabledstate/update_batch.proto

@@ -0,0 +1,96 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package privacyenabledstate
+
+import (
+	"sort"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb"
+	"github.com/hyperledger/fabric/core/ledger/util"
+	"github.com/pkg/errors"
+)
+
+type updatesBytesBuilder struct {
+}
+
+// DeterministicBytesForPubAndHashUpdates constructs the bytes for a given UpdateBatch
+// while constructing the bytes, it considers only public writes and hashed writes for
+// the collections. For achieveing the determinism, it constructs a slice of proto messages
+// of type 'KVWriteProto'. In the slice, all the writes for a namespace "ns1" appear before
+// the writes for another namespace "ns2" if "ns1" < "ns2" (lexicographically). Within a
+// namespace, all the public writes appear before the collection writes. Like namespaces,
+// the collections writes within a namespace appear in the order of lexicographical order.
+// If an entry has the same namespace as its preceding entry, the namespcae field is skipped.
+// A Similar treatment is given to the repeative entries for a collection within a namespace.
+// For illustration, see the corresponding unit tests
+func (bb *updatesBytesBuilder) DeterministicBytesForPubAndHashUpdates(u *UpdateBatch) ([]byte, error) {
+	pubUpdates := u.PubUpdates
+	hashUpdates := u.HashUpdates.UpdateMap
+	namespaces := dedupAndSort(
+		pubUpdates.GetUpdatedNamespaces(),
+		hashUpdates.getUpdatedNamespaces(),
+	)
+
+	kvWritesProto := []*KVWriteProto{}
+	for _, ns := range namespaces {
+		p := bb.buildForKeys(pubUpdates.GetUpdates(ns))
+		collsForNs, ok := hashUpdates[ns]
+		if ok {
+			p = append(p, bb.buildForColls(collsForNs)...)
+		}
+		p[0].Namespace = ns
+		kvWritesProto = append(kvWritesProto, p...)
+	}
+	batchProto := &KVWritesBatchProto{
+		Kvwrites: kvWritesProto,
+	}
+
+	batchBytes, err := proto.Marshal(batchProto)
+	return batchBytes, errors.Wrap(err, "error constructing deterministic bytes from update batch")
+}
+
+func (bb *updatesBytesBuilder) buildForColls(colls nsBatch) []*KVWriteProto {
+	collNames := colls.GetCollectionNames()
+	sort.Strings(collNames)
+	collsProto := []*KVWriteProto{}
+	for _, collName := range collNames {
+		collUpdates := colls.getCollectionUpdates(collName)
+		p := bb.buildForKeys(collUpdates)
+		p[0].Collection = collName
+		collsProto = append(collsProto, p...)
+	}
+	return collsProto
+}
+
+func (bb *updatesBytesBuilder) buildForKeys(kv map[string]*statedb.VersionedValue) []*KVWriteProto {
+	keys := util.GetSortedKeys(kv)
+	p := []*KVWriteProto{}
+	for _, key := range keys {
+		val := kv[key]
+		p = append(
+			p,
+			&KVWriteProto{
+				Key:          []byte(key),
+				Value:        val.Value,
+				IsDelete:     val.Value == nil,
+				VersionBytes: val.Version.ToBytes(),
+			},
+		)
+	}
+	return p
+}
+
+func dedupAndSort(a, b []string) []string {
+	m := map[string]struct{}{}
+	for _, entry := range a {
+		m[entry] = struct{}{}
+	}
+	for _, entry := range b {
+		m[entry] = struct{}{}
+	}
+	return util.GetSortedKeys(m)
+}