diff --git a/orderer/atomicbroadcast/ab.pb.go b/orderer/atomicbroadcast/ab.pb.go
index c14806cc1e8..5d5388618a8 100644
--- a/orderer/atomicbroadcast/ab.pb.go
+++ b/orderer/atomicbroadcast/ab.pb.go
@@ -11,6 +11,13 @@ It is generated from these files:
 It has these top-level messages:
 	BroadcastResponse
 	BroadcastMessage
+	SignedData
+	PayloadEnvelope
+	Transaction
+	ConfigurationEnvelope
+	ConfigurationEntry
+	Configuration
+	Policy
 	SignaturePolicyEnvelope
 	SignaturePolicy
 	SeekInfo
@@ -72,6 +79,41 @@ func (x Status) String() string {
 }
 func (Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
+type Configuration_ConfigurationType int32
+
+const (
+	Configuration_Policy Configuration_ConfigurationType = 0
+	Configuration_Fabric Configuration_ConfigurationType = 1
+	Configuration_Chain  Configuration_ConfigurationType = 2
+	Configuration_Solo   Configuration_ConfigurationType = 3
+	Configuration_Kafka  Configuration_ConfigurationType = 4
+	Configuration_PBFT   Configuration_ConfigurationType = 5
+)
+
+var Configuration_ConfigurationType_name = map[int32]string{
+	0: "Policy",
+	1: "Fabric",
+	2: "Chain",
+	3: "Solo",
+	4: "Kafka",
+	5: "PBFT",
+}
+var Configuration_ConfigurationType_value = map[string]int32{
+	"Policy": 0,
+	"Fabric": 1,
+	"Chain":  2,
+	"Solo":   3,
+	"Kafka":  4,
+	"PBFT":   5,
+}
+
+func (x Configuration_ConfigurationType) String() string {
+	return proto.EnumName(Configuration_ConfigurationType_name, int32(x))
+}
+func (Configuration_ConfigurationType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{7, 0}
+}
+
 // Start may be specified to a specific block number, or may be request from the newest or oldest available
 // The start location is always inclusive, so the first reply from NEWEST will contain the newest block at the time
 // of reception, it will must not wait until a new block is created.  Similarly, when SPECIFIED, and SpecifiedNumber = 10
@@ -98,7 +140,7 @@ var SeekInfo_StartType_value = map[string]int32{
 func (x SeekInfo_StartType) String() string {
 	return proto.EnumName(SeekInfo_StartType_name, int32(x))
 }
-func (SeekInfo_StartType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4, 0} }
+func (SeekInfo_StartType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 0} }
 
 type BroadcastResponse struct {
 	Status Status `protobuf:"varint,1,opt,name=Status,json=status,enum=atomicbroadcast.Status" json:"Status,omitempty"`
@@ -109,6 +151,10 @@ func (m *BroadcastResponse) String() string            { return proto.CompactTex
 func (*BroadcastResponse) ProtoMessage()               {}
 func (*BroadcastResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
+// For backwards compatibility, this is message is being left as bytes for the moment.
+// Internally, for testing authentication, the Data payload will be a marshalled SignedData message
+// However in the future, this whole message is likely to go away.
+// XXX Temporary
 type BroadcastMessage struct {
 	Data []byte `protobuf:"bytes,1,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
 }
@@ -118,6 +164,308 @@ func (m *BroadcastMessage) String() string            { return proto.CompactText
 func (*BroadcastMessage) ProtoMessage()               {}
 func (*BroadcastMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 
+// SignedData is a temporary message type to be removed once the real transaction type is finalized
+// Note that the identity of the signer is explicitely not included, but embedded in the envelope because
+// apparently the signature should always be over an object which contains the signer's identity
+// XXX Temporary
+type SignedData struct {
+	PayloadEnvelope []byte `protobuf:"bytes,1,opt,name=PayloadEnvelope,json=payloadEnvelope,proto3" json:"PayloadEnvelope,omitempty"`
+	Signature       []byte `protobuf:"bytes,2,opt,name=Signature,json=signature,proto3" json:"Signature,omitempty"`
+}
+
+func (m *SignedData) Reset()                    { *m = SignedData{} }
+func (m *SignedData) String() string            { return proto.CompactTextString(m) }
+func (*SignedData) ProtoMessage()               {}
+func (*SignedData) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+
+// PayloadEnvelope is the thin wrapper which allows the embedding of a signer's identity to sign over
+// XXX Temporary
+type PayloadEnvelope struct {
+	Payload []byte `protobuf:"bytes,1,opt,name=Payload,json=payload,proto3" json:"Payload,omitempty"`
+	Signer  []byte `protobuf:"bytes,2,opt,name=Signer,json=signer,proto3" json:"Signer,omitempty"`
+}
+
+func (m *PayloadEnvelope) Reset()                    { *m = PayloadEnvelope{} }
+func (m *PayloadEnvelope) String() string            { return proto.CompactTextString(m) }
+func (*PayloadEnvelope) ProtoMessage()               {}
+func (*PayloadEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+
+// Transaction embeds a configuration change and associated signoffs
+// This will be superseded once the real transaction format is finalized
+// XXX Temporary
+type Transaction struct {
+	// Types that are valid to be assigned to Type:
+	//	*Transaction_Opaque
+	//	*Transaction_ConfigurationEnvelope
+	Type       isTransaction_Type `protobuf_oneof:"Type"`
+	Signatures []*SignedData      `protobuf:"bytes,3,rep,name=Signatures,json=signatures" json:"Signatures,omitempty"`
+}
+
+func (m *Transaction) Reset()                    { *m = Transaction{} }
+func (m *Transaction) String() string            { return proto.CompactTextString(m) }
+func (*Transaction) ProtoMessage()               {}
+func (*Transaction) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+
+type isTransaction_Type interface {
+	isTransaction_Type()
+}
+
+type Transaction_Opaque struct {
+	Opaque []byte `protobuf:"bytes,1,opt,name=Opaque,json=opaque,proto3,oneof"`
+}
+type Transaction_ConfigurationEnvelope struct {
+	ConfigurationEnvelope []byte `protobuf:"bytes,2,opt,name=ConfigurationEnvelope,json=configurationEnvelope,proto3,oneof"`
+}
+
+func (*Transaction_Opaque) isTransaction_Type()                {}
+func (*Transaction_ConfigurationEnvelope) isTransaction_Type() {}
+
+func (m *Transaction) GetType() isTransaction_Type {
+	if m != nil {
+		return m.Type
+	}
+	return nil
+}
+
+func (m *Transaction) GetOpaque() []byte {
+	if x, ok := m.GetType().(*Transaction_Opaque); ok {
+		return x.Opaque
+	}
+	return nil
+}
+
+func (m *Transaction) GetConfigurationEnvelope() []byte {
+	if x, ok := m.GetType().(*Transaction_ConfigurationEnvelope); ok {
+		return x.ConfigurationEnvelope
+	}
+	return nil
+}
+
+func (m *Transaction) GetSignatures() []*SignedData {
+	if m != nil {
+		return m.Signatures
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Transaction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Transaction_OneofMarshaler, _Transaction_OneofUnmarshaler, _Transaction_OneofSizer, []interface{}{
+		(*Transaction_Opaque)(nil),
+		(*Transaction_ConfigurationEnvelope)(nil),
+	}
+}
+
+func _Transaction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Transaction)
+	// Type
+	switch x := m.Type.(type) {
+	case *Transaction_Opaque:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Opaque)
+	case *Transaction_ConfigurationEnvelope:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.ConfigurationEnvelope)
+	case nil:
+	default:
+		return fmt.Errorf("Transaction.Type has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Transaction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Transaction)
+	switch tag {
+	case 1: // Type.Opaque
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Type = &Transaction_Opaque{x}
+		return true, err
+	case 2: // Type.ConfigurationEnvelope
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Type = &Transaction_ConfigurationEnvelope{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Transaction_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Transaction)
+	// Type
+	switch x := m.Type.(type) {
+	case *Transaction_Opaque:
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Opaque)))
+		n += len(x.Opaque)
+	case *Transaction_ConfigurationEnvelope:
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.ConfigurationEnvelope)))
+		n += len(x.ConfigurationEnvelope)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// ConfigurationEnvelope is designed to contain _all_ configuration for a chain and is
+// intended to be a permenant data structure (noted explicitly because others above are temporary)
+// Its generated with the following scheme.  Given an existing configuration, a new configuration
+// increments the Sequence number, and updates any existing configuration entries and or adds new
+// configuration entries.  For each added or modified entry, the LastModified value must be set
+// to the Sequence number of the ConfigurationEnvelope.  The configuration manager will verify that
+// all configuration changes satisfy system policy, that all configuration changes have a LastModified
+// field equal to Sequence, that no configuration has been deleted without corresponding authorization,
+// that the configuration is well formed, and that some configuration item corresponds to the new
+// ConfigurationEnvelope sequence number.
+type ConfigurationEnvelope struct {
+	Sequence uint64                `protobuf:"varint,1,opt,name=Sequence,json=sequence" json:"Sequence,omitempty"`
+	ChainID  []byte                `protobuf:"bytes,2,opt,name=ChainID,json=chainID,proto3" json:"ChainID,omitempty"`
+	Entries  []*ConfigurationEntry `protobuf:"bytes,3,rep,name=Entries,json=entries" json:"Entries,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 fileDescriptor0, []int{5} }
+
+func (m *ConfigurationEnvelope) GetEntries() []*ConfigurationEntry {
+	if m != nil {
+		return m.Entries
+	}
+	return nil
+}
+
+// This message may change slightly depending on the finalization of signature schemes for transactions
+type ConfigurationEntry struct {
+	Configuration []byte        `protobuf:"bytes,1,opt,name=Configuration,json=configuration,proto3" json:"Configuration,omitempty"`
+	Signatures    []*SignedData `protobuf:"bytes,2,rep,name=Signatures,json=signatures" json:"Signatures,omitempty"`
+}
+
+func (m *ConfigurationEntry) Reset()                    { *m = ConfigurationEntry{} }
+func (m *ConfigurationEntry) String() string            { return proto.CompactTextString(m) }
+func (*ConfigurationEntry) ProtoMessage()               {}
+func (*ConfigurationEntry) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+
+func (m *ConfigurationEntry) GetSignatures() []*SignedData {
+	if m != nil {
+		return m.Signatures
+	}
+	return nil
+}
+
+type Configuration struct {
+	ChainID            []byte                          `protobuf:"bytes,1,opt,name=ChainID,json=chainID,proto3" json:"ChainID,omitempty"`
+	ID                 string                          `protobuf:"bytes,2,opt,name=ID,json=iD" json:"ID,omitempty"`
+	LastModified       uint64                          `protobuf:"varint,3,opt,name=LastModified,json=lastModified" json:"LastModified,omitempty"`
+	Type               Configuration_ConfigurationType `protobuf:"varint,4,opt,name=Type,json=type,enum=atomicbroadcast.Configuration_ConfigurationType" json:"Type,omitempty"`
+	Data               []byte                          `protobuf:"bytes,5,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
+	ModificationPolicy string                          `protobuf:"bytes,6,opt,name=ModificationPolicy,json=modificationPolicy" json:"ModificationPolicy,omitempty"`
+}
+
+func (m *Configuration) Reset()                    { *m = Configuration{} }
+func (m *Configuration) String() string            { return proto.CompactTextString(m) }
+func (*Configuration) ProtoMessage()               {}
+func (*Configuration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+
+// Policy expresses a policy which the orderer can evaluate, because there has been some desire expressed to support
+// multiple policy engines, this is typed as a oneof for now
+type Policy struct {
+	// Types that are valid to be assigned to Type:
+	//	*Policy_SignaturePolicy
+	Type isPolicy_Type `protobuf_oneof:"Type"`
+}
+
+func (m *Policy) Reset()                    { *m = Policy{} }
+func (m *Policy) String() string            { return proto.CompactTextString(m) }
+func (*Policy) ProtoMessage()               {}
+func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+
+type isPolicy_Type interface {
+	isPolicy_Type()
+}
+
+type Policy_SignaturePolicy struct {
+	SignaturePolicy *SignaturePolicyEnvelope `protobuf:"bytes,2,opt,name=SignaturePolicy,json=signaturePolicy,oneof"`
+}
+
+func (*Policy_SignaturePolicy) isPolicy_Type() {}
+
+func (m *Policy) GetType() isPolicy_Type {
+	if m != nil {
+		return m.Type
+	}
+	return nil
+}
+
+func (m *Policy) GetSignaturePolicy() *SignaturePolicyEnvelope {
+	if x, ok := m.GetType().(*Policy_SignaturePolicy); ok {
+		return x.SignaturePolicy
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Policy) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Policy_OneofMarshaler, _Policy_OneofUnmarshaler, _Policy_OneofSizer, []interface{}{
+		(*Policy_SignaturePolicy)(nil),
+	}
+}
+
+func _Policy_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Policy)
+	// Type
+	switch x := m.Type.(type) {
+	case *Policy_SignaturePolicy:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.SignaturePolicy); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("Policy.Type has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Policy_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Policy)
+	switch tag {
+	case 2: // Type.SignaturePolicy
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(SignaturePolicyEnvelope)
+		err := b.DecodeMessage(msg)
+		m.Type = &Policy_SignaturePolicy{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Policy_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Policy)
+	// Type
+	switch x := m.Type.(type) {
+	case *Policy_SignaturePolicy:
+		s := proto.Size(x.SignaturePolicy)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
 // SignaturePolicyEnvelope wraps a SignaturePolicy and includes a version for future enhancements
 type SignaturePolicyEnvelope struct {
 	Version    int32            `protobuf:"varint,1,opt,name=Version,json=version" json:"Version,omitempty"`
@@ -128,7 +476,7 @@ type SignaturePolicyEnvelope struct {
 func (m *SignaturePolicyEnvelope) Reset()                    { *m = SignaturePolicyEnvelope{} }
 func (m *SignaturePolicyEnvelope) String() string            { return proto.CompactTextString(m) }
 func (*SignaturePolicyEnvelope) ProtoMessage()               {}
-func (*SignaturePolicyEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+func (*SignaturePolicyEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 func (m *SignaturePolicyEnvelope) GetPolicy() *SignaturePolicy {
 	if m != nil {
@@ -153,7 +501,7 @@ type SignaturePolicy struct {
 func (m *SignaturePolicy) Reset()                    { *m = SignaturePolicy{} }
 func (m *SignaturePolicy) String() string            { return proto.CompactTextString(m) }
 func (*SignaturePolicy) ProtoMessage()               {}
-func (*SignaturePolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (*SignaturePolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 type isSignaturePolicy_Type interface {
 	isSignaturePolicy_Type()
@@ -267,7 +615,7 @@ type SignaturePolicy_NOutOf struct {
 func (m *SignaturePolicy_NOutOf) Reset()                    { *m = SignaturePolicy_NOutOf{} }
 func (m *SignaturePolicy_NOutOf) String() string            { return proto.CompactTextString(m) }
 func (*SignaturePolicy_NOutOf) ProtoMessage()               {}
-func (*SignaturePolicy_NOutOf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }
+func (*SignaturePolicy_NOutOf) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 0} }
 
 func (m *SignaturePolicy_NOutOf) GetPolicies() []*SignaturePolicy {
 	if m != nil {
@@ -285,7 +633,7 @@ type SeekInfo struct {
 func (m *SeekInfo) Reset()                    { *m = SeekInfo{} }
 func (m *SeekInfo) String() string            { return proto.CompactTextString(m) }
 func (*SeekInfo) ProtoMessage()               {}
-func (*SeekInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+func (*SeekInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 type Acknowledgement struct {
 	Number uint64 `protobuf:"varint,1,opt,name=Number,json=number" json:"Number,omitempty"`
@@ -294,7 +642,7 @@ type Acknowledgement struct {
 func (m *Acknowledgement) Reset()                    { *m = Acknowledgement{} }
 func (m *Acknowledgement) String() string            { return proto.CompactTextString(m) }
 func (*Acknowledgement) ProtoMessage()               {}
-func (*Acknowledgement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+func (*Acknowledgement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 
 // The update message either causes a seek to a new stream start with a new window, or acknowledges a received block and advances the base of the window
 type DeliverUpdate struct {
@@ -307,7 +655,7 @@ type DeliverUpdate struct {
 func (m *DeliverUpdate) Reset()                    { *m = DeliverUpdate{} }
 func (m *DeliverUpdate) String() string            { return proto.CompactTextString(m) }
 func (*DeliverUpdate) ProtoMessage()               {}
-func (*DeliverUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+func (*DeliverUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 
 type isDeliverUpdate_Type interface {
 	isDeliverUpdate_Type()
@@ -432,7 +780,7 @@ type Block struct {
 func (m *Block) Reset()                    { *m = Block{} }
 func (m *Block) String() string            { return proto.CompactTextString(m) }
 func (*Block) ProtoMessage()               {}
-func (*Block) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (*Block) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 
 func (m *Block) GetMessages() []*BroadcastMessage {
 	if m != nil {
@@ -451,7 +799,7 @@ type DeliverResponse struct {
 func (m *DeliverResponse) Reset()                    { *m = DeliverResponse{} }
 func (m *DeliverResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeliverResponse) ProtoMessage()               {}
-func (*DeliverResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+func (*DeliverResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
 type isDeliverResponse_Type interface {
 	isDeliverResponse_Type()
@@ -560,6 +908,13 @@ func _DeliverResponse_OneofSizer(msg proto.Message) (n int) {
 func init() {
 	proto.RegisterType((*BroadcastResponse)(nil), "atomicbroadcast.BroadcastResponse")
 	proto.RegisterType((*BroadcastMessage)(nil), "atomicbroadcast.BroadcastMessage")
+	proto.RegisterType((*SignedData)(nil), "atomicbroadcast.SignedData")
+	proto.RegisterType((*PayloadEnvelope)(nil), "atomicbroadcast.PayloadEnvelope")
+	proto.RegisterType((*Transaction)(nil), "atomicbroadcast.Transaction")
+	proto.RegisterType((*ConfigurationEnvelope)(nil), "atomicbroadcast.ConfigurationEnvelope")
+	proto.RegisterType((*ConfigurationEntry)(nil), "atomicbroadcast.ConfigurationEntry")
+	proto.RegisterType((*Configuration)(nil), "atomicbroadcast.Configuration")
+	proto.RegisterType((*Policy)(nil), "atomicbroadcast.Policy")
 	proto.RegisterType((*SignaturePolicyEnvelope)(nil), "atomicbroadcast.SignaturePolicyEnvelope")
 	proto.RegisterType((*SignaturePolicy)(nil), "atomicbroadcast.SignaturePolicy")
 	proto.RegisterType((*SignaturePolicy_NOutOf)(nil), "atomicbroadcast.SignaturePolicy.NOutOf")
@@ -569,6 +924,7 @@ func init() {
 	proto.RegisterType((*Block)(nil), "atomicbroadcast.Block")
 	proto.RegisterType((*DeliverResponse)(nil), "atomicbroadcast.DeliverResponse")
 	proto.RegisterEnum("atomicbroadcast.Status", Status_name, Status_value)
+	proto.RegisterEnum("atomicbroadcast.Configuration_ConfigurationType", Configuration_ConfigurationType_name, Configuration_ConfigurationType_value)
 	proto.RegisterEnum("atomicbroadcast.SeekInfo_StartType", SeekInfo_StartType_name, SeekInfo_StartType_value)
 }
 
@@ -752,50 +1108,72 @@ var _AtomicBroadcast_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("ab.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 720 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
-	0x10, 0xae, 0x13, 0xdb, 0x49, 0xa7, 0x3f, 0x09, 0x0b, 0x6a, 0x43, 0x84, 0xaa, 0x60, 0x24, 0x28,
-	0x1c, 0x52, 0x14, 0x2e, 0x20, 0xc1, 0x21, 0x89, 0x1d, 0xd5, 0x52, 0x70, 0x5a, 0x3b, 0x69, 0xb9,
-	0x55, 0x4e, 0xbc, 0x29, 0x56, 0x13, 0xaf, 0xe5, 0x75, 0x5b, 0xb5, 0xef, 0x80, 0x54, 0x09, 0xc4,
-	0xe3, 0x70, 0xe1, 0xca, 0xfb, 0x70, 0x65, 0x77, 0xb3, 0x09, 0x4d, 0x42, 0x55, 0x4e, 0x9e, 0x99,
-	0x9d, 0x6f, 0xfc, 0xcd, 0x37, 0xb3, 0x0b, 0x79, 0xbf, 0x5f, 0x8d, 0x13, 0x92, 0x12, 0x54, 0xf0,
-	0x53, 0x32, 0x0e, 0x07, 0xfd, 0x84, 0xf8, 0xc1, 0xc0, 0xa7, 0xa9, 0x61, 0xc2, 0x83, 0xc6, 0xd4,
-	0x71, 0x31, 0x8d, 0x49, 0x44, 0x31, 0xda, 0x03, 0xdd, 0x4b, 0xfd, 0xf4, 0x9c, 0x96, 0x94, 0x8a,
-	0xb2, 0xbb, 0x59, 0xdb, 0xae, 0x2e, 0xc0, 0xaa, 0x93, 0x63, 0x57, 0xa7, 0xe2, 0x6b, 0x3c, 0x87,
-	0xe2, 0xac, 0xca, 0x47, 0x4c, 0xa9, 0x7f, 0x8a, 0x11, 0x02, 0xd5, 0xf4, 0x53, 0x5f, 0x94, 0x58,
-	0x77, 0xd5, 0x80, 0xd9, 0xc6, 0x17, 0x05, 0xb6, 0xbd, 0xf0, 0x34, 0x62, 0xa0, 0x04, 0x1f, 0x90,
-	0x51, 0x38, 0xb8, 0xb2, 0xa2, 0x0b, 0x3c, 0x22, 0x31, 0x46, 0x25, 0xc8, 0x1d, 0xe1, 0x84, 0x86,
-	0x24, 0x12, 0x10, 0xcd, 0xcd, 0x5d, 0x4c, 0x5c, 0xf4, 0x16, 0xf4, 0x49, 0x6e, 0x29, 0xc3, 0x0e,
-	0xd6, 0x6a, 0x95, 0x65, 0x3a, 0xf3, 0x35, 0x5d, 0x3d, 0x16, 0x5f, 0xb4, 0x03, 0x60, 0x07, 0x38,
-	0x4a, 0xc3, 0x34, 0xc4, 0xb4, 0x94, 0xad, 0x64, 0x19, 0x13, 0x08, 0x67, 0x11, 0xe3, 0x97, 0x02,
-	0x85, 0x05, 0x2c, 0x7a, 0x02, 0x79, 0x1e, 0xc2, 0x41, 0xe3, 0x6a, 0x42, 0x64, 0x7f, 0xc5, 0xcd,
-	0x53, 0x19, 0x41, 0x1f, 0x40, 0x6d, 0x25, 0x64, 0x2c, 0x99, 0xbc, 0xb8, 0x8f, 0x49, 0xd5, 0xe9,
-	0x9c, 0xa7, 0x9d, 0x21, 0x2b, 0xa1, 0x0e, 0x19, 0xac, 0xdc, 0x05, 0x7d, 0x12, 0x41, 0xeb, 0xa0,
-	0x38, 0xb2, 0x51, 0x25, 0x42, 0xef, 0x21, 0x2f, 0x00, 0x9c, 0x66, 0x86, 0xd1, 0xfc, 0x9f, 0x26,
-	0xf3, 0xb1, 0x44, 0x34, 0x74, 0x50, 0xbb, 0x57, 0x31, 0x36, 0x7e, 0x2a, 0x8c, 0x3b, 0xc6, 0x67,
-	0x76, 0x34, 0x24, 0xe8, 0x1d, 0x68, 0x6c, 0x4a, 0x49, 0x2a, 0x67, 0xf8, 0x6c, 0xb9, 0x9e, 0xcc,
-	0xac, 0x8a, 0x34, 0x5e, 0xc0, 0xd5, 0x28, 0x37, 0xd1, 0x2e, 0x53, 0x25, 0xc6, 0x83, 0x70, 0x18,
-	0xe2, 0xc0, 0x39, 0x1f, 0xf7, 0x71, 0x22, 0xfa, 0x55, 0xdd, 0x02, 0x9d, 0x0f, 0x73, 0x81, 0x8f,
-	0xc3, 0x28, 0x20, 0x97, 0x5e, 0x78, 0x8d, 0x99, 0xc0, 0x3c, 0x09, 0x2e, 0x67, 0x11, 0xa3, 0x06,
-	0xab, 0xb3, 0xea, 0x08, 0x58, 0xf3, 0xd6, 0xb1, 0xe5, 0x75, 0x8b, 0x2b, 0xdc, 0xee, 0xb4, 0x4d,
-	0x6e, 0x2b, 0x68, 0x83, 0x25, 0x1d, 0x58, 0x4d, 0xbb, 0x65, 0x5b, 0x66, 0x31, 0x63, 0xbc, 0x84,
-	0x42, 0x7d, 0x70, 0x16, 0x91, 0xcb, 0x11, 0x0e, 0x4e, 0xf1, 0x98, 0x0d, 0x0b, 0x6d, 0x31, 0xe4,
-	0x84, 0x87, 0x22, 0x7e, 0xa1, 0x47, 0xc2, 0x33, 0xbe, 0x2b, 0xb0, 0x61, 0xe2, 0x51, 0xc8, 0x36,
-	0xa5, 0x17, 0xb3, 0x0d, 0xc3, 0xa8, 0xbd, 0x04, 0x16, 0x90, 0x7f, 0xe9, 0xb9, 0x90, 0xc7, 0x66,
-	0x54, 0xf0, 0x17, 0xfe, 0xbb, 0x07, 0x2a, 0x57, 0x49, 0x4e, 0xfb, 0xf1, 0x9d, 0x12, 0xf2, 0xf9,
-	0x52, 0x66, 0xcf, 0x26, 0x71, 0xa3, 0x80, 0xd6, 0x18, 0x91, 0xc1, 0xd9, 0x2d, 0xea, 0x99, 0xdb,
-	0xd4, 0x51, 0x99, 0x4d, 0x3c, 0xc1, 0x17, 0xfb, 0x3e, 0xfd, 0x2c, 0x74, 0x5b, 0x67, 0xf3, 0x94,
-	0x3e, 0x7a, 0x04, 0xda, 0x41, 0x42, 0xc8, 0xb0, 0xa4, 0x8a, 0x03, 0x2d, 0xe6, 0x0e, 0x5b, 0xbd,
-	0xbc, 0xbc, 0x5b, 0xb4, 0xa4, 0x89, 0x1d, 0x79, 0xba, 0x44, 0x68, 0xf1, 0x16, 0xba, 0xf9, 0xb1,
-	0x84, 0x18, 0xd7, 0x50, 0x90, 0x52, 0xdd, 0xba, 0xe7, 0x9a, 0x95, 0x24, 0x24, 0xb9, 0xe7, 0x9a,
-	0xb3, 0xee, 0x34, 0xcc, 0xf3, 0x50, 0x55, 0x76, 0x25, 0x05, 0xd9, 0x5a, 0xfe, 0x3f, 0x3f, 0xe5,
-	0xf9, 0x7d, 0x6e, 0x4c, 0xe5, 0x78, 0xe5, 0x4f, 0x1f, 0x14, 0xb4, 0x06, 0x39, 0xaf, 0xd7, 0x6c,
-	0x5a, 0x9e, 0xc7, 0x96, 0xa0, 0x08, 0x6b, 0x8d, 0xba, 0x79, 0xe2, 0x5a, 0x87, 0x3d, 0xbe, 0x09,
-	0x37, 0x59, 0xb4, 0x09, 0xab, 0xad, 0x8e, 0xdb, 0xb0, 0x4d, 0xd3, 0x72, 0x8a, 0x5f, 0x85, 0xef,
-	0x74, 0xba, 0x27, 0xad, 0x4e, 0xcf, 0x31, 0x8b, 0xdf, 0xb2, 0xec, 0x91, 0x78, 0xe8, 0x59, 0xee,
-	0x91, 0xdd, 0xb4, 0x4e, 0x7a, 0x4e, 0xfd, 0xa8, 0x6e, 0xb7, 0xeb, 0x8d, 0xb6, 0x55, 0xfc, 0x9d,
-	0xad, 0xfd, 0x60, 0x57, 0xb9, 0x2e, 0xd8, 0xcc, 0x34, 0x40, 0x9f, 0x60, 0xf5, 0xaf, 0x73, 0xbf,
-	0x58, 0x65, 0xe3, 0xee, 0x94, 0xa9, 0x66, 0xc6, 0xca, 0xae, 0xf2, 0x5a, 0x41, 0x87, 0x90, 0x93,
-	0x62, 0xa2, 0x9d, 0x25, 0xd0, 0xdc, 0x46, 0x96, 0x2b, 0x77, 0x9d, 0xcf, 0x97, 0xec, 0xeb, 0xe2,
-	0x85, 0x7e, 0xf3, 0x27, 0x00, 0x00, 0xff, 0xff, 0xdd, 0xa9, 0x3a, 0x84, 0xad, 0x05, 0x00, 0x00,
+	// 1063 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x56, 0x51, 0x6f, 0xe3, 0x44,
+	0x10, 0xae, 0x13, 0xdb, 0x71, 0xa6, 0xe9, 0xc5, 0xb7, 0x70, 0x77, 0xa1, 0xa0, 0x53, 0x31, 0x08,
+	0x0a, 0x0f, 0xb9, 0x53, 0x91, 0x10, 0x08, 0x78, 0x48, 0x62, 0x47, 0x17, 0x51, 0x92, 0x9c, 0x9d,
+	0xf4, 0x78, 0xab, 0x1c, 0x67, 0xd3, 0xb3, 0x9a, 0x78, 0x8d, 0xd7, 0x6d, 0xd5, 0xfb, 0x0d, 0x20,
+	0x9d, 0x04, 0xe2, 0x17, 0xf0, 0x3b, 0xee, 0x85, 0x57, 0xfe, 0x0f, 0xaf, 0xec, 0xae, 0xd7, 0xbe,
+	0x24, 0x6e, 0xa9, 0xee, 0xa5, 0xdd, 0x99, 0x9d, 0x99, 0xfd, 0xe6, 0xdb, 0x6f, 0xc7, 0x01, 0xc3,
+	0x9f, 0xb5, 0xe3, 0x84, 0xa4, 0x04, 0x35, 0xfd, 0x94, 0xac, 0xc2, 0x60, 0x96, 0x10, 0x7f, 0x1e,
+	0xf8, 0x34, 0xb5, 0x6c, 0xb8, 0xdf, 0xcd, 0x0d, 0x17, 0xd3, 0x98, 0x44, 0x14, 0xa3, 0x27, 0xa0,
+	0x7b, 0xa9, 0x9f, 0x5e, 0xd0, 0x96, 0x72, 0xa0, 0x1c, 0xde, 0x3b, 0x7a, 0xd4, 0xde, 0x4a, 0x6b,
+	0x67, 0xdb, 0xae, 0x4e, 0xc5, 0x7f, 0xeb, 0x33, 0x30, 0x8b, 0x2a, 0x3f, 0x61, 0x4a, 0xfd, 0x33,
+	0x8c, 0x10, 0xa8, 0xb6, 0x9f, 0xfa, 0xa2, 0x44, 0xc3, 0x55, 0xe7, 0x6c, 0x6d, 0x4d, 0x00, 0xbc,
+	0xf0, 0x2c, 0xc2, 0x73, 0xbe, 0x83, 0x0e, 0xa1, 0x39, 0xf6, 0xaf, 0x97, 0x2c, 0xcf, 0x89, 0x2e,
+	0xf1, 0x92, 0xc4, 0x58, 0x06, 0x37, 0xe3, 0x4d, 0x37, 0xfa, 0x08, 0xea, 0x3c, 0x8f, 0x9d, 0x95,
+	0xe0, 0x56, 0x45, 0xc4, 0xd4, 0x69, 0xee, 0xb0, 0x7a, 0xa5, 0x3a, 0xa8, 0x05, 0x35, 0xe9, 0x92,
+	0x25, 0x6b, 0xb2, 0x24, 0x7a, 0xc8, 0x7a, 0xe3, 0x10, 0x12, 0x59, 0x47, 0xa7, 0xc2, 0xb2, 0xfe,
+	0x52, 0x60, 0x77, 0x92, 0xf8, 0x11, 0xf5, 0x83, 0x34, 0x24, 0x11, 0xab, 0xa0, 0x8f, 0x62, 0xff,
+	0x97, 0x0b, 0x89, 0xe9, 0xd9, 0x8e, 0xab, 0x13, 0x61, 0xa3, 0xaf, 0xe1, 0x41, 0x8f, 0x44, 0x8b,
+	0xf0, 0xec, 0x22, 0xf1, 0x79, 0x68, 0x01, 0xbe, 0x22, 0x03, 0x1f, 0x04, 0x37, 0x6d, 0xa3, 0xef,
+	0xb2, 0xe6, 0x05, 0x66, 0xda, 0xaa, 0x1e, 0x54, 0x0f, 0x77, 0x8f, 0x3e, 0x2c, 0x33, 0x5b, 0xf0,
+	0xe3, 0x42, 0xd1, 0x22, 0xed, 0xea, 0xa0, 0x4e, 0xae, 0x63, 0x6c, 0xfd, 0xaa, 0xdc, 0x72, 0x3a,
+	0xda, 0x07, 0xc3, 0xc3, 0x0c, 0x5f, 0x14, 0x64, 0x90, 0x55, 0xd7, 0xa0, 0xd2, 0xe6, 0x74, 0xf4,
+	0x5e, 0xfa, 0x61, 0x34, 0xb0, 0x65, 0xd7, 0xb5, 0x20, 0x33, 0xd1, 0x0f, 0x50, 0x73, 0xa2, 0x34,
+	0x09, 0x0b, 0x44, 0x9f, 0x94, 0x10, 0x6d, 0x1d, 0x97, 0x26, 0xd7, 0x6e, 0x0d, 0x67, 0x39, 0xd6,
+	0x15, 0xa0, 0xf2, 0x36, 0xfa, 0x14, 0xf6, 0x36, 0xbc, 0xf2, 0x0e, 0xf6, 0x36, 0x78, 0xd9, 0xe2,
+	0xa3, 0xf2, 0x4e, 0x7c, 0x58, 0x6f, 0x2a, 0x5b, 0x67, 0xac, 0xf7, 0xa8, 0x6c, 0xf6, 0x78, 0x0f,
+	0x2a, 0xb2, 0xf1, 0xba, 0x5b, 0x09, 0x6d, 0x64, 0x41, 0xe3, 0x98, 0x0b, 0x95, 0xcc, 0xc3, 0x45,
+	0x88, 0xe7, 0xac, 0x71, 0xce, 0x56, 0x63, 0xb9, 0xe6, 0x43, 0x76, 0xc6, 0x77, 0x4b, 0x15, 0x0f,
+	0xe0, 0xe9, 0xff, 0x93, 0xb2, 0x69, 0xf1, 0x3c, 0x57, 0x4d, 0xd9, 0xdf, 0xe2, 0x0d, 0x68, 0x6f,
+	0xdf, 0x00, 0x6a, 0x03, 0xca, 0x4e, 0x09, 0x44, 0xf4, 0x98, 0x2c, 0xc3, 0xe0, 0xba, 0xa5, 0x0b,
+	0x74, 0x68, 0x55, 0xda, 0xb1, 0xa6, 0x70, 0xbf, 0x54, 0x1e, 0x01, 0xe8, 0xd9, 0xb6, 0xb9, 0xc3,
+	0xd7, 0x7d, 0x7f, 0x96, 0x84, 0x81, 0xa9, 0xa0, 0x3a, 0x68, 0x82, 0x04, 0xb3, 0x82, 0x0c, 0x50,
+	0x3d, 0xb2, 0x24, 0x66, 0x95, 0x3b, 0x7f, 0xf4, 0x17, 0xe7, 0xbe, 0xa9, 0x72, 0xe7, 0xb8, 0xdb,
+	0x9f, 0x98, 0x9a, 0xb5, 0xc8, 0x2b, 0xa0, 0x09, 0x34, 0x8b, 0x7b, 0x90, 0x68, 0x38, 0x57, 0xbb,
+	0x47, 0x87, 0x37, 0x5e, 0xc6, 0x5a, 0x5c, 0xae, 0x3d, 0xa6, 0xf9, 0x26, 0xdd, 0xdc, 0x2a, 0x04,
+	0xfb, 0x9b, 0x02, 0x8f, 0x6e, 0x49, 0xe3, 0x57, 0x76, 0x82, 0x13, 0x9a, 0x2b, 0x44, 0x73, 0x6b,
+	0x97, 0x99, 0x89, 0xbe, 0xc9, 0xd1, 0x49, 0x28, 0x07, 0x77, 0x41, 0x71, 0xf5, 0x38, 0xeb, 0xe6,
+	0x31, 0xc0, 0x60, 0xce, 0xe4, 0x19, 0xa6, 0xb9, 0xa6, 0x1b, 0x2e, 0x84, 0x85, 0xc7, 0xfa, 0x47,
+	0x29, 0xb5, 0xcb, 0xc6, 0x8b, 0x91, 0xc9, 0xac, 0x7b, 0x9d, 0x01, 0x61, 0x0d, 0x19, 0x54, 0x7a,
+	0xd8, 0x13, 0x51, 0xfb, 0x09, 0x59, 0x49, 0x24, 0x9f, 0xdf, 0x85, 0xa4, 0x3d, 0x1c, 0x5d, 0xa4,
+	0xa3, 0x05, 0x2b, 0xa1, 0x2e, 0x58, 0xda, 0xfe, 0x04, 0xf4, 0xcc, 0x83, 0x1a, 0xa0, 0x0c, 0x65,
+	0xa3, 0x4a, 0x84, 0xbe, 0x07, 0x43, 0x24, 0x84, 0x85, 0xf8, 0xef, 0x6e, 0xd2, 0x88, 0x65, 0x46,
+	0x41, 0xef, 0xdf, 0x0a, 0x7f, 0xf6, 0xf8, 0x7c, 0x10, 0x2d, 0x08, 0xfa, 0x16, 0x34, 0x36, 0x98,
+	0x93, 0x54, 0x8e, 0xed, 0xf2, 0x53, 0xce, 0x23, 0xdb, 0x22, 0x4c, 0x08, 0x55, 0xa3, 0x7c, 0xc9,
+	0x67, 0xb1, 0x17, 0xe3, 0x40, 0x88, 0x7f, 0x78, 0xb1, 0x9a, 0xc9, 0xf9, 0xa8, 0xb2, 0x8b, 0xdd,
+	0x74, 0x73, 0x82, 0x5f, 0x84, 0xd1, 0x9c, 0x5c, 0x79, 0xe1, 0x2b, 0x2c, 0xdf, 0x0e, 0x5c, 0x15,
+	0x1e, 0xeb, 0x88, 0xcd, 0xea, 0xbc, 0x3a, 0xd7, 0xe6, 0xd0, 0x79, 0xe1, 0x78, 0x93, 0x4c, 0xa7,
+	0xa3, 0x63, 0x9b, 0xaf, 0x15, 0xb4, 0xc7, 0x82, 0xc6, 0x4e, 0x6f, 0xd0, 0x1f, 0x38, 0xb6, 0x59,
+	0xb1, 0xbe, 0x80, 0x66, 0x27, 0x38, 0x8f, 0xc8, 0xd5, 0x12, 0xcf, 0xcf, 0xf0, 0x8a, 0x5d, 0x16,
+	0x9f, 0xd3, 0x12, 0x47, 0x36, 0xcc, 0xf4, 0x48, 0x58, 0xd6, 0x9f, 0x0a, 0xec, 0xd9, 0x78, 0x19,
+	0x32, 0xa5, 0x4c, 0x63, 0xf6, 0xa0, 0x30, 0x3a, 0x2e, 0x25, 0x8b, 0x94, 0x9b, 0xf8, 0xdc, 0x8a,
+	0xe3, 0xba, 0xf5, 0xb7, 0xce, 0x7d, 0xc2, 0x9e, 0x0d, 0x63, 0x49, 0xde, 0xf6, 0x07, 0xb7, 0x52,
+	0xc8, 0xef, 0x97, 0xb2, 0x75, 0x71, 0x13, 0xaf, 0x15, 0xd0, 0xba, 0x4b, 0x12, 0x9c, 0xaf, 0x41,
+	0xaf, 0xac, 0x43, 0xe7, 0x13, 0x7a, 0x9c, 0xe0, 0xcb, 0x67, 0x3e, 0x7d, 0x29, 0x78, 0x6b, 0xb0,
+	0xfb, 0x94, 0x36, 0x7a, 0x1f, 0xb4, 0x71, 0x42, 0xc8, 0x42, 0x0c, 0x9c, 0x86, 0xab, 0xc5, 0xdc,
+	0x60, 0xd2, 0x33, 0xe4, 0xe7, 0x94, 0xb2, 0x19, 0xc2, 0x35, 0xf2, 0x71, 0x09, 0xd0, 0xf6, 0x87,
+	0xd7, 0x35, 0x56, 0x32, 0xc5, 0x7a, 0x05, 0x4d, 0x49, 0xd5, 0xda, 0xa7, 0x5d, 0x73, 0x92, 0x84,
+	0x24, 0x77, 0x7c, 0xd9, 0x59, 0x77, 0x1a, 0xe6, 0x71, 0x6c, 0x5c, 0x65, 0x5d, 0x49, 0x42, 0x1e,
+	0x96, 0xcf, 0xe7, 0xbb, 0x3c, 0x7e, 0xc6, 0x17, 0x39, 0x1d, 0x5f, 0xfa, 0xf9, 0x6f, 0x08, 0xb4,
+	0x0b, 0x35, 0x6f, 0xda, 0xeb, 0x39, 0x9e, 0xc7, 0x44, 0x60, 0xc2, 0x6e, 0xb7, 0x63, 0x9f, 0xba,
+	0xce, 0xf3, 0x29, 0x57, 0xc2, 0xeb, 0x2a, 0x9b, 0xce, 0xf5, 0xfe, 0xc8, 0xed, 0x0e, 0x6c, 0xdb,
+	0x19, 0x9a, 0xbf, 0x0b, 0x7b, 0x38, 0x9a, 0x9c, 0xf6, 0x47, 0xd3, 0xa1, 0x6d, 0xfe, 0x51, 0x65,
+	0x43, 0xe2, 0x3d, 0xcf, 0x71, 0x4f, 0x06, 0x3d, 0xe7, 0x74, 0x3a, 0xec, 0x9c, 0x74, 0x06, 0xc7,
+	0x9d, 0xee, 0xb1, 0x63, 0xfe, 0x5b, 0x3d, 0x7a, 0xc3, 0x9e, 0x72, 0x47, 0xa0, 0x29, 0x38, 0x40,
+	0x3f, 0x43, 0xfd, 0xad, 0x71, 0x37, 0x59, 0xfb, 0xd6, 0xed, 0x21, 0x39, 0x67, 0xd6, 0xce, 0xa1,
+	0xf2, 0x54, 0x41, 0xcf, 0xa1, 0x26, 0xc9, 0x44, 0x8f, 0x4b, 0x49, 0x1b, 0x8a, 0xdc, 0x3f, 0xb8,
+	0x6d, 0x7f, 0xb3, 0xe4, 0x4c, 0x17, 0x3f, 0xca, 0xbe, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x52,
+	0xe5, 0xdc, 0xcc, 0xa0, 0x09, 0x00, 0x00,
 }
diff --git a/orderer/atomicbroadcast/ab.proto b/orderer/atomicbroadcast/ab.proto
index 05abaf22da6..d66a9ff5dd1 100644
--- a/orderer/atomicbroadcast/ab.proto
+++ b/orderer/atomicbroadcast/ab.proto
@@ -31,10 +31,90 @@ message BroadcastResponse {
     Status Status = 1;
 }
 
+// For backwards compatibility, this is message is being left as bytes for the moment. 
+// Internally, for testing authentication, the Data payload will be a marshalled SignedData message
+// However in the future, this whole message is likely to go away.
+// XXX Temporary
 message BroadcastMessage {
     bytes Data = 1;
 }
 
+// SignedData is a temporary message type to be removed once the real transaction type is finalized
+// Note that the identity of the signer is explicitely not included, but embedded in the envelope because
+// apparently the signature should always be over an object which contains the signer's identity
+// XXX Temporary
+message SignedData {
+    bytes PayloadEnvelope = 1;
+    bytes Signature = 2;
+}
+
+// PayloadEnvelope is the thin wrapper which allows the embedding of a signer's identity to sign over
+// XXX Temporary
+message PayloadEnvelope {
+    bytes Payload = 1;
+    bytes Signer = 2;
+}
+
+
+// Transaction embeds a configuration change and associated signoffs
+// This will be superseded once the real transaction format is finalized
+// XXX Temporary
+message Transaction {
+    oneof Type {
+        bytes Opaque = 1;               // An opaque set of bytes
+	bytes ConfigurationEnvelope = 2;        // A marshalled Configuration message
+    }
+    repeated SignedData Signatures = 3; // Signatures over the hash of the bytes for Type
+}
+
+// ConfigurationEnvelope is designed to contain _all_ configuration for a chain and is
+// intended to be a permenant data structure (noted explicitly because others above are temporary)
+// Its generated with the following scheme.  Given an existing configuration, a new configuration
+// increments the Sequence number, and updates any existing configuration entries and or adds new
+// configuration entries.  For each added or modified entry, the LastModified value must be set
+// to the Sequence number of the ConfigurationEnvelope.  The configuration manager will verify that
+// all configuration changes satisfy system policy, that all configuration changes have a LastModified
+// field equal to Sequence, that no configuration has been deleted without corresponding authorization,
+// that the configuration is well formed, and that some configuration item corresponds to the new
+// ConfigurationEnvelope sequence number.
+message ConfigurationEnvelope {
+    uint64 Sequence = 1;
+    bytes ChainID = 2;
+    repeated ConfigurationEntry Entries = 3;
+}
+
+// This message may change slightly depending on the finalization of signature schemes for transactions
+message ConfigurationEntry {
+    bytes Configuration = 1;
+    repeated SignedData Signatures = 2; // Signatures over the hash of Configuration
+}
+
+
+message Configuration {
+    enum ConfigurationType {
+        Policy = 0;
+        Fabric = 1;
+	Chain = 2;
+        Solo = 3;
+        Kafka = 4;
+        PBFT = 5;
+    }
+
+    bytes ChainID = 1;              // A Globally Unique Chain ID
+    string ID = 2;                  // A unique ID, unique scoped by Type
+    uint64 LastModified = 3;        // The Sequence number in the ConfigurationEnvelope this item was last modified
+    ConfigurationType Type = 4;     // The type of configuration
+    bytes Data = 5;                 // The byte representation of this configuration, usually a marshaled message
+    string ModificationPolicy = 6;  // What policy to check before allowing modification
+}
+
+// Policy expresses a policy which the orderer can evaluate, because there has been some desire expressed to support
+// multiple policy engines, this is typed as a oneof for now
+message Policy {
+    oneof Type {
+        SignaturePolicyEnvelope SignaturePolicy = 2;
+    }
+}
 
 // SignaturePolicyEnvelope wraps a SignaturePolicy and includes a version for future enhancements
 message SignaturePolicyEnvelope {