diff --git a/data/outport/outportBlock.pb.go b/data/outport/outportBlock.pb.go index f7020b56..e13bd827 100644 --- a/data/outport/outportBlock.pb.go +++ b/data/outport/outportBlock.pb.go @@ -16,6 +16,7 @@ import ( receipt "github.com/multiversx/mx-chain-core-go/data/receipt" rewardTx "github.com/multiversx/mx-chain-core-go/data/rewardTx" smartContractResult "github.com/multiversx/mx-chain-core-go/data/smartContractResult" + stateChange "github.com/multiversx/mx-chain-core-go/data/stateChange" transaction "github.com/multiversx/mx-chain-core-go/data/transaction" io "io" math "math" @@ -47,6 +48,7 @@ type OutportBlock struct { SignersIndexes []uint64 `protobuf:"varint,8,rep,packed,name=SignersIndexes,proto3" json:"signersIndexes,omitempty"` HighestFinalBlockNonce uint64 `protobuf:"varint,9,opt,name=HighestFinalBlockNonce,proto3" json:"highestFinalBlockNonce"` HighestFinalBlockHash []byte `protobuf:"bytes,10,opt,name=HighestFinalBlockHash,proto3" json:"highestFinalBlockHash,omitempty"` + StateChanges map[string]*stateChange.StateChanges `protobuf:"bytes,11,rep,name=StateChanges,proto3" json:"stateChanges,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (m *OutportBlock) Reset() { *m = OutportBlock{} } @@ -147,6 +149,13 @@ func (m *OutportBlock) GetHighestFinalBlockHash() []byte { return nil } +func (m *OutportBlock) GetStateChanges() map[string]*stateChange.StateChanges { + if m != nil { + return m.StateChanges + } + return nil +} + type BlockData struct { ShardID uint32 `protobuf:"varint,1,opt,name=ShardID,proto3" json:"shardID,omitempty"` HeaderBytes []byte `protobuf:"bytes,2,opt,name=HeaderBytes,proto3" json:"headerBytes,omitempty"` @@ -1109,6 +1118,7 @@ func (m *Shard) GetShardID() uint32 { func init() { proto.RegisterType((*OutportBlock)(nil), "proto.OutportBlock") proto.RegisterMapType((map[string]*alteredAccount.AlteredAccount)(nil), "proto.OutportBlock.AlteredAccountsEntry") + proto.RegisterMapType((map[string]*stateChange.StateChanges)(nil), "proto.OutportBlock.StateChangesEntry") proto.RegisterType((*BlockData)(nil), "proto.BlockData") proto.RegisterType((*TransactionPool)(nil), "proto.TransactionPool") proto.RegisterMapType((map[string]*TxInfo)(nil), "proto.TransactionPool.InvalidTxsEntry") @@ -1138,128 +1148,132 @@ func init() { func init() { proto.RegisterFile("outportBlock.proto", fileDescriptor_661b95cef868af95) } var fileDescriptor_661b95cef868af95 = []byte{ - // 1931 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x4b, 0x70, 0xe3, 0x48, - 0x19, 0x8e, 0xfc, 0x88, 0xe3, 0xdf, 0x89, 0x93, 0xe9, 0xcd, 0x04, 0x4d, 0x86, 0xb5, 0x82, 0x67, - 0x76, 0x49, 0x31, 0x8c, 0xcd, 0xce, 0x4e, 0x51, 0x53, 0x33, 0xb5, 0x05, 0xa3, 0xcc, 0xcb, 0xcc, - 0x23, 0x29, 0x25, 0xb0, 0xcc, 0x16, 0x55, 0x20, 0x5b, 0x1d, 0x59, 0x35, 0xb6, 0xda, 0x48, 0xed, - 0x60, 0x73, 0x81, 0x13, 0xcb, 0x81, 0xad, 0xe2, 0xc8, 0x8d, 0x2b, 0xc5, 0x81, 0x2b, 0x07, 0xee, - 0x14, 0x27, 0x6a, 0x4e, 0xd4, 0x9c, 0x04, 0x93, 0xb9, 0x50, 0x3a, 0x50, 0x7b, 0xe3, 0x4a, 0xa9, - 0xbb, 0x65, 0xb5, 0x64, 0x65, 0xcb, 0x59, 0xd8, 0xe2, 0x12, 0x4b, 0xff, 0xe3, 0xfb, 0xbb, 0xff, - 0x57, 0xff, 0xad, 0x00, 0x22, 0x63, 0x3a, 0x22, 0x1e, 0xd5, 0x07, 0xa4, 0xf7, 0xa2, 0x35, 0xf2, - 0x08, 0x25, 0xa8, 0xcc, 0x7e, 0xb6, 0xaf, 0xdb, 0x0e, 0xed, 0x8f, 0xbb, 0xad, 0x1e, 0x19, 0xb6, - 0x6d, 0x62, 0x93, 0x36, 0x23, 0x77, 0xc7, 0xc7, 0xec, 0x8d, 0xbd, 0xb0, 0x27, 0xae, 0xb5, 0xfd, - 0x81, 0x24, 0x3e, 0x1c, 0x0f, 0xa8, 0x73, 0x82, 0x3d, 0x7f, 0xd2, 0x1e, 0x4e, 0xae, 0xf7, 0xfa, - 0xa6, 0xe3, 0x5e, 0xef, 0x11, 0x0f, 0x5f, 0xb7, 0x49, 0xdb, 0x32, 0xa9, 0xd9, 0xee, 0x46, 0xe6, - 0xf8, 0x5f, 0xa1, 0x7e, 0xf7, 0x3c, 0xea, 0xd4, 0x33, 0x5d, 0xdf, 0xec, 0x51, 0x87, 0xb8, 0xed, - 0x01, 0xb1, 0x05, 0x44, 0xe7, 0xf3, 0x42, 0x48, 0xcf, 0x02, 0xea, 0xf9, 0x79, 0xa0, 0xfc, 0xa1, - 0xe9, 0xd1, 0x3d, 0xe2, 0x52, 0xcf, 0xec, 0x51, 0x03, 0xfb, 0xe3, 0x01, 0xcd, 0xa3, 0x7d, 0x9e, - 0x8d, 0x7a, 0xb8, 0x87, 0x9d, 0x11, 0x8d, 0x7f, 0x05, 0xc4, 0xde, 0xf9, 0x20, 0x7e, 0x62, 0x7a, - 0xd6, 0xd1, 0x64, 0xf6, 0x20, 0x40, 0xf6, 0xcf, 0x03, 0x62, 0x0e, 0x28, 0xf6, 0xb0, 0x75, 0xb7, - 0xd7, 0x23, 0x63, 0x97, 0x66, 0x5e, 0x39, 0x60, 0xf3, 0x4f, 0x15, 0x58, 0xdd, 0x97, 0xb2, 0x09, - 0xb5, 0xa1, 0x72, 0xd8, 0x37, 0x3d, 0xab, 0x73, 0x4f, 0x55, 0x76, 0x94, 0xdd, 0x35, 0xfd, 0x62, - 0x18, 0x68, 0x17, 0x7c, 0x4e, 0xfa, 0x3a, 0x19, 0x3a, 0x14, 0x0f, 0x47, 0x74, 0x6a, 0xc4, 0x52, - 0xe8, 0x21, 0x54, 0x99, 0xe6, 0x3d, 0x93, 0x9a, 0x6a, 0x61, 0x47, 0xd9, 0xad, 0xdd, 0xd8, 0xe0, - 0xe0, 0xad, 0x19, 0x5d, 0xff, 0x52, 0x18, 0x68, 0x6f, 0x75, 0xe3, 0x57, 0x09, 0x26, 0xd1, 0x45, - 0x3f, 0x84, 0xf5, 0xa3, 0x24, 0xa6, 0x07, 0x84, 0x0c, 0xd4, 0x22, 0x83, 0xdb, 0x12, 0x70, 0x19, - 0xae, 0xfe, 0x76, 0x18, 0x68, 0x97, 0x68, 0x9a, 0x28, 0x41, 0x67, 0xd1, 0x90, 0x0f, 0x9b, 0x8f, - 0xb0, 0x69, 0x61, 0xef, 0xa1, 0xe9, 0xef, 0x11, 0xd7, 0x1f, 0x0f, 0x47, 0x11, 0x4f, 0x2d, 0x31, - 0x2b, 0x97, 0x85, 0x95, 0x3c, 0x11, 0xbd, 0x19, 0x06, 0x5a, 0xa3, 0x9f, 0xc3, 0x91, 0xec, 0xe5, - 0x82, 0xa3, 0x1f, 0xc3, 0xfa, 0xdd, 0x94, 0xe3, 0x7d, 0xb5, 0xbc, 0x53, 0xdc, 0xad, 0xdd, 0xd8, - 0x15, 0xf6, 0x64, 0xef, 0xb7, 0x32, 0xa2, 0xf7, 0x5d, 0xea, 0x4d, 0xf9, 0x3e, 0xd3, 0xd1, 0xf3, - 0xe5, 0x7d, 0x66, 0x94, 0xd0, 0x0f, 0x60, 0xeb, 0x19, 0xa1, 0xa6, 0xe7, 0xfc, 0x14, 0x5b, 0x7c, - 0x4d, 0xfe, 0x23, 0xd3, 0xef, 0x63, 0x5f, 0x5d, 0xde, 0x29, 0xee, 0x56, 0xf5, 0xab, 0x61, 0xa0, - 0xed, 0xb8, 0xb9, 0x12, 0x12, 0xec, 0x19, 0x18, 0xe8, 0x36, 0xd4, 0x9f, 0x8d, 0x87, 0x5d, 0xec, - 0xed, 0x1f, 0xb3, 0x14, 0xf0, 0xd5, 0x0a, 0xcb, 0x13, 0x14, 0x06, 0x5a, 0xdd, 0x4d, 0x71, 0x8c, - 0x8c, 0x24, 0xba, 0x07, 0xf5, 0x43, 0xc7, 0x76, 0xb1, 0xe7, 0x77, 0x5c, 0x0b, 0x4f, 0xb0, 0xaf, - 0xae, 0xec, 0x14, 0x77, 0x4b, 0xfa, 0x97, 0xc3, 0x40, 0x53, 0xfd, 0x14, 0x47, 0x5a, 0x49, 0x46, - 0x07, 0x19, 0xb0, 0xf5, 0xc8, 0xb1, 0xfb, 0xd8, 0xa7, 0x0f, 0x1c, 0xd7, 0x1c, 0x30, 0xcf, 0x3d, - 0x23, 0x6e, 0x0f, 0xab, 0xd5, 0x1d, 0x65, 0xb7, 0xa4, 0x6f, 0x87, 0x81, 0xb6, 0xd5, 0xcf, 0x95, - 0x30, 0xce, 0xd0, 0x44, 0xcf, 0xe1, 0xe2, 0x1c, 0x27, 0xda, 0xb0, 0x0a, 0x3b, 0xca, 0xee, 0xaa, - 0x7e, 0x25, 0x0c, 0x34, 0xad, 0x9f, 0x27, 0x20, 0xad, 0x33, 0x1f, 0x61, 0xfb, 0x39, 0x6c, 0xe6, - 0x85, 0x15, 0x6d, 0x40, 0xf1, 0x05, 0x9e, 0xb2, 0x2a, 0xab, 0x1a, 0xd1, 0x23, 0xba, 0x06, 0xe5, - 0x13, 0x73, 0x30, 0xc6, 0xa2, 0x8c, 0x2e, 0x8a, 0x0c, 0x49, 0x6b, 0x1b, 0x5c, 0xe6, 0x76, 0xe1, - 0x96, 0xd2, 0xfc, 0x55, 0x51, 0x2a, 0xbe, 0xf3, 0x97, 0xee, 0x1d, 0xa8, 0xf1, 0xd8, 0xea, 0x53, - 0x8a, 0x7d, 0x66, 0x75, 0x55, 0xbf, 0x14, 0x06, 0xda, 0xc5, 0x7e, 0x42, 0x96, 0x14, 0x65, 0x69, - 0x74, 0x0b, 0x80, 0xbf, 0x1e, 0x4d, 0x47, 0x98, 0x55, 0x6a, 0x55, 0x57, 0xc3, 0x40, 0xdb, 0xec, - 0xcf, 0xa8, 0x92, 0xaa, 0x24, 0x9b, 0x68, 0x32, 0x07, 0x97, 0x98, 0x55, 0x49, 0x33, 0xe3, 0x55, - 0x49, 0x16, 0xbd, 0x0f, 0x25, 0x9d, 0x58, 0x53, 0xb5, 0xcc, 0xfc, 0x53, 0x8b, 0xdb, 0x0c, 0xb1, - 0xa6, 0x3c, 0xfd, 0xba, 0xc4, 0x9a, 0x4a, 0xaa, 0x4c, 0x18, 0xf5, 0x61, 0xb3, 0x13, 0xb5, 0x74, - 0xb6, 0xeb, 0xa7, 0x8e, 0xeb, 0x30, 0x8f, 0xf1, 0x62, 0x48, 0x7a, 0xd5, 0x8c, 0xc1, 0x6b, 0xdd, - 0xc9, 0xd1, 0x90, 0x6b, 0x3d, 0x0f, 0xb1, 0xf9, 0x31, 0xcc, 0xb5, 0x30, 0xd4, 0x87, 0x55, 0x89, - 0xe4, 0xab, 0x4a, 0xaa, 0xf8, 0x33, 0xd2, 0xf2, 0xbb, 0x28, 0x7e, 0x96, 0xcc, 0x52, 0x93, 0x93, - 0x57, 0x91, 0x42, 0x46, 0xbf, 0x54, 0x60, 0xf3, 0x70, 0xfe, 0x04, 0x8b, 0xe2, 0x1a, 0x99, 0xfc, - 0xc6, 0x19, 0x26, 0xf3, 0x54, 0xb8, 0x69, 0xe6, 0x88, 0x9c, 0x33, 0x31, 0xe5, 0x88, 0x3c, 0x75, - 0x74, 0x04, 0x15, 0x83, 0x1d, 0x5c, 0xbe, 0x5a, 0x64, 0xc6, 0xaf, 0x9c, 0x61, 0x5c, 0x48, 0x71, - 0x7b, 0x2c, 0x5d, 0xf9, 0x81, 0x27, 0x9b, 0x88, 0xa1, 0xd0, 0xf7, 0x61, 0xc5, 0xe0, 0x47, 0xaa, - 0xaf, 0x96, 0x18, 0xec, 0xd5, 0x33, 0x61, 0xb9, 0x18, 0xc7, 0xdd, 0x0a, 0x03, 0x0d, 0x89, 0xc3, - 0x58, 0x06, 0x9e, 0xa1, 0xa1, 0x1f, 0x01, 0x74, 0xdc, 0x13, 0x73, 0xe0, 0x58, 0x47, 0x93, 0xb8, - 0x3f, 0xbf, 0x7b, 0x06, 0x76, 0x22, 0xc8, 0xd1, 0x59, 0xe6, 0x3a, 0x33, 0xa2, 0x9c, 0xb9, 0x89, - 0x28, 0xfa, 0x26, 0x94, 0x9e, 0x10, 0x3b, 0x4e, 0xba, 0xba, 0xc0, 0x7e, 0x42, 0x6c, 0x76, 0x3c, - 0xb2, 0xe4, 0x1d, 0x10, 0x5b, 0xd6, 0x66, 0xf2, 0xe8, 0x17, 0x0a, 0x5c, 0x3d, 0xec, 0xf5, 0xb1, - 0x35, 0x1e, 0x60, 0xeb, 0xfe, 0x04, 0xf7, 0xc6, 0x14, 0x5b, 0x87, 0x7b, 0xc6, 0x21, 0xef, 0xc6, - 0x07, 0x1e, 0x3e, 0x61, 0xc9, 0xa7, 0x56, 0x58, 0x6b, 0xbf, 0x11, 0x06, 0x5a, 0xcb, 0x5f, 0x40, - 0x5e, 0x32, 0xb4, 0x10, 0x3e, 0xfa, 0x8d, 0x02, 0x5f, 0x9b, 0x13, 0x4c, 0x36, 0x98, 0x5d, 0xce, - 0x0a, 0x5b, 0xce, 0xad, 0x30, 0xd0, 0x6e, 0xfa, 0x0b, 0x6b, 0x49, 0x8b, 0x3a, 0x87, 0xad, 0xed, - 0x67, 0x70, 0x61, 0xae, 0x6e, 0x72, 0xba, 0xeb, 0x95, 0x74, 0x77, 0x5d, 0x8b, 0xe3, 0x3b, 0xe9, - 0xb8, 0xc7, 0x44, 0xea, 0xaa, 0xdb, 0x1f, 0xc2, 0xa5, 0x33, 0x8b, 0x22, 0x07, 0xf7, 0x6a, 0x1a, - 0x37, 0x8e, 0xed, 0xe1, 0x9e, 0x91, 0x05, 0x7e, 0x0a, 0xab, 0x72, 0xc2, 0xe7, 0x60, 0x7d, 0x35, - 0x8d, 0x75, 0x41, 0x60, 0x71, 0xad, 0x2c, 0xdc, 0x63, 0x58, 0x4b, 0x25, 0xfa, 0xe2, 0x6b, 0x13, - 0x6a, 0x32, 0xd8, 0x13, 0x58, 0xcf, 0x64, 0xf6, 0x7f, 0xe1, 0xc2, 0xe6, 0x1f, 0x0a, 0x50, 0x79, - 0x80, 0x71, 0x44, 0x46, 0xef, 0x40, 0xe5, 0xa1, 0xe9, 0x7f, 0xd7, 0xc7, 0x16, 0x83, 0x2a, 0xe9, - 0xb5, 0x30, 0xd0, 0x2a, 0x36, 0x27, 0x19, 0x31, 0x0f, 0x0d, 0xa0, 0xf8, 0x00, 0x63, 0x71, 0x08, - 0x7d, 0x14, 0x06, 0xda, 0xda, 0x31, 0x96, 0x4e, 0x90, 0xdf, 0xff, 0x5d, 0xbb, 0x3f, 0x34, 0x69, - 0xbf, 0xdd, 0x75, 0xec, 0x56, 0xc7, 0xa5, 0x77, 0xce, 0x31, 0x09, 0xb7, 0x74, 0xc7, 0xee, 0xb8, - 0x74, 0xcf, 0xf4, 0x29, 0xf6, 0x8c, 0xc8, 0x0c, 0xfa, 0x44, 0x81, 0x7a, 0xc7, 0x75, 0xa8, 0x63, - 0x0e, 0x0e, 0x4c, 0xc7, 0x8a, 0x2c, 0x17, 0x99, 0x65, 0x1c, 0x8d, 0x22, 0x4e, 0x8a, 0xf3, 0x45, - 0x2c, 0x22, 0x63, 0xbc, 0xf9, 0x37, 0x05, 0x96, 0xb9, 0x1b, 0xd1, 0x3e, 0xd4, 0xa4, 0x74, 0x66, - 0x3e, 0xab, 0xdd, 0x40, 0xf3, 0xdd, 0x88, 0x9f, 0xd4, 0xd2, 0xd1, 0x20, 0x9f, 0xd4, 0x92, 0x1c, - 0xfa, 0xd6, 0x2c, 0x16, 0x99, 0x34, 0x10, 0x54, 0xde, 0x78, 0x8f, 0xf9, 0x8b, 0xdc, 0x78, 0xe3, - 0x08, 0xde, 0x86, 0x3a, 0xaf, 0x42, 0x87, 0xb8, 0xfb, 0x9e, 0x85, 0x3d, 0xe6, 0x2b, 0x31, 0xf2, - 0xe1, 0x14, 0xc7, 0xc8, 0x48, 0x36, 0xff, 0xad, 0x40, 0x45, 0x94, 0x02, 0x22, 0xf0, 0x56, 0x4e, - 0x61, 0x89, 0x1d, 0x6e, 0xc7, 0x75, 0x33, 0x2f, 0xa1, 0x7f, 0x25, 0x0c, 0xb4, 0xb7, 0x73, 0x4e, - 0x22, 0x69, 0xb1, 0x79, 0xc8, 0xff, 0xdf, 0x9d, 0x1f, 0x41, 0x45, 0xf4, 0x77, 0xd4, 0x8c, 0x82, - 0xcb, 0xa6, 0x1d, 0x56, 0x4c, 0x3a, 0x84, 0x81, 0xb6, 0x4c, 0x19, 0xc5, 0x10, 0x1c, 0xf4, 0x0e, - 0x14, 0x9f, 0x10, 0x5b, 0xac, 0x13, 0x92, 0x03, 0x42, 0xaf, 0x84, 0x81, 0x56, 0x1c, 0x10, 0xdb, - 0x88, 0xf8, 0xcd, 0x8f, 0x15, 0x80, 0xa4, 0x1d, 0xa0, 0x0f, 0x60, 0x99, 0xbf, 0x09, 0x2f, 0xae, - 0xa7, 0x3a, 0xc6, 0xd1, 0x44, 0xdf, 0x0c, 0x03, 0x6d, 0x83, 0x1f, 0xaa, 0xd2, 0x06, 0x85, 0x52, - 0xce, 0xfe, 0x0a, 0x0b, 0xef, 0xef, 0x5f, 0x4a, 0xfe, 0x7d, 0x0a, 0xbd, 0x07, 0xb5, 0x87, 0xa6, - 0x7f, 0xe0, 0x91, 0x13, 0xc7, 0x9a, 0x15, 0xfd, 0x7a, 0x18, 0x68, 0x35, 0x3b, 0x21, 0x1b, 0xb2, - 0x8c, 0x50, 0x31, 0xf0, 0xf1, 0xd8, 0x8d, 0x54, 0x0a, 0x29, 0x95, 0x98, 0x6c, 0xc8, 0x32, 0xe8, - 0x26, 0xac, 0x46, 0x08, 0xd8, 0x35, 0x07, 0xd1, 0x25, 0x85, 0x05, 0xa6, 0xa4, 0x6f, 0x84, 0x81, - 0xb6, 0x6a, 0x4b, 0x74, 0x23, 0x25, 0x15, 0x6d, 0xf8, 0xa9, 0x39, 0x61, 0x24, 0x8f, 0x9f, 0x54, - 0x25, 0xa6, 0xc7, 0x36, 0x3c, 0x4c, 0x71, 0x8c, 0x8c, 0x64, 0xf3, 0x18, 0xde, 0xfa, 0x5e, 0xd4, - 0x20, 0x4d, 0x4a, 0x3c, 0xc3, 0xa4, 0x8e, 0x6b, 0xb3, 0x10, 0x5c, 0x83, 0xea, 0xc1, 0xb8, 0x3b, - 0x70, 0x7a, 0x8f, 0xe3, 0x66, 0xa9, 0xaf, 0x85, 0x81, 0x56, 0x1d, 0xc5, 0x44, 0x23, 0xe1, 0x47, - 0x99, 0xc0, 0x55, 0xd9, 0x1e, 0x0b, 0x3c, 0x13, 0x3c, 0x46, 0x31, 0x04, 0xa7, 0xf9, 0x57, 0x05, - 0x36, 0x66, 0x86, 0x7c, 0x4e, 0x8c, 0xba, 0x68, 0x7a, 0xb8, 0x67, 0x5d, 0x54, 0x0c, 0xf7, 0xc9, - 0x48, 0xaf, 0x41, 0xf9, 0xfe, 0x88, 0xf4, 0xfa, 0x22, 0x8e, 0xd5, 0x30, 0xd0, 0xca, 0x38, 0x22, - 0x18, 0x9c, 0x8e, 0x3c, 0xd8, 0xcc, 0x62, 0xb3, 0xfa, 0xe0, 0x73, 0x5a, 0x5c, 0x84, 0x39, 0xfb, - 0xe4, 0xe3, 0xe0, 0x49, 0x8e, 0xae, 0x3c, 0x0e, 0xe6, 0x61, 0x37, 0x7f, 0x5b, 0x80, 0xaa, 0x41, - 0xc6, 0x2e, 0x4f, 0x59, 0x0d, 0xca, 0xec, 0x45, 0x24, 0x06, 0x5b, 0xa2, 0x17, 0x11, 0x0c, 0x4e, - 0x8f, 0x62, 0x94, 0xb9, 0x25, 0x16, 0xd8, 0x2d, 0x91, 0xc5, 0x28, 0x7d, 0x4b, 0x9c, 0xbb, 0x1b, - 0x7e, 0x1b, 0x36, 0x58, 0xb0, 0x3e, 0x64, 0xc9, 0x35, 0x22, 0xbe, 0xc8, 0x8c, 0x15, 0x5e, 0x08, - 0xdd, 0x0c, 0xcf, 0x98, 0x93, 0x4e, 0x1c, 0x6d, 0xb1, 0xd4, 0x48, 0x39, 0xda, 0x8a, 0x1d, 0x6d, - 0x25, 0x8e, 0x2e, 0x9f, 0xe1, 0xe8, 0x6b, 0x50, 0x3d, 0x72, 0x86, 0xd8, 0xa7, 0xe6, 0x70, 0xa4, - 0x2e, 0xb3, 0xad, 0xb2, 0xb4, 0xa0, 0x31, 0xd1, 0x48, 0xf8, 0xcd, 0x9f, 0x01, 0xb0, 0xbd, 0xfb, - 0xf1, 0x89, 0xb9, 0x48, 0xac, 0xbf, 0x23, 0x2b, 0x89, 0x29, 0x3f, 0xbe, 0xce, 0xcc, 0xdc, 0xcd, - 0xe7, 0x53, 0x6f, 0x26, 0x27, 0xcf, 0xa7, 0x89, 0x76, 0xf3, 0x3d, 0xa8, 0x1c, 0x8c, 0xbb, 0x8f, - 0xf1, 0xd4, 0x47, 0xef, 0x42, 0x29, 0xfa, 0x65, 0x37, 0x95, 0x55, 0xee, 0xf4, 0x17, 0x78, 0x9a, - 0x1a, 0x4d, 0x23, 0x7e, 0xf3, 0xcf, 0x05, 0xb8, 0x90, 0x84, 0x3b, 0xd6, 0x5e, 0x70, 0xed, 0x9f, - 0x28, 0xb0, 0xc5, 0x9e, 0xe7, 0x10, 0xc4, 0x46, 0x6e, 0x66, 0x33, 0x31, 0xe6, 0xb7, 0xf2, 0xd5, - 0xf8, 0x30, 0xae, 0x85, 0x81, 0x76, 0xf9, 0x24, 0xcb, 0x93, 0xbf, 0x6a, 0xe4, 0x6b, 0x27, 0xe1, - 0x2c, 0xe6, 0x87, 0x73, 0xfb, 0x39, 0x5c, 0xfe, 0x0c, 0xc3, 0xf2, 0xac, 0xb4, 0xf6, 0x99, 0xa3, - 0x97, 0xd0, 0x92, 0x87, 0xa5, 0x3f, 0x16, 0x60, 0x65, 0xf6, 0xf1, 0x66, 0x41, 0xff, 0xdd, 0x86, - 0x3a, 0xcb, 0xdc, 0x24, 0xc5, 0x0a, 0x49, 0x1f, 0xeb, 0xa6, 0x38, 0x46, 0x46, 0x12, 0x0d, 0xe7, - 0x3f, 0x49, 0x15, 0x53, 0xd7, 0xa9, 0x98, 0xfc, 0x3f, 0xf9, 0x1c, 0xf5, 0x45, 0x7e, 0xff, 0xb0, - 0xa1, 0xce, 0x3e, 0xb6, 0x44, 0xad, 0x9d, 0x5f, 0x53, 0x16, 0x74, 0x5f, 0x2b, 0xf5, 0x09, 0x82, - 0xcf, 0x9c, 0xf5, 0x30, 0xd0, 0x20, 0xf9, 0x04, 0x21, 0x7f, 0x78, 0x68, 0xb6, 0xa0, 0xcc, 0x54, - 0x17, 0xc4, 0xd7, 0xc7, 0x2f, 0x5f, 0x37, 0x96, 0x5e, 0xbd, 0x6e, 0x2c, 0x7d, 0xfa, 0xba, 0xa1, - 0xfc, 0xfc, 0xb4, 0xa1, 0xfc, 0xee, 0xb4, 0xa1, 0xfc, 0xe5, 0xb4, 0xa1, 0xbc, 0x3c, 0x6d, 0x28, - 0xaf, 0x4e, 0x1b, 0xca, 0x3f, 0x4e, 0x1b, 0xca, 0x3f, 0x4f, 0x1b, 0x4b, 0x9f, 0x9e, 0x36, 0x94, - 0x5f, 0xbf, 0x69, 0x2c, 0xbd, 0x7c, 0xd3, 0x58, 0x7a, 0xf5, 0xa6, 0xb1, 0xf4, 0xd1, 0x79, 0x46, - 0xca, 0xb6, 0xf8, 0x3f, 0xc0, 0x1d, 0xf1, 0xdb, 0x5d, 0x66, 0x0e, 0x7b, 0xff, 0x3f, 0x01, 0x00, - 0x00, 0xff, 0xff, 0xe1, 0x15, 0x1f, 0x1e, 0x21, 0x18, 0x00, 0x00, + // 1987 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcd, 0x73, 0x1b, 0x49, + 0x15, 0xf7, 0x48, 0xb2, 0x65, 0x3d, 0xd9, 0x8e, 0xdd, 0x71, 0xcc, 0xc4, 0x61, 0x35, 0x46, 0x49, + 0x16, 0x43, 0x88, 0xc4, 0x66, 0x53, 0x54, 0x2a, 0xa9, 0x2d, 0xc8, 0x38, 0x5f, 0x22, 0x1f, 0x76, + 0x8d, 0x05, 0x4b, 0xb6, 0xa8, 0x82, 0x91, 0xa6, 0x3d, 0x9a, 0x8a, 0x34, 0x2d, 0x66, 0x5a, 0x46, + 0xe2, 0x02, 0x27, 0x96, 0x03, 0x5b, 0xc5, 0x91, 0x1b, 0x57, 0x8a, 0x03, 0x57, 0xfe, 0x03, 0x8a, + 0x13, 0x95, 0x13, 0x95, 0xd3, 0x40, 0x9c, 0x0b, 0x35, 0x07, 0x6a, 0x6f, 0x70, 0xa4, 0xa6, 0xbb, + 0x47, 0xd3, 0x33, 0x1a, 0x6f, 0xc9, 0x81, 0xad, 0xbd, 0x58, 0x33, 0xef, 0xe3, 0xf7, 0xfa, 0x7d, + 0xf4, 0xeb, 0xd7, 0x63, 0x40, 0x64, 0x44, 0x87, 0xc4, 0xa3, 0x7a, 0x9f, 0x74, 0x5f, 0x34, 0x86, + 0x1e, 0xa1, 0x04, 0x2d, 0xb2, 0x9f, 0xed, 0xeb, 0xb6, 0x43, 0x7b, 0xa3, 0x4e, 0xa3, 0x4b, 0x06, + 0x4d, 0x9b, 0xd8, 0xa4, 0xc9, 0xc8, 0x9d, 0xd1, 0x11, 0x7b, 0x63, 0x2f, 0xec, 0x89, 0x6b, 0x6d, + 0x7f, 0x20, 0x89, 0x0f, 0x46, 0x7d, 0xea, 0x1c, 0x63, 0xcf, 0x1f, 0x37, 0x07, 0xe3, 0xeb, 0xdd, + 0x9e, 0xe9, 0xb8, 0xd7, 0xbb, 0xc4, 0xc3, 0xd7, 0x6d, 0xd2, 0xb4, 0x4c, 0x6a, 0x36, 0x3b, 0x91, + 0x39, 0xfe, 0x57, 0xa8, 0xdf, 0x3d, 0x8b, 0x3a, 0xf5, 0x4c, 0xd7, 0x37, 0xbb, 0xd4, 0x21, 0x6e, + 0xb3, 0x4f, 0x6c, 0x01, 0xd1, 0x7a, 0x5b, 0x08, 0xe9, 0x59, 0x40, 0x3d, 0x3f, 0x0b, 0x94, 0x3f, + 0x30, 0x3d, 0xba, 0x47, 0x5c, 0xea, 0x99, 0x5d, 0x6a, 0x60, 0x7f, 0xd4, 0xa7, 0x79, 0xb4, 0xb7, + 0x71, 0xd4, 0xc3, 0x5d, 0xec, 0x0c, 0x69, 0xfc, 0x2b, 0x20, 0xf6, 0xce, 0x06, 0xf1, 0x53, 0xd3, + 0xb3, 0xda, 0xe3, 0xe9, 0x83, 0x00, 0xd9, 0x3f, 0x0b, 0x88, 0xd9, 0xa7, 0xd8, 0xc3, 0xd6, 0xdd, + 0x6e, 0x97, 0x8c, 0x5c, 0x9a, 0x79, 0x7d, 0x9b, 0xf0, 0xfb, 0xd4, 0xa4, 0x78, 0xaf, 0x67, 0xba, + 0x36, 0x96, 0x9f, 0x39, 0x54, 0xfd, 0x3f, 0xcb, 0xb0, 0xb2, 0x2f, 0x15, 0x26, 0x6a, 0x42, 0xf9, + 0xb0, 0x67, 0x7a, 0x56, 0xeb, 0x9e, 0xaa, 0xec, 0x28, 0xbb, 0xab, 0xfa, 0x85, 0x30, 0xd0, 0x36, + 0x7c, 0x4e, 0xfa, 0x06, 0x19, 0x38, 0x14, 0x0f, 0x86, 0x74, 0x62, 0xc4, 0x52, 0xe8, 0x21, 0x54, + 0x98, 0xe6, 0x3d, 0x93, 0x9a, 0x6a, 0x61, 0x47, 0xd9, 0xad, 0xde, 0x58, 0xe7, 0xe0, 0x8d, 0x29, + 0x5d, 0xff, 0x52, 0x18, 0x68, 0xe7, 0x3b, 0xf1, 0xab, 0x04, 0x93, 0xe8, 0xa2, 0x1f, 0xc1, 0xb9, + 0x76, 0x52, 0x1e, 0x07, 0x84, 0xf4, 0xd5, 0x22, 0x83, 0xdb, 0x12, 0x70, 0x19, 0xae, 0xfe, 0x4e, + 0x18, 0x68, 0x17, 0x69, 0x9a, 0x28, 0x41, 0x67, 0xd1, 0x90, 0x0f, 0x9b, 0x8f, 0xb0, 0x69, 0x61, + 0xef, 0xa1, 0xe9, 0xef, 0x11, 0xd7, 0x1f, 0x0d, 0x86, 0x11, 0x4f, 0x2d, 0x31, 0x2b, 0x97, 0x84, + 0x95, 0x3c, 0x11, 0xbd, 0x1e, 0x06, 0x5a, 0xad, 0x97, 0xc3, 0x91, 0xec, 0xe5, 0x82, 0xa3, 0x9f, + 0xc0, 0xb9, 0xbb, 0xa9, 0x1c, 0xfa, 0xea, 0xe2, 0x4e, 0x71, 0xb7, 0x7a, 0x63, 0x57, 0xd8, 0x93, + 0xa3, 0xdf, 0xc8, 0x88, 0xde, 0x77, 0xa9, 0x37, 0xe1, 0x7e, 0xa6, 0x0b, 0xc1, 0x97, 0xfd, 0xcc, + 0x28, 0xa1, 0x1f, 0xc2, 0xd6, 0x33, 0x42, 0x4d, 0xcf, 0xf9, 0x19, 0xb6, 0xf8, 0x9a, 0xfc, 0x47, + 0xa6, 0xdf, 0xc3, 0xbe, 0xba, 0xb4, 0x53, 0xdc, 0xad, 0xe8, 0x57, 0xc2, 0x40, 0xdb, 0x71, 0x73, + 0x25, 0x24, 0xd8, 0x53, 0x30, 0xd0, 0x6d, 0x58, 0x7b, 0x36, 0x1a, 0x74, 0xb0, 0xb7, 0x7f, 0xc4, + 0x4a, 0xc0, 0x57, 0xcb, 0xac, 0x4e, 0x50, 0x18, 0x68, 0x6b, 0x6e, 0x8a, 0x63, 0x64, 0x24, 0xd1, + 0x3d, 0x58, 0x3b, 0x74, 0x6c, 0x17, 0x7b, 0x7e, 0xcb, 0xb5, 0xf0, 0x18, 0xfb, 0xea, 0xf2, 0x4e, + 0x71, 0xb7, 0xa4, 0x7f, 0x39, 0x0c, 0x34, 0xd5, 0x4f, 0x71, 0xa4, 0x95, 0x64, 0x74, 0x90, 0x01, + 0x5b, 0x8f, 0x1c, 0xbb, 0x87, 0x7d, 0xfa, 0xc0, 0x71, 0xcd, 0x3e, 0x8b, 0xdc, 0x33, 0xe2, 0x76, + 0xb1, 0x5a, 0xd9, 0x51, 0x76, 0x4b, 0xfa, 0x76, 0x18, 0x68, 0x5b, 0xbd, 0x5c, 0x09, 0xe3, 0x14, + 0x4d, 0xf4, 0x1c, 0x2e, 0xcc, 0x70, 0x22, 0x87, 0x55, 0xd8, 0x51, 0x76, 0x57, 0xf4, 0xcb, 0x61, + 0xa0, 0x69, 0xbd, 0x3c, 0x01, 0x69, 0x9d, 0xf9, 0x08, 0x08, 0xc3, 0xca, 0x61, 0xb2, 0xef, 0x7c, + 0xb5, 0xca, 0xd2, 0x7f, 0x35, 0x2f, 0xfd, 0xb2, 0x1c, 0xcf, 0x3d, 0xf3, 0x45, 0xda, 0xb6, 0x72, + 0x5c, 0x52, 0xb0, 0xdb, 0xcf, 0x61, 0x33, 0xaf, 0x7a, 0xd0, 0x3a, 0x14, 0x5f, 0xe0, 0x09, 0xdb, + 0xcc, 0x15, 0x23, 0x7a, 0x44, 0xd7, 0x60, 0xf1, 0xd8, 0xec, 0x8f, 0xb0, 0xd8, 0xad, 0x17, 0xc4, + 0x4a, 0xd2, 0xda, 0x06, 0x97, 0xb9, 0x5d, 0xb8, 0xa5, 0x6c, 0xb7, 0x61, 0x63, 0x66, 0x65, 0x39, + 0xb8, 0x5f, 0x4b, 0xe3, 0x9e, 0x17, 0xb8, 0xb2, 0xaa, 0x84, 0x5a, 0xff, 0x75, 0x51, 0xea, 0x1c, + 0x67, 0xef, 0x3b, 0x77, 0xa0, 0xca, 0x0b, 0x53, 0x9f, 0x50, 0xec, 0x33, 0x9b, 0x2b, 0xfa, 0xc5, + 0x30, 0xd0, 0x2e, 0xf4, 0x12, 0xb2, 0xa4, 0x28, 0x4b, 0xa3, 0x5b, 0x00, 0xfc, 0xb5, 0x3d, 0x19, + 0x62, 0xd6, 0x66, 0x2a, 0xba, 0x1a, 0x06, 0xda, 0x66, 0x6f, 0x4a, 0x95, 0x54, 0x25, 0xd9, 0x44, + 0x93, 0x55, 0x47, 0x89, 0x59, 0x95, 0x34, 0x33, 0x25, 0x21, 0xc9, 0xa2, 0xf7, 0xa1, 0xa4, 0x13, + 0x6b, 0xa2, 0x2e, 0xb2, 0xe8, 0x54, 0xe3, 0x1e, 0x49, 0xac, 0x09, 0xdf, 0x3b, 0x1d, 0x62, 0x4d, + 0x24, 0x55, 0x26, 0x8c, 0x7a, 0xb0, 0xd9, 0x8a, 0x8e, 0x36, 0xe6, 0xf5, 0x53, 0xc7, 0x75, 0x58, + 0xc4, 0xf8, 0x4e, 0x4e, 0x1a, 0xed, 0x94, 0xc1, 0x1b, 0x95, 0x93, 0xa3, 0x21, 0x37, 0xaa, 0x3c, + 0xc4, 0xfa, 0xc7, 0x30, 0xd3, 0x7f, 0x51, 0x0f, 0x56, 0x24, 0x92, 0xaf, 0x2a, 0xa9, 0xce, 0x95, + 0x91, 0x96, 0xdf, 0xe5, 0xea, 0x95, 0x3a, 0x74, 0xaa, 0x7a, 0x65, 0x71, 0xf4, 0x2b, 0x05, 0x36, + 0x0f, 0x67, 0x4f, 0xf2, 0x28, 0xaf, 0x91, 0xc9, 0x6f, 0x9e, 0x62, 0x32, 0x4f, 0x85, 0x9b, 0x66, + 0x81, 0xc8, 0x99, 0x0d, 0x52, 0x81, 0xc8, 0x53, 0x47, 0x6d, 0x28, 0x1b, 0xec, 0x00, 0xf7, 0xd5, + 0x22, 0x33, 0x7e, 0xf9, 0x14, 0xe3, 0x42, 0x8a, 0xdb, 0x63, 0xe5, 0xca, 0x0f, 0x7e, 0xd9, 0x44, + 0x0c, 0x85, 0x7e, 0x00, 0xcb, 0x06, 0x1f, 0x2d, 0x7c, 0xb5, 0xc4, 0x60, 0xaf, 0x9c, 0x0a, 0xcb, + 0xc5, 0x38, 0xee, 0x56, 0x18, 0x68, 0x48, 0x0c, 0x25, 0x32, 0xf0, 0x14, 0x0d, 0xfd, 0x18, 0xa0, + 0xe5, 0x1e, 0x9b, 0x7d, 0xc7, 0x6a, 0x8f, 0xe3, 0xc3, 0xe5, 0xdd, 0x53, 0xb0, 0x13, 0x41, 0x8e, + 0xce, 0x2a, 0xd7, 0x99, 0x12, 0xe5, 0xca, 0x4d, 0x44, 0xd1, 0xb7, 0xa0, 0xf4, 0x84, 0xd8, 0x71, + 0xd1, 0xad, 0x09, 0xec, 0x27, 0xc4, 0x66, 0x67, 0x3b, 0x2b, 0xde, 0x3e, 0xb1, 0x65, 0x6d, 0x26, + 0x8f, 0x7e, 0xa9, 0xc0, 0x95, 0xc3, 0x6e, 0x0f, 0x5b, 0xa3, 0x3e, 0xb6, 0xee, 0x8f, 0x71, 0x77, + 0x44, 0xb1, 0x75, 0xb8, 0x67, 0x1c, 0xf2, 0xa3, 0xe4, 0xc0, 0xc3, 0xc7, 0xac, 0xf8, 0xd4, 0x32, + 0x3b, 0x97, 0x6e, 0x84, 0x81, 0xd6, 0xf0, 0xe7, 0x90, 0x97, 0x0c, 0xcd, 0x85, 0x8f, 0x7e, 0xab, + 0xc0, 0xd7, 0x67, 0x04, 0x13, 0x07, 0xb3, 0xcb, 0x59, 0x66, 0xcb, 0xb9, 0x15, 0x06, 0xda, 0x4d, + 0x7f, 0x6e, 0x2d, 0x69, 0x51, 0x67, 0xb0, 0xb5, 0xfd, 0x0c, 0x36, 0x66, 0xf6, 0x4d, 0x4e, 0x6f, + 0xbd, 0x9c, 0xee, 0xad, 0xab, 0x71, 0x7e, 0xc7, 0x2d, 0xf7, 0x88, 0xc8, 0xbd, 0xfa, 0x43, 0xb8, + 0x78, 0xea, 0xa6, 0xc8, 0xc1, 0xbd, 0x92, 0xc6, 0x8d, 0x73, 0x7b, 0xb8, 0x67, 0x64, 0x81, 0x9f, + 0xc2, 0x8a, 0x5c, 0xf0, 0x39, 0x58, 0x5f, 0x4d, 0x63, 0x6d, 0x08, 0x2c, 0xae, 0x95, 0x85, 0x7b, + 0x0c, 0xab, 0xa9, 0x42, 0x9f, 0x7f, 0x6d, 0x42, 0x4d, 0x06, 0x7b, 0x02, 0xe7, 0x32, 0x95, 0xfd, + 0x3f, 0x84, 0xb0, 0xfe, 0xc7, 0x02, 0x94, 0x1f, 0x60, 0x1c, 0x91, 0xd1, 0x55, 0x28, 0x3f, 0x34, + 0xfd, 0xef, 0xf9, 0xd8, 0x62, 0x50, 0x25, 0xbd, 0x1a, 0x06, 0x5a, 0xd9, 0xe6, 0x24, 0x23, 0xe6, + 0xa1, 0x3e, 0x14, 0x1f, 0x60, 0x2c, 0x0e, 0xa1, 0x8f, 0xc2, 0x40, 0x5b, 0x3d, 0xc2, 0xd2, 0x09, + 0xf2, 0x87, 0xbf, 0x6b, 0xf7, 0x07, 0x26, 0xed, 0x35, 0x3b, 0x8e, 0xdd, 0x68, 0xb9, 0xf4, 0xce, + 0x19, 0x06, 0xf8, 0x86, 0xee, 0xd8, 0x2d, 0x97, 0xee, 0x99, 0x3e, 0xc5, 0x9e, 0x11, 0x99, 0x41, + 0x9f, 0x28, 0xb0, 0xd6, 0x72, 0x1d, 0xea, 0x98, 0xfd, 0x03, 0xd3, 0xb1, 0x22, 0xcb, 0x45, 0x66, + 0x19, 0x47, 0x73, 0x94, 0x93, 0xe2, 0x7c, 0x1e, 0x8b, 0xc8, 0x18, 0xaf, 0xff, 0x4d, 0x81, 0x25, + 0x1e, 0x46, 0xb4, 0x0f, 0x55, 0xa9, 0x9c, 0x59, 0xcc, 0xaa, 0x37, 0xd0, 0x6c, 0x37, 0xe2, 0x27, + 0xb5, 0x74, 0x34, 0xc8, 0x27, 0xb5, 0x24, 0x87, 0xbe, 0x3d, 0xcd, 0x45, 0xa6, 0x0c, 0x04, 0x95, + 0x37, 0xde, 0x23, 0xfe, 0x22, 0x37, 0xde, 0x38, 0x83, 0xb7, 0x61, 0x8d, 0xef, 0x42, 0x87, 0xb8, + 0xfb, 0x9e, 0x85, 0x3d, 0x16, 0x2b, 0x31, 0xaf, 0xe2, 0x14, 0xc7, 0xc8, 0x48, 0xd6, 0xff, 0xad, + 0x40, 0x59, 0x6c, 0x05, 0x44, 0xe0, 0x7c, 0xce, 0xc6, 0x12, 0x1e, 0x6e, 0xc7, 0xfb, 0x66, 0x56, + 0x42, 0xff, 0x4a, 0x18, 0x68, 0xef, 0xe4, 0x9c, 0x44, 0xd2, 0x62, 0xf3, 0x90, 0xbf, 0x58, 0xcf, + 0xdb, 0x50, 0x16, 0xfd, 0x1d, 0xd5, 0xa3, 0xe4, 0xb2, 0x69, 0x87, 0x6d, 0x26, 0x1d, 0xc2, 0x40, + 0x5b, 0xa2, 0x8c, 0x62, 0x08, 0x0e, 0xba, 0x0a, 0xc5, 0x27, 0xc4, 0x16, 0xeb, 0x84, 0xe4, 0x80, + 0xd0, 0xcb, 0x61, 0xa0, 0x15, 0xfb, 0xc4, 0x36, 0x22, 0x7e, 0xfd, 0x63, 0x05, 0x20, 0x69, 0x07, + 0xe8, 0x03, 0x58, 0xe2, 0x6f, 0x22, 0x8a, 0xe7, 0x52, 0x1d, 0xa3, 0x3d, 0xd6, 0x37, 0xc3, 0x40, + 0x5b, 0xe7, 0x87, 0xaa, 0xe4, 0xa0, 0x50, 0xca, 0xf1, 0xaf, 0x30, 0xb7, 0x7f, 0xff, 0x52, 0xf2, + 0x2f, 0x83, 0xe8, 0x3d, 0xa8, 0x3e, 0x34, 0xfd, 0x03, 0x8f, 0x1c, 0x3b, 0xd6, 0x74, 0xd3, 0x9f, + 0x0b, 0x03, 0xad, 0x6a, 0x27, 0x64, 0x43, 0x96, 0x11, 0x2a, 0x06, 0x3e, 0x1a, 0xb9, 0x91, 0x4a, + 0x21, 0xa5, 0x12, 0x93, 0x0d, 0x59, 0x06, 0xdd, 0x84, 0x95, 0x08, 0x01, 0xbb, 0x66, 0x3f, 0xba, + 0x61, 0xb1, 0xc4, 0x94, 0xf4, 0xf5, 0x30, 0xd0, 0x56, 0x6c, 0x89, 0x6e, 0xa4, 0xa4, 0x22, 0x87, + 0x9f, 0x9a, 0x63, 0x46, 0xf2, 0xf8, 0x49, 0x55, 0x62, 0x7a, 0xcc, 0xe1, 0x41, 0x8a, 0x63, 0x64, + 0x24, 0xeb, 0x47, 0x70, 0xfe, 0xfb, 0x51, 0x83, 0x34, 0x29, 0xf1, 0x0c, 0x93, 0x3a, 0xae, 0xcd, + 0x52, 0x70, 0x0d, 0x2a, 0x07, 0xa3, 0x4e, 0xdf, 0xe9, 0x3e, 0x8e, 0x9b, 0xa5, 0xbe, 0x1a, 0x06, + 0x5a, 0x65, 0x18, 0x13, 0x8d, 0x84, 0x1f, 0x55, 0x02, 0x57, 0x65, 0x3e, 0x16, 0x78, 0x25, 0x78, + 0x8c, 0x62, 0x08, 0x4e, 0xfd, 0xaf, 0x0a, 0xac, 0x4f, 0x0d, 0xf9, 0x9c, 0x18, 0x75, 0xd1, 0xf4, + 0x70, 0xcf, 0xba, 0xa8, 0x18, 0xee, 0x93, 0x91, 0x5e, 0x83, 0xc5, 0xfb, 0x43, 0xd2, 0xed, 0x89, + 0x3c, 0x56, 0xc2, 0x40, 0x5b, 0xc4, 0x11, 0xc1, 0xe0, 0x74, 0xe4, 0xc1, 0x66, 0x16, 0x9b, 0xed, + 0x0f, 0x3e, 0xa7, 0xc5, 0x9b, 0x30, 0xc7, 0x4f, 0x3e, 0x0e, 0x1e, 0xe7, 0xe8, 0xca, 0xe3, 0x60, + 0x1e, 0x76, 0xfd, 0x77, 0x05, 0xa8, 0x18, 0x64, 0xe4, 0xf2, 0x92, 0xd5, 0x60, 0x91, 0xbd, 0x88, + 0xc2, 0x60, 0x4b, 0xf4, 0x22, 0x82, 0xc1, 0xe9, 0x51, 0x8e, 0x32, 0x57, 0xdc, 0x02, 0xbb, 0xe2, + 0xb2, 0x1c, 0xa5, 0xaf, 0xb8, 0x33, 0x17, 0xdb, 0xef, 0xc0, 0x3a, 0x4b, 0xd6, 0x87, 0xac, 0xb8, + 0x86, 0xc4, 0x17, 0x95, 0xb1, 0xcc, 0x37, 0x42, 0x27, 0xc3, 0x33, 0x66, 0xa4, 0x93, 0x40, 0x5b, + 0xac, 0x34, 0x52, 0x81, 0xb6, 0xe2, 0x40, 0x5b, 0x49, 0xa0, 0x17, 0x4f, 0x09, 0xf4, 0x35, 0xa8, + 0xb4, 0x9d, 0x01, 0xf6, 0xa9, 0x39, 0x18, 0xaa, 0x4b, 0xcc, 0x55, 0x56, 0x16, 0x34, 0x26, 0x1a, + 0x09, 0xbf, 0xfe, 0x73, 0x00, 0xe6, 0xbb, 0x1f, 0x9f, 0x98, 0xf3, 0xe4, 0xfa, 0xbb, 0xb2, 0x92, + 0x98, 0xf2, 0xe3, 0xeb, 0xcc, 0x34, 0xdc, 0x7c, 0x3e, 0xf5, 0xa6, 0x72, 0xf2, 0x7c, 0x9a, 0x68, + 0xd7, 0xdf, 0x83, 0xf2, 0xc1, 0xa8, 0xf3, 0x18, 0x4f, 0x7c, 0xf4, 0x2e, 0x94, 0xa2, 0x5f, 0x76, + 0x53, 0x59, 0xe1, 0x41, 0x7f, 0x81, 0x27, 0xa9, 0xd1, 0x34, 0xe2, 0xd7, 0xff, 0x5c, 0x80, 0x8d, + 0x24, 0xdd, 0xb1, 0xf6, 0x9c, 0x6b, 0xff, 0x44, 0x81, 0x2d, 0xf6, 0x3c, 0x83, 0x20, 0x1c, 0xb9, + 0x99, 0xad, 0xc4, 0x98, 0xdf, 0xc8, 0x57, 0xe3, 0xc3, 0xb8, 0x16, 0x06, 0xda, 0xa5, 0xe3, 0x2c, + 0x4f, 0xfe, 0x24, 0x93, 0xaf, 0x9d, 0xa4, 0xb3, 0x98, 0x9f, 0xce, 0xed, 0xe7, 0x70, 0xe9, 0x33, + 0x0c, 0xcb, 0xb3, 0xd2, 0xea, 0x67, 0x8e, 0x5e, 0x42, 0x4b, 0x1e, 0x96, 0xfe, 0x54, 0x80, 0xe5, + 0xe9, 0x97, 0xa7, 0x39, 0xe3, 0x77, 0x1b, 0xd6, 0x58, 0xe5, 0x26, 0x25, 0x56, 0x48, 0xfa, 0x58, + 0x27, 0xc5, 0x31, 0x32, 0x92, 0x68, 0x30, 0xfb, 0x3d, 0xad, 0x98, 0xba, 0x4e, 0xc5, 0xe4, 0xff, + 0xcb, 0xb7, 0xb4, 0xcf, 0xf1, 0xab, 0x4a, 0xdd, 0x86, 0x35, 0xf6, 0xa5, 0x28, 0x6a, 0xed, 0xfc, + 0x9a, 0x32, 0x67, 0xf8, 0x1a, 0xa9, 0x4f, 0x10, 0x7c, 0xe6, 0x5c, 0x0b, 0x03, 0x0d, 0x92, 0x4f, + 0x10, 0xf2, 0x87, 0x87, 0x7a, 0x03, 0x16, 0x99, 0xea, 0x9c, 0xf8, 0xfa, 0xe8, 0xe5, 0xeb, 0xda, + 0xc2, 0xab, 0xd7, 0xb5, 0x85, 0x4f, 0x5f, 0xd7, 0x94, 0x5f, 0x9c, 0xd4, 0x94, 0xdf, 0x9f, 0xd4, + 0x94, 0xbf, 0x9c, 0xd4, 0x94, 0x97, 0x27, 0x35, 0xe5, 0xd5, 0x49, 0x4d, 0xf9, 0xc7, 0x49, 0x4d, + 0xf9, 0xe7, 0x49, 0x6d, 0xe1, 0xd3, 0x93, 0x9a, 0xf2, 0x9b, 0x37, 0xb5, 0x85, 0x97, 0x6f, 0x6a, + 0x0b, 0xaf, 0xde, 0xd4, 0x16, 0x3e, 0x3a, 0xcb, 0x48, 0xd9, 0x14, 0xff, 0x0f, 0xb9, 0x23, 0x7e, + 0x3b, 0x4b, 0x2c, 0x60, 0xef, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x5a, 0xbb, 0xcb, 0x29, + 0x19, 0x00, 0x00, } func (this *OutportBlock) Equal(that interface{}) bool { @@ -1326,6 +1340,14 @@ func (this *OutportBlock) Equal(that interface{}) bool { if !bytes.Equal(this.HighestFinalBlockHash, that1.HighestFinalBlockHash) { return false } + if len(this.StateChanges) != len(that1.StateChanges) { + return false + } + for i := range this.StateChanges { + if !this.StateChanges[i].Equal(that1.StateChanges[i]) { + return false + } + } return true } func (this *BlockData) Equal(that interface{}) bool { @@ -1932,7 +1954,7 @@ func (this *OutportBlock) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 14) + s := make([]string, 0, 15) s = append(s, "&outport.OutportBlock{") s = append(s, "ShardID: "+fmt.Sprintf("%#v", this.ShardID)+",\n") if this.BlockData != nil { @@ -1962,6 +1984,19 @@ func (this *OutportBlock) GoString() string { s = append(s, "SignersIndexes: "+fmt.Sprintf("%#v", this.SignersIndexes)+",\n") s = append(s, "HighestFinalBlockNonce: "+fmt.Sprintf("%#v", this.HighestFinalBlockNonce)+",\n") s = append(s, "HighestFinalBlockHash: "+fmt.Sprintf("%#v", this.HighestFinalBlockHash)+",\n") + keysForStateChanges := make([]string, 0, len(this.StateChanges)) + for k, _ := range this.StateChanges { + keysForStateChanges = append(keysForStateChanges, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStateChanges) + mapStringForStateChanges := "map[string]*stateChange.StateChanges{" + for _, k := range keysForStateChanges { + mapStringForStateChanges += fmt.Sprintf("%#v: %#v,", k, this.StateChanges[k]) + } + mapStringForStateChanges += "}" + if this.StateChanges != nil { + s = append(s, "StateChanges: "+mapStringForStateChanges+",\n") + } s = append(s, "}") return strings.Join(s, "") } @@ -2306,6 +2341,37 @@ func (m *OutportBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.StateChanges) > 0 { + keysForStateChanges := make([]string, 0, len(m.StateChanges)) + for k := range m.StateChanges { + keysForStateChanges = append(keysForStateChanges, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStateChanges) + for iNdEx := len(keysForStateChanges) - 1; iNdEx >= 0; iNdEx-- { + v := m.StateChanges[string(keysForStateChanges[iNdEx])] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintOutportBlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(keysForStateChanges[iNdEx]) + copy(dAtA[i:], keysForStateChanges[iNdEx]) + i = encodeVarintOutportBlock(dAtA, i, uint64(len(keysForStateChanges[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintOutportBlock(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x5a + } + } if len(m.HighestFinalBlockHash) > 0 { i -= len(m.HighestFinalBlockHash) copy(dAtA[i:], m.HighestFinalBlockHash) @@ -2319,20 +2385,20 @@ func (m *OutportBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x48 } if len(m.SignersIndexes) > 0 { - dAtA2 := make([]byte, len(m.SignersIndexes)*10) - var j1 int + dAtA3 := make([]byte, len(m.SignersIndexes)*10) + var j2 int for _, num := range m.SignersIndexes { for num >= 1<<7 { - dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) + dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j1++ + j2++ } - dAtA2[j1] = uint8(num) - j1++ + dAtA3[j2] = uint8(num) + j2++ } - i -= j1 - copy(dAtA[i:], dAtA2[:j1]) - i = encodeVarintOutportBlock(dAtA, i, uint64(j1)) + i -= j2 + copy(dAtA[i:], dAtA3[:j2]) + i = encodeVarintOutportBlock(dAtA, i, uint64(j2)) i-- dAtA[i] = 0x42 } @@ -3118,20 +3184,20 @@ func (m *RoundInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x18 } if len(m.SignersIndexes) > 0 { - dAtA20 := make([]byte, len(m.SignersIndexes)*10) - var j19 int + dAtA21 := make([]byte, len(m.SignersIndexes)*10) + var j20 int for _, num := range m.SignersIndexes { for num >= 1<<7 { - dAtA20[j19] = uint8(uint64(num)&0x7f | 0x80) + dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j19++ + j20++ } - dAtA20[j19] = uint8(num) - j19++ + dAtA21[j20] = uint8(num) + j20++ } - i -= j19 - copy(dAtA[i:], dAtA20[:j19]) - i = encodeVarintOutportBlock(dAtA, i, uint64(j19)) + i -= j20 + copy(dAtA[i:], dAtA21[:j20]) + i = encodeVarintOutportBlock(dAtA, i, uint64(j20)) i-- dAtA[i] = 0x12 } @@ -3474,6 +3540,19 @@ func (m *OutportBlock) Size() (n int) { if l > 0 { n += 1 + l + sovOutportBlock(uint64(l)) } + if len(m.StateChanges) > 0 { + for k, v := range m.StateChanges { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovOutportBlock(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovOutportBlock(uint64(len(k))) + l + n += mapEntrySize + 1 + sovOutportBlock(uint64(mapEntrySize)) + } + } return n } @@ -3924,6 +4003,16 @@ func (this *OutportBlock) String() string { mapStringForAlteredAccounts += fmt.Sprintf("%v: %v,", k, this.AlteredAccounts[k]) } mapStringForAlteredAccounts += "}" + keysForStateChanges := make([]string, 0, len(this.StateChanges)) + for k, _ := range this.StateChanges { + keysForStateChanges = append(keysForStateChanges, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStateChanges) + mapStringForStateChanges := "map[string]*stateChange.StateChanges{" + for _, k := range keysForStateChanges { + mapStringForStateChanges += fmt.Sprintf("%v: %v,", k, this.StateChanges[k]) + } + mapStringForStateChanges += "}" s := strings.Join([]string{`&OutportBlock{`, `ShardID:` + fmt.Sprintf("%v", this.ShardID) + `,`, `BlockData:` + strings.Replace(this.BlockData.String(), "BlockData", "BlockData", 1) + `,`, @@ -3935,6 +4024,7 @@ func (this *OutportBlock) String() string { `SignersIndexes:` + fmt.Sprintf("%v", this.SignersIndexes) + `,`, `HighestFinalBlockNonce:` + fmt.Sprintf("%v", this.HighestFinalBlockNonce) + `,`, `HighestFinalBlockHash:` + fmt.Sprintf("%v", this.HighestFinalBlockHash) + `,`, + `StateChanges:` + mapStringForStateChanges + `,`, `}`, }, "") return s @@ -4709,6 +4799,135 @@ func (m *OutportBlock) Unmarshal(dAtA []byte) error { m.HighestFinalBlockHash = []byte{} } iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOutportBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOutportBlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthOutportBlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateChanges == nil { + m.StateChanges = make(map[string]*stateChange.StateChanges) + } + var mapkey string + var mapvalue *stateChange.StateChanges + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOutportBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOutportBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthOutportBlock + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthOutportBlock + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOutportBlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthOutportBlock + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthOutportBlock + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &stateChange.StateChanges{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipOutportBlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOutportBlock + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.StateChanges[mapkey] = mapvalue + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipOutportBlock(dAtA[iNdEx:]) diff --git a/data/outport/outportBlock.proto b/data/outport/outportBlock.proto index dfad100a..69a00ad3 100644 --- a/data/outport/outportBlock.proto +++ b/data/outport/outportBlock.proto @@ -13,6 +13,7 @@ import "github.com/multiversx/mx-chain-core-go/data/smartContractResult/smartCon import "github.com/multiversx/mx-chain-core-go/data/receipt/receipt.proto"; import "github.com/multiversx/mx-chain-core-go/data/rewardTx/rewardTx.proto"; import "github.com/multiversx/mx-chain-core-go/data/alteredAccount/alteredAccount.proto"; +import "github.com/multiversx/mx-chain-core-go/data/stateChange/stateChange.proto"; message OutportBlock { uint32 ShardID = 1 [(gogoproto.jsontag) = "shardID,omitempty"]; @@ -25,6 +26,7 @@ message OutportBlock { repeated uint64 SignersIndexes = 8 [(gogoproto.jsontag) = "signersIndexes,omitempty"]; uint64 HighestFinalBlockNonce = 9 [(gogoproto.jsontag) = "highestFinalBlockNonce"]; bytes HighestFinalBlockHash = 10 [(gogoproto.jsontag) = "highestFinalBlockHash,omitempty"]; + map StateChanges = 11 [(gogoproto.jsontag) = "stateChanges,omitempty"]; } message BlockData { diff --git a/data/stateChange/stateChange.go b/data/stateChange/stateChange.go new file mode 100644 index 00000000..236dbb7e --- /dev/null +++ b/data/stateChange/stateChange.go @@ -0,0 +1,13 @@ +//go:generate protoc -I=. -I=$GOPATH/src -I=$GOPATH/src/github.com/multiversx/protobuf/protobuf --gogoslick_out=$GOPATH/src stateChange.proto + +package stateChange + +// SetTxHash will set the tx hash with a provided value +func (sc *StateChange) SetTxHash(txHash []byte) { + sc.TxHash = txHash +} + +// SetIndex will set the index with a provided value +func (sc *StateChange) SetIndex(index int32) { + sc.Index = index +} diff --git a/data/stateChange/stateChange.pb.go b/data/stateChange/stateChange.pb.go new file mode 100644 index 00000000..ec047a19 --- /dev/null +++ b/data/stateChange/stateChange.pb.go @@ -0,0 +1,1977 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: stateChange.proto + +package stateChange + +import ( + bytes "bytes" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strconv "strconv" + strings "strings" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type ActionType int32 + +const ( + Read ActionType = 0 + Write ActionType = 1 +) + +var ActionType_name = map[int32]string{ + 0: "Read", + 1: "Write", +} + +var ActionType_value = map[string]int32{ + "Read": 0, + "Write": 1, +} + +func (ActionType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{0} +} + +type Operation int32 + +const ( + GetCode Operation = 0 + SaveAccount Operation = 1 + GetAccount Operation = 2 + WriteCode Operation = 3 + RemoveDataTrie Operation = 4 +) + +var Operation_name = map[int32]string{ + 0: "GetCode", + 1: "SaveAccount", + 2: "GetAccount", + 3: "WriteCode", + 4: "RemoveDataTrie", +} + +var Operation_value = map[string]int32{ + "GetCode": 0, + "SaveAccount": 1, + "GetAccount": 2, + "WriteCode": 3, + "RemoveDataTrie": 4, +} + +func (Operation) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{1} +} + +type StateChanges struct { + StateChanges []*StateChange `protobuf:"bytes,1,rep,name=StateChanges,proto3" json:"stateChanges"` +} + +func (m *StateChanges) Reset() { *m = StateChanges{} } +func (*StateChanges) ProtoMessage() {} +func (*StateChanges) Descriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{0} +} +func (m *StateChanges) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StateChanges) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateChanges.Merge(m, src) +} +func (m *StateChanges) XXX_Size() int { + return m.Size() +} +func (m *StateChanges) XXX_DiscardUnknown() { + xxx_messageInfo_StateChanges.DiscardUnknown(m) +} + +var xxx_messageInfo_StateChanges proto.InternalMessageInfo + +func (m *StateChanges) GetStateChanges() []*StateChange { + if m != nil { + return m.StateChanges + } + return nil +} + +type StateChange struct { + Type ActionType `protobuf:"varint,1,opt,name=Type,proto3,enum=proto.ActionType" json:"type"` + Index int32 `protobuf:"varint,2,opt,name=Index,proto3" json:"index"` + TxHash []byte `protobuf:"bytes,3,opt,name=TxHash,proto3" json:"txHash"` + MainTrieKey []byte `protobuf:"bytes,4,opt,name=MainTrieKey,proto3" json:"mainTrieKey"` + MainTrieVal []byte `protobuf:"bytes,5,opt,name=MainTrieVal,proto3" json:"mainTrieVal"` + Operation Operation `protobuf:"varint,6,opt,name=Operation,proto3,enum=proto.Operation" json:"operation"` + DataTrieChanges []*DataTrieChange `protobuf:"bytes,7,rep,name=DataTrieChanges,proto3" json:"dataTrieChanges,omitempty"` +} + +func (m *StateChange) Reset() { *m = StateChange{} } +func (*StateChange) ProtoMessage() {} +func (*StateChange) Descriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{1} +} +func (m *StateChange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *StateChange) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateChange.Merge(m, src) +} +func (m *StateChange) XXX_Size() int { + return m.Size() +} +func (m *StateChange) XXX_DiscardUnknown() { + xxx_messageInfo_StateChange.DiscardUnknown(m) +} + +var xxx_messageInfo_StateChange proto.InternalMessageInfo + +func (m *StateChange) GetType() ActionType { + if m != nil { + return m.Type + } + return Read +} + +func (m *StateChange) GetIndex() int32 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *StateChange) GetTxHash() []byte { + if m != nil { + return m.TxHash + } + return nil +} + +func (m *StateChange) GetMainTrieKey() []byte { + if m != nil { + return m.MainTrieKey + } + return nil +} + +func (m *StateChange) GetMainTrieVal() []byte { + if m != nil { + return m.MainTrieVal + } + return nil +} + +func (m *StateChange) GetOperation() Operation { + if m != nil { + return m.Operation + } + return GetCode +} + +func (m *StateChange) GetDataTrieChanges() []*DataTrieChange { + if m != nil { + return m.DataTrieChanges + } + return nil +} + +type DataTrieChange struct { + Type ActionType `protobuf:"varint,1,opt,name=Type,proto3,enum=proto.ActionType" json:"type"` + Key []byte `protobuf:"bytes,2,opt,name=Key,proto3" json:"key"` + Val []byte `protobuf:"bytes,3,opt,name=Val,proto3" json:"val"` +} + +func (m *DataTrieChange) Reset() { *m = DataTrieChange{} } +func (*DataTrieChange) ProtoMessage() {} +func (*DataTrieChange) Descriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{2} +} +func (m *DataTrieChange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DataTrieChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *DataTrieChange) XXX_Merge(src proto.Message) { + xxx_messageInfo_DataTrieChange.Merge(m, src) +} +func (m *DataTrieChange) XXX_Size() int { + return m.Size() +} +func (m *DataTrieChange) XXX_DiscardUnknown() { + xxx_messageInfo_DataTrieChange.DiscardUnknown(m) +} + +var xxx_messageInfo_DataTrieChange proto.InternalMessageInfo + +func (m *DataTrieChange) GetType() ActionType { + if m != nil { + return m.Type + } + return Read +} + +func (m *DataTrieChange) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *DataTrieChange) GetVal() []byte { + if m != nil { + return m.Val + } + return nil +} + +type DataAnalysisStateChange struct { + StateChange *StateChange `protobuf:"bytes,1,opt,name=StateChange,proto3" json:"stateChange"` + Operation Operation `protobuf:"varint,2,opt,name=Operation,proto3,enum=proto.Operation" json:"operation"` + Nonce bool `protobuf:"varint,3,opt,name=Nonce,proto3" json:"nonceChanged"` + Balance bool `protobuf:"varint,4,opt,name=Balance,proto3" json:"balanceChanged"` + CodeHash bool `protobuf:"varint,5,opt,name=CodeHash,proto3" json:"codeHashChanged"` + RootHash bool `protobuf:"varint,6,opt,name=RootHash,proto3" json:"rootHashChanged"` + DeveloperReward bool `protobuf:"varint,7,opt,name=DeveloperReward,proto3" json:"developerRewardChanged"` + OwnerAddress bool `protobuf:"varint,8,opt,name=OwnerAddress,proto3" json:"ownerAddressChanged"` + UserName bool `protobuf:"varint,9,opt,name=UserName,proto3" json:"userNameChanged"` + CodeMetadata bool `protobuf:"varint,10,opt,name=CodeMetadata,proto3" json:"codeMetadataChanged"` +} + +func (m *DataAnalysisStateChange) Reset() { *m = DataAnalysisStateChange{} } +func (*DataAnalysisStateChange) ProtoMessage() {} +func (*DataAnalysisStateChange) Descriptor() ([]byte, []int) { + return fileDescriptor_8e577663eebb0888, []int{3} +} +func (m *DataAnalysisStateChange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DataAnalysisStateChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *DataAnalysisStateChange) XXX_Merge(src proto.Message) { + xxx_messageInfo_DataAnalysisStateChange.Merge(m, src) +} +func (m *DataAnalysisStateChange) XXX_Size() int { + return m.Size() +} +func (m *DataAnalysisStateChange) XXX_DiscardUnknown() { + xxx_messageInfo_DataAnalysisStateChange.DiscardUnknown(m) +} + +var xxx_messageInfo_DataAnalysisStateChange proto.InternalMessageInfo + +func (m *DataAnalysisStateChange) GetStateChange() *StateChange { + if m != nil { + return m.StateChange + } + return nil +} + +func (m *DataAnalysisStateChange) GetOperation() Operation { + if m != nil { + return m.Operation + } + return GetCode +} + +func (m *DataAnalysisStateChange) GetNonce() bool { + if m != nil { + return m.Nonce + } + return false +} + +func (m *DataAnalysisStateChange) GetBalance() bool { + if m != nil { + return m.Balance + } + return false +} + +func (m *DataAnalysisStateChange) GetCodeHash() bool { + if m != nil { + return m.CodeHash + } + return false +} + +func (m *DataAnalysisStateChange) GetRootHash() bool { + if m != nil { + return m.RootHash + } + return false +} + +func (m *DataAnalysisStateChange) GetDeveloperReward() bool { + if m != nil { + return m.DeveloperReward + } + return false +} + +func (m *DataAnalysisStateChange) GetOwnerAddress() bool { + if m != nil { + return m.OwnerAddress + } + return false +} + +func (m *DataAnalysisStateChange) GetUserName() bool { + if m != nil { + return m.UserName + } + return false +} + +func (m *DataAnalysisStateChange) GetCodeMetadata() bool { + if m != nil { + return m.CodeMetadata + } + return false +} + +func init() { + proto.RegisterEnum("proto.ActionType", ActionType_name, ActionType_value) + proto.RegisterEnum("proto.Operation", Operation_name, Operation_value) + proto.RegisterType((*StateChanges)(nil), "proto.StateChanges") + proto.RegisterType((*StateChange)(nil), "proto.StateChange") + proto.RegisterType((*DataTrieChange)(nil), "proto.DataTrieChange") + proto.RegisterType((*DataAnalysisStateChange)(nil), "proto.DataAnalysisStateChange") +} + +func init() { proto.RegisterFile("stateChange.proto", fileDescriptor_8e577663eebb0888) } + +var fileDescriptor_8e577663eebb0888 = []byte{ + // 756 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcf, 0x6f, 0xe2, 0x46, + 0x18, 0xb5, 0x01, 0xf3, 0x63, 0x20, 0x40, 0x26, 0x6a, 0xe3, 0x44, 0xaa, 0x4d, 0x39, 0x54, 0x28, + 0x0a, 0x41, 0x4d, 0x8f, 0x51, 0x0f, 0x38, 0xa9, 0x92, 0xaa, 0x4a, 0x22, 0x4d, 0xd2, 0xb4, 0xaa, + 0xaa, 0x4a, 0x83, 0x3d, 0x05, 0x6b, 0xb1, 0x07, 0xd9, 0x03, 0x81, 0xc3, 0x4a, 0x7b, 0xdc, 0xe3, + 0xfe, 0x19, 0xfb, 0xa7, 0xe4, 0x98, 0x63, 0x4e, 0xd6, 0xc6, 0xb9, 0xac, 0x7c, 0xca, 0x9f, 0xb0, + 0x9a, 0x01, 0x63, 0x3b, 0xbb, 0x97, 0x9c, 0x98, 0x79, 0xdf, 0x7b, 0x6f, 0xbe, 0xef, 0xe3, 0x01, + 0xd8, 0xf4, 0x19, 0x66, 0xe4, 0x78, 0x84, 0xdd, 0x21, 0x39, 0x98, 0x78, 0x94, 0x51, 0xa8, 0x88, + 0x8f, 0xdd, 0xee, 0xd0, 0x66, 0xa3, 0xe9, 0xe0, 0xc0, 0xa4, 0x4e, 0x6f, 0x48, 0x87, 0xb4, 0x27, + 0xe0, 0xc1, 0xf4, 0x7f, 0x71, 0x13, 0x17, 0x71, 0x5a, 0xaa, 0xda, 0x7f, 0x83, 0xda, 0x55, 0x62, + 0xe5, 0xc3, 0xb3, 0xec, 0x5d, 0x95, 0x5b, 0xf9, 0x4e, 0xf5, 0x10, 0x2e, 0xd9, 0x07, 0xa9, 0x92, + 0xd1, 0x8c, 0x02, 0xbd, 0x96, 0x6a, 0xc3, 0x47, 0x19, 0x65, 0xfb, 0x7d, 0x1e, 0x54, 0x53, 0x00, + 0xec, 0x81, 0xc2, 0xf5, 0x62, 0x42, 0x54, 0xb9, 0x25, 0x77, 0xea, 0x87, 0x9b, 0x2b, 0xc7, 0xbe, + 0xc9, 0x6c, 0xea, 0xf2, 0x82, 0x51, 0x8e, 0x02, 0xbd, 0xc0, 0x16, 0x13, 0x82, 0x04, 0x11, 0xea, + 0x40, 0xf9, 0xdd, 0xb5, 0xc8, 0x5c, 0xcd, 0xb5, 0xe4, 0x8e, 0x62, 0x54, 0xa2, 0x40, 0x57, 0x6c, + 0x0e, 0xa0, 0x25, 0x0e, 0xdb, 0xa0, 0x78, 0x3d, 0x3f, 0xc3, 0xfe, 0x48, 0xcd, 0xb7, 0xe4, 0x4e, + 0xcd, 0x00, 0x51, 0xa0, 0x17, 0x99, 0x40, 0xd0, 0xaa, 0x02, 0x7f, 0x06, 0xd5, 0x73, 0x6c, 0xbb, + 0xd7, 0x9e, 0x4d, 0xfe, 0x20, 0x0b, 0xb5, 0x20, 0x88, 0x8d, 0x28, 0xd0, 0xab, 0x4e, 0x02, 0xa3, + 0x34, 0x27, 0x2d, 0xb9, 0xc1, 0x63, 0x55, 0xf9, 0x5a, 0x72, 0x83, 0xc7, 0x28, 0xcd, 0x81, 0xbf, + 0x82, 0xca, 0xe5, 0x84, 0x78, 0x98, 0xcf, 0xa2, 0x16, 0xc5, 0x80, 0xcd, 0xd5, 0x80, 0x6b, 0xdc, + 0xd8, 0x88, 0x02, 0xbd, 0x42, 0xe3, 0x2b, 0x4a, 0x14, 0xf0, 0x3f, 0xd0, 0x38, 0xc1, 0x0c, 0x73, + 0xb7, 0x78, 0xef, 0x25, 0xb1, 0xf7, 0xef, 0x56, 0x26, 0xd9, 0xaa, 0xf1, 0x43, 0x14, 0xe8, 0x3b, + 0x56, 0x56, 0xb1, 0x4f, 0x1d, 0x9b, 0x11, 0x67, 0xc2, 0x16, 0xe8, 0xa5, 0x59, 0xfb, 0x16, 0xd4, + 0xb3, 0xd0, 0xeb, 0xbf, 0x8c, 0x1d, 0x90, 0xe7, 0xfb, 0xcb, 0x89, 0x65, 0x94, 0xa2, 0x40, 0xcf, + 0xbf, 0x21, 0x0b, 0xc4, 0x31, 0x5e, 0xe2, 0x7b, 0xca, 0x27, 0xa5, 0x19, 0x1e, 0x23, 0x8e, 0xb5, + 0xef, 0x0a, 0x60, 0x9b, 0xbf, 0xdc, 0x77, 0xf1, 0x78, 0xe1, 0xdb, 0x7e, 0x3a, 0x0f, 0xbf, 0x65, + 0xe2, 0x21, 0x3a, 0xf9, 0x76, 0xd0, 0xc4, 0xea, 0x53, 0x41, 0x43, 0x99, 0x58, 0x65, 0x56, 0x9f, + 0x7b, 0xf5, 0xea, 0x7f, 0x02, 0xca, 0x05, 0x75, 0x4d, 0x22, 0xda, 0x2f, 0x2f, 0x43, 0xed, 0x72, + 0x60, 0x69, 0x6f, 0xa1, 0x65, 0x19, 0xee, 0x83, 0x92, 0x81, 0xc7, 0x98, 0x33, 0x0b, 0x82, 0x09, + 0xa3, 0x40, 0xaf, 0x0f, 0x96, 0x50, 0xcc, 0x8d, 0x29, 0xb0, 0x07, 0xca, 0xc7, 0xd4, 0x22, 0x22, + 0x9b, 0x8a, 0xa0, 0x6f, 0x45, 0x81, 0xde, 0x30, 0x57, 0x58, 0xcc, 0x5f, 0x93, 0xb8, 0x00, 0x51, + 0xca, 0x84, 0xa0, 0x98, 0x08, 0xbc, 0x15, 0xb6, 0x16, 0xc4, 0x24, 0x78, 0x02, 0x1a, 0x27, 0x64, + 0x46, 0xc6, 0x7c, 0x28, 0x44, 0x6e, 0xb1, 0x67, 0xa9, 0x25, 0xa1, 0xdb, 0x8d, 0x02, 0xfd, 0x7b, + 0x2b, 0x5b, 0x8a, 0xe5, 0x2f, 0x25, 0xf0, 0x08, 0xd4, 0x2e, 0x6f, 0x5d, 0xe2, 0xf5, 0x2d, 0xcb, + 0x23, 0xbe, 0xaf, 0x96, 0x85, 0xc5, 0x76, 0x14, 0xe8, 0x5b, 0x34, 0x85, 0xc7, 0xfa, 0x0c, 0x99, + 0xf7, 0xfc, 0xa7, 0x4f, 0xbc, 0x0b, 0xec, 0x10, 0xb5, 0x92, 0xf4, 0x3c, 0x5d, 0x61, 0xeb, 0x9e, + 0x63, 0x12, 0x7f, 0x8d, 0x0f, 0x7c, 0x4e, 0x18, 0xe6, 0xe1, 0x55, 0x41, 0xf2, 0x9a, 0x99, 0xc2, + 0xd7, 0xaf, 0xa5, 0xc9, 0x7b, 0x3f, 0x02, 0x90, 0xc4, 0x13, 0x96, 0x41, 0x01, 0x11, 0x6c, 0x35, + 0x25, 0x58, 0x01, 0xca, 0x5f, 0x9e, 0xcd, 0x48, 0x53, 0xde, 0xfb, 0x37, 0x15, 0x05, 0x58, 0x05, + 0xa5, 0x53, 0xc2, 0xb8, 0x45, 0x53, 0x82, 0x0d, 0x50, 0xbd, 0xc2, 0x33, 0xd2, 0x37, 0x4d, 0x3a, + 0x75, 0x59, 0x53, 0x86, 0x75, 0x00, 0x4e, 0x09, 0x8b, 0xef, 0x39, 0xb8, 0x01, 0x2a, 0xc2, 0x45, + 0xf0, 0xf3, 0x10, 0x82, 0x3a, 0x22, 0x0e, 0x9d, 0x91, 0xf8, 0x67, 0xd3, 0x2c, 0x18, 0x6f, 0xef, + 0x1f, 0x35, 0xe9, 0xe1, 0x51, 0x93, 0x9e, 0x1f, 0x35, 0xf9, 0x5d, 0xa8, 0xc9, 0x1f, 0x43, 0x4d, + 0xbe, 0x0b, 0x35, 0xf9, 0x3e, 0xd4, 0xe4, 0x87, 0x50, 0x93, 0x3f, 0x85, 0x9a, 0xfc, 0x39, 0xd4, + 0xa4, 0xe7, 0x50, 0x93, 0x3f, 0x3c, 0x69, 0xd2, 0xfd, 0x93, 0x26, 0x3d, 0x3c, 0x69, 0xd2, 0x3f, + 0xc7, 0xa9, 0xbf, 0x64, 0x67, 0x3a, 0x66, 0xf6, 0x8c, 0x78, 0xfe, 0xbc, 0xe7, 0xcc, 0xbb, 0xe6, + 0x08, 0xdb, 0x6e, 0xd7, 0xa4, 0x1e, 0xe9, 0x0e, 0x69, 0x8f, 0xcf, 0xd9, 0x4b, 0x05, 0xfd, 0x28, + 0x75, 0x1e, 0x14, 0x45, 0xa6, 0x7f, 0xf9, 0x12, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x5e, 0xf2, 0xf2, + 0xfa, 0x05, 0x00, 0x00, +} + +func (x ActionType) String() string { + s, ok := ActionType_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Operation) String() string { + s, ok := Operation_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *StateChanges) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*StateChanges) + if !ok { + that2, ok := that.(StateChanges) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if len(this.StateChanges) != len(that1.StateChanges) { + return false + } + for i := range this.StateChanges { + if !this.StateChanges[i].Equal(that1.StateChanges[i]) { + return false + } + } + return true +} +func (this *StateChange) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*StateChange) + if !ok { + that2, ok := that.(StateChange) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Type != that1.Type { + return false + } + if this.Index != that1.Index { + return false + } + if !bytes.Equal(this.TxHash, that1.TxHash) { + return false + } + if !bytes.Equal(this.MainTrieKey, that1.MainTrieKey) { + return false + } + if !bytes.Equal(this.MainTrieVal, that1.MainTrieVal) { + return false + } + if this.Operation != that1.Operation { + return false + } + if len(this.DataTrieChanges) != len(that1.DataTrieChanges) { + return false + } + for i := range this.DataTrieChanges { + if !this.DataTrieChanges[i].Equal(that1.DataTrieChanges[i]) { + return false + } + } + return true +} +func (this *DataTrieChange) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*DataTrieChange) + if !ok { + that2, ok := that.(DataTrieChange) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Type != that1.Type { + return false + } + if !bytes.Equal(this.Key, that1.Key) { + return false + } + if !bytes.Equal(this.Val, that1.Val) { + return false + } + return true +} +func (this *DataAnalysisStateChange) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*DataAnalysisStateChange) + if !ok { + that2, ok := that.(DataAnalysisStateChange) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.StateChange.Equal(that1.StateChange) { + return false + } + if this.Operation != that1.Operation { + return false + } + if this.Nonce != that1.Nonce { + return false + } + if this.Balance != that1.Balance { + return false + } + if this.CodeHash != that1.CodeHash { + return false + } + if this.RootHash != that1.RootHash { + return false + } + if this.DeveloperReward != that1.DeveloperReward { + return false + } + if this.OwnerAddress != that1.OwnerAddress { + return false + } + if this.UserName != that1.UserName { + return false + } + if this.CodeMetadata != that1.CodeMetadata { + return false + } + return true +} +func (this *StateChanges) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&stateChange.StateChanges{") + if this.StateChanges != nil { + s = append(s, "StateChanges: "+fmt.Sprintf("%#v", this.StateChanges)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *StateChange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&stateChange.StateChange{") + s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") + s = append(s, "Index: "+fmt.Sprintf("%#v", this.Index)+",\n") + s = append(s, "TxHash: "+fmt.Sprintf("%#v", this.TxHash)+",\n") + s = append(s, "MainTrieKey: "+fmt.Sprintf("%#v", this.MainTrieKey)+",\n") + s = append(s, "MainTrieVal: "+fmt.Sprintf("%#v", this.MainTrieVal)+",\n") + s = append(s, "Operation: "+fmt.Sprintf("%#v", this.Operation)+",\n") + if this.DataTrieChanges != nil { + s = append(s, "DataTrieChanges: "+fmt.Sprintf("%#v", this.DataTrieChanges)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DataTrieChange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&stateChange.DataTrieChange{") + s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + s = append(s, "Val: "+fmt.Sprintf("%#v", this.Val)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DataAnalysisStateChange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&stateChange.DataAnalysisStateChange{") + if this.StateChange != nil { + s = append(s, "StateChange: "+fmt.Sprintf("%#v", this.StateChange)+",\n") + } + s = append(s, "Operation: "+fmt.Sprintf("%#v", this.Operation)+",\n") + s = append(s, "Nonce: "+fmt.Sprintf("%#v", this.Nonce)+",\n") + s = append(s, "Balance: "+fmt.Sprintf("%#v", this.Balance)+",\n") + s = append(s, "CodeHash: "+fmt.Sprintf("%#v", this.CodeHash)+",\n") + s = append(s, "RootHash: "+fmt.Sprintf("%#v", this.RootHash)+",\n") + s = append(s, "DeveloperReward: "+fmt.Sprintf("%#v", this.DeveloperReward)+",\n") + s = append(s, "OwnerAddress: "+fmt.Sprintf("%#v", this.OwnerAddress)+",\n") + s = append(s, "UserName: "+fmt.Sprintf("%#v", this.UserName)+",\n") + s = append(s, "CodeMetadata: "+fmt.Sprintf("%#v", this.CodeMetadata)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringStateChange(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func (m *StateChanges) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StateChanges) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.StateChanges) > 0 { + for iNdEx := len(m.StateChanges) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.StateChanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStateChange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *StateChange) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StateChange) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.DataTrieChanges) > 0 { + for iNdEx := len(m.DataTrieChanges) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DataTrieChanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStateChange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + } + if m.Operation != 0 { + i = encodeVarintStateChange(dAtA, i, uint64(m.Operation)) + i-- + dAtA[i] = 0x30 + } + if len(m.MainTrieVal) > 0 { + i -= len(m.MainTrieVal) + copy(dAtA[i:], m.MainTrieVal) + i = encodeVarintStateChange(dAtA, i, uint64(len(m.MainTrieVal))) + i-- + dAtA[i] = 0x2a + } + if len(m.MainTrieKey) > 0 { + i -= len(m.MainTrieKey) + copy(dAtA[i:], m.MainTrieKey) + i = encodeVarintStateChange(dAtA, i, uint64(len(m.MainTrieKey))) + i-- + dAtA[i] = 0x22 + } + if len(m.TxHash) > 0 { + i -= len(m.TxHash) + copy(dAtA[i:], m.TxHash) + i = encodeVarintStateChange(dAtA, i, uint64(len(m.TxHash))) + i-- + dAtA[i] = 0x1a + } + if m.Index != 0 { + i = encodeVarintStateChange(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x10 + } + if m.Type != 0 { + i = encodeVarintStateChange(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DataTrieChange) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DataTrieChange) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DataTrieChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Val) > 0 { + i -= len(m.Val) + copy(dAtA[i:], m.Val) + i = encodeVarintStateChange(dAtA, i, uint64(len(m.Val))) + i-- + dAtA[i] = 0x1a + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintStateChange(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if m.Type != 0 { + i = encodeVarintStateChange(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DataAnalysisStateChange) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DataAnalysisStateChange) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DataAnalysisStateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CodeMetadata { + i-- + if m.CodeMetadata { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x50 + } + if m.UserName { + i-- + if m.UserName { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if m.OwnerAddress { + i-- + if m.OwnerAddress { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.DeveloperReward { + i-- + if m.DeveloperReward { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.RootHash { + i-- + if m.RootHash { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.CodeHash { + i-- + if m.CodeHash { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.Balance { + i-- + if m.Balance { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.Nonce { + i-- + if m.Nonce { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.Operation != 0 { + i = encodeVarintStateChange(dAtA, i, uint64(m.Operation)) + i-- + dAtA[i] = 0x10 + } + if m.StateChange != nil { + { + size, err := m.StateChange.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStateChange(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintStateChange(dAtA []byte, offset int, v uint64) int { + offset -= sovStateChange(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *StateChanges) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.StateChanges) > 0 { + for _, e := range m.StateChanges { + l = e.Size() + n += 1 + l + sovStateChange(uint64(l)) + } + } + return n +} + +func (m *StateChange) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovStateChange(uint64(m.Type)) + } + if m.Index != 0 { + n += 1 + sovStateChange(uint64(m.Index)) + } + l = len(m.TxHash) + if l > 0 { + n += 1 + l + sovStateChange(uint64(l)) + } + l = len(m.MainTrieKey) + if l > 0 { + n += 1 + l + sovStateChange(uint64(l)) + } + l = len(m.MainTrieVal) + if l > 0 { + n += 1 + l + sovStateChange(uint64(l)) + } + if m.Operation != 0 { + n += 1 + sovStateChange(uint64(m.Operation)) + } + if len(m.DataTrieChanges) > 0 { + for _, e := range m.DataTrieChanges { + l = e.Size() + n += 1 + l + sovStateChange(uint64(l)) + } + } + return n +} + +func (m *DataTrieChange) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Type != 0 { + n += 1 + sovStateChange(uint64(m.Type)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovStateChange(uint64(l)) + } + l = len(m.Val) + if l > 0 { + n += 1 + l + sovStateChange(uint64(l)) + } + return n +} + +func (m *DataAnalysisStateChange) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StateChange != nil { + l = m.StateChange.Size() + n += 1 + l + sovStateChange(uint64(l)) + } + if m.Operation != 0 { + n += 1 + sovStateChange(uint64(m.Operation)) + } + if m.Nonce { + n += 2 + } + if m.Balance { + n += 2 + } + if m.CodeHash { + n += 2 + } + if m.RootHash { + n += 2 + } + if m.DeveloperReward { + n += 2 + } + if m.OwnerAddress { + n += 2 + } + if m.UserName { + n += 2 + } + if m.CodeMetadata { + n += 2 + } + return n +} + +func sovStateChange(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozStateChange(x uint64) (n int) { + return sovStateChange(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *StateChanges) String() string { + if this == nil { + return "nil" + } + repeatedStringForStateChanges := "[]*StateChange{" + for _, f := range this.StateChanges { + repeatedStringForStateChanges += strings.Replace(f.String(), "StateChange", "StateChange", 1) + "," + } + repeatedStringForStateChanges += "}" + s := strings.Join([]string{`&StateChanges{`, + `StateChanges:` + repeatedStringForStateChanges + `,`, + `}`, + }, "") + return s +} +func (this *StateChange) String() string { + if this == nil { + return "nil" + } + repeatedStringForDataTrieChanges := "[]*DataTrieChange{" + for _, f := range this.DataTrieChanges { + repeatedStringForDataTrieChanges += strings.Replace(f.String(), "DataTrieChange", "DataTrieChange", 1) + "," + } + repeatedStringForDataTrieChanges += "}" + s := strings.Join([]string{`&StateChange{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Index:` + fmt.Sprintf("%v", this.Index) + `,`, + `TxHash:` + fmt.Sprintf("%v", this.TxHash) + `,`, + `MainTrieKey:` + fmt.Sprintf("%v", this.MainTrieKey) + `,`, + `MainTrieVal:` + fmt.Sprintf("%v", this.MainTrieVal) + `,`, + `Operation:` + fmt.Sprintf("%v", this.Operation) + `,`, + `DataTrieChanges:` + repeatedStringForDataTrieChanges + `,`, + `}`, + }, "") + return s +} +func (this *DataTrieChange) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DataTrieChange{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Val:` + fmt.Sprintf("%v", this.Val) + `,`, + `}`, + }, "") + return s +} +func (this *DataAnalysisStateChange) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DataAnalysisStateChange{`, + `StateChange:` + strings.Replace(this.StateChange.String(), "StateChange", "StateChange", 1) + `,`, + `Operation:` + fmt.Sprintf("%v", this.Operation) + `,`, + `Nonce:` + fmt.Sprintf("%v", this.Nonce) + `,`, + `Balance:` + fmt.Sprintf("%v", this.Balance) + `,`, + `CodeHash:` + fmt.Sprintf("%v", this.CodeHash) + `,`, + `RootHash:` + fmt.Sprintf("%v", this.RootHash) + `,`, + `DeveloperReward:` + fmt.Sprintf("%v", this.DeveloperReward) + `,`, + `OwnerAddress:` + fmt.Sprintf("%v", this.OwnerAddress) + `,`, + `UserName:` + fmt.Sprintf("%v", this.UserName) + `,`, + `CodeMetadata:` + fmt.Sprintf("%v", this.CodeMetadata) + `,`, + `}`, + }, "") + return s +} +func valueToStringStateChange(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *StateChanges) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StateChanges: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateChanges: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StateChanges = append(m.StateChanges, &StateChange{}) + if err := m.StateChanges[len(m.StateChanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStateChange(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StateChange) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StateChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= ActionType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TxHash = append(m.TxHash[:0], dAtA[iNdEx:postIndex]...) + if m.TxHash == nil { + m.TxHash = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MainTrieKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MainTrieKey = append(m.MainTrieKey[:0], dAtA[iNdEx:postIndex]...) + if m.MainTrieKey == nil { + m.MainTrieKey = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MainTrieVal", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MainTrieVal = append(m.MainTrieVal[:0], dAtA[iNdEx:postIndex]...) + if m.MainTrieVal == nil { + m.MainTrieVal = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType) + } + m.Operation = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Operation |= Operation(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataTrieChanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DataTrieChanges = append(m.DataTrieChanges, &DataTrieChange{}) + if err := m.DataTrieChanges[len(m.DataTrieChanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStateChange(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DataTrieChange) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DataTrieChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DataTrieChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= ActionType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Val", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Val = append(m.Val[:0], dAtA[iNdEx:postIndex]...) + if m.Val == nil { + m.Val = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStateChange(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DataAnalysisStateChange) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DataAnalysisStateChange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DataAnalysisStateChange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateChange", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStateChange + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStateChange + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateChange == nil { + m.StateChange = &StateChange{} + } + if err := m.StateChange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType) + } + m.Operation = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Operation |= Operation(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Nonce = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Balance = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeHash", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CodeHash = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RootHash", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RootHash = bool(v != 0) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DeveloperReward", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DeveloperReward = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.OwnerAddress = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UserName", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.UserName = bool(v != 0) + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeMetadata", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStateChange + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.CodeMetadata = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipStateChange(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStateChange + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipStateChange(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStateChange + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStateChange + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowStateChange + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthStateChange + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupStateChange + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthStateChange + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthStateChange = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowStateChange = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupStateChange = fmt.Errorf("proto: unexpected end of group") +) diff --git a/data/stateChange/stateChange.proto b/data/stateChange/stateChange.proto new file mode 100644 index 00000000..6f309651 --- /dev/null +++ b/data/stateChange/stateChange.proto @@ -0,0 +1,54 @@ +syntax = "proto3"; + +package proto; + +option go_package = "github.com/multiversx/mx-chain-core-go/data/stateChange;stateChange"; +option (gogoproto.stable_marshaler_all) = true; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message StateChanges { + repeated StateChange StateChanges = 1 [(gogoproto.jsontag) = "stateChanges"]; +} + +enum ActionType { + Read = 0; + Write = 1; +} + +enum Operation { + GetCode = 0; + SaveAccount = 1; + GetAccount = 2; + WriteCode = 3; + RemoveDataTrie = 4; +} + +message StateChange { + ActionType Type = 1 [(gogoproto.jsontag) = "type"]; + int32 Index = 2 [(gogoproto.jsontag) = "index"]; + bytes TxHash = 3 [(gogoproto.jsontag) = "txHash"]; + bytes MainTrieKey = 4 [(gogoproto.jsontag) = "mainTrieKey"]; + bytes MainTrieVal = 5 [(gogoproto.jsontag) = "mainTrieVal"]; + Operation Operation = 6 [(gogoproto.jsontag) = "operation"]; + repeated DataTrieChange DataTrieChanges = 7 [(gogoproto.jsontag) = "dataTrieChanges,omitempty"]; +} + +message DataTrieChange { + ActionType Type = 1 [(gogoproto.jsontag) = "type"]; + bytes Key = 2 [(gogoproto.jsontag) = "key"]; + bytes Val = 3 [(gogoproto.jsontag) = "val"]; +} + +message DataAnalysisStateChange { + StateChange StateChange = 1 [(gogoproto.jsontag) = "stateChange"]; + Operation Operation = 2 [(gogoproto.jsontag) = "operation"]; + bool Nonce = 3 [(gogoproto.jsontag) = "nonceChanged"]; + bool Balance = 4 [(gogoproto.jsontag) = "balanceChanged"]; + bool CodeHash = 5 [(gogoproto.jsontag) = "codeHashChanged"]; + bool RootHash = 6 [(gogoproto.jsontag) = "rootHashChanged"]; + bool DeveloperReward = 7 [(gogoproto.jsontag) = "developerRewardChanged"]; + bool OwnerAddress = 8 [(gogoproto.jsontag) = "ownerAddressChanged"]; + bool UserName = 9 [(gogoproto.jsontag) = "userNameChanged"]; + bool CodeMetadata = 10 [(gogoproto.jsontag) = "codeMetadataChanged"]; +}