From 5f17fde3c5f42f16548c57c1d3d9dce6e1547d1d Mon Sep 17 00:00:00 2001
From: Srinivasan Muralidharan <muralisr@us.ibm.com>
Date: Fri, 2 Dec 2016 10:46:57 -0500
Subject: [PATCH] FAB-1252 change chainID from []byte to string

https://jira.hyperledger.org/browse/FAB-1252

Most of the changes are syntactical and are helped by go's
strict type checking. The changes follow the simple change
of
   bytes chainID
to
   string chainID
in protos/common/common.proto.

Change-Id: Id25c009a8bff036098cee0491860907ce0daa02b
Signed-off-by: Srinivasan Muralidharan <muralisr@us.ibm.com>
---
 core/chaincode/shim/table.pb.go               |  54 ++--
 core/committer/noopssinglechain/client.go     |   4 +-
 core/crypto/attributes/proto/attributes.pb.go |  18 +-
 examples/chaincode/go/utxo/util/dah.pb.go     |  44 +--
 gossip/proto/message.pb.go                    | 127 ++++-----
 .../common/blockcutter/blockcutter_test.go    |   2 +-
 orderer/common/bootstrap/static/static.go     |   4 +-
 .../common/bootstrap/static/static_test.go    |   2 +-
 orderer/common/broadcast/broadcast.go         |   4 +-
 orderer/common/broadcast/broadcast_test.go    |  10 +-
 .../configfilter/configfilter_test.go         |   2 +-
 orderer/common/configtx/configtx.go           |  30 +--
 orderer/common/configtx/configtx_test.go      |  14 +-
 orderer/common/deliver/deliver.go             |   3 +-
 orderer/common/deliver/deliver_test.go        |   6 +-
 orderer/common/util/util.go                   |   2 +-
 orderer/common/util/util_test.go              |   2 +-
 orderer/multichain/manager.go                 |  16 +-
 orderer/multichain/manager_test.go            |   6 +-
 orderer/rawledger/blackbox_test.go            |   4 +-
 orderer/rawledger/fileledger/fileledger.go    |  14 +-
 orderer/rawledger/ramledger/ramledger.go      |  12 +-
 orderer/rawledger/rawledger.go                |   4 +-
 orderer/sbft/backend/backendab.go             |   8 +-
 orderer/sbft/backend/consensus.pb.go          |   8 +-
 orderer/sbft/config.pb.go                     |  36 +--
 orderer/sbft/simplebft/simplebft.pb.go        | 102 +++----
 orderer/solo/consensus_test.go                |   2 +-
 protos/common/common.pb.go                    |  92 +++----
 protos/common/common.proto                    |   2 +-
 protos/common/configuration.pb.go             |  70 ++---
 protos/orderer/ab.pb.go                       |  62 ++---
 protos/orderer/ab.proto                       |   2 +-
 protos/peer/chaincode.pb.go                   | 250 +++++++++++-------
 protos/peer/chaincode_proposal.pb.go          |  36 +--
 protos/peer/chaincode_transaction.pb.go       |  40 +--
 protos/peer/chaincodeevent.pb.go              |  93 +------
 protos/peer/events.pb.go                      |  65 ++---
 protos/peer/fabric.pb.go                      |  72 ++---
 protos/peer/fabric_message.pb.go              |  29 +-
 protos/peer/fabric_proposal.pb.go             |  32 +--
 protos/peer/fabric_proposal_response.pb.go    |  60 ++---
 protos/peer/fabric_service.pb.go              |  20 +-
 protos/peer/fabric_transaction.pb.go          |  50 ++--
 protos/peer/server_admin.pb.go                |  50 ++--
 protos/utils/configtxutils_test.go            |   6 +-
 protos/utils/proputils.go                     |   2 +-
 47 files changed, 787 insertions(+), 786 deletions(-)

diff --git a/core/chaincode/shim/table.pb.go b/core/chaincode/shim/table.pb.go
index 2526175e432..3b555527a28 100644
--- a/core/chaincode/shim/table.pb.go
+++ b/core/chaincode/shim/table.pb.go
@@ -369,31 +369,31 @@ func init() {
 func init() { proto.RegisterFile("table.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 404 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0xdd, 0x8a, 0x9b, 0x40,
-	0x14, 0x5e, 0xd7, 0xd1, 0xec, 0x9e, 0xdd, 0x16, 0x3b, 0x94, 0x20, 0xf4, 0xa6, 0x78, 0x51, 0xf6,
-	0xa6, 0x4a, 0x4d, 0xc8, 0x03, 0xd8, 0x2d, 0xed, 0x42, 0xd9, 0x2d, 0x13, 0x43, 0x69, 0xef, 0xd4,
-	0x4c, 0x74, 0xa8, 0x3a, 0x41, 0xc7, 0x96, 0x3c, 0x5c, 0xa1, 0x8f, 0xd6, 0xf9, 0x51, 0x08, 0xd9,
-	0xdc, 0x9d, 0xf3, 0xfd, 0x9c, 0x39, 0xe7, 0x53, 0xb8, 0x11, 0x59, 0x5e, 0xd3, 0x70, 0xdf, 0x71,
-	0xc1, 0x31, 0xea, 0x2b, 0xd6, 0x04, 0xff, 0x2c, 0xf0, 0x3e, 0xf2, 0x7a, 0x68, 0xda, 0x7b, 0xba,
-	0x63, 0x2d, 0x13, 0x8c, 0xb7, 0x18, 0x03, 0x6a, 0xb3, 0x86, 0xfa, 0xd6, 0x5b, 0xeb, 0xee, 0x9a,
-	0xe8, 0x1a, 0x47, 0x80, 0xc4, 0x61, 0x4f, 0xfd, 0x4b, 0x89, 0xbd, 0x8c, 0xdf, 0x84, 0xca, 0x1d,
-	0x9e, 0x3a, 0xc3, 0x54, 0x4a, 0x88, 0x16, 0x62, 0x0f, 0xec, 0x5f, 0xf4, 0xe0, 0xdb, 0x52, 0x7f,
-	0x45, 0x54, 0x19, 0x6c, 0x00, 0x29, 0x1e, 0x03, 0xb8, 0xeb, 0x94, 0x3c, 0x3c, 0x7e, 0xf6, 0x2e,
-	0xf0, 0x35, 0x38, 0x0f, 0x8f, 0xe9, 0x22, 0xf6, 0xac, 0xb1, 0x5c, 0x2d, 0xbd, 0x4b, 0xa5, 0xd8,
-	0x18, 0xd8, 0x9e, 0x6a, 0x89, 0x23, 0x25, 0x49, 0x7e, 0xa4, 0x9f, 0xd6, 0x9e, 0x83, 0xaf, 0x00,
-	0x25, 0x4f, 0x4f, 0x5f, 0x3d, 0x37, 0xc8, 0xc0, 0x49, 0xd5, 0x5d, 0x67, 0xd7, 0xbe, 0x87, 0x57,
-	0xc5, 0xc9, 0x92, 0xbd, 0xbc, 0xc1, 0xbe, 0xbb, 0x89, 0xe7, 0xe7, 0x6f, 0x20, 0xcf, 0x0d, 0xc1,
-	0x5f, 0x0b, 0x5c, 0xa3, 0xc3, 0x3e, 0xb8, 0xbd, 0xe8, 0x58, 0x5b, 0x9a, 0x67, 0xbe, 0x5c, 0x90,
-	0xb1, 0xc7, 0x73, 0x70, 0x58, 0x2b, 0x16, 0xb1, 0x8e, 0xc8, 0x91, 0x84, 0x69, 0x47, 0x7c, 0xb5,
-	0xd4, 0x51, 0xd8, 0x23, 0xbe, 0x5a, 0xaa, 0x49, 0x83, 0x31, 0x20, 0x49, 0xbc, 0x50, 0x93, 0x4c,
-	0x3f, 0x31, 0xd2, 0xe2, 0x48, 0x06, 0x4d, 0x8c, 0xf4, 0xc8, 0x59, 0xf9, 0x41, 0xd0, 0xde, 0x77,
-	0x25, 0x71, 0xab, 0x66, 0xe9, 0x16, 0xbf, 0x06, 0x94, 0x73, 0x5e, 0xfb, 0x33, 0x95, 0xb6, 0x84,
-	0x75, 0x97, 0xcc, 0xc0, 0xf9, 0x9d, 0xd5, 0x03, 0x0d, 0xde, 0x83, 0x4d, 0xf8, 0x1f, 0xfc, 0x0e,
-	0x66, 0xe6, 0xb6, 0x5e, 0x2e, 0xaf, 0x22, 0xb8, 0x3d, 0x8e, 0x80, 0x4c, 0x64, 0xf2, 0x1d, 0xe6,
-	0xbc, 0x2b, 0xc3, 0x4a, 0x7e, 0xac, 0xae, 0xa6, 0xdb, 0x92, 0x76, 0xe6, 0x9f, 0xe9, 0x13, 0xd0,
-	0x49, 0x7f, 0x53, 0xcd, 0xcf, 0x0f, 0x25, 0x13, 0xd5, 0x90, 0x87, 0x05, 0x6f, 0xa2, 0x23, 0x69,
-	0xb4, 0xcb, 0xf2, 0x8e, 0x15, 0x51, 0xc1, 0x3b, 0x1a, 0x15, 0x55, 0xc6, 0xda, 0x82, 0x6f, 0x69,
-	0xa4, 0x1e, 0xca, 0x5d, 0x3d, 0x66, 0xf1, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x35, 0x1b, 0xaf, 0x40,
-	0x89, 0x02, 0x00, 0x00,
+	// 413 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0xd1, 0x6a, 0xdb, 0x30,
+	0x14, 0x8d, 0x62, 0xd9, 0x69, 0x6f, 0xbb, 0xa1, 0x89, 0x11, 0x04, 0x7b, 0x31, 0x7e, 0x18, 0x7e,
+	0x99, 0xcd, 0x12, 0xe3, 0x0f, 0xf0, 0x3a, 0x96, 0xc2, 0x68, 0x87, 0xea, 0x32, 0xb6, 0x37, 0xdb,
+	0x55, 0x13, 0x31, 0xc7, 0x0a, 0xb6, 0xb2, 0xe1, 0x8f, 0x1b, 0xec, 0xd3, 0x86, 0xa4, 0x04, 0x4a,
+	0x9b, 0xb7, 0x7b, 0xee, 0x3d, 0xe7, 0xe8, 0xde, 0x83, 0xe0, 0x42, 0x57, 0x75, 0x2b, 0x92, 0x5d,
+	0xaf, 0xb4, 0xa2, 0x78, 0xd8, 0xc8, 0x6d, 0xf4, 0x0f, 0x01, 0xf9, 0xa4, 0xda, 0xfd, 0xb6, 0xbb,
+	0x12, 0x8f, 0xb2, 0x93, 0x5a, 0xaa, 0x8e, 0x52, 0xc0, 0x5d, 0xb5, 0x15, 0x0c, 0x85, 0x28, 0x3e,
+	0xe7, 0xb6, 0xa6, 0x29, 0x60, 0x3d, 0xee, 0x04, 0x9b, 0x86, 0x28, 0x7e, 0xbd, 0x78, 0x97, 0x18,
+	0x75, 0xf2, 0x5c, 0x99, 0x94, 0xe3, 0x4e, 0x70, 0x4b, 0xa4, 0x04, 0xbc, 0x5f, 0x62, 0x64, 0x5e,
+	0x88, 0xe2, 0x33, 0x6e, 0xca, 0xe8, 0x1e, 0xb0, 0x99, 0x53, 0x80, 0xe0, 0xae, 0xe4, 0xd7, 0x37,
+	0x5f, 0xc8, 0x84, 0x9e, 0x83, 0x7f, 0x7d, 0x53, 0x2e, 0x17, 0x04, 0x1d, 0xca, 0x3c, 0x23, 0x53,
+	0xc3, 0xb8, 0x77, 0x6d, 0xef, 0x58, 0xe7, 0x19, 0xc1, 0x86, 0x52, 0xfc, 0x28, 0x3f, 0xdf, 0x11,
+	0x9f, 0x9e, 0x01, 0x2e, 0x6e, 0x6f, 0xbf, 0x92, 0x20, 0xaa, 0xc0, 0x2f, 0xcd, 0x5d, 0x27, 0xd7,
+	0xbe, 0x82, 0x37, 0xcd, 0xb3, 0x25, 0x07, 0x36, 0x0d, 0xbd, 0xf8, 0x62, 0x31, 0x3f, 0x7d, 0x03,
+	0x7f, 0x29, 0x88, 0xfe, 0x22, 0x08, 0x1c, 0x8f, 0x32, 0x08, 0x06, 0xdd, 0xcb, 0x6e, 0xed, 0x9e,
+	0x59, 0x4d, 0xf8, 0x01, 0xd3, 0x39, 0xf8, 0xb2, 0xd3, 0xcb, 0x85, 0x8d, 0xc8, 0x5f, 0x4d, 0xb8,
+	0x83, 0x87, 0x7e, 0x9e, 0xd9, 0x28, 0xbc, 0x43, 0x3f, 0xcf, 0x8c, 0xd3, 0xde, 0x09, 0x70, 0x88,
+	0xe2, 0x57, 0xc6, 0xc9, 0xe1, 0xe3, 0x24, 0xcf, 0x98, 0x1f, 0xa2, 0x18, 0x1f, 0x27, 0x79, 0x66,
+	0xbc, 0xea, 0x51, 0x8b, 0x81, 0x05, 0x21, 0x8a, 0x2f, 0x8d, 0x97, 0x85, 0xf4, 0x2d, 0xe0, 0x5a,
+	0xa9, 0x96, 0xcd, 0x4c, 0xda, 0xab, 0x09, 0xb7, 0xa8, 0x98, 0x81, 0xff, 0xbb, 0x6a, 0xf7, 0x22,
+	0xfa, 0x00, 0x1e, 0x57, 0x7f, 0xe8, 0x7b, 0x98, 0xb9, 0xdb, 0x06, 0x86, 0x6c, 0x04, 0x97, 0x4f,
+	0x23, 0xe0, 0xc7, 0x61, 0xf1, 0x1d, 0xe6, 0xaa, 0x5f, 0x27, 0x9b, 0x71, 0x27, 0xfa, 0x56, 0x3c,
+	0xac, 0x45, 0xef, 0xfe, 0xcc, 0x50, 0x80, 0x4d, 0xfa, 0x9b, 0x01, 0x3f, 0x3f, 0xae, 0xa5, 0xde,
+	0xec, 0xeb, 0xa4, 0x51, 0xdb, 0xf4, 0x09, 0x35, 0x7d, 0xac, 0xea, 0x5e, 0x36, 0x69, 0xa3, 0x7a,
+	0x91, 0x36, 0x9b, 0x4a, 0x76, 0x8d, 0x7a, 0x10, 0xa9, 0x79, 0xa8, 0x0e, 0xac, 0xcd, 0xf2, 0x7f,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0x35, 0x1b, 0xaf, 0x40, 0x89, 0x02, 0x00, 0x00,
 }
diff --git a/core/committer/noopssinglechain/client.go b/core/committer/noopssinglechain/client.go
index 74c1d286238..bbc5a89af63 100644
--- a/core/committer/noopssinglechain/client.go
+++ b/core/committer/noopssinglechain/client.go
@@ -200,7 +200,7 @@ func (d *DeliverService) seekOldest() error {
 			Seek: &orderer.SeekInfo{
 				Start:      orderer.SeekInfo_OLDEST,
 				WindowSize: d.windowSize,
-				ChainID:    []byte(util.GetTestChainID()),
+				ChainID:    util.GetTestChainID(),
 			},
 		},
 	})
@@ -213,7 +213,7 @@ func (d *DeliverService) seekLatestFromCommitter(height uint64) error {
 				Start:           orderer.SeekInfo_SPECIFIED,
 				WindowSize:      d.windowSize,
 				SpecifiedNumber: height,
-				ChainID:         []byte(util.GetTestChainID()),
+				ChainID:         util.GetTestChainID(),
 			},
 		},
 	})
