rewrote metadata assembly code

Signed-off-by: Angelo De Caro <[email protected]>

Author: adecaro

integration/ports.go

@@ -60,8 +60,8 @@ var (
 
 	AllTestTypes = []*InfrastructureType{
 		WebSocketNoReplication,
-		LibP2PNoReplication,
-		WebSocketWithReplication,
+		// LibP2PNoReplication,
+		// WebSocketWithReplication,
 	}
 )
 

integration/token/interop/fabtoken/fabtoken_test.go

@@ -69,6 +69,7 @@ func newTestSuiteSingleFabric(commType fsc.P2PCommunicationType, factor int, nam
 		ReplicationOpts: opts,
 		DefaultTMSOpts:  common.TMSOpts{TokenSDKDriver: "fabtoken"},
 		SDKs:            []api2.SDK{&ffabtoken.SDK{}},
+		FSCLogSpec:      "token-sdk=debug:fabric-sdk=debug:info",
 	}))
 	return ts, selector
 }

token/core/fabtoken/transfer.go

@@ -67,21 +67,17 @@ func (s *TransferService) Transfer(ctx context.Context, _ string, _ driver.Owner
 		})
 	}
 
-	// assemble transfer metadata
+	// assemble transfer transferMetadata
 	ws := s.WalletService
-	metadata := &driver.TransferMetadata{
-		Inputs:       nil,
-		Outputs:      nil,
-		ExtraSigners: nil,
-	}
 
 	// inputs
+	transferInputsMetadata := make([]*driver.TransferInputMetadata, 0, len(inputTokens))
 	for i, t := range inputTokens {
 		auditInfo, err := s.Deserializer.GetOwnerAuditInfo(t.Owner, ws)
 		if err != nil {
 			return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(t.Owner).String())
 		}
