FAB-10303 Clean up some assorted struct init

Many of our tests and some of our code are still using order based
initialization for structs.  This is very brittle and against bad
practices.  In an attempt to upgrade the version of protobuf to v1.1.0,
all of files in this changeset broke, because the number of struct
members in the generated code changed.  Although this does not include
any of the proto updates itself, this CR serves as a prerequisite to
doing so.

Change-Id: Ib09ac38735b24894bd413ddaaf59288678c6151d
Signed-off-by: Jason Yellick <jyellick@us.ibm.com>

Author: Jason Yellick

common/tools/idemixgen/idemixca/idemixca.go

@@ -92,12 +92,12 @@ func GenerateSignerConfig(isAdmin bool, ouString string, enrollmentId string, re
 	}
 
 	signer := &m.IdemixMSPSignerConfig{
-		credBytes,
-		idemix.BigToBytes(sk),
-		ouString,
-		isAdmin,
-		enrollmentId,
-		criBytes,
+		Cred: credBytes,
+		Sk:   idemix.BigToBytes(sk),
+		OrganizationalUnitIdentifier: ouString,
+		IsAdmin:                         isAdmin,
+		EnrollmentId:                    enrollmentId,
+		CredentialRevocationInformation: criBytes,
 	}
 
 	return proto.Marshal(signer)

common/tools/idemixgen/idemixca/idemixca_test.go

@@ -39,7 +39,7 @@ func TestIdemixCa(t *testing.T) {
 
 	writeVerifierToFile(ipkBytes, elliptic.Marshal(elliptic.P384(), revocationkey.X, revocationkey.Y))
 
-	key := &idemix.IssuerKey{isk, ipk}
+	key := &idemix.IssuerKey{Isk: isk, Ipk: ipk}
 
 	conf, err := GenerateSignerConfig(false, "OU1", "enrollmentid1", 1, key, revocationkey)
 	assert.NoError(t, err)

common/tools/idemixgen/idemixgen.go

@@ -123,7 +123,7 @@ func readIssuerKey() *idemix.IssuerKey {
 	}
 	ipk := &idemix.IssuerPublicKey{}
 	handleError(proto.Unmarshal(ipkBytes, ipk))
-	key := &idemix.IssuerKey{isk, ipk}
+	key := &idemix.IssuerKey{Isk: isk, Ipk: ipk}
 
 	return key
 }

core/common/privdata/store_test.go

@@ -56,7 +56,7 @@ func TestCollectionStore(t *testing.T) {
 	assert.Error(t, err)
 
 	cc := &common.CollectionConfig{Payload: &common.CollectionConfig_StaticCollectionConfig{&common.StaticCollectionConfig{Name: "mycollection"}}}
-	ccp := &common.CollectionConfigPackage{[]*common.CollectionConfig{cc}}
+	ccp := &common.CollectionConfigPackage{Config: []*common.CollectionConfig{cc}}
 	ccpBytes, err := proto.Marshal(ccp)
 	assert.NoError(t, err)
 	assert.NotNil(t, ccpBytes)

core/ledger/kvledger/txmgmt/pvtstatepurgemgmt/pvtdata_key_helper.go

@@ -31,9 +31,9 @@ func (colls *Collections) getOrCreateKeysAndHashes(coll string) *KeysAndHashes {
 }
 
 func newPvtdataKeys() *PvtdataKeys {
-	return &PvtdataKeys{make(map[string]*Collections)}
+	return &PvtdataKeys{Map: make(map[string]*Collections)}
 }
 
 func newCollections() *Collections {
-	return &Collections{make(map[string]*KeysAndHashes)}
+	return &Collections{Map: make(map[string]*KeysAndHashes)}
 }

core/ledger/pvtdatastorage/expiry_data_helper.go

@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0
 package pvtdatastorage
 
 func newExpiryData() *ExpiryData {
-	return &ExpiryData{make(map[string]*Collections)}
+	return &ExpiryData{Map: make(map[string]*Collections)}
 }
 
 func newCollections() *Collections {
-	return &Collections{make(map[string]*TxNums)}
+	return &Collections{Map: make(map[string]*TxNums)}
 }
 
 func (e *ExpiryData) add(ns, coll string, txNum uint64) {

idemix/credential.go

@@ -74,11 +74,11 @@ func NewCredential(key *IssuerKey, m *CredRequest, attrs []*FP256BN.BIG, rng *am
 	}
 
 	return &Credential{
-		EcpToProto(A),
-		EcpToProto(B),
-		BigToBytes(E),
-		BigToBytes(S),
-		CredAttrs}, nil
+		A:     EcpToProto(A),
+		B:     EcpToProto(B),
+		E:     BigToBytes(E),
+		S:     BigToBytes(S),
+		Attrs: CredAttrs}, nil
 }
 
 // Ver cryptographically verifies the credential by verifying the signature

idemix/credrequest.go

