diff --git a/common/cauthdsl/policy_test.go b/common/cauthdsl/policy_test.go
index af3894727e7..c1ceb0f7097 100644
--- a/common/cauthdsl/policy_test.go
+++ b/common/cauthdsl/policy_test.go
@@ -59,8 +59,8 @@ func makePolicySource(policyResult bool) []byte {
 
 func addPolicy(manager *policies.ManagerImpl, id string, policy []byte) {
 	manager.BeginConfig()
-	err := manager.ProposeConfig(&cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Policy,
+	err := manager.ProposeConfig(&cb.ConfigItem{
+		Type:  cb.ConfigItem_Policy,
 		Key:   id,
 		Value: policy,
 	})
diff --git a/common/cauthdsl/policy_util.go b/common/cauthdsl/policy_util.go
index 7648050105f..04d8f38e7e0 100644
--- a/common/cauthdsl/policy_util.go
+++ b/common/cauthdsl/policy_util.go
@@ -22,9 +22,9 @@ import (
 )
 
 // TemplatePolicy creates a headerless configuration item representing a policy for a given key
-func TemplatePolicy(key string, sigPolicyEnv *cb.SignaturePolicyEnvelope) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type: cb.ConfigurationItem_Policy,
+func TemplatePolicy(key string, sigPolicyEnv *cb.SignaturePolicyEnvelope) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type: cb.ConfigItem_Policy,
 		Key:  key,
 		Value: utils.MarshalOrPanic(&cb.Policy{
 			Type:   int32(cb.Policy_SIGNATURE),
diff --git a/common/chainconfig/chainconfig.go b/common/chainconfig/chainconfig.go
index 353748b515d..dedce43c476 100644
--- a/common/chainconfig/chainconfig.go
+++ b/common/chainconfig/chainconfig.go
@@ -29,13 +29,13 @@ import (
 
 // Chain config keys
 const (
-	// HashingAlgorithmKey is the cb.ConfigurationItem type key name for the HashingAlgorithm message
+	// HashingAlgorithmKey is the cb.ConfigItem type key name for the HashingAlgorithm message
 	HashingAlgorithmKey = "HashingAlgorithm"
 
-	// BlockDataHashingStructureKey is the cb.ConfigurationItem type key name for the BlockDataHashingStructure message
+	// BlockDataHashingStructureKey is the cb.ConfigItem type key name for the BlockDataHashingStructure message
 	BlockDataHashingStructureKey = "BlockDataHashingStructure"
 
-	// OrdererAddressesKey is the cb.ConfigurationItem type key name for the OrdererAddresses message
+	// OrdererAddressesKey is the cb.ConfigItem type key name for the OrdererAddresses message
 	OrdererAddressesKey = "OrdererAddresses"
 )
 
@@ -47,10 +47,10 @@ const (
 
 var logger = logging.MustGetLogger("common/chainconfig")
 
-// Descriptor stores the common chain configuration
+// Descriptor stores the common chain config
 // It is intended to be the primary accessor of DescriptorImpl
 // It is intended to discourage use of the other exported DescriptorImpl methods
-// which are used for updating the chain configuration by the configtx.Manager
+// which are used for updating the chain config by the configtx.Manager
 type Descriptor interface {
 	// HashingAlgorithm returns the default algorithm to be used when hashing
 	// such as computing block hashes, and CreationPolicy digests
@@ -99,7 +99,7 @@ func (pm *DescriptorImpl) OrdererAddresses() []string {
 	return pm.config.ordererAddresses
 }
 
-// BeginConfig is used to start a new configuration proposal
+// BeginConfig is used to start a new config proposal
 func (pm *DescriptorImpl) BeginConfig() {
 	if pm.pendingConfig != nil {
 		logger.Panicf("Programming error, cannot call begin in the middle of a proposal")
@@ -107,12 +107,12 @@ func (pm *DescriptorImpl) BeginConfig() {
 	pm.pendingConfig = &chainConfig{}
 }
 
-// RollbackConfig is used to abandon a new configuration proposal
+// RollbackConfig is used to abandon a new config proposal
 func (pm *DescriptorImpl) RollbackConfig() {
 	pm.pendingConfig = nil
 }
 
-// CommitConfig is used to commit a new configuration proposal
+// CommitConfig is used to commit a new config proposal
 func (pm *DescriptorImpl) CommitConfig() {
 	if pm.pendingConfig == nil {
 		logger.Panicf("Programming error, cannot call commit without an existing proposal")
@@ -121,10 +121,10 @@ func (pm *DescriptorImpl) CommitConfig() {
 	pm.pendingConfig = nil
 }
 
-// ProposeConfig is used to add new configuration to the configuration proposal
-func (pm *DescriptorImpl) ProposeConfig(configItem *cb.ConfigurationItem) error {
-	if configItem.Type != cb.ConfigurationItem_Chain {
-		return fmt.Errorf("Expected type of ConfigurationItem_Chain, got %v", configItem.Type)
+// ProposeConfig is used to add new config to the config proposal
+func (pm *DescriptorImpl) ProposeConfig(configItem *cb.ConfigItem) error {
+	if configItem.Type != cb.ConfigItem_Chain {
+		return fmt.Errorf("Expected type of ConfigItem_Chain, got %v", configItem.Type)
 	}
 
 	switch configItem.Key {
@@ -157,7 +157,7 @@ func (pm *DescriptorImpl) ProposeConfig(configItem *cb.ConfigurationItem) error
 		}
 		pm.pendingConfig.ordererAddresses = ordererAddresses.Addresses
 	default:
-		logger.Warningf("Uknown Chain configuration item with key %s", configItem.Key)
+		logger.Warningf("Uknown Chain config item with key %s", configItem.Key)
 	}
 	return nil
 }
diff --git a/common/chainconfig/chainconfig_test.go b/common/chainconfig/chainconfig_test.go
index 721042dcbc1..b9954bbcd17 100644
--- a/common/chainconfig/chainconfig_test.go
+++ b/common/chainconfig/chainconfig_test.go
@@ -29,9 +29,9 @@ func init() {
 	logging.SetLevel(logging.DEBUG, "")
 }
 
-func makeInvalidConfigItem(key string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Chain,
+func makeInvalidConfigItem(key string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Chain,
 		Key:   key,
 		Value: []byte("Garbage Data"),
 	}
diff --git a/common/chainconfig/chainconfig_util.go b/common/chainconfig/chainconfig_util.go
index 029349cb7a3..b0879eeffa0 100644
--- a/common/chainconfig/chainconfig_util.go
+++ b/common/chainconfig/chainconfig_util.go
@@ -25,49 +25,49 @@ import (
 
 const defaultHashingAlgorithm = SHA3Shake256
 
-// TemplateHashingAlgorithm creates a headerless configuration item representing the hashing algorithm
-func TemplateHashingAlgorithm(name string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Chain,
+// TemplateHashingAlgorithm creates a headerless config item representing the hashing algorithm
+func TemplateHashingAlgorithm(name string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Chain,
 		Key:   HashingAlgorithmKey,
 		Value: utils.MarshalOrPanic(&cb.HashingAlgorithm{Name: name}),
 	}
 
 }
 
-// DefaultHashingAlgorithm creates a headerless configuration item for the default hashing algorithm
-func DefaultHashingAlgorithm() *cb.ConfigurationItem {
+// DefaultHashingAlgorithm creates a headerless config item for the default hashing algorithm
+func DefaultHashingAlgorithm() *cb.ConfigItem {
 	return TemplateHashingAlgorithm(defaultHashingAlgorithm)
 }
 
 const defaultBlockDataHashingStructureWidth = math.MaxUint32
 
-// TemplateBlockDataHashingStructure creates a headerless configuration item representing the block data hashing structure
-func TemplateBlockDataHashingStructure(width uint32) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Chain,
+// TemplateBlockDataHashingStructure creates a headerless config item representing the block data hashing structure
+func TemplateBlockDataHashingStructure(width uint32) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Chain,
 		Key:   BlockDataHashingStructureKey,
 		Value: utils.MarshalOrPanic(&cb.BlockDataHashingStructure{Width: width}),
 	}
 }
 
-// DefaultBlockDatahashingStructure creates a headerless configuration item for the default block data hashing structure
-func DefaultBlockDataHashingStructure() *cb.ConfigurationItem {
+// DefaultBlockDatahashingStructure creates a headerless config item for the default block data hashing structure
+func DefaultBlockDataHashingStructure() *cb.ConfigItem {
 	return TemplateBlockDataHashingStructure(defaultBlockDataHashingStructureWidth)
 }
 
 var defaultOrdererAddresses = []string{"127.0.0.1:7050"}
 
-// TemplateOrdererAddressess creates a headerless configuration item representing the orderer addresses
-func TemplateOrdererAddresses(addresses []string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Chain,
+// TemplateOrdererAddressess creates a headerless config item representing the orderer addresses
+func TemplateOrdererAddresses(addresses []string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Chain,
 		Key:   OrdererAddressesKey,
 		Value: utils.MarshalOrPanic(&cb.OrdererAddresses{Addresses: addresses}),
 	}
 }
 
-// DefaultOrdererAddresses creates a headerless configuration item for the default orderer addresses
-func DefaultOrdererAddresses() *cb.ConfigurationItem {
+// DefaultOrdererAddresses creates a headerless config item for the default orderer addresses
+func DefaultOrdererAddresses() *cb.ConfigItem {
 	return TemplateOrdererAddresses(defaultOrdererAddresses)
 }
diff --git a/common/configtx/bytes_handler.go b/common/configtx/bytes_handler.go
index cda1df2debd..c268c50e12f 100644
--- a/common/configtx/bytes_handler.go
+++ b/common/configtx/bytes_handler.go
@@ -56,7 +56,7 @@ func (bh *BytesHandler) CommitConfig() {
 }
 
 // ProposeConfig called when config is added to a proposal
-func (bh *BytesHandler) ProposeConfig(configItem *cb.ConfigurationItem) error {
+func (bh *BytesHandler) ProposeConfig(configItem *cb.ConfigItem) error {
 	bh.proposed[configItem.Key] = configItem.Value
 	return nil
 }
diff --git a/common/configtx/filter.go b/common/configtx/filter.go
index b26523ab254..e12b96460ed 100644
--- a/common/configtx/filter.go
+++ b/common/configtx/filter.go
@@ -38,13 +38,13 @@ func NewFilter(manager Manager) filter.Rule {
 
 type configCommitter struct {
 	manager        Manager
-	configEnvelope *cb.ConfigurationEnvelope
+	configEnvelope *cb.ConfigEnvelope
 }
 
 func (cc *configCommitter) Commit() {
 	err := cc.manager.Apply(cc.configEnvelope)
 	if err != nil {
-		panic(fmt.Errorf("Could not apply configuration transaction which should have already been validated: %s", err))
+		panic(fmt.Errorf("Could not apply config transaction which should have already been validated: %s", err))
 	}
 }
 
@@ -65,7 +65,7 @@ func (cf *configFilter) Apply(message *cb.Envelope) (filter.Action, filter.Commi
 		return filter.Forward, nil
 	}
 
-	config := &cb.ConfigurationEnvelope{}
+	config := &cb.ConfigEnvelope{}
 	err = proto.Unmarshal(msgData.Data, config)
 	if err != nil {
 		return filter.Reject, nil
diff --git a/common/configtx/filter_test.go b/common/configtx/filter_test.go
index d75a5be17c8..7cd8ee32a33 100644
--- a/common/configtx/filter_test.go
+++ b/common/configtx/filter_test.go
@@ -31,15 +31,15 @@ import (
 
 type mockConfigManager struct {
 	mockconfigtx.Manager
-	applied *cb.ConfigurationEnvelope
+	applied *cb.ConfigEnvelope
 	err     error
 }
 
-func (mcm *mockConfigManager) Validate(configtx *cb.ConfigurationEnvelope) error {
+func (mcm *mockConfigManager) Validate(configtx *cb.ConfigEnvelope) error {
 	return mcm.err
 }
 
-func (mcm *mockConfigManager) Apply(configtx *cb.ConfigurationEnvelope) error {
+func (mcm *mockConfigManager) Apply(configtx *cb.ConfigEnvelope) error {
 	mcm.applied = configtx
 	return mcm.err
 }
@@ -65,7 +65,7 @@ func TestForwardNonConfig(t *testing.T) {
 func TestAcceptGoodConfig(t *testing.T) {
 	mcm := &mockConfigManager{}
 	cf := NewFilter(mcm)
-	configEnv := &cb.ConfigurationEnvelope{}
+	configEnv := &cb.ConfigEnvelope{}
 	config, _ := proto.Marshal(configEnv)
 	configBytes, _ := proto.Marshal(&cb.Payload{Header: &cb.Header{ChainHeader: &cb.ChainHeader{Type: int32(cb.HeaderType_CONFIGURATION_TRANSACTION)}}, Data: config})
 	configEnvelope := &cb.Envelope{
@@ -73,23 +73,23 @@ func TestAcceptGoodConfig(t *testing.T) {
 	}
 	result, committer := cf.Apply(configEnvelope)
 	if result != filter.Accept {
-		t.Fatal("Should have indicated a good config message causes a reconfiguration")
+		t.Fatal("Should have indicated a good config message causes a reconfig")
 	}
 
 	if !committer.Isolated() {
-		t.Fatal("Configuration transactions should be isolated to their own block")
+		t.Fatal("Config transactions should be isolated to their own block")
 	}
 
 	committer.Commit()
 
 	if !reflect.DeepEqual(mcm.applied, configEnv) {
-		t.Fatalf("Should have applied new configuration on commit got %v and %v", mcm.applied, configEnv)
+		t.Fatalf("Should have applied new config on commit got %v and %v", mcm.applied, configEnv)
 	}
 }
 
 func TestRejectBadConfig(t *testing.T) {
 	cf := NewFilter(&mockConfigManager{err: fmt.Errorf("Error")})
-	config, _ := proto.Marshal(&cb.ConfigurationEnvelope{})
+	config, _ := proto.Marshal(&cb.ConfigEnvelope{})
 	configBytes, _ := proto.Marshal(&cb.Payload{Header: &cb.Header{ChainHeader: &cb.ChainHeader{Type: int32(cb.HeaderType_CONFIGURATION_TRANSACTION)}}, Data: config})
 	result, _ := cf.Apply(&cb.Envelope{
 		Payload: configBytes,
diff --git a/common/configtx/inspector/common_types.go b/common/configtx/inspector/common_types.go
index 9d0bad1ac49..d7f1c523ae5 100644
--- a/common/configtx/inspector/common_types.go
+++ b/common/configtx/inspector/common_types.go
@@ -23,10 +23,10 @@ import (
 	"github.com/golang/protobuf/proto"
 )
 
-func viewableConfigurationEnvelope(name string, configEnvelope *cb.ConfigurationEnvelope) Viewable {
+func viewableConfigEnvelope(name string, configEnvelope *cb.ConfigEnvelope) Viewable {
 	return &field{
 		name:   name,
-		values: []Viewable{viewableConfig("Config", configEnvelope.Config), viewableConfigurationSignatureSlice("Signatures", configEnvelope.Signatures)},
+		values: []Viewable{viewableConfig("Config", configEnvelope.Config), viewableConfigSignatureSlice("Signatures", configEnvelope.Signatures)},
 	}
 }
 
@@ -38,7 +38,7 @@ func viewableConfig(name string, configBytes []byte) Viewable {
 	}
 	values := make([]Viewable, len(config.Items))
 	for i, item := range config.Items {
-		values[i] = viewableConfigurationItem(fmt.Sprintf("Element %d", i), item)
+		values[i] = viewableConfigItem(fmt.Sprintf("Element %d", i), item)
 	}
 	return &field{
 		name:   name,
@@ -46,10 +46,10 @@ func viewableConfig(name string, configBytes []byte) Viewable {
 	}
 }
 
-func viewableConfigurationSignatureSlice(name string, configSigs []*cb.ConfigurationSignature) Viewable {
+func viewableConfigSignatureSlice(name string, configSigs []*cb.ConfigSignature) Viewable {
 	values := make([]Viewable, len(configSigs))
 	for i, item := range configSigs {
-		values[i] = viewableConfigurationSignature(fmt.Sprintf("Element %d", i), item)
+		values[i] = viewableConfigSignature(fmt.Sprintf("Element %d", i), item)
 	}
 	return &field{
 		name:   name,
@@ -57,7 +57,7 @@ func viewableConfigurationSignatureSlice(name string, configSigs []*cb.Configura
 	}
 }
 
-func viewableConfigurationSignature(name string, configSig *cb.ConfigurationSignature) Viewable {
+func viewableConfigSignature(name string, configSig *cb.ConfigSignature) Viewable {
 	children := make([]Viewable, 2)
 
 	sigHeader := &cb.SignatureHeader{}
@@ -83,7 +83,7 @@ func viewableSignatureHeader(name string, sh *cb.SignatureHeader) Viewable {
 	}
 }
 
-func viewableConfigurationItem(name string, ci *cb.ConfigurationItem) Viewable {
+func viewableConfigItem(name string, ci *cb.ConfigItem) Viewable {
 
 	values := make([]Viewable, 6) // Type, Key, Header, LastModified, ModificationPolicy, Value
 	values[0] = viewableString("Type", fmt.Sprintf("%v", ci.Type))
diff --git a/common/configtx/inspector/inspector.go b/common/configtx/inspector/inspector.go
index 340305283c2..162e8fcf9a7 100644
--- a/common/configtx/inspector/inspector.go
+++ b/common/configtx/inspector/inspector.go
@@ -21,11 +21,11 @@ import (
 	cb "github.com/hyperledger/fabric/protos/common"
 )
 
-var typeMap map[cb.ConfigurationItem_ConfigurationType]ConfigurationItemValueLens = make(map[cb.ConfigurationItem_ConfigurationType]ConfigurationItemValueLens)
+var typeMap map[cb.ConfigItem_ConfigType]ConfigItemValueLens = make(map[cb.ConfigItem_ConfigType]ConfigItemValueLens)
 
-type ConfigurationItemValueLens interface {
+type ConfigItemValueLens interface {
 	// Value takes a config item and returns a Viewable version of its value
-	Value(configItem *cb.ConfigurationItem) Viewable
+	Value(configItem *cb.ConfigItem) Viewable
 }
 
 type Viewable interface {
@@ -55,7 +55,7 @@ func printViewable(viewable Viewable, curDepth int) {
 	}
 }
 
-func PrintConfiguration(configEnvelope *cb.ConfigurationEnvelope) {
-	viewable := viewableConfigurationEnvelope("ConfigurationEnvelope", configEnvelope)
+func PrintConfig(configEnvelope *cb.ConfigEnvelope) {
+	viewable := viewableConfigEnvelope("ConfigEnvelope", configEnvelope)
 	printViewable(viewable, 0)
 }
diff --git a/common/configtx/inspector/inspector_test.go b/common/configtx/inspector/inspector_test.go
index eef2cbad9a8..4b850ce6ca9 100644
--- a/common/configtx/inspector/inspector_test.go
+++ b/common/configtx/inspector/inspector_test.go
@@ -28,5 +28,5 @@ func TestFromTemplate(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error creating signed items: %s", err)
 	}
-	PrintConfiguration(configEnvelope)
+	PrintConfig(configEnvelope)
 }
diff --git a/common/configtx/inspector/orderer_types.go b/common/configtx/inspector/orderer_types.go
index fcf818c08ad..485b37c2980 100644
--- a/common/configtx/inspector/orderer_types.go
+++ b/common/configtx/inspector/orderer_types.go
@@ -25,11 +25,11 @@ import (
 )
 
 // This file contains the functions needed to create Viewables for protos defined in
-// the orderer configuration proto
+// the orderer config proto
 
 type ordererTypes struct{}
 
-func (ot ordererTypes) Value(configItem *cb.ConfigurationItem) Viewable {
+func (ot ordererTypes) Value(configItem *cb.ConfigItem) Viewable {
 	name := "Value"
 	switch configItem.Key {
 	case "ConsensusType":
@@ -147,5 +147,5 @@ func viewableBatchSize(name string, batchSize *ab.BatchSize) Viewable {
 }
 
 func init() {
-	typeMap[cb.ConfigurationItem_Orderer] = ordererTypes{}
+	typeMap[cb.ConfigItem_Orderer] = ordererTypes{}
 }
diff --git a/common/configtx/inspector/policy_types.go b/common/configtx/inspector/policy_types.go
index 3ecfb478e83..da67129be79 100644
--- a/common/configtx/inspector/policy_types.go
+++ b/common/configtx/inspector/policy_types.go
@@ -26,7 +26,7 @@ import (
 
 type policyTypes struct{}
 
-func (ot policyTypes) Value(configItem *cb.ConfigurationItem) Viewable {
+func (ot policyTypes) Value(configItem *cb.ConfigItem) Viewable {
 	name := "Value"
 	value := &cb.Policy{}
 	if err := proto.Unmarshal(configItem.Value, value); err != nil {
@@ -59,5 +59,5 @@ func viewableSignaturePolicyEnvelope(name string, signaturePolicyEnvelope *cb.Si
 }
 
 func init() {
-	typeMap[cb.ConfigurationItem_Policy] = policyTypes{}
+	typeMap[cb.ConfigItem_Policy] = policyTypes{}
 }
diff --git a/common/configtx/manager.go b/common/configtx/manager.go
index 742d157ff6c..32efd7b46ad 100644
--- a/common/configtx/manager.go
+++ b/common/configtx/manager.go
@@ -52,28 +52,28 @@ type Handler interface {
 	CommitConfig()
 
 	// ProposeConfig called when config is added to a proposal
-	ProposeConfig(configItem *cb.ConfigurationItem) error
+	ProposeConfig(configItem *cb.ConfigItem) error
 }
 
-// Manager provides a mechanism to query and update configuration
+// Manager provides a mechanism to query and update config
 type Manager interface {
 	Resources
 
-	// Apply attempts to apply a configtx to become the new configuration
-	Apply(configtx *cb.ConfigurationEnvelope) error
+	// Apply attempts to apply a configtx to become the new config
+	Apply(configtx *cb.ConfigEnvelope) error
 
 	// Validate attempts to validate a new configtx against the current config state
-	Validate(configtx *cb.ConfigurationEnvelope) error
+	Validate(configtx *cb.ConfigEnvelope) error
 
 	// ChainID retrieves the chain ID associated with this manager
 	ChainID() string
 
-	// Sequence returns the current sequence number of the configuration
+	// Sequence returns the current sequence number of the config
 	Sequence() uint64
 }
 
-// NewConfigurationItemPolicyKey is the ID of the policy used when no other policy can be resolved, for instance when attempting to create a new config item
-const NewConfigurationItemPolicyKey = "NewConfigurationItemPolicy"
+// NewConfigItemPolicyKey is the ID of the policy used when no other policy can be resolved, for instance when attempting to create a new config item
+const NewConfigItemPolicyKey = "NewConfigItemPolicy"
 
 type acceptAllPolicy struct{}
 
@@ -81,16 +81,16 @@ func (ap *acceptAllPolicy) Evaluate(signedData []*cb.SignedData) error {
 	return nil
 }
 
-type configurationManager struct {
+type configManager struct {
 	Initializer
-	sequence      uint64
-	chainID       string
-	configuration map[cb.ConfigurationItem_ConfigurationType]map[string]*cb.ConfigurationItem
-	callOnUpdate  []func(Manager)
+	sequence     uint64
+	chainID      string
+	config       map[cb.ConfigItem_ConfigType]map[string]*cb.ConfigItem
+	callOnUpdate []func(Manager)
 }
 
-// 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
+// computeChainIDAndSequence returns the chain id and the sequence number for a config envelope
+// or an error if there is a problem with the config envelope
 func computeChainIDAndSequence(config *cb.Config) (string, uint64, error) {
 	if len(config.Items) == 0 {
 		return "", 0, errors.New("Empty envelope unsupported")
@@ -152,10 +152,10 @@ func validateChainID(chainID string) error {
 }
 
 // NewManagerImpl creates a new Manager unless an error is encountered, each element of the callOnUpdate slice
-// is invoked when a new configuration is committed
-func NewManagerImpl(configtx *cb.ConfigurationEnvelope, initializer Initializer, callOnUpdate []func(Manager)) (Manager, error) {
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		if _, ok := initializer.Handlers()[cb.ConfigurationItem_ConfigurationType(ctype)]; !ok {
+// is invoked when a new config is committed
+func NewManagerImpl(configtx *cb.ConfigEnvelope, initializer Initializer, callOnUpdate []func(Manager)) (Manager, error) {
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		if _, ok := initializer.Handlers()[cb.ConfigItem_ConfigType(ctype)]; !ok {
 			return nil, errors.New("Must supply a handler for all known types")
 		}
 	}
@@ -170,12 +170,12 @@ func NewManagerImpl(configtx *cb.ConfigurationEnvelope, initializer Initializer,
 		return nil, fmt.Errorf("Error computing chain ID and sequence: %s", err)
 	}
 
-	cm := &configurationManager{
-		Initializer:   initializer,
-		sequence:      seq - 1,
-		chainID:       chainID,
-		configuration: makeConfigMap(),
-		callOnUpdate:  callOnUpdate,
+	cm := &configManager{
+		Initializer:  initializer,
+		sequence:     seq - 1,
+		chainID:      chainID,
+		config:       makeConfigMap(),
+		callOnUpdate: callOnUpdate,
 	}
 
 	err = cm.Apply(configtx)
@@ -187,39 +187,39 @@ func NewManagerImpl(configtx *cb.ConfigurationEnvelope, initializer Initializer,
 	return cm, nil
 }
 
-func makeConfigMap() map[cb.ConfigurationItem_ConfigurationType]map[string]*cb.ConfigurationItem {
-	configMap := make(map[cb.ConfigurationItem_ConfigurationType]map[string]*cb.ConfigurationItem)
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		configMap[cb.ConfigurationItem_ConfigurationType(ctype)] = make(map[string]*cb.ConfigurationItem)
+func makeConfigMap() map[cb.ConfigItem_ConfigType]map[string]*cb.ConfigItem {
+	configMap := make(map[cb.ConfigItem_ConfigType]map[string]*cb.ConfigItem)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		configMap[cb.ConfigItem_ConfigType(ctype)] = make(map[string]*cb.ConfigItem)
 	}
 	return configMap
 }
 
-func (cm *configurationManager) beginHandlers() {
-	logger.Debugf("Beginning new configuration for chain %s", cm.chainID)
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		cm.Initializer.Handlers()[cb.ConfigurationItem_ConfigurationType(ctype)].BeginConfig()
+func (cm *configManager) beginHandlers() {
+	logger.Debugf("Beginning new config for chain %s", cm.chainID)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		cm.Initializer.Handlers()[cb.ConfigItem_ConfigType(ctype)].BeginConfig()
 	}
 }
 
-func (cm *configurationManager) rollbackHandlers() {
-	logger.Debugf("Rolling back configuration for chain %s", cm.chainID)
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		cm.Initializer.Handlers()[cb.ConfigurationItem_ConfigurationType(ctype)].RollbackConfig()
+func (cm *configManager) rollbackHandlers() {
+	logger.Debugf("Rolling back config for chain %s", cm.chainID)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		cm.Initializer.Handlers()[cb.ConfigItem_ConfigType(ctype)].RollbackConfig()
 	}
 }
 
-func (cm *configurationManager) commitHandlers() {
-	logger.Debugf("Committing configuration for chain %s", cm.chainID)
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		cm.Initializer.Handlers()[cb.ConfigurationItem_ConfigurationType(ctype)].CommitConfig()
+func (cm *configManager) commitHandlers() {
+	logger.Debugf("Committing config for chain %s", cm.chainID)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		cm.Initializer.Handlers()[cb.ConfigItem_ConfigType(ctype)].CommitConfig()
 	}
 	for _, callback := range cm.callOnUpdate {
 		callback(cm)
 	}
 }
 
-func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope) (configMap map[cb.ConfigurationItem_ConfigurationType]map[string]*cb.ConfigurationItem, err error) {
+func (cm *configManager) processConfig(configtx *cb.ConfigEnvelope) (configMap map[cb.ConfigItem_ConfigType]map[string]*cb.ConfigItem, err error) {
 	config, err := UnmarshalConfig(configtx.Config)
 	if err != nil {
 		return nil, err
@@ -245,7 +245,7 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 		return nil, fmt.Errorf("Config is for the wrong chain, expected %s, got %s", cm.chainID, chainID)
 	}
 
-	defaultModificationPolicy, defaultPolicySet := cm.PolicyManager().GetPolicy(NewConfigurationItemPolicyKey)
+	defaultModificationPolicy, defaultPolicySet := cm.PolicyManager().GetPolicy(NewConfigItemPolicyKey)
 
 	// If the default modification policy is not set, it indicates this is an uninitialized chain, so be permissive of modification
 	if !defaultPolicySet {
@@ -258,7 +258,7 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 		// Ensure the config sequence numbers are correct to prevent replay attacks
 		var isModified bool
 
-		if val, ok := cm.configuration[item.Type][item.Key]; ok {
+		if val, ok := cm.config[item.Type][item.Key]; ok {
 			// Config was modified if any of the contents changed
 			isModified = !reflect.DeepEqual(val, item)
 		} else {
@@ -270,7 +270,7 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 
 		// If a config item was modified, its LastModified must be set correctly, and it must satisfy the modification policy
 		if isModified {
-			logger.Debugf("Proposed configuration item of type %v and key %s on chain %s has been modified", item.Type, item.Key, chainID)
+			logger.Debugf("Proposed config item of type %v and key %s on chain %s has been modified", item.Type, item.Key, chainID)
 
 			if item.LastModified != seq {
 				return nil, fmt.Errorf("Key %v for type %v was modified, but its LastModified %d does not equal current configtx Sequence %d", item.Key, item.Type, item.LastModified, seq)
@@ -279,7 +279,7 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 			// Get the modification policy for this config item if one was previously specified
 			// or the default if this is a new config item
 			var policy policies.Policy
-			oldItem, ok := cm.configuration[item.Type][item.Key]
+			oldItem, ok := cm.config[item.Type][item.Key]
 			if ok {
 				policy, _ = cm.PolicyManager().GetPolicy(oldItem.ModificationPolicy)
 			} else {
@@ -293,10 +293,10 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 		}
 
 		// Ensure the type handler agrees the config is well formed
-		logger.Debugf("Proposing configuration item of type %v for key %s on chain %s", item.Type, item.Key, cm.chainID)
+		logger.Debugf("Proposing config item of type %v for key %s on chain %s", item.Type, item.Key, cm.chainID)
 		err = cm.Initializer.Handlers()[item.Type].ProposeConfig(item)
 		if err != nil {
-			return nil, fmt.Errorf("Error proposing configuration item of type %v for key %s on chain %s: %s", item.Type, item.Key, chainID, err)
+			return nil, fmt.Errorf("Error proposing config item of type %v for key %s on chain %s: %s", item.Type, item.Key, chainID, err)
 		}
 
 		// Ensure the same key has not been specified multiple times
@@ -309,13 +309,13 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 	}
 
 	// Ensure that any config items which used to exist still exist, to prevent implicit deletion
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		curMap := cm.configuration[cb.ConfigurationItem_ConfigurationType(ctype)]
-		newMap := configMap[cb.ConfigurationItem_ConfigurationType(ctype)]
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		curMap := cm.config[cb.ConfigItem_ConfigType(ctype)]
+		newMap := configMap[cb.ConfigItem_ConfigType(ctype)]
 		for id := range curMap {
 			_, ok := newMap[id]
 			if !ok {
-				return nil, fmt.Errorf("Missing key %v for type %v in new configuration", id, ctype)
+				return nil, fmt.Errorf("Missing key %v for type %v in new config", id, ctype)
 			}
 
 		}
@@ -326,33 +326,33 @@ func (cm *configurationManager) processConfig(configtx *cb.ConfigurationEnvelope
 }
 
 // Validate attempts to validate a new configtx against the current config state
-func (cm *configurationManager) Validate(configtx *cb.ConfigurationEnvelope) error {
+func (cm *configManager) Validate(configtx *cb.ConfigEnvelope) error {
 	cm.beginHandlers()
 	_, err := cm.processConfig(configtx)
 	cm.rollbackHandlers()
 	return err
 }
 
-// Apply attempts to apply a configtx to become the new configuration
-func (cm *configurationManager) Apply(configtx *cb.ConfigurationEnvelope) error {
+// Apply attempts to apply a configtx to become the new config
+func (cm *configManager) Apply(configtx *cb.ConfigEnvelope) error {
 	cm.beginHandlers()
 	configMap, err := cm.processConfig(configtx)
 	if err != nil {
 		cm.rollbackHandlers()
 		return err
 	}
-	cm.configuration = configMap
+	cm.config = configMap
 	cm.sequence++
 	cm.commitHandlers()
 	return nil
 }
 
 // ChainID retrieves the chain ID associated with this manager
-func (cm *configurationManager) ChainID() string {
+func (cm *configManager) ChainID() string {
 	return cm.chainID
 }
 
-// Sequence returns the current sequence number of the configuration
-func (cm *configurationManager) Sequence() uint64 {
+// Sequence returns the current sequence number of the config
+func (cm *configManager) Sequence() uint64 {
 	return cm.sequence
 }
diff --git a/common/configtx/manager_test.go b/common/configtx/manager_test.go
index 8a9e5173da4..14105fa73d9 100644
--- a/common/configtx/manager_test.go
+++ b/common/configtx/manager_test.go
@@ -30,10 +30,10 @@ import (
 
 var defaultChain = "DefaultChainID"
 
-func defaultHandlers() map[cb.ConfigurationItem_ConfigurationType]Handler {
-	handlers := make(map[cb.ConfigurationItem_ConfigurationType]Handler)
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		handlers[cb.ConfigurationItem_ConfigurationType(ctype)] = NewBytesHandler()
+func defaultHandlers() map[cb.ConfigItem_ConfigType]Handler {
+	handlers := make(map[cb.ConfigItem_ConfigType]Handler)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		handlers[cb.ConfigItem_ConfigType(ctype)] = NewBytesHandler()
 	}
 	return handlers
 }
@@ -66,8 +66,8 @@ func (mpm *mockPolicyManager) GetPolicy(id string) (policies.Policy, bool) {
 	return mpm.policy, (mpm.policy != nil)
 }
 
-func makeConfigurationItem(id, modificationPolicy string, lastModified uint64, data []byte) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
+func makeConfigItem(id, modificationPolicy string, lastModified uint64, data []byte) *cb.ConfigItem {
+	return &cb.ConfigItem{
 		ModificationPolicy: modificationPolicy,
 		LastModified:       lastModified,
 		Key:                id,
@@ -75,7 +75,7 @@ func makeConfigurationItem(id, modificationPolicy string, lastModified uint64, d
 	}
 }
 
-func makeMarshaledConfig(chainID string, configItems ...*cb.ConfigurationItem) []byte {
+func makeMarshaledConfig(chainID string, configItems ...*cb.ConfigItem) []byte {
 	config := &cb.Config{
 		Header: &cb.ChainHeader{ChainID: chainID},
 		Items:  configItems,
@@ -83,11 +83,11 @@ func makeMarshaledConfig(chainID string, configItems ...*cb.ConfigurationItem) [
 	return utils.MarshalOrPanic(config)
 }
 
-// TestOmittedHandler tests that startup fails if not all configuration types have an associated handler
+// TestOmittedHandler tests that startup fails if not all config types have an associated handler
 func TestOmittedHandler(t *testing.T) {
-	_, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
-	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: map[cb.ConfigurationItem_ConfigurationType]Handler{}}, nil)
+	_, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
+	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: map[cb.ConfigItem_ConfigType]Handler{}}, nil)
 
 	if err == nil {
 		t.Fatal("Should have failed to construct manager because handlers were missing")
@@ -100,12 +100,12 @@ func TestCallback(t *testing.T) {
 		calledBack = m
 	}
 
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, []func(Manager){callback})
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
 	if calledBack != cm {
@@ -113,79 +113,79 @@ func TestCallback(t *testing.T) {
 	}
 }
 
-// TestDifferentChainID tests that a configuration update for a different chain ID fails
+// TestDifferentChainID tests that a config update for a different chain ID fails
 func TestDifferentChainID(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig("wrongChain", makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	newConfig := &cb.ConfigEnvelope{
+		Config: makeMarshaledConfig("wrongChain", makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}
 
 	err = cm.Validate(newConfig)
 	if err == nil {
-		t.Error("Should have errored when validating a new configuration set the wrong chain ID")
+		t.Error("Should have errored when validating a new config set the wrong chain ID")
 	}
 
 	err = cm.Apply(newConfig)
 	if err == nil {
-		t.Error("Should have errored when applying a new configuration with the wrong chain ID")
+		t.Error("Should have errored when applying a new config with the wrong chain ID")
 	}
 }
 
 // TestOldConfigReplay tests that resubmitting a config for a sequence number which is not newer is ignored
 func TestOldConfigReplay(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	newConfig := &cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}
 
 	err = cm.Validate(newConfig)
 	if err == nil {
-		t.Error("Should have errored when validating a configuration that is not a newer sequence number")
+		t.Error("Should have errored when validating a config that is not a newer sequence number")
 	}
 
 	err = cm.Apply(newConfig)
 	if err == nil {
-		t.Error("Should have errored when applying a configuration that is not a newer sequence number")
+		t.Error("Should have errored when applying a config that is not a newer sequence number")
 	}
 }
 
-// TestInvalidInitialConfigByStructure tests to make sure that if the config contains corrupted configuration that construction results in error
+// TestInvalidInitialConfigByStructure tests to make sure that if the config contains corrupted config that construction results in error
 func TestInvalidInitialConfigByStructure(t *testing.T) {
-	_, err := NewManagerImpl(&cb.ConfigurationEnvelope{
+	_, err := NewManagerImpl(&cb.ConfigEnvelope{
 		Config: []byte("Corrupted"),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err == nil {
-		t.Fatal("Should have failed to construct configuration by policy")
+		t.Fatal("Should have failed to construct config by policy")
 	}
 }
 
-// TestValidConfigChange tests the happy path of updating a configuration value with no defaultModificationPolicy
+// TestValidConfigChange tests the happy path of updating a config value with no defaultModificationPolicy
 func TestValidConfigChange(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	newConfig := &cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}
 
 	err = cm.Validate(newConfig)
@@ -202,19 +202,19 @@ func TestValidConfigChange(t *testing.T) {
 // TestConfigChangeRegressedSequence tests to make sure that a new config cannot roll back one of the
 // config values while advancing another
 func TestConfigChangeRegressedSequence(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
+	newConfig := &cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 0, []byte("foo")),
-			makeConfigurationItem("bar", "bar", 2, []byte("bar")),
+			makeConfigItem("foo", "foo", 0, []byte("foo")),
+			makeConfigItem("bar", "bar", 2, []byte("bar")),
 		),
 	}
 
@@ -232,19 +232,19 @@ func TestConfigChangeRegressedSequence(t *testing.T) {
 // TestConfigChangeOldSequence tests to make sure that a new config cannot roll back one of the
 // config values while advancing another
 func TestConfigChangeOldSequence(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
+	newConfig := &cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 2, []byte("foo")),
-			makeConfigurationItem("bar", "bar", 1, []byte("bar")),
+			makeConfigItem("foo", "foo", 2, []byte("foo")),
+			makeConfigItem("bar", "bar", 1, []byte("bar")),
 		),
 	}
 
@@ -262,22 +262,22 @@ func TestConfigChangeOldSequence(t *testing.T) {
 // TestConfigImplicitDelete tests to make sure that a new config does not implicitly delete config items
 // by omitting them in the new config
 func TestConfigImplicitDelete(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 0, []byte("foo")),
-			makeConfigurationItem("bar", "bar", 0, []byte("bar")),
+			makeConfigItem("foo", "foo", 0, []byte("foo")),
+			makeConfigItem("bar", "bar", 0, []byte("bar")),
 		),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
+	newConfig := &cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("bar", "bar", 1, []byte("bar")),
+			makeConfigItem("bar", "bar", 1, []byte("bar")),
 		),
 	}
 
@@ -294,15 +294,15 @@ func TestConfigImplicitDelete(t *testing.T) {
 
 // TestEmptyConfigUpdate tests to make sure that an empty config is rejected as an update
 func TestEmptyConfigUpdate(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{}
+	newConfig := &cb.ConfigEnvelope{}
 
 	err = cm.Validate(newConfig)
 	if err == nil {
@@ -315,27 +315,27 @@ func TestEmptyConfigUpdate(t *testing.T) {
 	}
 }
 
-// TestSilentConfigModification tests to make sure that even if a validly signed new configuration for an existing sequence number
+// TestSilentConfigModification tests to make sure that even if a validly signed new config for an existing sequence number
 // is substituted into an otherwise valid new config, that the new config is rejected for attempting a modification without
 // increasing the config item's LastModified
 func TestSilentConfigModification(t *testing.T) {
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 0, []byte("foo")),
-			makeConfigurationItem("bar", "bar", 0, []byte("bar")),
+			makeConfigItem("foo", "foo", 0, []byte("foo")),
+			makeConfigItem("bar", "bar", 0, []byte("bar")),
 		),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
+	newConfig := &cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 0, []byte("different")),
-			makeConfigurationItem("bar", "bar", 1, []byte("bar")),
+			makeConfigItem("foo", "foo", 0, []byte("different")),
+			makeConfigItem("bar", "bar", 1, []byte("bar")),
 		),
 	}
 
@@ -353,12 +353,12 @@ func TestSilentConfigModification(t *testing.T) {
 // TestInvalidInitialConfigByPolicy tests to make sure that if an existing policies does not validate the config that
 // even construction fails
 func TestInvalidInitialConfigByPolicy(t *testing.T) {
-	_, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	_, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{policyResult: fmt.Errorf("err")}}, HandlersVal: defaultHandlers()}, nil)
 
 	if err == nil {
-		t.Fatal("Should have failed to construct configuration by policy")
+		t.Fatal("Should have failed to construct config by policy")
 	}
 }
 
@@ -366,18 +366,18 @@ func TestInvalidInitialConfigByPolicy(t *testing.T) {
 // it is rejected in a config update
 func TestConfigChangeViolatesPolicy(t *testing.T) {
 	mpm := &mockPolicyManager{}
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: mpm, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 	// Set the mock policy to error
 	mpm.policy = &mockPolicy{policyResult: fmt.Errorf("err")}
 
-	newConfig := &cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	newConfig := &cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}
 
 	err = cm.Validate(newConfig)
@@ -395,12 +395,12 @@ func TestConfigChangeViolatesPolicy(t *testing.T) {
 // as the policy may have changed, certs revoked, etc. since the config was adopted.
 func TestUnchangedConfigViolatesPolicy(t *testing.T) {
 	mpm := &mockPolicyManager{}
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: mpm, HandlersVal: defaultHandlers()}, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 	// Set the mock policy to error
 	mpm.policy = &mockPolicy{
@@ -408,11 +408,11 @@ func TestUnchangedConfigViolatesPolicy(t *testing.T) {
 		validReplies: 1,
 	}
 
-	newConfig := &cb.ConfigurationEnvelope{
+	newConfig := &cb.ConfigEnvelope{
 		Config: makeMarshaledConfig(
 			defaultChain,
-			makeConfigurationItem("foo", "foo", 0, []byte("foo")),
-			makeConfigurationItem("bar", "bar", 1, []byte("foo")),
+			makeConfigItem("foo", "foo", 0, []byte("foo")),
+			makeConfigItem("bar", "bar", 1, []byte("foo")),
 		),
 	}
 
@@ -432,7 +432,7 @@ type failHandler struct{}
 func (fh failHandler) BeginConfig()    {}
 func (fh failHandler) RollbackConfig() {}
 func (fh failHandler) CommitConfig()   {}
-func (fh failHandler) ProposeConfig(item *cb.ConfigurationItem) error {
+func (fh failHandler) ProposeConfig(item *cb.ConfigItem) error {
 	return errors.New("Fail")
 }
 
@@ -441,18 +441,18 @@ func (fh failHandler) ProposeConfig(item *cb.ConfigurationItem) error {
 func TestInvalidProposal(t *testing.T) {
 	handlers := defaultHandlers()
 	initializer := &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: handlers}
-	cm, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	cm, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, initializer, nil)
 
 	if err != nil {
-		t.Fatalf("Error constructing configuration manager: %s", err)
+		t.Fatalf("Error constructing config manager: %s", err)
 	}
 
-	initializer.Handlers()[cb.ConfigurationItem_ConfigurationType(0)] = failHandler{}
+	initializer.Handlers()[cb.ConfigItem_ConfigType(0)] = failHandler{}
 
-	newConfig := &cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig(defaultChain, makeConfigurationItem("foo", "foo", 1, []byte("foo"))),
+	newConfig := &cb.ConfigEnvelope{
+		Config: makeMarshaledConfig(defaultChain, makeConfigItem("foo", "foo", 1, []byte("foo"))),
 	}
 
 	err = cm.Validate(newConfig)
@@ -466,28 +466,28 @@ func TestInvalidProposal(t *testing.T) {
 	}
 }
 
-// TestMissingHeader checks that a configuration item with a missing header causes the config to be rejected
+// TestMissingHeader checks that a config item with a missing header causes the config to be rejected
 func TestMissingHeader(t *testing.T) {
 	handlers := defaultHandlers()
-	configItem := makeConfigurationItem("foo", "foo", 0, []byte("foo"))
-	data := utils.MarshalOrPanic(&cb.Config{Items: []*cb.ConfigurationItem{configItem}})
-	_, err := NewManagerImpl(&cb.ConfigurationEnvelope{
+	configItem := makeConfigItem("foo", "foo", 0, []byte("foo"))
+	data := utils.MarshalOrPanic(&cb.Config{Items: []*cb.ConfigItem{configItem}})
+	_, err := NewManagerImpl(&cb.ConfigEnvelope{
 		Config: data,
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: handlers}, nil)
 
 	if err == nil {
-		t.Error("Should have errored creating the configuration manager because of the missing header")
+		t.Error("Should have errored creating the config manager because of the missing header")
 	}
 }
 
-// TestMissingChainID checks that a configuration item with a missing chainID causes the config to be rejected
+// TestMissingChainID checks that a config item with a missing chainID causes the config to be rejected
 func TestMissingChainID(t *testing.T) {
 	handlers := defaultHandlers()
-	_, err := NewManagerImpl(&cb.ConfigurationEnvelope{
-		Config: makeMarshaledConfig("", makeConfigurationItem("foo", "foo", 0, []byte("foo"))),
+	_, err := NewManagerImpl(&cb.ConfigEnvelope{
+		Config: makeMarshaledConfig("", makeConfigItem("foo", "foo", 0, []byte("foo"))),
 	}, &mockconfigtx.Initializer{PolicyManagerVal: &mockPolicyManager{&mockPolicy{}}, HandlersVal: handlers}, nil)
 
 	if err == nil {
-		t.Error("Should have errored creating the configuration manager because of the missing header")
+		t.Error("Should have errored creating the config manager because of the missing header")
 	}
 }
diff --git a/common/configtx/resources.go b/common/configtx/resources.go
index 1dbd3ebc365..dc5ba59ce8b 100644
--- a/common/configtx/resources.go
+++ b/common/configtx/resources.go
@@ -25,9 +25,9 @@ import (
 	cb "github.com/hyperledger/fabric/protos/common"
 )
 
-// Resources is the common set of configuration resources for all chains
+// Resources is the common set of config resources for all chains
 // Depending on whether chain is used at the orderer or at the peer, other
-// configuration resources may be available
+// config resources may be available
 type Resources interface {
 	// PolicyManager returns the policies.Manager for the chain
 	PolicyManager() policies.Manager
@@ -45,11 +45,11 @@ type Resources interface {
 type Initializer interface {
 	Resources
 	// Handlers returns the handlers to be used when initializing the configtx.Manager
-	Handlers() map[cb.ConfigurationItem_ConfigurationType]Handler
+	Handlers() map[cb.ConfigItem_ConfigType]Handler
 }
 
 type resources struct {
-	handlers         map[cb.ConfigurationItem_ConfigurationType]Handler
+	handlers         map[cb.ConfigItem_ConfigType]Handler
 	policyManager    policies.Manager
 	chainConfig      chainconfig.Descriptor
 	mspConfigHandler *mspmgmt.MSPConfigHandler
@@ -71,7 +71,7 @@ func (r *resources) MSPManager() msp.MSPManager {
 }
 
 // Handlers returns the handlers to be used when initializing the configtx.Manager
-func (r *resources) Handlers() map[cb.ConfigurationItem_ConfigurationType]Handler {
+func (r *resources) Handlers() map[cb.ConfigItem_ConfigType]Handler {
 	return r.handlers
 }
 
@@ -93,16 +93,16 @@ func NewInitializer() Initializer {
 
 	policyManager := policies.NewManagerImpl(policyProviderMap)
 	chainConfig := chainconfig.NewDescriptorImpl()
-	handlers := make(map[cb.ConfigurationItem_ConfigurationType]Handler)
+	handlers := make(map[cb.ConfigItem_ConfigType]Handler)
 
-	for ctype := range cb.ConfigurationItem_ConfigurationType_name {
-		rtype := cb.ConfigurationItem_ConfigurationType(ctype)
+	for ctype := range cb.ConfigItem_ConfigType_name {
+		rtype := cb.ConfigItem_ConfigType(ctype)
 		switch rtype {
-		case cb.ConfigurationItem_Chain:
+		case cb.ConfigItem_Chain:
 			handlers[rtype] = chainConfig
-		case cb.ConfigurationItem_Policy:
+		case cb.ConfigItem_Policy:
 			handlers[rtype] = policyManager
-		case cb.ConfigurationItem_MSP:
+		case cb.ConfigItem_MSP:
 			handlers[rtype] = mspConfigHandler
 		default:
 			handlers[rtype] = NewBytesHandler()
diff --git a/common/configtx/template.go b/common/configtx/template.go
index 9236b62db10..55c13698a53 100644
--- a/common/configtx/template.go
+++ b/common/configtx/template.go
@@ -34,23 +34,23 @@ const (
 	epoch             = 0
 )
 
-// Template can be used to faciliate creation of configuration transactions
+// Template can be used to faciliate creation of config transactions
 type Template interface {
-	// Items returns a set of ConfigurationEnvelopes for the given chainID
-	Envelope(chainID string) (*cb.ConfigurationEnvelope, error)
+	// Items returns a set of ConfigEnvelopes for the given chainID
+	Envelope(chainID string) (*cb.ConfigEnvelope, error)
 }
 
 type simpleTemplate struct {
-	items []*cb.ConfigurationItem
+	items []*cb.ConfigItem
 }
 
 // NewSimpleTemplate creates a Template using the supplied items
-func NewSimpleTemplate(items ...*cb.ConfigurationItem) Template {
+func NewSimpleTemplate(items ...*cb.ConfigItem) Template {
 	return &simpleTemplate{items: items}
 }
 
-// Items returns a set of ConfigurationEnvelopes for the given chainID, and errors only on marshaling errors
-func (st *simpleTemplate) Envelope(chainID string) (*cb.ConfigurationEnvelope, error) {
+// Items returns a set of ConfigEnvelopes for the given chainID, and errors only on marshaling errors
+func (st *simpleTemplate) Envelope(chainID string) (*cb.ConfigEnvelope, error) {
 	marshaledConfig, err := proto.Marshal(&cb.Config{
 		Header: &cb.ChainHeader{
 			ChainID: chainID,
@@ -62,7 +62,7 @@ func (st *simpleTemplate) Envelope(chainID string) (*cb.ConfigurationEnvelope, e
 		return nil, err
 	}
 
-	return &cb.ConfigurationEnvelope{Config: marshaledConfig}, nil
+	return &cb.ConfigEnvelope{Config: marshaledConfig}, nil
 }
 
 type compositeTemplate struct {
@@ -74,9 +74,9 @@ func NewCompositeTemplate(templates ...Template) Template {
 	return &compositeTemplate{templates: templates}
 }
 
-// Items returns a set of ConfigurationEnvelopes for the given chainID, and errors only on marshaling errors
-func (ct *compositeTemplate) Envelope(chainID string) (*cb.ConfigurationEnvelope, error) {
-	items := make([][]*cb.ConfigurationItem, len(ct.templates))
+// Items returns a set of ConfigEnvelopes for the given chainID, and errors only on marshaling errors
+func (ct *compositeTemplate) Envelope(chainID string) (*cb.ConfigEnvelope, error) {
+	items := make([][]*cb.ConfigItem, len(ct.templates))
 	for i := range ct.templates {
 		configEnv, err := ct.templates[i].Envelope(chainID)
 		if err != nil {
@@ -93,11 +93,11 @@ func (ct *compositeTemplate) Envelope(chainID string) (*cb.ConfigurationEnvelope
 }
 
 // NewChainCreationTemplate takes a CreationPolicy and a Template to produce a Template which outputs an appropriately
-// constructed list of ConfigurationEnvelope.  Note, using this Template in
+// constructed list of ConfigEnvelope.  Note, using this Template in
 // a CompositeTemplate will invalidate the CreationPolicy
 func NewChainCreationTemplate(creationPolicy string, template Template) Template {
-	creationPolicyTemplate := NewSimpleTemplate(&cb.ConfigurationItem{
-		Type: cb.ConfigurationItem_Orderer,
+	creationPolicyTemplate := NewSimpleTemplate(&cb.ConfigItem{
+		Type: cb.ConfigItem_Orderer,
 		Key:  CreationPolicyKey,
 		Value: utils.MarshalOrPanic(&ab.CreationPolicy{
 			Policy: creationPolicy,
@@ -107,13 +107,13 @@ func NewChainCreationTemplate(creationPolicy string, template Template) Template
 	return NewCompositeTemplate(creationPolicyTemplate, template)
 }
 
-// join takes a number of []*cb.ConfigurationItems and produces their concatenation
-func join(sets ...[]*cb.ConfigurationItem) []*cb.ConfigurationItem {
+// join takes a number of []*cb.ConfigItems and produces their concatenation
+func join(sets ...[]*cb.ConfigItem) []*cb.ConfigItem {
 	total := 0
 	for _, set := range sets {
 		total += len(set)
 	}
-	result := make([]*cb.ConfigurationItem, total)
+	result := make([]*cb.ConfigItem, total)
 	last := 0
 	for _, set := range sets {
 		for i := range set {
@@ -138,7 +138,7 @@ func MakeChainCreationTransaction(creationPolicy string, chainID string, signer
 		return nil, err
 	}
 
-	newConfigEnv.Signatures = []*cb.ConfigurationSignature{&cb.ConfigurationSignature{
+	newConfigEnv.Signatures = []*cb.ConfigSignature{&cb.ConfigSignature{
 		SignatureHeader: utils.MarshalOrPanic(utils.MakeSignatureHeader(sSigner, utils.CreateNonceOrPanic())),
 	}}
 	newConfigEnv.Signatures[0].Signature, err = signer.Sign(util.ConcatenateBytes(newConfigEnv.Signatures[0].SignatureHeader, newConfigEnv.Config))
diff --git a/common/configtx/template_test.go b/common/configtx/template_test.go
index 2b6f9b51877..69b10709e99 100644
--- a/common/configtx/template_test.go
+++ b/common/configtx/template_test.go
@@ -49,8 +49,8 @@ func verifyItemsResult(t *testing.T, template Template, count int) {
 
 func TestSimpleTemplate(t *testing.T) {
 	simple := NewSimpleTemplate(
-		&cb.ConfigurationItem{Value: []byte("0")},
-		&cb.ConfigurationItem{Value: []byte("1")},
+		&cb.ConfigItem{Value: []byte("0")},
+		&cb.ConfigItem{Value: []byte("1")},
 	)
 	verifyItemsResult(t, simple, 2)
 }
@@ -58,11 +58,11 @@ func TestSimpleTemplate(t *testing.T) {
 func TestCompositeTemplate(t *testing.T) {
 	composite := NewCompositeTemplate(
 		NewSimpleTemplate(
-			&cb.ConfigurationItem{Value: []byte("0")},
-			&cb.ConfigurationItem{Value: []byte("1")},
+			&cb.ConfigItem{Value: []byte("0")},
+			&cb.ConfigItem{Value: []byte("1")},
 		),
 		NewSimpleTemplate(
-			&cb.ConfigurationItem{Value: []byte("2")},
+			&cb.ConfigItem{Value: []byte("2")},
 		),
 	)
 
@@ -71,8 +71,8 @@ func TestCompositeTemplate(t *testing.T) {
 
 func TestNewChainTemplate(t *testing.T) {
 	simple := NewSimpleTemplate(
-		&cb.ConfigurationItem{Value: []byte("1")},
-		&cb.ConfigurationItem{Value: []byte("2")},
+		&cb.ConfigItem{Value: []byte("1")},
+		&cb.ConfigItem{Value: []byte("2")},
 	)
 
 	creationPolicy := "Test"
@@ -81,7 +81,7 @@ func TestNewChainTemplate(t *testing.T) {
 	newChainID := "foo"
 	configEnv, err := nct.Envelope(newChainID)
 	if err != nil {
-		t.Fatalf("Error creation a chain creation configuration")
+		t.Fatalf("Error creation a chain creation config")
 	}
 
 	config, err := UnmarshalConfig(configEnv.Config)
diff --git a/common/configtx/test/helper.go b/common/configtx/test/helper.go
index a470d194f6a..e1793538fc8 100644
--- a/common/configtx/test/helper.go
+++ b/common/configtx/test/helper.go
@@ -78,7 +78,7 @@ func resolveName(name string) (string, []byte) {
 func readTemplate(name string) configtx.Template {
 	_, data := resolveName(name)
 
-	templateProto := &cb.ConfigurationTemplate{}
+	templateProto := &cb.ConfigTemplate{}
 	err := proto.Unmarshal(data, templateProto)
 	if err != nil {
 		panic(err)
@@ -87,16 +87,16 @@ func readTemplate(name string) configtx.Template {
 	return configtx.NewSimpleTemplate(templateProto.Items...)
 }
 
-// WriteTemplate takes an output file and set of config items and writes them to that file as a marshaled ConfigurationTemplate
-func WriteTemplate(name string, items ...*cb.ConfigurationItem) {
+// WriteTemplate takes an output file and set of config items and writes them to that file as a marshaled ConfigTemplate
+func WriteTemplate(name string, items ...*cb.ConfigItem) {
 	path, _ := resolveName(name)
 
-	logger.Debugf("Encoding configuration template")
-	outputData := utils.MarshalOrPanic(&cb.ConfigurationTemplate{
+	logger.Debugf("Encoding config template")
+	outputData := utils.MarshalOrPanic(&cb.ConfigTemplate{
 		Items: items,
 	})
 
-	logger.Debugf("Writing configuration to %s", path)
+	logger.Debugf("Writing config to %s", path)
 	ioutil.WriteFile(path, outputData, 0644)
 }
 
diff --git a/common/configtx/test/orderer.template b/common/configtx/test/orderer.template
index eb89bd5e0fa..18f3f701439 100644
Binary files a/common/configtx/test/orderer.template and b/common/configtx/test/orderer.template differ
diff --git a/common/configtx/util.go b/common/configtx/util.go
index 0dee711bb02..22209b3246a 100644
--- a/common/configtx/util.go
+++ b/common/configtx/util.go
@@ -35,9 +35,9 @@ func UnmarshalConfig(data []byte) (*cb.Config, error) {
 	return config, nil
 }
 
-// UnmarshalConfigurationEnvelope attempts to unmarshal bytes to a *cb.ConfigurationEnvelope
-func UnmarshalConfigurationEnvelope(data []byte) (*cb.ConfigurationEnvelope, error) {
-	configEnv := &cb.ConfigurationEnvelope{}
+// UnmarshalConfigEnvelope attempts to unmarshal bytes to a *cb.ConfigEnvelope
+func UnmarshalConfigEnvelope(data []byte) (*cb.ConfigEnvelope, error) {
+	configEnv := &cb.ConfigEnvelope{}
 	err := proto.Unmarshal(data, configEnv)
 	if err != nil {
 		return nil, err
@@ -45,9 +45,9 @@ func UnmarshalConfigurationEnvelope(data []byte) (*cb.ConfigurationEnvelope, err
 	return configEnv, nil
 }
 
-func ConfigurationEnvelopeFromBlock(block *cb.Block) (*cb.ConfigurationEnvelope, error) {
+func ConfigEnvelopeFromBlock(block *cb.Block) (*cb.ConfigEnvelope, error) {
 	if block.Data == nil || len(block.Data.Data) != 1 {
-		return nil, fmt.Errorf("Not a configuration block, must contain exactly one tx")
+		return nil, fmt.Errorf("Not a config block, must contain exactly one tx")
 	}
 
 	envelope, err := utils.UnmarshalEnvelope(block.Data.Data[0])
@@ -60,5 +60,5 @@ func ConfigurationEnvelopeFromBlock(block *cb.Block) (*cb.ConfigurationEnvelope,
 		return nil, err
 	}
 
-	return UnmarshalConfigurationEnvelope(payload.Data)
+	return UnmarshalConfigEnvelope(payload.Data)
 }
diff --git a/common/genesis/genesis.go b/common/genesis/genesis.go
index 2107418ff79..9c567a550f3 100644
--- a/common/genesis/genesis.go
+++ b/common/genesis/genesis.go
@@ -58,7 +58,7 @@ func (f *factory) Block(chainID string) (*cb.Block, error) {
 	block.Data = &cb.BlockData{Data: [][]byte{utils.MarshalOrPanic(envelope)}}
 	block.Header.DataHash = block.Data.Hash()
 	block.Metadata.Metadata[cb.BlockMetadataIndex_LAST_CONFIGURATION] = utils.MarshalOrPanic(&cb.Metadata{
-		Value: utils.MarshalOrPanic(&cb.LastConfiguration{Index: 0}),
+		Value: utils.MarshalOrPanic(&cb.LastConfig{Index: 0}),
 	})
 	return block, nil
 }
diff --git a/common/genesis/genesis_test.go b/common/genesis/genesis_test.go
index ee256701a90..3fe5bb16b4f 100644
--- a/common/genesis/genesis_test.go
+++ b/common/genesis/genesis_test.go
@@ -24,7 +24,7 @@ import (
 )
 
 func TestSanity(t *testing.T) {
-	impl := NewFactoryImpl(configtx.NewSimpleTemplate(&cb.ConfigurationItem{}))
+	impl := NewFactoryImpl(configtx.NewSimpleTemplate(&cb.ConfigItem{}))
 	_, err := impl.Block("TestChainID")
 	if err != nil {
 		t.Fatalf("Basic sanity fails")
diff --git a/common/mocks/configtx/configtx.go b/common/mocks/configtx/configtx.go
index 03438ba4f50..67c2d2e307b 100644
--- a/common/mocks/configtx/configtx.go
+++ b/common/mocks/configtx/configtx.go
@@ -26,7 +26,7 @@ import (
 
 type Initializer struct {
 	// HandlersVal is returned as the result of Handlers()
-	HandlersVal map[cb.ConfigurationItem_ConfigurationType]configtx.Handler
+	HandlersVal map[cb.ConfigItem_ConfigType]configtx.Handler
 
 	// PolicyManagerVal is returned as the result of PolicyManager()
 	PolicyManagerVal policies.Manager
@@ -39,7 +39,7 @@ type Initializer struct {
 }
 
 // Returns the HandlersVal
-func (i *Initializer) Handlers() map[cb.ConfigurationItem_ConfigurationType]configtx.Handler {
+func (i *Initializer) Handlers() map[cb.ConfigItem_ConfigType]configtx.Handler {
 	return i.HandlersVal
 }
 
@@ -80,12 +80,12 @@ func (cm *Manager) Sequence() uint64 {
 }
 
 // Apply panics
-func (cm *Manager) Apply(configtx *cb.ConfigurationEnvelope) error {
+func (cm *Manager) Apply(configtx *cb.ConfigEnvelope) error {
 	panic("Unimplemented")
 }
 
 // Validate panics
-func (cm *Manager) Validate(configtx *cb.ConfigurationEnvelope) error {
+func (cm *Manager) Validate(configtx *cb.ConfigEnvelope) error {
 	panic("Unimplemented")
 
 }
diff --git a/common/policies/policy.go b/common/policies/policy.go
index 2dca80bc1b4..868a4f57162 100644
--- a/common/policies/policy.go
+++ b/common/policies/policy.go
@@ -84,7 +84,7 @@ func (pm *ManagerImpl) GetPolicy(id string) (Policy, bool) {
 	return policy, true
 }
 
-// BeginConfig is used to start a new configuration proposal
+// BeginConfig is used to start a new config proposal
 func (pm *ManagerImpl) BeginConfig() {
 	if pm.pendingPolicies != nil {
 		logger.Panicf("Programming error, cannot call begin in the middle of a proposal")
@@ -92,12 +92,12 @@ func (pm *ManagerImpl) BeginConfig() {
 	pm.pendingPolicies = make(map[string]Policy)
 }
 
-// RollbackConfig is used to abandon a new configuration proposal
+// RollbackConfig is used to abandon a new config proposal
 func (pm *ManagerImpl) RollbackConfig() {
 	pm.pendingPolicies = nil
 }
 
-// CommitConfig is used to commit a new configuration proposal
+// CommitConfig is used to commit a new config proposal
 func (pm *ManagerImpl) CommitConfig() {
 	if pm.pendingPolicies == nil {
 		logger.Panicf("Programming error, cannot call commit without an existing proposal")
@@ -106,10 +106,10 @@ func (pm *ManagerImpl) CommitConfig() {
 	pm.pendingPolicies = nil
 }
 
-// ProposeConfig is used to add new configuration to the configuration proposal
-func (pm *ManagerImpl) ProposeConfig(configItem *cb.ConfigurationItem) error {
-	if configItem.Type != cb.ConfigurationItem_Policy {
-		return fmt.Errorf("Expected type of ConfigurationItem_Policy, got %v", configItem.Type)
+// ProposeConfig is used to add new config to the configuration proposal
+func (pm *ManagerImpl) ProposeConfig(configItem *cb.ConfigItem) error {
+	if configItem.Type != cb.ConfigItem_Policy {
+		return fmt.Errorf("Expected type of ConfigItem_Policy, got %v", configItem.Type)
 	}
 
 	policy := &cb.Policy{}
diff --git a/core/committer/txvalidator/validator.go b/core/committer/txvalidator/validator.go
index 79a1d5c82f7..c843ced2488 100644
--- a/core/committer/txvalidator/validator.go
+++ b/core/committer/txvalidator/validator.go
@@ -42,8 +42,8 @@ type Support interface {
 	// MSPManager returns the MSP manager for this chain
 	MSPManager() msp.MSPManager
 
-	// Apply attempts to apply a configtx to become the new configuration
-	Apply(configtx *common.ConfigurationEnvelope) error
+	// Apply attempts to apply a configtx to become the new config
+	Apply(configtx *common.ConfigEnvelope) error
 }
 
 //Validator interface which defines API to validate block transactions
@@ -142,15 +142,15 @@ func (v *txValidator) Validate(block *common.Block) error {
 						continue
 					}
 				} else if common.HeaderType(payload.Header.ChainHeader.Type) == common.HeaderType_CONFIGURATION_TRANSACTION {
-					configEnvelope, err := configtx.UnmarshalConfigurationEnvelope(payload.Data)
+					configEnvelope, err := configtx.UnmarshalConfigEnvelope(payload.Data)
 					if err != nil {
-						err := fmt.Errorf("Error unmarshaling configuration which passed initial validity checks: %s", err)
+						err := fmt.Errorf("Error unmarshaling config which passed initial validity checks: %s", err)
 						logger.Critical(err)
 						return err
 					}
 
 					if err := v.support.Apply(configEnvelope); err != nil {
-						err := fmt.Errorf("Error validating configuration which passed initial validity checks: %s", err)
+						err := fmt.Errorf("Error validating config which passed initial validity checks: %s", err)
 						logger.Critical(err)
 						return err
 					}
diff --git a/core/mocks/txvalidator/support.go b/core/mocks/txvalidator/support.go
index 64e5823ae17..770c9de926a 100644
--- a/core/mocks/txvalidator/support.go
+++ b/core/mocks/txvalidator/support.go
@@ -39,6 +39,6 @@ func (ms *Support) MSPManager() msp.MSPManager {
 }
 
 // Apply returns ApplyVal
-func (ms *Support) Apply(configtx *common.ConfigurationEnvelope) error {
+func (ms *Support) Apply(configtx *common.ConfigEnvelope) error {
 	return ms.ApplyVal
 }
diff --git a/core/peer/peer.go b/core/peer/peer.go
index 1d91e1db080..9329e9cf593 100644
--- a/core/peer/peer.go
+++ b/core/peer/peer.go
@@ -95,7 +95,7 @@ func Initialize(init func(string)) {
 			continue
 		}
 		if cb, err = getCurrConfigBlockFromLedger(ledger); err != nil {
-			peerLogger.Warningf("Failed to find configuration block on ledger %s(%s)", cid, err)
+			peerLogger.Warningf("Failed to find config block on ledger %s(%s)", cid, err)
 			peerLogger.Debug("Error while looking for config block on ledger %s with message %s. We continue to the next ledger rather than abort.", cid, err)
 			continue
 		}
@@ -120,7 +120,7 @@ func InitChain(cid string) {
 }
 
 func getCurrConfigBlockFromLedger(ledger ledger.PeerLedger) (*common.Block, error) {
-	// Configuration blocks contain only 1 transaction, so we look for 1-tx
+	// Config blocks contain only 1 transaction, so we look for 1-tx
 	// blocks and check the transaction type
 	var envelope *common.Envelope
 	var tx *common.Payload
@@ -148,13 +148,13 @@ func getCurrConfigBlockFromLedger(ledger ledger.PeerLedger) (*common.Block, erro
 		}
 		currBlockNumber = block.Header.Number - 1
 	}
-	return nil, fmt.Errorf("Failed to find configuration block.")
+	return nil, fmt.Errorf("Failed to find config block.")
 }
 
 // createChain creates a new chain object and insert it into the chains
 func createChain(cid string, ledger ledger.PeerLedger, cb *common.Block) error {
 
-	configEnvelope, err := configtx.ConfigurationEnvelopeFromBlock(cb)
+	configEnvelope, err := configtx.ConfigEnvelopeFromBlock(cb)
 	if err != nil {
 		return err
 	}
@@ -171,7 +171,7 @@ func createChain(cid string, ledger ledger.PeerLedger, cb *common.Block) error {
 	}
 
 	configtxInitializer := configtx.NewInitializer()
-	configtxInitializer.Handlers()[common.ConfigurationItem_Peer] = sharedConfigHandler
+	configtxInitializer.Handlers()[common.ConfigItem_Peer] = sharedConfigHandler
 	configtxManager, err := configtx.NewManagerImpl(
 		configEnvelope,
 		configtxInitializer,
@@ -287,10 +287,10 @@ func SetCurrConfigBlock(block *common.Block, cid string) error {
 	defer chains.Unlock()
 	if c, ok := chains.list[cid]; ok {
 		c.cb = block
-		// TODO: Change MSP configuration
+		// TODO: Change MSP config
 		// c.mspmgr.Reconfig(block)
 
-		// TODO: Change gossip configurations
+		// TODO: Change gossip configs
 		return nil
 	}
 	return fmt.Errorf("Chain %s doesn't exist on the peer", cid)
diff --git a/msp/mgmt/config.go b/msp/mgmt/config.go
index 45f0581b4a8..a4034e5e590 100644
--- a/msp/mgmt/config.go
+++ b/msp/mgmt/config.go
@@ -115,7 +115,7 @@ func (bh *MSPConfigHandler) CommitConfig() {
 }
 
 // ProposeConfig called when config is added to a proposal
-func (bh *MSPConfigHandler) ProposeConfig(configItem *common.ConfigurationItem) error {
+func (bh *MSPConfigHandler) ProposeConfig(configItem *common.ConfigItem) error {
 	mspconfig := &mspprotos.MSPConfig{}
 	err := proto.Unmarshal(configItem.Value, mspconfig)
 	if err != nil {
diff --git a/msp/mgmt/mspconfigmgr_test.go b/msp/mgmt/mspconfigmgr_test.go
index 0e4a277e164..b74b921efe8 100644
--- a/msp/mgmt/mspconfigmgr_test.go
+++ b/msp/mgmt/mspconfigmgr_test.go
@@ -34,7 +34,7 @@ func TestMSPConfigManager(t *testing.T) {
 	confBytes, err := proto.Marshal(conf)
 	assert.NoError(t, err)
 
-	ci := &common.ConfigurationItem{Key: "DEFAULT", Value: confBytes}
+	ci := &common.ConfigItem{Key: "DEFAULT", Value: confBytes}
 
 	// test success:
 
@@ -61,6 +61,6 @@ func TestMSPConfigManager(t *testing.T) {
 	mspCH.BeginConfig()
 	err = mspCH.ProposeConfig(ci)
 	assert.NoError(t, err)
-	err = mspCH.ProposeConfig(&common.ConfigurationItem{Type: common.ConfigurationItem_MSP, Key: "DEFAULT", Value: []byte("BARF!")})
+	err = mspCH.ProposeConfig(&common.ConfigItem{Type: common.ConfigItem_MSP, Key: "DEFAULT", Value: []byte("BARF!")})
 	assert.Error(t, err)
 }
diff --git a/msp/template_test.go b/msp/template_test.go
index aba06c6cb73..d028a9494e0 100644
--- a/msp/template_test.go
+++ b/msp/template_test.go
@@ -35,7 +35,7 @@ func TestTemplate(t *testing.T) {
 	assert.NoError(t, err)
 
 	// XXX We should really get the MSP name by inspecting it, but, we know it is DEFAULT so hardcoding for now
-	ci := &common.ConfigurationItem{Type: common.ConfigurationItem_MSP, Key: "DEFAULT", Value: confBytes}
+	ci := &common.ConfigItem{Type: common.ConfigItem_MSP, Key: "DEFAULT", Value: confBytes}
 
 	configtxtest.WriteTemplate(configtxtest.MSPTemplateName, ci)
 }
diff --git a/orderer/common/bootstrap/provisional/provisional.go b/orderer/common/bootstrap/provisional/provisional.go
index 2952f5b0f6b..6ea3eb79a7a 100644
--- a/orderer/common/bootstrap/provisional/provisional.go
+++ b/orderer/common/bootstrap/provisional/provisional.go
@@ -30,12 +30,12 @@ import (
 	ab "github.com/hyperledger/fabric/protos/orderer"
 )
 
-// Generator can either create an orderer genesis block or configuration template
+// Generator can either create an orderer genesis block or config template
 type Generator interface {
 	bootstrap.Helper
 
-	// TemplateItems returns a set of configuration items which can be used to initialize a template
-	TemplateItems() []*cb.ConfigurationItem
+	// TemplateItems returns a set of config items which can be used to initialize a template
+	TemplateItems() []*cb.ConfigItem
 }
 
 const (
@@ -60,14 +60,14 @@ const (
 var DefaultChainCreationPolicyNames = []string{AcceptAllPolicyKey}
 
 type bootstrapper struct {
-	minimalItems     []*cb.ConfigurationItem
-	systemChainItems []*cb.ConfigurationItem
+	minimalItems     []*cb.ConfigItem
+	systemChainItems []*cb.ConfigItem
 }
 
 // New returns a new provisional bootstrap helper.
 func New(conf *config.TopLevel) Generator {
 	bs := &bootstrapper{
-		minimalItems: []*cb.ConfigurationItem{
+		minimalItems: []*cb.ConfigItem{
 			// Chain Config Types
 			chainconfig.DefaultHashingAlgorithm(),
 			chainconfig.DefaultBlockDataHashingStructure(),
@@ -85,11 +85,11 @@ func New(conf *config.TopLevel) Generator {
 			sharedconfig.TemplateEgressPolicyNames([]string{AcceptAllPolicyKey}),
 
 			// Policies
-			cauthdsl.TemplatePolicy(configtx.NewConfigurationItemPolicyKey, cauthdsl.RejectAllPolicy),
+			cauthdsl.TemplatePolicy(configtx.NewConfigItemPolicyKey, cauthdsl.RejectAllPolicy),
 			cauthdsl.TemplatePolicy(AcceptAllPolicyKey, cauthdsl.AcceptAllPolicy),
 		},
 
-		systemChainItems: []*cb.ConfigurationItem{
+		systemChainItems: []*cb.ConfigItem{
 			sharedconfig.TemplateChainCreationPolicyNames(DefaultChainCreationPolicyNames),
 		},
 	}
@@ -105,7 +105,7 @@ func New(conf *config.TopLevel) Generator {
 	return bs
 }
 
-func (bs *bootstrapper) TemplateItems() []*cb.ConfigurationItem {
+func (bs *bootstrapper) TemplateItems() []*cb.ConfigItem {
 	return bs.minimalItems
 }
 
diff --git a/orderer/common/broadcast/broadcast_test.go b/orderer/common/broadcast/broadcast_test.go
index df185e24be7..9e3b892d259 100644
--- a/orderer/common/broadcast/broadcast_test.go
+++ b/orderer/common/broadcast/broadcast_test.go
@@ -99,7 +99,7 @@ func (ms *mockSupport) Enqueue(env *cb.Envelope) bool {
 
 func makeConfigMessage(chainID string) *cb.Envelope {
 	payload := &cb.Payload{
-		Data: utils.MarshalOrPanic(&cb.ConfigurationEnvelope{}),
+		Data: utils.MarshalOrPanic(&cb.ConfigEnvelope{}),
 		Header: &cb.Header{
 			ChainHeader: &cb.ChainHeader{
 				ChainID: chainID,
diff --git a/orderer/common/sharedconfig/sharedconfig.go b/orderer/common/sharedconfig/sharedconfig.go
index db3baff6ac5..0b159ce46e2 100644
--- a/orderer/common/sharedconfig/sharedconfig.go
+++ b/orderer/common/sharedconfig/sharedconfig.go
@@ -31,34 +31,34 @@ import (
 )
 
 const (
-	// ConsensusTypeKey is the cb.ConfigurationItem type key name for the ConsensusType message
+	// ConsensusTypeKey is the cb.ConfigItem type key name for the ConsensusType message
 	ConsensusTypeKey = "ConsensusType"
 
-	// BatchSizeKey is the cb.ConfigurationItem type key name for the BatchSize message
+	// BatchSizeKey is the cb.ConfigItem type key name for the BatchSize message
 	BatchSizeKey = "BatchSize"
 
-	// BatchTimeoutKey is the cb.ConfigurationItem type key name for the BatchTimeout message
+	// BatchTimeoutKey is the cb.ConfigItem type key name for the BatchTimeout message
 	BatchTimeoutKey = "BatchTimeout"
 
-	// ChainCreationPolicyNamesKey is the cb.ConfigurationItem type key name for the ChainCreationPolicyNames message
+	// ChainCreationPolicyNamesKey is the cb.ConfigItem type key name for the ChainCreationPolicyNames message
 	ChainCreationPolicyNamesKey = "ChainCreationPolicyNames"
 
-	// KafkaBrokersKey is the cb.ConfigurationItem type key name for the KafkaBrokers message
+	// KafkaBrokersKey is the cb.ConfigItem type key name for the KafkaBrokers message
 	KafkaBrokersKey = "KafkaBrokers"
 
-	// IngressPolicyNamesKey is the cb.ConfigurationItem type key name for the IngressPolicyNames message
+	// IngressPolicyNamesKey is the cb.ConfigItem type key name for the IngressPolicyNames message
 	IngressPolicyNamesKey = "IngressPolicyNames"
 
-	// EgressPolicyNamesKey is the cb.ConfigurationItem type key name for the EgressPolicyNames message
+	// EgressPolicyNamesKey is the cb.ConfigItem type key name for the EgressPolicyNames message
 	EgressPolicyNamesKey = "EgressPolicyNames"
 )
 
 var logger = logging.MustGetLogger("orderer/common/sharedconfig")
 
-// Manager stores the common shared orderer configuration
+// Manager stores the common shared orderer config
 // It is intended to be the primary accessor of ManagerImpl
 // It is intended to discourage use of the other exported ManagerImpl methods
-// which are used for updating the orderer configuration by the ConfigManager
+// which are used for updating the orderer config by the ConfigManager
 type Manager interface {
 	// ConsensusType returns the configured consensus type
 	ConsensusType() string
@@ -147,7 +147,7 @@ func (pm *ManagerImpl) EgressPolicyNames() []string {
 	return pm.config.egressPolicyNames
 }
 
-// BeginConfig is used to start a new configuration proposal
+// BeginConfig is used to start a new config proposal
 func (pm *ManagerImpl) BeginConfig() {
 	if pm.pendingConfig != nil {
 		logger.Fatalf("Programming error, cannot call begin in the middle of a proposal")
@@ -155,12 +155,12 @@ func (pm *ManagerImpl) BeginConfig() {
 	pm.pendingConfig = &ordererConfig{}
 }
 
-// RollbackConfig is used to abandon a new configuration proposal
+// RollbackConfig is used to abandon a new config proposal
 func (pm *ManagerImpl) RollbackConfig() {
 	pm.pendingConfig = nil
 }
 
-// CommitConfig is used to commit a new configuration proposal
+// CommitConfig is used to commit a new config proposal
 func (pm *ManagerImpl) CommitConfig() {
 	if pm.pendingConfig == nil {
 		logger.Fatalf("Programming error, cannot call commit without an existing proposal")
@@ -172,10 +172,10 @@ func (pm *ManagerImpl) CommitConfig() {
 	}
 }
 
-// ProposeConfig is used to add new configuration to the configuration proposal
-func (pm *ManagerImpl) ProposeConfig(configItem *cb.ConfigurationItem) error {
-	if configItem.Type != cb.ConfigurationItem_Orderer {
-		return fmt.Errorf("Expected type of ConfigurationItem_Orderer, got %v", configItem.Type)
+// ProposeConfig is used to add new config to the config proposal
+func (pm *ManagerImpl) ProposeConfig(configItem *cb.ConfigItem) error {
+	if configItem.Type != cb.ConfigItem_Orderer {
+		return fmt.Errorf("Expected type of ConfigItem_Orderer, got %v", configItem.Type)
 	}
 
 	switch configItem.Key {
@@ -185,7 +185,7 @@ func (pm *ManagerImpl) ProposeConfig(configItem *cb.ConfigurationItem) error {
 			return fmt.Errorf("Unmarshaling error for ConsensusType: %s", err)
 		}
 		if pm.config.consensusType == "" {
-			// The first configuration we accept the consensus type regardless
+			// The first config we accept the consensus type regardless
 			pm.config.consensusType = consensusType.Type
 		}
 		if consensusType.Type != pm.config.consensusType {
diff --git a/orderer/common/sharedconfig/sharedconfig_test.go b/orderer/common/sharedconfig/sharedconfig_test.go
index 9e8bec17d42..776c88a3a82 100644
--- a/orderer/common/sharedconfig/sharedconfig_test.go
+++ b/orderer/common/sharedconfig/sharedconfig_test.go
@@ -35,9 +35,9 @@ func init() {
 	logging.SetLevel(logging.DEBUG, "")
 }
 
-func invalidMessage(key string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+func invalidMessage(key string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   key,
 		Value: []byte("Garbage Data"),
 	}
@@ -135,7 +135,7 @@ func TestBatchSize(t *testing.T) {
 	validAbsoluteMaxBytes := uint32(1000)
 	validPreferredMaxBytes := uint32(500)
 
-	t.Run("ValidConfiguration", func(t *testing.T) {
+	t.Run("ValidConfig", func(t *testing.T) {
 		m := NewManagerImpl()
 		m.BeginConfig()
 		err := m.ProposeConfig(
@@ -154,7 +154,7 @@ func TestBatchSize(t *testing.T) {
 		}
 	})
 
-	t.Run("UnserializableConfiguration", func(t *testing.T) {
+	t.Run("UnserializableConfig", func(t *testing.T) {
 		m := NewManagerImpl()
 		m.BeginConfig()
 		err := m.ProposeConfig(invalidMessage(BatchSizeKey))
@@ -230,7 +230,7 @@ func TestKafkaBrokers(t *testing.T) {
 	invalidMessage := invalidMessage(KafkaBrokersKey)
 	zeroBrokers := TemplateKafkaBrokers([]string{})
 	badList := []string{"127.0.0.1", "foo.bar", "127.0.0.1:-1", "localhost:65536", "foo.bar.:9092", ".127.0.0.1:9092", "-foo.bar:9092"}
-	badMessages := []*cb.ConfigurationItem{}
+	badMessages := []*cb.ConfigItem{}
 	for _, badAddress := range badList {
 		badMessages = append(badMessages, TemplateKafkaBrokers([]string{badAddress}))
 	}
@@ -273,7 +273,7 @@ func TestKafkaBrokers(t *testing.T) {
 	}
 }
 
-func testPolicyNames(m *ManagerImpl, key string, initializer func(val []string) *cb.ConfigurationItem, retriever func() []string, t *testing.T) {
+func testPolicyNames(m *ManagerImpl, key string, initializer func(val []string) *cb.ConfigItem, retriever func() []string, t *testing.T) {
 	endPolicy := []string{"foo", "bar"}
 	invalidMessage := invalidMessage(key)
 	validMessage := initializer(endPolicy)
diff --git a/orderer/common/sharedconfig/sharedconfig_util.go b/orderer/common/sharedconfig/sharedconfig_util.go
index 90c3980298f..d4a5d3e8972 100644
--- a/orderer/common/sharedconfig/sharedconfig_util.go
+++ b/orderer/common/sharedconfig/sharedconfig_util.go
@@ -22,64 +22,64 @@ import (
 	"github.com/hyperledger/fabric/protos/utils"
 )
 
-// TemplateConsensusType creates a headerless configuration item representing the consensus type
-func TemplateConsensusType(typeValue string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateConsensusType creates a headerless config item representing the consensus type
+func TemplateConsensusType(typeValue string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   ConsensusTypeKey,
 		Value: utils.MarshalOrPanic(&ab.ConsensusType{Type: typeValue}),
 	}
 }
 
-// TemplateBatchSize creates a headerless configuration item representing the batch size
-func TemplateBatchSize(batchSize *ab.BatchSize) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateBatchSize creates a headerless config item representing the batch size
+func TemplateBatchSize(batchSize *ab.BatchSize) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   BatchSizeKey,
 		Value: utils.MarshalOrPanic(batchSize),
 	}
 }
 
-// TemplateBatchTimeout creates a headerless configuration item representing the batch timeout
-func TemplateBatchTimeout(batchTimeout string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateBatchTimeout creates a headerless config item representing the batch timeout
+func TemplateBatchTimeout(batchTimeout string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   BatchTimeoutKey,
 		Value: utils.MarshalOrPanic(&ab.BatchTimeout{Timeout: batchTimeout}),
 	}
 }
 
 // TemplateChainCreationPolicyNames creates a headerless configuraiton item representing the chain creation policy names
-func TemplateChainCreationPolicyNames(names []string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+func TemplateChainCreationPolicyNames(names []string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   ChainCreationPolicyNamesKey,
 		Value: utils.MarshalOrPanic(&ab.ChainCreationPolicyNames{Names: names}),
 	}
 }
 
-// TemplateIngressPolicyNames creates a headerless configuration item representing the ingress policy names
-func TemplateIngressPolicyNames(names []string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateIngressPolicyNames creates a headerless config item representing the ingress policy names
+func TemplateIngressPolicyNames(names []string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   IngressPolicyNamesKey,
 		Value: utils.MarshalOrPanic(&ab.IngressPolicyNames{Names: names}),
 	}
 }
 
-// TemplateEgressPolicyNames creates a headerless configuration item representing the egress policy names
-func TemplateEgressPolicyNames(names []string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateEgressPolicyNames creates a headerless config item representing the egress policy names
+func TemplateEgressPolicyNames(names []string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   EgressPolicyNamesKey,
 		Value: utils.MarshalOrPanic(&ab.EgressPolicyNames{Names: names}),
 	}
 }
 
-// TemplateKafkaBrokers creates a headerless configuration item representing the kafka brokers
-func TemplateKafkaBrokers(brokers []string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Orderer,
+// TemplateKafkaBrokers creates a headerless config item representing the kafka brokers
+func TemplateKafkaBrokers(brokers []string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Orderer,
 		Key:   KafkaBrokersKey,
 		Value: utils.MarshalOrPanic(&ab.KafkaBrokers{Brokers: brokers}),
 	}
diff --git a/orderer/multichain/chainsupport.go b/orderer/multichain/chainsupport.go
index fdd1a52551f..dbc88cbf0ab 100644
--- a/orderer/multichain/chainsupport.go
+++ b/orderer/multichain/chainsupport.go
@@ -77,7 +77,7 @@ type ChainSupport interface {
 	// This interface is actually the union with the deliver.Support but because of a golang
 	// limitation https://github.com/golang/go/issues/6977 the methods must be explicitly declared
 
-	// PolicyManager returns the current policy manager as specified by the chain configuration
+	// PolicyManager returns the current policy manager as specified by the chain config
 	PolicyManager() policies.Manager
 
 	// Reader returns the chain Reader for the chain
@@ -89,12 +89,12 @@ type ChainSupport interface {
 
 type chainSupport struct {
 	*ledgerResources
-	chain             Chain
-	cutter            blockcutter.Receiver
-	filters           *filter.RuleSet
-	signer            crypto.LocalSigner
-	lastConfiguration uint64
-	lastConfigSeq     uint64
+	chain         Chain
+	cutter        blockcutter.Receiver
+	filters       *filter.RuleSet
+	signer        crypto.LocalSigner
+	lastConfig    uint64
+	lastConfigSeq uint64
 }
 
 func newChainSupport(
@@ -218,7 +218,7 @@ func (cs *chainSupport) addBlockSignature(block *cb.Block) {
 func (cs *chainSupport) addLastConfigSignature(block *cb.Block) {
 	configSeq := cs.Sequence()
 	if configSeq > cs.lastConfigSeq {
-		cs.lastConfiguration = block.Header.Number
+		cs.lastConfig = block.Header.Number
 		cs.lastConfigSeq = configSeq
 	}
 
@@ -226,7 +226,7 @@ func (cs *chainSupport) addLastConfigSignature(block *cb.Block) {
 		SignatureHeader: utils.MarshalOrPanic(utils.NewSignatureHeaderOrPanic(cs.signer)),
 	}
 
-	lastConfigValue := utils.MarshalOrPanic(&cb.LastConfiguration{Index: cs.lastConfiguration})
+	lastConfigValue := utils.MarshalOrPanic(&cb.LastConfig{Index: cs.lastConfig})
 
 	lastConfigSignature.Signature = utils.SignOrPanic(cs.signer, util.ConcatenateBytes(lastConfigValue, lastConfigSignature.SignatureHeader, block.Header.Bytes()))
 
diff --git a/orderer/multichain/chainsupport_test.go b/orderer/multichain/chainsupport_test.go
index f1ade64335e..7c248948feb 100644
--- a/orderer/multichain/chainsupport_test.go
+++ b/orderer/multichain/chainsupport_test.go
@@ -115,28 +115,28 @@ func TestWriteBlockOrdererMetadata(t *testing.T) {
 
 }
 
-func TestWriteLastConfiguration(t *testing.T) {
+func TestWriteLastConfig(t *testing.T) {
 	ml := &mockLedgerReadWriter{}
 	cm := &mockconfigtx.Manager{}
 	cs := &chainSupport{ledgerResources: &ledgerResources{configResources: &configResources{Manager: cm}, ledger: ml}, signer: &xxxCryptoHelper{}}
 
 	expected := uint64(0)
 
-	if lc := utils.GetLastConfigurationIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(0, nil), nil, nil)); lc != expected {
+	if lc := utils.GetLastConfigIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(0, nil), nil, nil)); lc != expected {
 		t.Fatalf("First block should have config block index of %d, but got %d", expected, lc)
 	}
-	if lc := utils.GetLastConfigurationIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(1, nil), nil, nil)); lc != expected {
+	if lc := utils.GetLastConfigIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(1, nil), nil, nil)); lc != expected {
 		t.Fatalf("Second block should have config block index of %d, but got %d", expected, lc)
 	}
 
 	cm.SequenceVal = 1
 	expected = uint64(2)
 
-	if lc := utils.GetLastConfigurationIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(2, nil), nil, nil)); lc != expected {
+	if lc := utils.GetLastConfigIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(2, nil), nil, nil)); lc != expected {
 		t.Fatalf("Second block should have config block index of %d, but got %d", expected, lc)
 	}
 
-	if lc := utils.GetLastConfigurationIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(3, nil), nil, nil)); lc != expected {
+	if lc := utils.GetLastConfigIndexFromBlockOrPanic(cs.WriteBlock(cb.NewBlock(3, nil), nil, nil)); lc != expected {
 		t.Fatalf("Second block should have config block index of %d, but got %d", expected, lc)
 	}
 
diff --git a/orderer/multichain/manager.go b/orderer/multichain/manager.go
index a2d75ead1aa..e89a641b5ec 100644
--- a/orderer/multichain/manager.go
+++ b/orderer/multichain/manager.go
@@ -53,7 +53,7 @@ type Manager interface {
 	// GetChain retrieves the chain support for a chain (and whether it exists)
 	GetChain(chainID string) (ChainSupport, bool)
 
-	// ProposeChain accepts a configuration transaction for a chain which does not already exists
+	// ProposeChain accepts a config transaction for a chain which does not already exists
 	// The status returned is whether the proposal is accepted for consideration, only after consensus
 	// occurs will the proposal be committed or rejected
 	ProposeChain(env *cb.Envelope) cb.Status
@@ -83,13 +83,13 @@ type multiLedger struct {
 
 func getConfigTx(reader ordererledger.Reader) *cb.Envelope {
 	lastBlock := ordererledger.GetBlock(reader, reader.Height()-1)
-	index, err := utils.GetLastConfigurationIndexFromBlock(lastBlock)
+	index, err := utils.GetLastConfigIndexFromBlock(lastBlock)
 	if err != nil {
-		logger.Panicf("Chain did not have appropriately encoded last configuration in its latest block: %s", err)
+		logger.Panicf("Chain did not have appropriately encoded last config in its latest block: %s", err)
 	}
 	configBlock := ordererledger.GetBlock(reader, index)
 	if configBlock == nil {
-		logger.Panicf("Configuration block does not exist")
+		logger.Panicf("Config block does not exist")
 	}
 
 	return utils.ExtractEnvelopeOrPanic(configBlock, 0)
@@ -112,7 +112,7 @@ func NewManagerImpl(ledgerFactory ordererledger.Factory, consenters map[string]C
 		}
 		configTx := getConfigTx(rl)
 		if configTx == nil {
-			logger.Fatalf("Could not find configuration transaction for chain %s", chainID)
+			logger.Fatalf("Could not find config transaction for chain %s", chainID)
 		}
 		ledgerResources := ml.newLedgerResources(configTx)
 		chainID := ledgerResources.ChainID()
@@ -149,7 +149,7 @@ func NewManagerImpl(ledgerFactory ordererledger.Factory, consenters map[string]C
 	return ml
 }
 
-// ProposeChain accepts a configuration transaction for a chain which does not already exists
+// ProposeChain accepts a config transaction for a chain which does not already exists
 // The status returned is whether the proposal is accepted for consideration, only after consensus
 // occurs will the proposal be committed or rejected
 func (ml *multiLedger) ProposeChain(env *cb.Envelope) cb.Status {
@@ -162,14 +162,14 @@ func (ml *multiLedger) GetChain(chainID string) (ChainSupport, bool) {
 	return cs, ok
 }
 
-func newConfigResources(configEnvelope *cb.ConfigurationEnvelope) (*configResources, error) {
+func newConfigResources(configEnvelope *cb.ConfigEnvelope) (*configResources, error) {
 	sharedConfigManager := sharedconfig.NewManagerImpl()
 	initializer := configtx.NewInitializer()
-	initializer.Handlers()[cb.ConfigurationItem_Orderer] = sharedConfigManager
+	initializer.Handlers()[cb.ConfigItem_Orderer] = sharedConfigManager
 
 	configManager, err := configtx.NewManagerImpl(configEnvelope, initializer, nil)
 	if err != nil {
-		return nil, fmt.Errorf("Error unpacking configuration transaction: %s", err)
+		return nil, fmt.Errorf("Error unpacking config transaction: %s", err)
 	}
 
 	return &configResources{
@@ -185,7 +185,7 @@ func (ml *multiLedger) newLedgerResources(configTx *cb.Envelope) *ledgerResource
 		logger.Fatalf("Error unmarshaling a config transaction payload: %s", err)
 	}
 
-	configEnvelope := &cb.ConfigurationEnvelope{}
+	configEnvelope := &cb.ConfigEnvelope{}
 	err = proto.Unmarshal(payload.Data, configEnvelope)
 	if err != nil {
 		logger.Fatalf("Error unmarshaling a config transaction to config envelope: %s", err)
diff --git a/orderer/multichain/manager_test.go b/orderer/multichain/manager_test.go
index 07efba6353d..7eef95d3ae7 100644
--- a/orderer/multichain/manager_test.go
+++ b/orderer/multichain/manager_test.go
@@ -73,7 +73,7 @@ func TestGetConfigTx(t *testing.T) {
 	rl.Append(ordererledger.CreateNextBlock(rl, []*cb.Envelope{ctx}))
 
 	block := ordererledger.CreateNextBlock(rl, []*cb.Envelope{makeNormalTx(provisional.TestChainID, 7)})
-	block.Metadata.Metadata[cb.BlockMetadataIndex_LAST_CONFIGURATION] = utils.MarshalOrPanic(&cb.Metadata{Value: utils.MarshalOrPanic(&cb.LastConfiguration{Index: 7})})
+	block.Metadata.Metadata[cb.BlockMetadataIndex_LAST_CONFIGURATION] = utils.MarshalOrPanic(&cb.Metadata{Value: utils.MarshalOrPanic(&cb.LastConfig{Index: 7})})
 	rl.Append(block)
 
 	pctx := getConfigTx(rl)
@@ -95,7 +95,7 @@ func TestGetConfigTxFailure(t *testing.T) {
 	rl.Append(ordererledger.CreateNextBlock(rl, []*cb.Envelope{makeNormalTx(provisional.TestChainID, 11)}))
 	defer func() {
 		if recover() == nil {
-			t.Fatalf("Should have panic-ed because there was no configuration tx")
+			t.Fatalf("Should have panic-ed because there was no config tx")
 		}
 	}()
 	getConfigTx(rl)
@@ -221,7 +221,7 @@ func TestNewChain(t *testing.T) {
 	newChainID := "TestNewChain"
 	newChainMessage, err := configtx.MakeChainCreationTransaction(provisional.AcceptAllPolicyKey, newChainID, signer, simpleTemplate)
 	if err != nil {
-		t.Fatalf("Error producing configuration transaction: %s", err)
+		t.Fatalf("Error producing config transaction: %s", err)
 	}
 
 	status := manager.ProposeChain(newChainMessage)
diff --git a/orderer/multichain/systemchain.go b/orderer/multichain/systemchain.go
index f125bfa8aaf..b44239a82d0 100644
--- a/orderer/multichain/systemchain.go
+++ b/orderer/multichain/systemchain.go
@@ -147,7 +147,7 @@ func (sc *systemChain) proposeChain(configTx *cb.Envelope) cb.Status {
 	return cb.Status_SUCCESS
 }
 
-func (sc *systemChain) authorize(configEnvelope *cb.ConfigurationEnvelope) cb.Status {
+func (sc *systemChain) authorize(configEnvelope *cb.ConfigEnvelope) cb.Status {
 	config := &cb.Config{}
 	err := proto.Unmarshal(configEnvelope.Config, config)
 	if err != nil {
@@ -155,9 +155,9 @@ func (sc *systemChain) authorize(configEnvelope *cb.ConfigurationEnvelope) cb.St
 		return cb.Status_BAD_REQUEST
 	}
 
-	var creationConfigItem *cb.ConfigurationItem
+	var creationConfigItem *cb.ConfigItem
 	for _, item := range config.Items {
-		if item.Type == cb.ConfigurationItem_Orderer && item.Key == configtx.CreationPolicyKey {
+		if item.Type == cb.ConfigItem_Orderer && item.Key == configtx.CreationPolicyKey {
 			creationConfigItem = item
 			break
 		}
@@ -171,7 +171,7 @@ func (sc *systemChain) authorize(configEnvelope *cb.ConfigurationEnvelope) cb.St
 	creationPolicy := &ab.CreationPolicy{}
 	err = proto.Unmarshal(creationConfigItem.Value, creationPolicy)
 	if err != nil {
-		logger.Debugf("Failing to validate chain creation because first configuration item could not unmarshal to a CreationPolicy: %s", err)
+		logger.Debugf("Failing to validate chain creation because first config item could not unmarshal to a CreationPolicy: %s", err)
 		return cb.Status_BAD_REQUEST
 	}
 
@@ -210,7 +210,7 @@ func (sc *systemChain) authorize(configEnvelope *cb.ConfigurationEnvelope) cb.St
 }
 
 func (sc *systemChain) inspect(configResources *configResources) cb.Status {
-	// XXX decide what it is that we will require to be the same in the new configuration, and what will be allowed to be different
+	// XXX decide what it is that we will require to be the same in the new config, and what will be allowed to be different
 	// Are all keys allowed? etc.
 
 	return cb.Status_SUCCESS
@@ -225,18 +225,18 @@ func (sc *systemChain) authorizeAndInspect(configTx *cb.Envelope) cb.Status {
 	}
 
 	if payload.Header == nil || payload.Header.ChainHeader == nil || payload.Header.ChainHeader.Type != int32(cb.HeaderType_CONFIGURATION_TRANSACTION) {
-		logger.Debugf("Rejecting chain proposal: Not a configuration transaction: %s", err)
+		logger.Debugf("Rejecting chain proposal: Not a config transaction: %s", err)
 		return cb.Status_BAD_REQUEST
 	}
 
-	configEnvelope := &cb.ConfigurationEnvelope{}
+	configEnvelope := &cb.ConfigEnvelope{}
 	err = proto.Unmarshal(payload.Data, configEnvelope)
 	if err != nil {
 		logger.Debugf("Rejecting chain proposal: Error unmarshalling config envelope from payload: %s", err)
 		return cb.Status_BAD_REQUEST
 	}
 
-	// Make sure that the configuration was signed by the appropriate authorized entities
+	// Make sure that the config was signed by the appropriate authorized entities
 	status := sc.authorize(configEnvelope)
 	if status != cb.Status_SUCCESS {
 		return status
@@ -248,6 +248,6 @@ func (sc *systemChain) authorizeAndInspect(configTx *cb.Envelope) cb.Status {
 		return cb.Status_BAD_REQUEST
 	}
 
-	// Make sure that the configuration does not modify any of the orderer
+	// Make sure that the config does not modify any of the orderer
 	return sc.inspect(configResources)
 }
diff --git a/orderer/multichain/systemchain_test.go b/orderer/multichain/systemchain_test.go
index 3d30e0d1bef..3782f41522a 100644
--- a/orderer/multichain/systemchain_test.go
+++ b/orderer/multichain/systemchain_test.go
@@ -116,9 +116,9 @@ func TestGoodProposal(t *testing.T) {
 	mcc.ms.msc.ChainCreationPolicyNamesVal = []string{provisional.AcceptAllPolicyKey}
 	mcc.ms.mpm.mp = &mockPolicy{}
 
-	chainCreateTx := &cb.ConfigurationItem{
+	chainCreateTx := &cb.ConfigItem{
 		Key:  configtx.CreationPolicyKey,
-		Type: cb.ConfigurationItem_Orderer,
+		Type: cb.ConfigItem_Orderer,
 		Value: utils.MarshalOrPanic(&ab.CreationPolicy{
 			Policy: provisional.AcceptAllPolicyKey,
 		}),
@@ -171,9 +171,9 @@ func TestProposalWithBadPolicy(t *testing.T) {
 	mcc := newMockChainCreator()
 	mcc.ms.mpm.mp = &mockPolicy{}
 
-	chainCreateTx := &cb.ConfigurationItem{
+	chainCreateTx := &cb.ConfigItem{
 		Key:  configtx.CreationPolicyKey,
-		Type: cb.ConfigurationItem_Orderer,
+		Type: cb.ConfigItem_Orderer,
 
 		Value: utils.MarshalOrPanic(&ab.CreationPolicy{
 			Policy: provisional.AcceptAllPolicyKey,
@@ -194,9 +194,9 @@ func TestProposalWithMissingPolicy(t *testing.T) {
 	mcc := newMockChainCreator()
 	mcc.ms.msc.ChainCreationPolicyNamesVal = []string{provisional.AcceptAllPolicyKey}
 
-	chainCreateTx := &cb.ConfigurationItem{
+	chainCreateTx := &cb.ConfigItem{
 		Key:  configtx.CreationPolicyKey,
-		Type: cb.ConfigurationItem_Orderer,
+		Type: cb.ConfigItem_Orderer,
 		Value: utils.MarshalOrPanic(&ab.CreationPolicy{
 			Policy: provisional.AcceptAllPolicyKey,
 		}),
diff --git a/orderer/multichain/util_test.go b/orderer/multichain/util_test.go
index 70fdfb35101..446e15bb66f 100644
--- a/orderer/multichain/util_test.go
+++ b/orderer/multichain/util_test.go
@@ -80,12 +80,12 @@ func (mlw *mockLedgerWriter) Append(blockContents []*cb.Envelope, metadata [][]b
 }
 
 func makeConfigTx(chainID string, i int) *cb.Envelope {
-	return makeConfigTxWithItems(chainID, &cb.ConfigurationItem{
+	return makeConfigTxWithItems(chainID, &cb.ConfigItem{
 		Value: []byte(fmt.Sprintf("%d", i)),
 	})
 }
 
-func makeConfigTxWithItems(chainID string, items ...*cb.ConfigurationItem) *cb.Envelope {
+func makeConfigTxWithItems(chainID string, items ...*cb.ConfigItem) *cb.Envelope {
 	payload := &cb.Payload{
 		Header: &cb.Header{
 			ChainHeader: &cb.ChainHeader{
@@ -94,7 +94,7 @@ func makeConfigTxWithItems(chainID string, items ...*cb.ConfigurationItem) *cb.E
 			},
 			SignatureHeader: &cb.SignatureHeader{},
 		},
-		Data: utils.MarshalOrPanic(&cb.ConfigurationEnvelope{
+		Data: utils.MarshalOrPanic(&cb.ConfigEnvelope{
 			Config: utils.MarshalOrPanic(&cb.Config{
 				Items: items,
 				Header: &cb.ChainHeader{
diff --git a/peer/sharedconfig/sharedconfig.go b/peer/sharedconfig/sharedconfig.go
index dd5e446bf3f..33aa9bae83b 100644
--- a/peer/sharedconfig/sharedconfig.go
+++ b/peer/sharedconfig/sharedconfig.go
@@ -28,16 +28,16 @@ import (
 
 // Peer config keys
 const (
-	// AnchorPeersKey is the cb.ConfigurationItem type key name for the AnchorPeers message
+	// AnchorPeersKey is the cb.ConfigItem type key name for the AnchorPeers message
 	AnchorPeersKey = "AnchorPeers"
 )
 
 var logger = logging.MustGetLogger("peer/sharedconfig")
 
-// Descriptor stores the common peer configuration
+// Descriptor stores the common peer config
 // It is intended to be the primary accessor of DescriptorImpl
 // It is intended to discourage use of the other exported DescriptorImpl methods
-// which are used for updating the chain configuration by the configtx.Manager
+// which are used for updating the chain config by the configtx.Manager
 type Descriptor interface {
 	// AnchorPeers returns the list of anchor peers for the channel
 	AnchorPeers() []*pb.AnchorPeer
@@ -66,24 +66,24 @@ func (di *DescriptorImpl) AnchorPeers() []*pb.AnchorPeer {
 	return di.config.anchorPeers
 }
 
-// BeginConfig is used to start a new configuration proposal
+// BeginConfig is used to start a new config proposal
 func (di *DescriptorImpl) BeginConfig() {
-	logger.Debugf("Beginning a possible new peer shared configuration")
+	logger.Debugf("Beginning a possible new peer shared config")
 	if di.pendingConfig != nil {
 		logger.Panicf("Programming error, cannot call begin in the middle of a proposal")
 	}
 	di.pendingConfig = &sharedConfig{}
 }
 
-// RollbackConfig is used to abandon a new configuration proposal
+// RollbackConfig is used to abandon a new config proposal
 func (di *DescriptorImpl) RollbackConfig() {
-	logger.Debugf("Rolling back proposed peer shared configuration")
+	logger.Debugf("Rolling back proposed peer shared config")
 	di.pendingConfig = nil
 }
 
-// CommitConfig is used to commit a new configuration proposal
+// CommitConfig is used to commit a new config proposal
 func (di *DescriptorImpl) CommitConfig() {
-	logger.Debugf("Committing new peer shared configuration")
+	logger.Debugf("Committing new peer shared config")
 	if di.pendingConfig == nil {
 		logger.Panicf("Programming error, cannot call commit without an existing proposal")
 	}
@@ -91,10 +91,10 @@ func (di *DescriptorImpl) CommitConfig() {
 	di.pendingConfig = nil
 }
 
-// ProposeConfig is used to add new configuration to the configuration proposal
-func (di *DescriptorImpl) ProposeConfig(configItem *cb.ConfigurationItem) error {
-	if configItem.Type != cb.ConfigurationItem_Peer {
-		return fmt.Errorf("Expected type of ConfigurationItem_Peer, got %v", configItem.Type)
+// ProposeConfig is used to add new config to the config proposal
+func (di *DescriptorImpl) ProposeConfig(configItem *cb.ConfigItem) error {
+	if configItem.Type != cb.ConfigItem_Peer {
+		return fmt.Errorf("Expected type of ConfigItem_Peer, got %v", configItem.Type)
 	}
 
 	switch configItem.Key {
@@ -108,7 +108,7 @@ func (di *DescriptorImpl) ProposeConfig(configItem *cb.ConfigurationItem) error
 		}
 		di.pendingConfig.anchorPeers = anchorPeers.AnchorPeers
 	default:
-		logger.Warningf("Uknown Peer configuration item with key %s", configItem.Key)
+		logger.Warningf("Uknown Peer config item with key %s", configItem.Key)
 	}
 	return nil
 }
diff --git a/peer/sharedconfig/sharedconfig_test.go b/peer/sharedconfig/sharedconfig_test.go
index 44b6ae4ee15..3b453154f8b 100644
--- a/peer/sharedconfig/sharedconfig_test.go
+++ b/peer/sharedconfig/sharedconfig_test.go
@@ -30,9 +30,9 @@ func init() {
 	logging.SetLevel(logging.DEBUG, "")
 }
 
-func makeInvalidConfigItem(key string) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Peer,
+func makeInvalidConfigItem(key string) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Peer,
 		Key:   key,
 		Value: []byte("Garbage Data"),
 	}
diff --git a/peer/sharedconfig/sharedconfig_util.go b/peer/sharedconfig/sharedconfig_util.go
index ab109881de1..58d96fa324c 100644
--- a/peer/sharedconfig/sharedconfig_util.go
+++ b/peer/sharedconfig/sharedconfig_util.go
@@ -24,16 +24,16 @@ import (
 
 var defaultAnchorPeers = []*pb.AnchorPeer{}
 
-// TemplateAnchorPeers creates a headerless configuration item representing the anchor peers
-func TemplateAnchorPeers(anchorPeers []*pb.AnchorPeer) *cb.ConfigurationItem {
-	return &cb.ConfigurationItem{
-		Type:  cb.ConfigurationItem_Peer,
+// TemplateAnchorPeers creates a headerless config item representing the anchor peers
+func TemplateAnchorPeers(anchorPeers []*pb.AnchorPeer) *cb.ConfigItem {
+	return &cb.ConfigItem{
+		Type:  cb.ConfigItem_Peer,
 		Key:   AnchorPeersKey,
 		Value: utils.MarshalOrPanic(&pb.AnchorPeers{AnchorPeers: anchorPeers}),
 	}
 }
 
-// DefaultAnchorPeers creates a headerless configuration item for the default orderer addresses
-func DefaultAnchorPeers() *cb.ConfigurationItem {
+// DefaultAnchorPeers creates a headerless config item for the default orderer addresses
+func DefaultAnchorPeers() *cb.ConfigItem {
 	return TemplateAnchorPeers(defaultAnchorPeers)
 }
diff --git a/protos/common/common.pb.go b/protos/common/common.pb.go
index 90dfc482386..30885bd74ca 100644
--- a/protos/common/common.pb.go
+++ b/protos/common/common.pb.go
@@ -14,7 +14,7 @@ It is generated from these files:
 	common/policies.proto
 
 It has these top-level messages:
-	LastConfiguration
+	LastConfig
 	Metadata
 	MetadataSignature
 	Header
@@ -26,11 +26,11 @@ It has these top-level messages:
 	BlockHeader
 	BlockData
 	BlockMetadata
-	ConfigurationEnvelope
-	ConfigurationTemplate
+	ConfigEnvelope
+	ConfigTemplate
 	Config
-	ConfigurationItem
-	ConfigurationSignature
+	ConfigItem
+	ConfigSignature
 	HashingAlgorithm
 	BlockDataHashingStructure
 	OrdererAddresses
@@ -161,15 +161,15 @@ func (x BlockMetadataIndex) String() string {
 }
 func (BlockMetadataIndex) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 
-// LastConfiguration is the encoded value for the Metadata message which is encoded in the LAST_CONFIGURATION block metadata index
-type LastConfiguration struct {
+// LastConfig is the encoded value for the Metadata message which is encoded in the LAST_CONFIGURATION block metadata index
+type LastConfig struct {
 	Index uint64 `protobuf:"varint,1,opt,name=index" json:"index,omitempty"`
 }
 
-func (m *LastConfiguration) Reset()                    { *m = LastConfiguration{} }
-func (m *LastConfiguration) String() string            { return proto.CompactTextString(m) }
-func (*LastConfiguration) ProtoMessage()               {}
-func (*LastConfiguration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (m *LastConfig) Reset()                    { *m = LastConfig{} }
+func (m *LastConfig) String() string            { return proto.CompactTextString(m) }
+func (*LastConfig) ProtoMessage()               {}
+func (*LastConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 // Metadata is a common structure to be used to encode block metadata
 type Metadata struct {
@@ -378,7 +378,7 @@ func (*BlockMetadata) ProtoMessage()               {}
 func (*BlockMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 func init() {
-	proto.RegisterType((*LastConfiguration)(nil), "common.LastConfiguration")
+	proto.RegisterType((*LastConfig)(nil), "common.LastConfig")
 	proto.RegisterType((*Metadata)(nil), "common.Metadata")
 	proto.RegisterType((*MetadataSignature)(nil), "common.MetadataSignature")
 	proto.RegisterType((*Header)(nil), "common.Header")
@@ -398,60 +398,60 @@ func init() {
 func init() { proto.RegisterFile("common/common.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 871 bytes of a gzipped FileDescriptorProto
+	// 865 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
 	0x14, 0xae, 0xe3, 0xfc, 0x34, 0x27, 0xa5, 0xeb, 0x4e, 0xb7, 0xbb, 0xde, 0x8a, 0xd5, 0x56, 0x96,
-	0x40, 0xa5, 0x15, 0x89, 0x28, 0x42, 0x82, 0x4b, 0x27, 0x9e, 0x74, 0xad, 0x4d, 0xed, 0x65, 0xc6,
-	0x59, 0x04, 0xbd, 0xb0, 0x9c, 0x64, 0x9a, 0x58, 0x24, 0x76, 0x64, 0x3b, 0x55, 0x7b, 0xcb, 0x03,
-	0x20, 0x24, 0xb8, 0x42, 0xe2, 0x05, 0x78, 0x12, 0xde, 0x80, 0x17, 0x41, 0xe2, 0x16, 0xcd, 0xd8,
-	0xe3, 0xc6, 0xed, 0x05, 0x57, 0x9d, 0xef, 0x7c, 0xdf, 0x9c, 0xf3, 0x9d, 0x73, 0x26, 0x35, 0x1c,
-	0x4e, 0xe3, 0xd5, 0x2a, 0x8e, 0x7a, 0xf9, 0x9f, 0xee, 0x3a, 0x89, 0xb3, 0x18, 0x35, 0x73, 0x74,
-	0xfc, 0x66, 0x1e, 0xc7, 0xf3, 0x25, 0xeb, 0x89, 0xe8, 0x64, 0x73, 0xd3, 0xcb, 0xc2, 0x15, 0x4b,
-	0xb3, 0x60, 0xb5, 0xce, 0x85, 0xc6, 0x67, 0x70, 0x30, 0x0a, 0xd2, 0x6c, 0x10, 0x47, 0x37, 0xe1,
-	0x7c, 0x93, 0x04, 0x59, 0x18, 0x47, 0xe8, 0x39, 0x34, 0xc2, 0x68, 0xc6, 0xee, 0x74, 0xe5, 0x44,
-	0x39, 0xad, 0x93, 0x1c, 0x18, 0xd7, 0xb0, 0x7b, 0xc5, 0xb2, 0x60, 0x16, 0x64, 0x01, 0x57, 0xdc,
-	0x06, 0xcb, 0x0d, 0x13, 0x8a, 0x3d, 0x92, 0x03, 0xf4, 0x0d, 0x40, 0x1a, 0xce, 0xa3, 0x20, 0xdb,
-	0x24, 0x2c, 0xd5, 0x6b, 0x27, 0xea, 0x69, 0xe7, 0xe2, 0x55, 0xb7, 0x30, 0x26, 0xef, 0x52, 0xa9,
-	0x20, 0x5b, 0x62, 0xe3, 0x1a, 0x0e, 0x9e, 0x08, 0xd0, 0x29, 0x3c, 0x2b, 0x25, 0x6f, 0x59, 0x30,
-	0x63, 0x49, 0x51, 0xef, 0x71, 0x18, 0x7d, 0x0c, 0xed, 0x32, 0xa4, 0xd7, 0x84, 0xe6, 0x21, 0x60,
-	0xfc, 0xa4, 0x40, 0xb3, 0x10, 0x7e, 0x05, 0x9d, 0xe9, 0x22, 0x08, 0xa3, 0xad, 0x74, 0x9d, 0x8b,
-	0x43, 0xe9, 0x71, 0xf0, 0x40, 0x91, 0x6d, 0x1d, 0x32, 0x9f, 0x3a, 0xa9, 0x89, 0xab, 0x2f, 0xe5,
-	0x55, 0x5a, 0xa5, 0x9f, 0x58, 0x34, 0xfe, 0x56, 0xa0, 0xb3, 0x95, 0x1f, 0x21, 0xa8, 0x67, 0xf7,
-	0xeb, 0x7c, 0x82, 0x0d, 0x22, 0xce, 0x48, 0x87, 0xd6, 0x2d, 0x4b, 0xd2, 0x30, 0x8e, 0x44, 0xfa,
-	0x06, 0x91, 0x10, 0x7d, 0x0d, 0xed, 0x72, 0x75, 0xba, 0x2a, 0x4a, 0x1f, 0x77, 0xf3, 0xe5, 0x76,
-	0xe5, 0x72, 0xbb, 0x9e, 0x54, 0x90, 0x07, 0x31, 0xcf, 0x29, 0x3a, 0xb1, 0x2d, 0xbd, 0x7e, 0xa2,
-	0x9c, 0xb6, 0x89, 0x84, 0xc2, 0xc1, 0x9d, 0x6d, 0xe9, 0x0d, 0x11, 0x16, 0x67, 0xbe, 0x58, 0xb6,
-	0x8e, 0xa7, 0x0b, 0xbd, 0x99, 0xaf, 0x5e, 0x00, 0x3e, 0x5e, 0x76, 0x97, 0xb1, 0x48, 0x38, 0x6b,
-	0xe5, 0xe3, 0x2d, 0x03, 0x86, 0x09, 0xcf, 0x1e, 0x75, 0x2f, 0x8a, 0x26, 0x2c, 0xc8, 0x62, 0xb9,
-	0x31, 0x09, 0x79, 0x81, 0x28, 0x8e, 0xa6, 0x72, 0x4b, 0x39, 0x30, 0x30, 0xb4, 0xde, 0x07, 0xf7,
-	0xcb, 0x38, 0x98, 0xa1, 0x4f, 0xa1, 0xb9, 0xd8, 0x5e, 0xce, 0xbe, 0x9c, 0x70, 0x31, 0xd8, 0x82,
-	0xe5, 0xee, 0xf9, 0x6b, 0x29, 0xf2, 0x88, 0xb3, 0xd1, 0x87, 0x5d, 0x1c, 0xdd, 0xb2, 0x65, 0x9c,
-	0xcf, 0x72, 0x9d, 0xa7, 0x94, 0x16, 0x0a, 0xf8, 0x3f, 0x8f, 0xe5, 0x67, 0x05, 0x1a, 0xfd, 0x65,
-	0x3c, 0xfd, 0x11, 0x9d, 0xcb, 0x57, 0xf3, 0xf8, 0x99, 0x08, 0x5a, 0xda, 0x29, 0x3a, 0xfe, 0x04,
-	0xea, 0x96, 0xb4, 0xd3, 0xb9, 0x38, 0xa8, 0x48, 0x39, 0x41, 0x04, 0x8d, 0xbe, 0x78, 0xf8, 0x11,
-	0x15, 0x6b, 0x3c, 0xaa, 0x48, 0x25, 0x49, 0x4a, 0x99, 0xc1, 0xa0, 0xb3, 0x55, 0x10, 0xbd, 0x80,
-	0xa6, 0xb3, 0x59, 0x4d, 0x0a, 0x57, 0x75, 0x52, 0x20, 0x64, 0xc0, 0xde, 0xfb, 0x84, 0xdd, 0x86,
-	0xf1, 0x26, 0x7d, 0x1b, 0xa4, 0x8b, 0xa2, 0xb1, 0x4a, 0x0c, 0x1d, 0xc3, 0x2e, 0x77, 0x21, 0x78,
-	0x55, 0xf0, 0x25, 0x36, 0xde, 0x40, 0xbb, 0x34, 0xcb, 0x87, 0x2b, 0xba, 0x51, 0x4e, 0x54, 0x3e,
-	0x5c, 0x7e, 0x36, 0xce, 0xe1, 0xa3, 0x8a, 0x45, 0x9e, 0xad, 0xec, 0x25, 0x17, 0x96, 0xf8, 0xec,
-	0x4f, 0x05, 0x9a, 0x34, 0x0b, 0xb2, 0x4d, 0x8a, 0x3a, 0xd0, 0x1a, 0x3b, 0xef, 0x1c, 0xf7, 0x3b,
-	0x47, 0xdb, 0x41, 0x7b, 0xd0, 0xa2, 0xe3, 0xc1, 0x00, 0x53, 0xaa, 0xfd, 0xa5, 0x20, 0x0d, 0x3a,
-	0x7d, 0xd3, 0xf2, 0x09, 0xfe, 0x76, 0x8c, 0xa9, 0xa7, 0xfd, 0xa2, 0xa2, 0x7d, 0x68, 0x0f, 0x5d,
-	0xd2, 0xb7, 0x2d, 0x0b, 0x3b, 0xda, 0xaf, 0x02, 0x3b, 0xae, 0xe7, 0x0f, 0xdd, 0xb1, 0x63, 0x69,
-	0xbf, 0xa9, 0xe8, 0x35, 0xe8, 0x85, 0xda, 0xc7, 0x8e, 0x67, 0x7b, 0xdf, 0xfb, 0x9e, 0xeb, 0xfa,
-	0x23, 0x93, 0x5c, 0x62, 0xed, 0x0f, 0x15, 0x1d, 0xc3, 0x91, 0xed, 0x78, 0x98, 0x38, 0xe6, 0xc8,
-	0xa7, 0x98, 0x7c, 0xc0, 0xc4, 0xc7, 0x84, 0xb8, 0x44, 0xfb, 0x47, 0x45, 0x3a, 0x1c, 0xf2, 0x90,
-	0x3d, 0xc0, 0xfe, 0xd8, 0x31, 0x3f, 0x98, 0xf6, 0xc8, 0xec, 0x8f, 0xb0, 0xf6, 0xaf, 0x7a, 0xf6,
-	0xbb, 0x02, 0x90, 0x4f, 0xd7, 0xe3, 0xbf, 0xc2, 0x0e, 0xb4, 0xae, 0x30, 0xa5, 0xe6, 0x25, 0xd6,
-	0x76, 0xd0, 0x6b, 0x78, 0x35, 0x70, 0x9d, 0xa1, 0x7d, 0x39, 0x26, 0xa6, 0x67, 0xbb, 0x8e, 0xef,
-	0x11, 0xd3, 0xa1, 0xe6, 0x80, 0x9f, 0x35, 0x05, 0xbd, 0x00, 0x54, 0xa5, 0x6d, 0x0f, 0x5f, 0x69,
-	0x35, 0xa4, 0xc3, 0x73, 0xec, 0x58, 0x2e, 0xa1, 0x98, 0x54, 0x6e, 0xa8, 0xe8, 0x25, 0x1c, 0xba,
-	0xc4, 0xc2, 0xe4, 0x11, 0x51, 0x47, 0x47, 0x70, 0x60, 0xe1, 0x91, 0xcd, 0x3d, 0x53, 0x8c, 0xdf,
-	0xf9, 0xb6, 0x33, 0x74, 0xb5, 0xc6, 0xd9, 0x04, 0x50, 0x65, 0xec, 0x36, 0xff, 0x67, 0x8c, 0xf6,
-	0x01, 0xa8, 0x7d, 0xe9, 0x98, 0xde, 0x98, 0x60, 0xaa, 0xed, 0x70, 0x1f, 0x23, 0x93, 0x7a, 0x7e,
-	0xc5, 0x8c, 0xa6, 0xf0, 0x6a, 0x5b, 0x55, 0xa8, 0x3f, 0xb4, 0x47, 0x1e, 0x26, 0x5a, 0x8d, 0x37,
-	0x59, 0xd8, 0xd0, 0xd4, 0xfe, 0xe7, 0x3f, 0x9c, 0xcf, 0xc3, 0x6c, 0xb1, 0x99, 0xf0, 0xb7, 0xd8,
-	0x5b, 0xdc, 0xaf, 0x59, 0xb2, 0x64, 0xb3, 0x39, 0x4b, 0x7a, 0x37, 0xc1, 0x24, 0x09, 0xa7, 0xf9,
-	0xf7, 0x23, 0x2d, 0xbe, 0x31, 0x93, 0xa6, 0x80, 0x5f, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0x21,
-	0xa9, 0x8a, 0xec, 0x7b, 0x06, 0x00, 0x00,
+	0x40, 0x55, 0x2b, 0x12, 0x51, 0x84, 0x04, 0x97, 0x4e, 0x3c, 0xe9, 0x5a, 0x9b, 0xda, 0xcb, 0x8c,
+	0xb3, 0x08, 0x7a, 0x61, 0x39, 0xc9, 0x34, 0xb1, 0x48, 0xec, 0xc8, 0x76, 0xaa, 0xf6, 0x96, 0x07,
+	0x40, 0x48, 0x70, 0x85, 0xc4, 0x0b, 0xf0, 0x24, 0xbc, 0x01, 0x2f, 0x82, 0xc4, 0x2d, 0x9a, 0xb1,
+	0xc7, 0x8d, 0xdb, 0x8b, 0xbd, 0xea, 0x7c, 0xe7, 0xfb, 0xe6, 0x9c, 0xef, 0x9c, 0x33, 0xa9, 0xe1,
+	0x70, 0x1a, 0xaf, 0x56, 0x71, 0xd4, 0xcb, 0xff, 0x74, 0xd7, 0x49, 0x9c, 0xc5, 0xa8, 0x99, 0xa3,
+	0xe3, 0x37, 0xf3, 0x38, 0x9e, 0x2f, 0x59, 0x4f, 0x44, 0x27, 0x9b, 0x9b, 0x5e, 0x16, 0xae, 0x58,
+	0x9a, 0x05, 0xab, 0x75, 0x2e, 0x34, 0x0c, 0x80, 0x51, 0x90, 0x66, 0x83, 0x38, 0xba, 0x09, 0xe7,
+	0xe8, 0x39, 0x34, 0xc2, 0x68, 0xc6, 0xee, 0x74, 0xe5, 0x44, 0x39, 0xad, 0x93, 0x1c, 0x18, 0xd7,
+	0xb0, 0x7b, 0xc5, 0xb2, 0x60, 0x16, 0x64, 0x01, 0x57, 0xdc, 0x06, 0xcb, 0x0d, 0x13, 0x8a, 0x3d,
+	0x92, 0x03, 0xf4, 0x2d, 0x40, 0x1a, 0xce, 0xa3, 0x20, 0xdb, 0x24, 0x2c, 0xd5, 0x6b, 0x27, 0xea,
+	0x69, 0xe7, 0xe2, 0x55, 0xb7, 0x70, 0x24, 0xef, 0x52, 0xa9, 0x20, 0x5b, 0x62, 0xe3, 0x1a, 0x0e,
+	0x9e, 0x08, 0xd0, 0x29, 0x3c, 0x2b, 0x25, 0x6f, 0x59, 0x30, 0x63, 0x49, 0x51, 0xef, 0x71, 0x18,
+	0x7d, 0x0a, 0xed, 0x32, 0xa4, 0xd7, 0x84, 0xe6, 0x21, 0x60, 0xfc, 0xac, 0x40, 0xb3, 0x10, 0x7e,
+	0x0d, 0x9d, 0xe9, 0x22, 0x08, 0xa3, 0xad, 0x74, 0x9d, 0x8b, 0x43, 0xe9, 0x71, 0xf0, 0x40, 0x91,
+	0x6d, 0x1d, 0x32, 0x9f, 0x3a, 0xa9, 0x89, 0xab, 0x2f, 0xe5, 0x55, 0x5a, 0xa5, 0x9f, 0x58, 0x34,
+	0xfe, 0x51, 0xa0, 0xb3, 0x95, 0x1f, 0x21, 0xa8, 0x67, 0xf7, 0xeb, 0x7c, 0x82, 0x0d, 0x22, 0xce,
+	0x48, 0x87, 0xd6, 0x2d, 0x4b, 0xd2, 0x30, 0x8e, 0x44, 0xfa, 0x06, 0x91, 0x10, 0x7d, 0x03, 0xed,
+	0x72, 0x67, 0xba, 0x2a, 0x4a, 0x1f, 0x77, 0xf3, 0xad, 0x76, 0xe5, 0x56, 0xbb, 0x9e, 0x54, 0x90,
+	0x07, 0x31, 0xcf, 0x29, 0x3a, 0xb1, 0x2d, 0xbd, 0x7e, 0xa2, 0x9c, 0xb6, 0x89, 0x84, 0xc2, 0xc1,
+	0x9d, 0x6d, 0xe9, 0x0d, 0x11, 0x16, 0x67, 0xbe, 0x58, 0xb6, 0x8e, 0xa7, 0x0b, 0xbd, 0x99, 0xaf,
+	0x5e, 0x00, 0x3e, 0x5e, 0x76, 0x97, 0xb1, 0x48, 0x38, 0x6b, 0xe5, 0xe3, 0x2d, 0x03, 0x86, 0x09,
+	0xcf, 0x1e, 0x75, 0x2f, 0x8a, 0x26, 0x2c, 0xc8, 0x62, 0xb9, 0x31, 0x09, 0x79, 0x81, 0x28, 0x8e,
+	0xa6, 0x72, 0x4b, 0x39, 0x30, 0x30, 0xb4, 0xde, 0x07, 0xf7, 0xcb, 0x38, 0x98, 0xa1, 0xcf, 0xa1,
+	0xb9, 0xd8, 0x5e, 0xce, 0xbe, 0x9c, 0x70, 0x31, 0xd8, 0x82, 0xe5, 0xee, 0xf9, 0x6b, 0x29, 0xf2,
+	0x88, 0xb3, 0xd1, 0x87, 0x5d, 0x1c, 0xdd, 0xb2, 0x65, 0x9c, 0xcf, 0x72, 0x9d, 0xa7, 0x94, 0x16,
+	0x0a, 0xf8, 0x91, 0xc7, 0xf2, 0x8b, 0x02, 0x8d, 0xfe, 0x32, 0x9e, 0xfe, 0x84, 0xce, 0xe5, 0xab,
+	0x79, 0xfc, 0x4c, 0x04, 0x2d, 0xed, 0x14, 0x1d, 0x7f, 0x06, 0x75, 0x4b, 0xda, 0xe9, 0x5c, 0x1c,
+	0x54, 0xa4, 0x9c, 0x20, 0x82, 0x46, 0x5f, 0x3e, 0xfc, 0x88, 0x8a, 0x35, 0x1e, 0x55, 0xa4, 0x92,
+	0x24, 0xa5, 0xcc, 0x60, 0xd0, 0xd9, 0x2a, 0x88, 0x5e, 0x40, 0xd3, 0xd9, 0xac, 0x26, 0x85, 0xab,
+	0x3a, 0x29, 0x10, 0x32, 0x60, 0xef, 0x7d, 0xc2, 0x6e, 0xc3, 0x78, 0x93, 0xbe, 0x0d, 0xd2, 0x45,
+	0xd1, 0x58, 0x25, 0x86, 0x8e, 0x61, 0x97, 0xbb, 0x10, 0xbc, 0x2a, 0xf8, 0x12, 0x1b, 0x6f, 0xa0,
+	0x5d, 0x9a, 0xe5, 0xc3, 0x15, 0xdd, 0x28, 0x27, 0x2a, 0x1f, 0x2e, 0x3f, 0x1b, 0xe7, 0xf0, 0x49,
+	0xc5, 0x22, 0xcf, 0x56, 0xf6, 0x92, 0x0b, 0x4b, 0x7c, 0xf6, 0x97, 0x02, 0x4d, 0x9a, 0x05, 0xd9,
+	0x26, 0x45, 0x1d, 0x68, 0x8d, 0x9d, 0x77, 0x8e, 0xfb, 0xbd, 0xa3, 0xed, 0xa0, 0x3d, 0x68, 0xd1,
+	0xf1, 0x60, 0x80, 0x29, 0xd5, 0xfe, 0x56, 0x90, 0x06, 0x9d, 0xbe, 0x69, 0xf9, 0x04, 0x7f, 0x37,
+	0xc6, 0xd4, 0xd3, 0x7e, 0x55, 0xd1, 0x3e, 0xb4, 0x87, 0x2e, 0xe9, 0xdb, 0x96, 0x85, 0x1d, 0xed,
+	0x37, 0x81, 0x1d, 0xd7, 0xf3, 0x87, 0xee, 0xd8, 0xb1, 0xb4, 0xdf, 0x55, 0xf4, 0x1a, 0xf4, 0x42,
+	0xed, 0x63, 0xc7, 0xb3, 0xbd, 0x1f, 0x7c, 0xcf, 0x75, 0xfd, 0x91, 0x49, 0x2e, 0xb1, 0xf6, 0xa7,
+	0x8a, 0x8e, 0xe1, 0xc8, 0x76, 0x3c, 0x4c, 0x1c, 0x73, 0xe4, 0x53, 0x4c, 0x3e, 0x60, 0xe2, 0x63,
+	0x42, 0x5c, 0xa2, 0xfd, 0xab, 0x22, 0x1d, 0x0e, 0x79, 0xc8, 0x1e, 0x60, 0x7f, 0xec, 0x98, 0x1f,
+	0x4c, 0x7b, 0x64, 0xf6, 0x47, 0x58, 0xfb, 0x4f, 0x3d, 0xfb, 0x43, 0x01, 0xc8, 0xa7, 0xeb, 0xf1,
+	0x5f, 0x61, 0x07, 0x5a, 0x57, 0x98, 0x52, 0xf3, 0x12, 0x6b, 0x3b, 0xe8, 0x35, 0xbc, 0x1a, 0xb8,
+	0xce, 0xd0, 0xbe, 0x1c, 0x13, 0xd3, 0xb3, 0x5d, 0xc7, 0xf7, 0x88, 0xe9, 0x50, 0x73, 0xc0, 0xcf,
+	0x9a, 0x82, 0x5e, 0x00, 0xaa, 0xd2, 0xb6, 0x87, 0xaf, 0xb4, 0x1a, 0xd2, 0xe1, 0x39, 0x76, 0x2c,
+	0x97, 0x50, 0x4c, 0x2a, 0x37, 0x54, 0xf4, 0x12, 0x0e, 0x5d, 0x62, 0x61, 0xf2, 0x88, 0xa8, 0xa3,
+	0x23, 0x38, 0xb0, 0xf0, 0xc8, 0xe6, 0x9e, 0x29, 0xc6, 0xef, 0x7c, 0xdb, 0x19, 0xba, 0x5a, 0xe3,
+	0x6c, 0x02, 0xa8, 0x32, 0x76, 0x9b, 0xff, 0x33, 0x46, 0xfb, 0x00, 0xd4, 0xbe, 0x74, 0x4c, 0x6f,
+	0x4c, 0x30, 0xd5, 0x76, 0xb8, 0x8f, 0x91, 0x49, 0x3d, 0xbf, 0x62, 0x46, 0x53, 0x78, 0xb5, 0xad,
+	0x2a, 0xd4, 0x1f, 0xda, 0x23, 0x0f, 0x13, 0xad, 0xc6, 0x9b, 0x2c, 0x6c, 0x68, 0x6a, 0xff, 0x8b,
+	0x1f, 0xcf, 0xe7, 0x61, 0xb6, 0xd8, 0x4c, 0xf8, 0x5b, 0xec, 0x2d, 0xee, 0xd7, 0x2c, 0x59, 0xb2,
+	0xd9, 0x9c, 0x25, 0xbd, 0x9b, 0x60, 0x92, 0x84, 0xd3, 0xfc, 0xc3, 0x91, 0x16, 0x1f, 0x97, 0x49,
+	0x53, 0xc0, 0xaf, 0xfe, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x1b, 0xa5, 0xe2, 0x9d, 0x74, 0x06, 0x00,
+	0x00,
 }
diff --git a/protos/common/common.proto b/protos/common/common.proto
index 47390f92430..c205493279c 100644
--- a/protos/common/common.proto
+++ b/protos/common/common.proto
@@ -37,7 +37,7 @@ enum Status {
 enum HeaderType {
     MESSAGE = 0;                   // Used for messages which are signed but opaque
     CONFIGURATION_TRANSACTION = 1; // Used for messages which reconfigure the chain
-    CONFIGURATION_ITEM = 2;        // Used inside of the the reconfiguration message for signing over ConfigurationItems
+    CONFIGURATION_ITEM = 2;        // Used inside of the the reconfiguration message for signing over ConfigItems
     ENDORSER_TRANSACTION = 3;      // Used by the SDK to submit endorser based transactions
     ORDERER_TRANSACTION = 4;       // Used internally by the orderer for management
     DELIVER_SEEK_INFO = 5;         // Used as the type for Envelope messages submitted to instruct the Deliver API to seek
@@ -52,8 +52,8 @@ enum BlockMetadataIndex {
                                 // e.g. For Kafka, this is where we store the last offset written to the local ledger.
 }
 
-// LastConfiguration is the encoded value for the Metadata message which is encoded in the LAST_CONFIGURATION block metadata index
-message LastConfiguration {
+// LastConfig is the encoded value for the Metadata message which is encoded in the LAST_CONFIGURATION block metadata index
+message LastConfig {
 	uint64 index  = 1;
 }
 
diff --git a/protos/common/configtx.pb.go b/protos/common/configtx.pb.go
index e5acc8d1ddf..62d64ce2c7f 100644
--- a/protos/common/configtx.pb.go
+++ b/protos/common/configtx.pb.go
@@ -13,24 +13,24 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
-type ConfigurationItem_ConfigurationType int32
+type ConfigItem_ConfigType int32
 
 const (
-	ConfigurationItem_Policy  ConfigurationItem_ConfigurationType = 0
-	ConfigurationItem_Chain   ConfigurationItem_ConfigurationType = 1
-	ConfigurationItem_Orderer ConfigurationItem_ConfigurationType = 2
-	ConfigurationItem_Peer    ConfigurationItem_ConfigurationType = 3
-	ConfigurationItem_MSP     ConfigurationItem_ConfigurationType = 4
+	ConfigItem_Policy  ConfigItem_ConfigType = 0
+	ConfigItem_Chain   ConfigItem_ConfigType = 1
+	ConfigItem_Orderer ConfigItem_ConfigType = 2
+	ConfigItem_Peer    ConfigItem_ConfigType = 3
+	ConfigItem_MSP     ConfigItem_ConfigType = 4
 )
 
-var ConfigurationItem_ConfigurationType_name = map[int32]string{
+var ConfigItem_ConfigType_name = map[int32]string{
 	0: "Policy",
 	1: "Chain",
 	2: "Orderer",
 	3: "Peer",
 	4: "MSP",
 }
-var ConfigurationItem_ConfigurationType_value = map[string]int32{
+var ConfigItem_ConfigType_value = map[string]int32{
 	"Policy":  0,
 	"Chain":   1,
 	"Orderer": 2,
@@ -38,26 +38,24 @@ var ConfigurationItem_ConfigurationType_value = map[string]int32{
 	"MSP":     4,
 }
 
-func (x ConfigurationItem_ConfigurationType) String() string {
-	return proto.EnumName(ConfigurationItem_ConfigurationType_name, int32(x))
-}
-func (ConfigurationItem_ConfigurationType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor1, []int{3, 0}
+func (x ConfigItem_ConfigType) String() string {
+	return proto.EnumName(ConfigItem_ConfigType_name, int32(x))
 }
+func (ConfigItem_ConfigType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{3, 0} }
 
-// ConfigurationEnvelope is designed to contain _all_ configuration for a chain with no dependency
+// ConfigEnvelope is designed to contain _all_ configuration for a chain with no dependency
 // on previous configuration transactions.
 //
 // It is generated with the following scheme:
 //   1. Retrieve the existing configuration
 //   2. Note the highest configuration sequence number, store it and increment it by one
-//   3. Modify desired ConfigurationItems, setting each LastModified to the stored and incremented sequence number
-//     a) Note that the ConfigurationItem has a ChainHeader header attached to it, who's type is set to CONFIGURATION_ITEM
-//   4. Create Config message containing the new configuration, marshal it into ConfigurationEnvelope.config and encode the required signatures
-//     a) Each signature is of type ConfigurationSignature
-//     b) The ConfigurationSignature signature is over the concatenation of signatureHeader and the Config bytes (which includes a ChainHeader)
-//   5. Submit new Configuration for ordering in Envelope signed by submitter
-//     a) The Envelope Payload has data set to the marshaled ConfigurationEnvelope
+//   3. Modify desired ConfigItems, setting each LastModified to the stored and incremented sequence number
+//     a) Note that the ConfigItem has a ChainHeader header attached to it, who's type is set to CONFIGURATION_ITEM
+//   4. Create Config message containing the new configuration, marshal it into ConfigEnvelope.config and encode the required signatures
+//     a) Each signature is of type ConfigSignature
+//     b) The ConfigSignature signature is over the concatenation of signatureHeader and the Config bytes (which includes a ChainHeader)
+//   5. Submit new Config for ordering in Envelope signed by submitter
+//     a) The Envelope Payload has data set to the marshaled ConfigEnvelope
 //     b) The Envelope Payload has a header of type Header.Type.CONFIGURATION_TRANSACTION
 //
 // The configuration manager will verify:
@@ -66,36 +64,36 @@ func (ConfigurationItem_ConfigurationType) EnumDescriptor() ([]byte, []int) {
 //   3. No existing configuration item has been ommitted
 //   4. All configuration changes have a LastModification of one more than the last configuration's highest LastModification number
 //   5. All configuration changes satisfy the corresponding modification policy
-type ConfigurationEnvelope struct {
-	Config     []byte                    `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
-	Signatures []*ConfigurationSignature `protobuf:"bytes,2,rep,name=signatures" json:"signatures,omitempty"`
+type ConfigEnvelope struct {
+	Config     []byte             `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
+	Signatures []*ConfigSignature `protobuf:"bytes,2,rep,name=signatures" json:"signatures,omitempty"`
 }
 
-func (m *ConfigurationEnvelope) Reset()                    { *m = ConfigurationEnvelope{} }
-func (m *ConfigurationEnvelope) String() string            { return proto.CompactTextString(m) }
-func (*ConfigurationEnvelope) ProtoMessage()               {}
-func (*ConfigurationEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+func (m *ConfigEnvelope) Reset()                    { *m = ConfigEnvelope{} }
+func (m *ConfigEnvelope) String() string            { return proto.CompactTextString(m) }
+func (*ConfigEnvelope) ProtoMessage()               {}
+func (*ConfigEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
 
-func (m *ConfigurationEnvelope) GetSignatures() []*ConfigurationSignature {
+func (m *ConfigEnvelope) GetSignatures() []*ConfigSignature {
 	if m != nil {
 		return m.Signatures
 	}
 	return nil
 }
 
-// ConfigurationTemplate is used as a serialization format to share configuration templates
+// ConfigTemplate is used as a serialization format to share configuration templates
 // The orderer supplies a configuration template to the user to use when constructing a new
 // chain creation transaction, so this is used to facilitate that.
-type ConfigurationTemplate struct {
-	Items []*ConfigurationItem `protobuf:"bytes,1,rep,name=Items" json:"Items,omitempty"`
+type ConfigTemplate struct {
+	Items []*ConfigItem `protobuf:"bytes,1,rep,name=Items" json:"Items,omitempty"`
 }
 
-func (m *ConfigurationTemplate) Reset()                    { *m = ConfigurationTemplate{} }
-func (m *ConfigurationTemplate) String() string            { return proto.CompactTextString(m) }
-func (*ConfigurationTemplate) ProtoMessage()               {}
-func (*ConfigurationTemplate) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+func (m *ConfigTemplate) Reset()                    { *m = ConfigTemplate{} }
+func (m *ConfigTemplate) String() string            { return proto.CompactTextString(m) }
+func (*ConfigTemplate) ProtoMessage()               {}
+func (*ConfigTemplate) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
 
-func (m *ConfigurationTemplate) GetItems() []*ConfigurationItem {
+func (m *ConfigTemplate) GetItems() []*ConfigItem {
 	if m != nil {
 		return m.Items
 	}
@@ -104,8 +102,8 @@ func (m *ConfigurationTemplate) GetItems() []*ConfigurationItem {
 
 // This message may change slightly depending on the finalization of signature schemes for transactions
 type Config struct {
-	Header *ChainHeader         `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
-	Items  []*ConfigurationItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
+	Header *ChainHeader  `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Items  []*ConfigItem `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"`
 }
 
 func (m *Config) Reset()                    { *m = Config{} }
@@ -120,73 +118,73 @@ func (m *Config) GetHeader() *ChainHeader {
 	return nil
 }
 
-func (m *Config) GetItems() []*ConfigurationItem {
+func (m *Config) GetItems() []*ConfigItem {
 	if m != nil {
 		return m.Items
 	}
 	return nil
 }
 
-type ConfigurationItem struct {
-	Type               ConfigurationItem_ConfigurationType `protobuf:"varint,1,opt,name=Type,enum=common.ConfigurationItem_ConfigurationType" json:"Type,omitempty"`
-	LastModified       uint64                              `protobuf:"varint,2,opt,name=LastModified" json:"LastModified,omitempty"`
-	ModificationPolicy string                              `protobuf:"bytes,3,opt,name=ModificationPolicy" json:"ModificationPolicy,omitempty"`
-	Key                string                              `protobuf:"bytes,4,opt,name=Key" json:"Key,omitempty"`
-	Value              []byte                              `protobuf:"bytes,5,opt,name=Value,proto3" json:"Value,omitempty"`
+type ConfigItem struct {
+	Type               ConfigItem_ConfigType `protobuf:"varint,1,opt,name=Type,enum=common.ConfigItem_ConfigType" json:"Type,omitempty"`
+	LastModified       uint64                `protobuf:"varint,2,opt,name=LastModified" json:"LastModified,omitempty"`
+	ModificationPolicy string                `protobuf:"bytes,3,opt,name=ModificationPolicy" json:"ModificationPolicy,omitempty"`
+	Key                string                `protobuf:"bytes,4,opt,name=Key" json:"Key,omitempty"`
+	Value              []byte                `protobuf:"bytes,5,opt,name=Value,proto3" json:"Value,omitempty"`
 }
 
-func (m *ConfigurationItem) Reset()                    { *m = ConfigurationItem{} }
-func (m *ConfigurationItem) String() string            { return proto.CompactTextString(m) }
-func (*ConfigurationItem) ProtoMessage()               {}
-func (*ConfigurationItem) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
+func (m *ConfigItem) Reset()                    { *m = ConfigItem{} }
+func (m *ConfigItem) String() string            { return proto.CompactTextString(m) }
+func (*ConfigItem) ProtoMessage()               {}
+func (*ConfigItem) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 
-type ConfigurationSignature struct {
+type ConfigSignature struct {
 	SignatureHeader []byte `protobuf:"bytes,1,opt,name=signature_header,json=signatureHeader,proto3" json:"signature_header,omitempty"`
 	Signature       []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
 }
 
-func (m *ConfigurationSignature) Reset()                    { *m = ConfigurationSignature{} }
-func (m *ConfigurationSignature) String() string            { return proto.CompactTextString(m) }
-func (*ConfigurationSignature) ProtoMessage()               {}
-func (*ConfigurationSignature) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
+func (m *ConfigSignature) Reset()                    { *m = ConfigSignature{} }
+func (m *ConfigSignature) String() string            { return proto.CompactTextString(m) }
+func (*ConfigSignature) ProtoMessage()               {}
+func (*ConfigSignature) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 
 func init() {
-	proto.RegisterType((*ConfigurationEnvelope)(nil), "common.ConfigurationEnvelope")
-	proto.RegisterType((*ConfigurationTemplate)(nil), "common.ConfigurationTemplate")
+	proto.RegisterType((*ConfigEnvelope)(nil), "common.ConfigEnvelope")
+	proto.RegisterType((*ConfigTemplate)(nil), "common.ConfigTemplate")
 	proto.RegisterType((*Config)(nil), "common.Config")
-	proto.RegisterType((*ConfigurationItem)(nil), "common.ConfigurationItem")
-	proto.RegisterType((*ConfigurationSignature)(nil), "common.ConfigurationSignature")
-	proto.RegisterEnum("common.ConfigurationItem_ConfigurationType", ConfigurationItem_ConfigurationType_name, ConfigurationItem_ConfigurationType_value)
+	proto.RegisterType((*ConfigItem)(nil), "common.ConfigItem")
+	proto.RegisterType((*ConfigSignature)(nil), "common.ConfigSignature")
+	proto.RegisterEnum("common.ConfigItem_ConfigType", ConfigItem_ConfigType_name, ConfigItem_ConfigType_value)
 }
 
 func init() { proto.RegisterFile("common/configtx.proto", fileDescriptor1) }
 
 var fileDescriptor1 = []byte{
-	// 416 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x52, 0x5d, 0x8b, 0xd3, 0x40,
-	0x14, 0x35, 0x1f, 0xcd, 0xda, 0xdb, 0xa2, 0xf1, 0xae, 0xbb, 0x44, 0x11, 0x29, 0x79, 0xaa, 0x14,
-	0x1b, 0xa8, 0xef, 0x0a, 0x8a, 0xb0, 0x7e, 0x2c, 0x96, 0xd9, 0xc5, 0x07, 0x5f, 0x64, 0x9a, 0xdc,
-	0xb6, 0x03, 0x69, 0x26, 0x4c, 0xa6, 0x62, 0xff, 0x8b, 0x3f, 0x56, 0x72, 0xa7, 0xc6, 0xed, 0x5a,
-	0xd9, 0xa7, 0xcc, 0x3d, 0xe7, 0xdc, 0x73, 0x27, 0xf7, 0x0c, 0x9c, 0xe5, 0x7a, 0xb3, 0xd1, 0x55,
-	0x96, 0xeb, 0x6a, 0xa9, 0x56, 0xf6, 0xe7, 0xb4, 0x36, 0xda, 0x6a, 0x8c, 0x1c, 0xfc, 0xf4, 0xb4,
-	0xa3, 0xdb, 0x8f, 0x23, 0x53, 0x0d, 0x67, 0xef, 0x58, 0xbe, 0x35, 0xd2, 0x2a, 0x5d, 0xbd, 0xaf,
-	0x7e, 0x50, 0xa9, 0x6b, 0xc2, 0x73, 0x88, 0x9c, 0x4f, 0xe2, 0x8d, 0xbc, 0xf1, 0x50, 0xec, 0x2b,
-	0x7c, 0x0d, 0xd0, 0xa8, 0x55, 0x25, 0xed, 0xd6, 0x50, 0x93, 0xf8, 0xa3, 0x60, 0x3c, 0x98, 0x3d,
-	0x9f, 0xee, 0x3d, 0x0f, 0xac, 0xae, 0xfe, 0xc8, 0xc4, 0x8d, 0x8e, 0xf4, 0xe2, 0xd6, 0xc0, 0x6b,
-	0xda, 0xd4, 0xa5, 0xb4, 0x84, 0x19, 0xf4, 0x3e, 0x58, 0xda, 0x34, 0x89, 0xc7, 0x9e, 0x4f, 0x8e,
-	0x7a, 0xb6, 0x0a, 0xe1, 0x74, 0xe9, 0x12, 0x22, 0xc7, 0xe1, 0x04, 0xa2, 0x35, 0xc9, 0x82, 0x0c,
-	0xdf, 0x75, 0x30, 0x3b, 0xed, 0x7a, 0xd7, 0x52, 0x55, 0x17, 0x4c, 0x89, 0xbd, 0xa4, 0x9d, 0xa3,
-	0x78, 0x8e, 0x7f, 0xe7, 0x1c, 0xd6, 0xa5, 0xbf, 0x7c, 0x78, 0xf4, 0x0f, 0x89, 0x6f, 0x20, 0xbc,
-	0xde, 0xd5, 0xc4, 0x13, 0x1f, 0xcc, 0x26, 0xff, 0x75, 0x39, 0x44, 0xda, 0x16, 0xc1, 0x8d, 0x98,
-	0xc2, 0xf0, 0xb3, 0x6c, 0xec, 0xa5, 0x2e, 0xd4, 0x52, 0x51, 0x91, 0xf8, 0x23, 0x6f, 0x1c, 0x8a,
-	0x03, 0x0c, 0xa7, 0x80, 0xee, 0x9c, 0x73, 0xf7, 0x5c, 0x97, 0x2a, 0xdf, 0x25, 0xc1, 0xc8, 0x1b,
-	0xf7, 0xc5, 0x11, 0x06, 0x63, 0x08, 0x3e, 0xd1, 0x2e, 0x09, 0x59, 0xd0, 0x1e, 0xf1, 0x31, 0xf4,
-	0xbe, 0xca, 0x72, 0x4b, 0x49, 0x8f, 0x53, 0x74, 0x45, 0xfa, 0xf1, 0xd6, 0x1f, 0xf1, 0x85, 0x00,
-	0x22, 0x67, 0x13, 0xdf, 0xc3, 0x3e, 0xf4, 0x78, 0x77, 0xb1, 0x87, 0x03, 0x38, 0xf9, 0x62, 0x0a,
-	0x32, 0x64, 0x62, 0x1f, 0xef, 0x43, 0x38, 0x27, 0x32, 0x71, 0x80, 0x27, 0x10, 0x5c, 0x5e, 0xcd,
-	0xe3, 0x30, 0x95, 0x70, 0x7e, 0x3c, 0x76, 0x7c, 0x01, 0x71, 0x17, 0xfc, 0xf7, 0x1b, 0x01, 0x0d,
-	0xc5, 0xc3, 0x0e, 0x77, 0xe1, 0xe0, 0x33, 0xe8, 0x77, 0x10, 0x6f, 0x62, 0x28, 0xfe, 0x02, 0x6f,
-	0x5f, 0x7e, 0x9b, 0xac, 0x94, 0x5d, 0x6f, 0x17, 0xed, 0x96, 0xb3, 0xf5, 0xae, 0x26, 0x53, 0x52,
-	0xb1, 0x22, 0x93, 0x2d, 0xe5, 0xc2, 0xa8, 0x3c, 0xe3, 0xb7, 0xdc, 0xec, 0x5f, 0xf6, 0x22, 0xe2,
-	0xf2, 0xd5, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0xd8, 0x41, 0xa3, 0x10, 0x03, 0x00, 0x00,
+	// 409 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x52, 0x4d, 0x6f, 0xd3, 0x40,
+	0x10, 0xc5, 0x1f, 0x71, 0xc9, 0x24, 0x6a, 0xad, 0x29, 0x1f, 0x16, 0x02, 0x29, 0xf2, 0xc9, 0xa8,
+	0x22, 0x11, 0xe1, 0x80, 0xc4, 0x91, 0x0a, 0x09, 0x04, 0x15, 0xd1, 0xb6, 0xe2, 0xd0, 0x4b, 0xb5,
+	0xb1, 0x27, 0xf6, 0x4a, 0xb6, 0xd7, 0x5a, 0x6f, 0x10, 0xbe, 0xf1, 0xd3, 0x91, 0x77, 0x1d, 0xb7,
+	0x05, 0x7a, 0xf2, 0xcc, 0x7b, 0x6f, 0xe6, 0x8d, 0x67, 0x16, 0x9e, 0xa6, 0xb2, 0xaa, 0x64, 0xbd,
+	0x4a, 0x65, 0xbd, 0x13, 0xb9, 0xfe, 0xb5, 0x6c, 0x94, 0xd4, 0x12, 0x03, 0x0b, 0xbf, 0x38, 0x1d,
+	0xe9, 0xfe, 0x63, 0xc9, 0x98, 0xc3, 0xf1, 0xb9, 0x91, 0x7f, 0xaa, 0x7f, 0x52, 0x29, 0x1b, 0xc2,
+	0x67, 0x10, 0xd8, 0x06, 0x91, 0xb3, 0x70, 0x92, 0x39, 0x1b, 0x32, 0x7c, 0x0f, 0xd0, 0x8a, 0xbc,
+	0xe6, 0x7a, 0xaf, 0xa8, 0x8d, 0xdc, 0x85, 0x97, 0xcc, 0xd6, 0xcf, 0x97, 0x43, 0x33, 0xdb, 0xe3,
+	0xf2, 0xc0, 0xb3, 0x3b, 0xd2, 0xf8, 0xc3, 0xc1, 0xe2, 0x8a, 0xaa, 0xa6, 0xe4, 0x9a, 0x30, 0x81,
+	0xc9, 0x17, 0x4d, 0x55, 0x1b, 0x39, 0xa6, 0x0b, 0xde, 0xef, 0xd2, 0x53, 0xcc, 0x0a, 0xe2, 0x1b,
+	0x08, 0x2c, 0x88, 0x67, 0x10, 0x14, 0xc4, 0x33, 0x52, 0x66, 0xac, 0xd9, 0xfa, 0x74, 0x2c, 0x2a,
+	0xb8, 0xa8, 0x3f, 0x1b, 0x8a, 0x0d, 0x92, 0xde, 0x40, 0x18, 0x03, 0xf7, 0x61, 0x03, 0x23, 0x88,
+	0x7f, 0xbb, 0x00, 0xb7, 0x28, 0xbe, 0x05, 0xff, 0xaa, 0x6b, 0xc8, 0x78, 0x1c, 0xaf, 0x5f, 0xfd,
+	0x5b, 0x37, 0x84, 0xbd, 0x88, 0x19, 0x29, 0xc6, 0x30, 0xff, 0xc6, 0x5b, 0x7d, 0x21, 0x33, 0xb1,
+	0x13, 0x94, 0x45, 0xee, 0xc2, 0x49, 0x7c, 0x76, 0x0f, 0xc3, 0x25, 0xa0, 0x8d, 0x53, 0xae, 0x85,
+	0xac, 0x37, 0xb2, 0x14, 0x69, 0x17, 0x79, 0x0b, 0x27, 0x99, 0xb2, 0xff, 0x30, 0x18, 0x82, 0xf7,
+	0x95, 0xba, 0xc8, 0x37, 0x82, 0x3e, 0xc4, 0x27, 0x30, 0xf9, 0xc1, 0xcb, 0x3d, 0x45, 0x13, 0x73,
+	0x14, 0x9b, 0xc4, 0xe7, 0x87, 0xe1, 0xcd, 0x24, 0x00, 0x81, 0xad, 0x0f, 0x1f, 0xe1, 0x14, 0x26,
+	0x66, 0x31, 0xa1, 0x83, 0x33, 0x38, 0xfa, 0xae, 0x32, 0x52, 0xa4, 0x42, 0x17, 0x1f, 0x83, 0xbf,
+	0x21, 0x52, 0xa1, 0x87, 0x47, 0xe0, 0x5d, 0x5c, 0x6e, 0x42, 0x3f, 0xbe, 0x86, 0x93, 0xbf, 0xce,
+	0x87, 0xaf, 0x21, 0x1c, 0x0f, 0x78, 0x73, 0x67, 0xed, 0x73, 0x76, 0x32, 0xe2, 0x76, 0xe5, 0xf8,
+	0x12, 0xa6, 0x23, 0x64, 0xfe, 0x7d, 0xce, 0x6e, 0x81, 0x8f, 0x6f, 0xae, 0xcf, 0x72, 0xa1, 0x8b,
+	0xfd, 0xb6, 0xdf, 0xe4, 0xaa, 0xe8, 0x1a, 0x52, 0x25, 0x65, 0x39, 0xa9, 0xd5, 0x8e, 0x6f, 0x95,
+	0x48, 0x57, 0xe6, 0x15, 0xb6, 0xc3, 0x9b, 0xdc, 0x06, 0x26, 0x7d, 0xf7, 0x27, 0x00, 0x00, 0xff,
+	0xff, 0x9a, 0x2b, 0x43, 0x4d, 0xca, 0x02, 0x00, 0x00,
 }
diff --git a/protos/common/configtx.proto b/protos/common/configtx.proto
index 2995e695a1f..9ee150c7de0 100644
--- a/protos/common/configtx.proto
+++ b/protos/common/configtx.proto
@@ -25,19 +25,19 @@ option go_package = "github.com/hyperledger/fabric/protos/common";
 
 package common;
 
-// ConfigurationEnvelope is designed to contain _all_ configuration for a chain with no dependency
+// ConfigEnvelope is designed to contain _all_ configuration for a chain with no dependency
 // on previous configuration transactions.
 //
 // It is generated with the following scheme:
 //   1. Retrieve the existing configuration
 //   2. Note the highest configuration sequence number, store it and increment it by one
-//   3. Modify desired ConfigurationItems, setting each LastModified to the stored and incremented sequence number
-//     a) Note that the ConfigurationItem has a ChainHeader header attached to it, who's type is set to CONFIGURATION_ITEM
-//   4. Create Config message containing the new configuration, marshal it into ConfigurationEnvelope.config and encode the required signatures
-//     a) Each signature is of type ConfigurationSignature
-//     b) The ConfigurationSignature signature is over the concatenation of signatureHeader and the Config bytes (which includes a ChainHeader)
-//   5. Submit new Configuration for ordering in Envelope signed by submitter
-//     a) The Envelope Payload has data set to the marshaled ConfigurationEnvelope
+//   3. Modify desired ConfigItems, setting each LastModified to the stored and incremented sequence number
+//     a) Note that the ConfigItem has a ChainHeader header attached to it, who's type is set to CONFIGURATION_ITEM
+//   4. Create Config message containing the new configuration, marshal it into ConfigEnvelope.config and encode the required signatures
+//     a) Each signature is of type ConfigSignature
+//     b) The ConfigSignature signature is over the concatenation of signatureHeader and the Config bytes (which includes a ChainHeader)
+//   5. Submit new Config for ordering in Envelope signed by submitter
+//     a) The Envelope Payload has data set to the marshaled ConfigEnvelope
 //     b) The Envelope Payload has a header of type Header.Type.CONFIGURATION_TRANSACTION
 //
 // The configuration manager will verify:
@@ -46,40 +46,40 @@ package common;
 //   3. No existing configuration item has been ommitted
 //   4. All configuration changes have a LastModification of one more than the last configuration's highest LastModification number
 //   5. All configuration changes satisfy the corresponding modification policy
-message ConfigurationEnvelope {
+message ConfigEnvelope {
     bytes config = 1;                               // A marshaled Config structure
-    repeated ConfigurationSignature signatures = 2; // Signatures over the config
+    repeated ConfigSignature signatures = 2; // Signatures over the config
 }
 
-// ConfigurationTemplate is used as a serialization format to share configuration templates
+// ConfigTemplate is used as a serialization format to share configuration templates
 // The orderer supplies a configuration template to the user to use when constructing a new
 // chain creation transaction, so this is used to facilitate that.
-message ConfigurationTemplate {
-    repeated ConfigurationItem Items = 1;
+message ConfigTemplate {
+    repeated ConfigItem Items = 1;
 }
 
 // This message may change slightly depending on the finalization of signature schemes for transactions
 message Config {
     ChainHeader header = 1;
-    repeated ConfigurationItem items = 2;
+    repeated ConfigItem items = 2;
 }
 
-message ConfigurationItem {
-    enum ConfigurationType {
+message ConfigItem {
+    enum ConfigType {
         Policy = 0;   // Implies that the Value is a marshaled Policy message, and may be referred to by Key as a ModificationPolicy
         Chain = 1;    // Marshaled format for this type is yet to be determined
         Orderer = 2;  // Marshaled format for this type is yet to be determined
         Peer = 3;     // Marshaled format for this type is yet to be determined
         MSP = 4;      // Marshaled MSPConfig proto
     }
-    ConfigurationType Type = 1;     // The type of configuration this is.
-    uint64 LastModified = 2;        // The Sequence number in the ConfigurationEnvelope this item was last modified
+    ConfigType Type = 1;     // The type of configuration this is.
+    uint64 LastModified = 2;        // The Sequence number in the ConfigEnvelope this item was last modified
     string ModificationPolicy = 3;  // What policy to check before allowing modification
     string Key = 4;                 // A unique ID, unique scoped by Type, to reference the value by
     bytes Value = 5;                // The byte representation of this configuration, usually a marshaled message
 }
 
-message ConfigurationSignature {
+message ConfigSignature {
     bytes signature_header = 1; // A marshaled SignatureHeader
     bytes signature = 2;        // Signature over the concatenation signatureHeader bytes and config bytes
 }
diff --git a/protos/common/signed_data.go b/protos/common/signed_data.go
index ebba1f3353e..94bf904f6bc 100644
--- a/protos/common/signed_data.go
+++ b/protos/common/signed_data.go
@@ -41,9 +41,9 @@ type Signable interface {
 }
 
 // AsSignedData returns the set of signatures for the SignedCOnfigurationItem as SignedData or an error indicating why this was not possible
-func (ce *ConfigurationEnvelope) AsSignedData() ([]*SignedData, error) {
+func (ce *ConfigEnvelope) AsSignedData() ([]*SignedData, error) {
 	if ce == nil {
-		return nil, fmt.Errorf("No signatures for nil SignedConfigurationItem")
+		return nil, fmt.Errorf("No signatures for nil SignedConfigItem")
 	}
 
 	result := make([]*SignedData, len(ce.Signatures))
diff --git a/protos/common/signed_data_test.go b/protos/common/signed_data_test.go
index 1620b157406..e46c3ebc5c0 100644
--- a/protos/common/signed_data_test.go
+++ b/protos/common/signed_data_test.go
@@ -33,10 +33,10 @@ func marshalOrPanic(msg proto.Message) []byte {
 }
 
 func TestNilConfigEnvelopeAsSignedData(t *testing.T) {
-	var ce *ConfigurationEnvelope
+	var ce *ConfigEnvelope
 	_, err := ce.AsSignedData()
 	if err == nil {
-		t.Fatalf("Should have errored trying to convert a nil signed configuration item to signed data")
+		t.Fatalf("Should have errored trying to convert a nil signed config item to signed data")
 	}
 }
 
@@ -45,9 +45,9 @@ func TestConfigEnvelopeAsSignedData(t *testing.T) {
 	signatures := [][]byte{[]byte("Signature1"), []byte("Signature2")}
 	identities := [][]byte{[]byte("Identity1"), []byte("Identity2")}
 
-	configSignatures := make([]*ConfigurationSignature, len(signatures))
+	configSignatures := make([]*ConfigSignature, len(signatures))
 	for i := range configSignatures {
-		configSignatures[i] = &ConfigurationSignature{
+		configSignatures[i] = &ConfigSignature{
 			SignatureHeader: marshalOrPanic(&SignatureHeader{
 				Creator: identities[i],
 			}),
@@ -55,7 +55,7 @@ func TestConfigEnvelopeAsSignedData(t *testing.T) {
 		}
 	}
 
-	ce := &ConfigurationEnvelope{
+	ce := &ConfigEnvelope{
 		Config:     configBytes,
 		Signatures: configSignatures,
 	}
diff --git a/protos/utils/blockutils.go b/protos/utils/blockutils.go
index f8ef11db4da..d629ad0bb71 100644
--- a/protos/utils/blockutils.go
+++ b/protos/utils/blockutils.go
@@ -60,13 +60,13 @@ func GetMetadataFromBlockOrPanic(block *cb.Block, index cb.BlockMetadataIndex) *
 	return md
 }
 
-// GetLastConfigurationIndexFromBlock retrieves the index of the last configuration block as encoded in the block metadata
-func GetLastConfigurationIndexFromBlock(block *cb.Block) (uint64, error) {
+// GetLastConfigIndexFromBlock retrieves the index of the last config block as encoded in the block metadata
+func GetLastConfigIndexFromBlock(block *cb.Block) (uint64, error) {
 	md, err := GetMetadataFromBlock(block, cb.BlockMetadataIndex_LAST_CONFIGURATION)
 	if err != nil {
 		return 0, err
 	}
-	lc := &cb.LastConfiguration{}
+	lc := &cb.LastConfig{}
 	err = proto.Unmarshal(md.Value, lc)
 	if err != nil {
 		return 0, err
@@ -74,9 +74,9 @@ func GetLastConfigurationIndexFromBlock(block *cb.Block) (uint64, error) {
 	return lc.Index, nil
 }
 
-// GetLastConfigurationIndexFromBlockOrPanic retrieves the index of the last configuration block as encoded in the block metadata, or panics on error.
-func GetLastConfigurationIndexFromBlockOrPanic(block *cb.Block) uint64 {
-	index, err := GetLastConfigurationIndexFromBlock(block)
+// GetLastConfigIndexFromBlockOrPanic retrieves the index of the last config block as encoded in the block metadata, or panics on error.
+func GetLastConfigIndexFromBlockOrPanic(block *cb.Block) uint64 {
+	index, err := GetLastConfigIndexFromBlock(block)
 	if err != nil {
 		panic(err)
 	}