code: func CreateChaincodeProposalWithTxIDNonceAndTransient(txid string, typ common.HeaderType, chainID string, cis *peer.ChaincodeInvocationSpec, nonce, creator []byte, transientMap map[string][]byte) (*peer.Proposal, string, error) {
  	ccHdrExt := &peer.ChaincodeHeaderExtension{ChaincodeId: cis.ChaincodeSpec.ChaincodeId}
  	ccHdrExtBytes, err := proto.Marshal(ccHdrExt)
  	if err != nil {
  		return nil, "", errors.Wrap(err, "error marshaling ChaincodeHeaderExtension")
  	}
  
  	cisBytes, err := proto.Marshal(cis)
  	if err != nil {
  		return nil, "", errors.Wrap(err, "error marshaling ChaincodeInvocationSpec")
  	}
  
  	ccPropPayload := &peer.ChaincodeProposalPayload{Input: cisBytes, TransientMap: transientMap}
  	ccPropPayloadBytes, err := proto.Marshal(ccPropPayload)
  	if err != nil {
  		return nil, "", errors.Wrap(err, "error marshaling ChaincodeProposalPayload")
  	}
  
  	// TODO: epoch is now set to zero. This must be changed once we
  	// get a more appropriate mechanism to handle it in.
  	var epoch uint64
  
  	timestamp := util.CreateUtcTimestamp()
  
  	hdr := &common.Header{
  		ChannelHeader: MarshalOrPanic(
  			&common.ChannelHeader{
  				Type:      int32(typ),
  				TxId:      txid,
  				Timestamp: timestamp,
  				ChannelId: chainID,
  				Extension: ccHdrExtBytes,
  				Epoch:     epoch,
  			},
  		),
  		SignatureHeader: MarshalOrPanic(
  			&common.SignatureHeader{
  				Nonce:   nonce,
  				Creator: creator,
  			},
  		),
  	}
  
  	hdrBytes, err := proto.Marshal(hdr)
  	if err != nil {
  		return nil, "", err
  	}
  
  	prop := &peer.Proposal{
  		Header:  hdrBytes,
  		Payload: ccPropPayloadBytes,
  	}
  	return prop, txid, nil
  }
docs: // CreateChaincodeProposalWithTxIDNonceAndTransient creates a proposal from
  // given input