From fada6a13521bc26cad3e5e05f7c1cdda6c374911 Mon Sep 17 00:00:00 2001 From: Chenyao Yu <4844716+chenyaoy@users.noreply.github.com> Date: Mon, 20 May 2024 14:50:38 -0400 Subject: [PATCH] [CT-853] Generate order replacement protos (#1551) * Generate order replacement protos (cherry picked from commit 722ec245cbb379787b2e9a367088016906df6380) # Conflicts: # protocol/indexer/events/events.pb.go # protocol/indexer/off_chain_updates/types/off_chain_updates.pb.go --- .../dydxprotocol/indexer/events/events.ts | 69 ++- .../off_chain_updates/off_chain_updates.ts | 93 +++- .../dydxprotocol/indexer/events/events.proto | 6 + .../off_chain_updates/off_chain_updates.proto | 14 +- protocol/indexer/events/events.pb.go | 414 +++++++++++++++++ .../types/off_chain_updates.pb.go | 416 +++++++++++++++++- 6 files changed, 1004 insertions(+), 8 deletions(-) diff --git a/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/events/events.ts b/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/events/events.ts index e90dd087b7..db1669d820 100644 --- a/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/events/events.ts +++ b/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/events/events.ts @@ -624,6 +624,7 @@ export interface StatefulOrderEventV1 { conditionalOrderPlacement?: StatefulOrderEventV1_ConditionalOrderPlacementV1; conditionalOrderTriggered?: StatefulOrderEventV1_ConditionalOrderTriggeredV1; longTermOrderPlacement?: StatefulOrderEventV1_LongTermOrderPlacementV1; + orderReplace?: StatefulOrderEventV1_LongTermOrderReplacementV1; } /** * StatefulOrderEvent message contains information about a change to a stateful @@ -638,6 +639,7 @@ export interface StatefulOrderEventV1SDKType { conditional_order_placement?: StatefulOrderEventV1_ConditionalOrderPlacementV1SDKType; conditional_order_triggered?: StatefulOrderEventV1_ConditionalOrderTriggeredV1SDKType; long_term_order_placement?: StatefulOrderEventV1_LongTermOrderPlacementV1SDKType; + order_replace?: StatefulOrderEventV1_LongTermOrderReplacementV1SDKType; } /** A stateful order placement contains an order. */ @@ -709,6 +711,16 @@ export interface StatefulOrderEventV1_LongTermOrderPlacementV1 { export interface StatefulOrderEventV1_LongTermOrderPlacementV1SDKType { order?: IndexerOrderSDKType; } +/** A long term order placement contains an order. */ + +export interface StatefulOrderEventV1_LongTermOrderReplacementV1 { + order?: IndexerOrder; +} +/** A long term order placement contains an order. */ + +export interface StatefulOrderEventV1_LongTermOrderReplacementV1SDKType { + order?: IndexerOrderSDKType; +} /** * AssetCreateEventV1 message contains all the information about an new Asset on * the dYdX chain. @@ -2387,7 +2399,8 @@ function createBaseStatefulOrderEventV1(): StatefulOrderEventV1 { orderRemoval: undefined, conditionalOrderPlacement: undefined, conditionalOrderTriggered: undefined, - longTermOrderPlacement: undefined + longTermOrderPlacement: undefined, + orderReplace: undefined }; } @@ -2413,6 +2426,10 @@ export const StatefulOrderEventV1 = { StatefulOrderEventV1_LongTermOrderPlacementV1.encode(message.longTermOrderPlacement, writer.uint32(58).fork()).ldelim(); } + if (message.orderReplace !== undefined) { + StatefulOrderEventV1_LongTermOrderReplacementV1.encode(message.orderReplace, writer.uint32(66).fork()).ldelim(); + } + return writer; }, @@ -2445,6 +2462,10 @@ export const StatefulOrderEventV1 = { message.longTermOrderPlacement = StatefulOrderEventV1_LongTermOrderPlacementV1.decode(reader, reader.uint32()); break; + case 8: + message.orderReplace = StatefulOrderEventV1_LongTermOrderReplacementV1.decode(reader, reader.uint32()); + break; + default: reader.skipType(tag & 7); break; @@ -2461,6 +2482,7 @@ export const StatefulOrderEventV1 = { message.conditionalOrderPlacement = object.conditionalOrderPlacement !== undefined && object.conditionalOrderPlacement !== null ? StatefulOrderEventV1_ConditionalOrderPlacementV1.fromPartial(object.conditionalOrderPlacement) : undefined; message.conditionalOrderTriggered = object.conditionalOrderTriggered !== undefined && object.conditionalOrderTriggered !== null ? StatefulOrderEventV1_ConditionalOrderTriggeredV1.fromPartial(object.conditionalOrderTriggered) : undefined; message.longTermOrderPlacement = object.longTermOrderPlacement !== undefined && object.longTermOrderPlacement !== null ? StatefulOrderEventV1_LongTermOrderPlacementV1.fromPartial(object.longTermOrderPlacement) : undefined; + message.orderReplace = object.orderReplace !== undefined && object.orderReplace !== null ? StatefulOrderEventV1_LongTermOrderReplacementV1.fromPartial(object.orderReplace) : undefined; return message; } @@ -2701,6 +2723,51 @@ export const StatefulOrderEventV1_LongTermOrderPlacementV1 = { }; +function createBaseStatefulOrderEventV1_LongTermOrderReplacementV1(): StatefulOrderEventV1_LongTermOrderReplacementV1 { + return { + order: undefined + }; +} + +export const StatefulOrderEventV1_LongTermOrderReplacementV1 = { + encode(message: StatefulOrderEventV1_LongTermOrderReplacementV1, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.order !== undefined) { + IndexerOrder.encode(message.order, writer.uint32(10).fork()).ldelim(); + } + + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): StatefulOrderEventV1_LongTermOrderReplacementV1 { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseStatefulOrderEventV1_LongTermOrderReplacementV1(); + + while (reader.pos < end) { + const tag = reader.uint32(); + + switch (tag >>> 3) { + case 1: + message.order = IndexerOrder.decode(reader, reader.uint32()); + break; + + default: + reader.skipType(tag & 7); + break; + } + } + + return message; + }, + + fromPartial(object: DeepPartial): StatefulOrderEventV1_LongTermOrderReplacementV1 { + const message = createBaseStatefulOrderEventV1_LongTermOrderReplacementV1(); + message.order = object.order !== undefined && object.order !== null ? IndexerOrder.fromPartial(object.order) : undefined; + return message; + } + +}; + function createBaseAssetCreateEventV1(): AssetCreateEventV1 { return { id: 0, diff --git a/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/off_chain_updates/off_chain_updates.ts b/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/off_chain_updates/off_chain_updates.ts index e66f9b0e5c..47dcfcf0fe 100644 --- a/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/off_chain_updates/off_chain_updates.ts +++ b/indexer/packages/v4-protos/src/codegen/dydxprotocol/indexer/off_chain_updates/off_chain_updates.ts @@ -265,6 +265,20 @@ export interface OrderUpdateV1SDKType { order_id?: IndexerOrderIdSDKType; total_filled_quantums: Long; } +/** OrderReplace messages contain the replacement order. */ + +export interface OrderReplaceV1 { + order?: IndexerOrder; + placementStatus: OrderPlaceV1_OrderPlacementStatus; + timeStamp?: Date; +} +/** OrderReplace messages contain the replacement order. */ + +export interface OrderReplaceV1SDKType { + order?: IndexerOrderSDKType; + placement_status: OrderPlaceV1_OrderPlacementStatusSDKType; + time_stamp?: Date; +} /** * An OffChainUpdate message is the message type which will be sent on Kafka to * the Indexer. @@ -274,6 +288,7 @@ export interface OffChainUpdateV1 { orderPlace?: OrderPlaceV1; orderRemove?: OrderRemoveV1; orderUpdate?: OrderUpdateV1; + orderReplace?: OrderReplaceV1; } /** * An OffChainUpdate message is the message type which will be sent on Kafka to @@ -284,6 +299,7 @@ export interface OffChainUpdateV1SDKType { order_place?: OrderPlaceV1SDKType; order_remove?: OrderRemoveV1SDKType; order_update?: OrderUpdateV1SDKType; + order_replace?: OrderReplaceV1SDKType; } function createBaseOrderPlaceV1(): OrderPlaceV1 { @@ -461,11 +477,77 @@ export const OrderUpdateV1 = { }; +function createBaseOrderReplaceV1(): OrderReplaceV1 { + return { + order: undefined, + placementStatus: 0, + timeStamp: undefined + }; +} + +export const OrderReplaceV1 = { + encode(message: OrderReplaceV1, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.order !== undefined) { + IndexerOrder.encode(message.order, writer.uint32(10).fork()).ldelim(); + } + + if (message.placementStatus !== 0) { + writer.uint32(16).int32(message.placementStatus); + } + + if (message.timeStamp !== undefined) { + Timestamp.encode(toTimestamp(message.timeStamp), writer.uint32(26).fork()).ldelim(); + } + + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): OrderReplaceV1 { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseOrderReplaceV1(); + + while (reader.pos < end) { + const tag = reader.uint32(); + + switch (tag >>> 3) { + case 1: + message.order = IndexerOrder.decode(reader, reader.uint32()); + break; + + case 2: + message.placementStatus = (reader.int32() as any); + break; + + case 3: + message.timeStamp = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + break; + + default: + reader.skipType(tag & 7); + break; + } + } + + return message; + }, + + fromPartial(object: DeepPartial): OrderReplaceV1 { + const message = createBaseOrderReplaceV1(); + message.order = object.order !== undefined && object.order !== null ? IndexerOrder.fromPartial(object.order) : undefined; + message.placementStatus = object.placementStatus ?? 0; + message.timeStamp = object.timeStamp ?? undefined; + return message; + } + +}; + function createBaseOffChainUpdateV1(): OffChainUpdateV1 { return { orderPlace: undefined, orderRemove: undefined, - orderUpdate: undefined + orderUpdate: undefined, + orderReplace: undefined }; } @@ -483,6 +565,10 @@ export const OffChainUpdateV1 = { OrderUpdateV1.encode(message.orderUpdate, writer.uint32(26).fork()).ldelim(); } + if (message.orderReplace !== undefined) { + OrderReplaceV1.encode(message.orderReplace, writer.uint32(34).fork()).ldelim(); + } + return writer; }, @@ -507,6 +593,10 @@ export const OffChainUpdateV1 = { message.orderUpdate = OrderUpdateV1.decode(reader, reader.uint32()); break; + case 4: + message.orderReplace = OrderReplaceV1.decode(reader, reader.uint32()); + break; + default: reader.skipType(tag & 7); break; @@ -521,6 +611,7 @@ export const OffChainUpdateV1 = { message.orderPlace = object.orderPlace !== undefined && object.orderPlace !== null ? OrderPlaceV1.fromPartial(object.orderPlace) : undefined; message.orderRemove = object.orderRemove !== undefined && object.orderRemove !== null ? OrderRemoveV1.fromPartial(object.orderRemove) : undefined; message.orderUpdate = object.orderUpdate !== undefined && object.orderUpdate !== null ? OrderUpdateV1.fromPartial(object.orderUpdate) : undefined; + message.orderReplace = object.orderReplace !== undefined && object.orderReplace !== null ? OrderReplaceV1.fromPartial(object.orderReplace) : undefined; return message; } diff --git a/proto/dydxprotocol/indexer/events/events.proto b/proto/dydxprotocol/indexer/events/events.proto index c8af386296..94412603f4 100644 --- a/proto/dydxprotocol/indexer/events/events.proto +++ b/proto/dydxprotocol/indexer/events/events.proto @@ -247,6 +247,7 @@ message StatefulOrderEventV1 { ConditionalOrderPlacementV1 conditional_order_placement = 5; ConditionalOrderTriggeredV1 conditional_order_triggered = 6; LongTermOrderPlacementV1 long_term_order_placement = 7; + LongTermOrderReplacementV1 order_replace = 8; } // A stateful order placement contains an order. @@ -277,6 +278,11 @@ message StatefulOrderEventV1 { message LongTermOrderPlacementV1 { dydxprotocol.indexer.protocol.v1.IndexerOrder order = 1; } + + // A long term order placement contains an order. + message LongTermOrderReplacementV1 { + dydxprotocol.indexer.protocol.v1.IndexerOrder order = 1; + } } // AssetCreateEventV1 message contains all the information about an new Asset on diff --git a/proto/dydxprotocol/indexer/off_chain_updates/off_chain_updates.proto b/proto/dydxprotocol/indexer/off_chain_updates/off_chain_updates.proto index 1e80bddc6d..aa0040e849 100644 --- a/proto/dydxprotocol/indexer/off_chain_updates/off_chain_updates.proto +++ b/proto/dydxprotocol/indexer/off_chain_updates/off_chain_updates.proto @@ -78,13 +78,25 @@ message OrderUpdateV1 { uint64 total_filled_quantums = 2; } +// OrderReplace messages contain the replacement order. +message OrderReplaceV1 { + dydxprotocol.indexer.protocol.v1.IndexerOrder order = 1; + dydxprotocol.indexer.off_chain_updates.OrderPlaceV1.OrderPlacementStatus + placement_status = 2; + + google.protobuf.Timestamp time_stamp = 3 + [ (gogoproto.nullable) = true, (gogoproto.stdtime) = true ]; +} + // An OffChainUpdate message is the message type which will be sent on Kafka to // the Indexer. message OffChainUpdateV1 { - // Contains one of an OrderPlaceV1, OrderRemoveV1, and OrderUpdateV1 message. + // Contains one of an OrderPlaceV1, OrderRemoveV1, OrderUpdateV1, and + // OrderReplaceV1 message. oneof update_message { OrderPlaceV1 order_place = 1; OrderRemoveV1 order_remove = 2; OrderUpdateV1 order_update = 3; + OrderReplaceV1 order_replace = 4; } } diff --git a/protocol/indexer/events/events.pb.go b/protocol/indexer/events/events.pb.go index 42758bacda..77ea141524 100644 --- a/protocol/indexer/events/events.pb.go +++ b/protocol/indexer/events/events.pb.go @@ -1128,6 +1128,7 @@ type StatefulOrderEventV1 struct { // *StatefulOrderEventV1_ConditionalOrderPlacement // *StatefulOrderEventV1_ConditionalOrderTriggered // *StatefulOrderEventV1_LongTermOrderPlacement + // *StatefulOrderEventV1_OrderReplace Event isStatefulOrderEventV1_Event `protobuf_oneof:"event"` } @@ -1185,12 +1186,16 @@ type StatefulOrderEventV1_ConditionalOrderTriggered struct { type StatefulOrderEventV1_LongTermOrderPlacement struct { LongTermOrderPlacement *StatefulOrderEventV1_LongTermOrderPlacementV1 `protobuf:"bytes,7,opt,name=long_term_order_placement,json=longTermOrderPlacement,proto3,oneof" json:"long_term_order_placement,omitempty"` } +type StatefulOrderEventV1_OrderReplace struct { + OrderReplace *StatefulOrderEventV1_LongTermOrderReplacementV1 `protobuf:"bytes,8,opt,name=order_replace,json=orderReplace,proto3,oneof" json:"order_replace,omitempty"` +} func (*StatefulOrderEventV1_OrderPlace) isStatefulOrderEventV1_Event() {} func (*StatefulOrderEventV1_OrderRemoval) isStatefulOrderEventV1_Event() {} func (*StatefulOrderEventV1_ConditionalOrderPlacement) isStatefulOrderEventV1_Event() {} func (*StatefulOrderEventV1_ConditionalOrderTriggered) isStatefulOrderEventV1_Event() {} func (*StatefulOrderEventV1_LongTermOrderPlacement) isStatefulOrderEventV1_Event() {} +func (*StatefulOrderEventV1_OrderReplace) isStatefulOrderEventV1_Event() {} func (m *StatefulOrderEventV1) GetEvent() isStatefulOrderEventV1_Event { if m != nil { @@ -1234,6 +1239,13 @@ func (m *StatefulOrderEventV1) GetLongTermOrderPlacement() *StatefulOrderEventV1 return nil } +func (m *StatefulOrderEventV1) GetOrderReplace() *StatefulOrderEventV1_LongTermOrderReplacementV1 { + if x, ok := m.GetEvent().(*StatefulOrderEventV1_OrderReplace); ok { + return x.OrderReplace + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*StatefulOrderEventV1) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -1242,6 +1254,7 @@ func (*StatefulOrderEventV1) XXX_OneofWrappers() []interface{} { (*StatefulOrderEventV1_ConditionalOrderPlacement)(nil), (*StatefulOrderEventV1_ConditionalOrderTriggered)(nil), (*StatefulOrderEventV1_LongTermOrderPlacement)(nil), + (*StatefulOrderEventV1_OrderReplace)(nil), } } @@ -1501,6 +1514,55 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacementV1) GetOrder() *types.Indexe return nil } +// A long term order placement contains an order. +type StatefulOrderEventV1_LongTermOrderReplacementV1 struct { + Order *types.IndexerOrder `protobuf:"bytes,1,opt,name=order,proto3" json:"order,omitempty"` +} + +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) Reset() { + *m = StatefulOrderEventV1_LongTermOrderReplacementV1{} +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) String() string { + return proto.CompactTextString(m) +} +func (*StatefulOrderEventV1_LongTermOrderReplacementV1) ProtoMessage() {} +func (*StatefulOrderEventV1_LongTermOrderReplacementV1) Descriptor() ([]byte, []int) { + return fileDescriptor_6331dfb59c6fd2bb, []int{13, 5} +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StatefulOrderEventV1_LongTermOrderReplacementV1.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) XXX_Merge(src proto.Message) { + xxx_messageInfo_StatefulOrderEventV1_LongTermOrderReplacementV1.Merge(m, src) +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) XXX_Size() int { + return m.Size() +} +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) XXX_DiscardUnknown() { + xxx_messageInfo_StatefulOrderEventV1_LongTermOrderReplacementV1.DiscardUnknown(m) +} + +var xxx_messageInfo_StatefulOrderEventV1_LongTermOrderReplacementV1 proto.InternalMessageInfo + +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) GetOrder() *types.IndexerOrder { + if m != nil { + return m.Order + } + return nil +} + // AssetCreateEventV1 message contains all the information about an new Asset on // the dYdX chain. type AssetCreateEventV1 struct { @@ -2485,6 +2547,7 @@ func init() { proto.RegisterType((*StatefulOrderEventV1_ConditionalOrderPlacementV1)(nil), "dydxprotocol.indexer.events.StatefulOrderEventV1.ConditionalOrderPlacementV1") proto.RegisterType((*StatefulOrderEventV1_ConditionalOrderTriggeredV1)(nil), "dydxprotocol.indexer.events.StatefulOrderEventV1.ConditionalOrderTriggeredV1") proto.RegisterType((*StatefulOrderEventV1_LongTermOrderPlacementV1)(nil), "dydxprotocol.indexer.events.StatefulOrderEventV1.LongTermOrderPlacementV1") + proto.RegisterType((*StatefulOrderEventV1_LongTermOrderReplacementV1)(nil), "dydxprotocol.indexer.events.StatefulOrderEventV1.LongTermOrderReplacementV1") proto.RegisterType((*AssetCreateEventV1)(nil), "dydxprotocol.indexer.events.AssetCreateEventV1") proto.RegisterType((*PerpetualMarketCreateEventV1)(nil), "dydxprotocol.indexer.events.PerpetualMarketCreateEventV1") proto.RegisterType((*PerpetualMarketCreateEventV2)(nil), "dydxprotocol.indexer.events.PerpetualMarketCreateEventV2") @@ -2503,6 +2566,7 @@ func init() { } var fileDescriptor_6331dfb59c6fd2bb = []byte{ +<<<<<<< HEAD // 2269 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x23, 0x49, 0x15, 0x4f, 0xdb, 0x1d, 0xc7, 0x79, 0x8e, 0x33, 0x76, 0x8d, 0x93, 0x71, 0x12, 0xc8, 0x0c, 0x2d, @@ -2646,6 +2710,154 @@ var fileDescriptor_6331dfb59c6fd2bb = []byte{ 0xe5, 0x5f, 0x2f, 0x56, 0x95, 0x9f, 0xbe, 0x5c, 0x9d, 0x7a, 0xfe, 0x72, 0x75, 0xea, 0x1f, 0x2f, 0x57, 0xa7, 0x1e, 0xbd, 0x3f, 0x79, 0xf0, 0x7a, 0x3f, 0x41, 0x9f, 0x66, 0x38, 0xe3, 0x1b, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xb0, 0xa3, 0x08, 0x2d, 0xa8, 0x1e, 0x00, 0x00, +======= + // 2305 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x23, 0x49, + 0x15, 0x8f, 0xed, 0x8e, 0xe3, 0x3c, 0xc7, 0x19, 0xa7, 0xc6, 0xc9, 0x38, 0x09, 0x64, 0x86, 0x96, + 0x90, 0x46, 0xb3, 0xbb, 0xce, 0x24, 0xec, 0xa2, 0xd5, 0x1e, 0x10, 0x71, 0x3e, 0x36, 0x8e, 0x92, + 0x8c, 0xb7, 0x93, 0xcc, 0xee, 0x0e, 0x68, 0x9b, 0x4a, 0x77, 0xd9, 0x29, 0xa5, 0xbf, 0xa6, 0xab, + 0x9d, 0x99, 0x8c, 0x84, 0xc4, 0x0d, 0x0e, 0x48, 0x20, 0x21, 0x0e, 0x1c, 0x90, 0xb8, 0xc0, 0x01, + 0x89, 0x03, 0x12, 0x57, 0x0e, 0x88, 0xcb, 0xde, 0x18, 0x71, 0x01, 0x71, 0x58, 0xa1, 0x99, 0x03, + 0xff, 0x05, 0x42, 0xf5, 0xd1, 0xed, 0x6f, 0x8f, 0x67, 0x92, 0x95, 0x10, 0xe2, 0x64, 0xd7, 0x7b, + 0xf5, 0x7e, 0xef, 0xd5, 0x7b, 0xaf, 0xaa, 0x5e, 0xbd, 0x86, 0xbb, 0xf6, 0xa5, 0xfd, 0x34, 0x08, + 0xfd, 0xc8, 0xb7, 0x7c, 0x67, 0x95, 0x7a, 0x36, 0x79, 0x4a, 0xc2, 0x55, 0x72, 0x41, 0xbc, 0x88, + 0xa9, 0x9f, 0x8a, 0x60, 0xa3, 0xe5, 0xce, 0x99, 0x15, 0x35, 0xb3, 0x22, 0xa7, 0x2c, 0x2d, 0x5a, + 0x3e, 0x73, 0x7d, 0x66, 0x0a, 0xfe, 0xaa, 0x1c, 0x48, 0xb9, 0xa5, 0x52, 0xd3, 0x6f, 0xfa, 0x92, + 0xce, 0xff, 0x29, 0xea, 0xfd, 0x81, 0x7a, 0xd9, 0x19, 0x0e, 0x89, 0xbd, 0x1a, 0x12, 0xd7, 0xbf, + 0xc0, 0x8e, 0x19, 0x12, 0xcc, 0x7c, 0x4f, 0x49, 0xbc, 0x35, 0x50, 0x22, 0x21, 0x5c, 0xac, 0xad, + 0x5a, 0x8e, 0x7f, 0x3a, 0x12, 0xbe, 0x73, 0x72, 0x40, 0xc2, 0x80, 0x44, 0x2d, 0xec, 0x28, 0x89, + 0xb5, 0x57, 0x4a, 0xb0, 0xd6, 0x29, 0xb6, 0x2c, 0xbf, 0xe5, 0x45, 0x52, 0x44, 0xff, 0x4b, 0x0a, + 0x6e, 0xec, 0xb4, 0x3c, 0x9b, 0x7a, 0xcd, 0x93, 0xc0, 0xc6, 0x11, 0x79, 0xb8, 0x86, 0xbe, 0x06, + 0x33, 0x09, 0xb2, 0x49, 0xed, 0x72, 0xea, 0x4e, 0xea, 0x6e, 0xc1, 0xc8, 0x27, 0xb4, 0x9a, 0x8d, + 0xee, 0xc1, 0x5c, 0x43, 0x4a, 0x99, 0x17, 0xd8, 0x69, 0x11, 0x33, 0x08, 0xdc, 0x72, 0xfa, 0x4e, + 0xea, 0xee, 0xa4, 0x71, 0x43, 0x31, 0x1e, 0x72, 0x7a, 0x3d, 0x70, 0x91, 0x0b, 0x85, 0x78, 0xae, + 0x30, 0xa9, 0x9c, 0xb9, 0x93, 0xba, 0x3b, 0x53, 0xdd, 0xfd, 0xfc, 0x8b, 0xdb, 0x13, 0xff, 0xf8, + 0xe2, 0xf6, 0xb7, 0x9b, 0x34, 0x3a, 0x6b, 0x9d, 0x56, 0x2c, 0xdf, 0x5d, 0xed, 0xb2, 0xff, 0xe2, + 0xdd, 0x77, 0xac, 0x33, 0x4c, 0xbd, 0xf6, 0x02, 0xec, 0xe8, 0x32, 0x20, 0xac, 0x72, 0x44, 0x42, + 0x8a, 0x1d, 0xfa, 0x0c, 0x9f, 0x3a, 0xa4, 0xe6, 0x45, 0xc6, 0x8c, 0x82, 0xaf, 0x71, 0x74, 0xfd, + 0x67, 0x69, 0x98, 0x55, 0x2b, 0xda, 0xe6, 0x81, 0x7d, 0xb8, 0x86, 0xf6, 0x61, 0xaa, 0x25, 0x16, + 0xc7, 0xca, 0xa9, 0x3b, 0x99, 0xbb, 0xf9, 0xf5, 0xb7, 0x2b, 0x23, 0x12, 0xa1, 0xd2, 0xe3, 0x8f, + 0xaa, 0xc6, 0x2d, 0x35, 0x62, 0x08, 0xb4, 0x05, 0x1a, 0xb7, 0x43, 0x2c, 0x77, 0x76, 0xfd, 0xfe, + 0x38, 0x50, 0xca, 0x90, 0xca, 0xf1, 0x65, 0x40, 0x0c, 0x21, 0xad, 0xbb, 0xa0, 0xf1, 0x11, 0x2a, + 0x41, 0xf1, 0xf8, 0xd3, 0xfa, 0xb6, 0x79, 0x72, 0x78, 0x54, 0xdf, 0xde, 0xac, 0xed, 0xd4, 0xb6, + 0xb7, 0x8a, 0x13, 0xe8, 0x16, 0xdc, 0x14, 0xd4, 0xba, 0xb1, 0x7d, 0x50, 0x3b, 0x39, 0x30, 0x8f, + 0x36, 0x0e, 0xea, 0xfb, 0xdb, 0xc5, 0x14, 0xba, 0x0d, 0xcb, 0x82, 0xb1, 0x73, 0x72, 0xb8, 0x55, + 0x3b, 0xfc, 0xd0, 0x34, 0x36, 0x8e, 0xb7, 0xcd, 0x8d, 0xc3, 0x2d, 0xb3, 0x76, 0xb8, 0xb5, 0xfd, + 0x49, 0x31, 0x8d, 0xe6, 0x61, 0xae, 0x4b, 0xf2, 0xe1, 0x83, 0xe3, 0xed, 0x62, 0x46, 0xff, 0x73, + 0x1a, 0x0a, 0x07, 0x38, 0x3c, 0x27, 0x51, 0xec, 0x94, 0x65, 0x98, 0x76, 0x05, 0xa1, 0x1d, 0xe2, + 0x9c, 0x24, 0xd4, 0x6c, 0xf4, 0x08, 0x66, 0x82, 0x90, 0x5a, 0xc4, 0x94, 0x8b, 0x16, 0x6b, 0xcd, + 0xaf, 0xbf, 0x37, 0x72, 0xad, 0x12, 0xbe, 0xce, 0xc5, 0xa4, 0xeb, 0x94, 0xa6, 0xdd, 0x09, 0x23, + 0x1f, 0xb4, 0xa9, 0xe8, 0x63, 0x28, 0x28, 0xc5, 0x56, 0x48, 0x38, 0x78, 0x46, 0x80, 0xdf, 0x1f, + 0x03, 0x7c, 0x53, 0x08, 0xb4, 0x71, 0x67, 0xdc, 0x0e, 0x72, 0x07, 0xb0, 0xeb, 0xdb, 0xb4, 0x71, + 0x59, 0xd6, 0xc6, 0x06, 0x3e, 0x10, 0x02, 0x7d, 0xc0, 0x92, 0x5c, 0x9d, 0x82, 0x49, 0x31, 0x5b, + 0xdf, 0x83, 0xf2, 0xb0, 0x55, 0xa2, 0x0a, 0xdc, 0x94, 0x2e, 0x7b, 0x42, 0xa3, 0x33, 0x93, 0x3c, + 0x0d, 0x7c, 0x8f, 0x78, 0x91, 0xf0, 0xac, 0x66, 0xcc, 0x09, 0xd6, 0xc7, 0x34, 0x3a, 0xdb, 0x56, + 0x0c, 0xfd, 0x13, 0x98, 0x93, 0x58, 0x55, 0xcc, 0x12, 0x10, 0x04, 0x5a, 0x80, 0x69, 0x28, 0xa4, + 0xa6, 0x0d, 0xf1, 0x1f, 0xad, 0x42, 0xc9, 0xa5, 0x9e, 0x29, 0xc1, 0xad, 0x33, 0xec, 0x35, 0xdb, + 0xdb, 0xad, 0x60, 0xcc, 0xb9, 0xd4, 0x13, 0xd6, 0x6c, 0x0a, 0x4e, 0x3d, 0x70, 0xf5, 0x16, 0xdc, + 0x1c, 0xe0, 0x2e, 0x54, 0x05, 0xed, 0x14, 0x33, 0x22, 0xb0, 0xf3, 0xeb, 0x95, 0x31, 0xbc, 0xd2, + 0x61, 0x99, 0x21, 0x64, 0xd1, 0x12, 0xe4, 0x92, 0x95, 0x71, 0xfd, 0x73, 0x46, 0x32, 0xd6, 0x3f, + 0x8d, 0xd5, 0x76, 0x39, 0xf3, 0x3a, 0xd4, 0xea, 0xbf, 0x4b, 0x41, 0xe1, 0xc8, 0x6f, 0x85, 0x16, + 0x79, 0xd0, 0xe0, 0x5b, 0x8a, 0xa1, 0xef, 0x42, 0xa1, 0x7d, 0x96, 0xc5, 0x19, 0x3c, 0x34, 0x43, + 0x13, 0xc2, 0xc5, 0x5a, 0xa5, 0x26, 0x69, 0x47, 0x89, 0x74, 0xcd, 0xe6, 0x01, 0x67, 0x1d, 0x63, + 0xf4, 0x2e, 0x4c, 0x61, 0xdb, 0x0e, 0x09, 0x63, 0x62, 0x95, 0xd3, 0xd5, 0xf2, 0x5f, 0xff, 0xf0, + 0x4e, 0x49, 0x5d, 0x09, 0x1b, 0x92, 0x73, 0x14, 0x85, 0xd4, 0x6b, 0xee, 0x4e, 0x18, 0xf1, 0xd4, + 0x6a, 0x0e, 0xb2, 0x4c, 0x18, 0xa9, 0xff, 0x36, 0x03, 0x37, 0x8e, 0x43, 0xec, 0xb1, 0x06, 0x09, + 0x63, 0x3f, 0x34, 0xa1, 0xc4, 0x88, 0x67, 0x93, 0xd0, 0xbc, 0x3e, 0xc3, 0x0d, 0x24, 0x21, 0x3b, + 0x69, 0xc8, 0x85, 0x5b, 0x21, 0xb1, 0x68, 0x40, 0x89, 0x17, 0xf5, 0xe8, 0x4a, 0x5f, 0x45, 0xd7, + 0x7c, 0x82, 0xda, 0xa5, 0x6e, 0x11, 0x72, 0x98, 0x31, 0x79, 0x8c, 0x64, 0x44, 0x4a, 0x4e, 0x89, + 0x71, 0xcd, 0x46, 0x0b, 0x90, 0xc5, 0x2e, 0x9f, 0x26, 0x76, 0xa2, 0x66, 0xa8, 0x11, 0xaa, 0x42, + 0x56, 0xda, 0x5d, 0x9e, 0x14, 0x06, 0xdd, 0x1b, 0x99, 0x14, 0x5d, 0x81, 0x37, 0x94, 0x24, 0xda, + 0x85, 0xe9, 0xc4, 0x9e, 0x72, 0xf6, 0xb5, 0x61, 0xda, 0xc2, 0xfa, 0xdf, 0x32, 0x50, 0x7c, 0x10, + 0xda, 0x24, 0xdc, 0xa1, 0x8e, 0x13, 0x47, 0xeb, 0x04, 0xf2, 0x2e, 0x3e, 0x27, 0xa1, 0xe9, 0x73, + 0xce, 0xe8, 0xe4, 0x1d, 0xe0, 0x38, 0x81, 0xa7, 0x2e, 0x0e, 0x10, 0x40, 0x82, 0x82, 0x76, 0x60, + 0x52, 0x02, 0xa6, 0xdf, 0x04, 0x70, 0x77, 0xc2, 0x90, 0xe2, 0xe8, 0x33, 0x98, 0x73, 0xe8, 0xe3, + 0x16, 0xb5, 0x71, 0x44, 0x7d, 0x4f, 0x19, 0x29, 0x8f, 0xbb, 0xd5, 0x91, 0x5e, 0xd8, 0x6f, 0x4b, + 0x09, 0x48, 0x71, 0xda, 0x15, 0x9d, 0x1e, 0x2a, 0xba, 0x0d, 0xf9, 0x06, 0x75, 0x1c, 0x53, 0x85, + 0x2f, 0x23, 0xc2, 0x07, 0x9c, 0xb4, 0x21, 0x43, 0x28, 0x6e, 0x0f, 0xee, 0x9f, 0x06, 0x21, 0x22, + 0x8a, 0x88, 0xdf, 0x1e, 0xe7, 0x24, 0xdc, 0x21, 0x84, 0x33, 0xa3, 0x84, 0x99, 0x95, 0xcc, 0x28, + 0x66, 0xbe, 0x0d, 0x28, 0xf2, 0x23, 0xec, 0x98, 0x1c, 0x8d, 0xd8, 0xa6, 0x90, 0x2a, 0x4f, 0x09, + 0x0d, 0x45, 0xc1, 0xd9, 0x11, 0x8c, 0x03, 0x4e, 0xef, 0x9b, 0x2d, 0x60, 0xca, 0xb9, 0xbe, 0xd9, + 0xc7, 0x9c, 0x5e, 0x2d, 0x40, 0x3e, 0x6a, 0x47, 0x4d, 0xff, 0x71, 0x06, 0x6e, 0x6e, 0x11, 0x87, + 0x5c, 0x90, 0x10, 0x37, 0x3b, 0xea, 0x81, 0xef, 0x00, 0xc4, 0x2b, 0x26, 0x57, 0xdb, 0x80, 0x71, + 0x88, 0xdb, 0x70, 0x1c, 0xdc, 0x6f, 0x34, 0x18, 0x89, 0x22, 0xea, 0x35, 0xaf, 0xb4, 0xe3, 0x62, + 0xf0, 0x36, 0x5c, 0x5f, 0x69, 0x96, 0xe9, 0x2f, 0xcd, 0x7a, 0x42, 0xa7, 0xf5, 0x85, 0xee, 0x3e, + 0x94, 0xa4, 0x4b, 0x1f, 0xb7, 0xfc, 0x88, 0x98, 0x8f, 0x5b, 0xd8, 0x8b, 0x5a, 0x2e, 0x13, 0x51, + 0xd4, 0x0c, 0xe9, 0xee, 0x8f, 0x38, 0xeb, 0x23, 0xc5, 0x41, 0xf3, 0x90, 0xa5, 0xcc, 0x3c, 0x6d, + 0x5d, 0x8a, 0x60, 0xe6, 0x8c, 0x49, 0xca, 0xaa, 0xad, 0x4b, 0x7e, 0xe3, 0x51, 0x66, 0x36, 0xa8, + 0x87, 0x1d, 0x93, 0x1b, 0xe8, 0x10, 0x97, 0x6f, 0xc6, 0x29, 0x31, 0x67, 0x8e, 0xb2, 0x1d, 0xce, + 0x39, 0x4a, 0x18, 0xfa, 0x8f, 0xd2, 0x80, 0xfa, 0xf3, 0xef, 0xcb, 0x8d, 0xc6, 0x1d, 0x98, 0xe1, + 0x25, 0xb5, 0xc9, 0x6f, 0xd2, 0xf8, 0x04, 0x2c, 0x18, 0xc0, 0x69, 0x75, 0x4c, 0xc3, 0x9a, 0x3d, + 0x8e, 0x4b, 0xbf, 0x0a, 0x20, 0x3d, 0xc6, 0xe8, 0x33, 0xa2, 0x3c, 0x3a, 0x2d, 0x28, 0x47, 0xf4, + 0x19, 0xe9, 0x70, 0xcf, 0x64, 0xa7, 0x7b, 0x96, 0x20, 0xc7, 0x5a, 0xa7, 0x11, 0xb5, 0xce, 0x99, + 0xf0, 0x9b, 0x66, 0x24, 0x63, 0xfd, 0x5f, 0x69, 0xb8, 0xd5, 0xb6, 0xbc, 0xbb, 0x90, 0x78, 0x74, + 0x9d, 0x57, 0x5b, 0xcf, 0xc5, 0xf6, 0x0c, 0x96, 0x65, 0x45, 0x67, 0x9b, 0xed, 0x45, 0x07, 0x3e, + 0xa3, 0x3c, 0x20, 0xac, 0x9c, 0x11, 0xd5, 0xf1, 0x07, 0x63, 0x6b, 0xaa, 0xc7, 0x18, 0x75, 0x05, + 0x61, 0x2c, 0x2a, 0xf8, 0x3e, 0x0e, 0x43, 0x1e, 0xdc, 0x8a, 0x75, 0xcb, 0x0b, 0xa3, 0xad, 0x57, + 0x13, 0x7a, 0xbf, 0x39, 0xb6, 0xde, 0x0d, 0x2e, 0x9f, 0xe8, 0x9c, 0x57, 0xb0, 0x5d, 0x54, 0xb6, + 0xa7, 0xe5, 0xd2, 0xc5, 0x8c, 0xfe, 0xef, 0x3c, 0x94, 0x8e, 0x22, 0x1c, 0x91, 0x46, 0xcb, 0x11, + 0x19, 0x17, 0xbb, 0xf9, 0x31, 0xe4, 0xc5, 0x29, 0x61, 0x06, 0x0e, 0xb6, 0xe2, 0xf2, 0x64, 0x6f, + 0xf4, 0x15, 0x32, 0x00, 0xa7, 0x9b, 0x58, 0xe7, 0x58, 0xae, 0x60, 0x54, 0xd3, 0xe5, 0xd4, 0x2e, + 0xdf, 0xbd, 0x09, 0x1d, 0xf9, 0x50, 0x90, 0x2a, 0xd5, 0xe3, 0x50, 0x9d, 0xd8, 0xbb, 0x57, 0x54, + 0x6a, 0x48, 0x34, 0x59, 0xb8, 0xfa, 0x1d, 0x14, 0xf4, 0x93, 0x14, 0x2c, 0x5b, 0xbe, 0x67, 0x0b, + 0x8f, 0x60, 0xc7, 0xec, 0x58, 0xb0, 0xd8, 0xaa, 0xf2, 0xfa, 0x3d, 0x78, 0x7d, 0xfd, 0x9b, 0x6d, + 0xd0, 0xde, 0x75, 0xef, 0x4e, 0x18, 0x8b, 0xd6, 0x30, 0xf6, 0x10, 0x8b, 0xa2, 0x90, 0x36, 0x9b, + 0x24, 0x24, 0xb6, 0xba, 0xc9, 0xaf, 0xc1, 0xa2, 0xe3, 0x18, 0x72, 0xb0, 0x45, 0x09, 0x1b, 0xfd, + 0x30, 0x05, 0x8b, 0x8e, 0xef, 0x35, 0xcd, 0x88, 0x84, 0x6e, 0x9f, 0x87, 0xa6, 0xde, 0x34, 0x2d, + 0xf6, 0x7d, 0xaf, 0x79, 0x4c, 0x42, 0x77, 0x80, 0x7b, 0x16, 0x9c, 0x81, 0x3c, 0xc4, 0xda, 0xe9, + 0x21, 0x73, 0x32, 0x27, 0x94, 0xef, 0x5f, 0x51, 0xb9, 0x41, 0x82, 0x2e, 0xf5, 0x71, 0x8a, 0x08, + 0xea, 0xd2, 0xf7, 0xa0, 0x3c, 0x2c, 0x83, 0xd1, 0x56, 0x5c, 0xad, 0xbc, 0x51, 0xf9, 0xa3, 0x6a, + 0x95, 0xa5, 0x3f, 0xa6, 0x60, 0x61, 0x70, 0xbe, 0xa2, 0x47, 0x50, 0x14, 0x5b, 0x81, 0xd8, 0xca, + 0xf1, 0xc9, 0x69, 0x77, 0xff, 0xf5, 0x74, 0xd5, 0x6c, 0x63, 0x56, 0x21, 0xa9, 0x31, 0xfa, 0x10, + 0xb2, 0xb2, 0xf7, 0xa2, 0x1e, 0xea, 0x43, 0xea, 0x22, 0xd9, 0xae, 0xa9, 0x74, 0x1a, 0x66, 0x08, + 0x31, 0x43, 0x89, 0x2f, 0x59, 0xb0, 0x3c, 0x22, 0xdd, 0xaf, 0xc9, 0x49, 0xdf, 0xef, 0x57, 0xd2, + 0x91, 0xc1, 0xe8, 0x33, 0x40, 0xc9, 0x1e, 0xb9, 0xba, 0xab, 0x8a, 0x09, 0x96, 0xa2, 0xf0, 0x2c, + 0x18, 0x96, 0xb0, 0xd7, 0xb4, 0xc0, 0x53, 0x58, 0x1a, 0x9e, 0x95, 0xd7, 0xa3, 0x23, 0x79, 0xa7, + 0xcb, 0xa3, 0x7f, 0x4f, 0xcb, 0x65, 0x8a, 0x9a, 0xfe, 0xeb, 0x14, 0x20, 0x71, 0x33, 0x74, 0xbf, + 0x86, 0x67, 0x21, 0x9d, 0xf4, 0x3d, 0xd2, 0x54, 0xbc, 0x55, 0xd8, 0xa5, 0x7b, 0xea, 0x3b, 0xf2, + 0xc5, 0x67, 0xa8, 0x11, 0xbf, 0xfb, 0xcf, 0x30, 0x33, 0x65, 0x3f, 0x40, 0x14, 0x07, 0x39, 0x63, + 0xfa, 0x0c, 0x33, 0xf9, 0x54, 0xed, 0xee, 0xa2, 0x68, 0x3d, 0x5d, 0x94, 0xb7, 0x60, 0x0e, 0x47, + 0xbe, 0x4b, 0x2d, 0x33, 0x24, 0xcc, 0x77, 0x5a, 0x3c, 0xb8, 0xe2, 0xcc, 0x9d, 0x33, 0x8a, 0x92, + 0x61, 0x24, 0x74, 0xfd, 0x4f, 0x19, 0xf8, 0x4a, 0x72, 0x6b, 0x0e, 0x7a, 0xbf, 0xf7, 0x5a, 0xfc, + 0xea, 0xd2, 0x66, 0x01, 0xb2, 0xbc, 0xdc, 0x20, 0xa1, 0xb0, 0x7b, 0xda, 0x50, 0xa3, 0xd1, 0x46, + 0xef, 0x42, 0x96, 0x45, 0x38, 0x6a, 0xc9, 0x82, 0x70, 0x76, 0x9c, 0xf4, 0xda, 0x54, 0x2a, 0x8f, + 0x84, 0x9c, 0xa1, 0xe4, 0xd1, 0xb7, 0x60, 0x59, 0x15, 0x97, 0xa6, 0xe5, 0x7b, 0x17, 0x24, 0x64, + 0xfc, 0xad, 0x92, 0xf4, 0x0f, 0xb2, 0xc2, 0x11, 0x8b, 0x6a, 0xca, 0x66, 0x32, 0x23, 0xee, 0x90, + 0x0c, 0x76, 0xdf, 0xd4, 0x60, 0xf7, 0xa1, 0x7b, 0x30, 0x17, 0x57, 0x57, 0xbc, 0xb4, 0x31, 0xf9, + 0x3f, 0x71, 0x80, 0x16, 0x8c, 0x1b, 0x31, 0xa3, 0x4e, 0xc2, 0x63, 0x6a, 0x9d, 0xf3, 0x47, 0x05, + 0x8b, 0x48, 0x60, 0x9e, 0x62, 0xd6, 0x51, 0xff, 0x4e, 0xcb, 0x47, 0x05, 0xe7, 0x54, 0x31, 0x6b, + 0x57, 0xbf, 0x5f, 0x87, 0x59, 0x59, 0x50, 0xd2, 0xe8, 0xd2, 0x8c, 0x28, 0x09, 0xcb, 0x20, 0x60, + 0x0b, 0x09, 0xf5, 0x98, 0x92, 0xf0, 0x83, 0x74, 0x39, 0xa5, 0xff, 0x5c, 0x1b, 0x19, 0xc3, 0xf5, + 0xff, 0xc7, 0xf0, 0xbf, 0x3a, 0x86, 0xe8, 0x21, 0x7f, 0xf5, 0x0b, 0xa7, 0x8a, 0x0e, 0x6f, 0x5e, + 0x38, 0x6f, 0x8c, 0xc2, 0xbb, 0x27, 0xe6, 0xa2, 0xcd, 0x0b, 0x6e, 0xf2, 0x5f, 0xff, 0x55, 0x1a, + 0x96, 0xf6, 0x3b, 0x35, 0x9d, 0x04, 0x8c, 0x84, 0xd1, 0xb0, 0x9d, 0x8d, 0x40, 0xf3, 0xb0, 0x4b, + 0xd4, 0x49, 0x24, 0xfe, 0xf3, 0xf5, 0x52, 0x8f, 0x46, 0x14, 0x3b, 0xfc, 0x2c, 0x6a, 0x52, 0x4f, + 0xf4, 0x00, 0xe5, 0x63, 0xa5, 0xa8, 0x38, 0x07, 0x82, 0x51, 0x0f, 0x5c, 0xf4, 0x3e, 0x94, 0x5d, + 0x4c, 0xbd, 0x88, 0x78, 0xd8, 0xb3, 0x88, 0xd9, 0x08, 0xb1, 0x25, 0x1a, 0x05, 0x5c, 0x46, 0x26, + 0xcb, 0x42, 0x07, 0x7f, 0x47, 0xb1, 0xa5, 0xe4, 0x82, 0x70, 0x69, 0x5c, 0x9c, 0x9b, 0x9e, 0x2f, + 0xef, 0x24, 0xf9, 0x3e, 0xe4, 0x55, 0xad, 0x51, 0xe2, 0x33, 0xe2, 0x42, 0xfb, 0x50, 0xf1, 0xf7, + 0xb4, 0x5c, 0xb6, 0x38, 0xb5, 0xa7, 0xe5, 0xa6, 0x8a, 0x39, 0xe3, 0x96, 0x1f, 0x10, 0xcf, 0xe4, + 0x0a, 0x42, 0xc2, 0x22, 0xd3, 0xf1, 0x9f, 0x90, 0xd0, 0xb4, 0x70, 0xd0, 0xcb, 0x68, 0x05, 0x81, + 0x64, 0xe8, 0xbf, 0x4c, 0xc3, 0xbc, 0x7c, 0x07, 0xc5, 0x99, 0x18, 0x7b, 0xa7, 0x77, 0x8f, 0xa4, + 0xfa, 0xf6, 0x48, 0x3b, 0xdd, 0xd3, 0x5f, 0x6e, 0xba, 0x67, 0x5e, 0x95, 0xee, 0x03, 0x33, 0x58, + 0x7b, 0x9d, 0x0c, 0x9e, 0x1c, 0x9c, 0xc1, 0xfa, 0xef, 0x53, 0xb0, 0x20, 0xfd, 0x93, 0x24, 0xdb, + 0x88, 0xab, 0x4c, 0x1d, 0x19, 0xe9, 0xe1, 0x47, 0x46, 0x66, 0x9c, 0xbb, 0x4a, 0x1b, 0xb2, 0x51, + 0xfb, 0xb7, 0xd3, 0xe4, 0x80, 0xed, 0xa4, 0x33, 0x98, 0x3f, 0x0e, 0xb1, 0x4d, 0xbd, 0xa6, 0x41, + 0x9e, 0xe0, 0xd0, 0x66, 0xed, 0x27, 0xee, 0x8d, 0x48, 0x32, 0xcc, 0x50, 0x72, 0xd4, 0x87, 0x99, + 0xb5, 0x91, 0xb5, 0xae, 0xea, 0xbc, 0x76, 0x61, 0x1a, 0xb3, 0x51, 0x97, 0x0a, 0xfd, 0x17, 0x29, + 0x28, 0x0d, 0x9a, 0x88, 0x4a, 0x30, 0xe9, 0x3f, 0xf1, 0x48, 0xdc, 0x5c, 0x97, 0x03, 0x74, 0x0e, + 0x33, 0x36, 0xf1, 0x7c, 0x37, 0xee, 0x97, 0xa4, 0xaf, 0xf9, 0xe3, 0x54, 0x5e, 0xa0, 0xcb, 0xd6, + 0x8b, 0xfe, 0x83, 0x14, 0x2c, 0x3e, 0x08, 0x88, 0x57, 0x53, 0xf9, 0xdf, 0xfd, 0xf0, 0xb7, 0x60, + 0xbe, 0x77, 0x77, 0x74, 0x7e, 0xb4, 0x1a, 0xdd, 0xd8, 0xeb, 0x87, 0x35, 0x6e, 0xfa, 0x7d, 0x34, + 0xa6, 0xff, 0x26, 0x05, 0xa8, 0x7f, 0xee, 0x38, 0xdf, 0xfc, 0x5c, 0x28, 0x74, 0x99, 0x77, 0xed, + 0xae, 0x9a, 0xe9, 0xb4, 0x57, 0x7f, 0x3e, 0xea, 0xcc, 0x5c, 0xff, 0xdf, 0x38, 0x33, 0xd1, 0x7b, + 0x30, 0xec, 0xa4, 0x54, 0x2d, 0xa3, 0x52, 0xa7, 0x4f, 0xf6, 0x39, 0x73, 0x13, 0x07, 0xfd, 0x62, + 0xc9, 0x39, 0xaa, 0x1a, 0xa9, 0xa5, 0xee, 0xd0, 0x07, 0x42, 0xac, 0x6a, 0x7c, 0xfe, 0x62, 0x25, + 0xf5, 0xfc, 0xc5, 0x4a, 0xea, 0x9f, 0x2f, 0x56, 0x52, 0x3f, 0x7d, 0xb9, 0x32, 0xf1, 0xfc, 0xe5, + 0xca, 0xc4, 0xdf, 0x5f, 0xae, 0x4c, 0x3c, 0x7a, 0x7f, 0xfc, 0xe0, 0x75, 0x7f, 0x5f, 0x3f, 0xcd, + 0x0a, 0xc6, 0x37, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x9d, 0x34, 0x4e, 0xed, 0x85, 0x1f, 0x00, + 0x00, +>>>>>>> 722ec245 ([CT-853] Generate order replacement protos (#1551)) } func (m *FundingUpdateV1) Marshal() (dAtA []byte, err error) { @@ -3569,6 +3781,27 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacement) MarshalToSizedBuffer(dAtA } return len(dAtA) - i, nil } +func (m *StatefulOrderEventV1_OrderReplace) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatefulOrderEventV1_OrderReplace) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.OrderReplace != nil { + { + size, err := m.OrderReplace.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + return len(dAtA) - i, nil +} func (m *StatefulOrderEventV1_StatefulOrderPlacementV1) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3749,6 +3982,41 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacementV1) MarshalToSizedBuffer(dAt return len(dAtA) - i, nil } +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) 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 *StatefulOrderEventV1_LongTermOrderReplacementV1) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Order != nil { + { + size, err := m.Order.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *AssetCreateEventV1) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4742,6 +5010,18 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacement) Size() (n int) { } return n } +func (m *StatefulOrderEventV1_OrderReplace) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OrderReplace != nil { + l = m.OrderReplace.Size() + n += 1 + l + sovEvents(uint64(l)) + } + return n +} func (m *StatefulOrderEventV1_StatefulOrderPlacementV1) Size() (n int) { if m == nil { return 0 @@ -4810,6 +5090,19 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacementV1) Size() (n int) { return n } +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Order != nil { + l = m.Order.Size() + n += 1 + l + sovEvents(uint64(l)) + } + return n +} + func (m *AssetCreateEventV1) Size() (n int) { if m == nil { return 0 @@ -7200,6 +7493,41 @@ func (m *StatefulOrderEventV1) Unmarshal(dAtA []byte) error { } m.Event = &StatefulOrderEventV1_LongTermOrderPlacement{v} iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderReplace", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &StatefulOrderEventV1_LongTermOrderReplacementV1{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Event = &StatefulOrderEventV1_OrderReplace{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -7670,6 +7998,92 @@ func (m *StatefulOrderEventV1_LongTermOrderPlacementV1) Unmarshal(dAtA []byte) e } return nil } +func (m *StatefulOrderEventV1_LongTermOrderReplacementV1) 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 ErrIntOverflowEvents + } + 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: LongTermOrderReplacementV1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LongTermOrderReplacementV1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Order == nil { + m.Order = &types.IndexerOrder{} + } + if err := m.Order.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *AssetCreateEventV1) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/protocol/indexer/off_chain_updates/types/off_chain_updates.pb.go b/protocol/indexer/off_chain_updates/types/off_chain_updates.pb.go index b2dddf6dd2..48424430ae 100644 --- a/protocol/indexer/off_chain_updates/types/off_chain_updates.pb.go +++ b/protocol/indexer/off_chain_updates/types/off_chain_updates.pb.go @@ -287,15 +287,79 @@ func (m *OrderUpdateV1) GetTotalFilledQuantums() uint64 { return 0 } +// OrderReplace messages contain the replacement order. +type OrderReplaceV1 struct { + Order *types.IndexerOrder `protobuf:"bytes,1,opt,name=order,proto3" json:"order,omitempty"` + PlacementStatus OrderPlaceV1_OrderPlacementStatus `protobuf:"varint,2,opt,name=placement_status,json=placementStatus,proto3,enum=dydxprotocol.indexer.off_chain_updates.OrderPlaceV1_OrderPlacementStatus" json:"placement_status,omitempty"` + TimeStamp *time.Time `protobuf:"bytes,3,opt,name=time_stamp,json=timeStamp,proto3,stdtime" json:"time_stamp,omitempty"` +} + +func (m *OrderReplaceV1) Reset() { *m = OrderReplaceV1{} } +func (m *OrderReplaceV1) String() string { return proto.CompactTextString(m) } +func (*OrderReplaceV1) ProtoMessage() {} +func (*OrderReplaceV1) Descriptor() ([]byte, []int) { + return fileDescriptor_a3058c1b66f59e98, []int{3} +} +func (m *OrderReplaceV1) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OrderReplaceV1) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OrderReplaceV1.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *OrderReplaceV1) XXX_Merge(src proto.Message) { + xxx_messageInfo_OrderReplaceV1.Merge(m, src) +} +func (m *OrderReplaceV1) XXX_Size() int { + return m.Size() +} +func (m *OrderReplaceV1) XXX_DiscardUnknown() { + xxx_messageInfo_OrderReplaceV1.DiscardUnknown(m) +} + +var xxx_messageInfo_OrderReplaceV1 proto.InternalMessageInfo + +func (m *OrderReplaceV1) GetOrder() *types.IndexerOrder { + if m != nil { + return m.Order + } + return nil +} + +func (m *OrderReplaceV1) GetPlacementStatus() OrderPlaceV1_OrderPlacementStatus { + if m != nil { + return m.PlacementStatus + } + return OrderPlaceV1_ORDER_PLACEMENT_STATUS_UNSPECIFIED +} + +func (m *OrderReplaceV1) GetTimeStamp() *time.Time { + if m != nil { + return m.TimeStamp + } + return nil +} + // An OffChainUpdate message is the message type which will be sent on Kafka to // the Indexer. type OffChainUpdateV1 struct { - // Contains one of an OrderPlaceV1, OrderRemoveV1, and OrderUpdateV1 message. + // Contains one of an OrderPlaceV1, OrderRemoveV1, OrderUpdateV1, and + // OrderReplaceV1 message. // // Types that are valid to be assigned to UpdateMessage: + // // *OffChainUpdateV1_OrderPlace // *OffChainUpdateV1_OrderRemove // *OffChainUpdateV1_OrderUpdate + // *OffChainUpdateV1_OrderReplace UpdateMessage isOffChainUpdateV1_UpdateMessage `protobuf_oneof:"update_message"` } @@ -303,7 +367,7 @@ func (m *OffChainUpdateV1) Reset() { *m = OffChainUpdateV1{} } func (m *OffChainUpdateV1) String() string { return proto.CompactTextString(m) } func (*OffChainUpdateV1) ProtoMessage() {} func (*OffChainUpdateV1) Descriptor() ([]byte, []int) { - return fileDescriptor_a3058c1b66f59e98, []int{3} + return fileDescriptor_a3058c1b66f59e98, []int{4} } func (m *OffChainUpdateV1) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -347,10 +411,14 @@ type OffChainUpdateV1_OrderRemove struct { type OffChainUpdateV1_OrderUpdate struct { OrderUpdate *OrderUpdateV1 `protobuf:"bytes,3,opt,name=order_update,json=orderUpdate,proto3,oneof" json:"order_update,omitempty"` } +type OffChainUpdateV1_OrderReplace struct { + OrderReplace *OrderReplaceV1 `protobuf:"bytes,4,opt,name=order_replace,json=orderReplace,proto3,oneof" json:"order_replace,omitempty"` +} -func (*OffChainUpdateV1_OrderPlace) isOffChainUpdateV1_UpdateMessage() {} -func (*OffChainUpdateV1_OrderRemove) isOffChainUpdateV1_UpdateMessage() {} -func (*OffChainUpdateV1_OrderUpdate) isOffChainUpdateV1_UpdateMessage() {} +func (*OffChainUpdateV1_OrderPlace) isOffChainUpdateV1_UpdateMessage() {} +func (*OffChainUpdateV1_OrderRemove) isOffChainUpdateV1_UpdateMessage() {} +func (*OffChainUpdateV1_OrderUpdate) isOffChainUpdateV1_UpdateMessage() {} +func (*OffChainUpdateV1_OrderReplace) isOffChainUpdateV1_UpdateMessage() {} func (m *OffChainUpdateV1) GetUpdateMessage() isOffChainUpdateV1_UpdateMessage { if m != nil { @@ -380,12 +448,20 @@ func (m *OffChainUpdateV1) GetOrderUpdate() *OrderUpdateV1 { return nil } +func (m *OffChainUpdateV1) GetOrderReplace() *OrderReplaceV1 { + if x, ok := m.GetUpdateMessage().(*OffChainUpdateV1_OrderReplace); ok { + return x.OrderReplace + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*OffChainUpdateV1) XXX_OneofWrappers() []interface{} { return []interface{}{ (*OffChainUpdateV1_OrderPlace)(nil), (*OffChainUpdateV1_OrderRemove)(nil), (*OffChainUpdateV1_OrderUpdate)(nil), + (*OffChainUpdateV1_OrderReplace)(nil), } } @@ -395,6 +471,7 @@ func init() { proto.RegisterType((*OrderPlaceV1)(nil), "dydxprotocol.indexer.off_chain_updates.OrderPlaceV1") proto.RegisterType((*OrderRemoveV1)(nil), "dydxprotocol.indexer.off_chain_updates.OrderRemoveV1") proto.RegisterType((*OrderUpdateV1)(nil), "dydxprotocol.indexer.off_chain_updates.OrderUpdateV1") + proto.RegisterType((*OrderReplaceV1)(nil), "dydxprotocol.indexer.off_chain_updates.OrderReplaceV1") proto.RegisterType((*OffChainUpdateV1)(nil), "dydxprotocol.indexer.off_chain_updates.OffChainUpdateV1") } @@ -403,6 +480,7 @@ func init() { } var fileDescriptor_a3058c1b66f59e98 = []byte{ +<<<<<<< HEAD // 626 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xc1, 0x6e, 0xda, 0x4a, 0x14, 0xb5, 0xc9, 0x7b, 0x69, 0x35, 0x49, 0xa8, 0x35, 0x6d, 0xa5, 0x28, 0x55, 0xdd, 0xd4, 0xaa, @@ -444,6 +522,55 @@ var fileDescriptor_a3058c1b66f59e98 = []byte{ 0xee, 0x47, 0x75, 0x74, 0xb0, 0xc7, 0x8e, 0x34, 0xee, 0xf0, 0x07, 0x10, 0x5d, 0x0c, 0x48, 0xd8, 0x5a, 0x65, 0xc8, 0xb7, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x93, 0x06, 0x17, 0x37, 0x06, 0x00, 0x00, +======= + // 735 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4f, 0x4f, 0x13, 0x4f, + 0x18, 0xee, 0xb6, 0xfc, 0xf8, 0xe1, 0x0b, 0xd4, 0x66, 0xc4, 0x84, 0x60, 0x6c, 0xb1, 0x31, 0x04, + 0x63, 0xd8, 0xa5, 0x15, 0x3d, 0x9a, 0xf4, 0xcf, 0x56, 0x36, 0x96, 0xb6, 0x6e, 0x0b, 0x26, 0x24, + 0x66, 0xb2, 0xed, 0x4e, 0x4b, 0x93, 0xdd, 0xce, 0xba, 0xbb, 0x6d, 0xe0, 0x5b, 0x60, 0xe2, 0xc9, + 0xa3, 0x77, 0xbf, 0x07, 0x47, 0x8e, 0x9e, 0xd4, 0xc0, 0x17, 0x31, 0x3b, 0x33, 0x5d, 0x5a, 0x28, + 0x91, 0xd6, 0xab, 0xb7, 0x9d, 0x77, 0x9e, 0xf7, 0x99, 0x79, 0x9f, 0xe7, 0x19, 0x28, 0xbc, 0x36, + 0x4f, 0xcc, 0x63, 0xc7, 0xa5, 0x3e, 0x6d, 0x51, 0x4b, 0xe9, 0xf6, 0x4c, 0x72, 0x4c, 0x5c, 0x85, + 0xb6, 0xdb, 0xb8, 0x75, 0x64, 0x74, 0x7b, 0xb8, 0xef, 0x98, 0x86, 0x4f, 0xbc, 0x9b, 0x15, 0x99, + 0x35, 0xa1, 0x8d, 0xd1, 0x7e, 0x59, 0xf4, 0xcb, 0x37, 0xd0, 0x6b, 0xdb, 0x13, 0xcf, 0xf1, 0x8e, + 0x0c, 0x97, 0x98, 0x8a, 0x4b, 0x6c, 0x3a, 0x30, 0x2c, 0xec, 0x12, 0xc3, 0xa3, 0x3d, 0xce, 0xbc, + 0xf6, 0x7c, 0x62, 0x47, 0x58, 0x18, 0x64, 0x94, 0x96, 0x45, 0x9b, 0x02, 0x9c, 0xea, 0x50, 0xda, + 0xb1, 0x08, 0xdf, 0x6e, 0xf6, 0xdb, 0x8a, 0xdf, 0xb5, 0x89, 0xe7, 0x1b, 0xb6, 0x23, 0x00, 0x2b, + 0x1d, 0xda, 0xa1, 0xec, 0x53, 0x09, 0xbe, 0x78, 0x35, 0xfd, 0x35, 0x06, 0x4b, 0x55, 0xd7, 0x24, + 0x6e, 0xcd, 0x32, 0x5a, 0xe4, 0x20, 0x83, 0x8a, 0xf0, 0x1f, 0x0d, 0xd6, 0xab, 0xd2, 0xba, 0xb4, + 0xb9, 0x98, 0x95, 0xe5, 0x89, 0xe3, 0x85, 0x85, 0x41, 0x46, 0xd6, 0x78, 0x8d, 0xb1, 0xe8, 0xbc, + 0x19, 0xf9, 0x90, 0x70, 0x02, 0x42, 0x9b, 0xf4, 0x7c, 0xec, 0xf9, 0x86, 0xdf, 0xf7, 0x56, 0xa3, + 0xeb, 0xd2, 0x66, 0x3c, 0xab, 0xc9, 0x77, 0xd3, 0x4b, 0x1e, 0xbd, 0xd5, 0xc8, 0x22, 0x60, 0xac, + 0x33, 0x42, 0xfd, 0xbe, 0x33, 0x5e, 0x40, 0x05, 0x80, 0x60, 0x6a, 0xcc, 0xc6, 0x5e, 0x8d, 0xb1, + 0x01, 0xd6, 0x64, 0x2e, 0x8c, 0x3c, 0x14, 0x46, 0x6e, 0x0c, 0x85, 0xc9, 0x2f, 0x9c, 0xfd, 0x48, + 0x49, 0xa7, 0x3f, 0x53, 0x92, 0x7e, 0x2f, 0xe8, 0xab, 0x07, 0xc5, 0xf4, 0xa9, 0x04, 0x2b, 0x93, + 0x8e, 0x43, 0x1b, 0x90, 0xae, 0xea, 0x45, 0x55, 0xc7, 0xb5, 0x72, 0xae, 0xa0, 0xee, 0xa9, 0x95, + 0x06, 0xae, 0x37, 0x72, 0x8d, 0xfd, 0x3a, 0xde, 0xaf, 0xd4, 0x6b, 0x6a, 0x41, 0x2b, 0x69, 0x6a, + 0x31, 0x11, 0x41, 0x5b, 0xf0, 0xec, 0x16, 0x5c, 0x5e, 0xad, 0x37, 0xb0, 0x5a, 0x2a, 0x55, 0xf5, + 0x06, 0xae, 0xd6, 0xd4, 0x8a, 0x5a, 0x4c, 0x48, 0xe8, 0x09, 0x3c, 0xbe, 0x05, 0x2e, 0x20, 0xd1, + 0xf4, 0x97, 0x39, 0x58, 0xe6, 0xf2, 0x06, 0x31, 0x09, 0x5c, 0x3a, 0x84, 0x04, 0x8b, 0x0c, 0x31, + 0x31, 0x13, 0x1c, 0x77, 0x4d, 0x61, 0xd8, 0xf6, 0x74, 0x86, 0x69, 0xa6, 0x1e, 0x17, 0x4c, 0x62, + 0x8d, 0xde, 0xc0, 0x3c, 0x8f, 0xa1, 0x70, 0x4c, 0x99, 0xcc, 0xc8, 0x93, 0x2b, 0x5f, 0xdd, 0xcb, + 0xb0, 0x74, 0xd6, 0xa6, 0x8b, 0x76, 0x44, 0x21, 0x3e, 0xcc, 0xb5, 0x88, 0x40, 0x8c, 0x11, 0xee, + 0x4e, 0x15, 0x81, 0xe1, 0xcc, 0x63, 0x27, 0x89, 0x04, 0x2c, 0xbb, 0xa3, 0xcb, 0x6b, 0xfe, 0xcf, + 0xcd, 0xe6, 0xff, 0x37, 0x09, 0xd0, 0xcd, 0xa3, 0xd0, 0x53, 0x58, 0xe7, 0x36, 0xe9, 0xea, 0x5e, + 0xf5, 0x20, 0x57, 0xfe, 0x83, 0xf7, 0xd7, 0x50, 0xa3, 0xce, 0x17, 0x72, 0x95, 0x82, 0x5a, 0x1e, + 0xf7, 0xfe, 0x1a, 0x3c, 0x84, 0x44, 0x51, 0x0a, 0x1e, 0x4d, 0x84, 0x94, 0xb4, 0x72, 0x00, 0x88, + 0x05, 0x79, 0xe5, 0xe1, 0xd8, 0x67, 0xaa, 0x1d, 0x64, 0xd0, 0x5b, 0x58, 0xf8, 0xeb, 0x50, 0xfc, + 0x4f, 0x45, 0x1a, 0xb2, 0xf0, 0xd0, 0xa7, 0xbe, 0x61, 0xe1, 0x76, 0xd7, 0xb2, 0x88, 0x89, 0x3f, + 0xf6, 0x8d, 0x9e, 0xdf, 0xb7, 0xf9, 0x73, 0x9e, 0xd3, 0x1f, 0xb0, 0xcd, 0x12, 0xdb, 0x7b, 0x27, + 0xb6, 0xd2, 0x9f, 0xa2, 0x10, 0x17, 0x12, 0x3a, 0xff, 0xfe, 0xac, 0xf0, 0x58, 0x7d, 0x8e, 0x41, + 0xa2, 0xda, 0x6e, 0x17, 0x82, 0xcb, 0x84, 0x4e, 0xbd, 0x87, 0x45, 0xee, 0x14, 0x3b, 0x52, 0x68, + 0xb3, 0x33, 0xcb, 0x28, 0xbb, 0x11, 0x1d, 0x68, 0xb8, 0x46, 0x87, 0xb0, 0xc4, 0x89, 0xf9, 0xdb, + 0x66, 0x22, 0x2d, 0x66, 0x5f, 0xce, 0xf4, 0xf0, 0x76, 0x23, 0x3a, 0xbf, 0x25, 0x2f, 0x5c, 0x71, + 0x73, 0xb4, 0x10, 0x64, 0x3a, 0xee, 0xa1, 0x02, 0x21, 0x37, 0x2f, 0xa0, 0x0f, 0xb0, 0x3c, 0xbc, + 0x37, 0x97, 0x84, 0x3f, 0xe2, 0x57, 0x53, 0x5e, 0xdc, 0x09, 0x45, 0x59, 0xa2, 0x23, 0x95, 0x7c, + 0x02, 0xe2, 0x1c, 0x89, 0x6d, 0xe2, 0x79, 0x46, 0x87, 0xe4, 0x5b, 0x67, 0x17, 0x49, 0xe9, 0xfc, + 0x22, 0x29, 0xfd, 0xba, 0x48, 0x4a, 0xa7, 0x97, 0xc9, 0xc8, 0xf9, 0x65, 0x32, 0xf2, 0xfd, 0x32, + 0x19, 0x39, 0xd4, 0x3a, 0x5d, 0xff, 0xa8, 0xdf, 0x94, 0x5b, 0xd4, 0x56, 0xc6, 0xfe, 0x11, 0x0f, + 0x76, 0xb6, 0xd8, 0xa1, 0xca, 0x1d, 0x7e, 0x34, 0xf8, 0x27, 0x0e, 0xf1, 0x9a, 0xf3, 0x0c, 0xf9, + 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x27, 0xf4, 0x86, 0x6b, 0x08, 0x00, 0x00, +>>>>>>> 722ec245 ([CT-853] Generate order replacement protos (#1551)) } func (m *OrderPlaceV1) Marshal() (dAtA []byte, err error) { @@ -571,6 +698,56 @@ func (m *OrderUpdateV1) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *OrderReplaceV1) 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 *OrderReplaceV1) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OrderReplaceV1) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TimeStamp != nil { + n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.TimeStamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.TimeStamp):]) + if err6 != nil { + return 0, err6 + } + i -= n6 + i = encodeVarintOffChainUpdates(dAtA, i, uint64(n6)) + i-- + dAtA[i] = 0x1a + } + if m.PlacementStatus != 0 { + i = encodeVarintOffChainUpdates(dAtA, i, uint64(m.PlacementStatus)) + i-- + dAtA[i] = 0x10 + } + if m.Order != nil { + { + size, err := m.Order.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintOffChainUpdates(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *OffChainUpdateV1) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -666,6 +843,27 @@ func (m *OffChainUpdateV1_OrderUpdate) MarshalToSizedBuffer(dAtA []byte) (int, e } return len(dAtA) - i, nil } +func (m *OffChainUpdateV1_OrderReplace) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OffChainUpdateV1_OrderReplace) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.OrderReplace != nil { + { + size, err := m.OrderReplace.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintOffChainUpdates(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} func encodeVarintOffChainUpdates(dAtA []byte, offset int, v uint64) int { offset -= sovOffChainUpdates(v) base := offset @@ -728,6 +926,26 @@ func (m *OrderUpdateV1) Size() (n int) { return n } +func (m *OrderReplaceV1) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Order != nil { + l = m.Order.Size() + n += 1 + l + sovOffChainUpdates(uint64(l)) + } + if m.PlacementStatus != 0 { + n += 1 + sovOffChainUpdates(uint64(m.PlacementStatus)) + } + if m.TimeStamp != nil { + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.TimeStamp) + n += 1 + l + sovOffChainUpdates(uint64(l)) + } + return n +} + func (m *OffChainUpdateV1) Size() (n int) { if m == nil { return 0 @@ -776,6 +994,18 @@ func (m *OffChainUpdateV1_OrderUpdate) Size() (n int) { } return n } +func (m *OffChainUpdateV1_OrderReplace) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.OrderReplace != nil { + l = m.OrderReplace.Size() + n += 1 + l + sovOffChainUpdates(uint64(l)) + } + return n +} func sovOffChainUpdates(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 @@ -1117,6 +1347,147 @@ func (m *OrderUpdateV1) Unmarshal(dAtA []byte) error { } return nil } +func (m *OrderReplaceV1) 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 ErrIntOverflowOffChainUpdates + } + 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: OrderReplaceV1: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrderReplaceV1: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOffChainUpdates + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOffChainUpdates + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthOffChainUpdates + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Order == nil { + m.Order = &types.IndexerOrder{} + } + if err := m.Order.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PlacementStatus", wireType) + } + m.PlacementStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOffChainUpdates + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PlacementStatus |= OrderPlaceV1_OrderPlacementStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TimeStamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOffChainUpdates + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOffChainUpdates + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthOffChainUpdates + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TimeStamp == nil { + m.TimeStamp = new(time.Time) + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.TimeStamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOffChainUpdates(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthOffChainUpdates + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *OffChainUpdateV1) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1251,6 +1622,41 @@ func (m *OffChainUpdateV1) Unmarshal(dAtA []byte) error { } m.UpdateMessage = &OffChainUpdateV1_OrderUpdate{v} iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrderReplace", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOffChainUpdates + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOffChainUpdates + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthOffChainUpdates + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &OrderReplaceV1{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.UpdateMessage = &OffChainUpdateV1_OrderReplace{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipOffChainUpdates(dAtA[iNdEx:])