From 7a8a38f89d5bb2e9f74527f5a2a43702f078dead Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Fri, 25 May 2018 18:04:38 -0400 Subject: [PATCH] pushing for join to look at joinordervm validation --- .../Orders/OrderModificationControl.xaml.cs | 6 +- .../spark/Orders/OrderTypeVMs/JoinOrderVM.cs | 284 ++++++++++++++++++ .../spark/Orders/OrderTypeVMs/LeanOrderVM.cs | 174 +++++++++++ .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 8 +- .../spark/Orders/OrderTypeVMs/TickOrderVM.cs | 18 +- .../spark/Orders/OrderTypeVMs/TopOrderVM.cs | 174 +++++++++++ .../spark/core/FontsAndColors/BTSColors.cs | 2 +- .../Order/OrderDetailsPopupControl.xaml | 107 ++++++- .../spark/view/Spark/Ladder/LadderGridHost.cs | 4 +- .../view/Spark/Utilities/OrderDataHelper.cs | 35 ++- src/lib/api/services/OrderService.proto | 22 +- .../orderman/order_factory/OrderFactory.cpp | 12 +- .../sparkd/orderman/orders/NativeOrder.cpp | 12 +- .../orderman/orders/book_algos/BookAlgo.cpp | 88 ++++-- .../orderman/orders/book_algos/BookAlgo.h | 26 +- .../orderman/orders/book_algos/JoinOrder.cpp | 166 ++++++++++ .../orderman/orders/book_algos/JoinOrder.h | 30 ++ .../orderman/orders/book_algos/LeanOrder.cpp | 156 ++++++++++ .../orderman/orders/book_algos/LeanOrder.h | 30 ++ .../orderman/orders/book_algos/TickOrder.cpp | 51 ++-- .../orderman/orders/book_algos/TickOrder.h | 6 +- .../orderman/orders/book_algos/TopOrder.cpp | 127 ++++++++ .../orderman/orders/book_algos/TopOrder.h | 27 ++ 23 files changed, 1444 insertions(+), 121 deletions(-) create mode 100644 src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs create mode 100644 src/server/sparkd/orderman/orders/book_algos/JoinOrder.cpp create mode 100644 src/server/sparkd/orderman/orders/book_algos/JoinOrder.h create mode 100644 src/server/sparkd/orderman/orders/book_algos/LeanOrder.cpp create mode 100644 src/server/sparkd/orderman/orders/book_algos/LeanOrder.h create mode 100644 src/server/sparkd/orderman/orders/book_algos/TopOrder.cpp create mode 100644 src/server/sparkd/orderman/orders/book_algos/TopOrder.h diff --git a/src/client/spark/Orders/OrderModificationControl.xaml.cs b/src/client/spark/Orders/OrderModificationControl.xaml.cs index 85ea5f022..067e32cf0 100644 --- a/src/client/spark/Orders/OrderModificationControl.xaml.cs +++ b/src/client/spark/Orders/OrderModificationControl.xaml.cs @@ -21,8 +21,9 @@ namespace mbts.ui.spark { public DataTemplate StopMarketOrderTemplate { get; set; } public DataTemplate TimeBoxOrderTemplate { get; set; } public DataTemplate TickOrderTemplate { get; set; } + public DataTemplate LeanOrderTemplate { get; set; } public DataTemplate JoinOrderTemplate { get; set; } - public DataTemplate LeaderOrderTemplate { get; set; } + public DataTemplate TopOrderTemplate { get; set; } public DataTemplate IcebergOrderTemplate { get; set; } public DataTemplate SpreaderTemplate { get; set; } public DataTemplate BTSStopOrderTemplate { get; set; } @@ -37,8 +38,9 @@ namespace mbts.ui.spark { case CustomOrderDefinition.CustomOneofCase.StopLimit: return StopLimitOrderTemplate; case CustomOrderDefinition.CustomOneofCase.TimeBox: return TimeBoxOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Tick: return TickOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Lean: return LeanOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate; - case CustomOrderDefinition.CustomOneofCase.Leader: return LeaderOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Top: return TopOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate; } diff --git a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs new file mode 100644 index 000000000..39cc9a547 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs @@ -0,0 +1,284 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineJoinOrderProperties + { + public InlineJoinOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + + var hedgetype = CustomOneofCase.Lean; + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types"); + this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); + this.hedge_order_types = new InlineUserProperty>(child_order_types, true); + + min_tick_offset_on_deploy = new InlineUserProperty(0, false); + join_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Absolute = 1}, false); + enable_hedge = new InlineUserProperty(false, false); + hedge_ticks = new InlineUserProperty(1, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + public readonly InlineUserProperty selected_hedge_order_type; + public readonly InlineUserProperty> hedge_order_types; + + + public readonly InlineUserProperty min_tick_offset_on_deploy; + public readonly InlineUserProperty join_threshold; + + public readonly InlineUserProperty enable_hedge; + public readonly InlineUserProperty hedge_ticks; + + } + + class JoinOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineJoinOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + ObservableAutoWrapper _hedge_order_choices; + IOrderTypeVM _hedge_order; + IDisposable _hedge_order_errors_sub; + + public uint min_tick_offset_on_deploy { get; set; } = 0; + public bts.spark.QuantityMeasure join_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + bool _enable_hedge = false; + public bool enable_hedge + { + get { return _enable_hedge; } + set + { + _enable_hedge = value; + RaisePropertyChanged(nameof(enable_hedge)); + } + } + public int hedge_ticks { get; set; } = 1; + + public JoinOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineJoinOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public JoinOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (_hedge_order_choices != null && (_hedge_order == null || p.selected_hedge_order_type.force_override)) + { + _select_hedge_order(p.selected_hedge_order_type.value); + } + if (p.min_tick_offset_on_deploy.force_override) + { + min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(min_tick_offset_on_deploy)); + } + if (p.join_threshold.force_override) + { + join_threshold = p.join_threshold.value; + RaisePropertyChanged(nameof(join_threshold)); + } + if (p.enable_hedge.force_override) + { + enable_hedge = p.enable_hedge.value; + RaisePropertyChanged(nameof(enable_hedge)); + } + if (p.hedge_ticks.force_override) + { + hedge_ticks = p.hedge_ticks.value; + RaisePropertyChanged(nameof(hedge_ticks)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + if (_hedge_order == null && enable_hedge) + _select_hedge_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.join_order(); + i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy; + i.JoinThreshold = join_threshold; + i.EnableHedge = enable_hedge; + i.HedgeTicks = hedge_ticks; + child_order.assign_to(i.Child); + if(enable_hedge && hedge_order != null) + hedge_order.assign_to(i.Hedge); + value.Join = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public ICollection hedge_order_types + { + get + { + if (_hedge_order_choices == null) + _hedge_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _hedge_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public IOrderTypeVM hedge_order + { + get + { + init(); + return _hedge_order; + } + set + { + Disposable.dispose(ref _hedge_order_errors_sub); + _hedge_order = value; + _hedge_order?.init(); + if (_hedge_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _hedge_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(hedge_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + if (_hedge_order_choices != null) + _hedge_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + if (_hedge_order == null && _security.HasValue && enable_hedge) + _select_hedge_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _select_hedge_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_hedge_order_type.has_value ? + _inline_props.selected_hedge_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_hedge_order(ot); + } + + void _select_hedge_order(CustomOneofCase ot) + { + _hedge_order = hedge_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_hedge_order == null) + _hedge_order = hedge_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(hedge_order)); + } + + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + + if ( (_hedge_order == null && enable_hedge) || (_hedge_order is INotifyDataErrorInfo hdei && hdei.HasErrors)) + set_error(nameof(hedge_order), string.Empty, true); + else clear_error(nameof(hedge_order)); + + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs new file mode 100644 index 000000000..ae63ec031 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs @@ -0,0 +1,174 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineLeanOrderProperties + { + public InlineLeanOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + cross_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); + max_chase_ticks = new InlineUserProperty(10, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty cross_threshold; + public readonly InlineUserProperty max_chase_ticks; + } + + class LeanOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineLeanOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + public uint max_chase_ticks { get; set; } = 10; + + public LeanOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineLeanOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public LeanOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.cross_threshold.force_override) + { + cross_threshold = p.cross_threshold.value; + RaisePropertyChanged(nameof(cross_threshold)); + } + if (p.max_chase_ticks.force_override) + { + max_chase_ticks = p.max_chase_ticks.value; + RaisePropertyChanged(nameof(max_chase_ticks)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.lean_order(); + i.CrossThreshold = cross_threshold; + i.MaxChaseTicks = max_chase_ticks; + child_order.assign_to(i.Child); + value.Lean = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index 0b4892556..b9467cc56 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -15,8 +15,9 @@ namespace mbts.spark { public static IOrderTypeVM stop_limit(OrdersModel model) => new StopLimitOrderVM(model); public static IOrderTypeVM time_box(OrdersModel model, IObservable security_source) => new TimeBoxOrderVM(model, security_source); public static IOrderTypeVM tick(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); - public static IOrderTypeVM join(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); - public static IOrderTypeVM leader(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); + public static IOrderTypeVM lean(OrdersModel model, IObservable security_source) => new LeanOrderVM(model, security_source); + public static IOrderTypeVM join(OrdersModel model, IObservable security_source) => new JoinOrderVM(model, security_source); + public static IOrderTypeVM top(OrdersModel model, IObservable security_source) => new TopOrderVM(model, security_source); public static IOrderTypeVM iceberg(OrdersModel model, IObservable security_source) => new IcebergOrderVM(model, security_source); public static IOrderTypeVM spreader(OrdersModel model, IObservable security_source) => new SpreaderOrderVM(model, security_source); @@ -31,8 +32,9 @@ namespace mbts.spark { case CustomOneofCase.StopLimit: return stop_limit(model); case CustomOneofCase.TimeBox: return time_box(model, security_source); case CustomOneofCase.Tick: return tick(model, security_source); + case CustomOneofCase.Lean: return lean(model, security_source); case CustomOneofCase.Join: return join(model, security_source); - case CustomOneofCase.Leader: return leader(model, security_source); + case CustomOneofCase.Top: return top(model, security_source); case CustomOneofCase.Iceberg: return iceberg(model, security_source); case CustomOneofCase.Spreader: return spreader(model, security_source); default: throw new NotImplementedException(); diff --git a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs index 6bd478faf..3709c47e3 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs @@ -22,9 +22,9 @@ namespace mbts.spark ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); this.child_order_types = new InlineUserProperty>(child_order_types, true); - min_ticks_off_on_deploy = new InlineUserProperty(0, false); + min_tick_offset_on_deploy = new InlineUserProperty(0, false); cross_threshold = new InlineUserProperty( - new bts.spark.QuantityMeasure() { Absolute = 1}, false); + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); cross_ticks = new InlineUserProperty(0, false); max_chase_ticks = new InlineUserProperty(10, false); pay_up_on_toward = new InlineUserProperty(true, false); @@ -32,7 +32,7 @@ namespace mbts.spark public readonly InlineUserProperty selected_child_order_type; public readonly InlineUserProperty> child_order_types; - public readonly InlineUserProperty min_ticks_off_on_deploy; + public readonly InlineUserProperty min_tick_offset_on_deploy; public readonly InlineUserProperty cross_threshold; public readonly InlineUserProperty cross_ticks; public readonly InlineUserProperty max_chase_ticks; @@ -49,8 +49,8 @@ namespace mbts.spark IOrderTypeVM _child_order; IDisposable _dispose, _child_order_errors_sub; - public uint min_ticks_off_on_deploy { get; set; } = 0; - public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Absolute = 1 }; + public uint min_tick_offset_on_deploy { get; set; } = 0; + public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; public uint cross_ticks { get; set; } = 0; public uint max_chase_ticks { get; set; } = 10; public bool pay_up_on_toward { get; set; } = true; @@ -76,10 +76,10 @@ namespace mbts.spark { _select_child_order(p.selected_child_order_type.value); } - if (p.min_ticks_off_on_deploy.force_override) + if (p.min_tick_offset_on_deploy.force_override) { - min_ticks_off_on_deploy = p.min_ticks_off_on_deploy.value; - RaisePropertyChanged(nameof(min_ticks_off_on_deploy)); + min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(min_tick_offset_on_deploy)); } if (p.cross_threshold.force_override) { @@ -116,7 +116,7 @@ namespace mbts.spark if (!HasErrors) { var i = factory.tick_order(); - i.MinTicksOffOnDeploy = min_ticks_off_on_deploy; + i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy; i.CrossThreshold = cross_threshold; i.CrossTicks = cross_ticks; i.MaxChaseTicks = max_chase_ticks; diff --git a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs new file mode 100644 index 000000000..a8f184819 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs @@ -0,0 +1,174 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineTopOrderProperties + { + public InlineTopOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + watch_level_tick_offset = new InlineUserProperty(0, false); + top_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty watch_level_tick_offset; + public readonly InlineUserProperty top_threshold; + } + + class TopOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineTopOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public uint watch_level_tick_offset { get; set; } = 0; + public bts.spark.QuantityMeasure top_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; + + public TopOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineTopOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public TopOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.watch_level_tick_offset.force_override) + { + watch_level_tick_offset = p.watch_level_tick_offset.value; + RaisePropertyChanged(nameof(watch_level_tick_offset)); + } + if (p.top_threshold.force_override) + { + top_threshold = p.top_threshold.value; + RaisePropertyChanged(nameof(top_threshold)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.top_order(); + i.WatchLevelTickOffset = watch_level_tick_offset; + i.TopThreshold = top_threshold; + child_order.assign_to(i.Child); + value.Top = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/core/FontsAndColors/BTSColors.cs b/src/client/spark/core/FontsAndColors/BTSColors.cs index af694fa0d..0b653aa47 100644 --- a/src/client/spark/core/FontsAndColors/BTSColors.cs +++ b/src/client/spark/core/FontsAndColors/BTSColors.cs @@ -207,7 +207,7 @@ namespace mbts.ui { public static BTSColor tick_order { get { return new BTSColor(31, 4, 57);}} public static BTSColor lean_order { get { return new BTSColor(110, 77, 143);}} public static BTSColor join_order { get { return new BTSColor(15, 1, 29);}} - public static BTSColor leader_order { get { return new BTSColor(40, 9, 72);}} + public static BTSColor top_order { get { return new BTSColor(40, 9, 72);}} } public static class AW2 { diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 1fcb942b0..d2c5f8c5d 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -180,18 +180,17 @@ - Min Ticks Off - + Cross Thresh + - Cross Thresh - - - Cross Ticks - - Max Chase Ticks - - Pay Up on Toward - Child + Cross Ticks + + Max Chase Ticks + + Pay Up on Toward + Min Initial Tick Offset + + Child - + + + + + + + + + + + + + + + + + + + + Cross Thresh + + Max Chase Ticks + + Child + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Join Thresh + + Enable Hedge + Hedge Ticks + + Hedge + + Min Initial Tick Offset + + Child + + + + diff --git a/src/client/spark/view/Spark/Ladder/LadderGridHost.cs b/src/client/spark/view/Spark/Ladder/LadderGridHost.cs index b8cb40931..287a611bc 100644 --- a/src/client/spark/view/Spark/Ladder/LadderGridHost.cs +++ b/src/client/spark/view/Spark/Ladder/LadderGridHost.cs @@ -19,7 +19,7 @@ using System.Windows.Media.Animation; namespace mbts.spark { partial class LadderGridHost : Control { - const int _min_row_count = 501, _max_row_count = 2001, _column_min_width = 8; + const int _min_row_count = 1001, _max_row_count = 2001, _column_min_width = 8; int _row_count = _min_row_count; readonly VisualHost _visualHost = new VisualHost(); @@ -529,7 +529,7 @@ namespace mbts.spark { } } // Renders the grid lines - //_visualHost.AddVisualChild(_gridvis); + _visualHost.AddVisualChild(_gridvis); _visualHost.AddVisualChild(_mid_mkt_break_vis); _visualHost.AddVisualChild(_ask_mkt_break_vis); _visualHost.AddVisualChild(_bid_mkt_break_vis); diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index 070b24558..e28779dfe 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -28,8 +28,9 @@ namespace mbts.spark.utilities { CustomOrderDefinition.CustomOneofCase.Iceberg, CustomOrderDefinition.CustomOneofCase.TimeBox, CustomOrderDefinition.CustomOneofCase.Tick, + CustomOrderDefinition.CustomOneofCase.Lean, CustomOrderDefinition.CustomOneofCase.Join, - CustomOrderDefinition.CustomOneofCase.Leader, + CustomOrderDefinition.CustomOneofCase.Top, }, _spreader_types = new[] { CustomOrderDefinition.CustomOneofCase.Spreader, CustomOrderDefinition.CustomOneofCase.Iceberg, @@ -186,6 +187,22 @@ namespace mbts.spark.utilities { Child = custom_order(), CrossThreshold = new QuantityMeasure(), }; + public LeanOrderDefinition lean_order() => new LeanOrderDefinition + { + Child = custom_order(), + CrossThreshold = new QuantityMeasure(), + }; + public JoinOrderDefinition join_order() => new JoinOrderDefinition + { + Child = custom_order(), + JoinThreshold = new QuantityMeasure(), + }; + public TopOrderDefinition top_order() => new TopOrderDefinition + { + Child = custom_order(), + TopThreshold = new QuantityMeasure(), + }; + public SpreaderOrderDefinition spreader_order() => new SpreaderOrderDefinition { ExecutionStrategy = new ExecutionStrategy() }; @@ -199,6 +216,9 @@ namespace mbts.spark.utilities { case CustomOrderDefinition.CustomOneofCase.Iceberg: rv.Iceberg = iceberg_order(); break; case CustomOrderDefinition.CustomOneofCase.TimeBox: rv.TimeBox = time_box_order(); break; case CustomOrderDefinition.CustomOneofCase.Tick: rv.Tick = tick_order(); break; + case CustomOrderDefinition.CustomOneofCase.Lean: rv.Lean = lean_order(); break; + case CustomOrderDefinition.CustomOneofCase.Join: rv.Join = join_order(); break; + case CustomOrderDefinition.CustomOneofCase.Top: rv.Top = top_order(); break; case CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = spreader_order(); break; } return rv; @@ -214,7 +234,10 @@ namespace mbts.spark.utilities { case CustomOrderDefinition.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() }; case CustomOrderDefinition.CustomOneofCase.Iceberg: return new OrderMetadata { KeyBinding = "I", Color = BTSColors.pale_blue.rgb_color() }; case CustomOrderDefinition.CustomOneofCase.TimeBox: return new OrderMetadata { KeyBinding = "TB", Color = BTSColors.purple.rgb_color() }; - case CustomOrderDefinition.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.red_orange.rgb_color() }; + case CustomOrderDefinition.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.tick_order }; + case CustomOrderDefinition.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order }; + case CustomOrderDefinition.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order }; + case CustomOrderDefinition.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order }; case CustomOrderDefinition.CustomOneofCase.Spreader: goto default; case CustomOrderDefinition.CustomOneofCase.None: goto default; default: return _default_order_metadata; @@ -228,7 +251,10 @@ namespace mbts.spark.utilities { case OrderState.CustomOneofCase.StopLimit: return new OrderMetadata { KeyBinding = "SL", Color = BTSColors.pale_green.rgb_color() }; case OrderState.CustomOneofCase.Iceberg: return new OrderMetadata { KeyBinding = "I", Color = BTSColors.pale_blue.rgb_color() }; case OrderState.CustomOneofCase.TimeBox: return new OrderMetadata { KeyBinding = "TB", Color = BTSColors.purple.rgb_color() }; - case OrderState.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.red_orange.rgb_color() }; + case OrderState.CustomOneofCase.Tick: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.tick_order }; + case OrderState.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order }; + case OrderState.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order }; + case OrderState.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order }; case OrderState.CustomOneofCase.Spreader: goto default; case OrderState.CustomOneofCase.None: goto default; default: return _default_order_metadata; @@ -250,6 +276,9 @@ namespace mbts.spark.utilities { case nameof(SpreaderOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Spreader; case nameof(TimeBoxOrderDefinition): return CustomOrderDefinition.CustomOneofCase.TimeBox; case nameof(TickOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Tick; + case nameof(LeanOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Lean; + case nameof(JoinOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Join; + case nameof(TopOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Top; default: throw new ArgumentException($"Unable to match '{order_type_def?.Descriptor.Name}' to an order definition type"); } } diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 4fecdbb59..aa09c5627 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -65,11 +65,12 @@ message CustomOrderDefinition SpreaderOrderDefinition spreader = 16; TimeBoxOrderDefinition time_box = 17; TickOrderDefinition tick = 18; - JoinOrderDefinition join = 19; - LeaderOrderDefinition leader = 20; + LeanOrderDefinition lean = 19; + JoinOrderDefinition join = 20; + TopOrderDefinition top = 21; } } - + // Custom order definitions message MarketOrderDefinition {} message LimitOrderDefinition {} @@ -79,9 +80,10 @@ message IcebergOrderDefinition {double show_quantity = 1; CustomOrderDefinition 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 min_ticks_off_on_deploy = 1; spark.QuantityMeasure cross_threshold = 2; uint32 cross_ticks = 3; uint32 max_chase_ticks = 4; bool pay_up_on_toward = 5; CustomOrderDefinition child = 6; } -message JoinOrderDefinition {uint32 min_ticks_off_on_deploy = 1; spark.QuantityMeasure join_threshold = 2; CustomOrderDefinition cover = 3; uint32 cover_ticks = 4; CustomOrderDefinition child = 5;} -message LeaderOrderDefinition {uint32 watch_level_ticks_off = 1; spark.QuantityMeasure lead_threshold = 2; CustomOrderDefinition cover = 3; uint32 cover_ticks = 4; CustomOrderDefinition child = 5;} +message TickOrderDefinition {uint32 min_tick_offset_on_deploy = 1; spark.QuantityMeasure cross_threshold = 2; uint32 cross_ticks = 3; uint32 max_chase_ticks = 4; bool pay_up_on_toward = 5; CustomOrderDefinition child = 6; } +message LeanOrderDefinition {spark.QuantityMeasure cross_threshold = 1; uint32 max_chase_ticks = 2; CustomOrderDefinition child = 3; } +message JoinOrderDefinition {uint32 min_tick_offset_on_deploy = 1; spark.QuantityMeasure join_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;} +message TopOrderDefinition {uint32 watch_level_tick_offset = 1; spark.QuantityMeasure top_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;} message OrderRecord { uint32 key = 1 [(bts.api.key)=true]; @@ -114,8 +116,9 @@ message OrderState { SpreaderOrderState spreader = 14; TimeBoxOrderState time_box = 15; TickOrderState tick = 17; - JoinOrderState join = 18; - LeaderOrderState leader = 19; + LeanOrderState lean = 18; + JoinOrderState join = 19; + TopOrderState top = 20; } } @@ -169,8 +172,9 @@ message IcebergOrderState {} message SpreaderOrderState {SpreaderChildKind child_kind = 1;} message TimeBoxOrderState {} message TickOrderState {} +message LeanOrderState {} message JoinOrderState {} -message LeaderOrderState {} +message TopOrderState {} enum OrderStatus { diff --git a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp index a6c0d967f..61a7af6c8 100644 --- a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp +++ b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp @@ -13,6 +13,9 @@ #include "server/sparkd/orderman/orders/NativeOrder.h" #include "server/sparkd/orderman/orders/TimeBoxOrder.h" #include "server/sparkd/orderman/orders/book_algos/TickOrder.h" +#include "server/sparkd/orderman/orders/book_algos/LeanOrder.h" +#include "server/sparkd/orderman/orders/book_algos/JoinOrder.h" +#include "server/sparkd/orderman/orders/book_algos/TopOrder.h" #include #include @@ -124,11 +127,14 @@ Order &OrderFactory::allocate(OrderKey k, OrderKey pk, case CustomOrderDefinition::kTick: order_ptr.reset (new orderman::TickOrder()); break; + case CustomOrderDefinition::kLean: + order_ptr.reset (new orderman::LeanOrder()); + break; case CustomOrderDefinition::kJoin: - //order_ptr.reset (new orderman::JoinOrder()); + order_ptr.reset (new orderman::JoinOrder()); break; - case CustomOrderDefinition::kLeader: - //order_ptr.reset (new orderman::LeadOrder()); + case CustomOrderDefinition::kTop: + order_ptr.reset (new orderman::TopOrder()); break; case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); diff --git a/src/server/sparkd/orderman/orders/NativeOrder.cpp b/src/server/sparkd/orderman/orders/NativeOrder.cpp index c367e71a8..18598a0bf 100644 --- a/src/server/sparkd/orderman/orders/NativeOrder.cpp +++ b/src/server/sparkd/orderman/orders/NativeOrder.cpp @@ -82,8 +82,9 @@ void NativeOrder::on_init_new(OrderDefinition const &def, case CustomOrderDefinition::kSpreader: case CustomOrderDefinition::kTimeBox: case CustomOrderDefinition::kTick: + case CustomOrderDefinition::kLean: case CustomOrderDefinition::kJoin: - case CustomOrderDefinition::kLeader: + case CustomOrderDefinition::kTop: case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); break; @@ -350,8 +351,9 @@ void NativeOrder::on_activate(Price p, Quantity q, case CustomOrderDefinition::kSpreader: case CustomOrderDefinition::kTimeBox: case CustomOrderDefinition::kTick: + case CustomOrderDefinition::kLean: case CustomOrderDefinition::kJoin: - case CustomOrderDefinition::kLeader: + case CustomOrderDefinition::kTop: case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); break; @@ -839,8 +841,9 @@ void NativeOrder::init_fix() { case CustomOrderDefinition::kSpreader: case CustomOrderDefinition::kTimeBox: case CustomOrderDefinition::kTick: + case CustomOrderDefinition::kLean: case CustomOrderDefinition::kJoin: - case CustomOrderDefinition::kLeader: + case CustomOrderDefinition::kTop: case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); @@ -989,8 +992,9 @@ NativeOrder::get_native_state(api::orderman::OrderState &st) { case OrderState::kSpreader: case OrderState::kTimeBox: case OrderState::kTick: + case OrderState::kLean: case OrderState::kJoin: - case OrderState::kLeader: + case OrderState::kTop: case OrderState::CUSTOM_NOT_SET: break; } diff --git a/src/server/sparkd/orderman/orders/book_algos/BookAlgo.cpp b/src/server/sparkd/orderman/orders/book_algos/BookAlgo.cpp index 694695c87..b488a00f4 100644 --- a/src/server/sparkd/orderman/orders/book_algos/BookAlgo.cpp +++ b/src/server/sparkd/orderman/orders/book_algos/BookAlgo.cpp @@ -9,12 +9,23 @@ namespace orderman { using namespace api::orderman; +struct BookAlgo::PImpl +{ + PImpl() : services(nullptr), child_builder(), fake_detached_child(false), + supports_hedge(false) + { + } + + OrderServices* services; + OrderBuilder child_builder; + bool fake_detached_child; + bool supports_hedge; +}; -BookAlgo::BookAlgo() : _services(nullptr), _def(), _state(), - _child_builder(), _child(), _child_state(), - _fake_detached_child(false), - _supports_hedge(false), - _hedge_builder(), _hedge(), _hedge_state() +BookAlgo::BookAlgo() : me(new PImpl()), + _def(), _state(), + _child(), _child_state(), + _hedges(), _hedges_state() { } @@ -28,18 +39,19 @@ const api::orderman::OrderDefinition& BookAlgo::definition() const void BookAlgo::on_init_new(const api::orderman::OrderDefinition& def, const PreActivationOrderServices &services) { - _services = nullptr; + me->services = nullptr; _def = def; OrderDefinition child_def = def; setup_child(def, services, child_def); - _child_builder = OrderBuilder(key(), child_def, services, 1); + me->child_builder = OrderBuilder(key(), child_def, services, 1); OrderDefinition hedge_def = def; - _supports_hedge = setup_hedge(def, services, hedge_def); - if(_supports_hedge) + me->supports_hedge = setup_hedge(def, services, hedge_def); + if(me->supports_hedge) _hedge_builder = OrderBuilder(key(), hedge_def, services, 4); - + + _tick_size = services.sec_db.resolve(SecurityKey(def.security_key()))->contract_spec().low_tick(); transition(ORDER_STATUS_INACTIVE); } @@ -78,15 +90,15 @@ void BookAlgo::on_init_recovered(const api::orderman::OrderRecord& rec, void BookAlgo::on_activate(Price p, Quantity q, OrderServices& services) { - bts_assert(!_services); - _services = &services; - _child_builder.activate(services); - if(_supports_hedge) + bts_assert(!me->services); + me->services = &services; + me->child_builder.activate(services); + if(me->supports_hedge) _hedge_builder.activate(services); switch (_state.status()) { case ORDER_STATUS_INACTIVE: - _child = _child_builder.build(); + _child = me->child_builder.build(); _state.set_price(p.value()); _state.set_quantity(q.value()); services.child_updates.sub(key(), @@ -132,7 +144,7 @@ void BookAlgo::on_update(Price p, Quantity q) case ORDER_STATUS_WORKING: _state.set_price(p.value()); _state.set_quantity(q.value()); - if(!_fake_detached_child) + if(!me->fake_detached_child) _child.update(p,q); break; case ORDER_STATUS_PENDING_WORKING: @@ -189,14 +201,10 @@ void BookAlgo::on_cancel() transition(ORDER_STATUS_CANCELED); break; case ORDER_STATUS_WORKING: - if(!_fake_detached_child) + if(!me->fake_detached_child) _child.cancel(); - bts_assert(_hedge.size() == _hedge_state.size()); - for(const auto& i : _hedge_state) - { - if(i.second.status() == ORDER_STATUS_WORKING) - _hedge[i.first].crack(); - } + for(auto& i : _hedges) + i.crack(); transition(ORDER_STATUS_CANCELED); break; case ORDER_STATUS_PENDING_WORKING: @@ -245,10 +253,10 @@ void BookAlgo::transition(api::orderman::OrderStatus new_status, std::string msg void BookAlgo::on_child_order_update(const OrderStateUpdateEvent& ev) { - if(_fake_detached_child) + if(me->fake_detached_child) return; if(ev.key != _child.key()) - _hedge_state[ev.key] = ev.state; + _hedges_state[ev.key] = ev.state; else { api::orderman::OrderState orig_state = _child_state; @@ -260,11 +268,13 @@ void BookAlgo::on_child_order_update(const OrderStateUpdateEvent& ev) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: - send_hedge(orig_state, ev); + if(me->supports_hedge) + send_hedge(orig_state, ev); break; case ORDER_STATUS_COMPLETED: transition(ORDER_STATUS_COMPLETED); - send_hedge(orig_state, ev); + if(me->supports_hedge) + send_hedge(orig_state, ev); break; case ORDER_STATUS_DISCONNECTED: @@ -306,7 +316,29 @@ void BookAlgo::report_state() merged_state.set_filled_quantity(_child_state.filled_quantity()); merged_state.set_last_price(_child_state.last_price()); merged_state.set_avg_price(_child_state.avg_price()); - _services->report_state(merged_state); + me->services->report_state(merged_state); +} + +void BookAlgo::payup(const md::PriceSize& opposite, uint32_t cross_ticks) +{ + double new_price = opposite.price() + _tick_size * cross_ticks; + _child.update(Price(new_price), Quantity(_state.quantity())); + report_state(); +} + +void BookAlgo::paydown(const md::PriceSize& opposite, uint32_t cross_ticks) +{ + double new_price = opposite.price() - _tick_size * cross_ticks; + _child.update(Price(new_price), Quantity(_state.quantity())); + report_state(); +} + +void BookAlgo::detach() +{ + me->fake_detached_child = true; + _child.crack(); + transition(ORDER_STATUS_CANCELED); + report_state(); } void BookAlgo::on_book_update(const bts::orderman::BookUpdateEvent&) {} diff --git a/src/server/sparkd/orderman/orders/book_algos/BookAlgo.h b/src/server/sparkd/orderman/orders/book_algos/BookAlgo.h index 340b5f981..89d46800f 100644 --- a/src/server/sparkd/orderman/orders/book_algos/BookAlgo.h +++ b/src/server/sparkd/orderman/orders/book_algos/BookAlgo.h @@ -38,22 +38,28 @@ protected: virtual void on_book_update(const bts::orderman::BookUpdateEvent&); virtual void transition(api::orderman::OrderStatus new_state, std::string = ""); - virtual void report_state(); + virtual void report_state(); -protected: - OrderServices* _services; + virtual void payup(const md::PriceSize&, uint32_t cross_ticks = 0); + virtual void paydown(const md::PriceSize&, uint32_t cross_ticks = 0); + void detach(); + +private: + struct PImpl; + std::unique_ptr me; + +protected: api::orderman::OrderDefinition _def; api::orderman::OrderState _state; - - OrderBuilder _child_builder; + ChildOrder _child; api::orderman::OrderState _child_state; - bool _fake_detached_child; - bool _supports_hedge; - OrderBuilder _hedge_builder; - boost::container::flat_map _hedge; - boost::container::flat_map _hedge_state; + OrderBuilder _hedge_builder; + std::vector _hedges; + using HedgeStateMap = boost::container::flat_map; + HedgeStateMap _hedges_state; + double _tick_size; }; }} diff --git a/src/server/sparkd/orderman/orders/book_algos/JoinOrder.cpp b/src/server/sparkd/orderman/orders/book_algos/JoinOrder.cpp new file mode 100644 index 000000000..afdd1a406 --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/JoinOrder.cpp @@ -0,0 +1,166 @@ +#include "JoinOrder.h" + +#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" +#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include "lib/utils/PBUtils.h" +#include + +namespace bts { +namespace orderman { + +using namespace api::orderman; + +struct JoinOrder::PImpl +{ + PImpl() {} + + uint32_t min_tick_offset_on_deploy; + spark::QuantityMeasure join_threshold; + bool enable_hedge; + int hedge_ticks; + OrderDefinition hedge_def; + + md::PriceSize opposite_at_inception; + bool did_join; +}; + + +JoinOrder::JoinOrder() : me(new PImpl()) {} + +JoinOrder::~JoinOrder() {} + +void JoinOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) +{ + _state.mutable_join(); + auto const &join_def = parent_def.custom_def().join(); + _child_state.set_status(ORDER_STATUS_INACTIVE); + *child_def.mutable_custom_def() = join_def.child(); + + me->min_tick_offset_on_deploy = join_def.min_tick_offset_on_deploy(); + me->join_threshold = join_def.join_threshold(); + me->enable_hedge = join_def.enable_hedge(); + me->hedge_ticks = join_def.hedge_ticks(); + me->did_join = false; +} + +bool JoinOrder::setup_hedge(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& hedge_def) +{ + auto const &join_def = parent_def.custom_def().join(); + if(me->enable_hedge && join_def.has_hedge()) + { + *hedge_def.mutable_custom_def() = join_def.hedge(); + if(_def.side() == api::SIDE_BUY) + hedge_def.set_side(api::SIDE_SELL); + else + hedge_def.set_side(api::SIDE_BUY); + return true; + } + else + return false; +} + +void JoinOrder::send_hedge(const api::orderman::OrderState& orig_state, const OrderStateUpdateEvent& new_state) +{ + uint32_t qty = new_state.state.filled_quantity() - orig_state.filled_quantity(); + if(qty > 0) + { + double prx = new_state.state.last_price(); + if(_def.side() == api::SIDE_BUY) //if this is a buy, I'm going to sell my hedge, nticks higher than the fill price + prx = prx + _tick_size * me->hedge_ticks; + else + prx = prx - _tick_size * me->hedge_ticks; + + auto hedge = _hedge_builder.build(); + _hedges.push_back(std::move(hedge)); + _hedges[_hedges.size()-1].activate(Price(prx), Quantity(qty)); + } +} + +void JoinOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) +{ + switch (_state.status()) + { + case ORDER_STATUS_WORKING: + switch (_child_state.status()) + { + case ORDER_STATUS_INACTIVE: + { + if(_def.side() == api::SIDE_BUY) + me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; + else + me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; + + LOG(OrderMan, Info, "JoinOrder order {} launching child {}", key().value(), _child.key().value()); + _child.activate(Price(_state.price()), Quantity(_state.quantity())); + _child_state.set_status(ORDER_STATUS_PENDING_WORKING); + transition(ORDER_STATUS_WORKING); + report_state(); + } + break; + case ORDER_STATUS_WORKING: + { + Quantity thresh = SpreaderUtils::_quantity_threshold(me->join_threshold, Quantity(_state.quantity())); + if(_def.side() == api::SIDE_BUY) + { + const auto& same = book.book.side(api::Side::SIDE_BUY)[0]; + if(me->opposite_at_inception.price() > same.price()) + {} + else if(!me->did_join && same.size() >= thresh.value()) + { + me->did_join = true; + _child.update(Price(same.price()), Quantity(_state.quantity())); + report_state(); + } + } + else + { + const auto& same = book.book.side(api::Side::SIDE_SELL)[0]; + if(me->opposite_at_inception.price() < same.price()) + {} + else if(!me->did_join && same.size() >= thresh.value()) + { + me->did_join = true; + _child.update(Price(same.price()), Quantity(_state.quantity())); + report_state(); + } + } + } + break; + + case ORDER_STATUS_PENDING_WORKING: + break; + + // child cannot be in any of these states if we are in the working state + case ORDER_STATUS_DISCONNECTED: + case ORDER_STATUS_ERROR: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } + break; + + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case ORDER_STATUS_ERROR: + break; + + case ORDER_STATUS_INACTIVE: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_PENDING_WORKING: + case ORDER_STATUS_DISCONNECTED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } +} + +} +} + diff --git a/src/server/sparkd/orderman/orders/book_algos/JoinOrder.h b/src/server/sparkd/orderman/orders/book_algos/JoinOrder.h new file mode 100644 index 000000000..61f7cf04b --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/JoinOrder.h @@ -0,0 +1,30 @@ +#pragma once + +#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h" + +namespace bts { +namespace orderman { + +class OrderStateUpdateEvent; +class BookUpdateEvent; + +class JoinOrder : public BookAlgo +{ +public: + JoinOrder(); + virtual ~JoinOrder(); + +protected: + void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) override; + bool setup_hedge(const api::orderman::OrderDefinition& parent, const PreActivationOrderServices&, + api::orderman::OrderDefinition&) override; + void send_hedge(const api::orderman::OrderState&, const OrderStateUpdateEvent&) override; + void on_book_update(const bts::orderman::BookUpdateEvent&) override; + +private: + struct PImpl; + std::unique_ptr me; +}; + +}} diff --git a/src/server/sparkd/orderman/orders/book_algos/LeanOrder.cpp b/src/server/sparkd/orderman/orders/book_algos/LeanOrder.cpp new file mode 100644 index 000000000..c56246f89 --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/LeanOrder.cpp @@ -0,0 +1,156 @@ +#include "LeanOrder.h" + +#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" +#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include "lib/utils/PBUtils.h" +#include + +namespace bts { +namespace orderman { + +using namespace api::orderman; + +struct LeanOrder::PImpl +{ + PImpl() {} + + spark::QuantityMeasure cross_threshold; + uint32_t max_chase_ticks; + + md::PriceSize opposite_at_inception; +}; + + +LeanOrder::LeanOrder() : me(new PImpl()) {} + +LeanOrder::~LeanOrder() {} + +void LeanOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) +{ + _state.mutable_lean(); + auto const &lean_def = parent_def.custom_def().lean(); + _child_state.set_status(ORDER_STATUS_INACTIVE); + *child_def.mutable_custom_def() = lean_def.child(); + + me->cross_threshold = lean_def.cross_threshold(); + me->max_chase_ticks = lean_def.max_chase_ticks(); +} + +void LeanOrder::payup(const md::PriceSize& opposite, uint32_t cross_ticks) +{ + double new_price = opposite.price() + _tick_size * cross_ticks; + double limit = me->opposite_at_inception.price() + _tick_size * me->max_chase_ticks; + if(new_price <= limit) + _child.update(Price(new_price), Quantity(_state.quantity())); + else + { + _child.update(Price(limit), Quantity(_state.quantity())); + detach(); + } + report_state(); +} + +void LeanOrder::paydown(const md::PriceSize& opposite, uint32_t cross_ticks) +{ + double new_price = opposite.price() - _tick_size * cross_ticks; + double limit = me->opposite_at_inception.price() - _tick_size * me->max_chase_ticks; + if(new_price >= limit) + _child.update(Price(new_price), Quantity(_state.quantity())); + else + { + _child.update(Price(limit), Quantity(_state.quantity())); + detach(); + } + report_state(); +} + + +void LeanOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) +{ + switch (_state.status()) + { + case ORDER_STATUS_WORKING: + switch (_child_state.status()) + { + case ORDER_STATUS_INACTIVE: + { + if(_def.side() == api::SIDE_BUY) + me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; + else + me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; + + LOG(OrderMan, Info, "LeanOrder order {} launching child {}", key().value(), _child.key().value()); + _child.activate(Price(_state.price()), Quantity(_state.quantity())); + _child_state.set_status(ORDER_STATUS_PENDING_WORKING); + transition(ORDER_STATUS_WORKING); + report_state(); + } + break; + case ORDER_STATUS_WORKING: + { + Quantity thresh = SpreaderUtils::_quantity_threshold(me->cross_threshold, Quantity(_state.quantity())); + if(_def.side() == api::SIDE_BUY) + { + const auto& opposite = book.book.side(api::Side::SIDE_SELL)[0]; + if(opposite.price() < me->opposite_at_inception.price()) + me->opposite_at_inception = opposite; //your lucky day, try to get luckier + else if(opposite.price() > me->opposite_at_inception.price()) + payup(opposite); //you missed, payup + else + { + if(opposite.size() <= thresh.value()) + payup(opposite); + } + } + else + { + const auto& opposite = book.book.side(api::Side::SIDE_BUY)[0]; + if(opposite.price() > me->opposite_at_inception.price()) + me->opposite_at_inception = opposite; + else if(opposite.price() < me->opposite_at_inception.price()) + paydown(opposite); + else + { + if(opposite.size() <= thresh.value()) + paydown(opposite); + } + } + } + break; + + case ORDER_STATUS_PENDING_WORKING: + break; + + // child cannot be in any of these states if we are in the working state + case ORDER_STATUS_DISCONNECTED: + case ORDER_STATUS_ERROR: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } + break; + + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case ORDER_STATUS_ERROR: + break; + + case ORDER_STATUS_INACTIVE: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_PENDING_WORKING: + case ORDER_STATUS_DISCONNECTED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } +} + +} +} + diff --git a/src/server/sparkd/orderman/orders/book_algos/LeanOrder.h b/src/server/sparkd/orderman/orders/book_algos/LeanOrder.h new file mode 100644 index 000000000..41f5a643e --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/LeanOrder.h @@ -0,0 +1,30 @@ +#pragma once + +#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h" + +namespace bts { +namespace orderman { + +class OrderStateUpdateEvent; +class BookUpdateEvent; + +class LeanOrder : public BookAlgo +{ +public: + LeanOrder(); + virtual ~LeanOrder(); + +protected: + void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) override; + void on_book_update(const bts::orderman::BookUpdateEvent&) override; +private: + void payup(const md::PriceSize& opposite, uint32_t cross_ticks = 0) override; + void paydown(const md::PriceSize& opposite, uint32_t cross_ticks = 0) override; + +private: + struct PImpl; + std::unique_ptr me; +}; + +}} diff --git a/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp b/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp index 30f82d1e8..32b813547 100644 --- a/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp +++ b/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp @@ -14,13 +14,12 @@ struct TickOrder::PImpl { PImpl() {} - uint32_t min_ticks_off_on_deploy; + uint32_t min_tick_offset_on_deploy; spark::QuantityMeasure cross_threshold; uint32_t cross_ticks; uint32_t max_chase_ticks; bool pay_up_on_toward; - double tick_size; md::PriceSize opposite_at_inception; }; @@ -29,7 +28,7 @@ TickOrder::TickOrder() : me(new PImpl()) {} TickOrder::~TickOrder() {} -void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices& svc, +void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, api::orderman::OrderDefinition& child_def) { _state.mutable_tick(); @@ -37,20 +36,18 @@ void TickOrder::setup_child(const api::orderman::OrderDefinition& parent_def, co _child_state.set_status(ORDER_STATUS_INACTIVE); *child_def.mutable_custom_def() = tick_def.child(); - me->min_ticks_off_on_deploy = tick_def.min_ticks_off_on_deploy(); + me->min_tick_offset_on_deploy = tick_def.min_tick_offset_on_deploy(); me->cross_threshold = tick_def.cross_threshold(); me->cross_ticks = tick_def.cross_ticks(); me->max_chase_ticks = tick_def.max_chase_ticks(); me->cross_threshold = tick_def.cross_threshold(); - me->pay_up_on_toward = tick_def.pay_up_on_toward(); - - me->tick_size = svc.sec_db.resolve(SecurityKey(parent_def.security_key()))->contract_spec().low_tick(); + me->pay_up_on_toward = tick_def.pay_up_on_toward(); } -void TickOrder::payup(const md::PriceSize& opposite) +void TickOrder::payup(const md::PriceSize& opposite, uint32_t cross_ticks) { - double new_price = opposite.price() + me->tick_size * me->cross_ticks; - double limit = me->opposite_at_inception.price() + me->tick_size * me->max_chase_ticks; + double new_price = opposite.price() + _tick_size * cross_ticks; + double limit = me->opposite_at_inception.price() + _tick_size * me->max_chase_ticks; if(new_price <= limit) _child.update(Price(new_price), Quantity(_state.quantity())); else @@ -61,10 +58,10 @@ void TickOrder::payup(const md::PriceSize& opposite) report_state(); } -void TickOrder::paydown(const md::PriceSize& opposite) +void TickOrder::paydown(const md::PriceSize& opposite, uint32_t cross_ticks) { - double new_price = opposite.price() - me->tick_size * me->cross_ticks; - double limit = me->opposite_at_inception.price() - me->tick_size * me->max_chase_ticks; + double new_price = opposite.price() - _tick_size * cross_ticks; + double limit = me->opposite_at_inception.price() - _tick_size * me->max_chase_ticks; if(new_price >= limit) _child.update(Price(new_price), Quantity(_state.quantity())); else @@ -75,14 +72,6 @@ void TickOrder::paydown(const md::PriceSize& opposite) report_state(); } -void TickOrder::detach() -{ - _fake_detached_child = true; - _child.crack(); - transition(ORDER_STATUS_CANCELED); - report_state(); -} - void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) { switch (_state.status()) @@ -95,8 +84,8 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) if(_def.side() == api::SIDE_BUY) { me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; - double max_price = me->opposite_at_inception.price() - me->tick_size * me->min_ticks_off_on_deploy; - if(me->min_ticks_off_on_deploy && _state.price() > max_price) + double max_price = me->opposite_at_inception.price() - _tick_size * me->min_tick_offset_on_deploy; + if(me->min_tick_offset_on_deploy && _state.price() > max_price) { LOG(OrderMan, Info, "TickOrder order {} repricing child {}", key().value(), _child.key().value()); _state.set_price(max_price); @@ -112,8 +101,8 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) else { me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; - double min_price = me->opposite_at_inception.price() + me->tick_size * me->min_ticks_off_on_deploy; - if(me->min_ticks_off_on_deploy && _state.price() < min_price) + double min_price = me->opposite_at_inception.price() + _tick_size * me->min_tick_offset_on_deploy; + if(me->min_tick_offset_on_deploy && _state.price() < min_price) { LOG(OrderMan, Info, "TickOrder order {} repricing child {}", key().value(), _child.key().value()); _state.set_price(min_price); @@ -138,16 +127,16 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) if(opposite.price() < me->opposite_at_inception.price()) { if(me->pay_up_on_toward) - payup(opposite); + payup(opposite, me->cross_ticks); else detach(); } else if(opposite.price() > me->opposite_at_inception.price()) - payup(opposite); + payup(opposite, me->cross_ticks); else { if(opposite.size() <= thresh.value()) - payup(opposite); + payup(opposite, me->cross_ticks); } } else @@ -156,16 +145,16 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) if(opposite.price() > me->opposite_at_inception.price()) { if(me->pay_up_on_toward) - paydown(opposite); + paydown(opposite, me->cross_ticks); else detach(); } else if(opposite.price() < me->opposite_at_inception.price()) - paydown(opposite); + paydown(opposite, me->cross_ticks); else { if(opposite.size() <= thresh.value()) - paydown(opposite); + paydown(opposite, me->cross_ticks); } } } diff --git a/src/server/sparkd/orderman/orders/book_algos/TickOrder.h b/src/server/sparkd/orderman/orders/book_algos/TickOrder.h index bc541fb57..326f820cd 100644 --- a/src/server/sparkd/orderman/orders/book_algos/TickOrder.h +++ b/src/server/sparkd/orderman/orders/book_algos/TickOrder.h @@ -18,11 +18,9 @@ protected: void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, api::orderman::OrderDefinition& child_def) override; void on_book_update(const bts::orderman::BookUpdateEvent&) override; - private: - void payup(const md::PriceSize&); - void paydown(const md::PriceSize&); - void detach(); + void payup(const md::PriceSize& opposite, uint32_t cross_ticks) override; + void paydown(const md::PriceSize& opposite, uint32_t cross_ticks) override; private: struct PImpl; diff --git a/src/server/sparkd/orderman/orders/book_algos/TopOrder.cpp b/src/server/sparkd/orderman/orders/book_algos/TopOrder.cpp new file mode 100644 index 000000000..cdaf93fe0 --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/TopOrder.cpp @@ -0,0 +1,127 @@ +#include "TopOrder.h" + +#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" +#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include "lib/utils/PBUtils.h" +#include + +namespace bts { +namespace orderman { + +using namespace api::orderman; + +struct TopOrder::PImpl +{ + PImpl() {} + + spark::QuantityMeasure cross_threshold; + uint32_t max_chase_ticks; + + md::PriceSize opposite_at_inception; +}; + + +TopOrder::TopOrder() : me(new PImpl()) {} + +TopOrder::~TopOrder() {} + +void TopOrder::setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) +{ + _state.mutable_lean(); + auto const &lean_def = parent_def.custom_def().lean(); + _child_state.set_status(ORDER_STATUS_INACTIVE); + *child_def.mutable_custom_def() = lean_def.child(); + + me->cross_threshold = lean_def.cross_threshold(); + me->max_chase_ticks = lean_def.max_chase_ticks(); +} + +void TopOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) +{ + switch (_state.status()) + { + case ORDER_STATUS_WORKING: + switch (_child_state.status()) + { + case ORDER_STATUS_INACTIVE: + { + if(_def.side() == api::SIDE_BUY) + me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; + else + me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; + + LOG(OrderMan, Info, "TopOrder order {} launching child {}", key().value(), _child.key().value()); + _child.activate(Price(_state.price()), Quantity(_state.quantity())); + _child_state.set_status(ORDER_STATUS_PENDING_WORKING); + transition(ORDER_STATUS_WORKING); + report_state(); + } + break; + case ORDER_STATUS_WORKING: + { + Quantity thresh = SpreaderUtils::_quantity_threshold(me->cross_threshold, Quantity(_state.quantity())); + if(_def.side() == api::SIDE_BUY) + { + const auto& opposite = book.book.side(api::Side::SIDE_SELL)[0]; + if(opposite.price() < me->opposite_at_inception.price()) + me->opposite_at_inception = opposite; //your lucky day, try to get luckier + else if(opposite.price() > me->opposite_at_inception.price()) + payup(opposite); //you missed, payup + else + { + if(opposite.size() <= thresh.value()) + payup(opposite); + } + } + else + { + const auto& opposite = book.book.side(api::Side::SIDE_BUY)[0]; + if(opposite.price() > me->opposite_at_inception.price()) + me->opposite_at_inception = opposite; + else if(opposite.price() < me->opposite_at_inception.price()) + paydown(opposite); + else + { + if(opposite.size() <= thresh.value()) + paydown(opposite); + } + } + } + break; + + case ORDER_STATUS_PENDING_WORKING: + break; + + // child cannot be in any of these states if we are in the working state + case ORDER_STATUS_DISCONNECTED: + case ORDER_STATUS_ERROR: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } + break; + + case ORDER_STATUS_COMPLETED: + case ORDER_STATUS_CANCELED: + case ORDER_STATUS_ERROR: + break; + + case ORDER_STATUS_INACTIVE: + case ORDER_STATUS_REJECTED_BY_SPARK: + case ORDER_STATUS_PENDING_WORKING: + case ORDER_STATUS_DISCONNECTED: + case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: + case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: + bts_assert(false); + break; + } +} + +} +} + diff --git a/src/server/sparkd/orderman/orders/book_algos/TopOrder.h b/src/server/sparkd/orderman/orders/book_algos/TopOrder.h new file mode 100644 index 000000000..e1b63d7db --- /dev/null +++ b/src/server/sparkd/orderman/orders/book_algos/TopOrder.h @@ -0,0 +1,27 @@ +#pragma once + +#include "server/sparkd/orderman/orders/book_algos/BookAlgo.h" + +namespace bts { +namespace orderman { + +class OrderStateUpdateEvent; +class BookUpdateEvent; + +class TopOrder : public BookAlgo +{ +public: + TopOrder(); + virtual ~TopOrder(); + +protected: + void setup_child(const api::orderman::OrderDefinition& parent_def, const PreActivationOrderServices&, + api::orderman::OrderDefinition& child_def) override; + void on_book_update(const bts::orderman::BookUpdateEvent&) override; + +private: + struct PImpl; + std::unique_ptr me; +}; + +}}