-		metadata.Inputs = append(metadata.Inputs, &driver.TransferInputMetadata{
+		transferInputsMetadata = append(transferInputsMetadata, &driver.TransferInputMetadata{
 			TokenID: tokenIDs[i],
 			Senders: []*driver.AuditableIdentity{
 				{
@@ -98,57 +94,65 @@ func (s *TransferService) Transfer(ctx context.Context, _ string, _ driver.Owner
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "failed serializing output information")
 	}
+	transferOutputsMetadata := make([]*driver.TransferOutputMetadata, 0, len(outs))
 	for _, output := range outs {
+		var outputAudiInfo []byte
 		var receivers []driver.Identity
 		var receiversAuditInfo [][]byte
-		transferOutputMetadata := &driver.TransferOutputMetadata{
-			OutputMetadata:  outputMetadataRaw,
-			OutputAuditInfo: nil,
-			Receivers:       nil,
-		}
+		var outputReceivers []*driver.AuditableIdentity
 
 		if len(output.Owner) == 0 { // redeem
+			outputAudiInfo = nil
 			receivers = append(receivers, output.Owner)
 			receiversAuditInfo = append(receiversAuditInfo, []byte{})
+			outputReceivers = make([]*driver.AuditableIdentity, 0, 1)
 		} else {
+			outputAudiInfo, err = s.Deserializer.GetOwnerAuditInfo(output.Owner, ws)
+			if err != nil {
+				return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(output.Owner).String())
+			}
 			recipients, err := s.Deserializer.Recipients(output.Owner)
 			if err != nil {
 				return nil, nil, errors.Wrap(err, "failed getting recipients")
 			}
 			receivers = append(receivers, recipients...)
-			audiInfo, err := s.Deserializer.GetOwnerAuditInfo(output.Owner, ws)
-			if err != nil {
-				return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(output.Owner).String())
+			for _, receiver := range receivers {
+				receiverAudiInfo, err := s.Deserializer.GetOwnerAuditInfo(receiver, ws)
+				if err != nil {
+					return nil, nil, errors.Wrapf(err, "failed getting audit info for receiver identity [%s]", receiver)
+				}
+				receiversAuditInfo = append(receiversAuditInfo, receiverAudiInfo)
 			}
-			receiversAuditInfo = append(receiversAuditInfo, audiInfo)
+			outputReceivers = make([]*driver.AuditableIdentity, 0, len(recipients))
 		}
 		for i, receiver := range receivers {
-			transferOutputMetadata.Receivers = append(transferOutputMetadata.Receivers, &driver.AuditableIdentity{
+			outputReceivers = append(outputReceivers, &driver.AuditableIdentity{
 				Identity:  receiver,
 				AuditInfo: receiversAuditInfo[i],
 			})
 		}
 
-		metadata.Outputs = append(metadata.Outputs, transferOutputMetadata)
+		transferOutputsMetadata = append(transferOutputsMetadata, &driver.TransferOutputMetadata{
+			OutputMetadata:  outputMetadataRaw,
+			OutputAuditInfo: outputAudiInfo,
+			Receivers:       outputReceivers,
+		})
 	}
 
-	// receiverIsSender := make([]bool, len(receivers))
-	// for i, receiver := range receivers {
-	// 	_, err = ws.OwnerWallet(receiver)
-	// 	receiverIsSender[i] = err == nil
-	// }
-	//
-	// s.Logger.Debugf("Transfer metadata: [out:%d, rec:%d]", len(metadata.OutputsMetadata), len(metadata.Receivers))
-
 	// return
 	transfer := &TransferAction{
 		Inputs:      tokenIDs,
 		InputTokens: inputs,
 		Outputs:     outs,
 		Metadata:    meta.TransferActionMetadata(opts.Attributes),
 	}
+	transferMetadata := &driver.TransferMetadata{
+		Inputs:       transferInputsMetadata,
+		Outputs:      transferOutputsMetadata,
+		ExtraSigners: nil,
+	}
 
-	return transfer, metadata, nil
+	return transfer, transferMetadata, nil
 }
 
 // VerifyTransfer checks the outputs in the TransferAction against the passed tokenInfos

token/core/zkatdlog/nogh/transfer.go

@@ -144,27 +144,27 @@ func (s *TransferService) Transfer(ctx context.Context, txID string, _ driver.Ow
 	// return for each output its information in the clear
 	start := time.Now()
 	span.AddEvent("start_generate_zk_transfer")
-	action, outputMetadata, err := sender.GenerateZKTransfer(ctx, values, owners)
+	transfer, outputsMetadata, err := sender.GenerateZKTransfer(ctx, values, owners)
 	span.AddEvent("end_generate_zk_transfer")
 	duration := time.Since(start)
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "failed to generate zkatdlog transfer action for txid [%s]", txID)
 	}
 	s.Metrics.zkTransferDuration.Observe(float64(duration.Milliseconds()))
 
-	// add transfer action's metadata
-	action.Metadata = meta.TransferActionMetadata(opts.Attributes)
+	// add transfer action's transferMetadata
+	transfer.Metadata = meta.TransferActionMetadata(opts.Attributes)
 
 	// add upgrade witness
-	action.InputUpgradeWitness = make([]*token.UpgradeWitness, len(action.InputTokens))
-	for i := range action.InputTokens {
-		action.InputUpgradeWitness[i] = prepareInputs[i].UpgradeWitness
+	transfer.InputUpgradeWitness = make([]*token.UpgradeWitness, len(transfer.InputTokens))
+	for i := range transfer.InputTokens {
+		transfer.InputUpgradeWitness[i] = prepareInputs[i].UpgradeWitness
 	}
 
-	// prepare metadata
+	// prepare transferMetadata
 	ws := s.WalletService
 
-	var inputsMetadata []*driver.TransferInputMetadata
+	var transferInputsMetadata []*driver.TransferInputMetadata
 	tokens := prepareInputs.Tokens()
 	senderAuditInfos := make([][]byte, 0, len(tokens))
 	for i, t := range tokens {
@@ -175,7 +175,7 @@ func (s *TransferService) Transfer(ctx context.Context, txID string, _ driver.Ow
 		if len(auditInfo) == 0 {
 			s.Logger.Errorf("empty audit info for the owner [%s] of the i^th token [%s]", tokenIDs[i], driver.Identity(t.Owner))
 		}
-		inputsMetadata = append(inputsMetadata, &driver.TransferInputMetadata{
+		transferInputsMetadata = append(transferInputsMetadata, &driver.TransferInputMetadata{
 			TokenID: tokenIDs[i],
 			Senders: []*driver.AuditableIdentity{
 				{
@@ -186,58 +186,65 @@ func (s *TransferService) Transfer(ctx context.Context, txID string, _ driver.Ow
 		})
 	}
 
-	var outputsMetadata []*driver.TransferOutputMetadata
+	var transferOutputsMetadata []*driver.TransferOutputMetadata
 	for i, output := range outputTokens {
-		transferOutputMetadata := &driver.TransferOutputMetadata{}
+		var outputAudiInfo []byte
 		var receivers []driver.Identity
 		var receiversAuditInfo [][]byte
+		var outputReceivers []*driver.AuditableIdentity
+
 		if len(output.Owner) == 0 { // redeem
+			outputAudiInfo = nil
 			receivers = append(receivers, output.Owner)
 			receiversAuditInfo = append(receiversAuditInfo, []byte{})
+			outputReceivers = make([]*driver.AuditableIdentity, 0, 1)
 		} else {
+			outputAudiInfo, err = s.IdentityDeserializer.GetOwnerAuditInfo(output.Owner, ws)
+			if err != nil {
+				return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(output.Owner))
+			}
 			recipients, err := s.IdentityDeserializer.Recipients(output.Owner)
 			if err != nil {
 				return nil, nil, errors.Wrap(err, "failed getting recipients")
 			}
 			receivers = append(receivers, recipients...)
 			for _, receiver := range receivers {
-				auditInfo, err := s.IdentityDeserializer.GetOwnerAuditInfo(receiver, ws)
+				receiverAudiInfo, err := s.IdentityDeserializer.GetOwnerAuditInfo(receiver, ws)
 				if err != nil {
-					return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(receiver))
+					return nil, nil, errors.Wrapf(err, "failed getting audit info for receiver identity [%s]", receiver)
 				}
-				receiversAuditInfo = append(receiversAuditInfo, auditInfo)
+				receiversAuditInfo = append(receiversAuditInfo, receiverAudiInfo)
 			}
-			auditInfo, err := s.IdentityDeserializer.GetOwnerAuditInfo(output.Owner, s.WalletService)
-			if err != nil {
-				return nil, nil, errors.Wrapf(err, "failed getting audit info for sender identity [%s]", driver.Identity(output.Owner).String())
-			}
-			transferOutputMetadata.OutputAuditInfo = auditInfo
+			outputReceivers = make([]*driver.AuditableIdentity, 0, len(recipients))
 		}
-		for j, receiver := range receivers {
-			transferOutputMetadata.Receivers = append(transferOutputMetadata.Receivers, &driver.AuditableIdentity{
+		for i, receiver := range receivers {
+			outputReceivers = append(outputReceivers, &driver.AuditableIdentity{
 				Identity:  receiver,
-				AuditInfo: receiversAuditInfo[j],
+				AuditInfo: receiversAuditInfo[i],
 			})
 		}
 
-		raw, err := outputMetadata[i].Serialize()
+		outputMetadata, err := outputsMetadata[i].Serialize()
 		if err != nil {
 			return nil, nil, errors.WithMessage(err, "failed serializing token info for zkatdlog transfer action")
 		}
-		transferOutputMetadata.OutputMetadata = raw
 
-		outputsMetadata = append(outputsMetadata, transferOutputMetadata)
+		transferOutputsMetadata = append(transferOutputsMetadata, &driver.TransferOutputMetadata{
+			OutputMetadata:  outputMetadata,
+			OutputAuditInfo: outputAudiInfo,
+			Receivers:       outputReceivers,
+		})
 	}
 
-	s.Logger.Debugf("Transfer Action Prepared [id:%s,ins:%d:%d,outs:%d]", txID, len(tokenIDs), len(senderAuditInfos), action.NumOutputs())
+	s.Logger.Debugf("Transfer Action Prepared [id:%s,ins:%d:%d,outs:%d]", txID, len(tokenIDs), len(senderAuditInfos), transfer.NumOutputs())
 
-	metadata := &driver.TransferMetadata{
-		Inputs:       inputsMetadata,
-		Outputs:      outputsMetadata,
+	transferMetadata := &driver.TransferMetadata{
+		Inputs:       transferInputsMetadata,
+		Outputs:      transferOutputsMetadata,
 		ExtraSigners: nil,
 	}
 
-	return action, metadata, nil
+	return transfer, transferMetadata, nil
 }
 
 // VerifyTransfer checks the outputs in the TransferActionMetadata against the passed metadata

token/metadata.go

@@ -115,9 +115,12 @@ func (m *Metadata) FilterBy(eIDs ...string) (*Metadata, error) {
 					return nil, errors.Wrap(err, "failed getting enrollment ID")
 				}
 				if eIDSet.Contains(recipientEID) {
+					logger.Debugf("eid [%s] found in list [%v]", recipientEID, eIDs)
 					skip = false
 					found = true
 					break
+				} else {
+					logger.Debugf("eid [%s] not found in list [%v]", recipientEID, eIDs)
 				}
 			}
 			if found {

token/services/identity/msp/x509/deserializer.go

@@ -73,5 +73,6 @@ func (a *AuditInfoDeserializer) DeserializeAuditInfo(raw []byte) (driver2.AuditI
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to unmarshal")
 	}
+	logger.Debugf("audit info [%s]", string(raw))
 	return ai, nil
 }