From 4bead6804d0e81f86db16ffe46dd0be32aead373 Mon Sep 17 00:00:00 2001 From: Jason Yellick Date: Sat, 15 Oct 2016 23:55:32 -0400 Subject: [PATCH] Define Chain Configuration Protos In order to bootstrap a chain, certain configuration must be embedded in its genesis block. This configuration needs to be in a well defined format so that it is easy for consumers to read. Further, this configuration must be able to be modified in the future, so must define policy which dictates how modification is allowed. This changeset defines a set of protobuf messages in ab.proto which are designed to satisfy the above requirements. The configuration is essentially a list of configuration items, which have a name (string), a type (enum), a payload (bytes), and a reference to a modification policy (string). Additionally a sequence number scheme is included to prevent replay. This changeset also defines a wrapper for the policy configuration item type. It references the small proto DSL for signature validation, but embeds this in a one-of concept in case anyone wishes to swap in other policy validation schemes. This is related to, but does not completely satisfy: https://jira.hyperledger.org/browse/FAB-724 Change-Id: Id1cb73851a426f903455bb5b4eed552a65cc9327 Signed-off-by: Jason Yellick --- orderer/atomicbroadcast/ab.pb.go | 488 +++++++++++++++++++++++++++---- orderer/atomicbroadcast/ab.proto | 80 +++++ 2 files changed, 513 insertions(+), 55 deletions(-) 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 {