diff --git a/core/crypto/attributes/proto/attributes.pb.go b/core/crypto/attributes/proto/attributes.pb.go
index 0c3d8652528..78492f8f2e8 100644
--- a/core/crypto/attributes/proto/attributes.pb.go
+++ b/core/crypto/attributes/proto/attributes.pb.go
@@ -68,18 +68,18 @@ func init() {
 func init() { proto1.RegisterFile("attributes.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 202 bytes of a gzipped FileDescriptorProto
+	// 204 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0x48, 0x2c, 0x29, 0x29,
 	0xca, 0x4c, 0x2a, 0x2d, 0x49, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53,
 	0xc5, 0x4a, 0xc9, 0x5c, 0xe2, 0x8e, 0x70, 0x39, 0xdf, 0xd4, 0x92, 0xc4, 0x94, 0xc4, 0x92, 0x44,
 	0xd7, 0xbc, 0x92, 0xa2, 0x4a, 0x21, 0x15, 0x2e, 0x5e, 0xb8, 0x94, 0x5f, 0x62, 0x6e, 0xaa, 0x04,
 	0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0xaa, 0xa0, 0x90, 0x12, 0x17, 0x0f, 0x5c, 0xc0, 0x3b, 0xb5,
-	0x52, 0x82, 0x09, 0xa8, 0x88, 0x27, 0x08, 0x45, 0x4c, 0x29, 0x9b, 0x4b, 0x08, 0xd3, 0x12, 0x21,
-	0x29, 0x2e, 0x0e, 0x18, 0x1b, 0x6c, 0x34, 0x4f, 0x10, 0x9c, 0x2f, 0x64, 0xc9, 0xc5, 0x0e, 0x72,
-	0x44, 0x66, 0x6a, 0x31, 0xd0, 0x40, 0x66, 0x0d, 0x6e, 0x23, 0x79, 0x88, 0xbb, 0x8b, 0xf5, 0x70,
-	0xb8, 0x36, 0x08, 0xa6, 0xde, 0xc9, 0x26, 0xca, 0x2a, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f,
-	0x39, 0x3f, 0x57, 0x3f, 0xa3, 0xb2, 0x20, 0xb5, 0x28, 0x27, 0x35, 0x25, 0x3d, 0xb5, 0x48, 0x3f,
-	0x2d, 0x31, 0xa9, 0x28, 0x33, 0x59, 0x3f, 0x39, 0xbf, 0x28, 0x55, 0x3f, 0xb9, 0xa8, 0xb2, 0xa0,
-	0x24, 0x5f, 0x1f, 0x11, 0x2e, 0xfa, 0x60, 0xf3, 0x93, 0x20, 0xe1, 0x62, 0x0c, 0x08, 0x00, 0x00,
-	0xff, 0xff, 0xc7, 0x30, 0xd3, 0xb6, 0x32, 0x01, 0x00, 0x00,
+	0x52, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0x45, 0x4c, 0x29, 0x9b, 0x4b, 0x08, 0xd3, 0x12,
+	0x21, 0x29, 0x2e, 0x0e, 0x18, 0x1b, 0x6c, 0x34, 0x4f, 0x10, 0x9c, 0x2f, 0x64, 0xc9, 0xc5, 0x0e,
+	0x72, 0x44, 0x66, 0x6a, 0xb1, 0x04, 0x93, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x3c, 0xc4, 0xdd, 0xc5,
+	0x7a, 0x38, 0x5c, 0x1b, 0x04, 0x53, 0xef, 0x64, 0x13, 0x65, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a,
+	0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f, 0x51, 0x59, 0x90, 0x5a, 0x94, 0x93, 0x9a, 0x92, 0x9e, 0x5a,
+	0xa4, 0x9f, 0x96, 0x98, 0x54, 0x94, 0x99, 0xac, 0x9f, 0x9c, 0x5f, 0x94, 0xaa, 0x9f, 0x5c, 0x54,
+	0x59, 0x50, 0x92, 0xaf, 0x8f, 0x08, 0x17, 0x7d, 0xb0, 0xf9, 0x49, 0x90, 0x70, 0x31, 0x06, 0x04,
+	0x00, 0x00, 0xff, 0xff, 0xc7, 0x30, 0xd3, 0xb6, 0x32, 0x01, 0x00, 0x00,
 }
diff --git a/examples/chaincode/go/utxo/util/dah.pb.go b/examples/chaincode/go/utxo/util/dah.pb.go
index f83dc1b0d47..46cd1246795 100644
--- a/examples/chaincode/go/utxo/util/dah.pb.go
+++ b/examples/chaincode/go/utxo/util/dah.pb.go
@@ -89,26 +89,26 @@ func init() {
 func init() { proto.RegisterFile("dah.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 331 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x91, 0xcf, 0x4b, 0xfb, 0x30,
-	0x18, 0xc6, 0x59, 0x7f, 0xec, 0xfb, 0xf5, 0x75, 0x1b, 0x12, 0x44, 0xca, 0x0e, 0x32, 0xc5, 0xc3,
-	0x4e, 0x2d, 0xe8, 0x59, 0x04, 0x4f, 0x7a, 0x51, 0x08, 0x15, 0x86, 0xb7, 0x36, 0x7b, 0xd7, 0x46,
-	0xbb, 0xa6, 0x4b, 0x93, 0xd1, 0x5d, 0xfd, 0xcb, 0x4d, 0xb2, 0x6e, 0x4c, 0xe8, 0x21, 0x9f, 0xbe,
-	0x0f, 0xcf, 0xf3, 0xe4, 0x0d, 0x9c, 0x2d, 0xb3, 0x32, 0x6e, 0xa4, 0x50, 0x82, 0x04, 0x5a, 0xf1,
-	0xea, 0xf6, 0xc7, 0x07, 0x2f, 0x5d, 0x90, 0x08, 0xfe, 0x6d, 0x51, 0xb6, 0x5c, 0xd4, 0xd1, 0x60,
-	0x36, 0x98, 0x8f, 0xe9, 0x01, 0xc9, 0x14, 0xfe, 0x57, 0x82, 0x7d, 0xa7, 0x7c, 0x8d, 0x91, 0xe7,
-	0x46, 0x47, 0x26, 0x37, 0x10, 0xa8, 0x8e, 0xd7, 0x91, 0x3f, 0xf3, 0xe7, 0xe7, 0xf7, 0xe3, 0xd8,
-	0x3a, 0xc6, 0xe9, 0xc2, 0x7c, 0xaf, 0x6f, 0xd4, 0x8d, 0xc8, 0x1d, 0x84, 0xaa, 0x13, 0x5a, 0x45,
-	0x81, 0xd3, 0x4c, 0x4e, 0x34, 0xef, 0x1f, 0x29, 0xdd, 0x0f, 0xc9, 0x15, 0x0c, 0x73, 0xeb, 0xda,
-	0x46, 0xa1, 0x91, 0x8d, 0x68, 0x4f, 0xe4, 0x02, 0xfc, 0x15, 0x62, 0x34, 0x34, 0xb9, 0x01, 0xb5,
-	0xc7, 0xe9, 0x17, 0x04, 0xd6, 0x9d, 0x4c, 0xc0, 0xe3, 0x5d, 0xdf, 0xd5, 0x9c, 0xc8, 0x35, 0x40,
-	0x2b, 0xb4, 0x64, 0xf8, 0x92, 0xb5, 0xa5, 0x2b, 0x3a, 0xa2, 0x27, 0x7f, 0x6c, 0x42, 0xcb, 0x24,
-	0x6f, 0x94, 0x29, 0x6b, 0x67, 0x3d, 0xd9, 0xeb, 0xb5, 0xb8, 0xd1, 0x58, 0x33, 0x34, 0x15, 0xdd,
-	0xf5, 0x0e, 0x3c, 0x2d, 0x20, 0x74, 0x2d, 0xc9, 0x25, 0x84, 0xdb, 0xac, 0xd2, 0xe8, 0xf2, 0x02,
-	0xba, 0x87, 0x13, 0x4b, 0xef, 0x8f, 0xa5, 0x51, 0x33, 0x51, 0x09, 0xd9, 0x27, 0xed, 0xc1, 0x06,
-	0x6d, 0x74, 0x56, 0x2b, 0xae, 0x76, 0x2e, 0x28, 0xa0, 0x47, 0x7e, 0x7e, 0xfa, 0x7c, 0x2c, 0xb8,
-	0x2a, 0x75, 0x1e, 0x33, 0xb1, 0x4e, 0xca, 0x5d, 0x83, 0xb2, 0xc2, 0x65, 0x81, 0x32, 0x59, 0x65,
-	0xb9, 0xe4, 0x2c, 0xc1, 0x2e, 0x5b, 0x37, 0x15, 0xb6, 0x09, 0x2b, 0x33, 0x5e, 0x33, 0xb1, 0xc4,
-	0xa4, 0x10, 0x89, 0x36, 0xcb, 0x4b, 0xec, 0x3e, 0xf3, 0xa1, 0x7b, 0xd2, 0x87, 0xdf, 0x00, 0x00,
-	0x00, 0xff, 0xff, 0xbb, 0x8b, 0x8c, 0x33, 0xdf, 0x01, 0x00, 0x00,
+	// 329 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x54, 0x91, 0xc1, 0x4b, 0xc3, 0x30,
+	0x18, 0xc5, 0x59, 0x9b, 0x4e, 0x8d, 0xdb, 0x90, 0x30, 0x24, 0xec, 0x20, 0x55, 0x3c, 0xf4, 0xd4,
+	0x82, 0x9e, 0x45, 0xf0, 0xa4, 0x17, 0x85, 0x50, 0x61, 0x78, 0x6b, 0xb3, 0x6f, 0x6d, 0xb4, 0x6b,
+	0xba, 0x34, 0x19, 0xdd, 0xd5, 0xbf, 0x5c, 0x92, 0x76, 0x63, 0x5e, 0x42, 0x7e, 0x79, 0x1f, 0xef,
+	0xbd, 0x8f, 0xe0, 0x8b, 0x55, 0x56, 0xc6, 0x8d, 0x92, 0x5a, 0x12, 0x64, 0xb4, 0xa8, 0xee, 0x7e,
+	0x7d, 0xec, 0xa5, 0x4b, 0x42, 0xf1, 0xd9, 0x0e, 0x54, 0x2b, 0x64, 0x4d, 0x47, 0xe1, 0x28, 0x9a,
+	0xb2, 0x03, 0x92, 0x05, 0x3e, 0xaf, 0x24, 0xff, 0x49, 0xc5, 0x06, 0xa8, 0xe7, 0xa4, 0x23, 0x93,
+	0x5b, 0x8c, 0x74, 0x27, 0x6a, 0xea, 0x87, 0x7e, 0x74, 0xf9, 0x30, 0x8d, 0xad, 0x63, 0x9c, 0x2e,
+	0xe3, 0x74, 0xf9, 0xf6, 0xce, 0x9c, 0x44, 0xee, 0x71, 0xa0, 0x3b, 0x69, 0x34, 0x45, 0x6e, 0x66,
+	0x76, 0x32, 0xf3, 0xf1, 0x99, 0xb2, 0x5e, 0x24, 0xd7, 0x78, 0x9c, 0x5b, 0xd7, 0x96, 0x06, 0xa1,
+	0x1f, 0x4d, 0xd8, 0x40, 0xe4, 0x0a, 0xfb, 0x6b, 0x00, 0x3a, 0x0e, 0x47, 0x11, 0x62, 0xf6, 0xba,
+	0xf8, 0xc6, 0xc8, 0xba, 0x93, 0x19, 0xf6, 0x44, 0x37, 0x74, 0xf5, 0x44, 0x47, 0x6e, 0x30, 0x6e,
+	0xa5, 0x51, 0x1c, 0x5e, 0xb3, 0xb6, 0x74, 0x45, 0x27, 0xec, 0xe4, 0xc5, 0x26, 0xb4, 0x5c, 0x89,
+	0x46, 0x53, 0xdf, 0x69, 0x03, 0xd9, 0xf5, 0x5a, 0xd8, 0x1a, 0xa8, 0x39, 0x50, 0xd4, 0xaf, 0x77,
+	0xe0, 0x45, 0x81, 0x03, 0xd7, 0x92, 0xcc, 0x71, 0xb0, 0xcb, 0x2a, 0x03, 0x2e, 0x0f, 0xb1, 0x1e,
+	0x4e, 0x2c, 0xbd, 0x7f, 0x96, 0x73, 0x1c, 0x70, 0x59, 0x49, 0x35, 0x24, 0xf5, 0x60, 0x83, 0xb6,
+	0x26, 0xab, 0xb5, 0xd0, 0x7b, 0x17, 0x84, 0xd8, 0x91, 0x5f, 0x9e, 0xbf, 0x9e, 0x0a, 0xa1, 0x4b,
+	0x93, 0xc7, 0x5c, 0x6e, 0x92, 0x72, 0xdf, 0x80, 0xaa, 0x60, 0x55, 0x80, 0x4a, 0xd6, 0x59, 0xae,
+	0x04, 0x4f, 0xa0, 0xcb, 0x36, 0x4d, 0x05, 0x6d, 0xc2, 0xcb, 0x4c, 0xd4, 0x5c, 0xae, 0x20, 0x29,
+	0x64, 0x62, 0x74, 0x67, 0x0f, 0x51, 0xe5, 0x63, 0xf7, 0xa5, 0x8f, 0x7f, 0x01, 0x00, 0x00, 0xff,
+	0xff, 0xbb, 0x8b, 0x8c, 0x33, 0xdf, 0x01, 0x00, 0x00,
 }
diff --git a/gossip/proto/message.pb.go b/gossip/proto/message.pb.go
index 68fe798738f..f0ce43b0e53 100644
--- a/gossip/proto/message.pb.go
+++ b/gossip/proto/message.pb.go
@@ -1012,67 +1012,68 @@ var _Gossip_serviceDesc = grpc.ServiceDesc{
 func init() { proto1.RegisterFile("message.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 981 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x56, 0x5b, 0x6f, 0xe3, 0x44,
-	0x14, 0x6e, 0xee, 0xf5, 0x89, 0xd3, 0xa6, 0xb3, 0x05, 0x99, 0x0a, 0x24, 0x64, 0x10, 0x94, 0x0a,
-	0xd2, 0x25, 0xfb, 0xb0, 0x12, 0x08, 0x41, 0xdb, 0x84, 0x6d, 0x11, 0xc9, 0x56, 0x6e, 0x17, 0xb4,
-	0xbc, 0x54, 0x93, 0x64, 0xea, 0x58, 0x1b, 0x8f, 0xbd, 0x99, 0x09, 0xa8, 0x7f, 0x81, 0x07, 0x7e,
-	0x33, 0x67, 0x2e, 0x4e, 0xec, 0xc6, 0x7d, 0xd8, 0x97, 0xc6, 0xe7, 0xcc, 0xf7, 0x9d, 0xcb, 0x9c,
-	0xcb, 0x14, 0x3a, 0x31, 0x13, 0x82, 0x86, 0xac, 0x97, 0x2e, 0x13, 0x99, 0x90, 0x86, 0xfe, 0xf1,
-	0xff, 0x6b, 0x41, 0xe7, 0x55, 0x22, 0x44, 0x94, 0x8e, 0xcc, 0x31, 0x39, 0x84, 0x06, 0x4f, 0xf8,
-	0x94, 0x79, 0x95, 0xcf, 0x2b, 0xc7, 0xf5, 0xc0, 0x08, 0xc4, 0x83, 0xd6, 0x74, 0x4e, 0x39, 0x67,
-	0x0b, 0xaf, 0x8a, 0x7a, 0x37, 0xc8, 0x44, 0x72, 0x02, 0x35, 0x49, 0x43, 0xaf, 0x86, 0xda, 0xbd,
-	0xbe, 0x67, 0xac, 0xf7, 0x0a, 0x26, 0x7b, 0xb7, 0x34, 0x0c, 0x14, 0x88, 0x7c, 0x0f, 0xbb, 0x74,
-	0x11, 0xfd, 0xcd, 0x46, 0x22, 0xf4, 0xea, 0x48, 0x68, 0xf7, 0x9f, 0x59, 0xc2, 0x99, 0x56, 0x1b,
-	0xfc, 0xe5, 0x4e, 0xb0, 0x86, 0x91, 0x3e, 0x34, 0x63, 0x16, 0x07, 0xec, 0xbd, 0xd7, 0xd0, 0x84,
-	0xcc, 0xc3, 0x88, 0xc5, 0x13, 0xb6, 0x14, 0xf3, 0x28, 0xc5, 0xb3, 0x15, 0x13, 0x12, 0x59, 0x16,
-	0x49, 0x5e, 0x58, 0x8e, 0xf0, 0x9a, 0x9a, 0xf3, 0x49, 0x09, 0x47, 0xa4, 0x09, 0x17, 0x6c, 0x4d,
-	0x12, 0xa4, 0x07, 0xad, 0x19, 0x95, 0x54, 0x85, 0xd6, 0xd2, 0x2c, 0x62, 0x59, 0x03, 0xa5, 0x5d,
-	0x47, 0x96, 0x81, 0x30, 0xef, 0xc6, 0x9c, 0x2d, 0x16, 0x89, 0xf7, 0x67, 0x01, 0x6d, 0x32, 0xbf,
-	0x54, 0x27, 0x88, 0x36, 0x10, 0xf2, 0x9d, 0xb1, 0x3d, 0x88, 0x42, 0xcf, 0xd1, 0xe8, 0x83, 0x9c,
-	0x6d, 0xd4, 0x9a, 0xf0, 0x33, 0x4c, 0x16, 0x8a, 0x4a, 0x1a, 0xb6, 0x42, 0xd9, 0xa4, 0x9b, 0x81,
-	0x30, 0x5f, 0x50, 0x9f, 0x6f, 0x52, 0xfc, 0xcb, 0xbc, 0xf6, 0x96, 0x07, 0x73, 0x80, 0x8c, 0x1c,
-	0x0c, 0x6b, 0xa1, 0x4b, 0x78, 0x11, 0xcf, 0x3c, 0x57, 0x33, 0x3e, 0xb2, 0x8c, 0x0b, 0x53, 0xd8,
-	0x8b, 0x24, 0x8e, 0x29, 0x9f, 0x29, 0x3f, 0x16, 0x47, 0xbe, 0x84, 0x06, 0x8b, 0x53, 0xf9, 0xe0,
-	0x75, 0x34, 0xc1, 0xb5, 0x84, 0xa1, 0xd2, 0xa9, 0x64, 0xf5, 0x21, 0x5e, 0x4c, 0x7d, 0x9a, 0x70,
-	0xee, 0xed, 0x69, 0xd0, 0x61, 0x66, 0x15, 0x55, 0x43, 0x21, 0xe9, 0x64, 0x11, 0x89, 0x39, 0x82,
-	0x35, 0x86, 0x3c, 0x07, 0x07, 0x75, 0x92, 0x5d, 0xf1, 0xfb, 0xc4, 0xdb, 0xd7, 0x84, 0xae, 0x25,
-	0xdc, 0x64, 0x7a, 0x04, 0x6f, 0x40, 0xe4, 0x67, 0x70, 0xb5, 0x60, 0xaf, 0xc1, 0xeb, 0x16, 0x2a,
-	0x1c, 0xb0, 0x38, 0x91, 0xec, 0x26, 0x07, 0x40, 0x76, 0x81, 0x40, 0xce, 0xa1, 0x63, 0x65, 0xd3,
-	0x02, 0xde, 0x81, 0xb6, 0x70, 0x54, 0x66, 0x61, 0xdd, 0x24, 0x45, 0x8a, 0x3f, 0x86, 0x1a, 0xf6,
-	0x34, 0xe9, 0x80, 0xf3, 0x66, 0x3c, 0x18, 0xfe, 0x7a, 0x35, 0x1e, 0x0e, 0xba, 0x3b, 0xc4, 0x81,
-	0xc6, 0x70, 0x74, 0x7d, 0xfb, 0xb6, 0x5b, 0x21, 0x2e, 0xec, 0xbe, 0x0e, 0x5e, 0xdd, 0xbd, 0x1e,
-	0xff, 0xfe, 0xb6, 0x5b, 0x55, 0xb8, 0x8b, 0xcb, 0xb3, 0xb1, 0x11, 0x6b, 0xa4, 0x0b, 0xae, 0x16,
-	0xcf, 0xc6, 0x83, 0x3b, 0x44, 0x75, 0xeb, 0xe7, 0x0e, 0xd6, 0x22, 0xe1, 0x92, 0x71, 0xe9, 0xff,
-	0x5b, 0x01, 0x67, 0x9d, 0x3a, 0x39, 0x82, 0xdd, 0x98, 0x49, 0xaa, 0xca, 0xa6, 0xe7, 0xd1, 0x0d,
-	0xd6, 0x32, 0x36, 0x95, 0x23, 0x23, 0x1c, 0x6a, 0x49, 0xe3, 0x54, 0x0f, 0x65, 0xbb, 0xbf, 0x6f,
-	0x93, 0xb8, 0x66, 0x6c, 0x79, 0x8b, 0x67, 0xc1, 0x06, 0xa1, 0xe6, 0x3a, 0x7d, 0x17, 0x5d, 0x0d,
-	0xf4, 0xa4, 0xba, 0x81, 0x11, 0xc8, 0xa7, 0x58, 0x80, 0x28, 0xe4, 0x54, 0xae, 0x96, 0x4c, 0x8f,
-	0xa4, 0x1b, 0x6c, 0x14, 0xfe, 0x09, 0xec, 0x15, 0xbb, 0x41, 0xed, 0x81, 0x94, 0x3e, 0x2c, 0x12,
-	0x3a, 0xb3, 0xf1, 0x64, 0xa2, 0xff, 0x12, 0x3a, 0x85, 0x1a, 0x63, 0x9a, 0x35, 0xb4, 0x64, 0x61,
-	0xea, 0x73, 0x13, 0x42, 0x35, 0x17, 0x82, 0xff, 0x23, 0xb4, 0x73, 0x7d, 0xfd, 0xc4, 0xfe, 0xf9,
-	0x18, 0x9a, 0x82, 0xbd, 0x1f, 0x51, 0x95, 0x69, 0x0d, 0xd5, 0x56, 0xf2, 0xbf, 0x80, 0x76, 0x6e,
-	0xe2, 0xca, 0xc9, 0xfe, 0x6f, 0x00, 0x9b, 0x31, 0x78, 0xc2, 0xc1, 0x57, 0x50, 0xd7, 0xb7, 0xac,
-	0xcc, 0x97, 0xce, 0x7e, 0xa0, 0xcf, 0xfd, 0x1f, 0x8c, 0x2d, 0x33, 0xb4, 0x1f, 0x18, 0xec, 0x4b,
-	0x93, 0x69, 0xb6, 0x69, 0x8f, 0x8b, 0x77, 0xd9, 0xee, 0xef, 0x65, 0xe5, 0x33, 0xda, 0xcd, 0xdd,
-	0x5e, 0x41, 0xcb, 0xea, 0xac, 0xed, 0xf1, 0x2a, 0xb6, 0x2e, 0xad, 0x44, 0x08, 0xd4, 0xe7, 0x54,
-	0xcc, 0xf5, 0xd5, 0x3a, 0x81, 0xfe, 0x56, 0x3a, 0x9d, 0x93, 0xa9, 0xb8, 0x89, 0x1f, 0xfb, 0xcb,
-	0xcd, 0x2f, 0x5b, 0x6c, 0x23, 0x88, 0xd7, 0x7b, 0xd1, 0x06, 0xd2, 0x29, 0x2c, 0xcc, 0x20, 0x07,
-	0xf8, 0xd0, 0xae, 0x2b, 0xf4, 0x57, 0xed, 0x71, 0x7f, 0x9d, 0xc1, 0x6e, 0x46, 0x22, 0x9f, 0x01,
-	0x44, 0x7c, 0x7a, 0xc7, 0x57, 0xca, 0x95, 0x4d, 0xce, 0x41, 0xcd, 0x58, 0x2b, 0x72, 0x79, 0x57,
-	0xf3, 0x79, 0xfb, 0x73, 0x38, 0xd8, 0x7a, 0x0a, 0xc8, 0x4f, 0xb0, 0x2f, 0xd8, 0xe2, 0x5e, 0x8d,
-	0xd0, 0x32, 0xa6, 0x32, 0x4a, 0xb8, 0x4d, 0xac, 0xec, 0xb9, 0x09, 0x1e, 0x63, 0x55, 0x55, 0xdf,
-	0xf1, 0xe4, 0x1f, 0xae, 0xcb, 0x87, 0x7d, 0xaa, 0x05, 0xf4, 0x44, 0xb6, 0x1f, 0x10, 0xf2, 0x0d,
-	0x34, 0xf4, 0x5b, 0x85, 0x0e, 0x6a, 0x4f, 0x39, 0x30, 0x08, 0xf2, 0x35, 0x96, 0x83, 0x61, 0xb1,
-	0xab, 0x4f, 0x23, 0x35, 0xc0, 0xff, 0x03, 0x9a, 0xc6, 0x93, 0x9a, 0x7f, 0xc6, 0x67, 0x69, 0x12,
-	0x71, 0xa9, 0x33, 0x70, 0x82, 0xb5, 0x5c, 0xd8, 0x0d, 0xd5, 0x47, 0xbb, 0xa1, 0x74, 0xd8, 0xfd,
-	0x16, 0x2e, 0x28, 0xb5, 0xa2, 0xfd, 0x1e, 0x90, 0xed, 0x4d, 0xa9, 0x66, 0xdb, 0x5c, 0xaa, 0xd0,
-	0xc9, 0xd4, 0x83, 0x4c, 0xc4, 0x3a, 0x3d, 0x2b, 0xd9, 0x8b, 0xb8, 0xe9, 0x77, 0x6d, 0x87, 0x0a,
-	0x9b, 0xfe, 0xe3, 0x0e, 0x5e, 0x9f, 0xf7, 0x53, 0x68, 0x9a, 0x41, 0x25, 0xbf, 0x80, 0x6b, 0xbe,
-	0x6e, 0xe4, 0x92, 0xd1, 0x98, 0x1c, 0x96, 0xfd, 0xcf, 0x70, 0x54, 0xaa, 0xf5, 0x77, 0x8e, 0x2b,
-	0xcf, 0x2b, 0xf8, 0x0e, 0xd5, 0xaf, 0x23, 0x1e, 0x92, 0xc2, 0x03, 0x74, 0x54, 0x90, 0xfc, 0x9d,
-	0xf3, 0x6f, 0xff, 0x3a, 0x09, 0x23, 0x39, 0x5f, 0x4d, 0x7a, 0xd3, 0x24, 0x3e, 0x9d, 0x3f, 0xa4,
-	0x6c, 0xb9, 0x60, 0xb3, 0x90, 0x2d, 0x4f, 0xef, 0xe9, 0x64, 0x19, 0x4d, 0x4f, 0x43, 0x6d, 0xfa,
-	0x54, 0xb3, 0x26, 0x4d, 0xfd, 0xf3, 0xe2, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x54, 0x9e, 0xcc,
-	0xd3, 0x27, 0x09, 0x00, 0x00,
+	// 994 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x56, 0x5b, 0x4f, 0xe3, 0x46,
+	0x14, 0x8e, 0xc9, 0x0d, 0x9f, 0x38, 0x10, 0xce, 0xd2, 0xca, 0x45, 0xad, 0x84, 0xdc, 0x55, 0x9b,
+	0x46, 0x25, 0xec, 0x86, 0x87, 0x95, 0x5a, 0x55, 0x2d, 0x10, 0x4a, 0xa8, 0x4a, 0x40, 0x03, 0xdb,
+	0x6a, 0xfb, 0x82, 0x86, 0x64, 0x70, 0xac, 0x8d, 0xc7, 0x26, 0x33, 0xb4, 0xe2, 0x2f, 0xec, 0x43,
+	0x7f, 0xf3, 0x6a, 0x2e, 0x4e, 0x6c, 0xf0, 0x3e, 0xec, 0x53, 0x7c, 0xce, 0x7c, 0xdf, 0xb9, 0xcc,
+	0xb9, 0x4c, 0xa0, 0x1d, 0x33, 0x21, 0x68, 0xc8, 0xfa, 0xe9, 0x22, 0x91, 0x09, 0xd6, 0xf5, 0x4f,
+	0xf0, 0x7f, 0x13, 0xda, 0xa7, 0x89, 0x10, 0x51, 0x7a, 0x6e, 0x8e, 0x71, 0x1b, 0xea, 0x3c, 0xe1,
+	0x13, 0xe6, 0x3b, 0xbb, 0x4e, 0xb7, 0x46, 0x8c, 0x80, 0x3e, 0x34, 0x27, 0x33, 0xca, 0x39, 0x9b,
+	0xfb, 0x6b, 0xbb, 0x4e, 0xd7, 0x23, 0x99, 0x88, 0x3d, 0xa8, 0x4a, 0x1a, 0xfa, 0xd5, 0x5d, 0xa7,
+	0xbb, 0x31, 0xf0, 0x8d, 0xf5, 0x7e, 0xc1, 0x64, 0xff, 0x9a, 0x86, 0x44, 0x81, 0xf0, 0x35, 0xac,
+	0xd3, 0x79, 0xf4, 0x2f, 0x3b, 0x17, 0xa1, 0x5f, 0xdb, 0x75, 0xba, 0xad, 0xc1, 0x0b, 0x4b, 0x38,
+	0xd4, 0x6a, 0x83, 0x1f, 0x55, 0xc8, 0x12, 0x86, 0x03, 0x68, 0xc4, 0x2c, 0x26, 0xec, 0xde, 0xaf,
+	0x6b, 0x42, 0xe6, 0xe1, 0x9c, 0xc5, 0xb7, 0x6c, 0x21, 0x66, 0x51, 0x4a, 0xd8, 0xfd, 0x03, 0x13,
+	0x72, 0x54, 0x21, 0x16, 0x89, 0x07, 0x96, 0x23, 0xfc, 0x86, 0xe6, 0x7c, 0x55, 0xc2, 0x11, 0x69,
+	0xc2, 0x05, 0x5b, 0x92, 0x04, 0xf6, 0xa1, 0x39, 0xa5, 0x92, 0xaa, 0xd0, 0x9a, 0x9a, 0x85, 0x96,
+	0x35, 0x54, 0xda, 0x65, 0x64, 0x19, 0x08, 0x7b, 0x50, 0x9f, 0xb1, 0xf9, 0x3c, 0xf1, 0xff, 0x2e,
+	0xa0, 0x4d, 0xe6, 0x23, 0x75, 0x32, 0xaa, 0x10, 0x03, 0xc1, 0x3d, 0x63, 0x7b, 0x18, 0x85, 0xbe,
+	0xab, 0xd1, 0x5b, 0x39, 0xdb, 0xc3, 0x28, 0x34, 0xe1, 0x67, 0x98, 0x2c, 0x14, 0x95, 0x34, 0x3c,
+	0x0b, 0x65, 0x95, 0x6e, 0x06, 0xc2, 0x03, 0x00, 0xf5, 0xf9, 0x36, 0x9d, 0x52, 0xc9, 0xfc, 0xd6,
+	0x33, 0x0f, 0xe6, 0x60, 0x54, 0x21, 0x39, 0x18, 0xbe, 0x36, 0x15, 0x3d, 0x8e, 0xa7, 0xbe, 0xa7,
+	0x19, 0x5f, 0x58, 0xc6, 0xb1, 0x29, 0xec, 0x71, 0x12, 0xc7, 0x94, 0x4f, 0x95, 0x1f, 0x8b, 0xc3,
+	0x97, 0x50, 0x67, 0x71, 0x2a, 0x1f, 0xfd, 0xb6, 0x26, 0x78, 0x96, 0x70, 0xa2, 0x74, 0x2a, 0x59,
+	0x7d, 0x88, 0x3d, 0xa8, 0x4d, 0x12, 0xce, 0xfd, 0x0d, 0x0d, 0xda, 0xce, 0xac, 0x26, 0x9c, 0x9f,
+	0x08, 0x49, 0x6f, 0xe7, 0x91, 0x98, 0x8d, 0x2a, 0x44, 0x63, 0xf0, 0x15, 0xb8, 0x42, 0x52, 0xc9,
+	0xce, 0xf8, 0x5d, 0xe2, 0x6f, 0x6a, 0x42, 0xc7, 0x12, 0xae, 0x32, 0xfd, 0xa8, 0x42, 0x56, 0x20,
+	0xfc, 0x15, 0x3c, 0x2d, 0xd8, 0x6b, 0xf0, 0x3b, 0x85, 0x0a, 0x13, 0x16, 0x27, 0x92, 0x5d, 0xe5,
+	0x00, 0xa3, 0x0a, 0x29, 0x10, 0xf0, 0x08, 0xda, 0x56, 0x36, 0x2d, 0xe0, 0x6f, 0x69, 0x0b, 0x3b,
+	0x65, 0x16, 0x96, 0x4d, 0x52, 0xa4, 0x04, 0x63, 0xa8, 0x5e, 0xd3, 0x10, 0xdb, 0xe0, 0xbe, 0x1d,
+	0x0f, 0x4f, 0x7e, 0x3f, 0x1b, 0x9f, 0x0c, 0x3b, 0x15, 0x74, 0xa1, 0x7e, 0x72, 0x7e, 0x79, 0xfd,
+	0xae, 0xe3, 0xa0, 0x07, 0xeb, 0x17, 0xe4, 0xf4, 0xe6, 0x62, 0xfc, 0xe7, 0xbb, 0xce, 0x9a, 0xc2,
+	0x1d, 0x8f, 0x0e, 0xc7, 0x46, 0xac, 0x62, 0x07, 0x3c, 0x2d, 0x1e, 0x8e, 0x87, 0x37, 0x17, 0xe4,
+	0xb4, 0x53, 0x3b, 0x72, 0xa1, 0x39, 0x49, 0xb8, 0x64, 0x5c, 0x06, 0x1f, 0x1c, 0x70, 0x97, 0xa9,
+	0xe3, 0x0e, 0xac, 0xc7, 0x4c, 0x52, 0x55, 0x36, 0x3d, 0x8f, 0x1e, 0x59, 0xca, 0xb8, 0x07, 0xae,
+	0x8c, 0x62, 0x26, 0x24, 0x8d, 0x53, 0x3d, 0x94, 0xad, 0xc1, 0xa6, 0x4d, 0xe2, 0x92, 0xb1, 0xc5,
+	0x75, 0x14, 0x33, 0xb2, 0x42, 0xa8, 0xb9, 0x4e, 0xdf, 0x47, 0x67, 0x43, 0x3d, 0xa9, 0x1e, 0x31,
+	0x02, 0x7e, 0x0d, 0xae, 0x88, 0x42, 0x4e, 0xe5, 0xc3, 0x82, 0xe9, 0x91, 0xf4, 0xc8, 0x4a, 0x11,
+	0xf4, 0x60, 0xa3, 0xd8, 0x0d, 0x6a, 0x0f, 0xa4, 0xf4, 0x71, 0x9e, 0xd0, 0xa9, 0x8d, 0x27, 0x13,
+	0x83, 0x37, 0xd0, 0x2e, 0xd4, 0x18, 0x3b, 0x50, 0x15, 0x51, 0x68, 0x61, 0xea, 0x73, 0x15, 0xc2,
+	0x5a, 0x2e, 0x84, 0xe0, 0x67, 0x68, 0xe5, 0xfa, 0xfa, 0x13, 0xfb, 0xe7, 0x4b, 0x68, 0x08, 0x76,
+	0x7f, 0x4e, 0x55, 0xa6, 0xd5, 0x6e, 0x8d, 0x58, 0x29, 0xf8, 0x16, 0x5a, 0xb9, 0x89, 0x2b, 0x27,
+	0x07, 0x7f, 0x00, 0xac, 0xc6, 0xe0, 0x13, 0x0e, 0xbe, 0x83, 0x9a, 0xbe, 0x65, 0x65, 0xbe, 0x74,
+	0xf6, 0x89, 0x3e, 0x0f, 0x7e, 0x32, 0xb6, 0xcc, 0xd0, 0x7e, 0x66, 0xb0, 0x6f, 0x4c, 0xa6, 0xd9,
+	0xa6, 0xed, 0x16, 0xef, 0xb2, 0x35, 0xd8, 0xc8, 0xca, 0x67, 0xb4, 0xab, 0xbb, 0x3d, 0x83, 0xa6,
+	0xd5, 0x59, 0xdb, 0xe3, 0x87, 0xd8, 0xba, 0xb4, 0x12, 0x22, 0xd4, 0x66, 0x54, 0xcc, 0xf4, 0xd5,
+	0xba, 0x44, 0x7f, 0x2b, 0x9d, 0xce, 0xc9, 0x54, 0xdc, 0xc4, 0xff, 0xc1, 0x01, 0x2f, 0xbf, 0x6c,
+	0x71, 0x0f, 0x20, 0x5e, 0xee, 0x45, 0x1b, 0x48, 0xbb, 0xb0, 0x30, 0x49, 0x0e, 0xf0, 0xb9, 0x5d,
+	0x57, 0xe8, 0xaf, 0xea, 0xd3, 0xfe, 0x3a, 0x84, 0xf5, 0x8c, 0x84, 0xdf, 0x00, 0x44, 0x7c, 0x72,
+	0xc3, 0x1f, 0x94, 0x2b, 0x9b, 0x9c, 0x1b, 0xf1, 0xc9, 0x58, 0x2b, 0x72, 0x79, 0xaf, 0xe5, 0xf3,
+	0x0e, 0x66, 0xb0, 0xf5, 0xec, 0x29, 0xc0, 0x5f, 0x60, 0x53, 0xb0, 0xf9, 0x9d, 0x1a, 0xa1, 0x45,
+	0x4c, 0x65, 0x94, 0x70, 0x9b, 0x58, 0xd9, 0x73, 0x43, 0x9e, 0x62, 0x55, 0x55, 0xdf, 0xf3, 0xe4,
+	0x3f, 0xae, 0xcb, 0xe7, 0x11, 0x23, 0x04, 0x33, 0xc0, 0xe7, 0x0f, 0x08, 0xfe, 0x00, 0x75, 0xfd,
+	0x56, 0xf9, 0x8e, 0x6e, 0x9c, 0x52, 0x07, 0x06, 0x81, 0xdf, 0x43, 0x6d, 0xca, 0xe8, 0xd4, 0xb6,
+	0x58, 0x29, 0x52, 0x03, 0x82, 0xbf, 0xa0, 0x61, 0x3c, 0xa9, 0xf9, 0x67, 0x7c, 0x9a, 0x26, 0x11,
+	0x97, 0x3a, 0x03, 0x97, 0x2c, 0xe5, 0xc2, 0x6e, 0x58, 0x7b, 0xb2, 0x1b, 0x4a, 0x87, 0x3d, 0x68,
+	0x42, 0x5d, 0xef, 0xea, 0xa0, 0x0f, 0xf8, 0x7c, 0x53, 0xaa, 0xd9, 0x36, 0x97, 0x2a, 0x74, 0x32,
+	0x35, 0x92, 0x89, 0xc1, 0x21, 0xbc, 0x28, 0xd9, 0x8b, 0xd8, 0x83, 0x75, 0xdb, 0xa1, 0xc2, 0xa6,
+	0xff, 0xb4, 0x83, 0x97, 0xe7, 0x83, 0x14, 0x1a, 0x66, 0x50, 0xf1, 0x37, 0xf0, 0xcc, 0xd7, 0x95,
+	0x5c, 0x30, 0x1a, 0xe3, 0x76, 0xd9, 0x7f, 0x86, 0x9d, 0x52, 0x6d, 0x50, 0xe9, 0x3a, 0xaf, 0x1c,
+	0x7c, 0x09, 0xb5, 0xcb, 0x88, 0x87, 0x58, 0x78, 0x80, 0x76, 0x0a, 0x52, 0x50, 0x39, 0xfa, 0xf1,
+	0x9f, 0x5e, 0x18, 0xc9, 0xd9, 0xc3, 0x6d, 0x7f, 0x92, 0xc4, 0xfb, 0xb3, 0xc7, 0x94, 0x2d, 0xe6,
+	0x6c, 0x1a, 0xb2, 0xc5, 0xfe, 0x1d, 0xbd, 0x5d, 0x44, 0x93, 0xfd, 0x50, 0x9b, 0xde, 0xd7, 0xac,
+	0xdb, 0x86, 0xfe, 0x39, 0xf8, 0x18, 0x00, 0x00, 0xff, 0xff, 0x54, 0x9e, 0xcc, 0xd3, 0x27, 0x09,
+	0x00, 0x00,
 }
diff --git a/orderer/common/blockcutter/blockcutter_test.go b/orderer/common/blockcutter/blockcutter_test.go
index a4361a17bd4..426273d3be1 100644
--- a/orderer/common/blockcutter/blockcutter_test.go
+++ b/orderer/common/blockcutter/blockcutter_test.go
@@ -42,7 +42,7 @@ func (mcm *mockConfigManager) Apply(message *cb.ConfigurationEnvelope) error {
 	panic("Unimplemented")
 }
 
-func (mcm *mockConfigManager) ChainID() []byte {
+func (mcm *mockConfigManager) ChainID() string {
 	panic("Unimplemented")
 }
 
diff --git a/orderer/common/bootstrap/static/static.go b/orderer/common/bootstrap/static/static.go
index 57fd6e803ef..2c51d54b7b7 100644
--- a/orderer/common/bootstrap/static/static.go
+++ b/orderer/common/bootstrap/static/static.go
@@ -24,12 +24,12 @@ import (
 	cb "github.com/hyperledger/fabric/protos/common"
 )
 
-var TestChainID = []byte("**TEST_CHAINID**")
+var TestChainID = "**TEST_CHAINID**"
 
 const msgVersion = int32(1)
 
 type bootstrapper struct {
-	chainID []byte
+	chainID string
 }
 
 // New returns a new static bootstrap helper.
diff --git a/orderer/common/bootstrap/static/static_test.go b/orderer/common/bootstrap/static/static_test.go
index cde51e1b127..42f5eda6e90 100644
--- a/orderer/common/bootstrap/static/static_test.go
+++ b/orderer/common/bootstrap/static/static_test.go
@@ -124,7 +124,7 @@ func TestGenesisBlockData(t *testing.T) {
 	if configurationItemChainHeader.Version != expectedConfigurationItemChainHeaderVersion {
 		t.Fatalf("Expected configuration item chain header version %d, got %d", expectedConfigurationItemChainHeaderVersion, configurationItemChainHeader.Version)
 	}
-	if !bytes.Equal(configurationItemChainHeader.ChainID, payloadChainHeader.ChainID) {
+	if configurationItemChainHeader.ChainID != payloadChainHeader.ChainID {
 		t.Fatalf("Expected chain ID in chain headers of configuration item and payload to match, got %x and %x respectively", configurationItemChainHeader.ChainID, payloadChainHeader.ChainID)
 	}
 	if configurationItemChainHeader.Epoch != payloadChainHeader.Epoch {
diff --git a/orderer/common/broadcast/broadcast.go b/orderer/common/broadcast/broadcast.go
index 82f4f35b00f..603e61bbde0 100644
--- a/orderer/common/broadcast/broadcast.go
+++ b/orderer/common/broadcast/broadcast.go
@@ -21,9 +21,9 @@ import (
 	"github.com/hyperledger/fabric/orderer/multichain"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
+	"github.com/op/go-logging"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/op/go-logging"
 )
 
 var logger = logging.MustGetLogger("orderer/common/broadcast")
@@ -106,7 +106,7 @@ func (b *broadcaster) queueEnvelopes(srv ab.AtomicBroadcast_BroadcastServer) err
 
 		payload := &cb.Payload{}
 		err = proto.Unmarshal(msg.Payload, payload)
-		if payload.Header == nil || payload.Header.ChainHeader == nil || payload.Header.ChainHeader.ChainID == nil {
+		if payload.Header == nil || payload.Header.ChainHeader == nil || payload.Header.ChainHeader.ChainID == "" {
 			logger.Debugf("Received malformed message, dropping connection")
 			return srv.Send(&ab.BroadcastResponse{Status: cb.Status_BAD_REQUEST})
 		}
diff --git a/orderer/common/broadcast/broadcast_test.go b/orderer/common/broadcast/broadcast_test.go
index 88265214e39..bf6da7cae9b 100644
--- a/orderer/common/broadcast/broadcast_test.go
+++ b/orderer/common/broadcast/broadcast_test.go
@@ -33,7 +33,7 @@ import (
 	"google.golang.org/grpc"
 )
 
-var systemChain = []byte("systemChain")
+var systemChain = "systemChain"
 
 var configTx []byte
 
@@ -59,7 +59,7 @@ func (mcm *mockConfigManager) Apply(message *cb.ConfigurationEnvelope) error {
 	panic("Unimplemented")
 }
 
-func (mcm *mockConfigManager) ChainID() []byte {
+func (mcm *mockConfigManager) ChainID() string {
 	panic("Unimplemented")
 }
 
@@ -112,8 +112,8 @@ type mockMultichainManager struct {
 	chains map[string]*mockChainSupport
 }
 
-func (mm *mockMultichainManager) GetChain(chainID []byte) (multichain.ChainSupport, bool) {
-	chain, ok := mm.chains[string(chainID)]
+func (mm *mockMultichainManager) GetChain(chainID string) (multichain.ChainSupport, bool) {
+	chain, ok := mm.chains[chainID]
 	return chain, ok
 }
 
@@ -171,7 +171,7 @@ func (mc *mockChain) Halt() {
 	}
 }
 
-func makeMessage(chainID []byte, data []byte) *cb.Envelope {
+func makeMessage(chainID string, data []byte) *cb.Envelope {
 	payload := &cb.Payload{
 		Data: data,
 		Header: &cb.Header{
diff --git a/orderer/common/broadcastfilter/configfilter/configfilter_test.go b/orderer/common/broadcastfilter/configfilter/configfilter_test.go
index d83afa9d694..9e6b68ba62d 100644
--- a/orderer/common/broadcastfilter/configfilter/configfilter_test.go
+++ b/orderer/common/broadcastfilter/configfilter/configfilter_test.go
@@ -38,7 +38,7 @@ func (mcm *mockConfigManager) Apply(configtx *cb.ConfigurationEnvelope) error {
 	return mcm.err
 }
 
-func (mcm *mockConfigManager) ChainID() []byte {
+func (mcm *mockConfigManager) ChainID() string {
 	panic("Unimplemented")
 }
 
diff --git a/orderer/common/configtx/configtx.go b/orderer/common/configtx/configtx.go
index 6e13cc34147..f9da384a295 100644
--- a/orderer/common/configtx/configtx.go
+++ b/orderer/common/configtx/configtx.go
@@ -50,7 +50,7 @@ type Manager interface {
 	Validate(configtx *cb.ConfigurationEnvelope) error
 
 	// ChainID retrieves the chain ID associated with this manager
-	ChainID() []byte
+	ChainID() string
 }
 
 // DefaultModificationPolicyID is the ID of the policy used when no other policy can be resolved, for instance when attempting to create a new config item
@@ -64,7 +64,7 @@ func (ap *acceptAllPolicy) Evaluate(headers [][]byte, payload []byte, identities
 
 type configurationManager struct {
 	sequence      uint64
-	chainID       []byte
+	chainID       string
 	pm            policies.Manager
 	configuration map[cb.ConfigurationItem_ConfigurationType]map[string]*cb.ConfigurationItem
 	handlers      map[cb.ConfigurationItem_ConfigurationType]Handler
@@ -72,19 +72,19 @@ type configurationManager struct {
 
 // computeChainIDAndSequence returns the chain id and the sequence number for a configuration envelope
 // or an error if there is a problem with the configuration envelope
-func computeChainIDAndSequence(configtx *cb.ConfigurationEnvelope) ([]byte, uint64, error) {
+func computeChainIDAndSequence(configtx *cb.ConfigurationEnvelope) (string, uint64, error) {
 	if len(configtx.Items) == 0 {
-		return nil, 0, fmt.Errorf("Empty envelope unsupported")
+		return "", 0, fmt.Errorf("Empty envelope unsupported")
 	}
 
 	m := uint64(0)     //configtx.Items[0].LastModified
-	var chainID []byte //:= configtx.Items[0].Header.ChainID
+	var chainID string //:= configtx.Items[0].Header.ChainID
 
 	for _, signedItem := range configtx.Items {
 		item := &cb.ConfigurationItem{}
 		err := proto.Unmarshal(signedItem.ConfigurationItem, item)
 		if err != nil {
-			return nil, 0, fmt.Errorf("Error unmarshaling signedItem.ConfigurationItem: %s", err)
+			return "", 0, fmt.Errorf("Error unmarshaling signedItem.ConfigurationItem: %s", err)
 		}
 
 		if item.LastModified > m {
@@ -92,18 +92,18 @@ func computeChainIDAndSequence(configtx *cb.ConfigurationEnvelope) ([]byte, uint
 		}
 
 		if item.Header == nil {
-			return nil, 0, fmt.Errorf("Header not set: %v", item)
+			return "", 0, fmt.Errorf("Header not set: %v", item)
 		}
 
-		if item.Header.ChainID == nil {
-			return nil, 0, fmt.Errorf("Header chainID was nil: %v", item)
+		if item.Header.ChainID == "" {
+			return "", 0, fmt.Errorf("Header chainID was not set: %v", item)
 		}
 
-		if chainID == nil {
+		if chainID == "" {
 			chainID = item.Header.ChainID
 		} else {
-			if !bytes.Equal(chainID, item.Header.ChainID) {
-				return nil, 0, fmt.Errorf("Mismatched chainIDs in envelope %x != %x", chainID, item.Header.ChainID)
+			if chainID != item.Header.ChainID {
+				return "", 0, fmt.Errorf("Mismatched chainIDs in envelope %s != %s", chainID, item.Header.ChainID)
 			}
 		}
 	}
@@ -179,8 +179,8 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 	}
 
 	// Verify config is intended for this globally unique chain ID
-	if !bytes.Equal(chainID, cm.chainID) {
-		return nil, fmt.Errorf("Config is for the wrong chain, expected %x, got %x", cm.chainID, chainID)
+	if chainID != cm.chainID {
+		return nil, fmt.Errorf("Config is for the wrong chain, expected %s, got %s", cm.chainID, chainID)
 	}
 
 	defaultModificationPolicy, defaultPolicySet := cm.pm.GetPolicy(DefaultModificationPolicyID)
@@ -300,6 +300,6 @@ func (cm *configurationManager) Apply(configtx *cb.ConfigurationEnvelope) error
 }
 
 // ChainID retrieves the chain ID associated with this manager
-func (cm *configurationManager) ChainID() []byte {
+func (cm *configurationManager) ChainID() string {
 	return cm.chainID
 }
diff --git a/orderer/common/configtx/configtx_test.go b/orderer/common/configtx/configtx_test.go
index 3a21e00e805..9cdb905256f 100644
--- a/orderer/common/configtx/configtx_test.go
+++ b/orderer/common/configtx/configtx_test.go
@@ -26,7 +26,7 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
-var defaultChain = []byte("DefaultChainID")
+var defaultChain = "DefaultChainID"
 
 func defaultHandlers() map[cb.ConfigurationItem_ConfigurationType]Handler {
 	handlers := make(map[cb.ConfigurationItem_ConfigurationType]Handler)
@@ -57,7 +57,7 @@ func (mpm *mockPolicyManager) GetPolicy(id string) (policies.Policy, bool) {
 	return mpm.policy, (mpm.policy != nil)
 }
 
-func makeConfigurationItem(id, modificationPolicy string, lastModified uint64, data []byte, chainID []byte) *cb.ConfigurationItem {
+func makeConfigurationItem(id, modificationPolicy string, lastModified uint64, data []byte, chainID string) *cb.ConfigurationItem {
 	return &cb.ConfigurationItem{
 		Header:             &cb.ChainHeader{ChainID: chainID},
 		ModificationPolicy: modificationPolicy,
@@ -67,7 +67,7 @@ func makeConfigurationItem(id, modificationPolicy string, lastModified uint64, d
 	}
 }
 
-func makeSignedConfigurationItem(id, modificationPolicy string, lastModified uint64, data []byte, chainID []byte) *cb.SignedConfigurationItem {
+func makeSignedConfigurationItem(id, modificationPolicy string, lastModified uint64, data []byte, chainID string) *cb.SignedConfigurationItem {
 	config := makeConfigurationItem(id, modificationPolicy, lastModified, data, chainID)
 	marshaledConfig, err := proto.Marshal(config)
 	if err != nil {
@@ -100,7 +100,7 @@ func TestWrongChainID(t *testing.T) {
 	}
 
 	newConfig := &cb.ConfigurationEnvelope{
-		Items: []*cb.SignedConfigurationItem{makeSignedConfigurationItem("foo", "foo", 1, []byte("foo"), []byte("wrongChain"))},
+		Items: []*cb.SignedConfigurationItem{makeSignedConfigurationItem("foo", "foo", 1, []byte("foo"), "wrongChain")},
 	}
 
 	err = cm.Validate(newConfig)
@@ -421,7 +421,7 @@ func TestMissingHeader(t *testing.T) {
 func TestMissingChainID(t *testing.T) {
 	handlers := defaultHandlers()
 	_, err := NewConfigurationManager(&cb.ConfigurationEnvelope{
-		Items: []*cb.SignedConfigurationItem{makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), nil)},
+		Items: []*cb.SignedConfigurationItem{makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), "")},
 	}, &mockPolicyManager{&mockPolicy{}}, handlers)
 
 	if err == nil {
@@ -434,8 +434,8 @@ func TestMismatchedChainID(t *testing.T) {
 	handlers := defaultHandlers()
 	_, err := NewConfigurationManager(&cb.ConfigurationEnvelope{
 		Items: []*cb.SignedConfigurationItem{
-			makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), []byte("chain1")),
-			makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), []byte("chain2")),
+			makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), "chain1"),
+			makeSignedConfigurationItem("foo", "foo", 0, []byte("foo"), "chain2"),
 		},
 	}, &mockPolicyManager{&mockPolicy{}}, handlers)
 
diff --git a/orderer/common/deliver/deliver.go b/orderer/common/deliver/deliver.go
index faf660560a0..cb4d84a8cf1 100644
--- a/orderer/common/deliver/deliver.go
+++ b/orderer/common/deliver/deliver.go
@@ -21,7 +21,6 @@ import (
 	"github.com/hyperledger/fabric/orderer/rawledger"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
-
 	"github.com/op/go-logging"
 )
 
@@ -186,7 +185,7 @@ func (d *deliverer) processUpdate(update *ab.SeekInfo) bool {
 	}
 	logger.Debugf("Updating properties for client")
 
-	if update == nil || update.WindowSize == 0 || update.WindowSize > uint64(d.ds.maxWindow) || update.ChainID == nil {
+	if update == nil || update.WindowSize == 0 || update.WindowSize > uint64(d.ds.maxWindow) || update.ChainID == "" {
 		close(d.exitChan)
 		return d.sendErrorReply(cb.Status_BAD_REQUEST)
 	}
diff --git a/orderer/common/deliver/deliver_test.go b/orderer/common/deliver/deliver_test.go
index 0fd1d00944a..578e80f8eca 100644
--- a/orderer/common/deliver/deliver_test.go
+++ b/orderer/common/deliver/deliver_test.go
@@ -36,7 +36,7 @@ import (
 
 var genesisBlock *cb.Block
 
-var systemChainID = []byte("systemChain")
+var systemChainID = "systemChain"
 
 const ledgerSize = 10
 
@@ -82,8 +82,8 @@ type mockMultichainManager struct {
 	chains map[string]*mockChainSupport
 }
 
-func (mm *mockMultichainManager) GetChain(chainID []byte) (multichain.ChainSupport, bool) {
-	cs, ok := mm.chains[string(chainID)]
+func (mm *mockMultichainManager) GetChain(chainID string) (multichain.ChainSupport, bool) {
+	cs, ok := mm.chains[chainID]
 	return cs, ok
 }
 
diff --git a/orderer/common/util/util.go b/orderer/common/util/util.go
index cc390e35cab..c341e824d45 100644
--- a/orderer/common/util/util.go
+++ b/orderer/common/util/util.go
@@ -107,7 +107,7 @@ func ExtractPayload(envelope *cb.Envelope) (*cb.Payload, error) {
 }
 
 // MakeChainHeader creates a ChainHeader.
-func MakeChainHeader(headerType cb.HeaderType, version int32, chainID []byte, epoch uint64) *cb.ChainHeader {
+func MakeChainHeader(headerType cb.HeaderType, version int32, chainID string, epoch uint64) *cb.ChainHeader {
 	return &cb.ChainHeader{
 		Type:    int32(headerType),
 		Version: version,
diff --git a/orderer/common/util/util_test.go b/orderer/common/util/util_test.go
index 6178f2a6a0f..309067ee8a5 100644
--- a/orderer/common/util/util_test.go
+++ b/orderer/common/util/util_test.go
@@ -115,7 +115,7 @@ func TestExtractPayloadOrPanic(t *testing.T) {
 
 func testPayload() *cb.Payload {
 	return &cb.Payload{
-		Header: MakePayloadHeader(MakeChainHeader(cb.HeaderType_MESSAGE, int32(1), []byte("test"), 0), nil),
+		Header: MakePayloadHeader(MakeChainHeader(cb.HeaderType_MESSAGE, int32(1), "test", 0), nil),
 		Data:   []byte("test"),
 	}
 }
diff --git a/orderer/multichain/manager.go b/orderer/multichain/manager.go
index d23f48afe37..2b116bfe785 100644
--- a/orderer/multichain/manager.go
+++ b/orderer/multichain/manager.go
@@ -24,9 +24,9 @@ import (
 	"github.com/hyperledger/fabric/orderer/rawledger"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
+	"github.com/op/go-logging"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/op/go-logging"
 )
 
 var logger = logging.MustGetLogger("orderer/multichain")
@@ -46,7 +46,7 @@ func init() {
 // Manager coordinates the creation and access of chains
 type Manager interface {
 	// GetChain retrieves the chain support for a chain (and whether it exists)
-	GetChain(chainID []byte) (ChainSupport, bool)
+	GetChain(chainID string) (ChainSupport, bool)
 }
 
 type multiLedger struct {
@@ -109,15 +109,15 @@ func NewManagerImpl(ledgerFactory rawledger.Factory, consenters map[string]Conse
 	for _, chainID := range existingChains {
 		rl, err := ledgerFactory.GetOrCreate(chainID)
 		if err != nil {
-			logger.Fatalf("Ledger factory reported chainID %x but could not retrieve it: %s", chainID, err)
+			logger.Fatalf("Ledger factory reported chainID %s but could not retrieve it: %s", chainID, err)
 		}
 		configTx := getConfigTx(rl)
 		if configTx == nil {
-			logger.Fatalf("Could not find configuration transaction for chain %x", chainID)
+			logger.Fatalf("Could not find configuration transaction for chain %s", chainID)
 		}
 		configManager, policyManager, backingLedger := ml.newResources(configTx)
 		chainID := configManager.ChainID()
-		ml.chains[string(chainID)] = newChainSupport(configManager, policyManager, backingLedger, consenters)
+		ml.chains[chainID] = newChainSupport(configManager, policyManager, backingLedger, consenters)
 	}
 
 	for _, cs := range ml.chains {
@@ -128,8 +128,8 @@ func NewManagerImpl(ledgerFactory rawledger.Factory, consenters map[string]Conse
 }
 
 // GetChain retrieves the chain support for a chain (and whether it exists)
-func (ml *multiLedger) GetChain(chainID []byte) (ChainSupport, bool) {
-	cs, ok := ml.chains[string(chainID)]
+func (ml *multiLedger) GetChain(chainID string) (ChainSupport, bool) {
+	cs, ok := ml.chains[chainID]
 	return cs, ok
 }
 
@@ -167,7 +167,7 @@ func (ml *multiLedger) newResources(configTx *cb.Envelope) (configtx.Manager, po
 
 	ledger, err := ml.ledgerFactory.GetOrCreate(chainID)
 	if err != nil {
-		logger.Fatalf("Error getting ledger for %x", chainID)
+		logger.Fatalf("Error getting ledger for %s", chainID)
 	}
 
 	return configManager, policyManager, ledger
diff --git a/orderer/multichain/manager_test.go b/orderer/multichain/manager_test.go
index f7e398eed26..360240b646a 100644
--- a/orderer/multichain/manager_test.go
+++ b/orderer/multichain/manager_test.go
@@ -39,7 +39,7 @@ func init() {
 	}
 }
 
-func makeNormalTx(chainID []byte, i int) *cb.Envelope {
+func makeNormalTx(chainID string, i int) *cb.Envelope {
 	payload := &cb.Payload{
 		Header: &cb.Header{
 			ChainHeader: &cb.ChainHeader{
@@ -54,7 +54,7 @@ func makeNormalTx(chainID []byte, i int) *cb.Envelope {
 	}
 }
 
-func makeConfigTx(chainID []byte, i int) *cb.Envelope {
+func makeConfigTx(chainID string, i int) *cb.Envelope {
 	payload := &cb.Payload{
 		Header: &cb.Header{
 			ChainHeader: &cb.ChainHeader{
@@ -119,7 +119,7 @@ func TestManagerImpl(t *testing.T) {
 
 	manager := NewManagerImpl(lf, consenters)
 
-	_, ok := manager.GetChain([]byte("Fake"))
+	_, ok := manager.GetChain("Fake")
 	if ok {
 		t.Errorf("Should not have found a chain that was not created")
 	}
diff --git a/orderer/rawledger/blackbox_test.go b/orderer/rawledger/blackbox_test.go
index 38edebbce95..81e8a037733 100644
--- a/orderer/rawledger/blackbox_test.go
+++ b/orderer/rawledger/blackbox_test.go
@@ -214,8 +214,8 @@ func TestMultichain(t *testing.T) {
 
 func testMultichain(lf ledgerTestFactory, t *testing.T) {
 	f, _ := lf.New()
-	chain1 := []byte("chain1")
-	chain2 := []byte("chain2")
+	chain1 := "chain1"
+	chain2 := "chain2"
 
 	c1p1 := []byte("c1 payload1")
 	c1p2 := []byte("c1 payload2")
diff --git a/orderer/rawledger/fileledger/fileledger.go b/orderer/rawledger/fileledger/fileledger.go
index 81a9720e027..ecabe4af241 100644
--- a/orderer/rawledger/fileledger/fileledger.go
+++ b/orderer/rawledger/fileledger/fileledger.go
@@ -26,10 +26,10 @@ import (
 	"github.com/hyperledger/fabric/orderer/rawledger"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
+	"github.com/op/go-logging"
 
 	"github.com/golang/protobuf/jsonpb"
 	"github.com/golang/protobuf/proto"
-	"github.com/op/go-logging"
 )
 
 var logger = logging.MustGetLogger("rawledger/fileledger")
@@ -110,25 +110,25 @@ func New(directory string, systemGenesis *cb.Block) (rawledger.Factory, rawledge
 	return flf, fl
 }
 
-func (flf *fileLedgerFactory) ChainIDs() [][]byte {
+func (flf *fileLedgerFactory) ChainIDs() []string {
 	flf.mutex.Lock()
 	defer flf.mutex.Unlock()
-	ids := make([][]byte, len(flf.ledgers))
+	ids := make([]string, len(flf.ledgers))
 
 	i := 0
 	for key := range flf.ledgers {
-		ids[i] = []byte(key)
+		ids[i] = key
 		i++
 	}
 
 	return ids
 }
 
-func (flf *fileLedgerFactory) GetOrCreate(chainID []byte) (rawledger.ReadWriter, error) {
+func (flf *fileLedgerFactory) GetOrCreate(chainID string) (rawledger.ReadWriter, error) {
 	flf.mutex.Lock()
 	defer flf.mutex.Unlock()
 
-	key := string(chainID)
+	key := chainID
 
 	// Check a second time with the lock held
 	l, ok := flf.ledgers[key]
@@ -136,7 +136,7 @@ func (flf *fileLedgerFactory) GetOrCreate(chainID []byte) (rawledger.ReadWriter,
 		return l, nil
 	}
 
-	directory := fmt.Sprintf("%s/%x", flf.directory, chainID)
+	directory := fmt.Sprintf("%s/%s", flf.directory, chainID)
 
 	logger.Debugf("Initializing chain at '%s'", directory)
 
diff --git a/orderer/rawledger/ramledger/ramledger.go b/orderer/rawledger/ramledger/ramledger.go
index 9a25a2da6f5..11046c3ac43 100644
--- a/orderer/rawledger/ramledger/ramledger.go
+++ b/orderer/rawledger/ramledger/ramledger.go
@@ -22,9 +22,9 @@ import (
 	"github.com/hyperledger/fabric/orderer/rawledger"
 	cb "github.com/hyperledger/fabric/protos/common"
 	ab "github.com/hyperledger/fabric/protos/orderer"
+	"github.com/op/go-logging"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/op/go-logging"
 )
 
 var logger = logging.MustGetLogger("rawledger/ramledger")
@@ -78,11 +78,11 @@ func New(maxSize int, systemGenesis *cb.Block) (rawledger.Factory, rawledger.Rea
 	return rlf, rl
 }
 
-func (rlf *ramLedgerFactory) GetOrCreate(chainID []byte) (rawledger.ReadWriter, error) {
+func (rlf *ramLedgerFactory) GetOrCreate(chainID string) (rawledger.ReadWriter, error) {
 	rlf.mutex.Lock()
 	defer rlf.mutex.Unlock()
 
-	key := string(chainID)
+	key := chainID
 
 	// Check a second time with the lock held
 	l, ok := rlf.ledgers[key]
@@ -95,14 +95,14 @@ func (rlf *ramLedgerFactory) GetOrCreate(chainID []byte) (rawledger.ReadWriter,
 	return ch, nil
 }
 
-func (rlf *ramLedgerFactory) ChainIDs() [][]byte {
+func (rlf *ramLedgerFactory) ChainIDs() []string {
 	rlf.mutex.Lock()
 	defer rlf.mutex.Unlock()
-	ids := make([][]byte, len(rlf.ledgers))
+	ids := make([]string, len(rlf.ledgers))
 
 	i := 0
 	for key := range rlf.ledgers {
-		ids[i] = []byte(key)
+		ids[i] = key
 		i++
 	}
 
diff --git a/orderer/rawledger/rawledger.go b/orderer/rawledger/rawledger.go
index af209c110fa..dfaa3d8d606 100644
--- a/orderer/rawledger/rawledger.go
+++ b/orderer/rawledger/rawledger.go
@@ -24,10 +24,10 @@ import (
 // Factory retrieves or creates new ledgers by chainID
 type Factory interface {
 	// GetOrCreate gets an existing ledger (if it exists) or creates it if it does not
-	GetOrCreate(chainID []byte) (ReadWriter, error)
+	GetOrCreate(chainID string) (ReadWriter, error)
 
 	// ChainIDs returns the chain IDs the Factory is aware of
-	ChainIDs() [][]byte
+	ChainIDs() []string
 }
 
 // Iterator is useful for a chain Reader to stream blocks as they are created
diff --git a/orderer/sbft/backend/backendab.go b/orderer/sbft/backend/backendab.go
index f824e69142f..1a781345ed3 100644
--- a/orderer/sbft/backend/backendab.go
+++ b/orderer/sbft/backend/backendab.go
@@ -17,8 +17,6 @@ limitations under the License.
 package backend
 
 import (
-	"bytes"
-
 	"github.com/hyperledger/fabric/orderer/common/broadcastfilter"
 	"github.com/hyperledger/fabric/orderer/common/configtx"
 	"github.com/hyperledger/fabric/orderer/common/deliver"
@@ -32,12 +30,12 @@ import (
 )
 
 type xxxMultichain struct {
-	chainID      []byte
+	chainID      string
 	chainSupport *xxxChainSupport
 }
 
-func (xxx *xxxMultichain) GetChain(id []byte) (multichain.ChainSupport, bool) {
-	if !bytes.Equal(id, xxx.chainID) {
+func (xxx *xxxMultichain) GetChain(id string) (multichain.ChainSupport, bool) {
+	if id != xxx.chainID {
 		return nil, false
 	}
 	return xxx.chainSupport, true
diff --git a/orderer/sbft/backend/consensus.pb.go b/orderer/sbft/backend/consensus.pb.go
index a0186242ee4..b2bad42309b 100644
--- a/orderer/sbft/backend/consensus.pb.go
+++ b/orderer/sbft/backend/consensus.pb.go
@@ -148,7 +148,7 @@ var _Consensus_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("backend/consensus.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 162 bytes of a gzipped FileDescriptorProto
+	// 164 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0x4a, 0x4c, 0xce,
 	0x4e, 0xcd, 0x4b, 0xd1, 0x4f, 0xce, 0xcf, 0x2b, 0x4e, 0xcd, 0x2b, 0x2e, 0x2d, 0xd6, 0x2b, 0x28,
 	0xca, 0x2f, 0xc9, 0x17, 0x62, 0x87, 0x4a, 0x48, 0x49, 0x16, 0x67, 0xe6, 0x16, 0xe4, 0xa4, 0x26,
@@ -157,7 +157,7 @@ var fileDescriptor0 = []byte{
 	0x50, 0xb3, 0xf4, 0xe0, 0xaa, 0xa5, 0xf8, 0xf4, 0x10, 0x86, 0xf9, 0x16, 0xa7, 0x2b, 0x31, 0x18,
 	0x30, 0x3a, 0x99, 0x44, 0x19, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea,
 	0x67, 0x54, 0x16, 0xa4, 0x16, 0xe5, 0xa4, 0xa6, 0xa4, 0xa7, 0x16, 0xe9, 0xa7, 0x25, 0x26, 0x15,
-	0x65, 0x26, 0xeb, 0xe7, 0x17, 0xa5, 0xa4, 0x16, 0x01, 0xb9, 0xc5, 0x20, 0xc7, 0x40, 0xcd, 0x4c,
-	0x62, 0x03, 0xbb, 0xc5, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xff, 0x8b, 0x41, 0xd6, 0xca, 0x00,
-	0x00, 0x00,
+	0x65, 0x26, 0xeb, 0xe7, 0x17, 0xa5, 0xa4, 0x16, 0xa5, 0x16, 0xe9, 0x17, 0x83, 0x1c, 0x03, 0x35,
+	0x33, 0x89, 0x0d, 0xec, 0x16, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x8b, 0x41, 0xd6,
+	0xca, 0x00, 0x00, 0x00,
 }
diff --git a/orderer/sbft/config.pb.go b/orderer/sbft/config.pb.go
index 4cfe5ea2ed5..c55920b956c 100644
--- a/orderer/sbft/config.pb.go
+++ b/orderer/sbft/config.pb.go
@@ -98,22 +98,22 @@ func init() {
 func init() { proto.RegisterFile("config.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 268 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x91, 0x4d, 0x4f, 0x83, 0x40,
-	0x10, 0x86, 0x43, 0x4b, 0x35, 0x4c, 0x7b, 0xa8, 0x1b, 0x0f, 0xd8, 0x13, 0x72, 0x6a, 0x8c, 0x81,
-	0x44, 0x4d, 0x6c, 0x3c, 0x6a, 0xbc, 0x1b, 0x8e, 0x5e, 0x94, 0x8f, 0x81, 0xa2, 0x94, 0x25, 0xb3,
-	0x8b, 0x09, 0x7f, 0xcc, 0xdf, 0xe7, 0x7e, 0xd4, 0x12, 0x3d, 0xf6, 0xf6, 0xce, 0xe4, 0x99, 0x99,
-	0x67, 0xb3, 0xb0, 0xc8, 0x79, 0x5b, 0xd6, 0x55, 0xd4, 0x11, 0x97, 0x9c, 0xb9, 0x22, 0x2b, 0xe5,
-	0xea, 0x42, 0xd4, 0xbb, 0xae, 0x41, 0x15, 0xe3, 0x43, 0xb2, 0x40, 0xf8, 0xed, 0xc0, 0x52, 0x4d,
-	0x08, 0x6c, 0x45, 0x2f, 0xde, 0xec, 0x2c, 0x8b, 0xc1, 0x3b, 0xf4, 0x7c, 0x27, 0x70, 0xd6, 0xf3,
-	0x9b, 0xb3, 0x68, 0x9c, 0x7c, 0x32, 0x54, 0x32, 0x32, 0xec, 0x1e, 0x66, 0x1d, 0x22, 0x09, 0x7f,
-	0x12, 0x4c, 0x15, 0x7c, 0x19, 0xe9, 0xb3, 0xd1, 0xff, 0xbd, 0xd1, 0x8b, 0x66, 0x9e, 0x5b, 0x49,
-	0x43, 0x62, 0xf9, 0xd5, 0x06, 0x60, 0x6c, 0xb2, 0x25, 0x4c, 0x3f, 0x71, 0x30, 0x17, 0xbd, 0x44,
-	0x47, 0x76, 0x0e, 0xb3, 0xaf, 0xb4, 0xe9, 0x51, 0x2d, 0x76, 0xd6, 0x8b, 0xc4, 0x16, 0x0f, 0x93,
-	0x8d, 0x13, 0xbe, 0xc3, 0xfc, 0x43, 0xf0, 0xf6, 0x68, 0xe5, 0xe0, 0xaf, 0x32, 0x58, 0x65, 0xdd,
-	0xda, 0xbb, 0x85, 0x77, 0xe0, 0xea, 0xc0, 0x7c, 0x38, 0x4d, 0x8b, 0x82, 0x50, 0x88, 0xbd, 0xd9,
-	0x6f, 0xc9, 0x18, 0xb8, 0x39, 0x92, 0x34, 0x72, 0x5e, 0x62, 0xf2, 0xe3, 0xf5, 0xeb, 0x55, 0x55,
-	0xcb, 0x6d, 0x9f, 0xa9, 0xe7, 0xef, 0xe2, 0xed, 0xd0, 0x21, 0x35, 0x58, 0x54, 0x48, 0x71, 0x99,
-	0x66, 0x54, 0xe7, 0x31, 0xa7, 0x02, 0x49, 0x95, 0xfa, 0x5e, 0x76, 0x62, 0x7e, 0xe1, 0xf6, 0x27,
-	0x00, 0x00, 0xff, 0xff, 0x82, 0x1e, 0x52, 0x33, 0xb6, 0x01, 0x00, 0x00,
+	// 271 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x91, 0x4d, 0x4b, 0xc3, 0x40,
+	0x10, 0x86, 0x49, 0x9b, 0x2a, 0x99, 0xf4, 0x50, 0x17, 0x0f, 0xb1, 0xa7, 0x98, 0x53, 0x10, 0xd9,
+	0x85, 0x2a, 0x58, 0x3c, 0x2a, 0xde, 0x25, 0x47, 0x2f, 0x9a, 0x8f, 0x49, 0x1a, 0x4d, 0xb3, 0x61,
+	0x76, 0x23, 0xe4, 0x8f, 0xf9, 0xfb, 0x64, 0xb3, 0xb5, 0x41, 0x8f, 0xde, 0xde, 0x19, 0x9e, 0xd9,
+	0xf7, 0x81, 0x85, 0x65, 0x2e, 0xdb, 0xb2, 0xae, 0x78, 0x47, 0x52, 0x4b, 0xe6, 0xaa, 0xac, 0xd4,
+	0xeb, 0x0b, 0x55, 0xef, 0xbb, 0x06, 0xb3, 0x52, 0x8b, 0x63, 0xb2, 0x40, 0xf4, 0xe5, 0xc0, 0x2a,
+	0x97, 0xad, 0xc2, 0x56, 0xf5, 0xea, 0xd5, 0xde, 0x32, 0x01, 0xde, 0x71, 0x17, 0x38, 0xa1, 0x13,
+	0xfb, 0x9b, 0x33, 0x3e, 0x5d, 0x3e, 0x8e, 0x54, 0x32, 0x31, 0xec, 0x0e, 0x16, 0x1d, 0x22, 0xa9,
+	0x60, 0x16, 0xce, 0x63, 0x7f, 0x73, 0xc9, 0x4d, 0x2d, 0xff, 0xfb, 0x2e, 0x7f, 0x36, 0xcc, 0x53,
+	0xab, 0x69, 0x48, 0x2c, 0xbf, 0xde, 0x02, 0x4c, 0x4b, 0xb6, 0x82, 0xf9, 0x07, 0x0e, 0x63, 0xa3,
+	0x97, 0x98, 0xc8, 0xce, 0x61, 0xf1, 0x99, 0x36, 0x3d, 0x06, 0xb3, 0xd0, 0x89, 0x97, 0x89, 0x1d,
+	0xee, 0x67, 0x5b, 0x27, 0x7a, 0x03, 0xff, 0x5d, 0xc9, 0xf6, 0xdf, 0xca, 0xe1, 0x6f, 0x65, 0xb0,
+	0xca, 0x66, 0x75, 0x70, 0x8b, 0x6e, 0xc1, 0x35, 0x81, 0x05, 0x70, 0x9a, 0x16, 0x05, 0xa1, 0x52,
+	0x07, 0xb3, 0x9f, 0x91, 0x31, 0x70, 0x73, 0x24, 0x3d, 0xca, 0x79, 0xc9, 0x98, 0x1f, 0xae, 0x5f,
+	0xae, 0xaa, 0x5a, 0xef, 0xfa, 0x8c, 0xe7, 0x72, 0x2f, 0x76, 0x43, 0x87, 0xd4, 0x60, 0x51, 0x21,
+	0x89, 0x32, 0xcd, 0xa8, 0xce, 0x85, 0xa4, 0x02, 0x09, 0x49, 0x98, 0xbe, 0xec, 0x64, 0xfc, 0x85,
+	0x9b, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x82, 0x1e, 0x52, 0x33, 0xb6, 0x01, 0x00, 0x00,
 }
diff --git a/orderer/sbft/simplebft/simplebft.pb.go b/orderer/sbft/simplebft/simplebft.pb.go
index e08d145aece..edc350277b3 100644
--- a/orderer/sbft/simplebft/simplebft.pb.go
+++ b/orderer/sbft/simplebft/simplebft.pb.go
@@ -579,55 +579,55 @@ func init() {
 func init() { proto.RegisterFile("simplebft/simplebft.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 789 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x55, 0xdb, 0x6e, 0xd3, 0x40,
-	0x10, 0xc5, 0x75, 0xae, 0x93, 0x0a, 0xd2, 0xa5, 0x20, 0x53, 0xfa, 0x50, 0x19, 0x54, 0xfa, 0x00,
-	0x49, 0x15, 0x2a, 0x40, 0x95, 0x90, 0x50, 0x0a, 0x22, 0x42, 0xa2, 0x42, 0x6e, 0x55, 0x89, 0x3e,
-	0x10, 0x39, 0xce, 0xc6, 0x36, 0x4d, 0xec, 0xc4, 0x5e, 0xb7, 0x0d, 0x1f, 0xc3, 0x03, 0x5f, 0xc0,
-	0x07, 0xf0, 0x47, 0xfc, 0x04, 0xbb, 0xb3, 0x1b, 0xdb, 0xcd, 0xa5, 0x42, 0xca, 0x83, 0x77, 0xce,
-	0x99, 0xdd, 0x39, 0x73, 0x0b, 0x3c, 0x8a, 0xfd, 0xd1, 0x78, 0x48, 0x7b, 0x03, 0xd6, 0x4c, 0xbf,
-	0x1a, 0xe3, 0x28, 0x64, 0x21, 0xa9, 0xa6, 0x06, 0xf3, 0xb7, 0x06, 0xa5, 0xa3, 0x30, 0x18, 0xf8,
-	0x2e, 0x59, 0x07, 0x2d, 0x30, 0xb4, 0x1d, 0x6d, 0xaf, 0x60, 0x69, 0x81, 0x38, 0x0d, 0x8c, 0x35,
-	0x79, 0x1a, 0x90, 0x06, 0xdc, 0xef, 0xd9, 0xcc, 0xf1, 0xba, 0xfd, 0x24, 0xb2, 0x99, 0x1f, 0x06,
-	0xdd, 0x20, 0xa6, 0x8e, 0xa1, 0x23, 0xbe, 0x81, 0xd0, 0x7b, 0x85, 0x1c, 0x73, 0x80, 0xec, 0x41,
-	0x5d, 0xf2, 0x63, 0xff, 0x07, 0xed, 0xf6, 0xa6, 0x8c, 0xc6, 0x46, 0x01, 0xc9, 0x77, 0xd1, 0x7e,
-	0xc2, 0xcd, 0x6d, 0x61, 0x25, 0xfb, 0xb0, 0x19, 0xd1, 0x49, 0x42, 0x63, 0xd6, 0x65, 0xfe, 0x88,
-	0x86, 0x09, 0x93, 0x57, 0x17, 0x91, 0x4d, 0x14, 0x76, 0x2a, 0x21, 0x71, 0xb7, 0xf9, 0x53, 0x07,
-	0xfd, 0x73, 0xec, 0xf2, 0x98, 0xca, 0x0a, 0xc5, 0xa8, 0x6b, 0x2d, 0xd2, 0xc8, 0x84, 0x5a, 0x12,
-	0xe9, 0xdc, 0xb1, 0x66, 0x24, 0xf2, 0x1a, 0x60, 0x1c, 0x51, 0xf1, 0xb3, 0x23, 0x8a, 0xd2, 0x6a,
-	0xad, 0x07, 0x39, 0x97, 0x2f, 0x29, 0xc8, 0xbd, 0x72, 0x54, 0xf1, 0xd0, 0xcc, 0x4b, 0x5f, 0x78,
-	0xe8, 0x24, 0xe9, 0x7d, 0xa7, 0x0e, 0x3e, 0x34, 0xe3, 0x3f, 0x87, 0x92, 0x13, 0x8e, 0x46, 0x3e,
-	0x43, 0xc9, 0xab, 0xe8, 0x8a, 0x43, 0x0e, 0xa0, 0x76, 0xe9, 0xd3, 0xab, 0xae, 0xe3, 0xd9, 0x81,
-	0x4b, 0x51, 0x77, 0xad, 0xb5, 0x91, 0x77, 0xf1, 0xdd, 0x80, 0xf6, 0x45, 0x4c, 0x82, 0x77, 0x84,
-	0x34, 0xd2, 0x84, 0x4a, 0xc0, 0x9d, 0x84, 0xc5, 0x28, 0x2d, 0xbc, 0x72, 0x4c, 0xaf, 0xce, 0x38,
-	0x22, 0x82, 0x0a, 0xe4, 0xa7, 0x50, 0xef, 0x78, 0xd4, 0xb9, 0x18, 0x87, 0x7e, 0xc0, 0x8c, 0xf2,
-	0x82, 0xfa, 0xa3, 0x14, 0x14, 0x2f, 0x65, 0x54, 0x5e, 0xca, 0xa2, 0x47, 0x87, 0xc3, 0xd0, 0xa8,
-	0xa0, 0x4f, 0x3d, 0xe7, 0xd3, 0x11, 0x76, 0x4e, 0x97, 0x84, 0x76, 0x09, 0x0a, 0x6c, 0x3a, 0xa6,
-	0xe6, 0x13, 0x28, 0xab, 0xf4, 0x13, 0x83, 0xa7, 0xce, 0x9e, 0x0e, 0x43, 0xbb, 0x8f, 0x35, 0x5a,
-	0xb7, 0x66, 0x47, 0xb3, 0x09, 0xe5, 0x13, 0x3a, 0xc1, 0xd0, 0x08, 0x14, 0x50, 0x87, 0xec, 0x3d,
-	0xfc, 0x26, 0x75, 0xd0, 0x63, 0x3a, 0x51, 0x0d, 0x28, 0x3e, 0xcd, 0xaf, 0x50, 0x6b, 0x8b, 0xd6,
-	0xe9, 0x50, 0xbb, 0x4f, 0xa3, 0x19, 0x41, 0x4b, 0x09, 0xe4, 0x31, 0x54, 0x79, 0x05, 0x2e, 0xbb,
-	0x9e, 0x1d, 0x7b, 0xe8, 0xb8, 0x6e, 0x55, 0x84, 0xa1, 0xc3, 0xcf, 0x02, 0xec, 0xdb, 0xcc, 0x96,
-	0xa0, 0x2e, 0x41, 0x61, 0x10, 0xa0, 0xf9, 0x47, 0x83, 0x22, 0xde, 0x4d, 0x1e, 0x42, 0xc9, 0xc3,
-	0xfb, 0x55, 0xb8, 0xea, 0x44, 0xb6, 0xa0, 0xa2, 0x02, 0x8f, 0xf9, 0xd5, 0x3a, 0x5e, 0xad, 0xce,
-	0xe4, 0x1d, 0x40, 0xcc, 0x4b, 0x64, 0xb3, 0x24, 0xe2, 0x5d, 0xae, 0x73, 0xb4, 0xd6, 0xda, 0xc9,
-	0x65, 0x09, 0x6f, 0xc6, 0x2a, 0x4a, 0xca, 0x87, 0x80, 0x45, 0x53, 0x2b, 0xe7, 0xb3, 0xf5, 0x16,
-	0xee, 0xcd, 0xc1, 0x42, 0xde, 0x05, 0x9d, 0xce, 0xe4, 0xf1, 0x4f, 0xb2, 0x09, 0xc5, 0x4b, 0x7b,
-	0x98, 0x50, 0x25, 0x4d, 0x1e, 0x0e, 0xd7, 0xde, 0x68, 0xe6, 0x39, 0x40, 0xd6, 0xbb, 0xe4, 0x69,
-	0x96, 0x98, 0xb9, 0xd6, 0x93, 0xe9, 0x96, 0xc9, 0xda, 0x85, 0x22, 0x0e, 0xa2, 0x9a, 0x83, 0xfa,
-	0x7c, 0xbc, 0x96, 0x84, 0xcd, 0x8f, 0xbc, 0x4c, 0xb2, 0x65, 0xff, 0xf3, 0x62, 0x9e, 0xc1, 0xbe,
-	0xef, 0x8a, 0xa1, 0x94, 0x71, 0xaa, 0x93, 0xf9, 0x4b, 0x03, 0x38, 0xcb, 0xfa, 0x77, 0x59, 0xcd,
-	0x77, 0xa1, 0x30, 0x8e, 0x29, 0xc3, 0x04, 0x2f, 0x9d, 0x1a, 0x0b, 0x71, 0xc1, 0x9b, 0x08, 0x9e,
-	0xbe, 0x9a, 0x27, 0x70, 0xbe, 0x5a, 0xf2, 0x2d, 0x5f, 0x58, 0x21, 0x34, 0xc7, 0x31, 0x0f, 0xa1,
-	0x24, 0xa7, 0x4d, 0xc4, 0x27, 0xda, 0x43, 0xb5, 0x01, 0x7e, 0x93, 0x6d, 0xa8, 0xa6, 0x45, 0x53,
-	0xea, 0x32, 0x83, 0xf9, 0x57, 0x83, 0xb2, 0x9a, 0xbb, 0xa5, 0xea, 0xf6, 0xb9, 0x2d, 0x53, 0xb7,
-	0xbd, 0x38, 0xad, 0x8d, 0x33, 0x0e, 0xcb, 0xe6, 0x40, 0xa6, 0xd0, 0x79, 0x2d, 0x75, 0x6a, 0xab,
-	0x74, 0x5e, 0x4b, 0x9e, 0xaa, 0x65, 0xe1, 0xd6, 0x5a, 0x6e, 0x7d, 0x82, 0x6a, 0xfa, 0xc4, 0x92,
-	0x06, 0x7b, 0x96, 0x6f, 0xb0, 0x65, 0x2b, 0x28, 0xdf, 0x73, 0xa7, 0x00, 0xd9, 0xc6, 0x58, 0x32,
-	0x8c, 0x2b, 0xda, 0xe0, 0x66, 0x0e, 0xf5, 0xf9, 0x1c, 0x7e, 0x83, 0x22, 0xee, 0x94, 0x4c, 0x92,
-	0x76, 0xab, 0x24, 0xf2, 0x22, 0xb7, 0x06, 0xd7, 0x56, 0xad, 0xc1, 0x74, 0x09, 0xb6, 0x5f, 0x9d,
-	0x1f, 0xb8, 0x3e, 0xf3, 0x92, 0x5e, 0x83, 0x2f, 0xdf, 0xa6, 0xc7, 0x97, 0x55, 0x34, 0xa4, 0x7d,
-	0x97, 0x46, 0xcd, 0x81, 0xdd, 0x8b, 0x7c, 0xa7, 0x19, 0x46, 0x7c, 0xda, 0xf9, 0x31, 0xbe, 0xf1,
-	0xb7, 0xd9, 0x2b, 0xe1, 0xff, 0xe6, 0xcb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x7b, 0xcb,
-	0xdb, 0x54, 0x07, 0x00, 0x00,
+	// 799 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x55, 0xdd, 0x6e, 0xf3, 0x44,
+	0x10, 0xad, 0x63, 0xc7, 0x49, 0x26, 0x15, 0xe4, 0x5b, 0x4a, 0x65, 0x4a, 0x2f, 0x22, 0x83, 0x4a,
+	0x2e, 0x20, 0xa9, 0x42, 0x05, 0xa8, 0x12, 0x12, 0x4a, 0x41, 0x44, 0x48, 0x54, 0xc8, 0xad, 0x2a,
+	0xd1, 0x0b, 0x22, 0xc7, 0x9e, 0xd8, 0xa6, 0x89, 0xed, 0x78, 0x37, 0x49, 0xd3, 0x87, 0xe1, 0x82,
+	0x27, 0xe0, 0x01, 0x78, 0x23, 0x5e, 0x02, 0xed, 0x4f, 0x6c, 0x37, 0x3f, 0xd5, 0x27, 0xf9, 0x62,
+	0x77, 0xce, 0xd9, 0xdd, 0x39, 0xb3, 0x67, 0xd6, 0xf0, 0x09, 0x8d, 0x66, 0xe9, 0x14, 0xc7, 0x13,
+	0xd6, 0xcb, 0x47, 0xdd, 0x34, 0x4b, 0x58, 0x42, 0x1a, 0x79, 0xc0, 0xfe, 0x47, 0x03, 0xf3, 0x26,
+	0x89, 0x27, 0x51, 0x40, 0x8e, 0x41, 0x8b, 0x2d, 0xad, 0xad, 0x75, 0x0c, 0x47, 0x8b, 0xf9, 0x6c,
+	0x62, 0x55, 0xe4, 0x6c, 0x42, 0xba, 0xf0, 0xd1, 0xd8, 0x65, 0x5e, 0x38, 0xf2, 0x17, 0x99, 0xcb,
+	0xa2, 0x24, 0x1e, 0xc5, 0x14, 0x3d, 0x4b, 0x17, 0xf8, 0x3b, 0x01, 0xfd, 0xa8, 0x90, 0x5b, 0x8a,
+	0x1e, 0xe9, 0x40, 0x4b, 0xf2, 0x69, 0xf4, 0x82, 0xa3, 0xf1, 0x9a, 0x21, 0xb5, 0x0c, 0x41, 0xfe,
+	0x40, 0xc4, 0xef, 0xa2, 0x17, 0x1c, 0xf0, 0x28, 0xb9, 0x84, 0x93, 0x0c, 0xe7, 0x0b, 0xa4, 0x6c,
+	0xc4, 0xa2, 0x19, 0x26, 0x0b, 0x26, 0xb7, 0xae, 0x0a, 0x36, 0x51, 0xd8, 0xbd, 0x84, 0xf8, 0xde,
+	0xf6, 0x5f, 0x3a, 0xe8, 0xbf, 0xd2, 0x80, 0x74, 0xa1, 0xa6, 0x50, 0x91, 0x75, 0xb3, 0x4f, 0xba,
+	0x85, 0x50, 0x47, 0x22, 0xc3, 0x23, 0x67, 0x43, 0x22, 0xdf, 0x02, 0xa4, 0x19, 0xf2, 0xcf, 0xcd,
+	0x50, 0x48, 0x6b, 0xf6, 0x3f, 0x2e, 0x2d, 0xf9, 0x2d, 0x07, 0x87, 0x47, 0x4e, 0x89, 0xca, 0x0f,
+	0xda, 0xac, 0xd2, 0x77, 0x0e, 0xba, 0x5b, 0x8c, 0xff, 0x44, 0x4f, 0x1c, 0xb4, 0xe1, 0x7f, 0x09,
+	0xa6, 0x97, 0xcc, 0x66, 0x11, 0x13, 0x92, 0x0f, 0xd1, 0x15, 0x87, 0x5c, 0x41, 0x73, 0x19, 0xe1,
+	0x6a, 0xe4, 0x85, 0x6e, 0x1c, 0xa0, 0xd0, 0xdd, 0xec, 0xbf, 0x2b, 0x2f, 0x89, 0x82, 0x18, 0x7d,
+	0x9e, 0x13, 0xe7, 0xdd, 0x08, 0x1a, 0xe9, 0x41, 0x3d, 0xc6, 0xd5, 0x88, 0x47, 0x2c, 0x73, 0xe7,
+	0x94, 0x5b, 0x5c, 0x3d, 0x44, 0xb8, 0xe2, 0x49, 0xc5, 0x72, 0xc8, 0xd5, 0x7b, 0x21, 0x7a, 0x4f,
+	0x69, 0x12, 0xc5, 0xcc, 0xaa, 0xed, 0xa8, 0xbf, 0xc9, 0x41, 0x7e, 0x52, 0x41, 0x25, 0x1d, 0xa8,
+	0x86, 0x38, 0x9d, 0x26, 0x56, 0x5d, 0xac, 0x69, 0x95, 0xd6, 0x0c, 0x79, 0x7c, 0x78, 0xe4, 0x48,
+	0xc2, 0xc0, 0x04, 0x83, 0xad, 0x53, 0xb4, 0x3f, 0x83, 0x9a, 0x2a, 0x3f, 0xb1, 0xa0, 0x96, 0xba,
+	0xeb, 0x69, 0xe2, 0xfa, 0xe2, 0x8e, 0x8e, 0x9d, 0xcd, 0xd4, 0xee, 0x41, 0xed, 0x0e, 0xe7, 0x22,
+	0x35, 0x02, 0x86, 0xd0, 0x21, 0xbd, 0x27, 0xc6, 0xa4, 0x05, 0x3a, 0xc5, 0xb9, 0x32, 0x20, 0x1f,
+	0xda, 0xbf, 0x43, 0x73, 0xc0, 0xad, 0x33, 0x44, 0xd7, 0xc7, 0x6c, 0x43, 0xd0, 0x72, 0x02, 0xf9,
+	0x14, 0x1a, 0x69, 0x86, 0xcb, 0x51, 0xe8, 0xd2, 0x50, 0x2c, 0x3c, 0x76, 0xea, 0x3c, 0x30, 0x74,
+	0x69, 0xc8, 0x41, 0xdf, 0x65, 0xae, 0x04, 0x75, 0x09, 0xf2, 0x00, 0x07, 0xed, 0x7f, 0x35, 0xa8,
+	0x8a, 0xbd, 0xc9, 0x29, 0x98, 0xa1, 0xd8, 0x5f, 0xa5, 0xab, 0x66, 0xe4, 0x0c, 0xea, 0x2a, 0x71,
+	0x6a, 0x55, 0xda, 0xba, 0xd8, 0x5a, 0xcd, 0xc9, 0x0f, 0x00, 0x34, 0x0a, 0x62, 0x97, 0x2d, 0x32,
+	0xa4, 0x96, 0xde, 0xd6, 0x3b, 0xcd, 0x7e, 0xbb, 0x54, 0x25, 0xb1, 0xb3, 0xb8, 0x45, 0x49, 0xf9,
+	0x29, 0x66, 0xd9, 0xda, 0x29, 0xad, 0x39, 0xfb, 0x1e, 0x3e, 0xdc, 0x82, 0xb9, 0xbc, 0x27, 0x5c,
+	0x6f, 0xe4, 0x3d, 0xe1, 0x9a, 0x9c, 0x40, 0x75, 0xe9, 0x4e, 0x17, 0xa8, 0xa4, 0xc9, 0xc9, 0x75,
+	0xe5, 0x3b, 0xcd, 0x7e, 0x04, 0x28, 0xbc, 0x4b, 0x3e, 0x2f, 0x0a, 0xb3, 0x65, 0x3d, 0x59, 0x6e,
+	0x59, 0xac, 0x0b, 0xa8, 0x8a, 0x46, 0x54, 0x7d, 0xd0, 0xda, 0xce, 0xd7, 0x91, 0xb0, 0xfd, 0x33,
+	0xd4, 0x94, 0x65, 0xdf, 0x73, 0xe3, 0x53, 0x30, 0xfd, 0x28, 0xe0, 0x4d, 0x29, 0xf3, 0x54, 0x33,
+	0xfb, 0x6f, 0x0d, 0xe0, 0xa1, 0xf0, 0xef, 0xbe, 0x3b, 0xbf, 0x00, 0x23, 0xa5, 0xc8, 0x44, 0x81,
+	0xf7, 0x76, 0x8d, 0x23, 0x70, 0xce, 0x9b, 0x73, 0x9e, 0x7e, 0x98, 0xc7, 0x71, 0x72, 0xf9, 0xca,
+	0xf2, 0xc6, 0x01, 0xa1, 0x25, 0x8e, 0x7d, 0x0d, 0xa6, 0xec, 0x36, 0x9e, 0x1f, 0xb7, 0x87, 0xb2,
+	0x81, 0x18, 0x93, 0x73, 0x68, 0xe4, 0x97, 0xa6, 0xd4, 0x15, 0x01, 0xfb, 0x3f, 0x0d, 0x6a, 0xaa,
+	0xef, 0xf6, 0xaa, 0xbb, 0x04, 0x63, 0x59, 0xa8, 0x3b, 0xdf, 0xed, 0xd6, 0xee, 0x03, 0x45, 0x26,
+	0xcd, 0x21, 0x98, 0x5c, 0xe7, 0xb3, 0xd4, 0xa9, 0x1d, 0xd2, 0xf9, 0x2c, 0x79, 0xea, 0x2e, 0x8d,
+	0x37, 0xef, 0xf2, 0xec, 0x17, 0x68, 0xe4, 0x47, 0xec, 0x31, 0xd8, 0x17, 0x65, 0x83, 0xed, 0x7b,
+	0x82, 0xca, 0x9e, 0xbb, 0x07, 0x28, 0x5e, 0x8c, 0x3d, 0xcd, 0x78, 0xc0, 0x06, 0xaf, 0x6b, 0xa8,
+	0x6f, 0xd7, 0xf0, 0x0f, 0xa8, 0x8a, 0x37, 0xa5, 0x90, 0xa4, 0xbd, 0x29, 0x89, 0x7c, 0x55, 0x7a,
+	0x06, 0x2b, 0x87, 0x9e, 0xc1, 0xfc, 0x11, 0x1c, 0x7c, 0xf3, 0x78, 0x15, 0x44, 0x2c, 0x5c, 0x8c,
+	0xbb, 0x5e, 0x32, 0xeb, 0x85, 0xeb, 0x14, 0xb3, 0x29, 0xfa, 0x01, 0x66, 0xbd, 0x89, 0x3b, 0xce,
+	0x22, 0xaf, 0x97, 0x64, 0x3e, 0x66, 0x98, 0xf5, 0xe8, 0xab, 0xdf, 0xe6, 0xd8, 0x14, 0xff, 0xcd,
+	0xaf, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x7b, 0xcb, 0xdb, 0x54, 0x07, 0x00, 0x00,
 }
diff --git a/orderer/solo/consensus_test.go b/orderer/solo/consensus_test.go
index 260daf78b0a..40417f2bfee 100644
--- a/orderer/solo/consensus_test.go
+++ b/orderer/solo/consensus_test.go
@@ -53,7 +53,7 @@ func (mcm *mockConfigManager) Apply(message *cb.ConfigurationEnvelope) error {
 	return mcm.applyErr
 }
 
-func (mcm *mockConfigManager) ChainID() []byte {
+func (mcm *mockConfigManager) ChainID() string {
 	panic("Unimplemented")
 }
 
diff --git a/protos/common/common.pb.go b/protos/common/common.pb.go
index 611a2f302a1..53f925a151d 100644
--- a/protos/common/common.pb.go
+++ b/protos/common/common.pb.go
@@ -142,7 +142,7 @@ type ChainHeader struct {
 	// by the sender
 	Timestamp *google_protobuf.Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"`
 	// Identifier of the chain this message is bound for
-	ChainID []byte `protobuf:"bytes,4,opt,name=chainID,proto3" json:"chainID,omitempty"`
+	ChainID string `protobuf:"bytes,4,opt,name=chainID" json:"chainID,omitempty"`
 	// An unique identifier that is used end-to-end.
 	//  -  set by higher layers such as end user or SDK
 	//  -  passed to the endorser (which will check for uniqueness)
@@ -301,49 +301,49 @@ func init() {
 func init() { proto.RegisterFile("common/common.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 689 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x54, 0x4b, 0x6f, 0xd3, 0x4a,
-	0x18, 0xbd, 0xae, 0xf3, 0x68, 0xbe, 0xe4, 0xf6, 0xfa, 0x4e, 0x5b, 0x08, 0x15, 0xa8, 0x95, 0x25,
-	0x10, 0x6a, 0x45, 0x22, 0x8a, 0x90, 0xd8, 0x3a, 0xc9, 0xb4, 0xb5, 0x68, 0xc7, 0x65, 0xec, 0x14,
-	0x89, 0x4d, 0xe4, 0x24, 0xd3, 0x24, 0x90, 0x78, 0x22, 0xc7, 0xa9, 0xda, 0x2d, 0x5b, 0x24, 0x84,
-	0x04, 0x3f, 0x8a, 0x7f, 0xc0, 0x1f, 0x41, 0x62, 0xcb, 0x3c, 0xec, 0x3c, 0xba, 0xf2, 0x9c, 0xef,
-	0x79, 0xce, 0x19, 0xdb, 0xb0, 0xdd, 0xe3, 0x93, 0x09, 0x8f, 0xea, 0xfa, 0x51, 0x9b, 0xc6, 0x3c,
-	0xe1, 0xa8, 0xa0, 0xd1, 0xde, 0xfe, 0x80, 0xf3, 0xc1, 0x98, 0xd5, 0x55, 0xb4, 0x3b, 0xbf, 0xae,
-	0x27, 0xa3, 0x09, 0x9b, 0x25, 0xe1, 0x64, 0xaa, 0x0b, 0xed, 0xcf, 0x06, 0x14, 0xce, 0x58, 0xd8,
-	0x67, 0x31, 0x7a, 0x0d, 0xe5, 0xde, 0x30, 0x1c, 0x45, 0x1a, 0x56, 0x8d, 0x03, 0xe3, 0x79, 0xf9,
-	0x78, 0xbb, 0x96, 0xce, 0x6d, 0x2e, 0x53, 0x74, 0xb5, 0x0e, 0x39, 0xf0, 0xdf, 0x6c, 0x34, 0x88,
-	0xc2, 0x64, 0x1e, 0xb3, 0xb4, 0x75, 0x43, 0xb5, 0x3e, 0xcc, 0x5a, 0xfd, 0xf5, 0x34, 0xbd, 0x5f,
-	0x6f, 0xff, 0x32, 0xa0, 0xbc, 0x32, 0x1f, 0x21, 0xc8, 0x25, 0x77, 0x53, 0xa6, 0x28, 0xe4, 0xa9,
-	0x3a, 0xa3, 0x2a, 0x14, 0x6f, 0x58, 0x3c, 0x1b, 0xf1, 0x48, 0x8d, 0xcf, 0xd3, 0x0c, 0xa2, 0x37,
-	0x50, 0x5a, 0xa8, 0xaa, 0x9a, 0x6a, 0xf5, 0x5e, 0x4d, 0xeb, 0xae, 0x65, 0xba, 0x6b, 0x41, 0x56,
-	0x41, 0x97, 0xc5, 0x72, 0xa6, 0x52, 0xe2, 0xb6, 0xaa, 0x39, 0xd1, 0x57, 0xa1, 0x19, 0x54, 0x0c,
-	0x6e, 0x45, 0x38, 0x2f, 0xc2, 0x25, 0xaa, 0xce, 0x68, 0x07, 0xf2, 0x6c, 0xca, 0x7b, 0xc3, 0x6a,
-	0x41, 0x04, 0x73, 0x54, 0x03, 0xf4, 0x18, 0x4a, 0xec, 0x36, 0x61, 0x91, 0x62, 0x56, 0x54, 0x53,
-	0x96, 0x01, 0x5b, 0x98, 0x73, 0x4f, 0xbd, 0x5a, 0x1a, 0xb3, 0x30, 0xe1, 0xda, 0x62, 0xb9, 0x54,
-	0x43, 0xb9, 0x20, 0xe2, 0x51, 0x8f, 0x29, 0x81, 0x15, 0xaa, 0x81, 0x8d, 0xa1, 0x78, 0x19, 0xde,
-	0x8d, 0x79, 0xd8, 0x47, 0xcf, 0xa0, 0x30, 0x5c, 0xbd, 0x9c, 0xad, 0xcc, 0xe1, 0xd4, 0xd8, 0x34,
-	0x2b, 0xd9, 0xf7, 0xc3, 0x24, 0x4c, 0xe7, 0xa8, 0xb3, 0xdd, 0x80, 0x4d, 0x1c, 0xdd, 0xb0, 0x31,
-	0xd7, 0x5e, 0x4e, 0xf5, 0xc8, 0x8c, 0x42, 0x0a, 0xa5, 0x9a, 0xc5, 0xe5, 0xa4, 0xed, 0xcb, 0x80,
-	0xfd, 0xd5, 0x80, 0x7c, 0x63, 0xcc, 0x7b, 0x9f, 0xd0, 0x51, 0xf6, 0xd6, 0xdc, 0x7f, 0x4d, 0x54,
-	0x3a, 0xa3, 0x93, 0x2a, 0x7e, 0x0a, 0xb9, 0x56, 0x46, 0xa7, 0x7c, 0xfc, 0xff, 0x5a, 0xa9, 0x4c,
-	0x50, 0x95, 0x46, 0x2f, 0x61, 0xf3, 0x82, 0x25, 0xa1, 0x62, 0xae, 0xaf, 0x71, 0x77, 0xad, 0x34,
-	0x4b, 0xd2, 0x45, 0x99, 0xcd, 0xa0, 0xbc, 0xb2, 0x10, 0x3d, 0x80, 0x02, 0x99, 0x4f, 0xba, 0x29,
-	0xab, 0x1c, 0x4d, 0x11, 0xb2, 0xa1, 0x72, 0x19, 0xb3, 0x9b, 0x11, 0x9f, 0xcf, 0xce, 0xc2, 0xd9,
-	0x30, 0x15, 0xb6, 0x16, 0x43, 0x7b, 0xb0, 0x29, 0x59, 0xa8, 0xbc, 0xa9, 0xf2, 0x0b, 0x6c, 0xef,
-	0x43, 0x69, 0x41, 0x56, 0x9a, 0xab, 0xd4, 0x18, 0x07, 0xa6, 0x34, 0x57, 0x9e, 0xed, 0x23, 0xf8,
-	0x77, 0x8d, 0xa2, 0x9c, 0xb6, 0xd0, 0xa2, 0x0b, 0x17, 0xf8, 0xf0, 0x8b, 0xf8, 0xe4, 0xfc, 0x44,
-	0x38, 0x3a, 0x43, 0x65, 0x28, 0xb6, 0xc9, 0x5b, 0xe2, 0xbd, 0x27, 0xd6, 0x3f, 0xa8, 0x02, 0x45,
-	0xbf, 0xdd, 0x6c, 0x62, 0xdf, 0xb7, 0x7e, 0x1a, 0xc8, 0x12, 0xd2, 0x9c, 0x56, 0x87, 0xe2, 0x77,
-	0x6d, 0xec, 0x07, 0xd6, 0x37, 0x13, 0x6d, 0x41, 0xe9, 0xc4, 0xa3, 0x0d, 0xb7, 0xd5, 0xc2, 0xc4,
-	0xfa, 0xae, 0x30, 0xf1, 0x82, 0xce, 0x89, 0xd7, 0x26, 0x2d, 0xeb, 0x87, 0x29, 0x76, 0xee, 0xba,
-	0x24, 0xc0, 0x94, 0x38, 0xe7, 0x1d, 0x1f, 0xd3, 0x2b, 0x4c, 0x3b, 0x98, 0x52, 0x8f, 0x5a, 0xbf,
-	0x4d, 0x71, 0xe3, 0xdb, 0x32, 0xe4, 0x36, 0x71, 0xa7, 0x4d, 0x9c, 0x2b, 0xc7, 0x3d, 0x77, 0x1a,
-	0xe7, 0xd8, 0xfa, 0x63, 0x1e, 0x7e, 0x04, 0xd0, 0xee, 0x05, 0xf2, 0x2b, 0x13, 0x84, 0x2e, 0x04,
-	0x01, 0xe7, 0x14, 0x0b, 0x42, 0x4f, 0xe0, 0x51, 0xd3, 0x23, 0x27, 0xee, 0x69, 0x9b, 0x3a, 0x81,
-	0xeb, 0x91, 0x4e, 0x40, 0x1d, 0xe2, 0x3b, 0x4d, 0x79, 0xb6, 0x0c, 0xe1, 0x36, 0x5a, 0x4f, 0xbb,
-	0x01, 0xbe, 0xb0, 0x36, 0xc4, 0xae, 0x1d, 0x4c, 0x5a, 0x1e, 0x15, 0x0b, 0xd7, 0x3a, 0xcc, 0xc6,
-	0x8b, 0x0f, 0x47, 0x83, 0x51, 0x32, 0x9c, 0x77, 0xe5, 0xbd, 0xd6, 0x87, 0x62, 0x61, 0x3c, 0x66,
-	0xfd, 0x01, 0x8b, 0xeb, 0xd7, 0x61, 0x37, 0x1e, 0xf5, 0xf4, 0x6f, 0x6a, 0x96, 0xfe, 0xca, 0xba,
-	0x05, 0x05, 0x5f, 0xfd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x0e, 0x46, 0x37, 0x79, 0xe2, 0x04, 0x00,
-	0x00,
+	// 694 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
+	0x10, 0xad, 0xeb, 0x7c, 0x34, 0xe3, 0xd0, 0x9a, 0xed, 0x07, 0x26, 0x02, 0x35, 0xb2, 0x04, 0x8a,
+	0x5a, 0x91, 0x88, 0x22, 0x24, 0xae, 0x4e, 0xbc, 0x6d, 0x2d, 0x5a, 0xbb, 0xac, 0x9d, 0x22, 0x71,
+	0x89, 0x9c, 0x64, 0x9b, 0x04, 0x12, 0x6f, 0xe4, 0x38, 0x55, 0x7b, 0xe5, 0x8a, 0x84, 0x90, 0xe0,
+	0x47, 0xf1, 0x0f, 0xf8, 0x23, 0x48, 0x5c, 0xd1, 0xee, 0xda, 0xf9, 0xe8, 0x29, 0xf3, 0xe6, 0xcd,
+	0xcc, 0xbe, 0x37, 0xeb, 0x2c, 0xec, 0xf6, 0xd8, 0x64, 0xc2, 0xa2, 0x86, 0xfc, 0xa9, 0x4f, 0x63,
+	0x96, 0x30, 0x54, 0x90, 0xa8, 0x72, 0x38, 0x60, 0x6c, 0x30, 0xa6, 0x0d, 0x91, 0xed, 0xce, 0x6f,
+	0x1a, 0xc9, 0x68, 0x42, 0x67, 0x49, 0x38, 0x99, 0xca, 0x42, 0xf3, 0xab, 0x02, 0x85, 0x73, 0x1a,
+	0xf6, 0x69, 0x8c, 0xde, 0x82, 0xd6, 0x1b, 0x86, 0xa3, 0x48, 0x42, 0x43, 0xa9, 0x2a, 0x35, 0xed,
+	0x64, 0xb7, 0x9e, 0xce, 0x6d, 0x2d, 0x29, 0xb2, 0x5a, 0x87, 0x2c, 0xd8, 0x99, 0x8d, 0x06, 0x51,
+	0x98, 0xcc, 0x63, 0x9a, 0xb6, 0x6e, 0x8a, 0xd6, 0x27, 0x59, 0xab, 0xbf, 0x4e, 0x93, 0x87, 0xf5,
+	0xe6, 0x1f, 0x05, 0xb4, 0x95, 0xf9, 0x08, 0x41, 0x2e, 0xb9, 0x9f, 0x52, 0x21, 0x21, 0x4f, 0x44,
+	0x8c, 0x0c, 0x28, 0xde, 0xd2, 0x78, 0x36, 0x62, 0x91, 0x18, 0x9f, 0x27, 0x19, 0x44, 0xef, 0xa0,
+	0xb4, 0x70, 0x65, 0xa8, 0xe2, 0xe8, 0x4a, 0x5d, 0xfa, 0xae, 0x67, 0xbe, 0xeb, 0x41, 0x56, 0x41,
+	0x96, 0xc5, 0x7c, 0xa6, 0x70, 0xe2, 0xd8, 0x46, 0xae, 0xaa, 0xd4, 0x4a, 0x24, 0x83, 0x42, 0xc1,
+	0x9d, 0x63, 0x1b, 0x79, 0x91, 0x16, 0x31, 0xda, 0x83, 0x3c, 0x9d, 0xb2, 0xde, 0xd0, 0x28, 0x54,
+	0x95, 0x5a, 0x8e, 0x48, 0x80, 0x9e, 0x41, 0x89, 0xde, 0x25, 0x34, 0x12, 0xca, 0x8a, 0x55, 0xa5,
+	0x56, 0x26, 0xcb, 0x84, 0x69, 0xc1, 0xce, 0x03, 0xf7, 0xe2, 0xd0, 0x98, 0x86, 0x09, 0x93, 0x2b,
+	0x2e, 0x93, 0x0c, 0xf2, 0x03, 0x22, 0x16, 0xf5, 0xa8, 0x30, 0x58, 0x26, 0x12, 0x98, 0x18, 0x8a,
+	0x57, 0xe1, 0xfd, 0x98, 0x85, 0x7d, 0xf4, 0x12, 0x0a, 0xc3, 0xd5, 0xcb, 0xd9, 0xce, 0x36, 0x9c,
+	0x2e, 0x36, 0x65, 0xb9, 0xfa, 0x7e, 0x98, 0x84, 0xe9, 0x1c, 0x11, 0x9b, 0x4d, 0xd8, 0xc2, 0xd1,
+	0x2d, 0x1d, 0x33, 0xb9, 0xcb, 0xa9, 0x1c, 0x99, 0x49, 0x48, 0x21, 0x77, 0xb3, 0xb8, 0x9c, 0xb4,
+	0x7d, 0x99, 0x30, 0xbf, 0x2b, 0x90, 0x6f, 0x8e, 0x59, 0xef, 0x0b, 0x3a, 0xce, 0xbe, 0x9a, 0x87,
+	0x9f, 0x89, 0xa0, 0x33, 0x39, 0xa9, 0xe3, 0x17, 0x90, 0xb3, 0x33, 0x39, 0xda, 0xc9, 0xe3, 0xb5,
+	0x52, 0x4e, 0x10, 0x41, 0xa3, 0xd7, 0xb0, 0x75, 0x49, 0x93, 0x50, 0x28, 0x97, 0xd7, 0xb8, 0xbf,
+	0x56, 0x9a, 0x91, 0x64, 0x51, 0x66, 0x52, 0xd0, 0x56, 0x0e, 0x44, 0x07, 0x50, 0x70, 0xe7, 0x93,
+	0x6e, 0xaa, 0x2a, 0x47, 0x52, 0x84, 0x4c, 0x28, 0x5f, 0xc5, 0xf4, 0x76, 0xc4, 0xe6, 0xb3, 0xf3,
+	0x70, 0x36, 0x4c, 0x8d, 0xad, 0xe5, 0x50, 0x05, 0xb6, 0xb8, 0x0a, 0xc1, 0xab, 0x82, 0x5f, 0x60,
+	0xf3, 0x10, 0x4a, 0x0b, 0xb1, 0x7c, 0xb9, 0xc2, 0x8d, 0x52, 0x55, 0xf9, 0x72, 0x79, 0x6c, 0x1e,
+	0xc3, 0xa3, 0x35, 0x89, 0x7c, 0xda, 0xc2, 0x8b, 0x2c, 0x5c, 0xe0, 0xa3, 0x6f, 0x0a, 0x14, 0xfc,
+	0x24, 0x4c, 0xe6, 0x33, 0xa4, 0x41, 0xb1, 0xed, 0xbe, 0x77, 0xbd, 0x8f, 0xae, 0xbe, 0x81, 0xca,
+	0x50, 0xf4, 0xdb, 0xad, 0x16, 0xf6, 0x7d, 0xfd, 0xb7, 0x82, 0x74, 0xd0, 0x9a, 0x96, 0xdd, 0x21,
+	0xf8, 0x43, 0x1b, 0xfb, 0x81, 0xfe, 0x43, 0x45, 0xdb, 0x50, 0x3a, 0xf5, 0x48, 0xd3, 0xb1, 0x6d,
+	0xec, 0xea, 0x3f, 0x05, 0x76, 0xbd, 0xa0, 0x73, 0xea, 0xb5, 0x5d, 0x5b, 0xff, 0xa5, 0xa2, 0x0a,
+	0xec, 0x3b, 0x6e, 0x80, 0x89, 0x6b, 0x5d, 0x74, 0x7c, 0x4c, 0xae, 0x31, 0xe9, 0x60, 0x42, 0x3c,
+	0xa2, 0xff, 0x55, 0x91, 0x01, 0xbb, 0x3c, 0xe5, 0xb4, 0x70, 0xa7, 0xed, 0x5a, 0xd7, 0x96, 0x73,
+	0x61, 0x35, 0x2f, 0xb0, 0xfe, 0x4f, 0x3d, 0xfa, 0x0c, 0x20, 0xb7, 0x17, 0xf0, 0x7f, 0x99, 0x06,
+	0xc5, 0x4b, 0xec, 0xfb, 0xd6, 0x19, 0xd6, 0x37, 0xd0, 0x73, 0x78, 0xda, 0xf2, 0xdc, 0x53, 0xe7,
+	0xac, 0x4d, 0xac, 0xc0, 0xf1, 0xdc, 0x4e, 0x40, 0x2c, 0xd7, 0xb7, 0x5a, 0x3c, 0xd6, 0x15, 0x74,
+	0x00, 0x68, 0x9d, 0x76, 0x02, 0x7c, 0xa9, 0x6f, 0x22, 0x03, 0xf6, 0xb0, 0x6b, 0x7b, 0xc4, 0xc7,
+	0x64, 0xad, 0x43, 0x6d, 0xbe, 0xfa, 0x74, 0x3c, 0x18, 0x25, 0xc3, 0x79, 0x97, 0xdf, 0x6b, 0x63,
+	0x78, 0x3f, 0xa5, 0xf1, 0x98, 0xf6, 0x07, 0x34, 0x6e, 0xdc, 0x84, 0xdd, 0x78, 0xd4, 0x93, 0xcf,
+	0xd4, 0x2c, 0x7d, 0xca, 0xba, 0x05, 0x01, 0xdf, 0xfc, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xf3,
+	0x5f, 0x52, 0xe2, 0x04, 0x00, 0x00,
 }
diff --git a/protos/common/common.proto b/protos/common/common.proto
index c296fa331e1..359e6e59358 100644
--- a/protos/common/common.proto
+++ b/protos/common/common.proto
@@ -57,7 +57,7 @@ message ChainHeader {
     google.protobuf.Timestamp timestamp = 3;
 
     // Identifier of the chain this message is bound for
-    bytes chainID = 4;
+    string chainID = 4;
 
     // An unique identifier that is used end-to-end.
     //  -  set by higher layers such as end user or SDK
diff --git a/protos/common/configuration.pb.go b/protos/common/configuration.pb.go
index 0762fe22661..f7e87613d3c 100644
--- a/protos/common/configuration.pb.go
+++ b/protos/common/configuration.pb.go
@@ -393,39 +393,39 @@ func init() {
 func init() { proto.RegisterFile("common/configuration.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 536 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x54, 0x51, 0x8f, 0xd2, 0x40,
-	0x10, 0xbe, 0x1e, 0xb4, 0x77, 0x0c, 0x8d, 0x87, 0x73, 0xea, 0x35, 0xc4, 0xa0, 0xe9, 0x13, 0x09,
-	0x0a, 0x09, 0xa7, 0xaf, 0x9a, 0x70, 0xf1, 0x72, 0x17, 0x14, 0xcc, 0x6a, 0xee, 0xc1, 0xc4, 0xc4,
-	0x42, 0x17, 0xd8, 0x04, 0xba, 0x64, 0xdb, 0x9a, 0xf0, 0x6e, 0xe2, 0x7f, 0xf2, 0xd1, 0x5f, 0xe6,
-	0x76, 0xb7, 0xad, 0x2d, 0x94, 0xa7, 0x76, 0xbf, 0xf9, 0xbe, 0x99, 0x6f, 0xa6, 0xd3, 0x85, 0xf6,
-	0x9c, 0x6f, 0x36, 0x3c, 0x18, 0xcc, 0x79, 0xb0, 0x60, 0xcb, 0x58, 0x78, 0x11, 0xe3, 0x41, 0x7f,
-	0x2b, 0x78, 0xc4, 0xd1, 0xd2, 0xb1, 0xf6, 0x65, 0xce, 0x49, 0x1e, 0x3a, 0xe8, 0x4e, 0xe0, 0xe9,
-	0x4d, 0x51, 0xf3, 0x21, 0xf8, 0x49, 0xd7, 0x7c, 0x4b, 0xf1, 0x2d, 0x98, 0xf7, 0x11, 0xdd, 0x84,
-	0x8e, 0xf1, 0xb2, 0xd6, 0x6d, 0x0e, 0x5f, 0xf4, 0x53, 0xd9, 0x17, 0xb6, 0x0c, 0xa8, 0x5f, 0xd2,
-	0x24, 0x3c, 0xa2, 0xd9, 0xee, 0x6f, 0x03, 0xae, 0x8e, 0x50, 0xf0, 0x15, 0x3c, 0x3e, 0x00, 0x65,
-	0x7a, 0xa3, 0x6b, 0x93, 0xc3, 0x00, 0xbe, 0x03, 0x48, 0x12, 0x79, 0x51, 0x2c, 0x68, 0xe8, 0x9c,
-	0x2a, 0x17, 0x9d, 0xcc, 0x45, 0x89, 0x9e, 0xd3, 0x48, 0x41, 0xe1, 0xfe, 0x3d, 0xad, 0x28, 0x87,
-	0x3d, 0xb0, 0xee, 0xa8, 0xe7, 0x53, 0xa1, 0x0a, 0x37, 0x87, 0x97, 0x79, 0xc6, 0x95, 0xc7, 0x02,
-	0x1d, 0x22, 0x29, 0x05, 0xdf, 0x43, 0xfd, 0xeb, 0x6e, 0x4b, 0x65, 0x71, 0xa3, 0xfb, 0x68, 0xd8,
-	0xab, 0x2c, 0x9e, 0x64, 0x2d, 0x23, 0x89, 0x84, 0x28, 0x21, 0xba, 0x60, 0x7f, 0xf4, 0xc2, 0xe8,
-	0x13, 0xf7, 0xd9, 0x82, 0x51, 0xdf, 0xa9, 0xc9, 0x44, 0x75, 0x52, 0xc2, 0xb0, 0x0f, 0xa8, 0xdf,
-	0xe7, 0x4a, 0xfd, 0x99, 0xaf, 0xd9, 0x7c, 0xe7, 0xd4, 0x25, 0xb3, 0x41, 0x2a, 0x22, 0xd8, 0x82,
-	0xda, 0x98, 0xee, 0x1c, 0x53, 0x11, 0x92, 0x57, 0x7c, 0x02, 0xe6, 0x83, 0xb7, 0x8e, 0xa9, 0x63,
-	0xa9, 0x59, 0xea, 0x83, 0x7b, 0xb3, 0xd7, 0xbe, 0x32, 0x04, 0x60, 0xe9, 0x34, 0xad, 0x13, 0x6c,
-	0x80, 0xa9, 0x9a, 0x6e, 0x19, 0xd8, 0x84, 0xb3, 0xa9, 0x90, 0x1d, 0x53, 0xd1, 0x3a, 0x4d, 0x38,
-	0xb7, 0xde, 0x4c, 0xb0, 0x79, 0xab, 0xe6, 0xfe, 0x80, 0x67, 0xd5, 0xa3, 0xc6, 0x2e, 0x5c, 0x84,
-	0xd9, 0xa1, 0x30, 0x51, 0x9b, 0xec, 0xc3, 0xf8, 0x1c, 0x1a, 0x39, 0xa4, 0x46, 0x69, 0x93, 0xff,
-	0x80, 0xfb, 0x3d, 0x73, 0x84, 0x63, 0xb8, 0xc8, 0xd3, 0xa7, 0x53, 0xd0, 0xdf, 0xa8, 0xb4, 0x7b,
-	0x85, 0x70, 0xb6, 0xab, 0x77, 0x27, 0x64, 0x5f, 0x39, 0xb2, 0xf4, 0xa7, 0x73, 0x7f, 0xa5, 0xfb,
-	0x58, 0x21, 0x43, 0x07, 0xce, 0x1e, 0xa8, 0x08, 0x65, 0x5b, 0xaa, 0x90, 0x49, 0xb2, 0x23, 0x0e,
-	0x32, 0x53, 0xca, 0x6f, 0x73, 0x78, 0x75, 0xc4, 0x01, 0xc9, 0xbc, 0x77, 0x00, 0xee, 0x7d, 0x1a,
-	0x44, 0x2c, 0x62, 0x72, 0x59, 0x6b, 0x72, 0x59, 0x6d, 0x52, 0x40, 0xdc, 0x3f, 0xc6, 0x41, 0x73,
-	0x72, 0x2e, 0xe7, 0xfa, 0x4f, 0x19, 0xe9, 0x46, 0x4d, 0xd9, 0x47, 0x8e, 0xe0, 0x1b, 0xa8, 0xdf,
-	0x0a, 0xbe, 0x49, 0x0d, 0x74, 0x8e, 0x18, 0xe8, 0x4f, 0xa6, 0x71, 0x34, 0x5d, 0x48, 0xa5, 0x62,
-	0xb7, 0xc7, 0x60, 0x69, 0x04, 0x6d, 0x30, 0x26, 0x69, 0x5b, 0xc6, 0x04, 0xaf, 0xe1, 0x5c, 0x09,
-	0x58, 0xfe, 0x2b, 0x1d, 0x6d, 0x29, 0x27, 0x66, 0x33, 0x1c, 0xbd, 0xfe, 0xd6, 0x5b, 0xb2, 0x68,
-	0x15, 0xcf, 0x12, 0xc9, 0x60, 0x25, 0x21, 0xb1, 0xa6, 0xfe, 0x92, 0x8a, 0xc1, 0x42, 0xed, 0xc9,
-	0x40, 0x5d, 0x25, 0x61, 0x7a, 0xb1, 0xcc, 0x2c, 0x75, 0xbc, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff,
-	0x71, 0x39, 0xd4, 0x0c, 0x94, 0x04, 0x00, 0x00,
+	// 540 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x54, 0xdf, 0x8f, 0xd2, 0x40,
+	0x10, 0x66, 0x29, 0xed, 0xdd, 0x0d, 0x8d, 0x87, 0x73, 0xea, 0x35, 0xe4, 0x82, 0x4d, 0x9f, 0x9a,
+	0xa0, 0x90, 0x70, 0xfa, 0xaa, 0x09, 0x17, 0x2f, 0x5c, 0x50, 0x30, 0xab, 0xb9, 0x07, 0x13, 0x13,
+	0x0b, 0x5d, 0x60, 0x13, 0xe8, 0x92, 0x6d, 0x31, 0xe1, 0xdd, 0xc4, 0xff, 0xc9, 0x47, 0xff, 0x32,
+	0xd3, 0xdd, 0xb6, 0xf2, 0xa3, 0x3c, 0xb5, 0xfb, 0xcd, 0xf7, 0xcd, 0x7c, 0x33, 0x9d, 0x2e, 0x34,
+	0xa7, 0x62, 0xb5, 0x12, 0x51, 0x77, 0x2a, 0xa2, 0x19, 0x9f, 0x6f, 0x64, 0x90, 0x70, 0x11, 0x75,
+	0xd6, 0x52, 0x24, 0x02, 0x2d, 0x1d, 0x6b, 0x5e, 0x15, 0x9c, 0xf4, 0xa1, 0x83, 0xde, 0x08, 0x9e,
+	0xdf, 0xed, 0x6a, 0x3e, 0x44, 0x3f, 0xd9, 0x52, 0xac, 0x19, 0xbe, 0x05, 0xf3, 0x21, 0x61, 0xab,
+	0xd8, 0x21, 0xae, 0xe1, 0xd7, 0x7b, 0x2f, 0x3b, 0x99, 0xec, 0x0b, 0x9f, 0x47, 0x2c, 0xdc, 0xd3,
+	0xa4, 0x3c, 0xaa, 0xd9, 0xde, 0x6f, 0x02, 0xd7, 0x27, 0x28, 0xf8, 0x0a, 0x9e, 0x1e, 0x81, 0x0e,
+	0x71, 0x89, 0x6f, 0xd3, 0xe3, 0x00, 0xbe, 0x03, 0x48, 0x13, 0x05, 0xc9, 0x46, 0xb2, 0xd8, 0xa9,
+	0x2a, 0x17, 0xad, 0xdc, 0xc5, 0x1e, 0xbd, 0xa0, 0xd1, 0x1d, 0x85, 0xf7, 0xb7, 0x5a, 0x52, 0x0e,
+	0xdb, 0x60, 0x0d, 0x58, 0x10, 0x32, 0xa9, 0x0a, 0xd7, 0x7b, 0x57, 0x45, 0xc6, 0x45, 0xc0, 0x23,
+	0x1d, 0xa2, 0x19, 0x05, 0xdf, 0x43, 0xed, 0xeb, 0x76, 0xcd, 0x9c, 0xaa, 0x4b, 0xfc, 0x27, 0xbd,
+	0x76, 0x69, 0xf1, 0x34, 0xeb, 0x3e, 0x92, 0x4a, 0xa8, 0x12, 0xa2, 0x07, 0xf6, 0xc7, 0x20, 0x4e,
+	0x3e, 0x89, 0x90, 0xcf, 0x38, 0x0b, 0x1d, 0xc3, 0x25, 0x7e, 0x8d, 0xee, 0x61, 0xd8, 0x01, 0xd4,
+	0xef, 0x53, 0xa5, 0xfe, 0x2c, 0x96, 0x7c, 0xba, 0x75, 0x6a, 0x2e, 0xf1, 0x2f, 0x68, 0x49, 0x04,
+	0x1b, 0x60, 0x0c, 0xd9, 0xd6, 0x31, 0x15, 0x21, 0x7d, 0xc5, 0x67, 0x60, 0x3e, 0x06, 0xcb, 0x0d,
+	0x73, 0x2c, 0x35, 0x4b, 0x7d, 0xf0, 0xee, 0x0e, 0xda, 0x57, 0x86, 0x00, 0x2c, 0x9d, 0xa6, 0x51,
+	0xc1, 0x0b, 0x30, 0x55, 0xd3, 0x0d, 0x82, 0x75, 0x38, 0x1b, 0xcb, 0x90, 0x49, 0x26, 0x1b, 0xd5,
+	0x94, 0x73, 0x1f, 0x4c, 0x24, 0x9f, 0x36, 0x0c, 0xef, 0x07, 0xbc, 0x28, 0x1f, 0x35, 0xfa, 0x70,
+	0x19, 0xe7, 0x87, 0x9d, 0x89, 0xda, 0xf4, 0x10, 0xc6, 0x1b, 0xb8, 0x28, 0x20, 0x35, 0x4a, 0x9b,
+	0xfe, 0x07, 0xbc, 0xef, 0xb9, 0x23, 0x1c, 0xc2, 0x65, 0x91, 0x3e, 0x9b, 0x82, 0xfe, 0x46, 0x7b,
+	0xbb, 0xb7, 0x13, 0xce, 0x77, 0x75, 0x50, 0xa1, 0x87, 0xca, 0xbe, 0xa5, 0x3f, 0x9d, 0xf7, 0x2b,
+	0xdb, 0xc7, 0x12, 0x19, 0x3a, 0x70, 0xf6, 0xc8, 0x64, 0xcc, 0x45, 0xa4, 0x0a, 0x99, 0x34, 0x3f,
+	0x62, 0x37, 0x37, 0xa5, 0xfc, 0xd6, 0x7b, 0xd7, 0x27, 0x1c, 0xd0, 0xdc, 0x7b, 0x0b, 0xe0, 0x21,
+	0x64, 0x51, 0xc2, 0x13, 0xce, 0x62, 0xc7, 0x70, 0x0d, 0xdf, 0xa6, 0x3b, 0x88, 0xf7, 0x87, 0x1c,
+	0x35, 0x87, 0x37, 0x70, 0xae, 0xff, 0x94, 0xbe, 0x6e, 0xd4, 0x1c, 0x54, 0x68, 0x81, 0xe0, 0x1b,
+	0xa8, 0xdd, 0x4b, 0xb1, 0xca, 0x0c, 0xb4, 0x4e, 0x18, 0xe8, 0x8c, 0xc6, 0x9b, 0x64, 0x3c, 0x1b,
+	0x54, 0xa8, 0x62, 0x37, 0x87, 0x60, 0x69, 0x04, 0x6d, 0x20, 0xa3, 0xac, 0x2d, 0x32, 0xc2, 0x5b,
+	0x38, 0x57, 0x02, 0x5e, 0xfc, 0x4a, 0x27, 0x5b, 0x2a, 0x88, 0xf9, 0x0c, 0xfb, 0xaf, 0xbf, 0xb5,
+	0xe7, 0x3c, 0x59, 0x6c, 0x26, 0xa9, 0xa4, 0xbb, 0xd8, 0xae, 0x99, 0x5c, 0xb2, 0x70, 0xce, 0x64,
+	0x77, 0xa6, 0xf6, 0xa4, 0xab, 0xae, 0x92, 0x38, 0xbb, 0x58, 0x26, 0x96, 0x3a, 0xde, 0xfe, 0x0b,
+	0x00, 0x00, 0xff, 0xff, 0x71, 0x39, 0xd4, 0x0c, 0x94, 0x04, 0x00, 0x00,
 }
diff --git a/protos/orderer/ab.pb.go b/protos/orderer/ab.pb.go
index a721faa5843..89601dbd48d 100644
--- a/protos/orderer/ab.pb.go
+++ b/protos/orderer/ab.pb.go
@@ -79,7 +79,7 @@ type SeekInfo struct {
 	Start           SeekInfo_StartType `protobuf:"varint,1,opt,name=Start,enum=orderer.SeekInfo_StartType" json:"Start,omitempty"`
 	SpecifiedNumber uint64             `protobuf:"varint,2,opt,name=SpecifiedNumber" json:"SpecifiedNumber,omitempty"`
 	WindowSize      uint64             `protobuf:"varint,3,opt,name=WindowSize" json:"WindowSize,omitempty"`
-	ChainID         []byte             `protobuf:"bytes,4,opt,name=ChainID,proto3" json:"ChainID,omitempty"`
+	ChainID         string             `protobuf:"bytes,4,opt,name=ChainID" json:"ChainID,omitempty"`
 }
 
 func (m *SeekInfo) Reset()                    { *m = SeekInfo{} }
@@ -523,34 +523,34 @@ var _AtomicBroadcast_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("orderer/ab.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 459 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0xed, 0x6e, 0xd3, 0x30,
-	0x14, 0x9d, 0x47, 0x3f, 0xd8, 0x1d, 0x5d, 0x3b, 0x23, 0x4d, 0x51, 0x91, 0x10, 0x8a, 0x04, 0x14,
-	0x09, 0x25, 0x10, 0x7e, 0xf2, 0x03, 0xad, 0x4b, 0x10, 0x95, 0xd0, 0x40, 0xc9, 0xd0, 0x24, 0xfe,
-	0xe5, 0xe3, 0x76, 0xb5, 0xd6, 0xc4, 0x91, 0xe3, 0x6e, 0x82, 0x07, 0xe0, 0x0d, 0x78, 0x34, 0xde,
-	0x07, 0xc7, 0x71, 0xc2, 0xd6, 0xf2, 0x2b, 0xbe, 0xe7, 0x9e, 0x73, 0xcf, 0xcd, 0xb1, 0x61, 0xc2,
-	0x45, 0x86, 0x02, 0x85, 0x1b, 0x27, 0x4e, 0x29, 0xb8, 0xe4, 0x74, 0x68, 0x90, 0xe9, 0xe3, 0x94,
-	0xe7, 0x39, 0x2f, 0xdc, 0xe6, 0xd3, 0x74, 0xed, 0xf7, 0x70, 0x3c, 0x17, 0x3c, 0xce, 0xd2, 0xb8,
-	0x92, 0x21, 0x56, 0x25, 0x2f, 0x2a, 0xa4, 0x2f, 0x60, 0x10, 0xc9, 0x58, 0x6e, 0x2a, 0x8b, 0x3c,
-	0x23, 0xb3, 0x23, 0xef, 0xc8, 0x31, 0x9a, 0x06, 0x0d, 0x4d, 0xd7, 0xfe, 0x43, 0xe0, 0x61, 0x84,
-	0x78, 0xbd, 0x28, 0x96, 0x9c, 0xbe, 0x85, 0xbe, 0x82, 0x85, 0x34, 0x9a, 0x27, 0x8e, 0xf1, 0x75,
-	0x5a, 0x86, 0xa3, 0xdb, 0x17, 0x3f, 0x4a, 0x0c, 0x1b, 0x26, 0x9d, 0xc1, 0x38, 0x2a, 0x31, 0x65,
-	0x4b, 0x86, 0xd9, 0xf9, 0x26, 0x4f, 0x50, 0x58, 0xfb, 0x4a, 0xdc, 0x0b, 0xb7, 0x61, 0xfa, 0x14,
-	0xe0, 0x92, 0x15, 0x19, 0xbf, 0x8d, 0xd8, 0x4f, 0xb4, 0x1e, 0x68, 0xd2, 0x1d, 0x84, 0x5a, 0x30,
-	0x3c, 0x5b, 0xc5, 0xac, 0x58, 0xf8, 0x56, 0x4f, 0x35, 0x1f, 0x85, 0x6d, 0x69, 0x7b, 0x70, 0xd0,
-	0xf9, 0x52, 0x80, 0xc1, 0x79, 0x70, 0x19, 0x44, 0x17, 0x93, 0xbd, 0xfa, 0xfc, 0xe5, 0xb3, 0x5f,
-	0x9f, 0x09, 0x1d, 0x29, 0xd2, 0xd7, 0xe0, 0x6c, 0xf1, 0x71, 0x11, 0xf8, 0x93, 0x7d, 0xfb, 0x15,
-	0x8c, 0x4f, 0xd3, 0xeb, 0x82, 0xdf, 0xae, 0x31, 0xbb, 0xc2, 0x1c, 0x0b, 0x49, 0x4f, 0x94, 0xb2,
-	0xd9, 0x90, 0x68, 0x73, 0x53, 0xd9, 0xbf, 0x08, 0x8c, 0x7c, 0x5c, 0xb3, 0x1b, 0x14, 0xdf, 0xca,
-	0x2c, 0x96, 0x48, 0xfd, 0x1d, 0xb1, 0x96, 0x1c, 0x7a, 0x56, 0x97, 0xc8, 0x56, 0xff, 0xd3, 0x5e,
-	0xb8, 0xe3, 0xf7, 0x12, 0x7a, 0x75, 0x6e, 0x3a, 0x8f, 0x43, 0xef, 0x78, 0x27, 0x4c, 0xa5, 0xd1,
-	0x84, 0xf9, 0x00, 0x7a, 0xf5, 0xaf, 0xd9, 0x2b, 0x18, 0x9b, 0x3d, 0xee, 0x5c, 0x63, 0x3f, 0x10,
-	0x82, 0x8b, 0xff, 0xdf, 0xa2, 0x9a, 0xd0, 0xb4, 0xe9, 0x73, 0xe8, 0xcf, 0xd7, 0x3c, 0x6d, 0xcd,
-	0x46, 0x2d, 0x4f, 0x83, 0x35, 0x4d, 0x1f, 0x5a, 0x27, 0xef, 0x37, 0x51, 0x7f, 0x28, 0x79, 0xce,
-	0xd2, 0xee, 0xe5, 0xd0, 0x0f, 0x70, 0xf0, 0xaf, 0x98, 0xb4, 0x03, 0x82, 0xe2, 0x06, 0xd7, 0xbc,
-	0xc4, 0xe9, 0xb4, 0xdb, 0x7f, 0xe7, 0xb1, 0xd9, 0x7b, 0x33, 0xf2, 0x86, 0xd0, 0x53, 0x18, 0x9a,
-	0xf5, 0xe9, 0x49, 0x47, 0xbe, 0x17, 0xec, 0xd4, 0xda, 0xc6, 0xef, 0x8f, 0x98, 0x3b, 0xdf, 0x5f,
-	0x5f, 0x31, 0xb9, 0xda, 0x24, 0xb5, 0xbd, 0xbb, 0x52, 0xab, 0x0a, 0x9d, 0xa7, 0x70, 0x97, 0x71,
-	0x22, 0x58, 0xea, 0xea, 0x17, 0x5f, 0xb9, 0x66, 0x4a, 0x32, 0xd0, 0xf5, 0xbb, 0xbf, 0x01, 0x00,
-	0x00, 0xff, 0xff, 0x22, 0xc6, 0xf5, 0x3a, 0x33, 0x03, 0x00, 0x00,
+	// 462 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0xdb, 0x6e, 0xd3, 0x40,
+	0x10, 0xf5, 0x96, 0xc4, 0x21, 0x53, 0xa5, 0x49, 0x17, 0xa9, 0xb2, 0x82, 0x84, 0x22, 0x4b, 0x80,
+	0x91, 0x90, 0x0d, 0xe6, 0x91, 0x07, 0x94, 0xd4, 0x46, 0x89, 0x84, 0x0a, 0xb2, 0x8b, 0x2a, 0xf1,
+	0xe6, 0xcb, 0xa4, 0xb1, 0x1a, 0x7b, 0xad, 0xf5, 0xa6, 0x55, 0xf9, 0x00, 0xfe, 0x80, 0x4f, 0xe3,
+	0x7f, 0x90, 0xd7, 0x6b, 0xd3, 0x26, 0x3c, 0x79, 0xe6, 0xcc, 0x99, 0x39, 0xe3, 0xb3, 0x03, 0x13,
+	0xc6, 0x53, 0xe4, 0xc8, 0x9d, 0x28, 0xb6, 0x4b, 0xce, 0x04, 0xa3, 0x03, 0x85, 0x4c, 0x9f, 0x25,
+	0x2c, 0xcf, 0x59, 0xe1, 0x34, 0x9f, 0xa6, 0x6a, 0x7e, 0x84, 0xd3, 0x05, 0x67, 0x51, 0x9a, 0x44,
+	0x95, 0x08, 0xb0, 0x2a, 0x59, 0x51, 0x21, 0x7d, 0x05, 0x7a, 0x28, 0x22, 0xb1, 0xab, 0x0c, 0x32,
+	0x23, 0xd6, 0x89, 0x7b, 0x62, 0xab, 0x9e, 0x06, 0x0d, 0x54, 0xd5, 0xfc, 0x43, 0xe0, 0x69, 0x88,
+	0x78, 0xb3, 0x2a, 0xd6, 0x8c, 0xbe, 0x87, 0x7e, 0x28, 0x22, 0x2e, 0x54, 0xcf, 0x73, 0x5b, 0xe9,
+	0xda, 0x2d, 0xc3, 0x96, 0xe5, 0xcb, 0xfb, 0x12, 0x83, 0x86, 0x49, 0x2d, 0x18, 0x87, 0x25, 0x26,
+	0xd9, 0x3a, 0xc3, 0xf4, 0x62, 0x97, 0xc7, 0xc8, 0x8d, 0xa3, 0x19, 0xb1, 0x7a, 0xc1, 0x3e, 0x4c,
+	0x5f, 0x00, 0x5c, 0x65, 0x45, 0xca, 0xee, 0xc2, 0xec, 0x27, 0x1a, 0x4f, 0x24, 0xe9, 0x01, 0x42,
+	0x0d, 0x18, 0x9c, 0x6f, 0xa2, 0xac, 0x58, 0x79, 0x46, 0x6f, 0x46, 0xac, 0x61, 0xd0, 0xa6, 0xa6,
+	0x0b, 0xc3, 0x4e, 0x97, 0x02, 0xe8, 0x17, 0xfe, 0x95, 0x1f, 0x5e, 0x4e, 0xb4, 0x3a, 0xfe, 0xfa,
+	0xc5, 0xab, 0x63, 0x42, 0x47, 0x30, 0x0c, 0xbf, 0xf9, 0xe7, 0xab, 0xcf, 0x2b, 0xdf, 0x9b, 0x1c,
+	0x99, 0x6f, 0x60, 0x3c, 0x4f, 0x6e, 0x0a, 0x76, 0xb7, 0xc5, 0xf4, 0x1a, 0x73, 0x2c, 0x04, 0x3d,
+	0x03, 0x5d, 0x6d, 0x48, 0xa4, 0xb8, 0xca, 0xcc, 0x5f, 0x04, 0x46, 0x1e, 0x6e, 0xb3, 0x5b, 0xe4,
+	0xdf, 0xcb, 0x34, 0x12, 0x48, 0xbd, 0x83, 0x66, 0xd9, 0x72, 0xec, 0x1a, 0x9d, 0x23, 0x7b, 0xf5,
+	0xa5, 0x16, 0x1c, 0xe8, 0xbd, 0x86, 0x5e, 0xed, 0x9b, 0xf4, 0xe3, 0xd8, 0x3d, 0x3d, 0x30, 0x73,
+	0xa9, 0x05, 0x92, 0xb0, 0xd0, 0xa1, 0x57, 0xff, 0x9a, 0xb9, 0x81, 0xb1, 0xda, 0xe3, 0xc1, 0x33,
+	0xf6, 0x7d, 0xce, 0x19, 0xff, 0xff, 0x2b, 0x2e, 0xb5, 0xa0, 0x29, 0xd3, 0x97, 0xd0, 0x5f, 0x6c,
+	0x59, 0xd2, 0x8a, 0x8d, 0x5a, 0x9e, 0x04, 0x6b, 0x9a, 0x0c, 0x5a, 0x25, 0xf7, 0x37, 0x81, 0xf1,
+	0x5c, 0xb0, 0x3c, 0x4b, 0xba, 0xcb, 0xa1, 0x9f, 0x60, 0xf8, 0x2f, 0x99, 0xb4, 0x03, 0xfc, 0xe2,
+	0x16, 0xb7, 0xac, 0xc4, 0xe9, 0xb4, 0xdb, 0xff, 0xe0, 0xd8, 0x4c, 0xcd, 0x22, 0xef, 0x08, 0x9d,
+	0xc3, 0x40, 0xad, 0x4f, 0xcf, 0x3a, 0xf2, 0x23, 0x63, 0xa7, 0xc6, 0x3e, 0xfe, 0x78, 0xc4, 0xc2,
+	0xfe, 0xf1, 0xf6, 0x3a, 0x13, 0x9b, 0x5d, 0x5c, 0xcb, 0x3b, 0x9b, 0xfb, 0x12, 0xb9, 0xf4, 0x93,
+	0x3b, 0xeb, 0x28, 0xe6, 0x59, 0xe2, 0xc8, 0x8b, 0xaf, 0x1c, 0x35, 0x25, 0xd6, 0x65, 0xfe, 0xe1,
+	0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xf9, 0x20, 0x03, 0x33, 0x03, 0x00, 0x00,
 }
diff --git a/protos/orderer/ab.proto b/protos/orderer/ab.proto
index 959e9be7cb6..e65c7a8a96b 100644
--- a/protos/orderer/ab.proto
+++ b/protos/orderer/ab.proto
@@ -39,7 +39,7 @@ message SeekInfo {
     StartType Start = 1;
     uint64 SpecifiedNumber = 2; // Only used when start = SPECIFIED
     uint64 WindowSize = 3; // The window size is the maximum number of blocks that will be sent without Acknowledgement, the base of the window moves to the most recently received acknowledgment
-    bytes ChainID = 4; // The chain to seek within
+    string ChainID = 4; // The chain to seek within
 }
 
 message Acknowledgement {
diff --git a/protos/peer/chaincode.pb.go b/protos/peer/chaincode.pb.go
index 784c9e2b59b..cce78a9a93c 100644
--- a/protos/peer/chaincode.pb.go
+++ b/protos/peer/chaincode.pb.go
@@ -2,6 +2,69 @@
 // source: peer/chaincode.proto
 // DO NOT EDIT!
 
+/*
+Package peer is a generated protocol buffer package.
+
+It is generated from these files:
+	peer/chaincode.proto
+	peer/chaincode_proposal.proto
+	peer/chaincode_transaction.proto
+	peer/chaincodeevent.proto
+	peer/events.proto
+	peer/fabric.proto
+	peer/fabric_message.proto
+	peer/fabric_proposal.proto
+	peer/fabric_proposal_response.proto
+	peer/fabric_service.proto
+	peer/fabric_transaction.proto
+	peer/server_admin.proto
+
+It has these top-level messages:
+	ChaincodeID
+	ChaincodeInput
+	ChaincodeSpec
+	ChaincodeDeploymentSpec
+	ChaincodeInvocationSpec
+	ChaincodeMessage
+	PutStateInfo
+	RangeQueryState
+	RangeQueryStateNext
+	RangeQueryStateClose
+	RangeQueryStateKeyValue
+	RangeQueryStateResponse
+	ChaincodeHeaderExtension
+	ChaincodeProposalPayload
+	ChaincodeAction
+	ChaincodeActionPayload
+	ChaincodeEndorsedAction
+	ChaincodeEvent
+	ChaincodeReg
+	Interest
+	Register
+	Rejection
+	Unregister
+	Event
+	PeerAddress
+	PeerID
+	PeerEndpoint
+	PeersMessage
+	PeersAddresses
+	BlockchainInfo
+	Message
+	SignedProposal
+	Proposal
+	ProposalResponse
+	Response
+	ProposalResponsePayload
+	Endorsement
+	SignedTransaction
+	InvalidTransaction
+	Transaction
+	TransactionAction
+	ServerStatus
+	LogLevelRequest
+	LogLevelResponse
+*/
 package peer
 
 import proto "github.com/golang/protobuf/proto"
@@ -19,6 +82,12 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
 // Confidentiality Levels
 type ConfidentialityLevel int32
 
@@ -39,7 +108,7 @@ var ConfidentialityLevel_value = map[string]int32{
 func (x ConfidentialityLevel) String() string {
 	return proto.EnumName(ConfidentialityLevel_name, int32(x))
 }
-func (ConfidentialityLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+func (ConfidentialityLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 type ChaincodeSpec_Type int32
 
@@ -69,7 +138,7 @@ var ChaincodeSpec_Type_value = map[string]int32{
 func (x ChaincodeSpec_Type) String() string {
 	return proto.EnumName(ChaincodeSpec_Type_name, int32(x))
 }
-func (ChaincodeSpec_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{2, 0} }
+func (ChaincodeSpec_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2, 0} }
 
 type ChaincodeDeploymentSpec_ExecutionEnvironment int32
 
@@ -91,7 +160,7 @@ func (x ChaincodeDeploymentSpec_ExecutionEnvironment) String() string {
 	return proto.EnumName(ChaincodeDeploymentSpec_ExecutionEnvironment_name, int32(x))
 }
 func (ChaincodeDeploymentSpec_ExecutionEnvironment) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor2, []int{3, 0}
+	return fileDescriptor0, []int{3, 0}
 }
 
 type ChaincodeMessage_Type int32
@@ -158,7 +227,7 @@ var ChaincodeMessage_Type_value = map[string]int32{
 func (x ChaincodeMessage_Type) String() string {
 	return proto.EnumName(ChaincodeMessage_Type_name, int32(x))
 }
-func (ChaincodeMessage_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{5, 0} }
+func (ChaincodeMessage_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }
 
 // ChaincodeID contains the path as specified by the deploy transaction
 // that created it as well as the hashCode that is generated by the
@@ -178,7 +247,7 @@ type ChaincodeID struct {
 func (m *ChaincodeID) Reset()                    { *m = ChaincodeID{} }
 func (m *ChaincodeID) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeID) ProtoMessage()               {}
-func (*ChaincodeID) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+func (*ChaincodeID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 // Carries the chaincode function and its arguments.
 // UnmarshalJSON in transaction.go converts the string-based REST/JSON input to
@@ -190,7 +259,7 @@ type ChaincodeInput struct {
 func (m *ChaincodeInput) Reset()                    { *m = ChaincodeInput{} }
 func (m *ChaincodeInput) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeInput) ProtoMessage()               {}
-func (*ChaincodeInput) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+func (*ChaincodeInput) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 
 // Carries the chaincode specification. This is the actual metadata required for
 // defining a chaincode.
@@ -208,7 +277,7 @@ type ChaincodeSpec struct {
 func (m *ChaincodeSpec) Reset()                    { *m = ChaincodeSpec{} }
 func (m *ChaincodeSpec) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeSpec) ProtoMessage()               {}
-func (*ChaincodeSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
+func (*ChaincodeSpec) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 
 func (m *ChaincodeSpec) GetChaincodeID() *ChaincodeID {
 	if m != nil {
@@ -237,7 +306,7 @@ type ChaincodeDeploymentSpec struct {
 func (m *ChaincodeDeploymentSpec) Reset()                    { *m = ChaincodeDeploymentSpec{} }
 func (m *ChaincodeDeploymentSpec) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeDeploymentSpec) ProtoMessage()               {}
-func (*ChaincodeDeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
+func (*ChaincodeDeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 
 func (m *ChaincodeDeploymentSpec) GetChaincodeSpec() *ChaincodeSpec {
 	if m != nil {
@@ -269,7 +338,7 @@ type ChaincodeInvocationSpec struct {
 func (m *ChaincodeInvocationSpec) Reset()                    { *m = ChaincodeInvocationSpec{} }
 func (m *ChaincodeInvocationSpec) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeInvocationSpec) ProtoMessage()               {}
-func (*ChaincodeInvocationSpec) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
+func (*ChaincodeInvocationSpec) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 
 func (m *ChaincodeInvocationSpec) GetChaincodeSpec() *ChaincodeSpec {
 	if m != nil {
@@ -292,7 +361,7 @@ type ChaincodeMessage struct {
 func (m *ChaincodeMessage) Reset()                    { *m = ChaincodeMessage{} }
 func (m *ChaincodeMessage) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeMessage) ProtoMessage()               {}
-func (*ChaincodeMessage) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
+func (*ChaincodeMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 
 func (m *ChaincodeMessage) GetTimestamp() *google_protobuf.Timestamp {
 	if m != nil {
@@ -316,7 +385,7 @@ type PutStateInfo struct {
 func (m *PutStateInfo) Reset()                    { *m = PutStateInfo{} }
 func (m *PutStateInfo) String() string            { return proto.CompactTextString(m) }
 func (*PutStateInfo) ProtoMessage()               {}
-func (*PutStateInfo) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
+func (*PutStateInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
 type RangeQueryState struct {
 	StartKey string `protobuf:"bytes,1,opt,name=startKey" json:"startKey,omitempty"`
@@ -326,7 +395,7 @@ type RangeQueryState struct {
 func (m *RangeQueryState) Reset()                    { *m = RangeQueryState{} }
 func (m *RangeQueryState) String() string            { return proto.CompactTextString(m) }
 func (*RangeQueryState) ProtoMessage()               {}
-func (*RangeQueryState) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
+func (*RangeQueryState) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
 type RangeQueryStateNext struct {
 	ID string `protobuf:"bytes,1,opt,name=ID" json:"ID,omitempty"`
@@ -335,7 +404,7 @@ type RangeQueryStateNext struct {
 func (m *RangeQueryStateNext) Reset()                    { *m = RangeQueryStateNext{} }
 func (m *RangeQueryStateNext) String() string            { return proto.CompactTextString(m) }
 func (*RangeQueryStateNext) ProtoMessage()               {}
-func (*RangeQueryStateNext) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
+func (*RangeQueryStateNext) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
 type RangeQueryStateClose struct {
 	ID string `protobuf:"bytes,1,opt,name=ID" json:"ID,omitempty"`
@@ -344,7 +413,7 @@ type RangeQueryStateClose struct {
 func (m *RangeQueryStateClose) Reset()                    { *m = RangeQueryStateClose{} }
 func (m *RangeQueryStateClose) String() string            { return proto.CompactTextString(m) }
 func (*RangeQueryStateClose) ProtoMessage()               {}
-func (*RangeQueryStateClose) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }
+func (*RangeQueryStateClose) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 type RangeQueryStateKeyValue struct {
 	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
@@ -354,7 +423,7 @@ type RangeQueryStateKeyValue struct {
 func (m *RangeQueryStateKeyValue) Reset()                    { *m = RangeQueryStateKeyValue{} }
 func (m *RangeQueryStateKeyValue) String() string            { return proto.CompactTextString(m) }
 func (*RangeQueryStateKeyValue) ProtoMessage()               {}
-func (*RangeQueryStateKeyValue) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }
+func (*RangeQueryStateKeyValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 type RangeQueryStateResponse struct {
 	KeysAndValues []*RangeQueryStateKeyValue `protobuf:"bytes,1,rep,name=keysAndValues" json:"keysAndValues,omitempty"`
@@ -365,7 +434,7 @@ type RangeQueryStateResponse struct {
 func (m *RangeQueryStateResponse) Reset()                    { *m = RangeQueryStateResponse{} }
 func (m *RangeQueryStateResponse) String() string            { return proto.CompactTextString(m) }
 func (*RangeQueryStateResponse) ProtoMessage()               {}
-func (*RangeQueryStateResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }
+func (*RangeQueryStateResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 func (m *RangeQueryStateResponse) GetKeysAndValues() []*RangeQueryStateKeyValue {
 	if m != nil {
@@ -494,78 +563,79 @@ var _ChaincodeSupport_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 	},
-	Metadata: fileDescriptor2,
-}
-
-func init() { proto.RegisterFile("peer/chaincode.proto", fileDescriptor2) }
-
-var fileDescriptor2 = []byte{
-	// 1070 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x56, 0x4d, 0x6f, 0xdb, 0x46,
-	0x13, 0x8e, 0x3e, 0x6c, 0x49, 0xa3, 0x0f, 0x33, 0x1b, 0xc5, 0xd1, 0xab, 0xb7, 0x6d, 0x02, 0x22,
-	0x2d, 0xdc, 0x1e, 0xa8, 0x54, 0x4d, 0x8b, 0x02, 0x05, 0x82, 0x32, 0xe4, 0x46, 0x65, 0x2d, 0x53,
-	0xca, 0x8a, 0x36, 0x92, 0x5e, 0x0c, 0x9a, 0x5a, 0xd1, 0x44, 0x24, 0x92, 0x20, 0x97, 0x46, 0x74,
-	0xeb, 0xb9, 0xd7, 0xfe, 0x84, 0xfe, 0x87, 0x1e, 0xfa, 0xeb, 0xba, 0x4b, 0x8a, 0xb2, 0x64, 0xc9,
-	0x40, 0x80, 0x9e, 0xb4, 0x33, 0xf3, 0x3c, 0xb3, 0xb3, 0xf3, 0x25, 0x42, 0x3b, 0xa4, 0x34, 0xea,
-	0x39, 0xd7, 0xb6, 0xe7, 0x3b, 0xc1, 0x94, 0x2a, 0x61, 0x14, 0xb0, 0x00, 0x1d, 0xa6, 0x3f, 0x71,
-	0xf7, 0x7f, 0xdb, 0x56, 0x7a, 0x43, 0x7d, 0x96, 0x41, 0xba, 0x4f, 0xdd, 0x20, 0x70, 0xe7, 0xb4,
-	0x97, 0x4a, 0x57, 0xc9, 0xac, 0xc7, 0xbc, 0x05, 0x8d, 0x99, 0xbd, 0x08, 0x33, 0x80, 0xfc, 0x3d,
-	0xd4, 0xb5, 0x9c, 0x68, 0xe8, 0x08, 0x41, 0x39, 0xb4, 0xd9, 0x75, 0xa7, 0xf0, 0xac, 0x70, 0x52,
-	0x23, 0xe9, 0x59, 0xe8, 0x7c, 0x7b, 0x41, 0x3b, 0xc5, 0x4c, 0x27, 0xce, 0xf2, 0x73, 0x68, 0xdd,
-	0xd2, 0xfc, 0x30, 0x61, 0x02, 0x65, 0x47, 0x6e, 0xcc, 0x99, 0xa5, 0x93, 0x06, 0x49, 0xcf, 0xf2,
-	0xdf, 0x25, 0x68, 0xae, 0x61, 0x93, 0x90, 0x3a, 0x48, 0x81, 0x32, 0x5b, 0x86, 0x34, 0xf5, 0xdf,
-	0xea, 0x77, 0xb3, 0x20, 0x62, 0x65, 0x0b, 0xa4, 0x58, 0x1c, 0x41, 0x52, 0x1c, 0xe2, 0xe1, 0x39,
-	0xb7, 0xe1, 0xa5, 0x21, 0xd4, 0xfb, 0x8f, 0x76, 0x68, 0x86, 0x4e, 0x36, 0x71, 0xe8, 0x05, 0x54,
-	0x1c, 0x16, 0x44, 0x67, 0xb1, 0xdb, 0x29, 0xa5, 0x94, 0xe3, 0x5d, 0x8a, 0x88, 0x9a, 0xe4, 0x30,
-	0xd4, 0x81, 0x8a, 0x48, 0x4d, 0x90, 0xb0, 0x4e, 0x99, 0x33, 0x0e, 0x48, 0x2e, 0xa2, 0xe7, 0xd0,
-	0x8c, 0xa9, 0x93, 0x44, 0x54, 0x0b, 0x7c, 0x46, 0x3f, 0xb2, 0xce, 0x41, 0x9a, 0x87, 0x6d, 0x25,
-	0x1a, 0x43, 0xdb, 0x09, 0xfc, 0x99, 0x37, 0xe5, 0xb9, 0xf7, 0xec, 0xb9, 0xc7, 0x96, 0x43, 0x5e,
-	0x87, 0x79, 0xe7, 0x30, 0x7d, 0xe8, 0x67, 0xeb, 0xeb, 0xf7, 0x60, 0xc8, 0x5e, 0x26, 0xea, 0x42,
-	0x75, 0x41, 0x99, 0x3d, 0xb5, 0x99, 0xdd, 0xa9, 0x70, 0x2f, 0x0d, 0xb2, 0x96, 0xd1, 0x17, 0x00,
-	0x36, 0x63, 0x91, 0x77, 0x95, 0x30, 0x1a, 0x77, 0xaa, 0x3c, 0xe5, 0x35, 0xb2, 0xa1, 0x91, 0x5f,
-	0x41, 0x59, 0x24, 0x11, 0x35, 0xa1, 0x76, 0x6e, 0xea, 0xf8, 0x8d, 0x61, 0x62, 0x5d, 0x7a, 0x80,
-	0x00, 0x0e, 0x07, 0xa3, 0xa1, 0x6a, 0x0e, 0xa4, 0x02, 0xaa, 0x42, 0xd9, 0x1c, 0xe9, 0x58, 0x2a,
-	0xa2, 0x0a, 0x94, 0x34, 0x95, 0x48, 0x25, 0xa1, 0xfa, 0x55, 0xbd, 0x50, 0xa5, 0xb2, 0xfc, 0x4f,
-	0x11, 0x9e, 0xac, 0x33, 0xa5, 0xd3, 0x70, 0x1e, 0x2c, 0x17, 0x3c, 0xbc, 0xb4, 0x84, 0x3f, 0x41,
-	0xd3, 0xd9, 0x2c, 0x57, 0x5a, 0xcb, 0x7a, 0xff, 0xf1, 0xde, 0x5a, 0x92, 0x6d, 0x2c, 0xfa, 0x19,
-	0x9a, 0x74, 0x36, 0xa3, 0x0e, 0xf3, 0x6e, 0xa8, 0x6e, 0x33, 0xba, 0xaa, 0x68, 0x57, 0xc9, 0xfa,
-	0x54, 0xc9, 0xfb, 0x54, 0xb1, 0xf2, 0x3e, 0x25, 0xdb, 0x04, 0xf4, 0x8c, 0x77, 0x04, 0xf7, 0x36,
-	0xb6, 0x9d, 0x0f, 0xb6, 0x4b, 0xd3, 0xf2, 0x36, 0xc8, 0xa6, 0x0a, 0x99, 0x50, 0xa1, 0x1f, 0xa9,
-	0x83, 0xfd, 0x9b, 0xb4, 0x94, 0xad, 0xfe, 0xcb, 0x9d, 0xd0, 0xb6, 0x9f, 0xa4, 0x60, 0x0e, 0x4f,
-	0x98, 0x17, 0xf8, 0x9c, 0xe3, 0x45, 0x81, 0x2f, 0x0c, 0x24, 0x77, 0x22, 0x2b, 0xd0, 0xde, 0x07,
-	0x10, 0xd9, 0xd4, 0x47, 0xda, 0x29, 0x26, 0x59, 0x66, 0x27, 0xef, 0x27, 0x16, 0x3e, 0x93, 0x0a,
-	0xf2, 0xef, 0x85, 0x8d, 0xe4, 0x19, 0xfe, 0x4d, 0xe0, 0xd8, 0x82, 0xfa, 0xdf, 0x93, 0x77, 0x02,
-	0x47, 0xde, 0x74, 0x40, 0x7d, 0x1a, 0xa5, 0x0e, 0xd5, 0xb9, 0xbb, 0x9a, 0xc9, 0xbb, 0x6a, 0xf9,
-	0xcf, 0x32, 0x48, 0x6b, 0x57, 0x67, 0x34, 0x8e, 0x45, 0x5e, 0xbe, 0xdd, 0x9a, 0xbd, 0xcf, 0x77,
-	0xae, 0x5c, 0xe1, 0x36, 0xc7, 0xef, 0x47, 0xa8, 0xad, 0x17, 0xc6, 0x27, 0x94, 0xea, 0x16, 0x2c,
-	0xe6, 0x29, 0xb4, 0x97, 0xf3, 0xc0, 0x9e, 0xae, 0x4a, 0x94, 0x8b, 0x62, 0x51, 0xb0, 0x8f, 0xde,
-	0x34, 0xad, 0x0d, 0x5f, 0x27, 0xe2, 0x8c, 0x5e, 0x41, 0x6b, 0xfd, 0x54, 0x2c, 0xd6, 0x57, 0x3a,
-	0x37, 0xfb, 0xc6, 0x36, 0xb5, 0x92, 0x3b, 0x68, 0xf9, 0xaf, 0xe2, 0xfe, 0x86, 0x6f, 0x40, 0x95,
-	0xe0, 0x81, 0xc1, 0x0b, 0x43, 0x78, 0xcb, 0xb7, 0x00, 0x72, 0x89, 0x5b, 0x8b, 0xa2, 0xdf, 0x0d,
-	0xd3, 0xb0, 0x78, 0xe7, 0xd7, 0xe0, 0x80, 0x60, 0x55, 0x7f, 0x2f, 0x95, 0xd1, 0x11, 0xd4, 0x2d,
-	0xa2, 0x9a, 0x13, 0x55, 0xb3, 0x8c, 0x91, 0x29, 0x1d, 0x08, 0x97, 0xda, 0xe8, 0x6c, 0x3c, 0xc4,
-	0x16, 0x27, 0x1d, 0x0a, 0x28, 0x26, 0x64, 0x44, 0xa4, 0x8a, 0xb0, 0x0c, 0xb0, 0x75, 0x39, 0xb1,
-	0x54, 0x0b, 0x4b, 0x55, 0x21, 0x8e, 0xcf, 0x73, 0xb1, 0x26, 0x44, 0x1d, 0x0f, 0x57, 0x22, 0xa0,
-	0x36, 0x48, 0x86, 0x79, 0x31, 0x3a, 0xc5, 0x97, 0xda, 0x2f, 0xaa, 0x61, 0x6a, 0x62, 0xf6, 0xea,
-	0x59, 0x80, 0x93, 0xf1, 0xc8, 0x9c, 0x60, 0xa9, 0x89, 0x1e, 0xc3, 0x43, 0x7e, 0xf5, 0x00, 0x5f,
-	0xbe, 0x3d, 0xc7, 0xe4, 0xfd, 0x8a, 0xda, 0xe2, 0x9b, 0xe0, 0x78, 0x47, 0x7d, 0x69, 0xe2, 0x77,
-	0x96, 0x74, 0x84, 0xfe, 0x0f, 0x4f, 0x76, 0x6d, 0xda, 0x70, 0xc4, 0xfd, 0x49, 0x22, 0x84, 0x53,
-	0x8c, 0xc7, 0xea, 0xd0, 0xb8, 0xc0, 0xd2, 0x43, 0xf9, 0x07, 0x68, 0x8c, 0x13, 0x36, 0x61, 0x7c,
-	0x8c, 0x0c, 0x7f, 0x16, 0x20, 0x09, 0x4a, 0x1f, 0xe8, 0x72, 0xb5, 0xeb, 0xc5, 0x91, 0x07, 0x79,
-	0x70, 0x63, 0xcf, 0x93, 0x6c, 0x2c, 0x1b, 0x24, 0x13, 0x64, 0x0c, 0x47, 0xc4, 0xf6, 0x5d, 0xfa,
-	0x36, 0xa1, 0xd1, 0x32, 0xa5, 0x8b, 0xe5, 0xc4, 0xeb, 0x1c, 0xb1, 0xd3, 0x35, 0x7f, 0x2d, 0xa3,
-	0x63, 0x38, 0xa4, 0xfe, 0x54, 0x58, 0xb2, 0xee, 0x5c, 0x49, 0xf2, 0x97, 0xf0, 0xe8, 0x8e, 0x1b,
-	0x53, 0x6c, 0xce, 0x16, 0x14, 0xf9, 0x66, 0xcf, 0x9c, 0xf0, 0x93, 0xfc, 0x15, 0xb4, 0xef, 0xc0,
-	0xb4, 0x79, 0x10, 0xd3, 0x1d, 0x9c, 0xca, 0x5f, 0xbe, 0x8d, 0xe3, 0x97, 0x5c, 0x88, 0x80, 0x3f,
-	0xf9, 0x61, 0x7f, 0x14, 0x76, 0x7c, 0x10, 0x1a, 0x87, 0x81, 0xcf, 0xaf, 0xc3, 0xd0, 0xe4, 0xc4,
-	0x58, 0xf5, 0xa7, 0xa9, 0xcf, 0xec, 0x8f, 0xad, 0xde, 0x7f, 0x9a, 0x77, 0xe4, 0x3d, 0x77, 0x93,
-	0x6d, 0x96, 0x98, 0x83, 0x6b, 0x3b, 0x3e, 0x0b, 0xa2, 0xec, 0xea, 0x2a, 0xc9, 0xc5, 0xd5, 0x7b,
-	0x4a, 0xf9, 0x7b, 0xbe, 0x79, 0x09, 0xed, 0x7d, 0xff, 0x0e, 0x62, 0xb5, 0x8c, 0xcf, 0x5f, 0x0f,
-	0x0d, 0x8d, 0xf7, 0xb3, 0x04, 0x0d, 0x6d, 0x64, 0xbe, 0x31, 0x74, 0x6c, 0x5a, 0x86, 0x3a, 0x94,
-	0x0a, 0xfd, 0x77, 0x1b, 0x83, 0x3e, 0x49, 0xc2, 0x30, 0x88, 0x18, 0xd2, 0x79, 0x53, 0x51, 0xd7,
-	0x8b, 0x19, 0x8d, 0x50, 0xe7, 0xbe, 0x31, 0xef, 0xde, 0x6b, 0x91, 0x1f, 0x9c, 0x14, 0x5e, 0x14,
-	0x5e, 0x6b, 0x70, 0x1c, 0x44, 0xae, 0x72, 0xcd, 0xc7, 0x2a, 0x9a, 0xd3, 0xa9, 0x4b, 0xa3, 0x15,
-	0xe1, 0xb7, 0xaf, 0x5d, 0x8f, 0x5d, 0x27, 0x57, 0x8a, 0x13, 0x2c, 0x7a, 0x1b, 0xe6, 0xde, 0xcc,
-	0xbe, 0x8a, 0x3c, 0x27, 0xfb, 0xd6, 0x88, 0x7b, 0xe2, 0xa3, 0xe4, 0x2a, 0xfb, 0x44, 0xf9, 0xee,
-	0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3c, 0xd3, 0x09, 0x7d, 0xc1, 0x08, 0x00, 0x00,
+	Metadata: fileDescriptor0,
+}
+
+func init() { proto.RegisterFile("peer/chaincode.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 1073 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x56, 0x5f, 0x6f, 0xda, 0x56,
+	0x14, 0xaf, 0x81, 0x24, 0x70, 0xf8, 0x93, 0xdb, 0x5b, 0x9a, 0x32, 0xf6, 0xa7, 0x91, 0xd5, 0x4d,
+	0x6c, 0x0f, 0xa4, 0xcb, 0xda, 0x69, 0xd2, 0xa4, 0x6a, 0xae, 0x7d, 0xcb, 0xbc, 0x10, 0x43, 0x2f,
+	0x4e, 0xd4, 0xee, 0x25, 0x72, 0xcc, 0x81, 0x58, 0x05, 0xdb, 0xb2, 0x2f, 0x28, 0xbc, 0xed, 0x79,
+	0xaf, 0xfb, 0x08, 0xfb, 0x0e, 0x7b, 0xd8, 0xa7, 0x9b, 0xae, 0x8d, 0x29, 0x04, 0x22, 0x55, 0xda,
+	0x13, 0xf7, 0x9c, 0xf3, 0xfb, 0x9d, 0x7b, 0xee, 0xf9, 0x87, 0xa1, 0x1e, 0x22, 0x46, 0x27, 0xee,
+	0x8d, 0xe3, 0xf9, 0x6e, 0x30, 0xc4, 0x76, 0x18, 0x05, 0x22, 0xa0, 0xfb, 0xc9, 0x4f, 0xdc, 0xfc,
+	0x6c, 0xd3, 0x8a, 0x73, 0xf4, 0x45, 0x0a, 0x69, 0x3e, 0x1d, 0x07, 0xc1, 0x78, 0x82, 0x27, 0x89,
+	0x74, 0x3d, 0x1b, 0x9d, 0x08, 0x6f, 0x8a, 0xb1, 0x70, 0xa6, 0x61, 0x0a, 0x50, 0x5f, 0x42, 0x59,
+	0xcf, 0x88, 0xa6, 0x41, 0x29, 0x14, 0x42, 0x47, 0xdc, 0x34, 0x94, 0x63, 0xa5, 0x55, 0xe2, 0xc9,
+	0x59, 0xea, 0x7c, 0x67, 0x8a, 0x8d, 0x5c, 0xaa, 0x93, 0x67, 0xf5, 0x19, 0xd4, 0x3e, 0xd2, 0xfc,
+	0x70, 0x26, 0x24, 0xca, 0x89, 0xc6, 0x71, 0x43, 0x39, 0xce, 0xb7, 0x2a, 0x3c, 0x39, 0xab, 0xff,
+	0xe4, 0xa1, 0xba, 0x82, 0x0d, 0x42, 0x74, 0x69, 0x1b, 0x0a, 0x62, 0x11, 0x62, 0xe2, 0xbf, 0x76,
+	0xda, 0x4c, 0x83, 0x88, 0xdb, 0x1b, 0xa0, 0xb6, 0xbd, 0x08, 0x91, 0x27, 0x38, 0xfa, 0x12, 0xca,
+	0xee, 0xc7, 0xf0, 0x92, 0x10, 0xca, 0xa7, 0x8f, 0xb6, 0x68, 0xa6, 0xc1, 0xd7, 0x71, 0xf4, 0x39,
+	0x1c, 0xb8, 0x22, 0x88, 0xce, 0xe3, 0x71, 0x23, 0x9f, 0x50, 0x8e, 0xb6, 0x29, 0x32, 0x6a, 0x9e,
+	0xc1, 0x68, 0x03, 0x0e, 0x64, 0x6a, 0x82, 0x99, 0x68, 0x14, 0x8e, 0x95, 0xd6, 0x1e, 0xcf, 0x44,
+	0xfa, 0x0c, 0xaa, 0x31, 0xba, 0xb3, 0x08, 0xf5, 0xc0, 0x17, 0x78, 0x2b, 0x1a, 0x7b, 0x49, 0x1e,
+	0x36, 0x95, 0xb4, 0x0f, 0x75, 0x37, 0xf0, 0x47, 0xde, 0x10, 0x7d, 0xe1, 0x39, 0x13, 0x4f, 0x2c,
+	0xba, 0x38, 0xc7, 0x49, 0x63, 0x3f, 0x79, 0xe8, 0x17, 0xab, 0xeb, 0x77, 0x60, 0xf8, 0x4e, 0x26,
+	0x6d, 0x42, 0x71, 0x8a, 0xc2, 0x19, 0x3a, 0xc2, 0x69, 0x1c, 0x1c, 0x2b, 0xad, 0x0a, 0x5f, 0xc9,
+	0xf4, 0x2b, 0x00, 0x47, 0x88, 0xc8, 0xbb, 0x9e, 0x09, 0x8c, 0x1b, 0xc5, 0xe3, 0x7c, 0xab, 0xc4,
+	0xd7, 0x34, 0xea, 0x2b, 0x28, 0xc8, 0x24, 0xd2, 0x2a, 0x94, 0x2e, 0x2c, 0x83, 0xbd, 0x31, 0x2d,
+	0x66, 0x90, 0x07, 0x14, 0x60, 0xbf, 0xd3, 0xeb, 0x6a, 0x56, 0x87, 0x28, 0xb4, 0x08, 0x05, 0xab,
+	0x67, 0x30, 0x92, 0xa3, 0x07, 0x90, 0xd7, 0x35, 0x4e, 0xf2, 0x52, 0xf5, 0x9b, 0x76, 0xa9, 0x91,
+	0x82, 0xfa, 0x6f, 0x0e, 0x9e, 0xac, 0x32, 0x65, 0x60, 0x38, 0x09, 0x16, 0x53, 0xf4, 0x45, 0x52,
+	0xc2, 0x9f, 0xa1, 0xea, 0xae, 0x97, 0x2b, 0xa9, 0x65, 0xf9, 0xf4, 0xf1, 0xce, 0x5a, 0xf2, 0x4d,
+	0x2c, 0xfd, 0x05, 0xaa, 0x38, 0x1a, 0xa1, 0x2b, 0xbc, 0x39, 0x1a, 0x8e, 0xc0, 0x65, 0x45, 0x9b,
+	0xed, 0xb4, 0x4f, 0xdb, 0x59, 0x9f, 0xb6, 0xed, 0xac, 0x4f, 0xf9, 0x26, 0x81, 0x1e, 0x43, 0x59,
+	0x7a, 0xeb, 0x3b, 0xee, 0x07, 0x67, 0x8c, 0x49, 0x79, 0x2b, 0x7c, 0x5d, 0x45, 0x2d, 0x38, 0xc0,
+	0x5b, 0x74, 0x99, 0x3f, 0x4f, 0x4a, 0x59, 0x3b, 0x7d, 0xb1, 0x15, 0xda, 0xe6, 0x93, 0xda, 0xec,
+	0x16, 0xdd, 0x99, 0xf0, 0x02, 0x9f, 0xf9, 0x73, 0x2f, 0x0a, 0x7c, 0x69, 0xe0, 0x99, 0x13, 0xb5,
+	0x0d, 0xf5, 0x5d, 0x00, 0x99, 0x4d, 0xa3, 0xa7, 0x9f, 0x31, 0x9e, 0x66, 0x76, 0xf0, 0x7e, 0x60,
+	0xb3, 0x73, 0xa2, 0xa8, 0x7f, 0x28, 0x6b, 0xc9, 0x33, 0xfd, 0x79, 0xe0, 0x3a, 0x92, 0xfa, 0xff,
+	0x93, 0xd7, 0x82, 0x43, 0x6f, 0xd8, 0x41, 0x1f, 0xa3, 0xc4, 0xa1, 0x36, 0x19, 0x2f, 0x67, 0xf2,
+	0xae, 0x5a, 0xfd, 0xab, 0x00, 0x64, 0xe5, 0xea, 0x1c, 0xe3, 0x58, 0xe6, 0xe5, 0xfb, 0x8d, 0xd9,
+	0xfb, 0x72, 0xeb, 0xca, 0x25, 0x6e, 0x7d, 0xfc, 0x7e, 0x82, 0xd2, 0x6a, 0x61, 0x7c, 0x42, 0xa9,
+	0x3e, 0x82, 0xe5, 0x3c, 0x85, 0xce, 0x62, 0x12, 0x38, 0xc3, 0x65, 0x89, 0x32, 0x51, 0x2e, 0x0a,
+	0x71, 0xeb, 0x0d, 0x93, 0xda, 0x94, 0x78, 0x72, 0xa6, 0xaf, 0xa0, 0xb6, 0x7a, 0x2a, 0x93, 0xeb,
+	0x2b, 0x99, 0x9b, 0x5d, 0x63, 0x9b, 0x58, 0xf9, 0x1d, 0xb4, 0xfa, 0x77, 0x6e, 0x77, 0xc3, 0x57,
+	0xa0, 0xc8, 0x59, 0xc7, 0x1c, 0xd8, 0x8c, 0x13, 0x85, 0xd6, 0x00, 0x32, 0x89, 0x19, 0x24, 0x27,
+	0xfb, 0xdd, 0xb4, 0x4c, 0x9b, 0xe4, 0x69, 0x09, 0xf6, 0x38, 0xd3, 0x8c, 0xf7, 0xa4, 0x40, 0x0f,
+	0xa1, 0x6c, 0x73, 0xcd, 0x1a, 0x68, 0xba, 0x6d, 0xf6, 0x2c, 0xb2, 0x27, 0x5d, 0xea, 0xbd, 0xf3,
+	0x7e, 0x97, 0xd9, 0xcc, 0x20, 0xfb, 0x12, 0xca, 0x38, 0xef, 0x71, 0x72, 0x20, 0x2d, 0x1d, 0x66,
+	0x5f, 0x0d, 0x6c, 0xcd, 0x66, 0xa4, 0x28, 0xc5, 0xfe, 0x45, 0x26, 0x96, 0xa4, 0x68, 0xb0, 0xee,
+	0x52, 0x04, 0x5a, 0x07, 0x62, 0x5a, 0x97, 0xbd, 0x33, 0x76, 0xa5, 0xff, 0xaa, 0x99, 0x96, 0x2e,
+	0x67, 0xaf, 0x9c, 0x06, 0x38, 0xe8, 0xf7, 0xac, 0x01, 0x23, 0x55, 0xfa, 0x18, 0x1e, 0x72, 0xcd,
+	0xea, 0xb0, 0xab, 0xb7, 0x17, 0x8c, 0xbf, 0x5f, 0x52, 0x6b, 0xb4, 0x09, 0x47, 0x5b, 0xea, 0x2b,
+	0x8b, 0xbd, 0xb3, 0xc9, 0x21, 0xfd, 0x1c, 0x9e, 0x6c, 0xdb, 0xf4, 0x6e, 0x6f, 0xc0, 0x08, 0x91,
+	0x21, 0x9c, 0x31, 0xd6, 0xd7, 0xba, 0xe6, 0x25, 0x23, 0x0f, 0xd5, 0x1f, 0xa1, 0xd2, 0x9f, 0x89,
+	0x81, 0x70, 0x04, 0x9a, 0xfe, 0x28, 0xa0, 0x04, 0xf2, 0x1f, 0x70, 0xb1, 0xdc, 0xf5, 0xf2, 0x48,
+	0xeb, 0xb0, 0x37, 0x77, 0x26, 0xb3, 0x74, 0x2c, 0x2b, 0x3c, 0x15, 0x54, 0x06, 0x87, 0xdc, 0xf1,
+	0xc7, 0xf8, 0x76, 0x86, 0xd1, 0x22, 0xa1, 0xcb, 0xe5, 0x14, 0x0b, 0x27, 0x12, 0x67, 0x2b, 0xfe,
+	0x4a, 0xa6, 0x47, 0xb0, 0x8f, 0xfe, 0x50, 0x5a, 0xd2, 0xee, 0x5c, 0x4a, 0xea, 0xd7, 0xf0, 0xe8,
+	0x8e, 0x1b, 0x4b, 0x6e, 0xce, 0x1a, 0xe4, 0x4c, 0x63, 0xe9, 0x24, 0x67, 0x1a, 0xea, 0x37, 0x50,
+	0xbf, 0x03, 0xd3, 0x27, 0x41, 0x8c, 0x5b, 0x38, 0x0d, 0x9e, 0xdc, 0xc1, 0x9d, 0xe1, 0xe2, 0x52,
+	0x06, 0xfc, 0xc9, 0x0f, 0xfb, 0x53, 0xd9, 0xf2, 0xc1, 0x31, 0x0e, 0x03, 0x3f, 0x46, 0xca, 0xa0,
+	0xfa, 0x01, 0x17, 0xb1, 0xe6, 0x0f, 0x13, 0x9f, 0xe9, 0x1f, 0x5b, 0xf9, 0xf4, 0x69, 0xd6, 0x91,
+	0xf7, 0xdc, 0xcd, 0x37, 0x59, 0x72, 0x0e, 0x6e, 0x9c, 0xf8, 0x3c, 0x88, 0xd2, 0xab, 0x8b, 0x3c,
+	0x13, 0x97, 0xef, 0xc9, 0x67, 0xef, 0xf9, 0xee, 0x05, 0xd4, 0x77, 0xfd, 0x3b, 0xc8, 0xd5, 0xd2,
+	0xbf, 0x78, 0xdd, 0x35, 0x75, 0xf2, 0x80, 0x12, 0xa8, 0xe8, 0x3d, 0xeb, 0x8d, 0x69, 0x30, 0xcb,
+	0x36, 0xb5, 0x2e, 0x51, 0x4e, 0xdf, 0xad, 0x0d, 0xfa, 0x60, 0x16, 0x86, 0x41, 0x24, 0xa8, 0x01,
+	0x45, 0x8e, 0x63, 0x2f, 0x16, 0x18, 0xd1, 0xc6, 0x7d, 0x63, 0xde, 0xbc, 0xd7, 0xa2, 0x3e, 0x68,
+	0x29, 0xcf, 0x95, 0xd7, 0x3a, 0x1c, 0x05, 0xd1, 0xb8, 0x7d, 0xb3, 0x08, 0x31, 0x9a, 0xe0, 0x70,
+	0x8c, 0xd1, 0x92, 0xf0, 0xfb, 0xb7, 0x63, 0x4f, 0xdc, 0xcc, 0xae, 0xdb, 0x6e, 0x30, 0x3d, 0x59,
+	0x33, 0x9f, 0x8c, 0x9c, 0xeb, 0xc8, 0x73, 0xd3, 0x6f, 0x8d, 0xf8, 0x44, 0x7e, 0x94, 0x5c, 0xa7,
+	0x9f, 0x28, 0x3f, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0x3c, 0xd3, 0x09, 0x7d, 0xc1, 0x08, 0x00,
+	0x00,
 }
diff --git a/protos/peer/chaincode_proposal.pb.go b/protos/peer/chaincode_proposal.pb.go
index 1b17da12e71..85dbfa03910 100644
--- a/protos/peer/chaincode_proposal.pb.go
+++ b/protos/peer/chaincode_proposal.pb.go
@@ -89,22 +89,22 @@ func init() {
 func init() { proto.RegisterFile("peer/chaincode_proposal.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 263 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x50, 0xd1, 0x4a, 0xc3, 0x30,
-	0x14, 0x65, 0x82, 0x13, 0xef, 0x06, 0x62, 0x1c, 0x52, 0x44, 0x41, 0xfa, 0xa4, 0x28, 0x2d, 0x28,
-	0x7e, 0x80, 0x56, 0xc1, 0xbd, 0xc8, 0x28, 0xe2, 0x83, 0x2f, 0x92, 0xa6, 0xd7, 0x35, 0x10, 0x93,
-	0x90, 0xa4, 0x62, 0x9f, 0xfc, 0x75, 0xb3, 0x25, 0xdb, 0x2a, 0x7b, 0x6a, 0xef, 0x3d, 0x27, 0xe7,
-	0x9c, 0x7b, 0xe0, 0x4c, 0x23, 0x9a, 0x9c, 0x35, 0x94, 0x4b, 0xa6, 0x6a, 0xfc, 0xd0, 0x46, 0x69,
-	0x65, 0xa9, 0xc8, 0xfc, 0x8f, 0x53, 0x64, 0xb8, 0xfc, 0xd8, 0x93, 0xc9, 0x7f, 0x5a, 0x40, 0xd3,
-	0x5f, 0x48, 0x8a, 0xd5, 0xea, 0x19, 0x69, 0x8d, 0xe6, 0xe9, 0xc7, 0xa1, 0xb4, 0x5c, 0x49, 0x72,
-	0x0d, 0x87, 0x9a, 0x76, 0x42, 0xd1, 0xfa, 0x8d, 0x5b, 0x5e, 0x71, 0xc1, 0x5d, 0x97, 0x0c, 0xce,
-	0x07, 0x17, 0xe3, 0x72, 0x1b, 0x20, 0x77, 0x30, 0x5a, 0x8b, 0x4f, 0x1f, 0x93, 0x1d, 0xcf, 0x1b,
-	0xdd, 0x1c, 0x05, 0x1b, 0x9b, 0x15, 0x1b, 0xa8, 0xec, 0xf3, 0xd2, 0x97, 0x5e, 0x80, 0x59, 0x4c,
-	0x3e, 0x0b, 0xe2, 0x64, 0x02, 0xbb, 0x53, 0xa9, 0x5b, 0x17, 0x4d, 0xc3, 0x40, 0x4e, 0x61, 0xff,
-	0xd5, 0x50, 0x1f, 0x11, 0xa5, 0x5b, 0xda, 0x8c, 0xcb, 0xcd, 0x22, 0x2d, 0xe0, 0x60, 0xad, 0x77,
-	0xcf, 0xdc, 0xe2, 0x8e, 0x04, 0xf6, 0x0c, 0xda, 0x56, 0x38, 0x1b, 0x85, 0x56, 0x23, 0x39, 0x86,
-	0x21, 0x7e, 0xfb, 0x57, 0x36, 0xea, 0xc4, 0xe9, 0xe1, 0xea, 0xfd, 0x72, 0xce, 0x5d, 0xd3, 0x56,
-	0x19, 0x53, 0x5f, 0x79, 0xd3, 0x69, 0x34, 0x02, 0xeb, 0xb9, 0xef, 0xef, 0x93, 0x56, 0x86, 0xb3,
-	0x3c, 0x5c, 0x95, 0x2f, 0x2a, 0xad, 0x42, 0xc1, 0xb7, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x97,
-	0xb9, 0x42, 0xce, 0x88, 0x01, 0x00, 0x00,
+	// 264 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x90, 0xd1, 0x4b, 0xc3, 0x30,
+	0x10, 0xc6, 0xa9, 0xe0, 0xc4, 0x6c, 0x20, 0xc6, 0x21, 0x45, 0x14, 0x46, 0x9f, 0x26, 0x4a, 0x03,
+	0x8a, 0x7f, 0x80, 0x56, 0xc1, 0xbd, 0xc8, 0x28, 0xe2, 0x83, 0x2f, 0x92, 0xa6, 0xe7, 0x1a, 0x88,
+	0x49, 0x48, 0xae, 0x62, 0x9f, 0xfc, 0xd7, 0x65, 0x4b, 0xb6, 0x55, 0xf6, 0x74, 0x7c, 0xf7, 0x1d,
+	0xbf, 0xef, 0xee, 0xc8, 0x85, 0x05, 0x70, 0x4c, 0x34, 0x5c, 0x6a, 0x61, 0x6a, 0xf8, 0xb0, 0xce,
+	0x58, 0xe3, 0xb9, 0xca, 0xad, 0x33, 0x68, 0xe8, 0x60, 0x55, 0xfc, 0xd9, 0xf8, 0xff, 0x58, 0x70,
+	0xb3, 0x5f, 0x92, 0x16, 0xeb, 0xd6, 0x33, 0xf0, 0x1a, 0xdc, 0xd3, 0x0f, 0x82, 0xf6, 0xd2, 0x68,
+	0x7a, 0x4d, 0x8e, 0x2d, 0xef, 0x94, 0xe1, 0xf5, 0x9b, 0xf4, 0xb2, 0x92, 0x4a, 0x62, 0x97, 0x26,
+	0x93, 0x64, 0x3a, 0x2a, 0x77, 0x0d, 0x7a, 0x47, 0x86, 0x1b, 0xf8, 0xec, 0x31, 0xdd, 0x9b, 0x24,
+	0xd3, 0xe1, 0xcd, 0x49, 0x88, 0xf1, 0x79, 0xb1, 0xb5, 0xca, 0xfe, 0x5c, 0xf6, 0xd2, 0x5b, 0x60,
+	0x1e, 0x37, 0x9f, 0x07, 0x38, 0x1d, 0x93, 0xfd, 0x99, 0xb6, 0x2d, 0xc6, 0xd0, 0x20, 0xe8, 0x39,
+	0x39, 0x7c, 0x75, 0x5c, 0x7b, 0x09, 0x1a, 0x57, 0x31, 0xa3, 0x72, 0xdb, 0xc8, 0x0a, 0x72, 0xb4,
+	0xe1, 0xdd, 0x0b, 0x5c, 0xde, 0x91, 0x92, 0x03, 0x07, 0xbe, 0x55, 0xe8, 0x23, 0x68, 0x2d, 0xe9,
+	0x29, 0x19, 0xc0, 0x37, 0x68, 0xf4, 0x91, 0x13, 0xd5, 0xc3, 0xd5, 0xfb, 0xe5, 0x42, 0x62, 0xd3,
+	0x56, 0xb9, 0x30, 0x5f, 0xac, 0xe9, 0x2c, 0x38, 0x05, 0xf5, 0x02, 0x1c, 0xfb, 0xe4, 0x95, 0x93,
+	0x82, 0x85, 0xab, 0xd8, 0xf2, 0xa5, 0x55, 0x78, 0xf0, 0xed, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x97, 0xb9, 0x42, 0xce, 0x88, 0x01, 0x00, 0x00,
 }
diff --git a/protos/peer/chaincode_transaction.pb.go b/protos/peer/chaincode_transaction.pb.go
index 95d3c4b69af..d464d520c81 100644
--- a/protos/peer/chaincode_transaction.pb.go
+++ b/protos/peer/chaincode_transaction.pb.go
@@ -34,7 +34,7 @@ type ChaincodeActionPayload struct {
 func (m *ChaincodeActionPayload) Reset()                    { *m = ChaincodeActionPayload{} }
 func (m *ChaincodeActionPayload) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeActionPayload) ProtoMessage()               {}
-func (*ChaincodeActionPayload) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
+func (*ChaincodeActionPayload) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
 
 func (m *ChaincodeActionPayload) GetAction() *ChaincodeEndorsedAction {
 	if m != nil {
@@ -58,7 +58,7 @@ type ChaincodeEndorsedAction struct {
 func (m *ChaincodeEndorsedAction) Reset()                    { *m = ChaincodeEndorsedAction{} }
 func (m *ChaincodeEndorsedAction) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeEndorsedAction) ProtoMessage()               {}
-func (*ChaincodeEndorsedAction) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
+func (*ChaincodeEndorsedAction) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
 
 func (m *ChaincodeEndorsedAction) GetEndorsements() []*Endorsement {
 	if m != nil {
@@ -72,24 +72,24 @@ func init() {
 	proto.RegisterType((*ChaincodeEndorsedAction)(nil), "protos.ChaincodeEndorsedAction")
 }
 
-func init() { proto.RegisterFile("peer/chaincode_transaction.proto", fileDescriptor3) }
+func init() { proto.RegisterFile("peer/chaincode_transaction.proto", fileDescriptor2) }
 
-var fileDescriptor3 = []byte{
-	// 246 bytes of a gzipped FileDescriptorProto
+var fileDescriptor2 = []byte{
+	// 248 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x90, 0x31, 0x4f, 0xc3, 0x30,
-	0x14, 0x84, 0x15, 0x90, 0x3a, 0x98, 0x4e, 0x41, 0xa2, 0x11, 0x0b, 0x55, 0x59, 0x40, 0x48, 0x89,
-	0x04, 0x03, 0x88, 0x0d, 0x50, 0xf7, 0xca, 0x23, 0x4b, 0xe4, 0xd8, 0x8f, 0xc6, 0x52, 0xea, 0x67,
-	0xf9, 0x99, 0xa1, 0xff, 0x01, 0xfe, 0x33, 0x26, 0x76, 0x52, 0x65, 0xc8, 0x14, 0x29, 0x77, 0xbe,
-	0xfb, 0xde, 0xb1, 0xb5, 0x05, 0x70, 0x95, 0x6c, 0x85, 0x36, 0x12, 0x15, 0xd4, 0xde, 0x09, 0x43,
-	0x42, 0x7a, 0x8d, 0xa6, 0xb4, 0x0e, 0x3d, 0xe6, 0x8b, 0xfe, 0x43, 0xd7, 0xb7, 0xbd, 0xf3, 0x4b,
-	0x34, 0x4e, 0xcb, 0x3a, 0xfc, 0xb3, 0x48, 0xa2, 0xab, 0x1d, 0x90, 0x45, 0x43, 0x10, 0xcd, 0x9b,
-	0xdf, 0x8c, 0x5d, 0x7d, 0x0c, 0x61, 0x6f, 0x7d, 0xcc, 0x4e, 0x1c, 0x3b, 0x14, 0x2a, 0x7f, 0x65,
-	0xc5, 0x58, 0xb3, 0x4b, 0xcf, 0x93, 0x56, 0x64, 0xeb, 0xec, 0x6e, 0xc9, 0x67, 0xf5, 0xfc, 0x99,
-	0x2d, 0x22, 0x53, 0x71, 0x16, 0x9c, 0x17, 0x8f, 0x37, 0xb1, 0x8e, 0xca, 0xb1, 0x6b, 0x6b, 0x14,
-	0x3a, 0x02, 0x15, 0x3b, 0x79, 0xb2, 0x6f, 0x7e, 0x32, 0xb6, 0x9a, 0xf1, 0xe4, 0x2f, 0x6c, 0x35,
-	0x9c, 0xc1, 0xd3, 0x15, 0x53, 0x9e, 0x39, 0x39, 0xe0, 0x2c, 0x21, 0x66, 0x1d, 0xc0, 0x78, 0x0a,
-	0x50, 0xe7, 0x01, 0xea, 0x72, 0x80, 0xda, 0x9e, 0x34, 0x3e, 0x31, 0xbe, 0x3f, 0x7c, 0xde, 0xef,
-	0xb5, 0x6f, 0xbf, 0x9b, 0x52, 0xe2, 0xa1, 0x6a, 0x8f, 0x16, 0x5c, 0x07, 0x6a, 0x3f, 0xee, 0x5a,
-	0xc5, 0x84, 0xea, 0x7f, 0xea, 0x26, 0x0e, 0xff, 0xf4, 0x17, 0x00, 0x00, 0xff, 0xff, 0xcd, 0xa1,
-	0x56, 0xa7, 0xa3, 0x01, 0x00, 0x00,
+	0x14, 0x84, 0xe5, 0x22, 0x75, 0x70, 0x3b, 0x19, 0x89, 0x46, 0x2c, 0x44, 0x65, 0x09, 0x42, 0x4a,
+	0xa4, 0x32, 0x14, 0xb1, 0x01, 0xea, 0x5e, 0x65, 0x64, 0x89, 0x1c, 0xfb, 0xd1, 0x44, 0x4a, 0xfd,
+	0x2c, 0x3f, 0x33, 0xf4, 0x3f, 0xc0, 0x7f, 0x46, 0xc4, 0x4e, 0x50, 0x86, 0x4c, 0x1e, 0xee, 0xf3,
+	0xdd, 0xbd, 0xe3, 0xa9, 0x05, 0x70, 0x85, 0x6a, 0x64, 0x6b, 0x14, 0x6a, 0xa8, 0xbc, 0x93, 0x86,
+	0xa4, 0xf2, 0x2d, 0x9a, 0xdc, 0x3a, 0xf4, 0x28, 0x96, 0xfd, 0x43, 0xb7, 0xf7, 0x3d, 0xf9, 0x29,
+	0x6b, 0xd7, 0xaa, 0xca, 0x3a, 0xb4, 0x48, 0xb2, 0xab, 0x1c, 0x90, 0x45, 0x43, 0x10, 0xe0, 0xed,
+	0x0f, 0xe3, 0x37, 0xef, 0x83, 0xd9, 0x6b, 0x6f, 0x73, 0x94, 0x97, 0x0e, 0xa5, 0x16, 0x2f, 0x3c,
+	0x19, 0x63, 0x8e, 0xf1, 0x7b, 0xd4, 0x12, 0x96, 0xb2, 0x6c, 0x5d, 0xce, 0xea, 0x62, 0xcf, 0x97,
+	0xa1, 0x53, 0xb2, 0x48, 0x59, 0xb6, 0xda, 0xdd, 0x85, 0x38, 0xca, 0xc7, 0xac, 0x83, 0xd1, 0xe8,
+	0x08, 0x74, 0xc8, 0x2c, 0x23, 0xbe, 0xfd, 0x66, 0x7c, 0x33, 0xc3, 0x88, 0x67, 0xbe, 0x19, 0xce,
+	0x28, 0xe3, 0x15, 0xd3, 0x3e, 0x73, 0xb2, 0xd8, 0xf3, 0x35, 0x04, 0xaf, 0x33, 0x18, 0x4f, 0xc9,
+	0x22, 0xbd, 0xca, 0x56, 0xbb, 0xeb, 0xa1, 0xd4, 0xe1, 0x5f, 0x2b, 0x27, 0xe0, 0xdb, 0xe3, 0xc7,
+	0xc3, 0xa9, 0xf5, 0xcd, 0x57, 0x9d, 0x2b, 0x3c, 0x17, 0xcd, 0xc5, 0x82, 0xeb, 0x40, 0x9f, 0xc6,
+	0x5d, 0x8b, 0xe0, 0x50, 0xfc, 0x4d, 0x5d, 0x87, 0xe1, 0x9f, 0x7e, 0x03, 0x00, 0x00, 0xff, 0xff,
+	0xcd, 0xa1, 0x56, 0xa7, 0xa3, 0x01, 0x00, 0x00,
 }
diff --git a/protos/peer/chaincodeevent.pb.go b/protos/peer/chaincodeevent.pb.go
index 31faae3b750..91eb13ad47d 100644
--- a/protos/peer/chaincodeevent.pb.go
+++ b/protos/peer/chaincodeevent.pb.go
@@ -2,69 +2,6 @@
 // source: peer/chaincodeevent.proto
 // DO NOT EDIT!
 
-/*
-Package peer is a generated protocol buffer package.
-
-It is generated from these files:
-	peer/chaincodeevent.proto
-	peer/chaincode_proposal.proto
-	peer/chaincode.proto
-	peer/chaincode_transaction.proto
-	peer/events.proto
-	peer/fabric_message.proto
-	peer/fabric_proposal.proto
-	peer/fabric_proposal_response.proto
-	peer/fabric.proto
-	peer/fabric_service.proto
-	peer/fabric_transaction.proto
-	peer/server_admin.proto
-
-It has these top-level messages:
-	ChaincodeEvent
-	ChaincodeHeaderExtension
-	ChaincodeProposalPayload
-	ChaincodeAction
-	ChaincodeID
-	ChaincodeInput
-	ChaincodeSpec
-	ChaincodeDeploymentSpec
-	ChaincodeInvocationSpec
-	ChaincodeMessage
-	PutStateInfo
-	RangeQueryState
-	RangeQueryStateNext
-	RangeQueryStateClose
-	RangeQueryStateKeyValue
-	RangeQueryStateResponse
-	ChaincodeActionPayload
-	ChaincodeEndorsedAction
-	ChaincodeReg
-	Interest
-	Register
-	Rejection
-	Unregister
-	Event
-	Message
-	SignedProposal
-	Proposal
-	ProposalResponse
-	Response
-	ProposalResponsePayload
-	Endorsement
-	PeerAddress
-	PeerID
-	PeerEndpoint
-	PeersMessage
-	PeersAddresses
-	BlockchainInfo
-	SignedTransaction
-	InvalidTransaction
-	Transaction
-	TransactionAction
-	ServerStatus
-	LogLevelRequest
-	LogLevelResponse
-*/
 package peer
 
 import proto "github.com/golang/protobuf/proto"
@@ -76,12 +13,6 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
 // ChaincodeEvent is used for events and registrations that are specific to chaincode
 // string type - "chaincode"
 type ChaincodeEvent struct {
@@ -94,26 +25,26 @@ type ChaincodeEvent struct {
 func (m *ChaincodeEvent) Reset()                    { *m = ChaincodeEvent{} }
 func (m *ChaincodeEvent) String() string            { return proto.CompactTextString(m) }
 func (*ChaincodeEvent) ProtoMessage()               {}
-func (*ChaincodeEvent) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*ChaincodeEvent) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
 func init() {
 	proto.RegisterType((*ChaincodeEvent)(nil), "protos.ChaincodeEvent")
 }
 
-func init() { proto.RegisterFile("peer/chaincodeevent.proto", fileDescriptor0) }
+func init() { proto.RegisterFile("peer/chaincodeevent.proto", fileDescriptor3) }
 
-var fileDescriptor0 = []byte{
-	// 184 bytes of a gzipped FileDescriptorProto
+var fileDescriptor3 = []byte{
+	// 186 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0x48, 0x4d, 0x2d,
 	0xd2, 0x4f, 0xce, 0x48, 0xcc, 0xcc, 0x4b, 0xce, 0x4f, 0x49, 0x4d, 0x2d, 0x4b, 0xcd, 0x2b, 0xd1,
 	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53, 0xc5, 0x4a, 0x75, 0x5c, 0x7c, 0xce, 0x30,
 	0x79, 0x57, 0x90, 0xbc, 0x90, 0x02, 0x17, 0x37, 0x5c, 0x87, 0xa7, 0x8b, 0x04, 0xa3, 0x02, 0xa3,
-	0x06, 0x67, 0x10, 0xb2, 0x90, 0x90, 0x10, 0x17, 0x4b, 0x49, 0x05, 0x50, 0x8a, 0x09, 0x2c, 0x05,
-	0x66, 0x0b, 0xc9, 0x70, 0x71, 0x82, 0x8d, 0xf7, 0x4b, 0xcc, 0x4d, 0x95, 0x60, 0x06, 0x4b, 0x20,
-	0x04, 0x84, 0x24, 0xb8, 0xd8, 0x0b, 0x12, 0x2b, 0x73, 0xf2, 0x13, 0x53, 0x24, 0x58, 0x80, 0x72,
-	0x3c, 0x41, 0x30, 0xae, 0x93, 0x33, 0x97, 0x58, 0x7e, 0x51, 0xba, 0x5e, 0x46, 0x65, 0x41, 0x6a,
-	0x51, 0x4e, 0x6a, 0x4a, 0x7a, 0x6a, 0x11, 0xc4, 0x81, 0xc5, 0x51, 0x9a, 0xe9, 0x99, 0x25, 0x19,
-	0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x48, 0xd2, 0xfa, 0x69, 0x89, 0x49, 0x45, 0x99, 0xc9,
-	0xfa, 0x10, 0x55, 0xfa, 0x20, 0x1f, 0x26, 0x41, 0x3c, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff,
-	0x78, 0x83, 0xed, 0x60, 0xf0, 0x00, 0x00, 0x00,
+	0x06, 0x67, 0x10, 0xb2, 0x90, 0x90, 0x10, 0x17, 0x4b, 0x49, 0x85, 0xa7, 0x8b, 0x04, 0x13, 0x58,
+	0x0a, 0xcc, 0x16, 0x92, 0xe1, 0xe2, 0x04, 0x1b, 0xef, 0x97, 0x98, 0x9b, 0x2a, 0xc1, 0x0c, 0x96,
+	0x40, 0x08, 0x08, 0x49, 0x70, 0xb1, 0x17, 0x24, 0x56, 0xe6, 0xe4, 0x27, 0xa6, 0x48, 0xb0, 0x28,
+	0x30, 0x6a, 0xf0, 0x04, 0xc1, 0xb8, 0x4e, 0xce, 0x5c, 0x62, 0xf9, 0x45, 0xe9, 0x7a, 0x19, 0x95,
+	0x05, 0xa9, 0x45, 0x39, 0xa9, 0x29, 0xe9, 0xa9, 0x45, 0x10, 0x07, 0x16, 0x47, 0x69, 0xa6, 0x67,
+	0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x23, 0x49, 0xeb, 0xa7, 0x25, 0x26, 0x15,
+	0x65, 0x26, 0xeb, 0x43, 0x54, 0xe9, 0x83, 0x7c, 0x98, 0x04, 0xf1, 0x8c, 0x31, 0x20, 0x00, 0x00,
+	0xff, 0xff, 0x78, 0x83, 0xed, 0x60, 0xf0, 0x00, 0x00, 0x00,
 }
diff --git a/protos/peer/events.pb.go b/protos/peer/events.pb.go
index 9edd41d4b1a..4f95db151cb 100644
--- a/protos/peer/events.pb.go
+++ b/protos/peer/events.pb.go
@@ -545,36 +545,37 @@ var _Events_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("peer/events.proto", fileDescriptor4) }
 
 var fileDescriptor4 = []byte{
-	// 495 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x53, 0xd1, 0x6e, 0xd3, 0x30,
-	0x14, 0x6d, 0xda, 0xb5, 0x6b, 0x6e, 0xd7, 0x29, 0xbd, 0x43, 0x28, 0x54, 0x20, 0x4d, 0x41, 0x48,
-	0x65, 0x48, 0x0d, 0x94, 0x8a, 0x67, 0x48, 0x16, 0xb1, 0xc0, 0x68, 0x25, 0x53, 0x5e, 0x78, 0x41,
-	0x69, 0xe6, 0xb5, 0x81, 0x35, 0xa9, 0x1c, 0x0f, 0xc1, 0x2f, 0xf0, 0xc8, 0x17, 0xe3, 0x3a, 0x76,
-	0x92, 0xd1, 0xa7, 0x3d, 0xc5, 0xf6, 0x39, 0xe7, 0xde, 0xe3, 0x13, 0x5f, 0x18, 0x6c, 0x29, 0x65,
-	0x2e, 0xfd, 0x49, 0x53, 0x9e, 0x8f, 0xb7, 0x2c, 0xe3, 0x19, 0x76, 0xe4, 0x27, 0x1f, 0x9e, 0xc4,
-	0xd9, 0x66, 0x93, 0xa5, 0x6e, 0xf1, 0x29, 0xc0, 0xe1, 0x23, 0xc9, 0x8f, 0xd7, 0x51, 0x92, 0xc6,
-	0xd9, 0x15, 0x95, 0x42, 0x05, 0x3d, 0x91, 0xd0, 0x75, 0xb4, 0x64, 0x49, 0xfc, 0x8d, 0xb3, 0x28,
-	0xcd, 0xa3, 0x98, 0x27, 0x5a, 0xe9, 0xcc, 0xe0, 0xc8, 0xd7, 0x32, 0x42, 0x57, 0x78, 0x0a, 0xbd,
-	0xb2, 0x4c, 0x78, 0x6e, 0x1b, 0xa7, 0xc6, 0xc8, 0x24, 0xf5, 0x23, 0x7c, 0x0c, 0xa6, 0xac, 0x3f,
-	0x8b, 0x36, 0xd4, 0x6e, 0x4a, 0xbc, 0x3a, 0x70, 0xfe, 0x18, 0xd0, 0x0d, 0x53, 0x4e, 0x19, 0xcd,
-	0x39, 0xba, 0x8a, 0xba, 0xf8, 0xbd, 0xa5, 0xb2, 0xd4, 0xf1, 0x64, 0x50, 0xf4, 0xcd, 0xc7, 0x81,
-	0x06, 0x48, 0xc5, 0x41, 0x0f, 0xac, 0xb8, 0xe6, 0x26, 0x4c, 0xaf, 0x33, 0xd9, 0xa2, 0x37, 0x79,
-	0xa0, 0x75, 0x75, 0xb7, 0x17, 0x0d, 0xb2, 0xc7, 0xf7, 0x4c, 0x38, 0x54, 0x4b, 0x67, 0x0a, 0x5d,
-	0xb1, 0x4c, 0x72, 0x61, 0x07, 0x47, 0xd0, 0x29, 0xf2, 0x14, 0x46, 0x5a, 0xa2, 0xa0, 0xa5, 0x0b,
-	0x6a, 0xb7, 0x44, 0xe1, 0xce, 0x25, 0x98, 0x84, 0x7e, 0xa7, 0x32, 0x25, 0x7c, 0x0a, 0x4d, 0xfe,
-	0x4b, 0x7a, 0xef, 0x4d, 0x4e, 0xb4, 0x64, 0x51, 0xc5, 0x48, 0x04, 0x8c, 0x43, 0xe8, 0x52, 0xc6,
-	0x32, 0xf6, 0x29, 0x5f, 0xa9, 0x44, 0xca, 0xbd, 0xf3, 0x06, 0xe0, 0x4b, 0xca, 0xee, 0xef, 0xe2,
-	0x6f, 0x13, 0xda, 0x32, 0x23, 0x1c, 0x43, 0x57, 0xeb, 0x95, 0x91, 0x52, 0xa5, 0x6f, 0x27, 0x82,
-	0x28, 0x39, 0xf8, 0x0c, 0xda, 0xcb, 0x9b, 0x2c, 0xfe, 0xa1, 0x92, 0xeb, 0x8f, 0xd5, 0x53, 0xf1,
-	0x76, 0x87, 0x82, 0x59, 0xa0, 0xf8, 0x16, 0x8e, 0xcb, 0xec, 0x64, 0x23, 0xbb, 0x25, 0xf9, 0x0f,
-	0xf7, 0x92, 0x96, 0xa8, 0x10, 0xfe, 0xc7, 0xc7, 0x57, 0x60, 0x32, 0x1d, 0x94, 0x7d, 0x20, 0xc5,
-	0x83, 0xca, 0x99, 0x02, 0x84, 0xae, 0x62, 0xe1, 0x14, 0xe0, 0xb6, 0x4c, 0xc3, 0x6e, 0x4b, 0x0d,
-	0x6a, 0x4d, 0x95, 0x93, 0x10, 0xd5, 0x78, 0xde, 0xa1, 0x8a, 0xe2, 0xcc, 0x03, 0xb3, 0x7c, 0x37,
-	0x78, 0x24, 0xfe, 0x6e, 0xf0, 0x3e, 0xfc, 0xbc, 0x08, 0x88, 0xd5, 0x40, 0x13, 0xda, 0xde, 0xe5,
-	0xdc, 0xff, 0x68, 0x19, 0xd8, 0x07, 0xd3, 0xbf, 0x78, 0x17, 0xce, 0xfc, 0xf9, 0x79, 0x60, 0x35,
-	0x77, 0x5b, 0x12, 0x7c, 0x08, 0xfc, 0x45, 0x38, 0x9f, 0x59, 0xad, 0xc9, 0x14, 0x3a, 0xb2, 0x46,
-	0x8e, 0x67, 0x70, 0x20, 0xee, 0xc8, 0xb1, 0x7f, 0xe7, 0x4d, 0x0e, 0xef, 0x6e, 0x9d, 0xc6, 0xc8,
-	0x78, 0x69, 0x78, 0x2f, 0xbe, 0x3e, 0x5f, 0x25, 0x7c, 0x7d, 0xbb, 0xdc, 0xa5, 0xe9, 0xae, 0x45,
-	0x7f, 0x76, 0x43, 0xaf, 0x56, 0xe5, 0x68, 0xb9, 0x85, 0xc6, 0xdd, 0x4d, 0xdb, 0xb2, 0x98, 0xd5,
-	0xd7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xee, 0x26, 0x8f, 0xc7, 0x03, 0x00, 0x00,
+	// 501 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x93, 0xc1, 0x6f, 0xd3, 0x30,
+	0x18, 0xc5, 0x93, 0x76, 0xed, 0x9a, 0xaf, 0xeb, 0x94, 0x7e, 0x43, 0x28, 0x54, 0x20, 0x55, 0x41,
+	0x48, 0x65, 0x48, 0x0d, 0x84, 0x8a, 0x33, 0x24, 0x8b, 0x48, 0x60, 0xb4, 0x92, 0x29, 0x17, 0x2e,
+	0x28, 0xcd, 0xbc, 0x34, 0xb0, 0x26, 0x95, 0xe3, 0xa1, 0xed, 0x5f, 0xe0, 0xc8, 0x5f, 0x8c, 0xea,
+	0xd8, 0x49, 0xc7, 0x4e, 0x3b, 0xa5, 0xf6, 0x7b, 0xef, 0xf3, 0xeb, 0x4f, 0x36, 0x0c, 0xb7, 0x94,
+	0x32, 0x87, 0xfe, 0xa6, 0x39, 0x2f, 0xa7, 0x5b, 0x56, 0xf0, 0x02, 0xbb, 0xe2, 0x53, 0x8e, 0x4e,
+	0x92, 0x62, 0xb3, 0x29, 0x72, 0xa7, 0xfa, 0x54, 0xe2, 0xe8, 0x89, 0xf0, 0x27, 0xeb, 0x38, 0xcb,
+	0x93, 0xe2, 0x82, 0x8a, 0xa0, 0x94, 0x9e, 0x09, 0xe9, 0x32, 0x5e, 0xb1, 0x2c, 0xf9, 0xc1, 0x59,
+	0x9c, 0x97, 0x71, 0xc2, 0x33, 0x95, 0xb4, 0xe7, 0x70, 0xe4, 0xab, 0x18, 0xa1, 0x29, 0x8e, 0xa1,
+	0x5f, 0x8f, 0x89, 0xce, 0x2c, 0x7d, 0xac, 0x4f, 0x0c, 0xb2, 0xbf, 0x85, 0x4f, 0xc1, 0x10, 0xf3,
+	0xe7, 0xf1, 0x86, 0x5a, 0x2d, 0xa1, 0x37, 0x1b, 0xf6, 0x1f, 0x1d, 0x7a, 0x51, 0xce, 0x29, 0xa3,
+	0x25, 0x47, 0x47, 0x5a, 0x97, 0xb7, 0x5b, 0x2a, 0x46, 0x1d, 0xbb, 0xc3, 0xea, 0xdc, 0x72, 0x1a,
+	0x28, 0x81, 0x34, 0x1e, 0xf4, 0xc0, 0x4c, 0xf6, 0xda, 0x44, 0xf9, 0x65, 0x21, 0x8e, 0xe8, 0xbb,
+	0x8f, 0x54, 0x6e, 0xbf, 0x6d, 0xa8, 0x91, 0x7b, 0x7e, 0xcf, 0x80, 0x43, 0xf9, 0xd3, 0x9e, 0x41,
+	0x8f, 0xd0, 0x34, 0x2b, 0x39, 0x65, 0x38, 0x81, 0x6e, 0xc5, 0xd3, 0xd2, 0xc7, 0xed, 0x49, 0xdf,
+	0x35, 0xd5, 0x40, 0xd5, 0x96, 0x48, 0xdd, 0x3e, 0x07, 0x83, 0xd0, 0x9f, 0x54, 0x50, 0xc2, 0xe7,
+	0xd0, 0xe2, 0x37, 0xa2, 0x7b, 0xdf, 0x3d, 0x51, 0x91, 0x65, 0x83, 0x91, 0xb4, 0xf8, 0x0d, 0x8e,
+	0xa0, 0x47, 0x19, 0x2b, 0xd8, 0x97, 0x32, 0x95, 0x44, 0xea, 0xb5, 0xfd, 0x0e, 0xe0, 0x5b, 0xce,
+	0x1e, 0xde, 0xe2, 0x6f, 0x0b, 0x3a, 0x82, 0x11, 0x4e, 0xa1, 0xa7, 0xf2, 0xb2, 0x48, 0x9d, 0x52,
+	0xff, 0x2e, 0xd4, 0x48, 0xed, 0xc1, 0x17, 0xd0, 0x59, 0x5d, 0x15, 0xc9, 0x2f, 0x49, 0x6e, 0x30,
+	0x95, 0x57, 0xc5, 0xdb, 0x6d, 0x86, 0x1a, 0xa9, 0x54, 0x7c, 0x0f, 0xc7, 0x35, 0x3b, 0x71, 0x90,
+	0xd5, 0x16, 0xfe, 0xc7, 0xf7, 0x48, 0x0b, 0x35, 0xd4, 0xc8, 0x7f, 0x7e, 0x7c, 0x03, 0x06, 0x53,
+	0xa0, 0xac, 0x03, 0x11, 0x1e, 0x36, 0xcd, 0xa4, 0x10, 0x6a, 0xa4, 0x71, 0xe1, 0x0c, 0xe0, 0xba,
+	0xa6, 0x61, 0x75, 0x44, 0x06, 0x55, 0xa6, 0xe1, 0x14, 0x6a, 0x64, 0xcf, 0xe7, 0x1d, 0x4a, 0x14,
+	0xa7, 0x1e, 0x18, 0xf5, 0xbd, 0xc1, 0x23, 0xe8, 0x91, 0xe0, 0x63, 0xf4, 0x75, 0x19, 0x10, 0x53,
+	0x43, 0x03, 0x3a, 0xde, 0xf9, 0xc2, 0xff, 0x6c, 0xea, 0x38, 0x00, 0xc3, 0x0f, 0x3f, 0x44, 0x73,
+	0x7f, 0x71, 0x16, 0x98, 0xad, 0xdd, 0x92, 0x04, 0x9f, 0x02, 0x7f, 0x19, 0x2d, 0xe6, 0x66, 0xdb,
+	0x9d, 0x41, 0x57, 0xcc, 0x28, 0xf1, 0x14, 0x0e, 0xfc, 0x75, 0xcc, 0x71, 0x70, 0xe7, 0x4e, 0x8e,
+	0xee, 0x2e, 0x6d, 0x6d, 0xa2, 0xbf, 0xd6, 0xbd, 0x57, 0xdf, 0x5f, 0xa6, 0x19, 0x5f, 0x5f, 0xaf,
+	0x76, 0x34, 0x9d, 0xf5, 0xed, 0x96, 0xb2, 0x2b, 0x7a, 0x91, 0xd6, 0x4f, 0xcb, 0xa9, 0x32, 0xce,
+	0xee, 0xb5, 0xad, 0xaa, 0xb7, 0xfa, 0xf6, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xee, 0x26,
+	0x8f, 0xc7, 0x03, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric.pb.go b/protos/peer/fabric.pb.go
index 85f2059bc84..1d94bf5bec1 100644
--- a/protos/peer/fabric.pb.go
+++ b/protos/peer/fabric.pb.go
@@ -35,7 +35,7 @@ var PeerEndpoint_Type_value = map[string]int32{
 func (x PeerEndpoint_Type) String() string {
 	return proto.EnumName(PeerEndpoint_Type_name, int32(x))
 }
-func (PeerEndpoint_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor8, []int{2, 0} }
+func (PeerEndpoint_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{2, 0} }
 
 type PeerAddress struct {
 	Host string `protobuf:"bytes,1,opt,name=host" json:"host,omitempty"`
@@ -45,7 +45,7 @@ type PeerAddress struct {
 func (m *PeerAddress) Reset()                    { *m = PeerAddress{} }
 func (m *PeerAddress) String() string            { return proto.CompactTextString(m) }
 func (*PeerAddress) ProtoMessage()               {}
-func (*PeerAddress) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
+func (*PeerAddress) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 type PeerID struct {
 	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
@@ -54,7 +54,7 @@ type PeerID struct {
 func (m *PeerID) Reset()                    { *m = PeerID{} }
 func (m *PeerID) String() string            { return proto.CompactTextString(m) }
 func (*PeerID) ProtoMessage()               {}
-func (*PeerID) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
+func (*PeerID) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 type PeerEndpoint struct {
 	ID      *PeerID           `protobuf:"bytes,1,opt,name=ID" json:"ID,omitempty"`
@@ -66,7 +66,7 @@ type PeerEndpoint struct {
 func (m *PeerEndpoint) Reset()                    { *m = PeerEndpoint{} }
 func (m *PeerEndpoint) String() string            { return proto.CompactTextString(m) }
 func (*PeerEndpoint) ProtoMessage()               {}
-func (*PeerEndpoint) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
+func (*PeerEndpoint) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
 
 func (m *PeerEndpoint) GetID() *PeerID {
 	if m != nil {
@@ -82,7 +82,7 @@ type PeersMessage struct {
 func (m *PeersMessage) Reset()                    { *m = PeersMessage{} }
 func (m *PeersMessage) String() string            { return proto.CompactTextString(m) }
 func (*PeersMessage) ProtoMessage()               {}
-func (*PeersMessage) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
+func (*PeersMessage) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
 
 func (m *PeersMessage) GetPeers() []*PeerEndpoint {
 	if m != nil {
@@ -98,7 +98,7 @@ type PeersAddresses struct {
 func (m *PeersAddresses) Reset()                    { *m = PeersAddresses{} }
 func (m *PeersAddresses) String() string            { return proto.CompactTextString(m) }
 func (*PeersAddresses) ProtoMessage()               {}
-func (*PeersAddresses) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
+func (*PeersAddresses) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
 
 // Contains information about the blockchain ledger such as height, current
 // block hash, and previous block hash.
@@ -111,7 +111,7 @@ type BlockchainInfo struct {
 func (m *BlockchainInfo) Reset()                    { *m = BlockchainInfo{} }
 func (m *BlockchainInfo) String() string            { return proto.CompactTextString(m) }
 func (*BlockchainInfo) ProtoMessage()               {}
-func (*BlockchainInfo) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
+func (*BlockchainInfo) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
 
 func init() {
 	proto.RegisterType((*PeerAddress)(nil), "protos.PeerAddress")
@@ -123,33 +123,33 @@ func init() {
 	proto.RegisterEnum("protos.PeerEndpoint_Type", PeerEndpoint_Type_name, PeerEndpoint_Type_value)
 }
 
-func init() { proto.RegisterFile("peer/fabric.proto", fileDescriptor8) }
-
-var fileDescriptor8 = []byte{
-	// 391 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0x5d, 0x6b, 0xe2, 0x40,
-	0x14, 0xdd, 0x68, 0x74, 0xc9, 0x55, 0x83, 0x0e, 0xb2, 0x64, 0x41, 0x96, 0x25, 0x4f, 0xfb, 0x99,
-	0x80, 0xcb, 0xb2, 0xb0, 0x6f, 0x4a, 0x5c, 0x36, 0xd0, 0xc6, 0x32, 0xd8, 0x3e, 0xf4, 0xa5, 0xc4,
-	0x64, 0x4c, 0x82, 0x9a, 0x09, 0x33, 0xb1, 0xd0, 0xd7, 0xfe, 0xb8, 0xfe, 0xae, 0xce, 0x87, 0xa9,
-	0x05, 0xfb, 0x34, 0xf7, 0x9c, 0x7b, 0xee, 0x9d, 0x7b, 0xee, 0x0c, 0x8c, 0x2a, 0x42, 0x98, 0xbf,
-	0x89, 0xd7, 0xac, 0x48, 0xbc, 0x8a, 0xd1, 0x9a, 0xa2, 0xae, 0x3a, 0xb8, 0xfb, 0x1b, 0x7a, 0x57,
-	0x22, 0x39, 0x4b, 0x53, 0x46, 0x38, 0x47, 0x08, 0xcc, 0x9c, 0xf2, 0xda, 0x31, 0x3e, 0x1b, 0x5f,
-	0x2c, 0xac, 0x62, 0xc9, 0x55, 0x94, 0xd5, 0x4e, 0x4b, 0x70, 0x1d, 0xac, 0x62, 0x77, 0x02, 0x5d,
-	0x59, 0x16, 0x06, 0x32, 0x5b, 0xc6, 0x7b, 0xd2, 0x54, 0xc8, 0xd8, 0x7d, 0x32, 0xa0, 0x2f, 0xd3,
-	0x8b, 0x32, 0xad, 0x68, 0x51, 0xd6, 0xe8, 0x13, 0xb4, 0xc2, 0x40, 0x49, 0x7a, 0x53, 0x5b, 0x4f,
-	0xc0, 0x3d, 0xdd, 0x00, 0x8b, 0x0c, 0x72, 0xe0, 0x7d, 0xac, 0x27, 0x50, 0xb7, 0x58, 0xb8, 0x81,
-	0xe8, 0x27, 0x98, 0xf5, 0x43, 0x45, 0x9c, 0xb6, 0xa0, 0xed, 0xe9, 0xc7, 0xd7, 0xb5, 0x4d, 0x77,
-	0x6f, 0x25, 0x04, 0x58, 0xc9, 0xd0, 0x18, 0x3a, 0xd5, 0xb6, 0x10, 0x77, 0x99, 0x42, 0xdf, 0xc7,
-	0x1a, 0xb8, 0x7f, 0xc0, 0x94, 0x1a, 0x34, 0x00, 0xeb, 0x3a, 0x0a, 0x16, 0xff, 0xc2, 0x68, 0x11,
-	0x0c, 0xdf, 0x49, 0x78, 0x33, 0xbb, 0x08, 0x83, 0xd9, 0x6a, 0x89, 0x87, 0x06, 0x1a, 0xc1, 0x20,
-	0x5a, 0x46, 0x77, 0x27, 0xaa, 0xe5, 0xfe, 0xd5, 0x3e, 0xf8, 0xa5, 0x18, 0x25, 0xce, 0x08, 0xfa,
-	0x26, 0xda, 0x4b, 0x2c, 0xac, 0xb4, 0x85, 0x95, 0xf1, 0x5b, 0xe3, 0x60, 0x2d, 0x71, 0x3d, 0xb0,
-	0x55, 0xed, 0x71, 0xb5, 0x84, 0xa3, 0x09, 0x58, 0x71, 0x03, 0x54, 0x07, 0x0b, 0x9f, 0x08, 0xf7,
-	0xd1, 0x00, 0x7b, 0xbe, 0xa3, 0xc9, 0x36, 0xc9, 0xe3, 0xa2, 0x0c, 0xcb, 0x0d, 0x45, 0x1f, 0xa0,
-	0x9b, 0x93, 0x22, 0xcb, 0xf5, 0x7b, 0x98, 0xf8, 0x88, 0xc4, 0x18, 0xc3, 0xe4, 0xc0, 0x18, 0x29,
-	0x6b, 0x55, 0xf0, 0x3f, 0xe6, 0xb9, 0xda, 0x5b, 0x1f, 0x9f, 0xf1, 0xe8, 0x87, 0x78, 0x7d, 0x46,
-	0xee, 0x0b, 0x7a, 0xe0, 0x27, 0x71, 0x5b, 0x89, 0xcf, 0x13, 0xf3, 0xef, 0xb7, 0x5f, 0xb3, 0xa2,
-	0xce, 0x0f, 0x6b, 0x2f, 0xa1, 0x7b, 0x3f, 0x17, 0x4b, 0x63, 0x3b, 0x92, 0x66, 0x2f, 0xbf, 0xc7,
-	0xd7, 0x86, 0x7d, 0x69, 0x71, 0xad, 0xff, 0xd0, 0xaf, 0xe7, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8,
-	0x30, 0x01, 0x3f, 0x5f, 0x02, 0x00, 0x00,
+func init() { proto.RegisterFile("peer/fabric.proto", fileDescriptor5) }
+
+var fileDescriptor5 = []byte{
+	// 398 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x52, 0x51, 0x6b, 0xd4, 0x40,
+	0x10, 0x76, 0x73, 0xb9, 0x93, 0xcc, 0x5d, 0xc3, 0xdd, 0x52, 0x24, 0x42, 0x91, 0x90, 0xa7, 0x58,
+	0x35, 0x81, 0x13, 0x11, 0x7c, 0xbb, 0x92, 0x13, 0x03, 0x9a, 0xca, 0x52, 0x7d, 0xf0, 0x45, 0x72,
+	0xc9, 0x34, 0x09, 0x6d, 0xb3, 0xcb, 0x6e, 0x4e, 0xb8, 0x57, 0x7f, 0x9c, 0xbf, 0x4b, 0x76, 0xb7,
+	0xf1, 0x84, 0xf6, 0x29, 0xf3, 0x7d, 0xf3, 0x7d, 0x93, 0x99, 0xd9, 0x81, 0x95, 0x40, 0x94, 0xe9,
+	0x75, 0xb9, 0x93, 0x5d, 0x95, 0x08, 0xc9, 0x07, 0x4e, 0x67, 0xe6, 0xa3, 0xa2, 0x77, 0x30, 0xff,
+	0x8a, 0x28, 0x37, 0x75, 0x2d, 0x51, 0x29, 0x4a, 0xc1, 0x6d, 0xb9, 0x1a, 0x02, 0x12, 0x92, 0xd8,
+	0x63, 0x26, 0xd6, 0x9c, 0xe0, 0x72, 0x08, 0x9c, 0x90, 0xc4, 0x53, 0x66, 0xe2, 0xe8, 0x0c, 0x66,
+	0xda, 0x96, 0x67, 0x3a, 0xdb, 0x97, 0x77, 0x38, 0x3a, 0x74, 0x1c, 0xfd, 0x21, 0xb0, 0xd0, 0xe9,
+	0x6d, 0x5f, 0x0b, 0xde, 0xf5, 0x03, 0x7d, 0x01, 0x4e, 0x9e, 0x19, 0xc9, 0x7c, 0xed, 0xdb, 0x0e,
+	0x54, 0x62, 0x0b, 0x30, 0x27, 0xcf, 0x68, 0x00, 0x4f, 0x4b, 0xdb, 0x81, 0xf9, 0x8b, 0xc7, 0x46,
+	0x48, 0xdf, 0x80, 0x3b, 0x1c, 0x04, 0x06, 0x93, 0x90, 0xc4, 0xfe, 0xfa, 0xf9, 0xff, 0xde, 0xb1,
+	0x7a, 0x72, 0x75, 0x10, 0xc8, 0x8c, 0x8c, 0x9e, 0xc2, 0x54, 0xdc, 0x74, 0x79, 0x16, 0xb8, 0x21,
+	0x89, 0x17, 0xcc, 0x82, 0xe8, 0x3d, 0xb8, 0x5a, 0x43, 0x4f, 0xc0, 0xfb, 0x56, 0x64, 0xdb, 0x8f,
+	0x79, 0xb1, 0xcd, 0x96, 0x4f, 0x34, 0xfc, 0xbe, 0xf9, 0x9c, 0x67, 0x9b, 0xab, 0x4b, 0xb6, 0x24,
+	0x74, 0x05, 0x27, 0xc5, 0x65, 0xf1, 0xf3, 0x48, 0x39, 0xd1, 0x07, 0x3b, 0x87, 0xfa, 0x82, 0x4a,
+	0x95, 0x0d, 0xd2, 0x73, 0x98, 0xea, 0x55, 0xaa, 0x80, 0x84, 0x93, 0x78, 0xbe, 0x3e, 0x7d, 0xac,
+	0x1d, 0x66, 0x25, 0x51, 0x02, 0xbe, 0xf1, 0xde, 0xaf, 0x16, 0x15, 0x3d, 0x03, 0xaf, 0x1c, 0x81,
+	0xa9, 0xe0, 0xb1, 0x23, 0x11, 0xfd, 0x26, 0xe0, 0x5f, 0xdc, 0xf2, 0xea, 0xa6, 0x6a, 0xcb, 0xae,
+	0xcf, 0xfb, 0x6b, 0x4e, 0x9f, 0xc1, 0xac, 0xc5, 0xae, 0x69, 0xed, 0x7b, 0xb8, 0xec, 0x1e, 0xd1,
+	0x73, 0x58, 0x56, 0x7b, 0x29, 0xb1, 0x1f, 0x8c, 0xe1, 0x53, 0xa9, 0x5a, 0xb3, 0xb7, 0x05, 0x7b,
+	0xc0, 0xd3, 0xd7, 0xb0, 0x12, 0x12, 0x7f, 0x75, 0x7c, 0xaf, 0x8e, 0xe2, 0x89, 0x11, 0x3f, 0x4c,
+	0x5c, 0xbc, 0xfa, 0xf1, 0xb2, 0xe9, 0x86, 0x76, 0xbf, 0x4b, 0x2a, 0x7e, 0x97, 0xb6, 0x07, 0x81,
+	0xf2, 0x16, 0xeb, 0xe6, 0xdf, 0xf5, 0xa4, 0x76, 0xe0, 0x54, 0x8f, 0xb8, 0xb3, 0x37, 0xf4, 0xf6,
+	0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x30, 0x01, 0x3f, 0x5f, 0x02, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric_message.pb.go b/protos/peer/fabric_message.pb.go
index 40ef4016980..f3c86755285 100644
--- a/protos/peer/fabric_message.pb.go
+++ b/protos/peer/fabric_message.pb.go
@@ -38,7 +38,7 @@ var Message_Type_value = map[string]int32{
 func (x Message_Type) String() string {
 	return proto.EnumName(Message_Type_name, int32(x))
 }
-func (Message_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor5, []int{0, 0} }
+func (Message_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor6, []int{0, 0} }
 
 // A Message encapsulates a payload of the indicated type in this message.
 type Message struct {
@@ -54,28 +54,29 @@ type Message struct {
 func (m *Message) Reset()                    { *m = Message{} }
 func (m *Message) String() string            { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()               {}
-func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
 
 func init() {
 	proto.RegisterType((*Message)(nil), "protos.Message")
 	proto.RegisterEnum("protos.Message_Type", Message_Type_name, Message_Type_value)
 }
 
-func init() { proto.RegisterFile("peer/fabric_message.proto", fileDescriptor5) }
+func init() { proto.RegisterFile("peer/fabric_message.proto", fileDescriptor6) }
 
-var fileDescriptor5 = []byte{
-	// 208 bytes of a gzipped FileDescriptorProto
+var fileDescriptor6 = []byte{
+	// 212 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0x48, 0x4d, 0x2d,
 	0xd2, 0x4f, 0x4b, 0x4c, 0x2a, 0xca, 0x4c, 0x8e, 0xcf, 0x4d, 0x2d, 0x2e, 0x4e, 0x4c, 0x4f, 0xd5,
 	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53, 0xc5, 0x4a, 0xd3, 0x19, 0xb9, 0xd8, 0x7d,
 	0x21, 0x32, 0x42, 0x1a, 0x5c, 0x2c, 0x25, 0x95, 0x05, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x7c,
-	0x46, 0x22, 0x10, 0x95, 0xc5, 0x7a, 0x50, 0x69, 0xbd, 0x10, 0xa0, 0x5c, 0x10, 0x58, 0x85, 0x90,
-	0x04, 0x17, 0x7b, 0x59, 0x6a, 0x51, 0x71, 0x66, 0x7e, 0x9e, 0x04, 0x13, 0x50, 0x31, 0x6b, 0x10,
-	0x8c, 0x0b, 0x92, 0x29, 0x48, 0xac, 0xcc, 0xc9, 0x4f, 0x4c, 0x91, 0x60, 0x06, 0xca, 0xf0, 0x04,
-	0xc1, 0xb8, 0x4a, 0x7a, 0x5c, 0x2c, 0x20, 0x13, 0x84, 0x78, 0xb9, 0x38, 0x43, 0xfd, 0x5c, 0x5c,
-	0xdd, 0x3c, 0xfd, 0x5c, 0x5d, 0x04, 0x18, 0x40, 0x5c, 0x17, 0xcf, 0x60, 0x67, 0xff, 0x30, 0xd7,
-	0xa0, 0x48, 0x01, 0x46, 0x21, 0x0e, 0x2e, 0x96, 0xe0, 0x48, 0x3f, 0x67, 0x01, 0x26, 0x27, 0xed,
-	0x28, 0xcd, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0x0c, 0xa0, 0xd6,
-	0xa2, 0x9c, 0xd4, 0x94, 0x74, 0xb8, 0x87, 0xf4, 0x21, 0xce, 0xd3, 0x07, 0xf9, 0x31, 0x09, 0xe2,
-	0x1d, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x59, 0x84, 0x5f, 0xf2, 0x00, 0x00, 0x00,
+	0x46, 0x22, 0x10, 0x95, 0xc5, 0x7a, 0x50, 0x69, 0xbd, 0x90, 0xca, 0x82, 0xd4, 0x20, 0xb0, 0x0a,
+	0x21, 0x09, 0x2e, 0xf6, 0xb2, 0xd4, 0xa2, 0xe2, 0xcc, 0xfc, 0x3c, 0x09, 0x26, 0x05, 0x46, 0x0d,
+	0xd6, 0x20, 0x18, 0x17, 0x24, 0x53, 0x90, 0x58, 0x99, 0x93, 0x9f, 0x98, 0x22, 0xc1, 0xac, 0xc0,
+	0xa8, 0xc1, 0x13, 0x04, 0xe3, 0x2a, 0xe9, 0x71, 0xb1, 0x80, 0x4c, 0x10, 0xe2, 0xe5, 0xe2, 0x0c,
+	0xf5, 0x73, 0x71, 0x75, 0xf3, 0xf4, 0x73, 0x75, 0x11, 0x60, 0x00, 0x71, 0x5d, 0x3c, 0x83, 0x9d,
+	0xfd, 0xc3, 0x5c, 0x83, 0x22, 0x05, 0x18, 0x85, 0x38, 0xb8, 0x58, 0x82, 0x23, 0xfd, 0x9c, 0x05,
+	0x98, 0x9c, 0xb4, 0xa3, 0x34, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5,
+	0x33, 0x2a, 0x0b, 0x52, 0x8b, 0x72, 0x52, 0x53, 0xd2, 0xe1, 0x1e, 0xd2, 0x87, 0x38, 0x4f, 0x1f,
+	0xe4, 0xc7, 0x24, 0x88, 0x77, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x59, 0x84, 0x5f,
+	0xf2, 0x00, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric_proposal.pb.go b/protos/peer/fabric_proposal.pb.go
index b9e8bd39a8e..624015b7d97 100644
--- a/protos/peer/fabric_proposal.pb.go
+++ b/protos/peer/fabric_proposal.pb.go
@@ -49,7 +49,7 @@ type SignedProposal struct {
 func (m *SignedProposal) Reset()                    { *m = SignedProposal{} }
 func (m *SignedProposal) String() string            { return proto.CompactTextString(m) }
 func (*SignedProposal) ProtoMessage()               {}
-func (*SignedProposal) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
+func (*SignedProposal) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
 
 // A Proposal is sent to an endorser for endorsement.  The proposal contains:
 // 1. A header which should be unmarshaled to a Header message.  Note that
@@ -85,28 +85,28 @@ type Proposal struct {
 func (m *Proposal) Reset()                    { *m = Proposal{} }
 func (m *Proposal) String() string            { return proto.CompactTextString(m) }
 func (*Proposal) ProtoMessage()               {}
-func (*Proposal) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
+func (*Proposal) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
 
 func init() {
 	proto.RegisterType((*SignedProposal)(nil), "protos.SignedProposal")
 	proto.RegisterType((*Proposal)(nil), "protos.Proposal")
 }
 
-func init() { proto.RegisterFile("peer/fabric_proposal.proto", fileDescriptor6) }
+func init() { proto.RegisterFile("peer/fabric_proposal.proto", fileDescriptor7) }
 
-var fileDescriptor6 = []byte{
-	// 194 bytes of a gzipped FileDescriptorProto
+var fileDescriptor7 = []byte{
+	// 196 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x2a, 0x48, 0x4d, 0x2d,
 	0xd2, 0x4f, 0x4b, 0x4c, 0x2a, 0xca, 0x4c, 0x8e, 0x2f, 0x28, 0xca, 0x2f, 0xc8, 0x2f, 0x4e, 0xcc,
-	0xd1, 0x03, 0x32, 0x4a, 0xf2, 0x85, 0xd8, 0xc0, 0x54, 0xb1, 0x52, 0x08, 0x17, 0x5f, 0x70, 0x66,
-	0x7a, 0x5e, 0x6a, 0x4a, 0x00, 0x54, 0x5e, 0x48, 0x85, 0x8b, 0x17, 0xa6, 0xd6, 0xa9, 0xb2, 0x24,
-	0xb5, 0x58, 0x82, 0x51, 0x81, 0x51, 0x83, 0x27, 0x08, 0x55, 0x50, 0x48, 0x86, 0x8b, 0xb3, 0x18,
-	0xa8, 0x2f, 0xb1, 0xa4, 0xb4, 0x28, 0x55, 0x82, 0x09, 0xac, 0x02, 0x21, 0xa0, 0x14, 0xc5, 0xc5,
-	0x01, 0x37, 0x4f, 0x8c, 0x8b, 0x2d, 0x23, 0x35, 0x31, 0x25, 0xb5, 0x08, 0x6a, 0x10, 0x94, 0x27,
-	0x24, 0xc1, 0xc5, 0x5e, 0x90, 0x58, 0x99, 0x93, 0x9f, 0x98, 0x02, 0xd5, 0x0f, 0xe3, 0x82, 0xcc,
-	0x4e, 0xad, 0x28, 0x49, 0xcd, 0x2b, 0xce, 0xcc, 0xcf, 0x93, 0x60, 0x86, 0x98, 0x0d, 0x17, 0x70,
-	0xd2, 0x8e, 0xd2, 0x4c, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0xcf, 0xa8,
-	0x2c, 0x48, 0x2d, 0xca, 0x49, 0x4d, 0x49, 0x87, 0xfb, 0x54, 0x1f, 0xe2, 0x33, 0x7d, 0x90, 0xe7,
-	0x93, 0x20, 0xde, 0x34, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x5c, 0x58, 0xb9, 0x0b, 0x01,
-	0x00, 0x00,
+	0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53, 0xc5, 0x4a, 0x21, 0x5c, 0x7c, 0xc1,
+	0x99, 0xe9, 0x79, 0xa9, 0x29, 0x01, 0x50, 0x79, 0x21, 0x15, 0x2e, 0x5e, 0x98, 0x5a, 0xa7, 0xca,
+	0x92, 0xd4, 0x62, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x9e, 0x20, 0x54, 0x41, 0x21, 0x19, 0x2e, 0xce,
+	0xe2, 0xcc, 0xf4, 0xbc, 0xc4, 0x92, 0xd2, 0xa2, 0x54, 0x09, 0x26, 0xb0, 0x0a, 0x84, 0x80, 0x52,
+	0x14, 0x17, 0x07, 0xdc, 0x3c, 0x31, 0x2e, 0xb6, 0x8c, 0xd4, 0xc4, 0x94, 0xd4, 0x22, 0xa8, 0x41,
+	0x50, 0x9e, 0x90, 0x04, 0x17, 0x7b, 0x41, 0x62, 0x65, 0x4e, 0x7e, 0x62, 0x0a, 0x54, 0x3f, 0x8c,
+	0x0b, 0x32, 0x3b, 0xb5, 0xa2, 0x24, 0x35, 0xaf, 0x38, 0x33, 0x3f, 0x4f, 0x82, 0x19, 0x62, 0x36,
+	0x5c, 0xc0, 0x49, 0x3b, 0x4a, 0x33, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57,
+	0x3f, 0xa3, 0xb2, 0x20, 0xb5, 0x28, 0x27, 0x35, 0x25, 0x1d, 0xee, 0x53, 0x7d, 0x88, 0xcf, 0xf4,
+	0x41, 0x9e, 0x4f, 0x82, 0x78, 0xd3, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x5c, 0x58, 0xb9,
+	0x0b, 0x01, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric_proposal_response.pb.go b/protos/peer/fabric_proposal_response.pb.go
index 4935ce30f6d..40c99a3ea0b 100644
--- a/protos/peer/fabric_proposal_response.pb.go
+++ b/protos/peer/fabric_proposal_response.pb.go
@@ -41,7 +41,7 @@ type ProposalResponse struct {
 func (m *ProposalResponse) Reset()                    { *m = ProposalResponse{} }
 func (m *ProposalResponse) String() string            { return proto.CompactTextString(m) }
 func (*ProposalResponse) ProtoMessage()               {}
-func (*ProposalResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
+func (*ProposalResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
 
 func (m *ProposalResponse) GetTimestamp() *google_protobuf.Timestamp {
 	if m != nil {
@@ -78,7 +78,7 @@ type Response struct {
 func (m *Response) Reset()                    { *m = Response{} }
 func (m *Response) String() string            { return proto.CompactTextString(m) }
 func (*Response) ProtoMessage()               {}
-func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
+func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
 
 // ProposalResponsePayload is the payload of a proposal response.  This message
 // is the "bridge" between the client's request and the endorser's action in
@@ -113,7 +113,7 @@ type ProposalResponsePayload struct {
 func (m *ProposalResponsePayload) Reset()                    { *m = ProposalResponsePayload{} }
 func (m *ProposalResponsePayload) String() string            { return proto.CompactTextString(m) }
 func (*ProposalResponsePayload) ProtoMessage()               {}
-func (*ProposalResponsePayload) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
+func (*ProposalResponsePayload) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
 
 // An endorsement is a signature of an endorser over a proposal response.  By
 // producing an endorsement message, an endorser implicitly "approves" that
@@ -135,7 +135,7 @@ type Endorsement struct {
 func (m *Endorsement) Reset()                    { *m = Endorsement{} }
 func (m *Endorsement) String() string            { return proto.CompactTextString(m) }
 func (*Endorsement) ProtoMessage()               {}
-func (*Endorsement) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
+func (*Endorsement) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
 
 func init() {
 	proto.RegisterType((*ProposalResponse)(nil), "protos.ProposalResponse")
@@ -144,30 +144,30 @@ func init() {
 	proto.RegisterType((*Endorsement)(nil), "protos.Endorsement")
 }
 
-func init() { proto.RegisterFile("peer/fabric_proposal_response.proto", fileDescriptor7) }
-
-var fileDescriptor7 = []byte{
-	// 342 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x52, 0x5f, 0x4b, 0xfb, 0x30,
-	0x14, 0x65, 0xfb, 0xfd, 0x36, 0xb7, 0xbb, 0x3d, 0x8c, 0x08, 0x5a, 0x86, 0xa0, 0xd4, 0x17, 0x45,
-	0x69, 0x41, 0x11, 0x7c, 0x16, 0x44, 0x1f, 0x47, 0x10, 0x1f, 0xf4, 0x61, 0xa4, 0xdb, 0x5d, 0x57,
-	0x68, 0x9b, 0x90, 0x9b, 0x89, 0xfb, 0xc0, 0x7e, 0x0f, 0xdb, 0x34, 0xe9, 0x36, 0x9f, 0xca, 0xb9,
-	0x39, 0x39, 0x7f, 0xd2, 0x0b, 0x97, 0x0a, 0x51, 0xc7, 0x2b, 0x91, 0xe8, 0x6c, 0x31, 0x57, 0x5a,
-	0x2a, 0x49, 0x22, 0x9f, 0x6b, 0x24, 0x25, 0x4b, 0xc2, 0xa8, 0x9a, 0x18, 0xc9, 0xfa, 0xf6, 0x43,
-	0xd3, 0xf3, 0x54, 0xca, 0x34, 0xc7, 0xd8, 0xc2, 0x64, 0xb3, 0x8a, 0x4d, 0x56, 0x20, 0x19, 0x51,
-	0xa8, 0x86, 0x18, 0xfe, 0x74, 0x60, 0x32, 0x73, 0x22, 0xdc, 0x69, 0xb0, 0x00, 0x8e, 0xbe, 0x50,
-	0x53, 0x26, 0xcb, 0xa0, 0x73, 0xd1, 0xb9, 0xea, 0x71, 0x0f, 0xd9, 0x23, 0x0c, 0x5b, 0x85, 0xa0,
-	0x5b, 0x9d, 0x8d, 0xee, 0xa6, 0x51, 0xe3, 0x11, 0x79, 0x8f, 0xe8, 0xcd, 0x33, 0xf8, 0x8e, 0xcc,
-	0x6e, 0x61, 0xe0, 0x33, 0x06, 0xff, 0xed, 0xc5, 0x49, 0x73, 0x83, 0x22, 0xef, 0xcb, 0x5b, 0x46,
-	0x9d, 0x40, 0x89, 0x6d, 0x2e, 0xc5, 0x32, 0xe8, 0x55, 0xe4, 0x31, 0xf7, 0x90, 0x3d, 0xc0, 0x08,
-	0xcb, 0xa5, 0xd4, 0x84, 0x05, 0x96, 0x26, 0xe8, 0x5b, 0xa9, 0x63, 0x2f, 0xf5, 0xbc, 0x3b, 0xe2,
-	0xfb, 0xbc, 0xf0, 0x1d, 0x06, 0x6d, 0xbd, 0x13, 0xe8, 0x57, 0x99, 0xcc, 0x86, 0x5c, 0x3b, 0x87,
-	0x6a, 0xd3, 0x2a, 0x2d, 0x89, 0x14, 0x6d, 0xb5, 0x21, 0xf7, 0x70, 0x3f, 0xce, 0xbf, 0x83, 0x38,
-	0xe1, 0x27, 0x9c, 0xfe, 0x7d, 0xbe, 0x99, 0x4b, 0x1a, 0xc2, 0xd8, 0xff, 0x9e, 0x57, 0x41, 0x6b,
-	0x6b, 0x36, 0xe6, 0x07, 0x33, 0x76, 0x06, 0x43, 0xfc, 0x36, 0x58, 0xda, 0xb7, 0xee, 0x5a, 0xc2,
-	0x6e, 0x10, 0xbe, 0xc0, 0x68, 0xaf, 0x10, 0x9b, 0xc2, 0xc0, 0x55, 0xd2, 0x4e, 0xac, 0xc5, 0xb5,
-	0x10, 0x65, 0x69, 0x59, 0xf5, 0xd0, 0xe8, 0x85, 0xda, 0xc1, 0xd3, 0xcd, 0xc7, 0x75, 0x9a, 0x99,
-	0xf5, 0x26, 0x89, 0x16, 0xb2, 0x88, 0xd7, 0x5b, 0x85, 0x3a, 0xc7, 0x65, 0xda, 0xee, 0x51, 0xb3,
-	0x1f, 0x14, 0xd7, 0xab, 0x95, 0x34, 0xbb, 0x73, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x43, 0xe1,
-	0xd2, 0xab, 0x69, 0x02, 0x00, 0x00,
+func init() { proto.RegisterFile("peer/fabric_proposal_response.proto", fileDescriptor8) }
+
+var fileDescriptor8 = []byte{
+	// 345 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x52, 0x4d, 0x6b, 0xe3, 0x30,
+	0x10, 0xc5, 0xd9, 0x4d, 0x36, 0x99, 0xe4, 0x10, 0xb4, 0xb0, 0x6b, 0x42, 0xa1, 0xc1, 0xbd, 0xa4,
+	0xb4, 0xd8, 0xd0, 0x52, 0xe8, 0xb9, 0x50, 0xda, 0x63, 0x10, 0xa5, 0x87, 0xf6, 0x10, 0xe4, 0x64,
+	0xe2, 0x18, 0x6c, 0x4b, 0x68, 0xe4, 0xd2, 0xfc, 0xe0, 0xfe, 0x8f, 0x62, 0x59, 0x72, 0x92, 0x9e,
+	0xcc, 0x1b, 0x3f, 0xbd, 0x0f, 0x69, 0xe0, 0x42, 0x21, 0xea, 0x64, 0x2b, 0x52, 0x9d, 0xaf, 0x57,
+	0x4a, 0x4b, 0x25, 0x49, 0x14, 0x2b, 0x8d, 0xa4, 0x64, 0x45, 0x18, 0x2b, 0x2d, 0x8d, 0x64, 0x03,
+	0xfb, 0xa1, 0xd9, 0x79, 0x26, 0x65, 0x56, 0x60, 0x62, 0x61, 0x5a, 0x6f, 0x13, 0x93, 0x97, 0x48,
+	0x46, 0x94, 0xaa, 0x25, 0x46, 0x5f, 0x01, 0x4c, 0x97, 0x4e, 0x84, 0x3b, 0x0d, 0x16, 0xc2, 0x9f,
+	0x0f, 0xd4, 0x94, 0xcb, 0x2a, 0x0c, 0xe6, 0xc1, 0xa2, 0xcf, 0x3d, 0x64, 0xf7, 0x30, 0xea, 0x14,
+	0xc2, 0xde, 0x3c, 0x58, 0x8c, 0x6f, 0x66, 0x71, 0xeb, 0x11, 0x7b, 0x8f, 0xf8, 0xc5, 0x33, 0xf8,
+	0x81, 0xcc, 0xae, 0x61, 0xe8, 0x33, 0x86, 0xbf, 0xed, 0xc1, 0x69, 0x7b, 0x82, 0x62, 0xef, 0xcb,
+	0x3b, 0x46, 0x93, 0x40, 0x89, 0x7d, 0x21, 0xc5, 0x26, 0xec, 0xcf, 0x83, 0xc5, 0x84, 0x7b, 0xc8,
+	0xee, 0x60, 0x8c, 0xd5, 0x46, 0x6a, 0xc2, 0x12, 0x2b, 0x13, 0x0e, 0xac, 0xd4, 0x5f, 0x2f, 0xf5,
+	0x78, 0xf8, 0xc5, 0x8f, 0x79, 0xd1, 0x2b, 0x0c, 0xbb, 0x7a, 0xff, 0x60, 0x40, 0x46, 0x98, 0x9a,
+	0x5c, 0x3b, 0x87, 0x1a, 0xd3, 0x12, 0x89, 0x44, 0x86, 0xb6, 0xda, 0x88, 0x7b, 0x78, 0x1c, 0xe7,
+	0xd7, 0x49, 0x9c, 0xe8, 0x1d, 0xfe, 0xff, 0xbc, 0xbe, 0xa5, 0x4b, 0x1a, 0xc1, 0xc4, 0x3f, 0xcf,
+	0xb3, 0xa0, 0x9d, 0x35, 0x9b, 0xf0, 0x93, 0x19, 0x3b, 0x83, 0x11, 0x7e, 0x1a, 0xac, 0xec, 0x5d,
+	0xf7, 0x2c, 0xe1, 0x30, 0x88, 0x9e, 0x60, 0x7c, 0x54, 0x88, 0xcd, 0x60, 0xe8, 0x2a, 0x69, 0x27,
+	0xd6, 0xe1, 0x46, 0x88, 0xf2, 0xac, 0x12, 0xa6, 0xd6, 0xe8, 0x85, 0xba, 0xc1, 0xc3, 0xd5, 0xdb,
+	0x65, 0x96, 0x9b, 0x5d, 0x9d, 0xc6, 0x6b, 0x59, 0x26, 0xbb, 0xbd, 0x42, 0x5d, 0xe0, 0x26, 0xeb,
+	0xf6, 0xa8, 0xdd, 0x0f, 0x4a, 0x9a, 0xd5, 0x4a, 0xdb, 0xdd, 0xb9, 0xfd, 0x0e, 0x00, 0x00, 0xff,
+	0xff, 0x43, 0xe1, 0xd2, 0xab, 0x69, 0x02, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric_service.pb.go b/protos/peer/fabric_service.pb.go
index 8155a0e8bfb..d1787074352 100644
--- a/protos/peer/fabric_service.pb.go
+++ b/protos/peer/fabric_service.pb.go
@@ -93,16 +93,16 @@ var _Endorser_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("peer/fabric_service.proto", fileDescriptor9) }
 
 var fileDescriptor9 = []byte{
-	// 170 bytes of a gzipped FileDescriptorProto
+	// 172 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0x48, 0x4d, 0x2d,
 	0xd2, 0x4f, 0x4b, 0x4c, 0x2a, 0xca, 0x4c, 0x8e, 0x2f, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5,
-	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53, 0xc5, 0x52, 0x52, 0xc8, 0x4a, 0x80, 0x62,
-	0x05, 0xf9, 0xc5, 0x89, 0x39, 0x10, 0x35, 0x52, 0xca, 0xd8, 0xe4, 0xe2, 0x8b, 0x52, 0x8b, 0x0b,
-	0xf2, 0xf3, 0x8a, 0xa1, 0x06, 0x19, 0x05, 0x72, 0x71, 0xb8, 0xe6, 0xa5, 0xe4, 0x17, 0x01, 0x8d,
-	0x17, 0x72, 0xe5, 0xe2, 0x0f, 0x28, 0xca, 0x4f, 0x4e, 0x2d, 0x2e, 0x0e, 0x80, 0xaa, 0x16, 0x12,
-	0x83, 0x28, 0x2b, 0xd6, 0x0b, 0xce, 0x4c, 0xcf, 0x4b, 0x4d, 0x81, 0x89, 0x4b, 0x49, 0xc0, 0xc4,
-	0x61, 0x22, 0x41, 0x50, 0x63, 0x95, 0x18, 0x9c, 0xb4, 0xa3, 0x34, 0xd3, 0x33, 0x4b, 0x32, 0x4a,
-	0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x33, 0x2a, 0x0b, 0x52, 0x8b, 0x72, 0x52, 0x53, 0xd2, 0xe1,
-	0x6e, 0xd1, 0x87, 0x68, 0xd5, 0x07, 0x39, 0x2f, 0x09, 0xe2, 0x11, 0x63, 0x40, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x4e, 0xa5, 0x8a, 0xe0, 0xec, 0x00, 0x00, 0x00,
+	0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0x53, 0xc5, 0x52, 0x52, 0xc8, 0x4a, 0x0a, 0x8a,
+	0xf2, 0x0b, 0xf2, 0x8b, 0x13, 0x73, 0x20, 0x6a, 0xa4, 0x94, 0xb1, 0xc9, 0xc5, 0x17, 0xa5, 0x16,
+	0x17, 0xe4, 0xe7, 0x15, 0x43, 0x0d, 0x32, 0x0a, 0xe4, 0xe2, 0x70, 0xcd, 0x4b, 0xc9, 0x2f, 0x2a,
+	0x4e, 0x2d, 0x12, 0x72, 0xe5, 0xe2, 0x0f, 0x28, 0xca, 0x4f, 0x4e, 0x2d, 0x2e, 0x0e, 0x80, 0xaa,
+	0x16, 0x12, 0x83, 0x28, 0x2b, 0xd6, 0x0b, 0xce, 0x4c, 0xcf, 0x4b, 0x4d, 0x81, 0x89, 0x4b, 0x49,
+	0xc0, 0xc4, 0x61, 0x22, 0x41, 0x50, 0x63, 0x95, 0x18, 0x9c, 0xb4, 0xa3, 0x34, 0xd3, 0x33, 0x4b,
+	0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x33, 0x2a, 0x0b, 0x52, 0x8b, 0x72, 0x52, 0x53,
+	0xd2, 0xe1, 0x6e, 0xd1, 0x87, 0x68, 0xd5, 0x07, 0x39, 0x2f, 0x09, 0xe2, 0x11, 0x63, 0x40, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0x4e, 0xa5, 0x8a, 0xe0, 0xec, 0x00, 0x00, 0x00,
 }
diff --git a/protos/peer/fabric_transaction.pb.go b/protos/peer/fabric_transaction.pb.go
index 6977bdae4da..415adae3b8d 100644
--- a/protos/peer/fabric_transaction.pb.go
+++ b/protos/peer/fabric_transaction.pb.go
@@ -139,29 +139,29 @@ func init() {
 func init() { proto.RegisterFile("peer/fabric_transaction.proto", fileDescriptor10) }
 
 var fileDescriptor10 = []byte{
-	// 370 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0xdf, 0x4a, 0xc3, 0x30,
-	0x18, 0xc5, 0xad, 0x63, 0x1b, 0xfb, 0x2a, 0xb2, 0x45, 0x1c, 0x75, 0x28, 0x8e, 0x5e, 0xf9, 0x07,
-	0x5a, 0xd8, 0x50, 0xc4, 0xbb, 0x6d, 0xee, 0x62, 0xb7, 0x75, 0x20, 0x08, 0x22, 0x69, 0x9b, 0x75,
-	0x81, 0xb6, 0x29, 0x49, 0x3a, 0xd6, 0x17, 0xf1, 0x75, 0x7c, 0x35, 0xbb, 0x66, 0xdd, 0xaa, 0xf3,
-	0xaa, 0x9c, 0xf4, 0x97, 0x93, 0x93, 0x93, 0x0f, 0xae, 0x12, 0x42, 0xb8, 0xbd, 0xc0, 0x2e, 0xa7,
-	0xde, 0xa7, 0xe4, 0x38, 0x16, 0xd8, 0x93, 0x94, 0xc5, 0x56, 0xc2, 0x99, 0x64, 0xa8, 0x51, 0x7c,
-	0x44, 0xef, 0x3a, 0x60, 0x2c, 0x08, 0x89, 0x5d, 0x48, 0x37, 0x5d, 0xd8, 0x92, 0x46, 0x44, 0x48,
-	0x1c, 0x25, 0x0a, 0x34, 0x3f, 0xa0, 0xf3, 0x4a, 0x83, 0x98, 0xf8, 0xf3, 0xbd, 0x07, 0xba, 0x83,
-	0x76, 0xc5, 0x72, 0x9c, 0x49, 0x22, 0x0c, 0xad, 0xaf, 0xdd, 0x9c, 0x38, 0x07, 0xeb, 0xe8, 0x12,
-	0x5a, 0x22, 0x37, 0xc0, 0x32, 0xe5, 0xc4, 0x38, 0x2e, 0xa0, 0xfd, 0x82, 0xf9, 0xad, 0x01, 0x9a,
-	0xc5, 0x2b, 0x1c, 0xd2, 0x5f, 0x07, 0x3c, 0x80, 0x5e, 0x31, 0x2a, 0xbc, 0xf5, 0xc1, 0x99, 0x8a,
-	0x24, 0xac, 0x0a, 0xe9, 0x54, 0x39, 0xf4, 0x08, 0x75, 0x0f, 0xa7, 0x42, 0x9d, 0x73, 0x3a, 0xe8,
-	0x97, 0x1b, 0x0e, 0x4f, 0xb0, 0x26, 0x1b, 0xce, 0x51, 0xb8, 0xf9, 0x0c, 0xf5, 0x42, 0xa3, 0x73,
-	0xe8, 0xcc, 0xd7, 0x33, 0x7f, 0x14, 0x72, 0x82, 0xfd, 0x6c, 0xba, 0xa6, 0x42, 0x8a, 0xf6, 0x11,
-	0xea, 0x41, 0xd7, 0x79, 0x9b, 0xb0, 0x78, 0x11, 0x52, 0x4f, 0xbe, 0xa4, 0x9c, 0xc6, 0xc1, 0x84,
-	0x45, 0x11, 0x95, 0x6d, 0xcd, 0xfc, 0xd2, 0x40, 0xaf, 0x46, 0x37, 0xa0, 0xb9, 0x22, 0x5c, 0x94,
-	0xb1, 0xeb, 0x4e, 0x29, 0xd1, 0x13, 0xb4, 0x76, 0xed, 0x16, 0x09, 0xf5, 0x41, 0xcf, 0x52, 0xfd,
-	0x5b, 0x65, 0xff, 0xd6, 0xbc, 0x24, 0x9c, 0x3d, 0x8c, 0x86, 0xd0, 0x54, 0xee, 0xc2, 0xa8, 0xf5,
-	0x6b, 0xf9, 0xbe, 0x8b, 0x7f, 0xaa, 0x18, 0xa9, 0x42, 0x4a, 0xd2, 0x9c, 0xe6, 0x77, 0xf9, 0xfb,
-	0x17, 0x75, 0xa1, 0xb1, 0xcc, 0xaf, 0x46, 0xf8, 0xf6, 0xbd, 0xb6, 0x6a, 0x93, 0x3a, 0xc1, 0x59,
-	0xc8, 0xb0, 0xbf, 0x7d, 0xa3, 0x52, 0x8e, 0xef, 0xdf, 0x6f, 0x03, 0x2a, 0x97, 0xa9, 0x6b, 0x79,
-	0x2c, 0xb2, 0x97, 0x59, 0x42, 0x78, 0x48, 0xfc, 0x60, 0x37, 0x5c, 0x6a, 0x74, 0x84, 0xbd, 0x99,
-	0x37, 0x57, 0x8d, 0xd5, 0xf0, 0x27, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x48, 0x72, 0x86, 0x7e, 0x02,
-	0x00, 0x00,
+	// 371 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0x51, 0x6b, 0xea, 0x30,
+	0x1c, 0xc5, 0x6f, 0xaf, 0xa8, 0xf8, 0xef, 0xe5, 0xa2, 0x19, 0x93, 0x4e, 0x36, 0x26, 0x7d, 0x72,
+	0x1b, 0xb4, 0x50, 0xd9, 0x18, 0x7b, 0x53, 0xe7, 0x83, 0xaf, 0x9d, 0x30, 0x18, 0x8c, 0x91, 0xb6,
+	0xb1, 0x06, 0xda, 0xa6, 0x24, 0xa9, 0xd8, 0x2f, 0xb2, 0xaf, 0xb3, 0xaf, 0x36, 0x6c, 0x8c, 0x76,
+	0xb8, 0xa7, 0x72, 0xd2, 0x5f, 0xce, 0xff, 0x70, 0xf2, 0x87, 0xab, 0x9c, 0x10, 0xee, 0xae, 0x70,
+	0xc0, 0x69, 0xf8, 0x21, 0x39, 0xce, 0x04, 0x0e, 0x25, 0x65, 0x99, 0x93, 0x73, 0x26, 0x19, 0x6a,
+	0x55, 0x1f, 0x31, 0xb8, 0x8e, 0x19, 0x8b, 0x13, 0xe2, 0x56, 0x32, 0x28, 0x56, 0xae, 0xa4, 0x29,
+	0x11, 0x12, 0xa7, 0xb9, 0x02, 0xed, 0x77, 0xe8, 0xbd, 0xd0, 0x38, 0x23, 0xd1, 0xf2, 0xe8, 0x81,
+	0x6e, 0xa1, 0x5b, 0xb3, 0x9c, 0x96, 0x92, 0x08, 0xcb, 0x18, 0x1a, 0xa3, 0x7f, 0xfe, 0xc9, 0x39,
+	0xba, 0x84, 0x8e, 0xa0, 0x71, 0x86, 0x65, 0xc1, 0x89, 0xf5, 0xb7, 0x82, 0x8e, 0x07, 0xf6, 0x97,
+	0x01, 0x68, 0x91, 0x6d, 0x70, 0x42, 0x7f, 0x0c, 0xb8, 0x07, 0xb3, 0x66, 0x54, 0x79, 0x9b, 0xde,
+	0x99, 0x8a, 0x24, 0x9c, 0x1a, 0xe9, 0xd7, 0x39, 0xf4, 0x00, 0xcd, 0x10, 0x17, 0x42, 0xcd, 0xf9,
+	0xef, 0x0d, 0xf5, 0x85, 0xd3, 0x09, 0xce, 0x6c, 0xc7, 0xf9, 0x0a, 0xb7, 0x9f, 0xa0, 0x59, 0x69,
+	0x74, 0x0e, 0xbd, 0xe5, 0x76, 0x11, 0x4d, 0x12, 0x4e, 0x70, 0x54, 0xce, 0xb7, 0x54, 0x48, 0xd1,
+	0xfd, 0x83, 0x06, 0xd0, 0xf7, 0x5f, 0x67, 0x2c, 0x5b, 0x25, 0x34, 0x94, 0xcf, 0x05, 0xa7, 0x59,
+	0x3c, 0x63, 0x69, 0x4a, 0x65, 0xd7, 0xb0, 0x3f, 0x0d, 0x30, 0xeb, 0xd1, 0x2d, 0x68, 0x6f, 0x08,
+	0x17, 0x3a, 0x76, 0xd3, 0xd7, 0x12, 0x3d, 0x42, 0xe7, 0xd0, 0x6e, 0x95, 0xd0, 0xf4, 0x06, 0x8e,
+	0xea, 0xdf, 0xd1, 0xfd, 0x3b, 0x4b, 0x4d, 0xf8, 0x47, 0x18, 0x8d, 0xa1, 0xad, 0xdc, 0x85, 0xd5,
+	0x18, 0x36, 0x46, 0xa6, 0x77, 0xf1, 0x4b, 0x15, 0x13, 0x55, 0x88, 0x26, 0xed, 0x39, 0xf4, 0x4e,
+	0xfe, 0xa2, 0x3e, 0xb4, 0xd6, 0x04, 0x47, 0x84, 0xef, 0xdf, 0x6b, 0xaf, 0x76, 0xa9, 0x73, 0x5c,
+	0x26, 0x0c, 0x47, 0xfb, 0x37, 0xd2, 0x72, 0x7a, 0xf7, 0x76, 0x13, 0x53, 0xb9, 0x2e, 0x02, 0x27,
+	0x64, 0xa9, 0xbb, 0x2e, 0x73, 0xc2, 0x13, 0x12, 0xc5, 0x87, 0xe5, 0x52, 0xab, 0x23, 0xdc, 0xdd,
+	0xbe, 0x05, 0x6a, 0xad, 0xc6, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x48, 0x72, 0x86, 0x7e,
+	0x02, 0x00, 0x00,
 }
diff --git a/protos/peer/server_admin.pb.go b/protos/peer/server_admin.pb.go
index 1cca8aec090..4ff7bfa5423 100644
--- a/protos/peer/server_admin.pb.go
+++ b/protos/peer/server_admin.pb.go
@@ -297,29 +297,29 @@ var _Admin_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("peer/server_admin.proto", fileDescriptor11) }
 
 var fileDescriptor11 = []byte{
-	// 380 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x92, 0xcf, 0x4e, 0xea, 0x40,
-	0x14, 0xc6, 0x29, 0xf7, 0xc2, 0xbd, 0x3d, 0xdc, 0xab, 0x75, 0x62, 0x84, 0x54, 0x13, 0x4d, 0x57,
-	0x1a, 0x93, 0x36, 0xc1, 0x85, 0x0b, 0x75, 0x81, 0x52, 0xff, 0x04, 0x2c, 0xa4, 0x85, 0x18, 0xdd,
-	0x18, 0x4a, 0x0f, 0x85, 0xa4, 0x30, 0xb5, 0x33, 0x25, 0xe1, 0x75, 0x7c, 0x27, 0xdf, 0xc7, 0xb6,
-	0x03, 0x62, 0xd4, 0x8d, 0xc4, 0xd5, 0x9c, 0xef, 0xcc, 0x77, 0x4e, 0x66, 0x7e, 0xf9, 0xa0, 0x1c,
-	0x22, 0x46, 0x06, 0xc3, 0x68, 0x8a, 0xd1, 0x63, 0xcf, 0x1b, 0x8f, 0x26, 0x7a, 0x18, 0x51, 0x4e,
-	0x49, 0x31, 0x3b, 0x98, 0xba, 0xed, 0x53, 0xea, 0x07, 0x68, 0x64, 0xd2, 0x8d, 0x07, 0x06, 0x8e,
-	0x43, 0x3e, 0x13, 0x26, 0xed, 0x59, 0x82, 0x7f, 0x4e, 0x36, 0xeb, 0xf0, 0x1e, 0x8f, 0x19, 0x39,
-	0x86, 0x22, 0xcb, 0xaa, 0x8a, 0xb4, 0x27, 0xed, 0xaf, 0x55, 0x77, 0x85, 0x91, 0xe9, 0xef, 0x5d,
-	0xba, 0x38, 0x2e, 0xa8, 0x87, 0xf6, 0xdc, 0xae, 0xdd, 0x03, 0x2c, 0xbb, 0xe4, 0x3f, 0xc8, 0x5d,
-	0xab, 0x6e, 0x5e, 0xde, 0x58, 0x66, 0x5d, 0xc9, 0x91, 0x12, 0xfc, 0x71, 0x3a, 0x35, 0xbb, 0x93,
-	0x08, 0x49, 0x88, 0x56, 0xbb, 0x9d, 0x88, 0x3c, 0x01, 0x28, 0xb6, 0x6b, 0x5d, 0x27, 0xa9, 0x7f,
-	0x11, 0x19, 0x0a, 0xa6, 0x6d, 0xb7, 0x6c, 0xe5, 0x77, 0xea, 0xe9, 0x5a, 0x0d, 0xab, 0x75, 0x67,
-	0x29, 0x05, 0xad, 0x01, 0xeb, 0x4d, 0xea, 0x37, 0x71, 0x8a, 0x81, 0x8d, 0x4f, 0x31, 0x32, 0x4e,
-	0x76, 0x40, 0x0e, 0xa8, 0x7f, 0x4b, 0xbd, 0x38, 0xc0, 0xec, 0xa5, 0xb2, 0xbd, 0x6c, 0x10, 0x15,
-	0xfe, 0x06, 0xf3, 0x81, 0x4a, 0x3e, 0xbb, 0x7c, 0xd3, 0x5a, 0x13, 0x94, 0xe5, 0x32, 0x16, 0xd2,
-	0x09, 0xc3, 0xd5, 0xb7, 0x55, 0x5f, 0xf2, 0x50, 0xa8, 0xa5, 0xd0, 0xc9, 0x09, 0xc8, 0x57, 0xc8,
-	0xe7, 0x14, 0xb7, 0x74, 0x01, 0x5d, 0x5f, 0x40, 0xd7, 0xcd, 0x14, 0xba, 0xba, 0xf9, 0x15, 0x4d,
-	0x2d, 0x47, 0xce, 0xa0, 0x94, 0xd4, 0x11, 0x17, 0xed, 0x6f, 0x8f, 0x9f, 0xa6, 0xec, 0x69, 0xb8,
-	0xe2, 0xf4, 0x35, 0x6c, 0x24, 0x2f, 0x17, 0x9f, 0x5d, 0xa0, 0x21, 0xe5, 0x85, 0xf9, 0x03, 0x79,
-	0xb5, 0xf2, 0xf9, 0x42, 0x50, 0x14, 0x9b, 0x9c, 0x1f, 0xd9, 0x74, 0x7e, 0xf8, 0x70, 0xe0, 0x8f,
-	0xf8, 0x30, 0x76, 0xf5, 0x3e, 0x1d, 0x1b, 0xc3, 0x59, 0x88, 0x51, 0x80, 0x9e, 0x9f, 0x24, 0x7d,
-	0xd0, 0x73, 0xa3, 0x51, 0x5f, 0xa4, 0x99, 0x19, 0x69, 0xf8, 0x5d, 0x91, 0xf4, 0xa3, 0xd7, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0xa2, 0xc9, 0xe8, 0x56, 0x0b, 0x03, 0x00, 0x00,
+	// 384 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x92, 0xcf, 0x4e, 0xe2, 0x50,
+	0x14, 0xc6, 0x29, 0x33, 0x30, 0xd3, 0xc3, 0xfc, 0xe9, 0xdc, 0x4c, 0x06, 0xd2, 0x99, 0x64, 0x26,
+	0x5d, 0x8d, 0x31, 0x69, 0x13, 0x5c, 0xb8, 0x50, 0x17, 0x68, 0x2b, 0x1a, 0xb0, 0x90, 0x16, 0x62,
+	0x74, 0x63, 0x5a, 0x7a, 0x28, 0x24, 0x85, 0x5b, 0xef, 0xbd, 0x25, 0xe1, 0x75, 0x7c, 0x27, 0xdf,
+	0xc7, 0xb4, 0x17, 0xc4, 0xa8, 0x1b, 0x89, 0xab, 0xd3, 0x73, 0xce, 0xf7, 0x7d, 0xe9, 0xfd, 0xe5,
+	0x40, 0x3d, 0x45, 0x64, 0x16, 0x47, 0xb6, 0x40, 0x76, 0x13, 0x44, 0xb3, 0xe9, 0xdc, 0x4c, 0x19,
+	0x15, 0x94, 0x54, 0x8b, 0xc2, 0xf5, 0xdf, 0x31, 0xa5, 0x71, 0x82, 0x56, 0xd1, 0x86, 0xd9, 0xd8,
+	0xc2, 0x59, 0x2a, 0x96, 0x52, 0x64, 0xdc, 0x29, 0xf0, 0xc5, 0x2f, 0xbc, 0xbe, 0x08, 0x44, 0xc6,
+	0xc9, 0x3e, 0x54, 0x79, 0xf1, 0xd5, 0x50, 0xfe, 0x29, 0xff, 0xbf, 0x35, 0xff, 0x4a, 0x21, 0x37,
+	0x9f, 0xaa, 0x4c, 0x59, 0x4e, 0x68, 0x84, 0xde, 0x4a, 0x6e, 0x5c, 0x01, 0x6c, 0xa6, 0xe4, 0x2b,
+	0xa8, 0x43, 0xd7, 0x76, 0x4e, 0xcf, 0x5d, 0xc7, 0xd6, 0x4a, 0xa4, 0x06, 0x9f, 0xfc, 0x41, 0xcb,
+	0x1b, 0x38, 0xb6, 0xa6, 0xc8, 0xa6, 0xd7, 0xef, 0x3b, 0xb6, 0x56, 0x26, 0x00, 0xd5, 0x7e, 0x6b,
+	0xe8, 0x3b, 0xb6, 0xf6, 0x81, 0xa8, 0x50, 0x71, 0x3c, 0xaf, 0xe7, 0x69, 0x1f, 0x73, 0xcd, 0xd0,
+	0xed, 0xb8, 0xbd, 0x4b, 0x57, 0xab, 0x18, 0x1d, 0xf8, 0xde, 0xa5, 0x71, 0x17, 0x17, 0x98, 0x78,
+	0x78, 0x9b, 0x21, 0x17, 0xe4, 0x0f, 0xa8, 0x09, 0x8d, 0x2f, 0x68, 0x94, 0x25, 0x58, 0xfc, 0xa9,
+	0xea, 0x6d, 0x06, 0x44, 0x87, 0xcf, 0xc9, 0xca, 0xd0, 0x28, 0x17, 0xcb, 0xc7, 0xde, 0xe8, 0x82,
+	0xb6, 0x09, 0xe3, 0x29, 0x9d, 0x73, 0xdc, 0x3e, 0xad, 0x79, 0x5f, 0x86, 0x4a, 0x2b, 0x87, 0x4e,
+	0x0e, 0x40, 0x6d, 0xa3, 0x58, 0x51, 0xfc, 0x65, 0x4a, 0xe8, 0xe6, 0x1a, 0xba, 0xe9, 0xe4, 0xd0,
+	0xf5, 0x9f, 0xaf, 0xd1, 0x34, 0x4a, 0xe4, 0x08, 0x6a, 0xbe, 0x08, 0x98, 0x90, 0xe3, 0x37, 0xdb,
+	0x0f, 0x73, 0xf6, 0x34, 0xdd, 0xd2, 0x7d, 0x06, 0x3f, 0xda, 0x28, 0xe4, 0x63, 0xd7, 0x68, 0x48,
+	0x7d, 0x2d, 0x7e, 0x46, 0x5e, 0x6f, 0xbc, 0x5c, 0x48, 0x8a, 0x32, 0xc9, 0x7f, 0x97, 0xa4, 0xe3,
+	0xdd, 0xeb, 0x9d, 0x78, 0x2a, 0x26, 0x59, 0x68, 0x8e, 0xe8, 0xcc, 0x9a, 0x2c, 0x53, 0x64, 0x09,
+	0x46, 0x31, 0x32, 0x6b, 0x1c, 0x84, 0x6c, 0x3a, 0x92, 0xd7, 0xcc, 0xad, 0xfc, 0xf8, 0x43, 0x79,
+	0xe9, 0x7b, 0x0f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xc9, 0xe8, 0x56, 0x0b, 0x03, 0x00, 0x00,
 }
diff --git a/protos/utils/configtxutils_test.go b/protos/utils/configtxutils_test.go
index 1ac657bfa4e..7d562d11ad7 100644
--- a/protos/utils/configtxutils_test.go
+++ b/protos/utils/configtxutils_test.go
@@ -43,7 +43,7 @@ func TestBreakOutBlockData(t *testing.T) {
 	if len(payloads) != 1 {
 		t.Errorf("TestBreakOutBlock did not unmarshall to array of 1 payloads\n")
 	}
-	if payloads[0].Header.ChainHeader.Version != 1 || payloads[0].Header.ChainHeader.Type != int32(pb.HeaderType_CONFIGURATION_TRANSACTION) || !bytes.Equal(payloads[0].Header.ChainHeader.ChainID, []byte("test")) {
+	if payloads[0].Header.ChainHeader.Version != 1 || payloads[0].Header.ChainHeader.Type != int32(pb.HeaderType_CONFIGURATION_TRANSACTION) || payloads[0].Header.ChainHeader.ChainID != "test" {
 		t.Errorf("TestBreakOutBlockData payload header is %+v . Expected type is %v and Version == 1\n", payloads[0].Header.ChainHeader, int32(pb.HeaderType_CONFIGURATION_TRANSACTION))
 	}
 	if !bytes.Equal(payloads[0].Data, []byte("test")) {
@@ -98,7 +98,7 @@ func TestBreakOutConfigEnvelopeToConfigItems(t *testing.T) {
 	if len(configItems) != 1 {
 		t.Errorf("TestBreakOutPayloadDataToConfigurationEnvelope did not return array of 1 config item\n")
 	}
-	if configItems[0].Header.Type != int32(pb.HeaderType_CONFIGURATION_TRANSACTION) || !bytes.Equal(configItems[0].Header.ChainID, []byte("test")) {
+	if configItems[0].Header.Type != int32(pb.HeaderType_CONFIGURATION_TRANSACTION) || configItems[0].Header.ChainID != "test" {
 		t.Errorf("TestBreakOutConfigEnvelopeToConfigItems, configItem header does not match original %+v . Expected config_transaction and chainid 'test'\n", configItems[0].Header)
 	}
 	if configItems[0].Type != pb.ConfigurationItem_Orderer || configItems[0].Key != "abc" || !bytes.Equal(configItems[0].Value, []byte("test")) {
@@ -139,7 +139,7 @@ func testChainHeader() *pb.ChainHeader {
 			Seconds: time.Now().Unix(),
 			Nanos:   0,
 		},
-		ChainID: []byte("test"),
+		ChainID: "test",
 	}
 }
 
diff --git a/protos/utils/proputils.go b/protos/utils/proputils.go
index e6428d7440c..8ad49582074 100644
--- a/protos/utils/proputils.go
+++ b/protos/utils/proputils.go
@@ -222,7 +222,7 @@ func CreateChaincodeProposal(txid string, chainID string, cis *peer.ChaincodeInv
 
 	hdr := &common.Header{ChainHeader: &common.ChainHeader{Type: int32(common.HeaderType_ENDORSER_TRANSACTION),
 		TxID:      txid,
-		ChainID:   []byte(chainID),
+		ChainID:   chainID,
 		Extension: ccHdrExtBytes},
 		SignatureHeader: &common.SignatureHeader{Nonce: nonce, Creator: creator}}