@@ -56,7 +56,11 @@ func NewCredRequest(sk *FP256BN.BIG, IssuerNonce *FP256BN.BIG, ipk *IssuerPublic
 	proofC := HashModOrder(proofData)
 	proofS := Modadd(FP256BN.Modmul(proofC, sk, GroupOrder), rSk, GroupOrder)
 
-	return &CredRequest{EcpToProto(Nym), BigToBytes(IssuerNonce), BigToBytes(proofC), BigToBytes(proofS)}
+	return &CredRequest{
+		Nym:         EcpToProto(Nym),
+		IssuerNonce: BigToBytes(IssuerNonce),
+		ProofC:      BigToBytes(proofC),
+		ProofS:      BigToBytes(proofS)}
 }
 
 // Check cryptographically verifies the credential request

idemix/nymsignature.go

@@ -63,10 +63,10 @@ func NewNymSignature(sk *FP256BN.BIG, Nym *FP256BN.ECP, RNym *FP256BN.BIG, ipk *
 
 	// The signature consists of the Fiat-Shamir hash (ProofC), the s-values (ProofSSk, ProofSRNym), and the nonce.
 	return &NymSignature{
-		BigToBytes(ProofC),
-		BigToBytes(ProofSSk),
-		BigToBytes(ProofSRNym),
-		BigToBytes(Nonce)}, nil
+		ProofC:     BigToBytes(ProofC),
+		ProofSSk:   BigToBytes(ProofSSk),
+		ProofSRNym: BigToBytes(ProofSRNym),
+		Nonce:      BigToBytes(Nonce)}, nil
 }
 
 // Ver verifies an idemix NymSignature

idemix/signature.go

@@ -172,23 +172,23 @@ func NewSignature(cred *Credential, sk *FP256BN.BIG, Nym *FP256BN.ECP, RNym *FP2
 	}
 
 	return &Signature{
-			EcpToProto(APrime),
-			EcpToProto(ABar),
-			EcpToProto(BPrime),
-			BigToBytes(ProofC),
-			BigToBytes(ProofSSk),
-			BigToBytes(ProofSE),
-			BigToBytes(ProofSR2),
-			BigToBytes(ProofSR3),
-			BigToBytes(ProofSSPrime),
-			ProofSAttrs,
-			BigToBytes(Nonce),
-			EcpToProto(Nym),
-			BigToBytes(ProofSRNym),
-			cri.EpochPk,
-			cri.EpochPkSig,
-			cri.Epoch,
-			nonRevokedProof},
+			APrime:             EcpToProto(APrime),
+			ABar:               EcpToProto(ABar),
+			BPrime:             EcpToProto(BPrime),
+			ProofC:             BigToBytes(ProofC),
+			ProofSSk:           BigToBytes(ProofSSk),
+			ProofSE:            BigToBytes(ProofSE),
+			ProofSR2:           BigToBytes(ProofSR2),
+			ProofSR3:           BigToBytes(ProofSR3),
+			ProofSSPrime:       BigToBytes(ProofSSPrime),
+			ProofSAttrs:        ProofSAttrs,
+			Nonce:              BigToBytes(Nonce),
+			Nym:                EcpToProto(Nym),
+			ProofSRNym:         BigToBytes(ProofSRNym),
+			RevocationEpochPk:  cri.EpochPk,
+			RevocationPkSig:    cri.EpochPkSig,
+			Epoch:              cri.Epoch,
+			NonRevocationProof: nonRevokedProof},
 		nil
 }
 

idemix/util.go

@@ -93,8 +93,8 @@ func BigToBytes(big *FP256BN.BIG) []byte {
 // EcpToProto converts a *amcl.ECP into the proto struct *ECP
 func EcpToProto(p *FP256BN.ECP) *ECP {
 	return &ECP{
-		BigToBytes(p.GetX()),
-		BigToBytes(p.GetY())}
+		X: BigToBytes(p.GetX()),
+		Y: BigToBytes(p.GetY())}
 }
 
 // EcpFromProto converts a proto struct *ECP into an *amcl.ECP
@@ -105,10 +105,10 @@ func EcpFromProto(p *ECP) *FP256BN.ECP {
 // Ecp2ToProto converts a *amcl.ECP2 into the proto struct *ECP2
 func Ecp2ToProto(p *FP256BN.ECP2) *ECP2 {
 	return &ECP2{
-		BigToBytes(p.GetX().GetA()),
-		BigToBytes(p.GetX().GetB()),
-		BigToBytes(p.GetY().GetA()),
-		BigToBytes(p.GetY().GetB())}
+		Xa: BigToBytes(p.GetX().GetA()),
+		Xb: BigToBytes(p.GetX().GetB()),
+		Ya: BigToBytes(p.GetY().GetA()),
+		Yb: BigToBytes(p.GetY().GetB())}
 }
 
 // Ecp2FromProto converts a proto struct *ECP2 into an *amcl.ECP2