syntax="proto3"; package bts.api.orderman; option csharp_namespace="bts.api.orderman"; import "lib/api/apioptions.proto"; import "lib/domain_model/Security.proto"; import "google/protobuf/timestamp.proto"; import "lib/sparkproto/SparkProtos.proto"; import "lib/api/apicore.proto"; service OrderService { option (bts.api.service_description)="Implements order management"; // service calls rpc create_order(Create) returns (Response) { option(skip_excel_generation) = true; }; rpc cancel_order(Cancel) returns (Response) { option(skip_excel_generation) = true; }; rpc update_order(Update) returns (Response) { option(skip_excel_generation) = true; }; rpc detach_order(Detach) returns (Response) { option(skip_excel_generation) = true; }; rpc get_registered_dynamic_order_types(bts.api.VoidMessage) returns (RegisteredDynamicOrderTypes); // streams rpc orders (OrdersSub) returns (stream OrderRecord); rpc fills (FillsSub) returns (stream Fill); } // request types message Create { OrderDefinition new_order = 1; double price = 2; uint32 quantity = 3; } message Update { CustomOrderDefinition custom = 4; double price = 2; uint32 quantity = 3; uint32 order_key = 1; } message Cancel {uint32 order_key = 1;}; message Detach {uint32 order_key = 1;}; // response types message Response {uint32 order_key = 1; OrderError error_code = 2; string msg = 3;} // subscription types message OrdersSub {} message FillsSub {} message OrderDefinition { // deleted fields (don't reuse!): // - uint32 algo_template_key = 15; (originally deleted 05/03/2019) // standard order elements uint32 security_key = 1; api.Side side = 2; string user = 5; uint32 user_id = 13; string account = 6; uint32 account_id = 14; TimeInForce time_in_force = 7; ManualOrderIndicator manual_order_indicator = 8; CTICode cti_code = 9; CustomerOrFirm customer_or_firm = 10; OrderSubType sub_type = 12; uint32 attach_target_order_key = 16; CustomOrderDefinition custom_def = 11; } message CustomOrderDefinition { oneof custom { // native order types // https://www.cmegroup.com/confluence/display/EPICSANDBOX/New+Order MarketOrderDefinition market = 11; // OrdType = 1 LimitOrderDefinition limit = 12; // OrdType = 2 StopOrderDefinition stop = 13; // OrdType = 3 StopLimitOrderDefinition stop_limit = 14; // OrdType = 4 IcebergOrderDefinition iceberg = 15; SpreaderOrderDefinition spreader = 16; TimeBoxOrderDefinition time_box = 17; TickOrderDefinition tick = 18; LeanOrderDefinition lean = 19; JoinOrderDefinition join = 20; TopOrderDefinition top = 21; TriggerOrderDefinition trigger = 22; CoverOrderDefinition cover = 23; OffsetOrderDefinition offset = 24; QueueHolderDefinition queue_holder = 30; OCOOrderDefinition oco = 25; PricerOrderDefinition pricer = 26; CompositeOrderDefinition composite = 27; DynamicOrderDefinition dynamic = 1000; } } // Custom order definitions message MarketOrderDefinition {} message LimitOrderDefinition {} message StopOrderDefinition { double stop_price = 1; } message StopLimitOrderDefinition { double stop_price = 1; } message IcebergOrderDefinition { double show_quantity = 1; uint32 pause_between_orders_ms = 3; CustomOrderDefinition child = 2; } message SpreaderOrderDefinition { api.Security security = 1; spark.ExecutionStrategy execution_strategy = 2; } message TimeBoxOrderDefinition { google.protobuf.Timestamp start = 1; google.protobuf.Timestamp stop = 2; CustomOrderDefinition child = 3; } message TickOrderDefinition { uint32 tick_offset_on_deploy = 1; spark.QuantityMeasure cross_threshold = 2; uint32 cross_ticks = 3; uint32 max_chase_ticks = 4; bool detach_on_toward = 5; CustomOrderDefinition child = 6; } message LeanOrderDefinition { spark.QuantityMeasure cross_threshold = 1; uint32 max_chase_ticks = 2; /*deprecated*/ bool detach_on_toward = 4; enum OnToward { NO_CHANGE = 0; //continue to lean on initial inside market CANCEL = 1; //cancel algo and order DETACH = 2; //cancel algo but leave order working REPRICE = 3; //lean on new inside market } OnToward trade_toward_behavior = 5; CustomOrderDefinition child = 3; } message JoinOrderDefinition { spark.QuantityMeasure join_threshold = 2; CustomOrderDefinition child = 6; } message TopOrderDefinition { uint32 watch_level_tick_offset = 1; spark.QuantityMeasure top_threshold = 2; CustomOrderDefinition child = 6; } message TriggerOrderDefinition { TriggerCondition trigger_condition=1; TriggerAction trigger_action=2; CustomOrderDefinition child=3; TriggerExitCondition exit_condition=4; } message CoverOrderDefinition { CustomOrderDefinition hedge = 1; int32 hedge_ticks = 2; CustomOrderDefinition child = 3; } message OffsetOrderDefinition { uint32 tick_offset_on_deploy = 1; CustomOrderDefinition child = 6; } message QueueHolderDefinition{ // this is for the number of trailing // orders behind the top one (so value // of 1 means 2 orders in all) uint32 n_queue_orders = 1; CustomOrderDefinition child=10; } message OCOOrderDefinition { CustomOrderDefinition other = 1; int32 other_ticks = 2; api.RelativeSide other_side = 4; CustomOrderDefinition child = 3; } message PricerOrderDefinition { int32 price_offset_ticks = 1; double price_factor = 2; CustomOrderDefinition child = 3; } message CompositeOrderDefinition { uint32 algo_template_key = 1; CustomOrderDefinition definition = 2; } message DynamicOrderDefinition { string dynamic_order_type = 1; map order_params = 2; } // End custom order definitions message OrderRecord { uint32 key = 1 [(bts.api.key)=true]; uint32 parent_key = 2; OrderDefinition def = 3; OrderState state = 4; } message OrderState { // standard order state OrderStatus status = 1; double price = 2; uint32 quantity = 3; uint32 filled_quantity=4; double last_price = 5; double avg_price = 6; string last_msg = 7; google.protobuf.Timestamp created = 16; google.protobuf.Timestamp last_change = 8; enum DisplayStatus { VISIBLE = 0; HIDDEN = 1; } DisplayStatus display_status=23; oneof custom { // native order types MarketOrderState market = 9; // OrdType = 1 LimitOrderState limit = 10; // OrdType = 2 StopOrderState stop= 11; // OrdType = 3 StopLimitOrderState stop_limit = 12; // OrdType = 4 IcebergOrderState iceberg = 13; SpreaderOrderState spreader = 14; TimeBoxOrderState time_box = 15; TickOrderState tick = 17; LeanOrderState lean = 18; JoinOrderState join = 19; TopOrderState top = 20; TriggerOrderState trigger = 21; CoverOrderState cover = 22; OffsetOrderState offset = 24; QueueHolderState queue_holder = 30; OCOOrderState oco = 25; PricerOrderState pricer = 26; DynamicOrderState dynamic = 255; // do not use anything bigger than 255, or things will break } } // only native orders have fills message Fill { uint32 order_key = 1; uint32 security_key = 2; string account = 3; double last_price = 4; double avg_price = 9; api.Side side = 5; double last_shares = 6; string fill_key = 7 [(bts.api.key)=true]; google.protobuf.Timestamp timestamp = 8; uint32 internal_account_id = 11; enum FillKind { FILL_KIND_STANDARD = 0; FILL_KIND_LEG = 1; FILL_KIND_SOD = 2; } FillKind fill_kind = 10; } enum OrderSubType { ORDER_SUB_TYPE_NONE = 0; ORDER_SUB_TYPE_HEDGING_LEG = 1; ORDER_SUB_TYPE_QUOTING_LEG = 2; } message RoutingRecord { string session = 1; string account = 2; string operator_id = 3; CTICode cti_code = 4; CustomerOrFirm customer_or_firm = 5; string smp_id = 6 ; SelfMatchPreventionInstruction smp_instruction = 7; string location = 8; } message NativeOrderState { string exchange_order_id = 1; uint64 last_msg_seq_num = 4; enum SubError { SUB_ERROR_NONE = 0; SUB_ERROR_UNKNOWN_SECURITY = 1; SUB_ERROR_UNKNOWN_FIX_SESSION = 2; } SubError sub_error_code = 2; NativeOrderStatus native_status = 3; RoutingRecord routing_record = 5; NativeOrderType native_type = 6; string last_transact_time = 7; } // Custom order states message MarketOrderState {NativeOrderState native_state = 1;} message LimitOrderState {NativeOrderState native_state = 1;} message StopOrderState {NativeOrderState native_state = 1;} message StopLimitOrderState {NativeOrderState native_state = 1;} message IcebergOrderState {} message SpreaderOrderState {} message TimeBoxOrderState {} message TickOrderState {} message LeanOrderState {} message JoinOrderState {} message TopOrderState {} message TriggerOrderState {} message CoverOrderState {} message OffsetOrderState {} message OCOOrderState {} message PricerOrderState {} message DynamicOrderState {} message QueueHolderState {} enum OrderStatus { // The order has been constructed but not acted on. Inactive orders // can be abandoned without consequences. This state should only be // used internally by the order manager, i.e. it should never appear // in externally visible orders. ORDER_STATUS_INACTIVE = 0; // The order is currently working, i.e. its algorithm is operating. ORDER_STATUS_WORKING = 1; // The order has completed successfully and accomplished its // goal. This is a terminal state. ORDER_STATUS_COMPLETED = 2; // The order was terminated orderly before it had a chance to // complete. This is a terminal state. ORDER_STATUS_CANCELED = 3; // The order has encountered an unexpected condition from which it // cannot recover. This a terminal state. ORDER_STATUS_ERROR = 4; // The last known state for this order was ORDER_STATUS_WORKING, but // since then the execution gateway has signaled a disconnect. This // is not a terminal state ORDER_STATUS_DISCONNECTED = 5; // The order is initializing. It cannot be modified at this point. ORDER_STATUS_PENDING_WORKING = 6; // The order is invalid and was rejected by Spark (not the // exchange), on creation. This is a terminal state. ORDER_STATUS_REJECTED_BY_SPARK= 7; } enum TimeInForce { TIME_IN_FORCE_UNDEFINED = 0; TIME_IN_FORCE_DAY = 48; TIME_IN_FORCE_GTC = 49; TIME_IN_FORCE_IOC = 51; } enum ManualOrderIndicator { MANUAL_ORDER_INDICATOR_NO = 0; MANUAL_ORDER_INDICATOR_YES = 1; } enum CustomerOrFirm { CUSTOMER_OR_FIRM_CUSTOMER = 0; CUSTOMER_OR_FIRM_FIRM = 1; } enum CTICode { CTI_CODE_UNDEFINED = 0; CTI_CODE_CTI_CODE1 = 49; CTI_CODE_CTI_CODE2 = 50; CTI_CODE_CTI_CODE3 = 51; CTI_CODE_CTI_CODE4 = 52; } enum SelfMatchPreventionInstruction { SELF_MATCH_PREVENTION_INSTRUCTION_UNDEFINED = 0; SELF_MATCH_PREVENTION_INSTRUCTION_CANCEL_RESTING = 79; SELF_MATCH_PREVENTION_INSTRUCTION_CANCEL_AGRESSING = 78; } enum NativeOrderStatus { NATIVE_ORDER_STATUS_UNACKNOWLEDGED = 0; NATIVE_ORDER_STATUS_NEW = 48; NATIVE_ORDER_STATUS_PARTIALLY_FILLED = 49; NATIVE_ORDER_STATUS_FILLED = 50; NATIVE_ORDER_STATUS_DONE = 51; NATIVE_ORDER_STATUS_CANCELED = 52; NATIVE_ORDER_STATUS_REPLACED = 53; NATIVE_ORDER_STATUS_PENDING_CANCEL = 54; NATIVE_ORDER_STATUS_STOPPED = 55; NATIVE_ORDER_STATUS_REJECTED = 56; NATIVE_ORDER_STATUS_SUSPENDED = 57; NATIVE_ORDER_STATUS_PENDING_NEW = 65; NATIVE_ORDER_STATUS_CALCULATED = 66; NATIVE_ORDER_STATUS_EXPIRED = 67; NATIVE_ORDER_STATUS_ACCEPTED_FOR_BIDDING = 68; NATIVE_ORDER_STATUS_PENDING_REPLACE = 69; NATIVE_ORDER_STATUS_CANCEL_ACK = 72; NATIVE_ORDER_STATUS_UNDEFINED = 85; NATIVE_ORDER_STATUS_ORDER_NOT_FOUND = 89; } enum NativeOrderType { NATIVE_ORDER_TYPE_UNDEFINED = 0 ; NATIVE_ORDER_TYPE_MARKET = 49 ; // 1 NATIVE_ORDER_TYPE_LIMIT = 50 ; // 2 NATIVE_ORDER_TYPE_STOP = 51 ; // 3 NATIVE_ORDER_TYPE_STOP_LIMIT = 52 ; // 4 NATIVE_ORDER_TYPE_MARKET_LIMIT = 75 ; // K } enum ExecType { EXEC_TYPE_UNDEFINED = 0 ; EXEC_TYPE_NEW = 48 ; EXEC_TYPE_PARTIAL_FILL = 49 ; EXEC_TYPE_FILL = 50 ; EXEC_TYPE_DONE = 51 ; EXEC_TYPE_CANCELED = 52 ; EXEC_TYPE_REPLACED = 53 ; EXEC_TYPE_PENDING_CANCEL = 54 ; EXEC_TYPE_STOPPED = 55 ; EXEC_TYPE_REJECTED = 56 ; EXEC_TYPE_SUSPENDED = 57 ; EXEC_TYPE_PENDING_NEW = 65 ; EXEC_TYPE_CALCULATED = 66 ; EXEC_TYPE_EXPIRED = 67 ; EXEC_TYPE_RESTATED = 68 ; EXEC_TYPE_PENDING_REPLACE = 69 ; EXEC_TYPE_TRADE_CORRECT = 71 ; EXEC_TYPE_TRADE_CANCEL = 72 ; } enum OrderError { ORDER_ERROR_UNDEFINED = 0; ORDER_ERROR_UNSUPPORTED_ORDER_TYPE = 1; ORDER_ERROR_GATEWAY_NOT_READY = 2; ORDER_ERROR_UNKNOWN_ORDER = 5 ; ORDER_ERROR_UNKNOWN_SECURITY = 6; ORDER_ERROR_ORDER_NOT_ACK = 7; ORDER_ERROR_SERVER_NOT_READY = 8; ORDER_ERROR_OK = 9; ORDER_ERROR_OP_NOT_SUPPORTED = 10; ORDER_ERROR_INVALID_OP = 11; ORDER_ERROR_LIMIT_BREACH = 12; ORDER_ERROR_MESSAGING_LIMIT_BREACH = 13; ORDER_ERROR_UNAUTHORIZED = 14; ORDER_ERROR_INVALID_ORDER_DEFINITON = 15; ORDER_ERROR_UNEXPECTED_CHILD_STATE = 16; } // Trigger Condition ///////////////////////////////// ////////////////////////////////////////////////////// enum TriggerType{ STOP = 0; INVERSE_STOP = 1; } // this is the maket the trigger order // watches for the trigger condition enum TriggerPriceType{ BID = 0; ASK = 1; LAST_TRADE_PRICE = 2; //unused->assert } message TriggerQuantity{ spark.QuantityMeasure quantity_measure = 10; uint32 threshold_quantity = 20; } message AbsolutePriceTrigger{ // we can leave out qty for now TriggerQuantity trigger_quantity = 10; //unused } message TrailingTrigger{ TriggerType trigger_type = 10; int32 number_of_ticks = 20; } message TriggerCondition{ TriggerPriceType price_type = 10; oneof trigger{ AbsolutePriceTrigger absolute_price_trigger = 20; TrailingTrigger trailing_trigger = 30; //unused } } // Trigger Action //////////////////////////////////// ////////////////////////////////////////////////////// // if TriggerAction.orderprice is payup // then the payup price will be calc'ed // with respect to this price message TriggerPayupPrice{ enum TriggerPayupPriceType{ BID = 0; ASK = 1; LAST_TRADE_PRICE = 2; //unused TRIGGER=3; } TriggerPriceType price_type = 10; // defunct TriggerPayupPriceType payup_price_type = 15; int32 payup_ticks = 20; } message TriggerAction{ uint32 security_id = 10; //unused oneof orderprice{ TriggerPayupPrice payup = 20; double price = 30; } } // Trigger Exit Condition //////////////////////////// ////////////////////////////////////////////////////// message TriggerExitCondition{ bool timeout_enabled = 10; uint32 timeout_seconds=20; //seconds bool conditional_cancel=30; } // Dynamic Orders enum DynamicOrderPrimitiveDescriptor { DYNAMIC_ORDER_PRIMITIVE_INT = 0; DYNAMIC_ORDER_PRIMITIVE_UINT = 1; DYNAMIC_ORDER_PRIMITIVE_DOUBLE = 2; DYNAMIC_ORDER_PRIMITIVE_STRING = 3; DYNAMIC_ORDER_PRIMITIVE_BOOL = 4; DYNAMIC_ORDER_PRIMITIVE_ORDER_DEF = 5; } message DynamicOrderTypeDescriptor { oneof descriptor { DynamicOrderPrimitiveDescriptor primitive = 2; DynamicOrderArrayDescriptor array = 3; DynamicOrderStructDescriptor structure = 4; DynamicOrderEnumeratedDescriptor enumerated = 5; } } message DynamicOrderArrayDescriptor { DynamicOrderTypeDescriptor element_type = 1; } message DynamicOrderParamDescriptor { string param_name = 1; DynamicOrderTypeDescriptor param_type = 2; } message DynamicOrderStructDescriptor { repeated DynamicOrderParamDescriptor field = 1; } message DynamicOrderEnumeratedDescriptor { repeated string element = 1; } message DynamicOrderDescriptor { string dynamic_order_type = 1; repeated DynamicOrderParamDescriptor param_desc = 3; } message RegisteredDynamicOrderTypes { repeated DynamicOrderDescriptor dynamic_order_desc = 1; } message DynamicOrderParam { oneof value { uint32 as_int32 = 1; uint32 as_uint32 = 2; double as_double = 3; string as_string = 4; bool as_bool = 5; CustomOrderDefinition as_order_def = 6; DynamicOrderArray as_array = 7; DynamicOrderStruct as_struct = 8; DynamicOrderEnumerated as_enumerated = 9; } } message DynamicOrderArray { repeated DynamicOrderParam element = 1; } message DynamicOrderStruct { map field = 1; } message DynamicOrderEnumerated { string enum_value = 1; }