Merge branch 'DJ_ICE_space_bar_recenter' into DJ_ICE

Updated docker
Added a few build tools.
2020-06-14 21:08:51 -04:00 · 2020-06-14 15:23:18 -04:00 · 2020-06-14 15:21:55 -04:00 · 2020-06-12 17:05:53 -05:00 · 2020-06-12 13:16:57 -05:00 · 2020-06-12 08:44:36 -04:00
105 changed files with 3049 additions and 1634 deletions
@@ -55,7 +55,7 @@ else ()
    COMMAND ln ARGS -sf ${CMAKE_BINARY_DIR}/web ${CMAKE_BINARY_DIR}/server
    COMMAND ln ARGS -sf ${CMAKE_BINARY_DIR}/data_files ${CMAKE_BINARY_DIR}/server
    COMMAND ln ARGS -sf ${CMAKE_BINARY_DIR}/src/lib/libspark.so ${CMAKE_BINARY_DIR}/server
-    COMMAND ln ARGS -sf ${EXTERNALS_ROOT}/lib/Release/libOnixS.IceImpactMulticastPriceFeedHandlerCpp.so.3.13.0.0 ${CMAKE_BINARY_DIR}/server
+    COMMAND ln ARGS -sf ${EXTERNALS_ROOT}/lib/Release/libOnixS.IceImpactMulticastPriceFeedHandlerCpp.so.3.16.0.0 ${CMAKE_BINARY_DIR}/server
    COMMAND ln ARGS -sf ${EXTERNALS_ROOT}/lib/Release/libACE-5.7.5.so ${CMAKE_BINARY_DIR}/server
    COMMAND mkdir ARGS -p ${CMAKE_BINARY_DIR}/server/plugins
    COMMENT "Creating server runtime layout"
@@ -1 +1,731 @@
-+++
title = "Release notes"
weight = 3
sort_by = "weight"
insert_anchor_links = "right"
+++
## 2.16.2
### User Visible Change
  - Synthetic creation dialog has a "fractional" checkbox next to the tick settings.  Users may uncheck this box to enter integer tick sizes, so the synthetic security's prices will be displayed without decimals, or fractional units.
## 2.16.1
### Bug Fixes
  - OrderBook's algo state parameters (in the panel on the right side) are sorted alphabetically
## 2.16.0
### Bug Fixes
  - Solved an issue that could result in incorrect ladder levels
  - Solved an issue that could lead to incorrect routing of orders in the event of certain MSGW changes
### API Changes
  - Add C# client side API samples for order entry, position monitoring and market data observation

## 2.15.10
### Bug Fixes
  - Solved an issue that could cause the user interface to fail when playing some alert sounds
### API Changes
  - Added settlement and position information to the API
  - Added the ability for user algos to report custom state to the user interface
  - Added the ability for algos to discover all active securities
## 2.15.3
### Bug Fixes
  - Fixed a bug where some CME currency spreads exhibited incorrect tick values
## 2.15.2
### User Visible Changes  
  - Excel RTD plugin can now receive ICE market data
## 2.15.1
### Bug Fixes
  - Fixed a FIX log parsing issue that resulted in exchange gateway logon problems
## 2.15.0
### User Visible Changes  
  - Added ability to hide Ladder status messages via Ladder Settings -> Left Panel tab -> Show/Hide groupbox -> Status Message
  - Synthetic cloning now allows for any parameter to be changed, including tick size and leg contracts
  - Added ability to import synthetics from a CSV file; see our manual for further details on this process
  - Reduced Iceberg reloading latency
### Bug Fixes
  - Fixed a bug where highlighted fills could lose their highlight status
  - Fixed a bug where the (Mini) OrderBook PIQ could be displaying an old value

## 2.14.3
### Bug Fixes
  - Fixed a bug regarding ICE logon messaging
  
## 2.14.2
### Bug Fixes
  - Fixed a bug regarding ICE messaging
  
## 2.14.1
### Bug Fixes
  - Fixed a bug regarding ICE logon authentication
  
## 2.14.0
### User Visible Changes  
  - All ladders can now be recentered by (shift or alt) + double clicking over the Price column in a ladder
  - Added a Max Order Quantity setting to the Safety Checks tab on the Ladder settings. This setting allows for a user-defined maximum order quantity.
  - Added a Price Display Format setting to the Market Price and Size Display tab on the Ladder settings. This setting allows for price levels in the ladder to be displayed without a decimal separator.
  - Synthetic instrument creation with 3 legs no longer defaults to butterfly quantites
### Bug Fixes
  - Fixed an issue where market transition were not observed by IAlgoOrder
  - Fixed a bug in error reporting
  - Fixed a bug in the PnL window where specifying a certain grouping order would lead to a UI failure

## 2.13.0
### User Visible Changes  
  - Added the name of the spreader to the parent algo badge (for spreader child orders), in the fills, orderbook and floating orderbook windows
  - Added support for sounds for new orders
  - Added a new quoting throttle parameter for the spreader, that throttles quotes that are moving toward the inside market but are still a configurable number of ticks away
  - Enabled the ladder to remember the left panel scroll position across front end restarts
### Bug Fixes
  - Fixed the local fills window so that it does not show the admin fills
  - Removed the deleted accounts from the ladder accounts dropdown
  - Fixed the orderbook price for iceberg of spreaders
  
## 2.12.0
### User Visible Changes
  - Added support for ICE market data and order execution
### Internal Changes
  - Lots of permission / admin changes to facilitate ICE

## 2.11.0
### User Visible Changes
  - Fixed fills form time filter to also apply to SOD fills
  - Addressed an issue that could prevent the web Admin UI from displaying over slow HTTP connections
  - Removed the option to enter manual spread fills
  - Fixed an issue that could cause erroneous fill account attribution in the event of a crash
### Internal Changes
  - Added support for tag 1031. Currently defaults to Y, can it be override through config.
  - To facilitate support, allowed the bts user to view and edit algos from all other users 
  - Improved system tests
  - Improved log messages in UI to include dispatcher thread name
  - Added support for Windows core dumps in the UI
  
## 2.10.0
### User Visible Changes
  - Fills now include information about the algo that originated the fill
  - A new, more powerful PnL form is now available
### API Changes
  - Added security state information (pre open, halted, normal, closed, etc)
### Bug Fixes
  - Brought back the "select all" check box in the mini order book
  - Fixed an issue in the market data subsyLine truncated
+++
+title = "Release notes"
+weight = 3
+sort_by = "weight"
+insert_anchor_links = "right"
+++
+## 2.16.2
+### User Visible Change
+  - Synthetic creation dialog has a "fractional" checkbox next to the tick settings.  Users may uncheck this box to enter integer tick sizes, so the synthetic security's prices will be displayed without decimals, or fractional units.
+## 2.16.1
+### Bug Fixes
+  - OrderBook's algo state parameters (in the panel on the right side) are sorted alphabetically
+## 2.16.0
+### Bug Fixes
+  - Solved an issue that could result in incorrect ladder levels
+  - Solved an issue that could lead to incorrect routing of orders in the event of certain MSGW changes
+### API Changes
+  - Add C# client side API samples for order entry, position monitoring and market data observation
+
+## 2.15.10
+### Bug Fixes
+  - Solved an issue that could cause the user interface to fail when playing some alert sounds
+### API Changes
+  - Added settlement and position information to the API
+  - Added the ability for user algos to report custom state to the user interface
+  - Added the ability for algos to discover all active securities
+## 2.15.3
+### Bug Fixes
+  - Fixed a bug where some CME currency spreads exhibited incorrect tick values
+## 2.15.2
+### User Visible Changes  
+  - Excel RTD plugin can now receive ICE market data
+## 2.15.1
+### Bug Fixes
+  - Fixed a FIX log parsing issue that resulted in exchange gateway logon problems
+## 2.15.0
+### User Visible Changes  
+  - Added ability to hide Ladder status messages via Ladder Settings -> Left Panel tab -> Show/Hide groupbox -> Status Message
+  - Synthetic cloning now allows for any parameter to be changed, including tick size and leg contracts
+  - Added ability to import synthetics from a CSV file; see our manual for further details on this process
+  - Reduced Iceberg reloading latency
+### Bug Fixes
+  - Fixed a bug where highlighted fills could lose their highlight status
+  - Fixed a bug where the (Mini) OrderBook PIQ could be displaying an old value
+
+## 2.14.3
+### Bug Fixes
+  - Fixed a bug regarding ICE logon messaging
+  
+## 2.14.2
+### Bug Fixes
+  - Fixed a bug regarding ICE messaging
+  
+## 2.14.1
+### Bug Fixes
+  - Fixed a bug regarding ICE logon authentication
+  
+## 2.14.0
+### User Visible Changes  
+  - All ladders can now be recentered by (shift or alt) + double clicking over the Price column in a ladder
+  - Added a Max Order Quantity setting to the Safety Checks tab on the Ladder settings. This setting allows for a user-defined maximum order quantity.
+  - Added a Price Display Format setting to the Market Price and Size Display tab on the Ladder settings. This setting allows for price levels in the ladder to be displayed without a decimal separator.
+  - Synthetic instrument creation with 3 legs no longer defaults to butterfly quantites
+### Bug Fixes
+  - Fixed an issue where market transition were not observed by IAlgoOrder
+  - Fixed a bug in error reporting
+  - Fixed a bug in the PnL window where specifying a certain grouping order would lead to a UI failure
+
+## 2.13.0
+### User Visible Changes  
+  - Added the name of the spreader to the parent algo badge (for spreader child orders), in the fills, orderbook and floating orderbook windows
+  - Added support for sounds for new orders
+  - Added a new quoting throttle parameter for the spreader, that throttles quotes that are moving toward the inside market but are still a configurable number of ticks away
+  - Enabled the ladder to remember the left panel scroll position across front end restarts
+### Bug Fixes
+  - Fixed the local fills window so that it does not show the admin fills
+  - Removed the deleted accounts from the ladder accounts dropdown
+  - Fixed the orderbook price for iceberg of spreaders
+  
+## 2.12.0
+### User Visible Changes
+  - Added support for ICE market data and order execution
+### Internal Changes
+  - Lots of permission / admin changes to facilitate ICE
+
+## 2.11.0
+### User Visible Changes
+  - Fixed fills form time filter to also apply to SOD fills
+  - Addressed an issue that could prevent the web Admin UI from displaying over slow HTTP connections
+  - Removed the option to enter manual spread fills
+  - Fixed an issue that could cause erroneous fill account attribution in the event of a crash
+### Internal Changes
+  - Added support for tag 1031. Currently defaults to Y, can it be override through config.
+  - To facilitate support, allowed the bts user to view and edit algos from all other users 
+  - Improved system tests
+  - Improved log messages in UI to include dispatcher thread name
+  - Added support for Windows core dumps in the UI
+  
+## 2.10.0
+### User Visible Changes
+  - Fills now include information about the algo that originated the fill
+  - A new, more powerful PnL form is now available
+### API Changes
+  - Added security state information (pre open, halted, normal, closed, etc)
+### Bug Fixes
+  - Brought back the "select all" check box in the mini order book
+  - Fixed an issue in the market data subsystem that on rare occasions could result in a startup crash
+### Internal Changes
+  - Fixed an issue that was stopping us from interpreting SOD times as local rather than GMT
+## 2.9.3
+### Internal Changes
+  - Fixed system test scripts
+## 2.9.2
+### Bug Fixes
+  - Fixed an issue with the exchange simulator that could lead to crossed markets
+## 2.9.1
+### Bug Fixes
+  - Fixed an issue with trade sound alerts, where in some cases the use of a "In Between" condition could lead to a UI failure.
+  - Fixed an issue with the display of the new raw position column in the market view window.
+  - Fixed the popup label that describes the raw position information in the ladder
+### Internal Changes
+  - Avoided shipping production configuration defaults that lead to trying to download a position file for the development sftp server.
+### Api
+  - C# API sample now uses synchronous calls.
+
+## 2.9.0
+### User Visible Changes
+  - Improved Workspace management User Interface
+  - Added the ability to change grid background colors
+  - The Spark UI Window group now has a title in the Windows task bar
+  - Added sound alerts for trade events, see Launcher -> Settings -> Alerts
+  - Allowed composite algos that are attached to existing orders to identify fills that were already present prior to attachment
+  - Added import facilities for GMI position files
+  - Added the ability for risk managers to enter manual fills
+  - Added "raw" P&L columns, that is columns that *do not* include spread legs in their accounting
+### Bug Fixes
+  - Fixed the settings action menu (Load/Save/Reset to Factory)
+  - Fixed the method used to determine if a security is expired to take into account the start of day time
+### API Changes
+  - Fixed an issue in the Client SDK that could lead to occasional failures to connect to the spark server as well as excessive memory usage.
+  - Added the ability for algo orders to distinguish fills existing prior to launch
+### Internal Changes
+  - Changed how we packaged certain third-party components
+  - Added logging of entitlement status
+  - Tagged outgoing orders with sequence number of marketdata or FIX event that triggered them
+## 2.8.3
+### Bug Fixes
+  - Fixed a bug that could cause an OrderBook's Security column filter to be blank
+  - Fixed a bug that could cause a UI failure when clearing a filter selection on a filtering widget
+## 2.8.2
+### Bug Fixes
+  - Added proper display factors for SOM spreads
+  - Fixed a bug that could cause a UI failure when trying to change settings in a synthetic ladder
+## 2.8.1
+### Bug fixes
+  - Fixed an error in the UI grids filtering widget
+## 2.8.0
+### User Visible Changes
+  - Added ProRata and Scratch algos
+  - Ladder badge now grows/shrinks to fill the containing cell
+  - Attached algo parameters are now displayed in the update panel
+  - Fixed a bug where the update panel would show '-' values when only
+    1 order was selected
+  - Fixed a bug that cause cause a failure on startup if the user
+    loaded a workspace with a Ladder that had a dynamic order type
+    selected by default
+  - Increased width of login panel to better show login error messages
+  - Added optional 'Maker/Taker' pricing to Spreader algo
+  - Algo buttons in ladder can now be made to deactivate after launching an algo or remain 'sticky'
+### Internal changes
+  - Made it easier to generate simple UI's for new order types
+### API Changes
+  - Dynamic orders can now use QuantityMeasure parameter types
+
+## 2.7.2
+### User Visible Changes
+  - Changed the login dialog to avoid leaking workspace names from other users.
+  - Added new Splitter algo. From the manual: The splitter is useful
+    for pro-rata markets where you want to vary your exposure
+    independent of the order quantity that you want to fill.  The
+    splitter will complete when the number of fills reaches or exceeds
+    the order quantity but it will put exposed_qty total size on the
+    market. Splitter favors order size over queue position.
+### Internal Changes
+  - Made spark more resilient to lack of connectivity to the CME web site for downloading of templates.
+
+## 2.7.1
+### User Visible Changes
+  - Fixed some issues with the Cover algo, where in some circumstances
+    it would erroneously cancel launched hedges on completion.
+
+## 2.7.0
+### User Visible Changes
+  - Allowed algos to process "in-flight" fills while shutting down
+  - Changed the cover algo to continue to hedge while shutting down
+### API Changes
+  - Changed the API so that algos do not fully terminate until all
+    their children are terminated. Algos that are in the process of
+    shutting down in response to a complete or cancel call will still
+    receive child updates, which they can use to calculate and report
+    an accurate fill count (during this shutdown stage algos cannot
+    create, cancel or update children). A new IAlgoServices method,
+    is_shutting_down(), can be used to determine if an algo is
+    shutting down.
+
+## 2.6.2
+### User Visible Changes
+  - Fixed an issue in the ladder where in some cases the mini order book could not be brought up from a badge
+  - Fixed a rare race condition that could lead to erroneous limit enforcement
+  - Fixed an issue with the margin limits where an error could occur if an account name with more than 12 chars was used
+
+## 2.6.1
+### User Visible Changes
+  - Fixed an issue in the ladder where an error could occur when trying to change ladder settings for the first time
+
+## 2.6.0
+### User Visible Changes
+  - In the ladder made last trade more distinctive when overlayed on the volumn column
+  - In the ladder, corrected display of volume tool tip
+  - In the ladder, changed the consolidation of last trade to consider only the price ignoring aggressor changes
+  - Added an option for the Top Algo to delete itself if within N ticks from top of book
+  - Address a rare issue that could lead to an error report on UI exit
+  - Added margin risk limits
+  - Added the "Offset" algo. Offset prices a child algo at a parameterizable distance from the top of the book
+  - Avoided switching the current account and order type on open ladders when limits are changed
+### Internal Changes
+  - Ensure that admin logins are always allowed to login, regardless of keycode status.
+
+## 2.5.0
+### User Visible Changes
+  - Added loss limit risk check
+  - Made algos, synthetics and user names private so that multiple users can share a single system privately.
+  - Allowed the mini order book defaults for column widths to be changed from the mini order book
+  - Allowed the mini order book to shrink to the minimum size that will be needed to display the selected columns
+  - Improved accuracy of the directional arrow when displaying last trades in the volumn column
+## 2.4.0
+### User Visible Settings
+  - In the ladder, changed the last trade column to accumulate successive trades at the same price
+  - Fixed a bug in the order book where the right side ladder would display the top leve order's security rather then current row's
+  - Added OK, Cancel buttons to the security picker for ladder profiles or sounds
+  - Added ladder settings for the mini order book
+  - Added a safety check to guard against unintentional market crosses
+  - Improved the Queue Holder mode in the spreader:
+     - Added a Show Quantity, allowing the spreader to keep queue position of the trailing orders as Fills (of size Show Qty) happen
+     - Improved spreader performance when in Queue Holder mode
+### Internal changes
+  - Suppressed order callbacks for completed/canceled orders. This should eliminate some bogus error logs by spreader orders.
+  - Addressed a potential concurrency issues with service initialization.
+
+
+## 2.3.0
+### User Visible Changes
+  - Introduced multiple settings profiles for the ladder
+     - This allows multiple standard configuration for the ladder, optionally with security specific variations
+  - Made Cover order more independent from its hedging chidren:
+     - Cover continues to operate even if an hedging child is canceled
+	 - When a cover is canceled it will detach from any running hedging children, instead of canceling them
+  - Changed Lean, Join and Cover algos to hide themselves in the ladder once they have completed their work
+  - Changed manual fills to appear in day PnL rather than in the SOD records
+  - Add buy/sell coloring to fill rows in fills window
+  - Streamlined the mini order book:
+    - Display of the mini order book popup is quicker
+    - Only exchange orders are displayed
+	- Update buttons are only displayed for orders that are under control of an algo with the update applying to the entire algo, not just the exchange order
+    - We can now select multiple rows to attach, detach, update or cancel multiple orders in a batch
+    - A checkbox column has been added to make clearer which rows are selected
+### API Changes
+  - Enhanced the API to allow algos to implement custom cancel handling
+  - Allowed algos to control their visibility in the ladder through the API
+### Internal Changes
+  - Added system requirements to Spark documentation
+  - Implemented keycodes
+  - Temporarily rejected stop and stop limit orders, pending bug fixes
+
+## 2.2.0
+### User Visible Changes
+  - Made our orders easier to spot in MBO display
+  - Changed middle-click on center column to recenter ladder and introduced Alt middle-click on center to bring up the MBO popup
+  - Fixed Net/Absolute radio button in risk admin UI
+  - Fixed double counting of spread legs in limits
+  - Removed expired fills from the system
+  - Improved handling of orders with undiscovered securities
+  - Added feedback to the ladder when the user attempts to middle click on bid/ask columns using an order that does not have parameters
+  - Fixed display of algo studio algo types in order book
+  - Hid net change setting in synthetic ladders
+  - Fixed a number of problems with filtering on the Fills form
+  - On the Lean algo, OnToward and Away are now calculated with respect to the opposite inside market at time of the order launch
+  - Iceberg Spreaders with queue holders are not erroneously cancelled after the first fill
+  - Added security symbol column to fills window
+  - Re-organized ladder settings dialog to make it clearer and easier to use
+
+## 2.1.4
+### User Visible Changes
+  - Fixed handling of cancel button in security picker
+
+## 2.1.3
+### User Visible Changes
+  - Fixed a simulator bug in the handling of 0 sized orders
+
+## 2.2.1
+### User Visible Changes
+  - Fixed order book form exception when display a spreader order for whichs the legs were not present yet
+
+## 2.1.1
+### User Visible Changes
+  - Added PIQ to GLBX Iceberg orders
+  - Corrected handling of stop limit orders
+
+## 2.1.0
+### User Visible Changes
+  - Added support for the GLBX Iceberg order type
+  - Allowed quick algo param edits by middle-clicking on either the bid/ask columns or a "favorite" button
+  - Added support for manual fills, either entered manually or imported from file. Manual fills are used only for P&L purposes, they have no impact on limits
+  - Allowed the LTQ and VAP values to be overlayed on the same ladder column
+  - Added day position information to the ladder
+  - Added PIQ to the mini order book
+  - Fixed a rare bug that could lead to server failure when requesting market data
+  - Fixed a bug that could cause incorrect price displays for certain types of synthetic securities
+
+## 2.0.5
+### User Visible Changes
+  - Fixed a bug in the handling of rejected QHO orders
+  - Implemented stricter position limit enforcement
+  - Fixed a bug that could cause server failure when trying to attach to already attached orders
+
+## 2.0.4
+### User Visible Changes
+  - Fixed performance regression in order manager
+
+### Internal changes
+  - Improved market data diagnostics for bad configurations
+  - Changed market data default buffer size
+
+## 2.0.3
+### Internal changes
+  - Improved backwards compatibility in UI settings
+
+
+## 2.0.2
+### User Visible Changes
+  - Middle click the ladder price column to show the orders for that price level
+  - Middle click the bid or ask column in the ladder no longer sends an order
+
+### Internal changes
+  - Improved market by order performance under heavy load
+  - Fixed a concurrency bug in SIM
+
+## 2.0.0
+### User Visible Changes
+  - Support for attaching and detaching algos to existing orders
+  - Support for display and update of all parameters in running algos
+  - Streamlining of order badge decorations in ladder
+  - New order search/filtering algorithm for order book
+  - Simpler representation of complex algo chains in order book and mini order book
+  - Visual and usability improvements to mini order book
+  - Streamlining of algo parameter dialog in ladder
+  - New spreader queue holder behavior
+  - Visual improvements to the order book
+  - New server side API
+  - Improved admin UI performance
+  - Optimized PIQ rendering
+### Internal changes
+  - Exchange simulator no longer requires daily sequence number reset
+  - Improved MD resilience to corrupted shared memory
+  - Native orders can now buffer updates/cancels when disconnected or pending first acknowledgment
+  - Improved settings manager tool output
+  - Added diagnostics in the event MD memory corruption is detected
+  - Added systems tests for join,lean, iceberg and spreader orders
+  - Made exchange order recovery more resilient in the presence of database loss
+
+## 1.6.2
+### User Visible Changes
+### Exchange simulator
+  - Exchange simulator now now produce position in queue data
+
+## 1.6.0
+### User Visible Changes
+#### New Features
+  - You can now view your order's position in queue in the ladder
+#### Bug Fixes
+  - Fix a bug in the order popup in the ladder which could lead to a crash.
+
+## 1.5.9
+### User Visible Changes
+  - Fix for stunnel connections on Windows 7
+
+## 1.5.8
+### User Visible Changes
+  - Fixed a bug where it was possible to crash the UI by entering an order through the order ticket if Enter was used to dismiss the dialog.
+  - Fixed a spreader reporting bug which could cause the server to crash if an algo was used to control certain types of synthetics
+  - Improved user message when the UI fails to login
+  - Integrated stunnel into UI to make VPN setup unnecessary in unsecured environments.
+## 1.5.7
+### User Visible Changes
+  - New videos have been added to the manual describing the [Algo Studio](./bts_spark/Trading/_index.md#algo-studio) and [Spreader](./bts_spark/Spreader/_index.md)
+  - Fixed a bug that occasionally would cause windows to be position outside the visible screen on startup
+  - Fixed a bug in the order book form that would occasionally cause the Recreate Order option to be unavailable
+  - Added a confirmation step to Cancel All, Cancel Buys and Cancel Sells commands
+  - Fixed Aggressor coloring and ladder high/low coloring in the SIM execution gateway
+  - Added initial support for ICE market data
+  - In an effort to streamline the PnL report we've made the following changes:
+    - The PnL report will by default filter for Futures contracts only
+    - If you wish to see Spread contracts again you may change Security Type column filter
+    - The PnL report will now only show rows in which there is a position (net and/or day)
+    - The Exchange, Start PnL, Total Net Pos, and Total Net PnL columns are now hidden by default
+    - These columns can be restored by toggling their visibility within the PnL's Settings form
+    - A new Traded Today column has been added to the PnL
+      - Filtering on this column will allow a user to restrict the report to only show today's position
+### Internal changes
+  - Improved organization of the shell notification architecture
+  - Added logging to help troubleshoot shell exit hang
+
+## 1.5.6
+### User Visible Changes
+  - Fixed a bug that could cause limits to be erroneously enforced
+  - Improved algo documentation
+  - Changed how the spreader uses net change
+  - Simplified trigger algo user interface
+### Internal changes
+  - Defaulted to not recording sim market data
+  - Improved documentation build
+  - Added additional performance tracing
+
+## 1.5.5
+  - Fixed Market View 'stale working orders' bug
+
+## 1.5.4
+  - Avoided logging when warming up cache
+
+## 1.5.3
+  - Fixed sounds startup issue
+
+## 1.5.2
+  - Added better logging to AlgoDefinitionService
+
+## 1.5.1
+  - Fixed missing securities in the Fills and P&L windows.
+
+## 1.5.0
+### User Visible Changes
+#### New Features
+  - This release introduces a major new feature, the Algo Studio, a
+    set of tools allowing traders to create their own algos by
+    composing existing algos to express unique strategies.
+#### User Interface Improvements
+  - Removed security key field from most grids
+  - Removed trade key field from time and sales grid
+  - Fixed the "Since Open" time filter to use the exchange open time rather than 8:30 AM
+  - Fixed the floating order book so that rows are no longer
+    highlighted after an order is modified
+  - Relocated quantity and price columns in floating order book immediately after the cancel column; users now can move the mouse a much shorter distance when modifying their orders
+  - The escape key now closes the floating order book
+#### Bug Fixes
+  - Fixed the "Since Open" time filter to use the exchange open time rather than 8:30 AM
+  - Fixed a bug in the order book where sometimes parent orders would not update their last message column.
+
+#### Algos
+  - Added OCO Algo
+    - An OCO order creates a relationship between a child order and a 'stop' or 'other' order such that when one of these is cancelled, both cancel, or when one is filled, the other order's size is debited in the amount of the fill.  Composing this order with Cover simulates scalping functionality
+#### SDK
+  - Improved SDK documentation and usability
+  - Dynamic orders are now properly identified in the order book
+#### Documentation
+  - Information on the Spark API has been added to the Spark manual
+  - The documentation has been updated and reorganized to make information easier to find
+### Internal Changes
+  - Improved robustness of limit system test
+  - Fixed a bug in handling of built-in bts to user that could lead to failure to login as bts in old systems
+  - Improved market data subsystem to support security definition updates
+  - Fixed a startup race in market data that could lead to data corruption on startup
+  - Increased default order price precision to 8 digis as required by some CME products
+
+## 1.4.11
+### New Features
+  - Floating Order Book
+    - The floating order book provides a quick view of orders occupying a price level in the ladder
+    - Launch the Floating Order Book by middle-clicking a ladder badge
+    - Cancel orders by clicking on the red X in the Cancel column
+    - Quantity and Price modification
+      - Clicking on a row will select it, providing the option for changing your price and quantity
+      - Enter in a new value or use the up/down buttons to set a desired value
+      - Press the green checkbox to finalize your change and update the order
+### SDK
+  - Improved SDK documentation and usability
+### User Interface Improvements
+  - The following spreader quoting parameters have been deprecated:
+    - Hidden parameter
+    - Price Type setting of the Conditional parameter
+### Bug Fixes
+  - Fixed a limit enforcement problem that could lead to 0 sized orders being sent to the exchange
+
+## 1.4.10
+### Bug Fixes
+  - Removed duplicate entries in performance log
+
+## 1.4.9
+### SDK
+  - Added ticker events to the order API
+### Performance Improvements
+  - Significantly improved hedging speed
+### Bug Fixes
+  - Fixed a visual oddity in the order book UI when using High DPI displays
+
+## 1.4.8
+### Marketdata
+  - Additional trade details for CME ticker
+
+## 1.4.7
+### Bug Fixes
+  - Corrected FIX tag 1028, ManualOrderIndicator, when orders are triggered by algos
+
+## 1.4.6
+### Ladder Usability Improvements
+  - The ladder can now be zoomed in/out according to a user's preference
+  - The zoom slider can be enabled from Ladder Form -> Settings button -> Left Pane tab -> check Zoom Slider checkbox
+  - The zoom functionality can also be performed via hotkey and mouse wheel combinations
+    - Zoom In = CTRL + Mouse wheel up
+    - Zoom Out = CTRL + Mouse wheel down
+
+    - Reset zoom = CTRL + Mouse wheel click or double click on the zoom slider
+### Exchange simulator
+  - Improved the exchange simulator to track real market data more closely
+### Bug Fixes
+  - Fixed a UI crash in some cases when attempting to sort the order book by time
+
+## 1.4.5
+  - Fixed entitlement validation for ICS spreads
+  - Tuned performance logging
+
+## 1.4.4
+
+### Performance Improvements
+  - Reduced performance logging activity
+
+## 1.4.3
+
+### Ladder Usability Improvements
+  - Controls found in Left Pane of the ladder can now be hidden via the checkboxes found under Ladder Form -> Settings button -> Left Pane tab
+  - The Left Pane is now scrollable with the mouse wheel when there isn't enough vertical space to accomodate the entire form
+  - The Left Pane can now grown and shrunk horizontally via the splitter between the left pane and the main ladder area
+### Performance Improvements
+  - Requoting and hedging latency has been reduced by up to 30%
+### Software Development Kit (SDK) Improvements
+  - The API now enforces authentication
+### Bug Fixes
+  - The Market View form now honors filters when new securities are added
+
+## 1.4.2
+
+### User Interface Improvements
+  - When creating a synthetic from the Market View window, securities are now added to the Create Synthetic dialog in the same sort order as they appear in grid
+### Bug Fixes
+  - Shell no longer crashes when removing a security from the synthetics window
+  - It is now possible to create a new synthetic using the same name as a previously deleted synthetic
+### SDK Improvements
+  - Improved Client and Server SDK clarity and documentation
+### Performance Improvements
+  - Synthetic calculation speed was improved by 400%.
+### Risk / Entitlement System
+  - Risk Admin UI
+    - Spark users now have separate Trading, RiskAdmin, and/or MDAdmin permissions
+    - Spark users can now only add other users or accounts if permissioned to do so.
+  - Market Data Entitlement
+    - Automated market data reporting
+
+
+## 1.4.1
+
+### Tabs
+  - Tabs now shrink and expand to make better use of horizontal space
+### Bug Fixes
+  - Fixed a bug that could cause excessive CPU usage when a connection broke
+  - Fixed a layout bug in hedging/requoting performance reports
+  - Fixed account name mismatching bug for old fills
+### Absolute Position limits
+  - Positions can now be netted or absolute for purposes of limit enforcing
+
+## 1.4.0
+
+### Speed Enhancements
+  - Improved requoting and hedging performance
+  - Improved order book form performance
+### Server Side SDK
+  - Added a beta version of the server side SDK
+### Front End
+  - Added status bars to all UI grids
+### Reporting
+  - Added reporting of hedging and requoting performance
+
+## 1.3.8
+
+### Speed Enhancements
+  - Further speed enhancements
+### Conditional (new quoting parameter)
+  - Reduces re-quoting updates by only quoting if N ticks away from the opposite inside market.
+  - Quotes are canceled when it gets further away.
+  - "Price Type" dictates if this logic applies to the quoting market or to the synthetic spread market.
+
+## 1.3.7
+
+### Net Change pricing
+  - The ability to price synthetics based off of net change
+
+## 1.3.5
+
+### Speed Enhancements
+  - Further speed enhancements
+### Separation of implied and direct market data
+  - Viewing within a market view will now show 3 columns
+    - Direct
+    - Implied
+    - Merged
+  - Ability to configure the market data size in a ladder as the following
+    - Direct
+    - Implied
+    - Merged
+### Synthetic creation option to choose Merged or Direct
+  - The ability to choose Merged or Direct per leg when creating a synthetic
+### Volume at price
+  - Within a ladder, you can now see a volume at price graph
+  - This is configurable from a ladder's settings as well
+### Customized settings in all windows
+ - All windows now contain a settings page where grid settings (font color, size, etc) are applied
+ - These settings can be saved on a per-window basis or as a Default for newly-launched windows
+
+
+## 1.3.1 Through 1.3.4
+
+### Speed Enhancements
+  - Further speed enhancements
+
+## 1.2
+
+### Market View
+  - Synthetic future leg working orders are now shown
+
+### Order Book
+  - Many visual facets of the Order Book grid can now be customized
+    - The Order Book settings page can be accessed from the gears icon in the Order Book toolbar or from the right-click menu
+  - The Expand/Collapse All button has been separated into two different buttons on the toolbar
+
+### Sound Alerts
+  - Sounds alerts can now be configured for various order events
+  - Configure sounds under the Sound/Notification Triggers on the Order Book settings page
+
+### Fills
+  - Newly launched fill windows will filter out start-of-day records by default
+
+### PnL
+  - Prices are now formatted with penny precision
+  - Day PnL has been added to the Totals footer at the bottom of the window
+
+### Ladder
+  - Order badges now have been improved to communicate a variety of order state
+    - Background color now indicates order side
+    - Child orders will display a one-character abbreviation to their parent order enclosed in a rectangle; the rectangle will have a fill color matching the parent order
+    - Border color around badge will match the associated algo color
+    - Exchange orders will present with a solid dot in the badge's top-right corner
+    - When multiple orders reside at the same level, a solid triangle will be present in badge's bottom-right corner; all other badge decorations will not be visible in this state
+    - Hedge orders will present with a vertical line inside the badge's left border
+  - Trigger orders, once triggered, will no longer be shown in the ladder
+  - Session High and Low visual indicators have been added to the Price column
+  - Session range is now indicated in the Price column
+  - A button reflecting position has been added above the quantity field
+    - This button reflects the position for the currently selected account
+    - Pressing the button will copy the position size to the quantity field
+  - Order quantity button size values are now customizable
+    - Default size preset values can now be changed, as well as added or removed
+    - This can be configured per ladder instance (i.e. per security) by making use of the Custom tab
+  - Synthetic ladders that were saved as part of a workspace are now restored on startup
+
+### Synthetics
+  - Hedge Ratio parameter has been renamed to Lean Qty Factor
+  - Spreader now includes a Hidden mode parameter
+    - A quoting leg can be hidden, ie an order will not be sent out until the market crosses the computed quoting price. When that happens, the quote is sent out as an IOC order.
+
+### Algos
+  - Trigger orders now can contain a Trigger Exit parameter based on time or price; once the exit condition has been met the Trigger order will cancel
+  - IOC/FAK order type added
+  - Cover order type added
+  - Canceling a synthetic order no longer cancels any working hedge orders
+
+### General
+  - A manual page has been added to the launcher Help menu
+  - Various help buttons and tooltips were added throughout the application
+  - Various cash per point values updated
+  - Time-based grid filters now have tick up/down buttons
+  - Numerous performance improvements and stability enhancements
+  - Automated position and Order Book maintenance during daily recycle
+    - Individual fills will be compacted into the Start of Day position records
+    - Orders from the day before the recycle will be deleted
+
+
+## 1.1
+
+### 1.1.22
+- Order Book: Orders in Error status can now be recreated
+- Order Book: Orders containing child orders will now be collapsed by default.
+- Order Book: Expand / Collapse All button added to the right-click menu and window action pane, denoted by ▲ icon
+- Order Book: Symbol column added to allow for filtering based on group symbol
+- Time filters now have a quick Set Last Hour hyperlink which will set the Period Begin filter to (Now - 1 hour)
+
+### 1.1.20
+- Update CME market data handler for price precision extension.
+  https://www.cmegroup.com/confluence/display/EPICSANDBOX/Price+Precision+Extension
+
+### 1.1.8
+- Enabled wild cards in risk management UI
+- Fixed spreader order updates
+
+### 1.1.7
+- Fixed spread leg price fill
+- Fixed HO cash per point value
+
+### 1.1.6
+- Fixed occasional crash when filtering fills
+- Fixed several cash per point multipliers
+- Colored time of sales row with aggressor side
+- Iceberg orders now cancel (rather than an error) when a child is canceled
+
+### 1.1.0
+- Added per user self match protection, location and self match protection FIX tag settings
+- Implemented a new "Trigger Order" algo
+- Corrected tick formatting for a number of products
+- Added the ability to recreate canceled orders
+- Added leg fills to facilitate futures based PnL
+- PnL report now has PnL columns calculated based on your Start of Day, current day, and total position
+- Start, Day and Total PnL columns are painted with a red or green background color based on if the pnl value is negative or positive respectively
+- Corrected cash per point values, used in pnl calculations, for a number of products
+- PnL report will now remember any customizations you make to filtering and/or sorting criteria
+
@@ -17,7 +17,7 @@ namespace bts.shell {
   class MarketShellModule : IShellModule {
      [ImportingConstructor]
      public MarketShellModule(IBus bus, MDConsumer consumer, UserSettingsHub settings_hub, OrdersModel orders_model) {
-         _tsf = new TimeAndSalesWindowFactory(this, bus, consumer, settings_hub);
+         _tsf = new TimeAndSalesWindowFactory(this, bus, consumer, settings_hub, orders_model.security_auxiliary_model);
         _mvf = new MarketViewWindowFactory(this, bus, settings_hub, orders_model);
      }

@@ -1,10 +1,12 @@
 using bts.api;
 using bts.api.orderman;
 using bts.collections;
+using bts.utils;
 using mbts.co2;
 using mbts.spark.utilities;
 using mbts.ui;
 using mbts.ui.controls;
+using mbts.ui.shell;
 using mbts.ui.spark;
 using mbts.ui.utility;
 using mbts.utils;
@@ -24,7 +26,6 @@ namespace mbts.spark {
         readonly AnimationManager _animation = new AnimationManager();
         readonly ObservableCollection<OrderRecordImmutable> _orders = new ObservableCollection<OrderRecordImmutable>();
         readonly ObservableFilterCollection<OrderRecordImmutable> _working_orders, _working_bids, _working_asks;
-         readonly string _security_text, _security_key_text;
         readonly Property<double> _bid_price, _ask_price, _last_price, _day_change, _settlement, _session_high, _session_low;
         readonly Property<bool> _last_price_from_spread;
         readonly CellProperty<int> _position;
@@ -33,48 +34,51 @@ namespace mbts.spark {
         readonly CellProperty<bool> _inside_bids, _inside_asks;
         readonly CellProperty<int> _working_bid_volume, _working_ask_volume;
         readonly CellProperty<double> _working_best_bid, _working_best_ask;
-         readonly CellProperty<string> _working_bids_text, _working_asks_text;
         readonly MyOrderSummarizer _order_summarizer = new MyOrderSummarizer();
         readonly MDDisplayHelper.SizeFormatter _size_formatter = MDDisplayHelper.get_formatter(MarketSizeDisplay.get_default());
-         Property<uint> _bid_direct_size, _bid_merged_size, _ask_direct_size, _ask_merged_size;
+         PropertyAutoWrapper<uint, uint>
+            _bid_direct_size,
+            _bid_implied_size,
+            _bid_merged_size,
+            _ask_direct_size,
+            _ask_implied_size,
+            _ask_merged_size;
         double _raw_day_position;
-         string _bid_merged_size_text, _ask_merged_size_text;
         ulong _bbo_ref, _last_ref;
+         uint? _display_qty_divisor_backing;

         public Row(IBus bus, SecurityMD smd, OrdersModel orders_model) : base(smd) {
            _bus = bus;
            _orders_model = orders_model;
-            _security_text = smd.security.ToString();
-            _security_key_text = security_key.ToString();
            string format_price(double price) => security.ContractSpec.format(price);
-            _position = new CellProperty<int>(this, nameof(position), 0);
+            _position = new CellProperty<int>(this, nameof(position), fmt_display_qty_int);
            _bid_price = backing(nameof(bid_price), double.NaN);
            _ask_price = backing(nameof(ask_price), double.NaN);
            _last_price = backing(nameof(last_price), double.NaN);
-            _last_size = new CellProperty<uint>(this, nameof(last_size), 0);
+            _last_size = new CellProperty<uint>(this, nameof(last_size), fmt_display_qty_uint);
            _day_change = backing(nameof(day_change), double.NaN);
            _session_low = backing(nameof(session_low), double.NaN);
            _session_high = backing(nameof(session_high), double.NaN);
            _last_price_from_spread = backing(nameof(last_price_from_spread), false);
            _settlement = backing(nameof(settlement), double.NaN);
-            _volume = new CellProperty<ulong>(this, nameof(volume), 0);
+            _volume = new CellProperty<ulong>(this, nameof(volume), fmt_display_qty_ulong, 0);
            _inside_bids = new CellProperty<bool>(this, nameof(inside_bids));
            _inside_asks = new CellProperty<bool>(this, nameof(inside_asks));
            _working_bid_volume = new CellProperty<int>(this, nameof(working_bid_volume));
            _working_ask_volume = new CellProperty<int>(this, nameof(working_ask_volume));
            //
-            _bid_direct_size = backing(nameof(bid_direct_size), default(uint));
-            _bid_merged_size = backing(nameof(bid_merged_size), default(uint));
-            _ask_direct_size = backing(nameof(ask_direct_size), default(uint));
-            _ask_merged_size = backing(nameof(ask_merged_size), default(uint));
+            _bid_direct_size = backing(nameof(bid_direct_size), 0u, convert_display_qty_uint);
+            _bid_implied_size = backing(nameof(bid_implied_size), 0u, convert_display_qty_uint);
+            _bid_merged_size = backing(nameof(bid_merged_size), 0u, convert_display_qty_uint);
+            _ask_direct_size = backing(nameof(ask_direct_size), 0u, convert_display_qty_uint);
+            _ask_implied_size = backing(nameof(ask_implied_size), 0u, convert_display_qty_uint);
+            _ask_merged_size = backing(nameof(ask_merged_size), 0u, convert_display_qty_uint);
            //
            _working_orders = new ObservableFilterCollection<OrderRecordImmutable>(_orders, o => o.is_active());
            _working_bids = new ObservableFilterCollection<OrderRecordImmutable>(_working_orders, o => o.Def.Side == Side.Buy);
            _working_asks = new ObservableFilterCollection<OrderRecordImmutable>(_working_orders, o => o.Def.Side == Side.Sell);
            _working_best_bid = new CellProperty<double>(this, nameof(working_best_bid), format_price, double.NaN);
            _working_best_ask = new CellProperty<double>(this, nameof(working_best_ask), format_price, double.NaN);
-            _working_bids_text = new CellProperty<string>(this, nameof(working_bids_text), string.Empty);
-            _working_asks_text = new CellProperty<string>(this, nameof(working_asks_text), string.Empty);
            //
            default_command = new DelegateCommand(_show_ladder);
            bid_price_click = new DelegateCommand(() => _show_order_ticket(MarketViewView.Columns.Bid));
@@ -90,17 +94,45 @@ namespace mbts.spark {
            _animation.AnimationsChanged += on_animations_changed;
            void on_animations_changed() => RaisePropertyChanged(nameof(animations));
            _dispose = Disposable.Create(
+               attach_prop_changed_cb(_bid_direct_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(bid_direct_size_text))),
+               attach_prop_changed_cb(_bid_implied_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(bid_implied_size_text))),
+               attach_prop_changed_cb(_bid_merged_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(bid_merged_size_text))),
+               attach_prop_changed_cb(_ask_direct_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(ask_direct_size_text))),
+               attach_prop_changed_cb(_ask_implied_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(ask_implied_size_text))),
+               attach_prop_changed_cb(_ask_merged_size, mk_echo_prop_changed_cb<(uint,uint)>(nameof(ask_merged_size_text))),
               _orders_model.on_security_root_orders(security.Id).OnDispatcher().Subscribe(_on_orders),
               _position.OnDispatcher().Subscribe(v => _animation.animate_position(v.newval > v.oldval)),
               _orders_model.on_security_positions(security.Id).OnDispatcher().Subscribe(t => {
-                  if (Set(ref _raw_day_position, t.state.Values.Sum(p => p.Item2.raw_day_pos()), nameof(raw_day_position)))
+                  if (Set(ref _raw_day_position, t.state.Values.Sum(p => p.Item2.raw_day_pos()), nameof(raw_day_position))) {
+                     RaisePropertyChanged(nameof(raw_day_position_text));
                     raise_invalidated();
+                  }
               }),
               _inside_bids.OnDispatcher().Subscribe(v => _animation.animate_working_bids_inside(v.newval)),
               _inside_asks.OnDispatcher().Subscribe(v => _animation.animate_working_asks_inside(v.newval)),
               _day_change.OnDispatcher().Subscribe(v => _animation.animate_day_change(v.newval > v.oldval)),
               Disposable.Create(() => _animation.AnimationsChanged -= on_animations_changed)
            );
+
+            uint convert_display_qty_uint(uint value) =>
+               value.safe_divide(_display_qty_divisor);
+
+            string fmt_display_qty_int(int value) =>
+               value.safe_divide(_display_qty_divisor).ToString();
+
+            string fmt_display_qty_uint(uint value) =>
+               value.safe_divide(_display_qty_divisor).ToString();
+
+            string fmt_display_qty_ulong(ulong value) =>
+               value.safe_divide(_display_qty_divisor).ToString();
+
+            PropertyChange<T> mk_echo_prop_changed_cb<T>(params string[] props) =>
+               (oldval, newval) => RaisePropertyChanged(props);
+
+            IDisposable attach_prop_changed_cb<TView, TModel>(PropertyAutoWrapper<TModel, TView> prop, PropertyChange<(TModel, TView)> callback) {
+               prop.changed += callback;
+               return Disposable.Create(() => prop.changed -= callback);
+            }
         }

         public event Action invalidated;
@@ -109,32 +141,63 @@ namespace mbts.spark {
         public bool inside_bids => _inside_bids.value;
         public bool inside_asks => _inside_asks.value;
         public int position => _position.value;
+         public string position_text => _position.text;
         public double raw_day_position => _raw_day_position;
+         public string raw_day_position_text => SparkUtils.fmt_position(_raw_day_position.safe_divide(_display_qty_divisor));
         public double last_price => _last_price.Value;
         public bool last_price_from_spread => _last_price_from_spread.Value;
         public uint last_size => _last_size.value;
+         public string last_size_text => _last_size.text;
+         // bid price/size
         public double bid_price => _bid_price.Value;
-         public uint bid_direct_size => _bid_direct_size.Value;
-         public uint bid_implied_size => _bid_merged_size.Value - _bid_direct_size.Value;
-         public uint bid_merged_size => _bid_merged_size.Value;
-         public string bid_merged_size_text => _bid_merged_size_text ?? (_bid_merged_size_text = _size_formatter(_bid_merged_size.Value, bid_implied_size));
+         public uint bid_direct_size => _bid_direct_size.model;
+         public uint bid_implied_size => _bid_merged_size.model - _bid_direct_size.model;
+         public uint bid_merged_size => _bid_merged_size.model;
+         // bid size text
+         public string bid_direct_size_text => _bid_direct_size.view.ToString();
+         public string bid_implied_size_text => _bid_implied_size.view.ToString();
+         public string bid_merged_size_text => _bid_merged_size.view.ToString();
+         // ask price/size
         public double ask_price => _ask_price.Value;
-         public uint ask_direct_size => _ask_direct_size.Value;
-         public uint ask_implied_size => _ask_merged_size.Value - _ask_direct_size.Value;
-         public uint ask_merged_size => _ask_merged_size.Value;
-         public string ask_merged_size_text => _ask_merged_size_text ?? (_ask_merged_size_text = _size_formatter(_ask_merged_size.Value, ask_implied_size));
+         public uint ask_direct_size => _ask_direct_size.model;
+         public uint ask_implied_size => _ask_implied_size.model;
+         public uint ask_merged_size => _ask_merged_size.model;
+         // ask size text
+         public string ask_direct_size_text => _ask_direct_size.view.ToString();
+         public string ask_implied_size_text => _ask_implied_size.view.ToString();
+         public string ask_merged_size_text => _ask_merged_size.view.ToString();
+         //
         public ulong volume => _volume.value;
+         public string volume_text => _volume.text;
         public double settlement => _settlement.Value;
         public double day_change => _day_change.Value;
         public double session_low => _session_low.Value;
         public double session_high => _session_high.Value;
         public int working_bid_volume => _working_bid_volume.value;
         public int working_ask_volume => _working_ask_volume.value;
-         public string working_bids_text => OrderUtils.order_collection_summary(_order_summarizer.best_working_bid, _order_summarizer.best_working_bid_qty, _order_summarizer.working_bid_qty, security.ContractSpec);
-         public string working_asks_text => OrderUtils.order_collection_summary(_order_summarizer.best_working_ask, _order_summarizer.best_working_ask_qty, _order_summarizer.working_ask_qty, security.ContractSpec);
+         public string working_bids_text => OrderUtils.order_collection_summary(
+            _order_summarizer.best_working_bid,
+            _order_summarizer.best_working_bid_qty.safe_divide(_display_qty_divisor),
+            _order_summarizer.working_bid_qty.safe_divide(_display_qty_divisor),
+            security.ContractSpec);
+         public string working_asks_text => OrderUtils.order_collection_summary(
+            _order_summarizer.best_working_ask,
+            _order_summarizer.best_working_ask_qty.safe_divide(_display_qty_divisor),
+            _order_summarizer.working_ask_qty.safe_divide(_display_qty_divisor),
+            security.ContractSpec);
         public double working_best_bid => _working_best_bid.value;
         public double working_best_ask => _working_best_ask.value;
+         // ice props
+         public string market_description => security.market_description();
+         public string cleared_alias => security.cleared_alias();
+         public string product_description => security.product_name();
+         public string hub_alias => security.hub_alias();
+         public string strip_name => security.strip_name();
+         public string mic_code => security.mic_code();
+         // animations
         public IList<ui.spark.CellAnimation> animations => _animation.get_animations().ToList();
+         public ObservableCollection<RowAnimation> row_animations { get; } = new ObservableCollection<RowAnimation>();
+         // commands
         public ICommand bid_price_click { get; }
         public ICommand bid_merged_size_click { get; }
         public ICommand bid_direct_size_click { get; }
@@ -146,27 +209,30 @@ namespace mbts.spark {
         public ICommand ask_implied_size_click { get; }
         public ICommand working_asks_click { get; }
         public ICommand default_command { get; }
-         public string market_description {get;}
-         public string cleared_alias { get; }
-         public string product_description { get; }
-         public string hub_alias { get; }
-         public string strip_name{ get; }
-         public string mic_code { get; }
-
-         public ObservableCollection<RowAnimation> row_animations { get; } = new ObservableCollection<RowAnimation>();

         public IReadOnlyList<DIYGrid.IGridCellStore> cell_stores => new DIYGrid.IGridCellStore[0];
         #endregion

+         uint _display_qty_divisor => _display_qty_divisor_backing ??
+            (_display_qty_divisor_backing = _orders_model.security_auxiliary_model.get_display_quantity_divisor(security)).Value;
+
         public void raise_invalidated() => invalidated?.Invoke();

         public void refresh() {
            bool dirty = false;
            if (md.md.get_bbo(ref _bbo_ref, out NativePriceSize b, out NativePriceSize a)) {
               _bid_price.set(b.price);
-               refresh_size(ref b, _bid_direct_size, _bid_merged_size, ref _bid_merged_size_text, nameof(bid_merged_size_text));
+               // don't use the '||' operator - every 'set_new' call must be made
+               // (the operation mustn't terminate the first time a set_new call returns true).
+               dirty |= (
+                  _bid_direct_size.set_new(b.direct_size) |
+                  _bid_implied_size.set_new(b.implied_size) |
+                  _bid_merged_size.set_new(b.size) |
+                  _ask_direct_size.set_new(a.direct_size) |
+                  _ask_implied_size.set_new(a.implied_size) |
+                  _ask_merged_size.set_new(a.size));
+
               _ask_price.set(a.price);
-               refresh_size(ref a, _ask_direct_size, _ask_merged_size, ref _ask_merged_size_text, nameof(ask_merged_size_text));
               _inside_bids.on_next_distinct(_bid_price.Value >= _working_best_bid.value, ref dirty);
               _inside_asks.on_next_distinct(_ask_price.Value <= _working_best_ask.value, ref dirty);
            }
@@ -183,16 +249,6 @@ namespace mbts.spark {
            _volume.on_next_distinct(md.md.total_volume, ref dirty);
            if (dirty)
               invalidated?.Invoke();
-
-            void refresh_size(ref NativePriceSize nps, Property<uint> direct, Property<uint> merged, ref string text, string text_prop) {
-               if (nps.size != merged.Value || nps.direct_size != direct.Value) {
-                  merged.set(nps.size);
-                  direct.set(nps.direct_size);
-                  text = null;
-                  dirty = true;
-                  RaisePropertyChanged(text_prop);
-               }
-            }
         }

         public bool Equals(Row other) =>
@@ -9,6 +9,7 @@ using mbts.ui.utility;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
 using System.Reactive.Linq;
 using System.Windows.Data;
 using System.Windows.Media;
@@ -18,6 +19,9 @@ using static mbts.ui.spark.MarketViewView;

 namespace mbts.spark {
   partial class MarketViewVM : SecurityMDGrid<MarketViewVM.Row, SecurityMD> {
+      static IReadOnlyList<Func<MarketViewVM, IDataGridColumnFilter<Row>>> _filter_getters =
+         ObjectSnapshot.property_delegates_of_type<MarketViewVM, IDataGridColumnFilter<Row>>();
+
      readonly IBus _bus;
      readonly OrdersModel _orders_model;
      IWindowSettingsManager<GridSettings> _settings_manager;
@@ -37,21 +41,21 @@ namespace mbts.spark {
         const double working_orders_col_width = 105;
         IMultiValueConverter price_converter = new ui.spark.converters.TickDisplayConverter();
         add_col(Columns.Security, "Security", r => r.security.ToString(), nameof(Row.security), DefaultColumnWidths.Security, security_filter, DataGridFilterKnownTemplates.Regex);
-         add_col(Columns.Volume, "Volume", r => r.volume.ToString(), nameof(Row.volume), DefaultColumnWidths.Volume, volume_filter, DataGridFilterKnownTemplates.ULongMinMax);
+         add_col(Columns.Volume, "Volume", r => r.volume_text, nameof(Row.volume), DefaultColumnWidths.Volume, volume_filter, DataGridFilterKnownTemplates.ULongMinMax);
         add_col(Columns.LastSpd, "Spd", r => r.last_price_from_spread ? "S" : "", nameof(Row.last_price_from_spread), DefaultColumnWidths.Side, last_price_from_spread_filter, DataGridFilterKnownTemplates.Regex);
         add_col(Columns.Last, "Last", r => r.format_price(r.last_price), nameof(Row.last_price), DefaultColumnWidths.Price, last_price_filter, DataGridFilterKnownTemplates.DoubleMinMax);         
-         add_col(Columns.LastSize, merged_size_col_header, r => r.last_size.ToString(), nameof(Row.last_size), DefaultColumnWidths.Size, last_size_filter, DataGridFilterKnownTemplates.UIntMinMax, h_alignment: System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.Position, "Pos", r => r.position.ToString(), nameof(Row.position), DefaultColumnWidths.Size, position_filter, DataGridFilterKnownTemplates.IntMinMax, true, h_alignment: System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.RawDayPosition, "Raw Day Pos", r => SparkUtils.fmt_position(r.raw_day_position), nameof(Row.raw_day_position), DefaultColumnWidths.Size, raw_day_position_filter, DataGridFilterKnownTemplates.DoubleMinMax, true, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.LastSize, merged_size_col_header, r => r.last_size_text, nameof(Row.last_size), DefaultColumnWidths.Size, last_size_filter, DataGridFilterKnownTemplates.UIntMinMax, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.Position, "Pos", r => r.position_text, nameof(Row.position), DefaultColumnWidths.Size, position_filter, DataGridFilterKnownTemplates.IntMinMax, true, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.RawDayPosition, "Raw Day Pos", r => r.raw_day_position_text, nameof(Row.raw_day_position), DefaultColumnWidths.Size, raw_day_position_filter, DataGridFilterKnownTemplates.DoubleMinMax, true, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_working_orders_col(Columns.WorkingBids, working_col_header, nameof(Row.working_bids_text), nameof(Row.working_best_bid), nameof(Row.working_bids_click), working_bid_volume_filter, BTSColors.MarketData.bid, System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.BidImpliedSize, implied_size_col_header, r => r.bid_implied_size.ToString(), nameof(Row.bid_implied_size), DefaultColumnWidths.ImpliedDirectMergedSize, bid_implied_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.BidDirectSize, direct_size_col_header, r => r.bid_direct_size.ToString(), nameof(Row.bid_direct_size), DefaultColumnWidths.ImpliedDirectMergedSize, bid_direct_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.BidImpliedSize, implied_size_col_header, r => r.bid_implied_size_text, nameof(Row.bid_implied_size), DefaultColumnWidths.ImpliedDirectMergedSize, bid_implied_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.BidDirectSize, direct_size_col_header, r => r.bid_direct_size_text, nameof(Row.bid_direct_size), DefaultColumnWidths.ImpliedDirectMergedSize, bid_direct_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_merged_size_col(Columns.BidMergedSize, merged_size_col_header, nameof(Row.bid_merged_size), nameof(Row.bid_merged_size_text), nameof(Row.bid_merged_size_click), bid_merged_size_filter, BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_price_col(Columns.Bid, "Bid", nameof(Row.bid_price), nameof(Row.bid_price_click), bid_price_filter, BTSColors.header_text, BTSColors.MarketData.bid, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_price_col(Columns.Ask, "Ask", nameof(Row.ask_price), nameof(Row.ask_price_click), ask_price_filter, BTSColors.header_text, BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_merged_size_col(Columns.AskMergedSize, merged_size_col_header, nameof(Row.ask_merged_size), nameof(Row.ask_merged_size_text), nameof(Row.ask_merged_size_click), ask_merged_size_filter, BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.AskDirectSize, direct_size_col_header, r => r.ask_direct_size.ToString(), nameof(Row.ask_direct_size), DefaultColumnWidths.ImpliedDirectMergedSize, ask_direct_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
-         add_col(Columns.AskImpliedSize, implied_size_col_header, r => r.ask_implied_size.ToString(), nameof(Row.ask_implied_size), DefaultColumnWidths.ImpliedDirectMergedSize, ask_implied_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.AskDirectSize, direct_size_col_header, r => r.ask_direct_size_text, nameof(Row.ask_direct_size), DefaultColumnWidths.ImpliedDirectMergedSize, ask_direct_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
+         add_col(Columns.AskImpliedSize, implied_size_col_header, r => r.ask_implied_size_text, nameof(Row.ask_implied_size), DefaultColumnWidths.ImpliedDirectMergedSize, ask_implied_size_filter, DataGridFilterKnownTemplates.UIntMinMax, font_color: BTSColors.MarketData.ask, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_hl_working_orders_col(Columns.WorkingAsks, working_col_header, nameof(Row.working_asks_text), nameof(Row.working_best_ask), nameof(Row.working_asks_click), working_ask_volume_filter, BTSColors.MarketData.ask, System.Windows.HorizontalAlignment.Right);
         add_col(Columns.Settlement, "Settlement", r => r.format_price(r.settlement), nameof(Row.settlement), DefaultColumnWidths.Settlement, settlement_filter, DataGridFilterKnownTemplates.DoubleMinMax, h_alignment: System.Windows.HorizontalAlignment.Right);
         add_col(Columns.DayChange, "Change", r => r.format_price(r.day_change), nameof(Row.day_change), DefaultColumnWidths.Price, day_change_filter, DataGridFilterKnownTemplates.DoubleMinMax, true, h_alignment: System.Windows.HorizontalAlignment.Right);
@@ -151,14 +155,16 @@ namespace mbts.spark {
                     working_ask_volume_filter.load_state(filters.working_ask_volume);
                     volume_filter.load_state(filters.volume);
                     security_key_filter.load_state(filters.security_key);
+                     market_description_filter.load_state(filters.market_description);
+                     cleared_alias_filter.load_state(filters.cleared_alias);
+                     product_description_filter.load_state(filters.product_description);
+                     hub_alias_filter.load_state(filters.hub_alias);
+                     strip_name_filter.load_state(filters.strip_name);
+                     mic_code_filter.load_state(filters.mic_code);
                  }
                  rows_view.set_sort_descriptions(s.sorting_criterion, columns);
               }
-            }), DataGridFilterHelper.hook_filters(rows_view, security_filter,
-            bid_price_filter, bid_merged_size_filter, bid_direct_size_filter, bid_implied_size_filter,
-            ask_price_filter, ask_merged_size_filter, ask_direct_size_filter, ask_implied_size_filter,
-            last_price_filter, last_price_from_spread_filter, last_size_filter, day_change_filter, settlement_filter,
-            session_low_filter, session_high_filter, position_filter, raw_day_position_filter, working_bid_volume_filter, working_ask_volume_filter, volume_filter, security_key_filter),
+            }), DataGridFilterHelper.hook_filters(rows_view, _filters),
            settings_manager.subscribe_current().OnDispatcher().Subscribe(grid_settings_manager),
            WorkLoop.Start("MarketView", _refresh)
         );
@@ -233,13 +239,15 @@ namespace mbts.spark {
      public IDataGridColumnPersistentFilter<Row, ULongMinMaxState> volume_filter { get; } = new ULongMinMax<Row>(r => r.volume, nameof(Row.volume));
      public IDataGridColumnPersistentFilter<Row, string> security_key_filter { get; } = new RegexFilterVM<Row>(r => r.security_key.ToString(), nameof(Row.security_key));
      
-      public IDataGridColumnPersistentFilter<Row, string> market_description_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.MarketDescription : "", nameof(Row.market_description));
-      public IDataGridColumnPersistentFilter<Row, string> cleared_alias_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.ClearedAlias : "", nameof(Row.cleared_alias));
-      public IDataGridColumnPersistentFilter<Row, string> product_description_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.ProductName : "", nameof(Row.product_description));
-      public IDataGridColumnPersistentFilter<Row, string> hub_alias_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.HubAlias : "", nameof(Row.hub_alias));
-      public IDataGridColumnPersistentFilter<Row, string> strip_name_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.StripName : "", nameof(Row.strip_name));
-      public IDataGridColumnPersistentFilter<Row, string> mic_code_filter { get; } = new RegexFilterVM<Row>(r => r.security.HasIce ? r.security.Ice.MicCode : "", nameof(Row.mic_code));
-      
+      public IDataGridColumnPersistentFilter<Row, string> market_description_filter { get; } = new RegexFilterVM<Row>(r => r.market_description, nameof(Row.market_description));
+      public IDataGridColumnPersistentFilter<Row, string> cleared_alias_filter { get; } = new RegexFilterVM<Row>(r => r.cleared_alias, nameof(Row.cleared_alias));
+      public IDataGridColumnPersistentFilter<Row, string> product_description_filter { get; } = new RegexFilterVM<Row>(r => r.product_description, nameof(Row.product_description));
+      public IDataGridColumnPersistentFilter<Row, string> hub_alias_filter { get; } = new RegexFilterVM<Row>(r => r.hub_alias, nameof(Row.hub_alias));
+      public IDataGridColumnPersistentFilter<Row, string> strip_name_filter { get; } = new RegexFilterVM<Row>(r => r.strip_name, nameof(Row.strip_name));
+      public IDataGridColumnPersistentFilter<Row, string> mic_code_filter { get; } = new RegexFilterVM<Row>(r => r.mic_code, nameof(Row.mic_code));
+
+      IEnumerable<IDataGridColumnFilter<Row>> _filters =>
+         _filter_getters.Select(fn => fn(this));

      public FilterStates get_filter_states() {
         return new FilterStates {
@@ -22,12 +22,15 @@ namespace bts.shell.time_and_sales {
         .to_safe();

      readonly TradeMessageImmutable _trade;
+      readonly Func<SecurityImmutable?, uint> _get_display_qty_divisor;
+      uint? _display_size;

-      public TimeAndSalesRowVM(int row_key, SecurityImmutable security, TradeMessageImmutable trade) {
+      public TimeAndSalesRowVM(int row_key, SecurityImmutable security, TradeMessageImmutable trade, Func<SecurityImmutable?, uint> get_display_qty_divisor) {
         this.row_key = row_key;
         this.security = security;
         _trade = trade;
         trade_key = trade.Key;
+         _get_display_qty_divisor = get_display_qty_divisor ?? new Func<SecurityImmutable?, uint>(sec => 1);
      }

      public event Action invalidated;
@@ -39,6 +42,8 @@ namespace bts.shell.time_and_sales {
      public DateTime time => ((ulong)_trade.Time).lldatetime().ToLocalTime();
      public double price => _trade.price();
      public uint size => _trade.Size;
+      public uint display_size => _display_size ??
+         (_display_size = size.safe_divide(_get_display_qty_divisor(security))).Value;
      public AggressorSide aggressor_side => _trade.AggressorSide;

      public void raise_invalidated() =>
@@ -40,6 +40,7 @@ namespace bts.shell.time_and_sales {
         _refresh_filter,
         _refresh_sort,
         _refresh_selected_rows;
+      readonly Func<SecurityImmutable?, uint> _get_display_qty_divisor;
      IComparer<TimeAndSalesRowVM> _comparer_backing;
      Func<TimeAndSalesRowVM, bool> _filter_backing;
      ImmutableHashSet<TimeAndSalesRowVM> _selected_rows = ImmutableHashSet<TimeAndSalesRowVM>.Empty;
@@ -58,8 +59,9 @@ namespace bts.shell.time_and_sales {
         _filter_change_count,
         _sort_change_count;

-      public TimeAndSalesVM(IWindowSettingsManager<GridSettings> settings_manager) {
+      public TimeAndSalesVM(IWindowSettingsManager<GridSettings> settings_manager, Func<SecurityImmutable?, uint> get_display_qty_divisor) {
         _sort_manager = new ColumnSortManager(columns.WrapSelector(c => c as ISortableDIYGridColumn, null), TimeAndSalesView.Columns.RowKey.ToString());
+         _get_display_qty_divisor = get_display_qty_divisor ?? new Func<SecurityImmutable?, uint>(sec => 1);
         _comparer_backing = _sort_manager.BuildComparer(_get_column_comparer);
         _log = new LoggerContext(Log.Ui, $"Time And Sales VM ({Interlocked.Increment(ref _id_counter)})", null);
         _settings_manager = settings_manager;
@@ -95,7 +97,7 @@ namespace bts.shell.time_and_sales {
            System.Windows.HorizontalAlignment.Right);
         add_column(
            TimeAndSalesView.Columns.Size,
-            r => r.size.ToString(),
+            r => r.display_size.ToString(),
            DefaultColumnHeaders.Size,
            DefaultColumnWidths.Size,
            size_filter,
@@ -304,7 +306,7 @@ namespace bts.shell.time_and_sales {
         }
         var all_rows_bd = _all_rows.ToBuilder();
         foreach (var t in trades) {
-            var r = _row_factory.create(t.security, t.trade);
+            var r = _row_factory.create(t.security, t.trade, _get_display_qty_divisor);
            all_rows_bd.Add(r);
            if (_filter_backing == null || _filter_backing(r))
               rows.InsertSorted(r, _comparer);
@@ -400,11 +402,11 @@ namespace bts.shell.time_and_sales {
         // the row key must be unique to each row in the collection
         int _row_id_counter;

-         public TimeAndSalesRowVM create(TradeInfo trade_info) =>
-            new TimeAndSalesRowVM(_row_id_counter++, trade_info.security, trade_info.trade);
+         public TimeAndSalesRowVM create(TradeInfo trade_info, Func<SecurityImmutable?, uint> get_display_qty_divisor) =>
+            new TimeAndSalesRowVM(_row_id_counter++, trade_info.security, trade_info.trade, get_display_qty_divisor);

-         public TimeAndSalesRowVM create(SecurityImmutable security, TradeMessageImmutable trade) =>
-            new TimeAndSalesRowVM(_row_id_counter++, security, trade);
+         public TimeAndSalesRowVM create(SecurityImmutable security, TradeMessageImmutable trade, Func<SecurityImmutable?, uint> get_display_qty_divisor) =>
+            new TimeAndSalesRowVM(_row_id_counter++, security, trade, get_display_qty_divisor);
      }
   }
 }
@@ -26,6 +26,7 @@ namespace bts.shell.time_and_sales {
      readonly TimeAndSalesWindowFactory _factory;
      readonly IWindowSettingsManager<GridSettings> _settings_manager;
      readonly bool _can_pause_updates;
+      readonly Func<SecurityImmutable?, uint> _get_display_qty_divisor;
      TimeAndSalesVM _vm;
      TimeAndSalesModel _model;
      SecurityCriteria _security_criteria_backing;
@@ -35,12 +36,21 @@ namespace bts.shell.time_and_sales {
      SparkMenuDisplayVM _menu_display_vm;
      IDisposable _subscriptions;

-      public TimeAndSalesWindow(TimeAndSalesWindowFactory factory, IBus bus, MDConsumer consumer, TimeAndSalesSettings state, ImageSource icon, IWindowSettingsManager<GridSettings> settings_manager, bool can_pause_updates)
+      public TimeAndSalesWindow(
+         TimeAndSalesWindowFactory factory,
+         IBus bus,
+         MDConsumer consumer,
+         TimeAndSalesSettings state,
+         ImageSource icon,
+         IWindowSettingsManager<GridSettings> settings_manager,
+         bool can_pause_updates,
+         Func<SecurityImmutable?, uint> get_display_qty_divisor)
         : base("Time And Sales", bus, factory, SparkCommands.ShowTimeAndSales.icon) {
         Log.assert(state != null);
         _consumer = consumer;
         _factory = factory;
         _state = state ?? TimeAndSalesSettings.Default(new SecurityCriteria());
+         _get_display_qty_divisor = get_display_qty_divisor ?? new Func<SecurityImmutable?, uint>(sec => 1);
         if (_state.security_criteria == null)
            _state = _state.with(new SecurityCriteria());
         _security_criteria_backing = _state.security_criteria;
@@ -86,7 +96,7 @@ namespace bts.shell.time_and_sales {
            _settings_manager.instance_settings = _state.grid;
         _menu_display_vm = new SparkMenuDisplayVM();
         _menu_display_vm.load_from(_state.menu_display);
-         _vm = new TimeAndSalesVM(_settings_manager);
+         _vm = new TimeAndSalesVM(_settings_manager, _get_display_qty_divisor);
         var selected_rows_src = Observable.Create<ImmutableHashSet<TimeAndSalesRowVM>>(o => {
            _vm.selected_rows_changed += o.OnNext;
            return Disposable.Create(() => _vm.selected_rows_changed -= o.OnNext);
@@ -20,12 +20,15 @@ namespace bts.shell {
      readonly MDConsumer _consumer;
      readonly UserSettingsHub _settings_hub;
      readonly TimeAndSalesConfig _time_and_sales_conf;
+      readonly ISecurityAuxiliaryDataModel _security_auxiliary_model;
      IReadOnlyDictionary<uint, SecurityMD> _securities = new Dictionary<uint, SecurityMD>();

-      public TimeAndSalesWindowFactory(IShellModule module, IBus bus, MDConsumer consumer, UserSettingsHub settings_hub) : base(module, "TimeAndSales") {
+      public TimeAndSalesWindowFactory(IShellModule module, IBus bus, MDConsumer consumer, UserSettingsHub settings_hub, ISecurityAuxiliaryDataModel security_auxiliary_model)
+         : base(module, "TimeAndSales") {
         _bus = bus;
         _consumer = consumer;
         _settings_hub = settings_hub;
+         _security_auxiliary_model = security_auxiliary_model;
         _time_and_sales_conf = new TimeAndSalesConfig(Configuration.get<bts.config.TimeAndSalesOptions>());
         _dispose = Disposable.Create(
            bus.subscribe(SparkTags.SecuritiesTag).Subscribe(s => _securities = s),
@@ -38,7 +41,8 @@ namespace bts.shell {
      public override Task<IShellWindow> load(TimeAndSalesSettings state) =>
         Task.FromResult<IShellWindow>(new TimeAndSalesWindow(this, _bus, _consumer, state, SparkCommands.PickTimeAndSales.icon,
            new WindowSettingsManager<GridSettings>(_settings_hub, state.grid, s => s.time_and_sales_grid, (s, g) => s.with(time_and_sales:g)),
-            _time_and_sales_conf.can_pause_updates));
+            _time_and_sales_conf.can_pause_updates,
+            _security_auxiliary_model.get_display_quantity_divisor));

      public async void show(SecurityCriteria criteria) {
         var w = await load(new TimeAndSalesSettings(criteria));
@@ -236,12 +236,20 @@ namespace mbts.spark {
         get => algo_root;
         set => algo_root = value;
      }
+      IAlgoVM IAlgoParamVM<IAlgoVM>.display_value {
+         get => algo_root;
+         set => algo_root = value;
+      }
      bool IAlgoParamVM.has_value => _algo_root != null;
      bool IAlgoParamVM.is_enabled { get; set; } = true;
      object IAlgoParamVM.value {
         get => algo_root;
         set => algo_root = (IAlgoVM)value;
      }
+      object IAlgoParamVM.display_value {
+         get => algo_root;
+         set => algo_root = (IAlgoVM)value;
+      }
      AlgoParamPermissions _permissions = AlgoParamPermissions.ReadWrite;
      AlgoParamPermissions IAlgoParamVM.permissions { get => _permissions; set => _permissions = value; }

@@ -199,18 +199,30 @@
                Grid.Column="1"
                HorizontalAlignment="Center"
                Foreground="{u:BTSColor MarketData.bid}"
-                Text="{Binding DataContext.bbo.bid_size, RelativeSource={RelativeSource AncestorType=usp:AlgoEditorGridView}}"
                ToolTip="Best Bid Size"
-              />
+              >
+                <TextBlock.Text>
+                  <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}">
+                    <Binding Path="DataContext.bbo.bid_size" RelativeSource="{RelativeSource AncestorType=usp:AlgoEditorGridView}" Mode="OneWay"/>
+                    <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=usp:AlgoEditorGridView}" Mode="OneWay"/>
+                  </MultiBinding> 
+                </TextBlock.Text>
+              </TextBlock>
              <TextBlock
                x:Name="ask_text"
                Grid.Column="2"
                HorizontalAlignment="Center"
                Margin="4,0"
                Foreground="{u:BTSColor MarketData.ask}"
-                Text="{Binding DataContext.bbo.ask_size, RelativeSource={RelativeSource AncestorType=usp:AlgoEditorGridView}}"
                ToolTip="Best Ask Size"
-              />
+              >
+                <TextBlock.Text>
+                  <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}">
+                    <Binding Path="DataContext.bbo.ask_size" RelativeSource="{RelativeSource AncestorType=usp:AlgoEditorGridView}" Mode="OneWay"/>
+                    <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=usp:AlgoEditorGridView}" Mode="OneWay"/>
+                  </MultiBinding> 
+                </TextBlock.Text>
+              </TextBlock>
            </Grid>
            <DataTemplate.Triggers>
              <DataTrigger Binding="{Binding path_disambiguation}" Value="{x:Static sys:String.Empty}">
@@ -272,6 +284,14 @@
              </Grid>
            </DataTemplate>
          </u:TemplateSelectorKeyValue>
+          <!--TODO: replace all the param.value bindings with param.display_value.
+              The reason this has not already been done is that the display_value property is new,
+              and only necessary for the size param as of 6/8/2020 (slightly more uniform code doesn't warrant rocking the boat).-->
+          <u:TemplateSelectorKeyValue Key="{x:Static usp:AlgoParamTemplateKeys.Size}">
+            <DataTemplate>
+              <TextBlock Text="{Binding param.display_value}"/>
+            </DataTemplate>
+          </u:TemplateSelectorKeyValue>
        </usp:AlgoParamTemplateSelector.KeyedTemplates>
        <!--Bool-->
        <usp:AlgoParamTemplateSelector.BoolTemplate>
@@ -360,6 +380,22 @@
              />
            </DataTemplate>
          </u:TemplateSelectorKeyValue>
+          <!--TODO: replace all the param.value bindings with param.display_value.
+              The reason this has not already been done is that the display_value property is new,
+              and only necessary for the size param as of 6/8/2020 (slightly more uniform code doesn't warrant rocking the boat).-->
+          <u:TemplateSelectorKeyValue Key="{x:Static usp:AlgoParamTemplateKeys.Size}">
+            <DataTemplate>
+              <c:TickUpDownNullableInt Focusable="False" HorizontalAlignment="Stretch" Value="{Binding param.display_value, UpdateSourceTrigger=PropertyChanged}" ArrowKeyTickModifiers="Ctrl">
+                <c:TickUpDownNullableInt.CommandBindings>
+                  <CommandBinding Command="{x:Static u:NavigationHelper.MoveFocusCommand}" Executed="{x:Static u:NavigationHelper.KeyboardMoveFocusExecuted}"/>
+                </c:TickUpDownNullableInt.CommandBindings>
+                <c:TickUpDownNullableInt.InputBindings>
+                  <KeyBinding Key="Up" Command="{x:Static u:NavigationHelper.MoveFocusCommand}" CommandParameter="{x:Static FocusNavigationDirection.Up}"/>
+                  <KeyBinding Key="Down" Command="{x:Static u:NavigationHelper.MoveFocusCommand}" CommandParameter="{x:Static FocusNavigationDirection.Down}"/>
+                </c:TickUpDownNullableInt.InputBindings>
+              </c:TickUpDownNullableInt>
+            </DataTemplate>
+          </u:TemplateSelectorKeyValue>
        </usp:AlgoParamTemplateSelector.KeyedTemplates>
        <!--Bool-->
        <usp:AlgoParamTemplateSelector.BoolTemplate>
@@ -122,7 +122,7 @@ namespace mbts.spark {
         add_col(Columns.Account, DefaultColumnHeaders.Account, r => r.account, dv_filter_rx(_model.factory.subscribe_accounts().Select(d => d.Values.Ordered()), r => r.account), DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.Account);
         add_col(Columns.Exchange, DefaultColumnHeaders.Exchange, r => r.exchange.ToString(), dv_filter(EnumHelper.get_values<Venue>().ToArray(), r => r.security.exchange_or_default()), DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.Exchange);
         add_col(Columns.TimeInForce, DefaultColumnHeaders.TimeInForce, r => r.time_in_force.ToString(), dv_filter(EnumHelper.get_values<TimeInForce>().ToArray(), r => r.order?.time_in_force() ?? TimeInForce.Undefined), DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.TimeInForce);
-         add_col(Columns.Size, DefaultColumnHeaders.Size, r => r.size.ToString(), new DoubleMinMax<FillTuple>(r => r.fill.LastShares), DataGridFilterKnownTemplates.UIntMinMax, DefaultColumnWidths.Size);
+         add_col(Columns.Size, DefaultColumnHeaders.Size, r => r.display_size.ToString(), new DoubleMinMax<FillTuple>(r => r.fill.LastShares), DataGridFilterKnownTemplates.UIntMinMax, DefaultColumnWidths.Size);
         add_col(Columns.Price, DefaultColumnHeaders.Price, r => r.format_price(r.price), new DoubleMinMax<FillTuple>(r => r.fill.LastPrice), DataGridFilterKnownTemplates.DoubleMinMax, DefaultColumnWidths.Price);
         add_col(Columns.FillKind, DefaultColumnHeaders.FillKind, r => r.fill_kind.ToString(), dv_filter(EnumHelper.get_values<FillKind>().ToArray(), r => r.fill.FillKind), DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.FillKind);
         add_col(Columns.FillStatus, DefaultColumnHeaders.FillStatus, r => r.fill_status.ToString(), dv_filter(EnumHelper.get_values<FillStatus>().ToArray(), r => r.fill.FillStatus), DataGridFilterKnownTemplates.DiscreteValues, DefaultColumnWidths.FillKind);
@@ -286,6 +286,7 @@ namespace mbts.spark {
         Color? _root_algo_badge_color;
         OrderMetadata _order_metadata;
         bool _is_selected;
+         double? _display_size;

         public Row(FillTuple fill_tuple, OrdersModel model) : 
            base(fill_tuple.security ?? SecurityDataHelper.Defaults.SecurityImmutable) {
@@ -306,6 +307,8 @@ namespace mbts.spark {
         public Side side => _fill.Side;
         public double price => _fill.LastPrice;
         public double size => _fill.LastShares;
+         public double display_size => _display_size ??
+            (_display_size = size.safe_divide(_model.security_auxiliary_model.get_display_quantity_divisor(security))).Value;
         public FillKind fill_kind => _fill.FillKind;
         public FillStatus fill_status => _fill.FillStatus;
         public string fill_key => _fill.FillKey;
@@ -87,6 +87,15 @@ namespace mbts.spark {
      public static bool operator !=(LadderColumnSettings x, LadderColumnSettings y) => !(x == y);
   }

+   [ProtoContract]
+   class LadderOrderLimits : IEquatable<LadderOrderLimits> {
+      [ProtoMember(1)]
+      public ToggleInt32Proto max_settlement_cross_ticks { get; set; }
+
+      public bool Equals(LadderOrderLimits other) =>
+         other != null && max_settlement_cross_ticks == other.max_settlement_cross_ticks;
+   }
+
   [ProtoContract]
   class HistogramBarAnimation : IEquatable<HistogramBarAnimation> {
      // this class is 100% mutable (there are literally 0 readonly members),
@@ -314,6 +323,8 @@ namespace mbts.spark {
   // Settings are liable to change in the near future, so an internal IEqualityComparer simply won't do as it risks becoming out of date.
   [ProtoContract]
   class LadderSettings : IEquatable<LadderSettings> {
+      // RESERVED ProtoMember indices
+      //    900-999: dj settings
      const double _default_order_entry_panel_width = 110.0;
      const double _default_zoom_factor = 1.0;
      const bool _default_show_warn_on_cross = true;
@@ -592,6 +603,9 @@ namespace mbts.spark {
      [ProtoMember(61), DefaultValue(true)]
      public bool status_message_visible { get; set; }

+      [ProtoMember(900)]
+      public LadderOrderLimits ladder_order_limits { get; set; }
+
      public void sanitize() =>
         sanitize(this);

@@ -697,7 +711,8 @@ namespace mbts.spark {
         a.enforce_max_clip == b.enforce_max_clip &&
         a.max_clip == b.max_clip &&
         a.price_display_format == b.price_display_format &&
-         a.status_message_visible == b.status_message_visible;
+         a.status_message_visible == b.status_message_visible &&
+         a.ladder_order_limits.safe_equals(b.ladder_order_limits);

      public bool Equals(LadderSettings other) =>
         profile_equals(this, other) &&
@@ -100,6 +100,7 @@ namespace bts.shell {
         ShellWindowVM shell_window_vm = null;
         IShellWindow shell_window = null;
         var title_source = new LazyObservable<string>(() => ShellWindowExtensions.literal_title_source(shell_window, shell_window_vm));
+         LadderVM vm = null;
         var view = new Lazy<UIElement>(() => {
            // resources
            var model = new LadderModel(md, _orders_model, _mbo);
@@ -113,7 +114,6 @@ namespace bts.shell {
            /// In response to that event, 'needs_resync' is set to true. This causes 'last_value' to be refreshed when the next caller requests the latest settings
            /// (i.e., an IObserver subscribing to the settings_source, or the settings-dialog viewmodel).
            bool initialized = false, needs_resync = false;
-            LadderVM vm = null;
            var settings_subject = new Subject<LadderSettings>();
            var settings_source = Observable.Create<LadderSettings>(o => {
               ensure_synced();
@@ -272,10 +272,11 @@ namespace bts.shell {
            (v, s) => save(_get_state(((LadderView)v).vm, settings_id), s),
            icon: Icons.Ladder,
            thread_id: _thread_id_provider.next_id(),
-            vm => {
-               shell_window_vm = vm;
+            swvm => {
+               shell_window_vm = swvm;
               title_source.connect();
-            });
+            },
+            key_event_args => vm?.key_down(key_event_args));
      }

      async void _show_windows(IImmutableSet<uint> securities) {
@@ -4,6 +4,7 @@ using bts.shell.orderbook;
 using mbts.persist;
 using mbts.ui;
 using mbts.ui.shell;
+using mbts.ui.spark;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -169,7 +170,8 @@ namespace mbts.spark {
      }

      private void _set_badge_text() {
-         text_lines = BadgeRender.format(side, quantity, filled, _current_badge_style);
+         var fmt = MDDisplayHelper.get_value_formatter(_owner.display_quantity_divisor);
+         text_lines = BadgeRender.format(side, quantity, filled, _current_badge_style, fmt);
         RaisePropertyChanged(nameof(text_lines));
      }

@@ -3,6 +3,7 @@ using bts.api;
 using bts.api.orderman;
 using bts.collections;
 using bts.persist.algo;
+using bts.proto;
 using bts.shell.orderbook;
 using bts.utils;
 using mbts.collections;
@@ -44,7 +45,8 @@ namespace mbts.spark {
      LadderSettings.NetChangeTerms _price_format;
      LadderSettings.PriceDisplayFormat _price_display_format;
      double _order_entry_panel_width, _zoom_factor;
-      bool _auto_clear, _show_warn_on_cross, _enforce_max_clip;
+      bool _auto_clear, _show_warn_on_cross, _enforce_max_clip, _enforce_max_settlement_cross_ticks;
+      int _max_settlement_cross_ticks;
      LadderSettings _current;
      LadderColumnSettingsVM
         _orders = new OrdersColumnSettingsVM(),
@@ -190,6 +192,8 @@ namespace mbts.spark {
      public bool show_warn_on_cross { get => _show_warn_on_cross; set => Set(ref _show_warn_on_cross, value); }
      public bool enforce_max_clip { get => _enforce_max_clip; set => Set(ref _enforce_max_clip, value); }
      public uint max_clip { get => _max_clip.Value; set => _max_clip.Value = value; }
+      public bool enforce_max_settlement_cross_ticks { get => _enforce_max_settlement_cross_ticks; set => Set(ref _enforce_max_settlement_cross_ticks, value); }
+      public int max_settlement_cross_ticks { get => _max_settlement_cross_ticks; set => Set(ref _max_settlement_cross_ticks, value); }

      // favorites
      public FavoriteAlgosVM favorite_algos_vm { get; }
@@ -370,6 +374,10 @@ namespace mbts.spark {
            show_warn_on_cross = settings.show_warn_on_cross;
            enforce_max_clip = settings.enforce_max_clip;
            max_clip = settings.max_clip;
+            if (settings.ladder_order_limits != null) {
+               enforce_max_settlement_cross_ticks = settings.ladder_order_limits.max_settlement_cross_ticks.is_enabled;
+               max_settlement_cross_ticks = settings.ladder_order_limits.max_settlement_cross_ticks.value;
+            }
         }
      }

@@ -448,6 +456,10 @@ namespace mbts.spark {
         clone.show_warn_on_cross = show_warn_on_cross;
         clone.enforce_max_clip = enforce_max_clip;
         clone.max_clip = max_clip;
+         if (clone.ladder_order_limits == null)
+            clone.ladder_order_limits = new LadderOrderLimits();
+         clone.ladder_order_limits.max_settlement_cross_ticks =
+            new ToggleInt32Proto(max_settlement_cross_ticks, enforce_max_settlement_cross_ticks);
         return clone;
      }

@@ -1,6 +1,6 @@
 using bts.api;
 using bts.api.orderman;
-using bts.collections;
+using bts.proto;
 using bts.shell;
 using bts.spark;
 using bts.utils;
@@ -8,6 +8,7 @@ using mbts.co2;
 using mbts.spark.utilities;
 using mbts.ui;
 using mbts.ui.shell;
+using mbts.ui.spark;
 using mbts.utils;
 using System;
 using System.Collections.Generic;
@@ -66,6 +67,8 @@ namespace mbts.spark {
         current_settings = init;
         this.settings = settings;
         _equality = TickUtils.tick_equality_comparer(_model.security.ContractSpec);
+         display_quantity_divisor = model.order_gateway.security_auxiliary_model.get_display_quantity_divisor(model.security);
+         size_calculator.display_divisor = display_quantity_divisor;
         _slot_price_vs_orders = new Dictionary<double, LadderOrderVM>(_equality);
         this.order_properties_vm = order_properties_vm;
         _high = backing(nameof(high), double.NaN);
@@ -257,7 +260,11 @@ namespace mbts.spark {

      public IBus bus => _bus;

-      public event Action on_tick, request_settings_dialog, settings_invalidated;
+      public event Action
+         on_tick,
+         request_settings_dialog,
+         request_recenter,
+         settings_invalidated;

      public MDConsumerHandle md => _model.md;
      // we return only entries who have piqs and whose piqs are not uint.Max
@@ -292,6 +299,7 @@ namespace mbts.spark {
         remove => _on_disposed_impl -= value;
      }
      public SecurityImmutable security => _model.security;
+      public uint display_quantity_divisor { get; }
      public LadderSettings current_settings { get; private set; }
      public double high => _high.Value;
      public double low => _low.Value;
@@ -369,14 +377,14 @@ namespace mbts.spark {
         get {
            string rv = null;
            if (show_day_position)
-               rv = SparkUtils.fmt_position(day_position);
+               rv = SparkUtils.fmt_position(day_position / display_quantity_divisor);
            if (show_raw_day_position) {
-               var raw_day_text = SparkUtils.fmt_position(raw_day_position);
+               var raw_day_text = SparkUtils.fmt_position(raw_day_position / display_quantity_divisor);
               rv = rv == null ? raw_day_text : $"{rv} / {raw_day_text}";
            }
            if (show_account_position) {
-               var acc_text = SparkUtils.fmt_position(position);
-               rv = rv == null ? SparkUtils.fmt_position(position) : $"{rv} ({acc_text})";
+               var acc_text = SparkUtils.fmt_position(position / display_quantity_divisor);
+               rv = rv == null ? acc_text : $"{rv} ({acc_text})";
            }
            return rv ?? "";
         }
@@ -444,15 +452,27 @@ namespace mbts.spark {
      public void key_down(KeyEventArgs e) {
         if (order_properties_vm == null)
            return;
-         if (KeyboardExtensions.IsDown(Key.Space)) {
-            _bus?.post(SparkTags.RequestRecenterLadder, null);
-         }
-         // the ctrl modifier requirement helps avoid keyboard-input collisions w/ algo-templates popup
-         if (!KeyboardExtensions.IsCtrlDown()) return;
-         var new_algo = order_properties_vm.algo_definitions.FirstOrDefault(o => o.algo_root.key_match(e));
-         if (new_algo != null) {
-            order_properties_vm.selected_algo_definition = new_algo;
-            e.Handled = true;
+         switch (e.Key) {
+            case Key.Space:
+               if (KeyboardExtensions.IsShiftDown()) {
+                  // only recenter this ladder
+                  request_recenter?.Invoke();
+               } else {
+                  // recenter all ladders
+                  _bus?.post(SparkTags.RequestRecenterLadder, null);
+               }
+               e.Handled = true;
+               break;
+            default:
+               // the ctrl modifier requirement helps avoid keyboard-input collisions w/ algo-templates popup
+               if (KeyboardExtensions.IsCtrlDown()) {
+                  var new_algo = order_properties_vm.algo_definitions.FirstOrDefault(o => o.algo_root.key_match(e));
+                  if (new_algo != null) {
+                     order_properties_vm.selected_algo_definition = new_algo;
+                     e.Handled = true;
+                  }
+               }
+               break;
         }
      }

@@ -486,6 +506,10 @@ namespace mbts.spark {
      }

      public async Task send_order_async(Side side, uint size, double price) {
+         if (!_validate_price(side, price, out var invalid_price_msg)) {
+            status_update(new Activity { security = security, message = invalid_price_msg, category = ActivityLogCategory.order });
+            return;
+         }
         var order = order_properties_vm.create(side);
         if (order.CustomDef != null) {
            if (order.CustomDef.Stop != null) {
@@ -517,6 +541,23 @@ namespace mbts.spark {
         }
      }

+      bool _validate_price(Side side, double price, out string msg) {
+         msg = null;
+         if (!price.is_real()) {
+            msg = "not a real number";
+         } else if (settlement.is_real()) {
+            var ticks_from_settle = security.ContractSpec.tickdiff(price, settlement);
+            if (ticks_from_settle.HasValue) {
+               var max_cross = (current_settings?.ladder_order_limits?.max_settlement_cross_ticks)?.as_nullable();
+               if (max_cross.HasValue) {
+                  if (side == Side.Sell ? ticks_from_settle < (-1 * max_cross.Value) : ticks_from_settle > max_cross.Value)
+                     msg = $"exceeds settle cross ticks limit ({ticks_from_settle.Value})";
+               }
+            }
+         }
+         return msg == null;
+      }
+
      void _update_header() {
         bool last_updated = md.get_last_trade(ref _last_trade_time, out NativePriceSize last, out DateTime time, out ulong volume);
         if (_misc_time != _model.md.misc_timestamp || last_updated) {
@@ -46,12 +46,12 @@ namespace mbts.spark {
      void _reset_ladder_vm() {
         if (_value == null && !_security_md.HasValue)
            return;
-         Disposable.replace(ref _value,
-            _security_md.HasValue ?
-               LadderVM.create_readonly(_bus,
-                  new LadderModel(security_md.Value, _model, _model.mbo_service,
-                  new Func<OrderSecurity, bool>(osec => _selected_order_tree.Contains(osec.order.Key))),
-                  Observable.Return(LadderSettings.sanitize(LadderSettings.Default))) : null);
+         _value?.Dispose();
+         _value = _security_md.HasValue ?
+            LadderVM.create_readonly(_bus,
+               new LadderModel(security_md.Value, _model, _model.mbo_service,
+               new Func<OrderSecurity, bool>(osec => _selected_order_tree.Contains(osec.order.Key))),
+               Observable.Return(LadderSettings.sanitize(LadderSettings.Default))) : null;
         RaisePropertyChanged(nameof(value));
      }
   }
@@ -53,7 +53,7 @@ namespace mbts.spark {
      readonly RefValueContainer<IEnumerable<VolumeAtPriceLevelImmutable>> _volume_container =
         new RefValueContainer<IEnumerable<VolumeAtPriceLevelImmutable>>();

-      IDisposable _settings_sub, _volume_sub, _tick_sub;
+      IDisposable _settings_sub, _volume_sub, _tick_sub, _vm_sub;
      ScrollViewer _scrollViewer;
      LadderSettings _settings;
      LadderVM _vm;
@@ -66,7 +66,8 @@ namespace mbts.spark {
      double _last_origin_price;
      MarketBreakLines _mkt_break_lines;
      NativePriceSize _last_trade;
-      Func<NativePriceSize, string> _fmt_size = MDDisplayHelper.get_formatter_nps(MarketSizeDisplay.get_default());
+      Func<NativePriceSize, string> _fmt_mkt_depth_item_impl = MDDisplayHelper.get_formatter_nps(MarketSizeDisplay.get_default());
+      Func<uint, string> _fmt_mkt_quantity_impl = v => v.ToString();
      int _old_tooltip_row = int.MaxValue;
      NativePriceSize? _old_last_trade;
      string _direction_arrow = string.Empty;
@@ -468,7 +469,7 @@ namespace mbts.spark {
            security_id: _vm.model.security.Id,
            price_level: price_for_point(point)
         );
-         var model = new MBOPopupModel(_vm.model.mbo_service, _vm.model.security, query);
+         var model = new MBOPopupModel(_vm.model.mbo_service, _vm.model.security, query, fmt_mbo_qty);
         // Load the first set of orders so we know if there are any before showing the popup
         var result = await model.load_orders();
         if (result.success && result.value.orders.Count > 0) {
@@ -489,6 +490,8 @@ namespace mbts.spark {
            };
            view.RequestClose += (o, _) => popup.IsOpen = false;
         }
+         string fmt_mbo_qty(int value) =>
+            value < 0 ? $"-{_fmt_mkt_quantity((uint)value)}" : _fmt_mkt_quantity((uint)value);
      }

      protected override void OnMouseDoubleClick(MouseButtonEventArgs e) {
@@ -656,7 +659,7 @@ namespace mbts.spark {
            }
            void render_market_col(NativePriceSize[] depth) {
               var mid = LadderRender.index_of(_price_list, _last_origin_price, _price_comparer);
-               LadderRender.render_sizes(column.visual_tup.visual, column.visual_tup.glyph_context, mid, _price_list, depth, _settings.row_height, security.ContractSpec, column.settings, _fmt_size);
+               LadderRender.render_sizes(column.visual_tup.visual, column.visual_tup.glyph_context, mid, _price_list, depth, _settings.row_height, security.ContractSpec, column.settings, _fmt_mkt_depth_item);
            }
         }
         _apply_column_visual_offset();
@@ -694,10 +697,22 @@ namespace mbts.spark {
            _price_comparer = Comparer<double>.Create((x, y) => security.ContractSpec.tick_equals(x, y) ? 0 : y.CompareTo(x));
            _price_dirty = true;
            _piq_dirty = true;
-            _vm.on_tick += _tick;
+            // **use local vm to protect against re-assignment,
+            // so the events are unhooked from the same instance to which they were added
+            // when the subs are disposed.
+            var local_vm = _vm;
+            local_vm.on_tick += _tick;
+            local_vm.request_recenter += on_request_recenter;
            _settings_sub = _vm.settings.OnDispatcher().Subscribe(_settings_updated);
            _volume_sub = _vm.model.order_gateway.md_auxiliary_model.security_volume_at_price(security.Id).Subscribe(t => _volume_container.write_value(t.state.Values));
-            _tick_sub = Disposable.Create(() => _vm.on_tick -= _tick);
+            // **unhook from local_vm.request_recenter.
+            // todo: organize these subs into a single entity, prob _vm_subs.
+            // This hasn't already been done bc the ladder a bit fragile, so changes must be carefully implemented,
+            // with meticulous attention to detail.
+            _tick_sub = Disposable.Create(() => local_vm.on_tick -= _tick);
+            _vm_sub = Disposable.Create(() => local_vm.request_recenter -= on_request_recenter);
+            void on_request_recenter() =>
+               RecenterCommand?.ExecuteIfCan(null);
         }
      }

@@ -734,7 +749,7 @@ namespace mbts.spark {
                  _hide_tool_tip();
               }

-               tooltip_view.Content = $"{volume}";
+               tooltip_view.Content = _fmt_mkt_quantity(volume);
               tooltip_view.IsOpen = true;
               this.ToolTip = tooltip_view;
            } else {
@@ -850,7 +865,7 @@ namespace mbts.spark {
               if (last_trade_changed) {
                  var last_index = LadderRender.index_of(_price_list, _last_trade.price, _price_comparer);
                  if (last_index > 0)
-                     LadderRender.render_last(_last_vis_tup.visual, _last_vis_tup.glyph_context, _last_trade, last_index, _settings.row_height, _settings.last_column);
+                     LadderRender.render_last(_last_vis_tup.visual, _last_vis_tup.glyph_context, _last_trade, last_index, _settings.row_height, _settings.last_column, _fmt_mkt_quantity);
               }
               if (depth_changed)
                  _refresh_sizes();
@@ -892,21 +907,21 @@ namespace mbts.spark {
      void _refresh_last_trade() {
         var last_index = LadderRender.index_of(_price_list, _last_trade.price, _price_comparer);
         if (last_index > 0)
-            LadderRender.render_last(_last_vis_tup.visual, _last_vis_tup.glyph_context, _last_trade, last_index, _settings.row_height, _settings.last_column);
+            LadderRender.render_last(_last_vis_tup.visual, _last_vis_tup.glyph_context, _last_trade, last_index, _settings.row_height, _settings.last_column, _fmt_mkt_quantity);
      }

      void _refresh_piq() {
         if (!_settings.piq_column.show)
            return;
         int origin_index = LadderRender.index_of(_price_list, _mkt_break_lines.origin, _price_comparer);
-         LadderRender.render_piqs(_piq_vis_tup.visual, _last_vis_tup.glyph_context, origin_index, _price_list, _vm.price_vs_piq, _settings.row_height, security.ContractSpec, _settings.piq_column);
+         LadderRender.render_piqs(_piq_vis_tup.visual, _last_vis_tup.glyph_context, origin_index, _price_list, _vm.price_vs_piq, _settings.row_height, security.ContractSpec, _settings.piq_column, _fmt_mkt_quantity);
      }

      void _refresh_sizes() {
         Log.assert_d(_price_list != null);
         int origin_index = LadderRender.index_of(_price_list, _mkt_break_lines.origin, _price_comparer);
-         LadderRender.render_sizes(_bid_vis_tup.visual, _bid_vis_tup.glyph_context, origin_index, _price_list, _bids, _settings.row_height, security.ContractSpec, _settings.bid_column, _fmt_size);
-         LadderRender.render_sizes(_ask_vis_tup.visual, _ask_vis_tup.glyph_context, origin_index, _price_list, _asks, _settings.row_height, security.ContractSpec, _settings.ask_column, _fmt_size);
+         LadderRender.render_sizes(_bid_vis_tup.visual, _bid_vis_tup.glyph_context, origin_index, _price_list, _bids, _settings.row_height, security.ContractSpec, _settings.bid_column, _fmt_mkt_depth_item);
+         LadderRender.render_sizes(_ask_vis_tup.visual, _ask_vis_tup.glyph_context, origin_index, _price_list, _asks, _settings.row_height, security.ContractSpec, _settings.ask_column, _fmt_mkt_depth_item);
      }

      /// <summary>
@@ -928,7 +943,17 @@ namespace mbts.spark {
         if (vapls != null) {
            Log.assert_d(_price_list != null);
            var last_index = LadderRender.index_of(_price_list, _last_trade.price, _price_comparer);
-            LadderRender.render_volumes(_volume_vis_tup.visual, _volume_vis_tup.glyph_context, _price_list, vapls, _settings.row_height, security.ContractSpec, _settings.volume_column, last_index, _get_last_arrow_string());
+            LadderRender.render_volumes(
+               _volume_vis_tup.visual,
+               _volume_vis_tup.glyph_context,
+               _price_list,
+               vapls,
+               _settings.row_height,
+               security.ContractSpec,
+               _settings.volume_column,
+               last_index,
+               _get_last_arrow_string(),
+               _fmt_mkt_quantity);
            _old_last_trade = _last_trade;
         }

@@ -951,7 +976,7 @@ namespace mbts.spark {
            } 
            // regardless of if we've arrived here via a new Last (and new direction arrow)
            // or we're reusing the old one, this format bit is the same
-            return $"{_direction_arrow} {_last_trade.size} ";
+            return $"{_direction_arrow} {_fmt_mkt_quantity(_last_trade.size)} ";
         }
      }

@@ -1056,7 +1081,7 @@ namespace mbts.spark {
         double best_bid = _get_top_price(_bids);
         double best_ask = _get_top_price(_asks);
         return double.IsNaN(best_bid) ?
-            double.IsNaN(best_ask) ? _vm.low : security.ContractSpec.tickdown(best_ask) :
+            double.IsNaN(best_ask) ? _vm.settlement : security.ContractSpec.tickdown(best_ask) :
            best_bid;
      }

@@ -1064,7 +1089,7 @@ namespace mbts.spark {
         double best_bid = _get_top_price(_bids);
         double best_ask = _get_top_price(_asks);
         return double.IsNaN(best_ask) ?
-            double.IsNaN(best_bid) ? security.ContractSpec.tickdown(_vm.high) : best_bid :
+            double.IsNaN(best_bid) ? _vm.settlement : best_bid :
            security.ContractSpec.tickdown(best_ask);
      }

@@ -1072,7 +1097,7 @@ namespace mbts.spark {
         double best_bid = _get_top_price(_bids);
         double best_ask = _get_top_price(_asks);
         return double.IsNaN(best_bid) ?
-            double.IsNaN(best_ask) ? 0.5 * (_vm.low + _vm.high) : security.ContractSpec.tickdown(best_ask) :
+            double.IsNaN(best_ask) ? _vm.settlement : security.ContractSpec.tickdown(best_ask) :
            double.IsNaN(best_ask) ? best_bid : TickUtils.mid_tick(security.ContractSpec, best_bid, best_ask);
      }

@@ -1109,7 +1134,9 @@ namespace mbts.spark {
         GlyphContext glyph_context(LadderColumnSettings cs) =>
            GlyphContext.create(cs.font_family, cs.font_weight);

-         _fmt_size = MDDisplayHelper.get_formatter_nps(_settings.size_display);
+         var mkt_qty_display_divisor = _vm?.display_quantity_divisor ?? 1;
+         _fmt_mkt_depth_item_impl = MDDisplayHelper.get_formatter_nps(_settings.size_display, mkt_qty_display_divisor);
+         _fmt_mkt_quantity_impl = MDDisplayHelper.get_value_formatter(mkt_qty_display_divisor);
         _set_columns();
         _apply_column_visual_offset();
         if (prev_row_height != _settings.row_height)
@@ -1158,6 +1185,22 @@ namespace mbts.spark {
         }
         visible_columns_changed?.Invoke();
      }
+
+      // This is designed to be a redundant null check for _fmt_mkt_depth_item_impl.
+      string _fmt_mkt_depth_item(NativePriceSize value) {
+         // Assign the impl delegate to a local variable, just in case it is reassigned on another thread.
+         // This shouldn't happen, but better to avoid the potential null ref just in case it does. Expect the unexpected.
+         var impl = _fmt_mkt_depth_item_impl;
+         return impl is null ? MDDisplayHelper.get_formatter_nps(MarketSizeDisplay.get_default())?.ToString() ?? "Error" : impl(value);
+      }
+
+      // This is designed to be a redundant null check for _fmt_mkt_quantity_impl.
+      string _fmt_mkt_quantity(uint value) {
+         // Assign the impl delegate to a local variable, just in case it is reassigned on another thread.
+         // This shouldn't happen, but better to avoid the potential null ref just in case it does. Expect the unexpected.
+         var impl = _fmt_mkt_quantity_impl;
+         return impl is null ? value.ToString() : impl(value);
+      }
 
      void _init_tactile_adorner() {
         Disposable.dispose(ref _tactile_adorner);
@@ -12,20 +12,24 @@ using System.Linq;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Media;
+using bts.utils;

 namespace mbts.spark {
   static class BadgeRender {
      // IMPORTANT: the return values for this method MUST BE IN SYNC with the "format" method, else "measure_height" and "LadderRender.measure_row_height" will be broken.
      static int _line_count_for_style(LadderSettings.BadgeStyle badge_style) => badge_style == LadderSettings.BadgeStyle.Alternate ? 2 : 1;
      // IMPORTANT: at the risk of being redundant, see above comment.
-      public static IReadOnlyList<string> format(Side side, uint quantity, uint filled, LadderSettings.BadgeStyle style) {
+      public static IReadOnlyList<string> format(Side side, uint quantity, uint filled, LadderSettings.BadgeStyle style, Func<uint, string> fmt_value = null) {
+         if (fmt_value is null)
+            fmt_value = FormattingDelegates.default_string<uint>();
         switch (style) {
            case LadderSettings.BadgeStyle.Alternate:
+               var working_qty = quantity > filled ? quantity - filled : 0;
               return new[] {
-                  $"{side.abbreviate()}:{filled}",
-                  $"W:{quantity - filled}"
+                  $"{side.abbreviate()}:{fmt_value(filled)}",
+                  $"W:{fmt_value(working_qty)}"
               };
-            default: return new[] { $"{filled}/{quantity}" };
+            default: return new[] { $"{fmt_value(filled)}/{fmt_value(quantity)}" };
         }
      }

@@ -193,16 +197,17 @@ namespace mbts.spark {
      }

      public static void render_volumes(
-        DrawingVisual dv,
-        GlyphContext glyph_context,
-        double[] prices,
-        IEnumerable<VolumeAtPriceLevelImmutable> data,
-        double row_height,
-        ContractSpecificationImmutable spec,
-        VolumeColumnSettings settings,
-        int last_index,
-        string last_size_and_direction
-        ) {
+         DrawingVisual dv,
+         GlyphContext glyph_context,
+         double[] prices,
+         IEnumerable<VolumeAtPriceLevelImmutable> data,
+         double row_height,
+         ContractSpecificationImmutable spec,
+         VolumeColumnSettings settings,
+         int last_index,
+         string last_size_and_direction,
+         Func<uint, string> fmt_value) {
+         //
         if (!data.Any()) {
            _clear_visual(dv);
            return;
@@ -224,6 +229,8 @@ namespace mbts.spark {
            _clear_visual(dv);
            return;
         }
+         if (fmt_value is null)
+            fmt_value = FormattingDelegates.default_string<uint>();
         // inflate the max so that the graph never fills the available space
         double max = data.Max(v => v.Volume) * 1.1;
         _render_cells(dv, row_height, data.Select(d => (d.Price, d)), settings.general, prices, spec, render_cell);
@@ -255,11 +262,11 @@ namespace mbts.spark {
               }
               x_bar += width;
               if (show_numbers)
-                  numbers_text.Add(v.ToString());
+                  numbers_text.Add(fmt_value(v));
            }

            if (settings.total.show_numbers) {
-               numbers_text.Add(vap.Volume.ToString());
+               numbers_text.Add(fmt_value(vap.Volume));
            }
            if (settings.show_ltq && last_trade_here) {
               numbers_text.Clear();
@@ -309,19 +316,33 @@ namespace mbts.spark {
         }
      }

-      internal static void render_last(DrawingVisual dv, GlyphContext glyph_context, NativePriceSize last, int index, double row_height, LadderColumnSettings settings) {
+      internal static void render_last(DrawingVisual dv, GlyphContext glyph_context, NativePriceSize last, int index, double row_height, LadderColumnSettings settings, Func<uint, string> fmt_value) {
+         if (fmt_value is null)
+            fmt_value = FormattingDelegates.default_string<uint>();
         using (var dc = dv.RenderOpen()) {
-            var gr = format_text(last.size.ToString(), index, row_height, settings, glyph_context);
+            var gr = format_text(fmt_value(last.size), index, row_height, settings, glyph_context);
            dc.DrawGlyphRun(settings.foreground.rgb_brush(), gr);
         }
      }

      // this is basically a copy of redner_sizes up above
-      internal static void render_piqs(DrawingVisual dv, GlyphContext glyph_context, int origin_index, double[] prices, IEnumerable<(double price, uint piq)> pvp, double row_height, ContractSpecificationImmutable spec, LadderColumnSettings settings) {
+      internal static void render_piqs(
+         DrawingVisual dv,
+         GlyphContext glyph_context,
+         int origin_index,
+         double[] prices,
+         IEnumerable<(double price, uint piq)> pvp,
+         double row_height,
+         ContractSpecificationImmutable spec,
+         LadderColumnSettings settings,
+         Func<uint, string> fmt_value) {
+         //
         using (var dc = dv.RenderOpen()) {
            using (_draw_with_clip(dc, settings, row_height, prices.Length)) {
               if (!prices.within_range(origin_index) || pvp.is_null_or_empty())
                  return;
+               if (fmt_value is null)
+                  fmt_value = FormattingDelegates.default_string<uint>();
               var foreground = settings.foreground.rgb_brush();
               int curr_index = origin_index;
               double curr_price = prices[curr_index];
@@ -332,7 +353,7 @@ namespace mbts.spark {
                  curr_index += tick_diff;
                  curr_price = price;
                  if (curr_index >= 0 && curr_index < prices.Length) {
-                     var gr = format_text(entry.piq.ToString(), curr_index, row_height, settings, glyph_context);
+                     var gr = format_text(fmt_value(entry.piq), curr_index, row_height, settings, glyph_context);
                     dc.DrawGlyphRun(foreground, gr);
                  } else break;
               }
@@ -371,4 +392,4 @@ namespace mbts.spark {
         using (dv.RenderOpen()) { }
      }
   }
-}
+}
@@ -1019,45 +1019,47 @@
      <Grid HorizontalAlignment="Left" Margin="6">
        <Grid.RowDefinitions>
          <RowDefinition Height="Auto"/>
+          <RowDefinition Height="{Binding Source={StaticResource VerticalPush1}}"/>
          <RowDefinition Height="Auto" />
          <RowDefinition Height="{Binding Source={StaticResource VerticalPush1}}"/>
-          <RowDefinition Height="Auto"/>
+          <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
          <ColumnDefinition Width="Auto"/>
-          <ColumnDefinition Width="Auto"/>
-          <ColumnDefinition Width="50"/>
          <ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush3}}"/>
          <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <!-- market cross -->
-        <CheckBox Name="warn" Grid.Column="0" FlowDirection="RightToLeft" IsChecked="{Binding show_warn_on_cross}">
-          <CheckBox.Resources>
-            <Style TargetType="{x:Type Path}">
-              <Setter Property="FlowDirection" Value="LeftToRight"/>
-            </Style>
-          </CheckBox.Resources>
+        <CheckBox Grid.Column="0" VerticalContentAlignment="Center" IsChecked="{Binding show_warn_on_cross}">
+          <TextBlock
+            Style="{StaticResource EnableDisableFeatureText}"
+            IsEnabled="{Binding show_warn_on_cross}"
+            Text="Warn on Market Cross"
+          />
        </CheckBox>
-        <TextBlock Grid.Column="1"
-                   Style="{StaticResource EnableDisableFeatureText}"
-                   IsEnabled="{Binding ElementName=warn, Path=IsChecked}"
-                   Text="Warn on Market Cross" />
        <!-- max order qty -->
-        <CheckBox Name="enforce_max_clip" Grid.Row="1" Grid.Column="0" FlowDirection="RightToLeft" IsChecked="{Binding enforce_max_clip}">
-          <CheckBox.Resources>
-            <Style TargetType="{x:Type Path}">
-              <Setter Property="FlowDirection" Value="LeftToRight"/>
-            </Style>
-          </CheckBox.Resources>
+        <CheckBox Grid.Row="2" Grid.Column="0" VerticalContentAlignment="Center" IsChecked="{Binding enforce_max_clip}">
+          <TextBlock
+            Style="{StaticResource EnableDisableFeatureText}"
+            IsEnabled="{Binding enforce_max_clip}"
+            Text="Max Order Quantity"
+          />
        </CheckBox>
-        <TextBlock Grid.Row="1" Grid.Column="1"
-                   Style="{StaticResource EnableDisableFeatureText}"
-                   IsEnabled="{Binding ElementName=enforce_max_clip, Path=IsChecked}"
-                   MinWidth="{Binding ElementName=warn, Path=ActualWidth}"
-                   Text="Max Order Quantity"/>
-        <c:TickUpDownUInt Grid.Row="1" Grid.Column="2"
-                          IsEnabled="{Binding ElementName=enforce_max_clip, Path=IsChecked}"
-                          Value="{Binding max_clip}" />
+        <c:TickUpDownUInt
+          Grid.Row="2"
+          Grid.Column="2"
+          IsEnabled="{Binding enforce_max_clip}"
+          Value="{Binding max_clip}"
+          Width="60"
+        />
+        <CheckBox Grid.Row="4" VerticalContentAlignment="Center" IsChecked="{Binding enforce_max_settlement_cross_ticks}">
+          <TextBlock
+            Style="{StaticResource EnableDisableFeatureText}"
+            IsEnabled="{Binding enforce_max_settlement_cross_ticks}"
+            Text="Max Ticks from Settlement"
+          />
+        </CheckBox>
+        <c:TickUpDownInt Grid.Row="4" Grid.Column="2" IsEnabled="{Binding enforce_max_settlement_cross_ticks}" Value="{Binding max_settlement_cross_ticks}"/>
      </Grid>
    </TabItem>
    <TabItem Header="Mini Order Book">
@@ -426,9 +426,26 @@
                     Text="{Binding left_panel_width, Converter={StaticResource VolumeTextConverter}}"
                     Margin="0,0,0,4"
                     Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"/>
-              <TextBlock Grid.Column="2" Grid.Row="5" Text="{Binding volume, Mode=OneWay}" FontWeight="Bold"
-                     Margin="0,0,0,4"
-                     Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+              <TextBlock
+                Grid.Column="2"
+                Grid.Row="5"
+                FontWeight="Bold"
+                Margin="0,0,0,4"
+                Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"
+              >
+                <TextBlock.Text>
+                  <MultiBinding>
+                    <MultiBinding.Converter>
+                      <converters:MultiValueConverterPipe>
+                        <x:Static MemberType="{x:Type converters:DynamicDoubleDivisorConverter}" Member="Instance"/>
+                        <x:Static MemberType="{x:Type converters:ValueConverters}" Member="SimpleString"/>
+                      </converters:MultiValueConverterPipe>
+                    </MultiBinding.Converter>
+                    <Binding Path="volume" Mode="OneWay"/>
+                    <Binding Path="display_quantity_divisor" Mode="OneTime"/>
+                  </MultiBinding>
+                </TextBlock.Text>
+              </TextBlock>
            </Grid>
            <!-- Account combobox -->
            <ComboBox DataContext="{Binding order_properties_vm}" Margin="2,10,2,2" 
@@ -507,7 +524,7 @@
              mbts:TextBoxBehavior.IncrementDecrementOnMouseClick="True"
              HorizontalContentAlignment="Right"
              Margin="2"
-              Text="{Binding size_calculator.value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+              Text="{Binding size_calculator.display_value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
              ContextMenu="{x:Null}"
            />
            <!-- Qty quick buttons -->
@@ -522,7 +539,14 @@
              </ItemsControl.ItemsPanel>
              <ItemsControl.ItemTemplate>
                <DataTemplate>
-                  <Button Margin="2" Command="{Binding Path=DataContext.size_calculator.click, RelativeSource={RelativeSource AncestorType=ItemsControl}}" CommandParameter="{Binding}" Content="{Binding}" Focusable="False"/>
+                  <Button Margin="2" Command="{Binding Path=DataContext.size_calculator.click, RelativeSource={RelativeSource AncestorType=ItemsControl}}" Content="{Binding}" Focusable="False">
+                    <Button.CommandParameter>
+                      <MultiBinding Converter="{x:Static converters:DynamicDoubleMultiplierConverter.Instance}">
+                        <Binding/>
+                        <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=spark:LadderView}"/>
+                      </MultiBinding>
+                    </Button.CommandParameter>
+                  </Button>
                </DataTemplate>
              </ItemsControl.ItemTemplate>
            </ItemsControl>
@@ -93,6 +93,7 @@ namespace mbts.spark {
         _ui_scaler.MouseDoubleClick += _ui_scaler_MouseDoubleClick;
         this.PreviewMouseWheel += LadderView_PreviewMouseWheel;
         this.PreviewMouseDown += LadderView_PreviewMouseDown;
+         PreviewKeyDown += (s, e) => vm.key_down(e);
      }

      IDisposable _connect_left_panel_scroll() {
@@ -3,6 +3,7 @@ using bts.api.position;
 using bts.utils;
 using mbts;
 using mbts.spark;
+using mbts.ui;
 using mbts.ui.shell;
 using System;
 using System.Collections.Generic;
@@ -25,24 +26,27 @@ namespace bts.shell.manual_fills {
      readonly Property<bool> _is_dirty;
      readonly Property<EditableItemState> _editable_item_state;
      readonly DelegateProperty<bool> _is_valid;
+      readonly DisplayQuantityMultiplier _size = new DisplayQuantityMultiplier();
+      readonly Func<SecurityImmutable?, uint> _get_display_qty_divisor;
      SecurityImmutable? _security;
      AccountTuple? _account;
      UserTuple? _user;
      Side _side;
-      uint _size;
      double _price;
      bool _is_selected;
      ManualFillData? _data;
      IDisposable _committed_snapshot;

-      public ManualFillRow(ManualFillData data) {
+      public ManualFillRow(ManualFillData data, Func<SecurityImmutable?, uint> get_display_qty_divisor) {
         _data = data;
+         _get_display_qty_divisor = get_display_qty_divisor ?? new Func<SecurityImmutable?, uint>(sec => 1);
         key = data.key;
         _security = data.value.security;
         _account = data.value.account;
         _user = data.value.user;
         _side = data.value.manual_fill.Side;
-         _size = data.value.manual_fill.Quantity;
+         _size.actual_value = data.value.manual_fill.Quantity;
+         _size.conversion_data = new QuantityConversionData(_get_display_qty_divisor(data.value.security), QuantityConversionData.OpType.DivideActual);
         _price = data.value.manual_fill.Price;
         if (placeholder_key.HasValue) {
            _is_dirty = backing(nameof(is_dirty), false);
@@ -53,6 +57,7 @@ namespace bts.shell.manual_fills {
            _editable_item_state = backing(nameof(editable_item_state), _is_dirty, ch => ch.newval ? EditableItemState.Modified : EditableItemState.None);
         }
         _is_valid = backing(nameof(is_valid), () => _validate(this));
+         _dispose = _size.connect_owner(this, nameof(size), nameof(display_size));
      }

      public event Action<bool> is_selected_changed;
@@ -65,8 +70,10 @@ namespace bts.shell.manual_fills {
      public SecurityImmutable? security {
         get => _security;
         set {
-            if (_set(ref _security, value))
+            if (_set(ref _security, value)) {
+               _size.conversion_data = new QuantityConversionData(_get_display_qty_divisor(value), QuantityConversionData.OpType.DivideActual);
               RaisePropertyChanged(nameof(spec));
+            }
         }
      }
      public ContractSpecificationImmutable? spec => security.spec_or_default();
@@ -75,7 +82,8 @@ namespace bts.shell.manual_fills {
      public UserTuple? user { get => _user; set => _set(ref _user, value); }
      // side/size/price
      public Side side { get => _side; set => _set(ref _side, value); }
-      public uint size { get => _size; set => _set(ref _size, value); }
+      public uint size { get => _size.actual_value; set => _size.actual_value = value; }
+      public uint display_size { get => _size.display_value; set => _size.display_value = value; }
      public double price { get => _price; set => _set(ref _price, value); }
      // is selected
      public bool is_selected {
@@ -71,7 +71,7 @@
      <ComboBox Grid.Row="2" Grid.Column="2" ItemsSource="{DynamicResource ResourceKey={x:Static u:ResourceKeys.Accounts}}" SelectedItem="{Binding account}"/>
      <ComboBox Grid.Row="2" Grid.Column="4" ItemsSource="{DynamicResource ResourceKey={x:Static u:ResourceKeys.Users}}" SelectedItem="{Binding user}"/>
      <ComboBox Grid.Row="2" Grid.Column="6" ItemsSource="{DynamicResource ResourceKey={x:Static u:ResourceKeys.Sides}}" SelectedItem="{Binding side}" Width="48"/>
-      <c:TickUpDownUInt Grid.Row="2" Grid.Column="8" MinWidth="40" Value="{Binding size}"/>
+      <c:TickUpDownUInt Grid.Row="2" Grid.Column="8" MinWidth="40" Value="{Binding display_size}"/>
      <usp:PriceEntryControl Grid.Row="2" Grid.Column="10" MinWidth="55" Value="{Binding price}" ContractSpec="{Binding spec}"/>
    </Grid>
    <c:DialogSkirt Grid.Row="1" Margin="0,6,0,0">
@@ -1,4 +1,5 @@
-using bts.api.core;
+using bts.api;
+using bts.api.core;
 using bts.api.position;
 using bts.collections;
 using mbts.spark;
@@ -103,5 +104,8 @@ namespace bts.shell.manual_fills {

      public async Task<bool> update_fills(IEnumerable<ManualFill> fills) =>
         await _model.update_manual_fills(fills);
+
+      public uint get_display_qty_divisor(SecurityImmutable? security) =>
+         _model.security_auxiliary_model.get_display_quantity_divisor(security);
   }
 }
@@ -68,7 +68,7 @@ namespace bts.shell.manual_fills {
            RXCollection.connect(_persisted_rows,
               _model.manual_fills.OnDispatcher(),
               Observable.Return(Comparer<ManualFillData>.Create((a, b) => a.key.CompareTo(b.key))),
-               mfd => new ManualFillRow(mfd),
+               mfd => new ManualFillRow(mfd, model.get_display_qty_divisor),
               mfr => mfr.data),
            _bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().Subscribe(m => {
               security_map = new FilteredDictionary<uint, SecurityMD>(m, smd => smd.security.ContractCase == Security.ContractOneofCase.Future);
@@ -126,7 +126,8 @@ namespace bts.shell.manual_fills {
               new ManualFillKey(_placeholder_id_counter++),
               new ManualFillTuple(new ManualFillImmutable(new ManualFill {
                  Side = Side.Buy
-               }), null, accounts.FirstOrDefault(), users.FirstOrDefault())));
+               }), null, accounts.FirstOrDefault(), users.FirstOrDefault())),
+            _model.get_display_qty_divisor);

      void _add_fill(ManualFillRow new_row) =>
         _placeholder_rows.InsertSorted((new_row ?? (new_row = row_factory())).placeholder_key.HasValue ?
@@ -210,11 +211,20 @@ namespace bts.shell.manual_fills {
            } else {
               add_imported_fills();
            }
-            void add_imported_fills() =>
-               _placeholder_rows.InsertSorted(parsed_fills.Select(pmf => new ManualFillRow(new ManualFillData(new ManualFillKey(_placeholder_id_counter++), new ManualFillTuple(new ManualFillImmutable(pmf.result),
-                  pmf.result.SecurityKey != 0 && security_map.TryGetValue(pmf.result.SecurityKey, out var smd) ? smd.security : (SecurityImmutable?)null,
-                  accounts.FirstOrDefault(a => a?.id == pmf.result.AccountId),
-                  users.FirstOrDefault(a => a?.id == pmf.result.UserId))))), _row_key_comparer);
+            void add_imported_fills() {
+               _placeholder_rows.InsertSorted(parsed_fills.Select(mk_row), _row_key_comparer);
+
+               ManualFillRow mk_row(ParsedManualFill pmf) {
+                  var data = new ManualFillData(
+                     new ManualFillKey(_placeholder_id_counter++),
+                     new ManualFillTuple(
+                        new ManualFillImmutable(pmf.result),
+                        pmf.result.SecurityKey != 0 && security_map.TryGetValue(pmf.result.SecurityKey, out var smd) ? smd.security : (SecurityImmutable?)null,
+                        accounts.FirstOrDefault(a => a?.id == pmf.result.AccountId),
+                        users.FirstOrDefault(a => a?.id == pmf.result.UserId)));
+                  return new ManualFillRow(data, _model.get_display_qty_divisor);
+               }
+            }
         } catch (Exception ex) {
            BTSMessageBox.Error($"Error importing fills: {ex}.", ManualFillsWindowFactory.window_name);
         }
@@ -212,12 +212,12 @@
          <DataGridTemplateColumn c:DataGridEx.CellKey="{x:Static Size, MemberType={u:Nested usp:ManualFillsView.Columns}}" Header="Qty" SortMemberPath="side">
            <DataGridTemplateColumn.CellTemplate>
              <DataTemplate>
-                <TextBlock Text="{Binding size}" VerticalAlignment="Center"/>
+                <TextBlock Text="{Binding display_size}" VerticalAlignment="Center"/>
              </DataTemplate>
            </DataGridTemplateColumn.CellTemplate>
            <DataGridTemplateColumn.CellEditingTemplate>
              <DataTemplate>
-                <c:TickUpDownUInt MinWidth="40" Value="{Binding size, UpdateSourceTrigger=PropertyChanged}"/>
+                <c:TickUpDownUInt MinWidth="40" Value="{Binding display_size, UpdateSourceTrigger=PropertyChanged}"/>
              </DataTemplate>
            </DataGridTemplateColumn.CellEditingTemplate>
          </DataGridTemplateColumn>
@@ -597,19 +597,19 @@ namespace mbts.spark {

      public class SizeColumn : OrderbookColumnBase<UIntMinMaxState>, IRenderColumn<OrderBookRowVM> {
         public SizeColumn(IDataGridColumnPersistentFilter<OrderSecurityRootPair, UIntMinMaxState> filter)
-            : base(Columns.Size, "Qty", r => r.quantity.ToString(), DefaultColumnWidths.Size, filter, DataGridFilterKnownTemplates.UIntMinMax, _wrap_comparer(r => r.quantity)) { }
+            : base(Columns.Size, "Qty", r => r.display_quantity.ToString(), DefaultColumnWidths.Size, filter, DataGridFilterKnownTemplates.UIntMinMax, _wrap_comparer(r => r.quantity)) { }

         public void draw(OrderBookRowVM row, DrawingContext dc, ColumnGeometry position, double row_height) =>
-            CellRender.draw_text(dc, _get_glyph_context(row), font_size, row.quantity.ToString(), position, row_height,
+            CellRender.draw_text(dc, _get_glyph_context(row), font_size, row.display_quantity.ToString(), position, row_height,
               RenderUtils.get_side_brush(row), null, horizontal_alignment, VerticalAlignment.Center, DefaultCellPadding);
      }

      public class FilledColumn : OrderbookColumnBase<UIntMinMaxState>, IRenderColumn<OrderBookRowVM> {
         public FilledColumn(IDataGridColumnPersistentFilter<OrderSecurityRootPair, UIntMinMaxState> filter)
-            : base(Columns.Filled, "Filled Qty", r => r.filled_quantity.ToString(), DefaultColumnWidths.Size, filter, DataGridFilterKnownTemplates.UIntMinMax, _wrap_comparer(r => r.filled_quantity)) { }
+            : base(Columns.Filled, "Filled Qty", r => r.display_filled_quantity.ToString(), DefaultColumnWidths.Size, filter, DataGridFilterKnownTemplates.UIntMinMax, _wrap_comparer(r => r.filled_quantity)) { }

         public void draw(OrderBookRowVM row, DrawingContext dc, ColumnGeometry position, double row_height) =>
-            CellRender.draw_text(dc, _get_glyph_context(row), font_size, row.filled_quantity.ToString(), position, row_height,
+            CellRender.draw_text(dc, _get_glyph_context(row), font_size, row.display_filled_quantity.ToString(), position, row_height,
               RenderUtils.get_side_brush(row), null, horizontal_alignment, VerticalAlignment.Center, DefaultCellPadding);
      }

@@ -1163,7 +1163,7 @@ namespace mbts.spark {

         public override FrameworkElement view_factory() {
            var tick_up_down = new TickUpDownNullableUIntCommit();
-            tick_up_down.SetBinding(TickUpDownNullableUIntCommit.SourceValueProperty, nameof(OrderBookRowVM.prospective_quantity));
+            tick_up_down.SetBinding(TickUpDownNullableUIntCommit.SourceValueProperty, nameof(OrderBookRowVM.prospective_display_quantity));
            tick_up_down.SetBinding(TickUpDownNullableUIntCommit.OnCommitProperty, nameof(OrderBookRowVM.modify_order_quantity_andor_price));
            tick_up_down.InputBindings.Add(_create_keyinput_binding(Key.Enter, nameof(OrderBookRowVM.modify_order_quantity_andor_price)));
            tick_up_down.InputBindings.Add(_create_keyinput_binding(Key.Escape, nameof(OrderBookRowVM.revert_prospective_order_quantity_andor_price)));
@@ -29,7 +29,9 @@ namespace mbts.spark {
      int _depth_level;
      SecurityImmutable? _security => order_tuple.order.security;
      // for mini-ob 
-      uint _prospective_quantity;
+      DisplayQuantityMultiplier _prospective_qty_translator_backing;
+      uint _display_qty_divisor_backing;
+      bool _display_qty_divisor_dirty = true;
      double _prospective_price;
      Action<bool> _on_selection_changed;

@@ -37,7 +39,6 @@ namespace mbts.spark {
         _owner = owner;
         this.order_tuple = order_tuple;
         _is_expanded = is_expanded;
-         prospective_quantity = this.quantity;
         prospective_price = this.price;
         _on_selection_changed = on_selection_changed;
      }
@@ -94,14 +95,18 @@ namespace mbts.spark {
      public string last_price_text => _fmt_price(last_price);
      public string avg_price_text => _fmt_price(avg_price);
      public uint quantity => order.quantity();
+      public uint display_quantity => quantity.safe_divide(_display_qty_divisor);
      public uint filled_quantity => order.filled();
+      public uint display_filled_quantity => filled_quantity.safe_divide(_display_qty_divisor);
      public string last_msg => order.last_msg();
+      // piq
      public uint piq => order_tuple.order.piq ?? uint.MaxValue;
-      public string piq_text => piq == uint.MaxValue ? string.Empty : piq.ToString();
+      public string piq_text => piq == uint.MaxValue ? string.Empty : piq.safe_divide(_display_qty_divisor).ToString();
+
      public bool is_non_terminal => order.is_non_terminal();
      public bool is_attachable { get => _is_attachable; set => SetVisual(ref _is_attachable, value); }
      public bool is_detachable { get => _is_detachable; set => SetVisual(ref _is_detachable, value); }
-      public string filled_status_desc => order.filled_status_description(security.spec_or_default());
+      public string filled_status_desc => order.filled_status_description(security.spec_or_default(), _display_qty_divisor);

      // Root Algo
      public CustomOrderDefinition.CustomOneofCase root_algo_order_type => order_tuple.root.algo.value.CustomCase;
@@ -129,12 +134,12 @@ namespace mbts.spark {
         }
      }
      public uint prospective_quantity {
-         get => _prospective_quantity;
-         set {
-            if (Set(ref _prospective_quantity, value)) {
-               RaisePropertyChanged(nameof(is_qty_dirty));
-            }
-         }
+         get => _prospective_qty_translator.actual_value;
+         set => _prospective_qty_translator.actual_value = value;
+      }
+      public uint prospective_display_quantity {
+         get => _prospective_qty_translator.display_value;
+         set => _prospective_qty_translator.display_value = value;
      }
      public double prospective_price {
         get => _prospective_price;
@@ -224,6 +229,29 @@ namespace mbts.spark {
         }
      }

+      uint _display_qty_divisor {
+         get {
+            _sync_display_qty_if_dirty();
+            return _display_qty_divisor_backing;
+         }
+      }
+
+      IDisplayTranslator<uint> _prospective_qty_translator {
+         get {
+            if (_prospective_qty_translator_backing == null) {
+               _prospective_qty_translator_backing = new DisplayQuantityMultiplier {
+                  conversion_data = new QuantityConversionData(_display_qty_divisor, QuantityConversionData.OpType.DivideActual),
+                  actual_value = quantity
+               };
+               _prospective_qty_translator.value_changed += () =>
+                  RaisePropertyChanged(nameof(is_qty_dirty));
+            } else {
+               _sync_display_qty_if_dirty();
+            }
+            return _prospective_qty_translator_backing;
+         }
+      }
+
      #region IHierarchicalRow
      bool IHierarchicalRow.is_parent => is_parent;
      bool IHierarchicalRow.is_expanded => is_expanded;
@@ -267,22 +295,35 @@ namespace mbts.spark {
         if ((Columns.OrderType & dirty) != 0)
            RaisePropertyChanged(nameof(order_type), nameof(order_metadata));
         // quantity
-         if ((Columns.Size & dirty) != 0) {
-            RaisePropertyChanged(nameof(quantity), nameof(is_qty_dirty));
-            // we need to update the prospective_quantity here b/c an update could have come in while the row was in edit mode
-            // via the Mini OB update column mechanism (vs the EditableQty column)
-            // prospecive price does not need to be updated in the same manner b/c if the price is changed, the whole
-            // row will no longer match the filter
-            prospective_quantity = quantity;
-         }
         // price
         if ((Columns.Price & dirty) != 0) {
            RaisePropertyChanged(nameof(price));
            RaisePropertyChanged(nameof(is_price_dirty));
         }
         // security
-         if ((Columns.Security & dirty) != 0)
-            RaisePropertyChanged(nameof(security), nameof(security_text));
+         if ((Columns.Security & dirty) != 0) {
+            _display_qty_divisor_dirty = true;
+            RaisePropertyChanged(
+               // security props
+               nameof(security),
+               nameof(security_text),
+               // qty props
+               nameof(display_quantity),
+               nameof(prospective_quantity),
+               nameof(prospective_display_quantity),
+               nameof(is_qty_dirty),
+               //
+               nameof(piq_text),
+               nameof(display_filled_quantity));
+         }
+         if ((Columns.Size & dirty) != 0) {
+            RaisePropertyChanged(nameof(quantity), nameof(display_quantity));
+            if (_prospective_qty_translator_backing != null)
+               _prospective_qty_translator_backing.actual_value = quantity;
+         }
+         if ((Columns.Filled & dirty) != 0) {
+            RaisePropertyChanged(nameof(filled_quantity), nameof(display_filled_quantity));
+         }
         // badge fill
         if (old_order_tuple.order.meta?.badge_color != order_tuple.order.meta?.badge_color) {
            // invalidate by setting to null (will be re-instantiated in the public getter)
@@ -359,6 +400,15 @@ namespace mbts.spark {
         security.Value.ContractSpec.format(v) :
         Math.Round(v, _unknown_security_price_num_fractional_digits, MidpointRounding.AwayFromZero).ToString(_unknown_security_price_format_string);

+      void _sync_display_qty_if_dirty() {
+         if (_display_qty_divisor_dirty) {
+            _display_qty_divisor_dirty = false;
+            _display_qty_divisor_backing = _owner.get_display_qty_divisor(security);
+            if (_prospective_qty_translator_backing != null)
+               _prospective_qty_translator_backing.conversion_data = new QuantityConversionData(_display_qty_divisor_backing, QuantityConversionData.OpType.DivideActual);
+         }
+      }
+
      void RaisePropertyChanged(params string[] props) {
         var pc = PropertyChanged;
         if (pc == null)
@@ -397,6 +447,7 @@ namespace mbts.spark {
               Columns.LastMessage |
               Columns.Piq,
            filled_status_desc_mask =
+               Columns.Security |
               Columns.Filled |
               Columns.AvgFilled |
               Columns.Status;
@@ -639,6 +639,9 @@ namespace mbts.spark {

      public OrderMetadata get_metadata(OrderBookRowVM row) => _model.factory.get_metadata(row.order.actual_order_type());

+      internal uint get_display_qty_divisor(SecurityImmutable? security) =>
+         _model.security_auxiliary_model.get_display_quantity_divisor(security);
+
      internal void show_order_modify(OrderBookRowVM row) =>
         _bus.post(SparkTags.ShowModifyOrderTag, row.order_key);

@@ -798,7 +801,7 @@ namespace mbts.spark {
         readonly Property<bool> _is_dirty;
         IRaiseCanExecuteChangedCommand _payup_bid_cmd, _payup_ask_cmd;
         IAlgoParamVM<double> _price_param;
-         IAlgoParamVM<uint?> _size_param;
+         AlgoParamVM<uint?> _size_param;
         AlgoParamPermissions
            _price_permissions = AlgoParamPermissions.ReadOnly | AlgoParamPermissions.Write,
            _size_permissions = AlgoParamPermissions.ReadOnly | AlgoParamPermissions.Write;
@@ -835,7 +838,9 @@ namespace mbts.spark {
                     _price_param = null;
                     _size_param = null;
                  } else {
-                     _size_param = new AlgoParamVM<uint?>("size", "Size", owner._selected_params_mon.size) {
+                     _size_param = new AlgoParamVM<uint?>("size", "Size", owner._selected_params_mon.size, EqualityComparer<uint?>.Default,
+                        to_display_value: v => v.HasValue ? v.Value / display_quantity_divisor : v,
+                        from_display_value: v => v.HasValue ? v.Value * display_quantity_divisor : v) {
                        permissions = _size_permissions & _param_permissions
                     };
                     var price_param = new AlgoParamVM<double>("price", "Price", owner._selected_params_mon.price, spec?.tick_equality_comparer() ?? MathUtils.epsilon_eq_comparer) {
@@ -878,10 +883,11 @@ namespace mbts.spark {
            get => _security_md;
            set {
               if (Set(ref _security_md, value)) {
-                  RaisePropertyChanged(nameof(security), nameof(spec));
+                  RaisePropertyChanged(nameof(security), nameof(spec), nameof(display_quantity_divisor));
                  bbo.security_md = value;
                  _payup_bid_cmd.RaiseCanExecuteChanged();
                  _payup_ask_cmd.RaiseCanExecuteChanged();
+                  _size_param?.refresh_display_value();
               }
            }
         }
@@ -903,6 +909,7 @@ namespace mbts.spark {
         public AlgoDefinitionVM algo_vm { get; }
         public IReadOnlyObservableCollection<AlgoParamRowVM> param_rows { get; }
         public BBOVM bbo { get; }
+         public uint display_quantity_divisor => _owner.get_display_qty_divisor(security);
         public ICommand send_order { get; }
         public ICommand payup_bid_cmd => _payup_bid_cmd;
         public ICommand payup_ask_cmd => _payup_ask_cmd;
@@ -62,7 +62,7 @@
        </Setter>
      </Style>
      <Style x:Key="{x:Static usp:OrderParamsPanel.BestBidSizeButtonStyleKey}" TargetType="Button" BasedOn="{StaticResource {x:Type Button}}">
-        <Setter Property="Command" Value="{Binding DataContext.size_calculator.set_value_command, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
+        <Setter Property="Command" Value="{Binding DataContext.size_calculator.set_actual_value_command, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
        <Setter Property="CommandParameter" Value="{Binding BestBidSize, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
        <Setter Property="ToolTip">
          <Setter.Value>
@@ -82,7 +82,7 @@
        </Setter>
      </Style>
      <Style x:Key="{x:Static usp:OrderParamsPanel.BestAskSizeButtonStyleKey}" TargetType="Button" BasedOn="{StaticResource {x:Type Button}}">
-        <Setter Property="Command" Value="{Binding DataContext.size_calculator.set_value_command, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
+        <Setter Property="Command" Value="{Binding DataContext.size_calculator.set_actual_value_command, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
        <Setter Property="CommandParameter" Value="{Binding BestAskSize, RelativeSource={RelativeSource AncestorType=usp:OrderParamsPanel}}"/>
        <Setter Property="ToolTip">
          <Setter.Value>
@@ -101,7 +101,7 @@
          <TextBlock.Inlines>
            <Run Text="{Binding security, Mode=OneWay}" FontWeight="Bold"/>
            <Run Text="{Binding side, Mode=OneWay}" Foreground="{Binding side, Converter={StaticResource SideToBrushConverter}}"/>
-            <Run Text="{Binding quantity, Mode=OneWay}"/>
+            <Run Text="{Binding display_quantity, Mode=OneWay}"/>
            <Run>@</Run>
            <Run>
              <Run.Text>
@@ -5,6 +5,7 @@ using bts.utils;
 using mbts;
 using mbts.spark;
 using mbts.spark.utilities;
+using mbts.ui;
 using mbts.ui.controls;
 using mbts.utils;
 using System;
@@ -140,15 +141,18 @@ namespace bts.shell.pnl {
      public PositionPriceSize summary =>
         new PositionPriceSize(long_data.working_total, long_data.avg_price, short_data.working_total, short_data.avg_price);

-      public static WorkingOrderData Create(IEnumerable<OrderRecordImmutable> orders) =>
-         orders.Aggregate(Empty, (seed, order) => seed.Add(order));
+      public static WorkingOrderData Create(IEnumerable<OrderRecordImmutable> orders, QuantityConversionData qty_conversion) =>
+         Create(orders.Select(o => (o, qty_conversion)));

-      public WorkingOrderData Add(OrderRecordImmutable order) {
+      public static WorkingOrderData Create(IEnumerable<(OrderRecordImmutable order, QuantityConversionData qty_conversion)> orders) =>
+         orders.Aggregate(Empty, (seed, tup) => seed.Add(tup.order, tup.qty_conversion));
+
+      public WorkingOrderData Add(OrderRecordImmutable order, QuantityConversionData qty_conversion) {
         if (order.working_quantity() <= 0)
            return new WorkingOrderData(long_data, short_data);
         switch (order.side()) {
-            case Side.Buy: return new WorkingOrderData(long_data.Add(order), short_data);
-            case Side.Sell: return new WorkingOrderData(long_data, short_data.Add(order));
+            case Side.Buy: return new WorkingOrderData(long_data.Add(order, qty_conversion), short_data);
+            case Side.Sell: return new WorkingOrderData(long_data, short_data.Add(order, qty_conversion));
            default: throw ExceptionBuilder.Argument.unexpected_case(order.side(), "order.side");
         }
      }
@@ -165,18 +169,21 @@ namespace bts.shell.pnl {
   }

   readonly struct WorkingOrderSideData {
-      public readonly double avg_price;
-      public readonly ImmutableSortedDictionary<double, ImmutableDictionary<uint, OrderRecordImmutable>> data;
+      public readonly double avg_price, display_avg_price;
+      public readonly ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable order, QuantityConversionData qty_conversion)>> data;
      public readonly int working_total;
+      public readonly int display_working_total;

-      WorkingOrderSideData(double avg_price, int working_total, ImmutableSortedDictionary<double, ImmutableDictionary<uint, OrderRecordImmutable>> data) {
+      WorkingOrderSideData(double avg_price, int working_total, double display_avg_price, int display_working_total, ImmutableSortedDictionary<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>> data) {
         this.avg_price = avg_price;
         this.working_total = working_total;
+         this.display_avg_price = display_avg_price;
         this.data = data;
+         this.display_working_total = display_working_total;
      }

-      public static WorkingOrderSideData EmptyLong => new WorkingOrderSideData(double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, OrderRecordImmutable>>(new ReverseComparer<double>(OrderDataHelper.PriceComparer)));
-      public static WorkingOrderSideData EmptyShort => new WorkingOrderSideData(double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, OrderRecordImmutable>>(OrderDataHelper.PriceComparer));
+      public static WorkingOrderSideData EmptyLong => new WorkingOrderSideData(double.NaN, 0, double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>>(new ReverseComparer<double>(OrderDataHelper.PriceComparer)));
+      public static WorkingOrderSideData EmptyShort => new WorkingOrderSideData(double.NaN, 0, double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>>(OrderDataHelper.PriceComparer));

      public double top_price =>
         data.Count > 0 ?
@@ -185,23 +192,35 @@ namespace bts.shell.pnl {

      public int top_volume =>
         data.Count > 0 ?
-            data.Values.First().Values.Sum(o => o.working_quantity()) :
+            data.Values.First().Values.Sum(o => o.order.working_quantity()) :
            0;

-      public WorkingOrderSideData Add(OrderRecordImmutable order_record) {
-         uint order = order_record.Key;
+      public int display_top_volume =>
+         data.Count > 0 ?
+            data.Values.First().Values.Sum(o => o.qty_conversion.to_display(o.order.working_quantity())) :
+            0;
+
+      public WorkingOrderSideData Add(OrderRecordImmutable order_record) =>
+         Add(order_record, new QuantityConversionData());
+
+      public WorkingOrderSideData Add(OrderRecordImmutable order_record, QuantityConversionData qty_conversion) {
         int working_qty = order_record.working_quantity();
-         double price = order_record.price();
         if (working_qty <= 0)
            throw new ArgumentException(nameof(working_qty));
+         uint order = order_record.Key;
+         int dworking_qty = qty_conversion.to_display(working_qty);
+         double price = order_record.price();
         if (working_total == 0) {
-            return new WorkingOrderSideData(price, working_qty, data.Add(price, ImmutableDictionary<uint, OrderRecordImmutable>.Empty.Add(order, order_record)));
+            Log.assert(display_working_total == 0);
+            return new WorkingOrderSideData(price, working_qty, display_avg_price, dworking_qty, data.Add(price, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>.Empty.Add(order, (order_record, qty_conversion))));
         } else return new WorkingOrderSideData(
              avg_price + ((price - avg_price) * ((double)working_qty / (working_total + working_qty))),
              working_total + working_qty,
+              display_avg_price + ((price - display_avg_price) * ((double)dworking_qty / (display_working_total + dworking_qty))),
+              display_working_total + dworking_qty,
              data.SetItem(price, data.TryGetValue(price, out var curr) ?
-                 curr.Add(order, order_record) :
-                 ImmutableDictionary<uint, OrderRecordImmutable>.Empty.Add(order, order_record)));
+                 curr.Add(order, (order_record, qty_conversion)) :
+                 ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>.Empty.Add(order, (order_record, qty_conversion))));
      }

      public WorkingOrderSideData Remove(uint order, double price) {
@@ -210,22 +229,30 @@ namespace bts.shell.pnl {
            throw new KeyNotFoundException(nameof(price));
         if (!wdata.TryGetValue(order, out var worder))
            throw new KeyNotFoundException(nameof(order));
-         var wqty = worder.working_quantity();
+         var wqty = worder.order.working_quantity();
+         var dwqty = worder.qty_conversion.to_display(wqty);
         wdata = wdata.Remove(order);
         if (wdata.Count == 0)
            tmp_data = tmp_data.Remove(price);
         if (tmp_data.Count == 0)
-            return new WorkingOrderSideData(double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, OrderRecordImmutable>>(data.KeyComparer));
+            return new WorkingOrderSideData(double.NaN, 0, double.NaN, 0, ImmutableSortedDictionary.Create<double, ImmutableDictionary<uint, (OrderRecordImmutable, QuantityConversionData)>>(data.KeyComparer));
         return new WorkingOrderSideData(
            avg_price - ((price - avg_price) * (wqty / (working_total - wqty))),
            working_total - wqty,
+            display_avg_price - ((price - display_avg_price) * (dwqty / (display_working_total - dwqty))),
+            display_working_total - dwqty,
            tmp_data);
      }

      public override string ToString() {
         if (data.Count > 0) {
            var best_order = data.Values.First().Values.First();
-            return OrderUtils.order_collection_summary(best_order.price(), avg_price, best_order.working_quantity(), working_total, SecurityDataHelper.Defaults.ContractSpecificationImmutable);
+            return OrderUtils.order_collection_summary(
+               best_order.order.price(),
+               display_avg_price,
+               best_order.qty_conversion.to_display(best_order.order.working_quantity()),
+               display_working_total,
+               SecurityDataHelper.Defaults.ContractSpecificationImmutable);
         }
         return string.Empty;
      }
@@ -248,6 +275,7 @@ namespace bts.shell.pnl {

      public readonly PNLKey key;
      public readonly SecurityImmutable? security;
+      public readonly QuantityConversionData qty_conversion;
      public readonly string account_name;
      public readonly PNLCalculationType calc_type;
      public readonly PositionPriceSize day, raw_day, sod;
@@ -273,7 +301,8 @@ namespace bts.shell.pnl {
         WorkingOrderData? working = null,
         SecurityImmutable? security = null,
         string account_name = null,
-         PNLCalculationType calc_type = PNLCalculationType.Mid) {
+         PNLCalculationType calc_type = PNLCalculationType.Mid,
+         QuantityConversionData? qty_conversion = null) {
         //
         this.key = key;
         this.cpp = cpp;
@@ -288,6 +317,7 @@ namespace bts.shell.pnl {
         this.security = security;
         this.account_name = account_name;
         this.calc_type = calc_type;
+         this.qty_conversion = qty_conversion ?? new QuantityConversionData();
      }

      [Flags]
@@ -368,6 +398,10 @@ namespace bts.shell.pnl {
         MathUtils.weighted_average(
            sod_long_avg_price_delta_raw, sod.long_pos,
            sod_short_avg_price_delta_raw, sod.short_pos);
+      // display
+      public double display_sod_net_pos => qty_conversion.to_display(sod_net_pos);
+      public double display_sod_long_pos => qty_conversion.to_display(sod_long_pos);
+      public double display_sod_short_pos => qty_conversion.to_display(sod_short_pos);

      /// Day
      public double day_pnl => cpp *
@@ -395,11 +429,19 @@ namespace bts.shell.pnl {
         MathUtils.weighted_average(
            day_long_avg_price_delta_raw, day.long_pos,
            day_short_avg_price_delta_raw, day.short_pos);
+      // display
+      public double display_day_net_pos => qty_conversion.to_display(day_net_pos);
+      public double display_day_long_pos => qty_conversion.to_display(day_long_pos);
+      public double display_day_short_pos => qty_conversion.to_display(day_short_pos);

      /// Raw Day
      public double raw_day_long_pos => raw_day.long_pos;
      public double raw_day_short_pos => raw_day.short_pos;
      public double raw_day_net_pos => raw_day.net_pos;
+      // display
+      public double display_raw_day_net_pos => qty_conversion.to_display(raw_day_net_pos);
+      public double display_raw_day_long_pos => qty_conversion.to_display(raw_day_long_pos);
+      public double display_raw_day_short_pos => qty_conversion.to_display(raw_day_short_pos);

      /// Total
      public double total_pnl => DoubleUtil.nan_to_zero_sum(sod_pnl, day_pnl);
@@ -428,6 +470,10 @@ namespace bts.shell.pnl {
         MathUtils.weighted_average(
            total_long_avg_price_delta_raw, total_long_pos,
            total_short_avg_price_delta_raw, total_short_pos);
+      // display
+      public double display_total_net_pos => qty_conversion.to_display(total_net_pos);
+      public double display_total_long_pos => qty_conversion.to_display(total_long_pos);
+      public double display_total_short_pos => qty_conversion.to_display(total_short_pos);

      #region Working
      // long
@@ -453,6 +499,10 @@ namespace bts.shell.pnl {
         MathUtils.weighted_average(
            working_long_avg_price_delta_raw, working_long_pos,
            working_short_avg_price_delta_raw, working_short_pos);
+      // display
+      public double display_working_net_pos => qty_conversion.to_display(working_net_pos);
+      public double display_working_long_pos => qty_conversion.to_display(working_long_pos);
+      public double display_working_short_pos => qty_conversion.to_display(working_short_pos);
      #endregion

      WaterfallPriceFlags _waterfall_flags() {
@@ -508,7 +558,8 @@ namespace bts.shell.pnl {
         settlement_price.Equals(other.settlement_price) &&
         calc_type.Equals(other.calc_type) &&
         raw_day == other.raw_day &&
-         working.summary == other.working.summary;
+         working.summary == other.working.summary &&
+         qty_conversion == other.qty_conversion;

      public override bool Equals(object obj) =>
         obj is PNLRowData other && Equals(other);
@@ -523,7 +574,7 @@ namespace bts.shell.pnl {
   }

   static class PNLRowDataFactory {
-      public static PNLRowData create((SecurityImmutable? sec, PNLUnitImmutable value) t) =>
+      public static PNLRowData create((SecurityImmutable? sec, PNLUnitImmutable value, QuantityConversionData qty_conversion) t) =>
         new PNLRowData(new PNLKey(t.value.Pos.AccountId, t.value.Pos.SecurityId),
            t.value.CashValue,
            t.value.BidPrice,
@@ -535,7 +586,8 @@ namespace bts.shell.pnl {
            t.value.Pos.raw_day_pps(),
            WorkingOrderData.Empty,
            t.sec,
-            t.value.Pos.Account);
+            t.value.Pos.Account,
+            qty_conversion: t.qty_conversion);
   }

   static class PNLDataExtensions {
@@ -554,6 +606,7 @@ namespace bts.shell.pnl {
            working ?? pnl_data.working,
            security ?? pnl_data.security,
            account_name ?? pnl_data.account_name,
-            calc_type ?? pnl_data.calc_type);
+            calc_type ?? pnl_data.calc_type,
+            qty_conversion: pnl_data.qty_conversion);
   }
-}
+}
@@ -16,7 +16,15 @@ namespace bts.shell.pnl {
         decimal sod_long_pos,
         decimal sod_short_pos,
         decimal working_long_pos = 0,
-         decimal working_short_pos = 0) {
+         decimal working_short_pos = 0,
+         decimal? display_day_long_pos = null,
+         decimal? display_day_short_pos = null,
+         decimal? display_raw_day_long_pos = null,
+         decimal? display_raw_day_short_pos = null,
+         decimal? display_sod_long_pos = null,
+         decimal? display_sod_short_pos = null,
+         decimal? display_working_long_pos = null,
+         decimal? display_working_short_pos = null) {
         //
         this.day_pnl = day_pnl;
         this.day_long_pos = day_long_pos;
@@ -28,6 +36,15 @@ namespace bts.shell.pnl {
         this.sod_short_pos = sod_short_pos;
         this.working_long_pos = working_long_pos;
         this.working_short_pos = working_short_pos;
+         // display
+         this.display_day_long_pos = display_day_long_pos ?? day_long_pos;
+         this.display_day_short_pos = display_day_short_pos ?? day_short_pos;
+         this.display_raw_day_long_pos = display_raw_day_long_pos ?? raw_day_long_pos;
+         this.display_raw_day_short_pos = display_raw_day_short_pos ?? raw_day_short_pos;
+         this.display_sod_long_pos = display_sod_long_pos ?? sod_long_pos;
+         this.display_sod_short_pos = display_sod_short_pos ?? sod_short_pos;
+         this.display_working_long_pos = display_working_long_pos ?? working_long_pos;
+         this.display_working_short_pos = display_working_short_pos ?? working_short_pos;
      }

      // sod
@@ -35,24 +52,48 @@ namespace bts.shell.pnl {
      public decimal sod_long_pos { get; }
      public decimal sod_short_pos { get; }
      public decimal sod_net_pos => sod_long_pos - sod_short_pos;
+      // sod display
+      public decimal display_sod_long_pos { get; }
+      public decimal display_sod_short_pos { get; }
+      public decimal display_sod_net_pos => display_sod_long_pos - display_sod_short_pos;
+
      // day
      public decimal day_pnl { get; }
      public decimal day_long_pos { get; }
      public decimal day_short_pos { get; }
      public decimal day_net_pos => day_long_pos - day_short_pos;
+      // display
+      public decimal display_day_long_pos { get; }
+      public decimal display_day_short_pos { get; }
+      public decimal display_day_net_pos => display_day_long_pos - display_day_short_pos;
+
      // raw day
      public decimal raw_day_long_pos { get; }
      public decimal raw_day_short_pos { get; }
      public decimal raw_day_net_pos => raw_day_long_pos - raw_day_short_pos;
+      // display
+      public decimal display_raw_day_long_pos { get; }
+      public decimal display_raw_day_short_pos { get; }
+      public decimal display_raw_day_net_pos => display_raw_day_long_pos - display_raw_day_short_pos;
+
      // total
      public decimal total_pnl => sod_pnl + day_pnl;
      public decimal total_net_pos => total_long_pos - total_short_pos;
      public decimal total_long_pos => sod_long_pos + day_long_pos;
      public decimal total_short_pos => sod_short_pos + day_short_pos;
+      // display
+      public decimal display_total_long_pos => display_sod_long_pos + display_day_long_pos;
+      public decimal display_total_short_pos => display_sod_short_pos + display_day_short_pos;
+      public decimal display_total_net_pos => display_total_long_pos - display_total_short_pos;
+
      // working
      public decimal working_long_pos { get; }
-      public decimal working_net_pos => working_long_pos - working_short_pos;
      public decimal working_short_pos { get; }
+      public decimal working_net_pos => working_long_pos - working_short_pos;
+      // display
+      public decimal display_working_long_pos { get; }
+      public decimal display_working_short_pos { get; }
+      public decimal display_working_net_pos => display_working_long_pos - display_working_short_pos;

      public bool Equals(PNLNormalizedData other) =>
         day_pnl == other.day_pnl &&
@@ -64,6 +105,17 @@ namespace bts.shell.pnl {
         sod_long_pos == other.sod_long_pos &&
         sod_short_pos == other.sod_short_pos &&
         working_long_pos == other.working_long_pos &&
+         working_short_pos == other.working_short_pos &&
+         // display
+         sod_long_pos == other.sod_long_pos &&
+         sod_short_pos == other.sod_short_pos &&
+         day_long_pos == other.day_long_pos &&
+         day_short_pos == other.day_short_pos &&
+         raw_day_long_pos == other.raw_day_long_pos &&
+         raw_day_short_pos == other.raw_day_short_pos &&
+         total_long_pos == other.total_long_pos &&
+         total_short_pos == other.total_short_pos &&
+         working_long_pos == other.working_long_pos &&
         working_short_pos == other.working_short_pos;

      public override bool Equals(object obj) =>
@@ -102,7 +154,16 @@ namespace bts.shell.pnl {
            a.sod_long_pos + b.sod_long_pos,
            a.sod_short_pos + b.sod_short_pos,
            a.working_long_pos + b.working_long_pos,
-            a.working_short_pos + b.working_short_pos);
+            a.working_short_pos + b.working_short_pos,
+            // display
+            a.display_day_long_pos + b.display_day_long_pos,
+            a.display_day_short_pos + b.display_day_short_pos,
+            a.display_raw_day_long_pos + b.display_raw_day_long_pos,
+            a.display_raw_day_short_pos + b.display_raw_day_short_pos,
+            a.display_sod_long_pos + b.display_sod_long_pos,
+            a.display_sod_short_pos + b.display_sod_short_pos,
+            a.display_working_long_pos + b.display_working_long_pos,
+            a.display_working_short_pos + b.display_working_short_pos);

      public static PNLNormalizedData operator -(PNLNormalizedData a, PNLNormalizedData b) =>
         new PNLNormalizedData(
@@ -115,6 +176,15 @@ namespace bts.shell.pnl {
            a.sod_long_pos - b.sod_long_pos,
            a.sod_short_pos - b.sod_short_pos,
            a.working_long_pos - b.working_long_pos,
-            a.working_short_pos - b.working_short_pos);
+            a.working_short_pos - b.working_short_pos,
+            // display
+            a.display_day_long_pos - b.display_day_long_pos,
+            a.display_day_short_pos - b.display_day_short_pos,
+            a.display_raw_day_long_pos - b.display_raw_day_long_pos,
+            a.display_raw_day_short_pos - b.display_raw_day_short_pos,
+            a.display_sod_long_pos - b.display_sod_long_pos,
+            a.display_sod_short_pos - b.display_sod_short_pos,
+            a.display_working_long_pos - b.display_working_long_pos,
+            a.display_working_short_pos - b.display_working_short_pos);
   }
 }
@@ -14,7 +14,7 @@ namespace bts.shell.pnl {
      public readonly DIYGridAnimationModel<PNLView.Columns, TRow> animation_model = new DIYGridAnimationModel<PNLView.Columns, TRow>(TimeSpan.FromSeconds(0.3));

      static readonly Func<WorkingOrderSideData, string> _fmt_working_order_data =
-         d => OrderUtils.order_collection_summary(d.top_price, d.top_volume, d.working_total);
+         d => OrderUtils.order_collection_summary(d.top_price, d.display_top_volume, d.display_working_total);

      static readonly IComparer<WorkingOrderSideData> _working_total_comparer =
         Comparer<int>.Default.wrap<int, WorkingOrderSideData>(d => d.working_total);        
@@ -31,40 +31,40 @@ namespace bts.shell.pnl {
         security_type_cell = _cell_map.add(ColumnKeys.SecurityType, d => d.security?.ContractCase ?? Security.ContractOneofCase.None);
         exchange_cell = _cell_map.add(ColumnKeys.Exchange, d => d.security?.Exchange ?? Venue.Unset);
         symbol_cell = _cell_map.add(ColumnKeys.Symbol, d => d.security?.Symbol ?? string.Empty);
-         security_cell = _cell_map.add(ColumnKeys.Security, d => d.security, null, EqualityComparer<SecurityImmutable?>.Default, Comparer<SecurityImmutable>.Default.to_nullable());
+         security_cell = _cell_map.add(ColumnKeys.Security, d => (d.security), null, EqualityComparer<SecurityImmutable?>.Default, Comparer<SecurityImmutable>.Default.to_nullable());
         security_key = _cell_map.add(ColumnKeys.SecurityKey, d => d.key.security_id);
         cpp = _cell_map.add(ColumnKeys.CPP, d => d.cpp);
         // sod
         sod_pnl = _cell_map.add_pnl_double(ColumnKeys.SODPNL, d => d.sod_pnl);
-         sod_net_pos = _cell_map.add_net_pos(ColumnKeys.SODNetPos, d => d.sod_net_pos);
-         sod_long_pos = _cell_map.add_long_pos(ColumnKeys.SODLongPos, d => d.sod_long_pos);
+         sod_net_pos = _cell_map.add_net_pos(ColumnKeys.SODNetPos, d => d.display_sod_net_pos);
+         sod_long_pos = _cell_map.add_long_pos(ColumnKeys.SODLongPos, d => d.display_sod_long_pos);
         sod_long_avg_price = _cell_map.add_long_price(ColumnKeys.SODLongAvgPrice, d => d.sod_long_avg_price_raw);
-         sod_short_pos = _cell_map.add_short_pos(ColumnKeys.SODShortPos, d => d.sod_short_pos);
+         sod_short_pos = _cell_map.add_short_pos(ColumnKeys.SODShortPos, d => d.display_sod_short_pos);
         sod_short_avg_price = _cell_map.add_short_price(ColumnKeys.SODShortAvgPrice, d => d.sod_short_avg_price_raw);
         // day
         day_pnl = _cell_map.add_pnl_double(ColumnKeys.DayPNL, d => d.day_pnl);
-         day_net_pos = _cell_map.add_net_pos(ColumnKeys.DayNetPos, d => d.day_net_pos);
-         day_long_pos = _cell_map.add_long_pos(ColumnKeys.DayLongPos, d => d.day_long_pos);
+         day_net_pos = _cell_map.add_net_pos(ColumnKeys.DayNetPos, d => d.display_day_net_pos);
+         day_long_pos = _cell_map.add_long_pos(ColumnKeys.DayLongPos, d => d.display_day_long_pos);
         day_long_avg_price = _cell_map.add_long_price(ColumnKeys.DayLongAvgPrice, d => d.day_long_avg_price_raw);
-         day_short_pos = _cell_map.add_short_pos(ColumnKeys.DayShortPos, d => d.day_short_pos);
+         day_short_pos = _cell_map.add_short_pos(ColumnKeys.DayShortPos, d => d.display_day_short_pos);
         day_short_avg_price = _cell_map.add_short_price(ColumnKeys.DayShortAvgPrice, d => d.day_short_avg_price_raw);
         has_day_trades = _cell_map.add(ColumnKeys.HasDayTrades, d => d.has_day_trades, _fmt_has_day_trades);
         // raw day
-         raw_day_net_pos = _cell_map.add_net_pos(ColumnKeys.RawDayNetPos, d => d.raw_day_net_pos);
-         raw_day_long_pos = _cell_map.add_long_pos(ColumnKeys.RawDayLongPos, d => d.raw_day_long_pos);
-         raw_day_short_pos = _cell_map.add_short_pos(ColumnKeys.RawDayShortPos, d => d.raw_day_short_pos);
+         raw_day_net_pos = _cell_map.add_net_pos(ColumnKeys.RawDayNetPos, d => d.display_raw_day_net_pos);
+         raw_day_long_pos = _cell_map.add_long_pos(ColumnKeys.RawDayLongPos, d => d.display_raw_day_long_pos);
+         raw_day_short_pos = _cell_map.add_short_pos(ColumnKeys.RawDayShortPos, d => d.display_raw_day_short_pos);
         // working
-         working_net_pos = _cell_map.add_net_pos(ColumnKeys.WorkingNetPos, d => d.working_net_pos);
+         working_net_pos = _cell_map.add_net_pos(ColumnKeys.WorkingNetPos, d => d.display_working_net_pos);
         working_long_pos = _cell_map.add_working_long(ColumnKeys.WorkingLongPos, d => d.working.long_data, d => d.bid_price);
         working_long_avg_price = _cell_map.add_long_price(ColumnKeys.WorkingLongAvgPrice, d => d.working_long_avg_price_raw);
         working_short_pos = _cell_map.add_working_short(ColumnKeys.WorkingShortPos, r => r.working.short_data, r => r.ask_price);
         working_short_avg_price = _cell_map.add_short_price(ColumnKeys.WorkingShortAvgPrice, d => d.working_short_avg_price_raw);
         // total
         total_pnl = _cell_map.add_pnl_double(ColumnKeys.TotalPNL, d => d.total_pnl);
-         total_net_pos = _cell_map.add_net_pos(ColumnKeys.TotalNetPos, d => d.total_net_pos);
-         total_long_pos = _cell_map.add_long_pos(ColumnKeys.TotalLongPos, d => d.total_long_pos);
+         total_net_pos = _cell_map.add_net_pos(ColumnKeys.TotalNetPos, d => d.display_total_net_pos);
+         total_long_pos = _cell_map.add_long_pos(ColumnKeys.TotalLongPos, d => d.display_total_long_pos);
         total_long_avg_price = _cell_map.add_long_price(ColumnKeys.TotalLongAvgPrice, d => d.total_long_avg_price_raw);
-         total_short_pos = _cell_map.add_short_pos(ColumnKeys.TotalShortPos, d => d.total_short_pos);
+         total_short_pos = _cell_map.add_short_pos(ColumnKeys.TotalShortPos, d => d.display_total_short_pos);
         total_short_avg_price = _cell_map.add_short_price(ColumnKeys.TotalShortAvgPrice, d => d.total_short_avg_price_raw);
         // market
         bid_price = _cell_map.add_price_double(ColumnKeys.BidPrice, d => d.bid_price);
@@ -112,7 +112,16 @@ namespace bts.shell.pnl {
                  sod_long,
                  sod_short,
                  DoubleUtil.round_to_decimal(data.working_long_pos),
-                  DoubleUtil.round_to_decimal(data.working_short_pos));
+                  DoubleUtil.round_to_decimal(data.working_short_pos),
+                  // display
+                  DoubleUtil.round_to_decimal(data.display_day_long_pos),
+                  DoubleUtil.round_to_decimal(data.display_day_short_pos),
+                  DoubleUtil.round_to_decimal(data.display_raw_day_long_pos),
+                  DoubleUtil.round_to_decimal(data.display_raw_day_short_pos),
+                  DoubleUtil.round_to_decimal(data.display_sod_long_pos),
+                  DoubleUtil.round_to_decimal(data.display_sod_short_pos),
+                  DoubleUtil.round_to_decimal(data.display_working_long_pos),
+                  DoubleUtil.round_to_decimal(data.display_working_short_pos));
               if (_normalized_data != nd) {
                  _normalized_data = nd;
                  updated?.Invoke(nd);
@@ -206,4 +215,4 @@ namespace bts.shell.pnl {
      public override string ToString() =>
         $"account: {account_name} exchange: {exchange} symbol: {symbol} security: {security} buy_quantity: {day_long_pos} sell_quantity: {day_short_pos} pnl: {total_pnl}";
   }
-}
+}
@@ -112,27 +112,27 @@ namespace bts.shell.pnl {
         });
         // sod
         sod_pnl = _cell_map.add_pnl(ColumnKeys.SODPNL, d => d.sod_pnl);
-         sod_net_pos = _cell_map.add_net_pos(ColumnKeys.SODNetPos, d => d.sod_net_pos);
-         sod_long_pos = _cell_map.add_long_pos(ColumnKeys.SODLongPos, d => d.sod_long_pos);
-         sod_short_pos = _cell_map.add_short_pos(ColumnKeys.SODShortPos, d => d.sod_short_pos);
+         sod_net_pos = _cell_map.add_net_pos(ColumnKeys.SODNetPos, d => d.display_sod_net_pos);
+         sod_long_pos = _cell_map.add_long_pos(ColumnKeys.SODLongPos, d => d.display_sod_long_pos);
+         sod_short_pos = _cell_map.add_short_pos(ColumnKeys.SODShortPos, d => d.display_sod_short_pos);
         // day
         day_pnl = _cell_map.add_pnl(ColumnKeys.DayPNL, d => d.day_pnl);
-         day_net_pos = _cell_map.add_net_pos(ColumnKeys.DayNetPos, d => d.day_net_pos);
-         day_long_pos = _cell_map.add_long_pos(ColumnKeys.DayLongPos, d => d.day_long_pos);
-         day_short_pos = _cell_map.add_short_pos(ColumnKeys.DayShortPos, d => d.day_short_pos);
+         day_net_pos = _cell_map.add_net_pos(ColumnKeys.DayNetPos, d => d.display_day_net_pos);
+         day_long_pos = _cell_map.add_long_pos(ColumnKeys.DayLongPos, d => d.display_day_long_pos);
+         day_short_pos = _cell_map.add_short_pos(ColumnKeys.DayShortPos, d => d.display_day_short_pos);
         // raw day
-         raw_day_net_pos = _cell_map.add_net_pos(ColumnKeys.RawDayNetPos, d => d.raw_day_net_pos);
-         raw_day_long_pos = _cell_map.add_long_pos(ColumnKeys.RawDayLongPos, d => d.raw_day_long_pos);
-         raw_day_short_pos = _cell_map.add_short_pos(ColumnKeys.RawDayShortPos, d => d.raw_day_short_pos);
+         raw_day_net_pos = _cell_map.add_net_pos(ColumnKeys.RawDayNetPos, d => d.display_raw_day_net_pos);
+         raw_day_long_pos = _cell_map.add_long_pos(ColumnKeys.RawDayLongPos, d => d.display_raw_day_long_pos);
+         raw_day_short_pos = _cell_map.add_short_pos(ColumnKeys.RawDayShortPos, d => d.display_raw_day_short_pos);
         // total
         total_pnl = _cell_map.add(ColumnKeys.TotalPNL, d => d.total_pnl, FormattingDelegates.Price<decimal>.Value);
-         total_net_pos = _cell_map.add(ColumnKeys.TotalNetPos, d => d.total_net_pos);
-         total_long_pos = _cell_map.add(ColumnKeys.TotalLongPos, d => d.total_long_pos);
-         total_short_pos = _cell_map.add(ColumnKeys.TotalShortPos, d => d.total_short_pos);
+         total_net_pos = _cell_map.add(ColumnKeys.TotalNetPos, d => d.display_total_net_pos);
+         total_long_pos = _cell_map.add(ColumnKeys.TotalLongPos, d => d.display_total_long_pos);
+         total_short_pos = _cell_map.add(ColumnKeys.TotalShortPos, d => d.display_total_short_pos);
         // working
-         working_net_pos = _cell_map.add(ColumnKeys.WorkingNetPos, d => d.working_net_pos);
-         working_long_pos = _cell_map.add(ColumnKeys.WorkingLongPos, d => d.working_long_pos);
-         working_short_pos = _cell_map.add(ColumnKeys.WorkingShortPos, d => d.working_short_pos);
+         working_net_pos = _cell_map.add(ColumnKeys.WorkingNetPos, d => d.display_working_net_pos);
+         working_long_pos = _cell_map.add(ColumnKeys.WorkingLongPos, d => d.display_working_long_pos);
+         working_short_pos = _cell_map.add(ColumnKeys.WorkingShortPos, d => d.display_working_short_pos);

         _cell_map.on_row(data);
         _cell_map.set_appearances(_animator.cell_appearances);
@@ -10,6 +10,7 @@ namespace mbts.spark {
   class AlgoParamVM<T> : IAlgoParamVM<T>, INotifyPropertyChanged, ITemplateSelectorKey {
      readonly IEqualityComparer<T> _comparer;
      readonly string _template_key;
+      readonly Func<T, T> _to_display_value, _from_display_value;
      AlgoParamPermissions _permissions;
      bool _is_enabled, _has_value;
      T _committed_value, _value;
@@ -20,13 +21,15 @@ namespace mbts.spark {
      public AlgoParamVM(string id, string display_name, T value, string template_key = null)
         : this(id, display_name, value, EqualityComparer<T>.Default, template_key) { }

-      public AlgoParamVM(string id, string display_name, T value, IEqualityComparer<T> comparer, string template_key = null) {
+      public AlgoParamVM(string id, string display_name, T value, IEqualityComparer<T> comparer, string template_key = null, Func<T, T> to_display_value = null, Func<T, T> from_display_value = null) {
         this.id = id;
         this.display_name = display_name;
         _value = value;
         _committed_value = value;
         _comparer = comparer;
         _template_key = template_key;
+         _to_display_value = to_display_value;
+         _from_display_value = from_display_value;
      }

      public event PropertyChangedEventHandler PropertyChanged;
@@ -43,6 +46,10 @@ namespace mbts.spark {
               _toggle_is_dirty();
         }
      }
+      public T display_value {
+         get => _to_display_value == null ? value : _to_display_value(value);
+         set => this.value = _from_display_value == null ? value : _from_display_value(value);
+      }
      public AlgoParamPermissions permissions {
         get => _permissions;
         set {
@@ -54,6 +61,7 @@ namespace mbts.spark {
      public bool has_value { get => _has_value; set => _set(ref _has_value, value); }
      public bool is_dirty { get; private set; }
      object IAlgoParamVM.value { get => value; set => this.value = (T)value; }
+      object IAlgoParamVM.display_value { get => display_value; set => display_value = (T)value; }

      string ITemplateSelectorKey.key => _template_key;

@@ -64,6 +72,9 @@ namespace mbts.spark {
         }
      }

+      public void refresh_display_value() =>
+         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(display_value)));
+
      public IObservable<T> subscribe_value() {
         return Observable.Create<T>(o => {
            o.OnNext(_value);
@@ -113,6 +124,7 @@ namespace mbts.spark {
            value_changed(_value, _value = new_value);
         }
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(value)));
+         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(display_value)));
      }

      void _toggle_is_dirty() {
@@ -18,6 +18,7 @@ namespace mbts.spark {
      readonly Property<TimeInForce> _current_time_in_force;
      readonly Property<CustomOrderDefinition.CustomOneofCase> _current_order_type;
      readonly Property<bool> _price_dirty, _size_dirty, _account_dirty, _time_in_force_dirty, _order_type_dirty;
+      uint _display_quantity_divisor = 1;

      public ExistingOrderTicketVM(OrdersModel model, IObservable<(SecurityMD? security_md, OrderRecordImmutable order)> order_source, IObservable<int[]> calculator_buttons) {
         uint? key = null;
@@ -40,7 +41,7 @@ namespace mbts.spark {
            (val, curr) => !double.IsNaN(val) && val != curr));
         _size_dirty = backing(
            nameof(size_dirty),
-            size_calculator.observe_current(true)
+            size_calculator.observe_actual_value()
            .CombineLatest(_current_size.observe_current(true),
            (val, curr) => val.HasValue && val.Value != curr));
         _account_dirty = backing(
@@ -83,14 +84,17 @@ namespace mbts.spark {
         _dispose = Disposable.Create(
            size_calculator,
            properties_vm,
-            security_md_source.OnDispatcher().Subscribe(smd => bbo.security_md = smd),
+            security_md_source.OnDispatcher().Subscribe(smd => {
+               bbo.security_md = smd;
+               display_quantity_divisor = model.security_auxiliary_model.get_display_quantity_divisor(smd.security);
+            }),
            bbo,
            order_source.OnDispatcher().Subscribe(ort => {
               key = ort.order.Key;
               if (DoubleHelper.IsNaNOrInfinity(price))
                  price = ort.order.State.Price;
               if (!size_calculator.value.HasValue || !size_calculator.value_setter_called)
-                  size_calculator.bypass_value_setter(ort.order.State.Quantity);
+                  size_calculator.bypass_value_setter(ort.order.State.Quantity, true);
            }),
            Observable.Merge(_price_dirty, _size_dirty, _account_dirty, _time_in_force_dirty, _order_type_dirty).OnDispatcher().Subscribe(_ => RaisePropertyChanged(nameof(dirty_items_text))),
            _price_dirty.observe_current(true).CombineLatest(_size_dirty.observe_current(true), (pd, sd) => pd || sd).DistinctUntilChanged().OnDispatcher().Subscribe(modify_order));
@@ -104,6 +108,13 @@ namespace mbts.spark {
      public OrderPropertiesEditorVM properties_vm { get; }
      public double price { get => _price.Value; set => _price.Value = value; }
      public CalculatorLogic size_calculator { get; }
+      public uint display_quantity_divisor {
+         get => _display_quantity_divisor;
+         private set {
+            Set(ref _display_quantity_divisor, value);
+            size_calculator.display_divisor = value;
+         }
+      }
      public double current_price => _current_price.Value;
      public uint current_size => _current_size.Value;
      public AccountTuple current_account => _current_account.Value;
@@ -137,4 +148,4 @@ namespace mbts.spark {
         if (_order_type_dirty.Value) yield return "type";
      }
   }
-}
+}
@@ -31,6 +31,7 @@ namespace mbts.spark {

   class NewOrderTicketVM : DisposableViewModelBase, IRequestViewClose {
      readonly Property<SecurityImmutable> _security;
+      uint _display_quantity_divisor = 1;

      public NewOrderTicketVM(OrdersModel model, SecurityMD security_md, OrderDefinitionImmutable def, double price, uint size, IObservable<int[]> calculator_buttons)
         : this(model, Observable.Return(security_md), Observable.Return(new InlineOrderTicketProperties(model, def, price, size)), calculator_buttons) { }
@@ -61,7 +62,10 @@ namespace mbts.spark {
         set_price_command = new DelegateCommand<double>(set_price);
         _dispose = Disposable.Create(
            bbo,
-            security_md_source.OnDispatcher().Subscribe(smd => bbo.security_md = smd),
+            security_md_source.OnDispatcher().Subscribe(smd => {
+               bbo.security_md = smd;
+               display_quantity_divisor = model.security_auxiliary_model.get_display_quantity_divisor(smd.security);
+            }),
            size_calculator = new CalculatorLogic(0, calculator_buttons),
            props_source.OnDispatcher().Subscribe(p => on_props(p.price, p.size))
         );
@@ -83,6 +87,13 @@ namespace mbts.spark {
      public SecurityImmutable security => _security.Value;
      public double price { get; set; }
      public CalculatorLogic size_calculator { get; }
+      public uint display_quantity_divisor {
+         get => _display_quantity_divisor;
+         private set {
+            Set(ref _display_quantity_divisor, value);
+            size_calculator.display_divisor = value;
+         }
+      }
      public OrderPropertiesEditorVM properties_vm { get; }
      public BBOVM bbo { get; }
      public bool close_on_send { get; set; }
@@ -85,7 +85,7 @@
        usp:OrderModificationControl.IsDirty="{Binding size_dirty, FallbackValue={x:Null}}"
        CommitOnEnter="True"
        Focusable="False"
-        Value="{Binding size_calculator.value}"
+        Value="{Binding size_calculator.display_value}"
      />
    </Grid>
    <Grid Grid.Column="2">
@@ -114,15 +114,26 @@
        <ColumnDefinition/>
      </Grid.ColumnDefinitions>
      <Button
-        Content="{Binding bbo.bid_size}" Command="{Binding size_calculator.set_value_command}"
-        CommandParameter="{Binding bbo.bid_size}" Foreground="{u:BTSColor MarketData.bid}"
-      />
+        Command="{Binding size_calculator.set_actual_value_command}"
+        CommandParameter="{Binding bbo.bid_size}"
+        Foreground="{u:BTSColor MarketData.bid}"
+      >
+        <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}">
+          <Binding Path="bbo.bid_size"/>
+          <Binding Path="display_quantity_divisor"/>
+        </MultiBinding>
+      </Button>
      <Button
        Grid.Column="2"
-        Content="{Binding bbo.ask_size}" Command="{Binding size_calculator.set_value_command}"
+        Command="{Binding size_calculator.set_actual_value_command}"
        CommandParameter="{Binding bbo.ask_size}"
        Foreground="{u:BTSColor MarketData.ask}"
-      />
+      >
+        <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}">
+          <Binding Path="bbo.ask_size"/>
+          <Binding Path="display_quantity_divisor"/>
+        </MultiBinding>
+      </Button>
    </Grid>
    <Grid Grid.Row="4" Grid.RowSpan="3">
      <Grid.RowDefinitions>
@@ -139,9 +150,18 @@
        <ItemsControl.ItemTemplate>
          <DataTemplate>
            <Button
-              Margin="2,4,2,0" Content="{Binding}" Focusable="False" CommandParameter="{Binding}"
+              Margin="2,4,2,0"
+              Content="{Binding}"
+              Focusable="False"
              Command="{Binding Path=DataContext.click, RelativeSource={RelativeSource AncestorType=ItemsControl}}"
-            />
+            >
+              <Button.CommandParameter>
+                <MultiBinding Converter="{x:Static cv:DynamicDoubleMultiplierConverter.Instance}">
+                  <Binding/>
+                  <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=usp:OrderModificationControl}"/>
+                </MultiBinding>
+              </Button.CommandParameter>
+            </Button>
          </DataTemplate>
        </ItemsControl.ItemTemplate>
      </ItemsControl>
@@ -1,13 +1,16 @@
-<Window x:Class="mbts.ui.spark.OrderTicket"
-        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:msys="clr-namespace:bts.api;assembly=spark_api"
-        xmlns:u="clr-namespace:mbts.ui"
-        xmlns:usp="clr-namespace:mbts.ui.spark"
-        xmlns:sys="clr-namespace:System;assembly=mscorlib"
-        u:WindowStyle.SizeToContent="WidthAndHeight"
-        u:WindowStyle.TitleContent="{Binding bbo, Mode=OneWay}"
-        Style="{StaticResource BTSWindowTitleTemplate}">
+<Window
+  x:Class="mbts.ui.spark.OrderTicket"
+  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+  xmlns:msys="clr-namespace:bts.api;assembly=spark_api"
+  xmlns:u="clr-namespace:mbts.ui"
+  xmlns:cv="clr-namespace:mbts.ui.converters"
+  xmlns:usp="clr-namespace:mbts.ui.spark"
+  xmlns:sys="clr-namespace:System;assembly=mscorlib"
+  u:WindowStyle.SizeToContent="WidthAndHeight"
+  u:WindowStyle.TitleContent="{Binding bbo, Mode=OneWay}"
+  Style="{StaticResource BTSWindowTitleTemplate}"
+>
  <Window.Resources>
    <ResourceDictionary>
      <ResourceDictionary.MergedDictionaries>
@@ -123,7 +126,12 @@
      <TextBlock>
        <TextBlock.Inlines>
          <Run Text="{Binding security, Mode=OneWay}" FontWeight="Bold"/>
-          <Run Foreground="{u:BTSColor MarketData.bid}" FontSize="10" Text="{Binding bid_size, Mode=OneWay, StringFormat='{}({0})'}"/>
+          <Run Foreground="{u:BTSColor MarketData.bid}" FontSize="10">
+            <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}" Mode="OneWay" StringFormat="({0})">
+              <Binding Path="bid_size" Mode="OneWay"/>
+              <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=usp:OrderTicket}"/>
+            </MultiBinding>
+          </Run>
          <Run Foreground="{u:BTSColor MarketData.bid}" FontWeight="Bold">
            <Run.Text>
              <MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
@@ -140,7 +148,12 @@
              </MultiBinding>
            </Run.Text>
          </Run>
-          <Run Foreground="{u:BTSColor MarketData.ask}" FontSize="10" Text="{Binding ask_size, Mode=OneWay, StringFormat='{}({0})'}"/>
+          <Run Foreground="{u:BTSColor MarketData.ask}" FontSize="10">
+            <MultiBinding Converter="{x:Static cv:DynamicDoubleDivisorConverter.Instance}" Mode="OneWay" StringFormat="({0})">
+              <Binding Path="ask_size" Mode="OneWay"/>
+              <Binding Path="DataContext.display_quantity_divisor" RelativeSource="{RelativeSource AncestorType=usp:OrderTicket}"/>
+            </MultiBinding>
+          </Run>
        </TextBlock.Inlines>
      </TextBlock>
    </DataTemplate>
@@ -70,6 +70,7 @@ namespace mbts.spark {
      string id { get; }
      string display_name { get; }
      object value { get; set; }
+      object display_value { get; set; }
      bool is_enabled { get; set; }
      bool is_dirty { get; }
      bool has_value { get; }
@@ -81,6 +82,7 @@ namespace mbts.spark {
   interface IAlgoParamVM<T> : IAlgoParamVM {
      event PropertyChange<T> value_changed;
      new T value { get; set; }
+      new T display_value { get; set; }
   }

   interface IAlgoSelector : IAlgoParamVM<IAlgoVM>, IObserver<(IReadOnlyDictionary<AlgoKey, AlgoData> algo_data, AlgoKey? default_algo)> {
@@ -985,8 +985,10 @@ namespace mbts.spark {

         #region IAlgoParamVM
         IAlgoVM IAlgoParamVM<IAlgoVM>.value { get => selected_algo; set => selected_algo = value; }
+         IAlgoVM IAlgoParamVM<IAlgoVM>.display_value { get => selected_algo; set => selected_algo = value; }
         event PropertyChange<IAlgoVM> IAlgoParamVM<IAlgoVM>.value_changed { add => selected_algo_changed += value; remove => selected_algo_changed -= value; }
         object IAlgoParamVM.value { get => selected_algo; set => selected_algo = (IAlgoVM)value; }
+         object IAlgoParamVM.display_value { get => selected_algo; set => selected_algo = (IAlgoVM)value; }
         bool IAlgoParamVM.has_value => _algo != null;
         // changing child algos is not allowed, so an algo selector is never dirty
         bool IAlgoParamVM.is_dirty => false;
@@ -240,8 +240,8 @@ namespace mbts.spark {
      public static string price_quantity_description(double price, uint quantity, ContractSpecificationImmutable spec) =>
         new StringBuilderEx(quantity.ToString(), " @ ", spec.format(price) ?? price.ToString("#0.00##")).ToString();

-      public static string filled_status_description(this OrderRecordImmutable order, ContractSpecificationImmutable spec) {
-         var sb = new StringBuilderEx("filled ", order.filled().ToString());
+      public static string filled_status_description(this OrderRecordImmutable order, ContractSpecificationImmutable spec, uint display_qty_divisor = 1) {
+         var sb = new StringBuilderEx("filled ", order.filled().safe_divide(display_qty_divisor).ToString());
         if (order.filled() > 0)
            sb.Add(" @ ", spec.format(order.avg_price()));
         sb.Add(", ", camel_to_title_case(order.status().ToString(), TextCapitalizationFormat.NoCaps));
@@ -10,6 +10,7 @@ using bts.spark;
 using bts.utils;
 using mbts.config;
 using mbts.spark.utilities;
+using mbts.ui;
 using mbts.utils;
 using System;
 using System.Collections.Generic;
@@ -26,8 +27,9 @@ using OrderUpdatePiq = bts.api.core.TableUpdate<bts.api.orderman.OrderSecurity,
 namespace mbts.spark {
   [Export]
   class OrdersModel : IDisposable {
-      public readonly MarketDataAuxiliaryModel md_auxiliary_model;
      public static readonly bool piq_enabled = Configuration.get<bts.config.toggles.PlacementInQueue>().enabled;
+      public readonly MarketDataAuxiliaryModel md_auxiliary_model;
+      public readonly ISecurityAuxiliaryDataModel security_auxiliary_model;

      readonly IBus _bus;
      readonly OrderFactory _factory;
@@ -44,8 +46,20 @@ namespace mbts.spark {
      IDisposable _dispose;

      [ImportingConstructor]
-      OrdersModel(IBus bus, OrderFactory factory, OrderService service, PositionService position_service, MBOService mbo_service,
-         SpreaderModel spreader, DynamicOrderHelper dynamic_helper, AdminModel admin_model, IAlgoStudioModel algo_model, MarketDataAuxiliaryModel md_auxiliary_model, SecurityStore sstore, ErrorReporter error) {
+      OrdersModel(IBus bus,
+         OrderFactory factory,
+         OrderService service,
+         PositionService position_service,
+         MBOService mbo_service,
+         SpreaderModel spreader,
+         DynamicOrderHelper dynamic_helper,
+         AdminModel admin_model,
+         IAlgoStudioModel algo_model,
+         ISecurityAuxiliaryDataModel security_auxiliary_model,
+         MarketDataAuxiliaryModel md_auxiliary_model,
+         SecurityStore sstore,
+         ErrorReporter error) {
+         //
         _bus = bus;
         _factory = factory;
         _service = service;
@@ -57,6 +71,7 @@ namespace mbts.spark {
         this.admin_model = admin_model;
         this.algo_model = algo_model;
         this.md_auxiliary_model = md_auxiliary_model;
+         this.security_auxiliary_model = security_auxiliary_model;
         var scheduler = ThreadPoolScheduler.Instance;
         var interval = TimeSpan.FromMilliseconds(100);
         on_orders = admin_model
@@ -80,7 +95,10 @@ namespace mbts.spark {
               _position_service.subscribei_pnl_data().Naggle(interval, scheduler),
               p => p.Pos.AccountId)
            .join(sstore, p => p.Pos.SecurityId)
-            .TableCheckedAutoCorrect(EqualityComparer<(SecurityImmutable? sec, PNLUnitImmutable data)>.Default)
+            .Select(
+               tup => (tup.sec, tup.val, new QuantityConversionData(security_auxiliary_model.get_display_quantity_divisor(tup.sec), QuantityConversionData.OpType.DivideActual)),
+               tup => tup.val.RecordId)
+            .TableCheckedAutoCorrect(EqualityComparer<(SecurityImmutable?, PNLUnitImmutable, QuantityConversionData)>.Default)
            .Where(t => t.has_changes())
            .Cache();
         var working_orders = on_orders.Filter(tup => tup.order.is_active());
@@ -167,8 +185,8 @@ namespace mbts.spark {
               working_account_order_groups,
               PNLRowData.key_fn,
               acc_orders => acc_orders.group_key,
-               (pnl_row_data, acc_orders, pnl_key) => pnl_row_data.with(working: WorkingOrderData.Create(acc_orders.table.state.Values.Select(t => t.order))),
-               (pnl_row_data, pnl_id) => pnl_row_data,
+               (row, acc_orders, pnl_key) => row.with(working: WorkingOrderData.Create(acc_orders.table.state.Values.Select(t => t.order), row.qty_conversion)),
+               (row, pnl_id) => row,
               (acc_orders, pnl_id) => {
                  string account;
                  SecurityImmutable? security;
@@ -182,7 +200,9 @@ namespace mbts.spark {
                  return new PNLRowData(pnl_id,
                     security: security,
                     account_name: account,
-                     working: WorkingOrderData.Create(acc_orders.table.state.Values.Select(t => t.order)));
+                     working: WorkingOrderData.Create(
+                        acc_orders.table.state.Values.Select(t => t.order),
+                        new QuantityConversionData(security_auxiliary_model.get_display_quantity_divisor(security), QuantityConversionData.OpType.DivideActual)));
               },
               PNLRowData.key_fn)
               .Where(t => t.has_changes())
@@ -282,7 +302,7 @@ namespace mbts.spark {
      public IObservable<TableUpdate<FillTuple, string>> on_fill_tuples { get; }
      public IObservable<TableUpdate<FillTuple, string>> on_fill_tuples_with_root { get; }
      public IObservable<IReadOnlyDictionary<uint, OrderSecurity>> working_orders { get; }
-      public IObservable<TableUpdate<(SecurityImmutable?, PNLUnitImmutable), int>> on_pnl { get; }
+      public IObservable<TableUpdate<(SecurityImmutable?, PNLUnitImmutable, QuantityConversionData), int>> on_pnl { get; }
      public IObservable<TableUpdate<PNLRowData, PNLKey>> security_account_pnl { get; }
      public IObservable<TableUpdate<(SecurityImmutable?, PositionUnitImmutable), int>> on_positions { get; }
      public IObservable<TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>> studio_algos_with_meta { get; }
@@ -0,0 +1,45 @@
+using bts.api;
+using bts.utils;
+using mbts.config;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+
+namespace mbts.spark {
+   interface ISecurityAuxiliaryDataModel {
+      SecurityAuxiliaryData? get_auxiliary_data(SecurityImmutable security);
+   }
+
+   readonly struct SecurityAuxiliaryData {
+      public SecurityAuxiliaryData(uint quantity_divisor) =>
+         this.quantity_divisor = quantity_divisor;
+
+      public static SecurityAuxiliaryData Default => new SecurityAuxiliaryData(1);
+
+      public uint quantity_divisor { get; }
+   }
+
+   [Export(typeof(ISecurityAuxiliaryDataModel))]
+   class SecurityAuxiliaryDataModel : ISecurityAuxiliaryDataModel {
+      readonly Dictionary<string, SecurityAuxiliaryData> _auxiliary_data = new Dictionary<string, SecurityAuxiliaryData>();
+
+      public SecurityAuxiliaryDataModel() {
+         var sym_config = Configuration.get<bts.config.SymbolUIConfiguration>();
+         var sym_config_items = Configuration.get<bts.config.SymbolUIConfiguration>().items;
+         foreach (var item in sym_config_items)
+            _auxiliary_data[item.symbol] = new SecurityAuxiliaryData(item.display_quantity_divisor);
+      }
+
+      public SecurityAuxiliaryData? get_auxiliary_data(SecurityImmutable security) =>
+         security.ToString().SafeContains("ICE Lots") ?
+            new SecurityAuxiliaryData(1) :
+            _auxiliary_data.TryGetValue(security.Symbol, out var d) ? d : (SecurityAuxiliaryData?)null;
+   }
+
+   static class SecurityAuxiliaryDataModelExtensions {
+      public static uint get_display_quantity(this ISecurityAuxiliaryDataModel model, SecurityImmutable? security, uint actual_qty) =>
+         actual_qty.safe_divide(model.get_display_quantity_divisor(security));
+
+      public static uint get_display_quantity_divisor(this ISecurityAuxiliaryDataModel model, SecurityImmutable? security) =>
+         security.HasValue ? model.get_auxiliary_data(security.Value)?.quantity_divisor ?? 1 : 1;
+   }
+}
@@ -38,9 +38,6 @@ namespace mbts {
      public static bool IsNonZero(this double value) =>
         value != 0 && !double.IsNaN(value) && !double.IsInfinity(value);

-      public static bool IsRealNonZero(this double value) =>
-         value > 0 && value != double.PositiveInfinity;
-
      public static double CoerceNaN(double value) => CoerceNaN(value, 0.0);
      public static double CoerceNaN(double value, double if_nan) => double.IsNaN(value) ? if_nan : value;
      public static double CoerceNaNOrInfinity(double value) => CoerceNaNOrInfinity(value, 0.0);
@@ -0,0 +1,34 @@
+using ProtoBuf;
+using System;
+
+namespace bts.proto {
+   [ProtoContract]
+   readonly struct ToggleInt32Proto : IEquatable<ToggleInt32Proto> {
+      public ToggleInt32Proto(int value, bool is_enabled) {
+         this.value = value;
+         this.is_enabled = is_enabled;
+      }
+
+      [ProtoMember(1)]
+      public int value { get; }
+      [ProtoMember(2)]
+      public bool is_enabled { get; }
+
+      public bool Equals(ToggleInt32Proto other) =>
+         value == other.value && is_enabled == other.is_enabled;
+
+      public override bool Equals(object obj) =>
+         obj is ToggleInt32Proto other && Equals(other);
+
+      public override int GetHashCode() =>
+         (value % (1 << 31)) | (is_enabled ? 1 << 31 : 0);
+
+      public static bool operator ==(ToggleInt32Proto a, ToggleInt32Proto b) => a.Equals(b);
+      public static bool operator !=(ToggleInt32Proto a, ToggleInt32Proto b) => !a.Equals(b);
+   }
+
+   static class ToggleInt32ProtoExtensions {
+      public static int? as_nullable(this ToggleInt32Proto toggle) =>
+         toggle.is_enabled ? toggle.value : (int?)null;
+   }
+}
@@ -1,39 +1,43 @@
-using System;
-using System.Text.RegularExpressions;
+using System;
+using System.Text.RegularExpressions;
+
+namespace mbts.spark.filters {
+   static class RegexFilterUtils {
+      public static Regex build_regex(string str) {
+         if (str == null)
+            return null;
+         str = str.Trim();
+         if (str == string.Empty)
+            return null;
+         return new Regex(str, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
+      }
+   }
+   class RegexFilterVM<TRow> : FilterVMBase<TRow, string, string> {
+      string _text = string.Empty;
+      Regex _regex;
+
+      public RegexFilterVM(Func<TRow, string> get_row_val, string prop_name = null) : base(get_row_val, prop_name) { }
+
+      public string text {
+         get => _text;
+         set => _regex = RegexFilterUtils.build_regex(_text = (value ?? string.Empty));
+      }
+
+      public override string get_state() => _text ?? string.Empty;
+
+      protected override bool _get_active() => _regex != null;
+      protected override bool _filter(string value) =>
+         _regex != null && (
+            _regex.IsMatch(value) ||
+            (!string.IsNullOrEmpty(value) && _regex.IsMatch(value.Replace(" ", ""))));

-namespace mbts.spark.filters {
-   static class RegexFilterUtils {
-      public static Regex build_regex(string str) {
-         if (str == null)
-            return null;
-         str = str.Trim();
-         if (str == string.Empty)
-            return null;
-         return new Regex(str, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
-      }
-   }
-   class RegexFilterVM<TRow> : FilterVMBase<TRow, string, string> {
-      string _text = string.Empty;
-      Regex _regex;
-
-      public RegexFilterVM(Func<TRow, string> get_row_val, string prop_name = null) : base(get_row_val, prop_name) { }
-
-      public string text {
-         get => _text;
-         set => _regex = RegexFilterUtils.build_regex(_text = (value ?? string.Empty));
-      }
-
-      public override string get_state() => _text ?? string.Empty;
-
-      protected override bool _get_active() => _regex != null;
-      protected override bool _filter(string value) => _regex != null && _regex.IsMatch(value);
-      protected override void _load_state_internal(string state) => text = state;
-      protected override void _clear() {
-         _close();
-         _text = string.Empty;
-         _regex = null;
-         RaisePropertyChanged(nameof(text));
-         _raise_filter_changed();
-      }
-   }
+      protected override void _load_state_internal(string state) => text = state;
+      protected override void _clear() {
+         _close();
+         _text = string.Empty;
+         _regex = null;
+         RaisePropertyChanged(nameof(text));
+         _raise_filter_changed();
+      }
+   }
 }
@@ -0,0 +1,38 @@
+using bts.utils;
+using System;
+using System.Globalization;
+using System.Windows.Controls;
+using System.Windows.Data;
+
+namespace mbts.ui.converters {
+   [ValueConversion(typeof(double), typeof(string))]
+   class DoubleDivisorConverter : IValueConverter {
+      public double Divisor { get; set; }
+
+      public object Convert(object value, Type targetType, object parameter, CultureInfo culture) =>
+         value is double d ? d.safe_divide(Divisor) :
+         value is int i ? i.safe_divide(Divisor) :
+         value is uint u ? u.safe_divide(Divisor) :
+         double.NaN;
+
+      public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) =>
+         value is double d ? d * Divisor :
+         value is int i ? (double)i * Divisor :
+         value is uint u ? (double)u * Divisor :
+         double.NaN;
+   }
+
+   class DynamicDoubleDivisorConverter : IMultiValueConverter {
+      public static DynamicDoubleDivisorConverter Instance { get; } = new DynamicDoubleDivisorConverter();
+
+      public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) {
+         if (ConvertUtils.try_convert_args(values, out double value, out double div)) {
+            return value.safe_divide(div);
+         }
+         return new ValidationResult(false, "unable to convert values to doubles.");
+      }
+
+      public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) =>
+         throw new NotSupportedException();
+   }
+}
@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Windows.Controls;
 using System.Windows.Data;

 namespace mbts.ui.converters {
@@ -19,4 +20,18 @@ namespace mbts.ui.converters {
         value is uint u ? (double)u / Multiplier :
         double.NaN;
   }
-}
+
+   class DynamicDoubleMultiplierConverter : IMultiValueConverter {
+      public static DynamicDoubleMultiplierConverter Instance { get; } = new DynamicDoubleMultiplierConverter();
+
+      public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) {
+         if (ConvertUtils.try_convert_args(values, out double value, out double mult)) {
+            return value * mult;
+         }
+         return new ValidationResult(false, "unable to convert values to doubles.");
+      }
+
+      public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture) =>
+         throw new NotSupportedException();
+   }
+}
@@ -183,7 +183,7 @@ namespace mbts.ui.dpi {
      }

      public static void DrawHorizontalLine(this DrawingContext drawing_context, System.Windows.Media.Pen pen, Point start, double length, bool snap_to_device_pixels) {
-         if (pen == null || !length.IsRealNonZero()) {
+         if (pen == null || !length.is_real_positive()) {
            // no need to flip out and throw an exception
            return;
         }
@@ -1,4 +1,5 @@
-using System;
+using bts.utils;
+using System;
 using System.ComponentModel;
 using System.Windows.Markup;

@@ -19,7 +20,7 @@ namespace mbts.ui {
      public double RoundingUnit { get; set; }

      public override object ProvideValue(IServiceProvider serviceProvider) =>
-         RoundingUnit.IsRealNonZero() ? Math.Round(Value * RoundingUnit) / RoundingUnit : Value;
+         RoundingUnit.is_real_non_zero() ? Math.Round(Value * RoundingUnit) / RoundingUnit : Value;
   }

   internal class DoubleStringTypeConverter : TypeConverter
@@ -2,6 +2,7 @@
 using System;
 using System.IO;
 using System.Windows;
+using System.Windows.Input;
 using System.Windows.Media;

 namespace mbts.ui {
@@ -51,15 +52,19 @@ namespace mbts.ui {
         public void thread_init() { }
      }

-      public static IShellWindow create(IShellModule owner, string title, string window_type, Lazy<UIElement> content, Action<UIElement, Stream> get_state = null, ImageSource icon = null, string thread_id=null, Action<ShellWindowVM> on_shell_window_vm = null) {
+      public static IShellWindow create(IShellModule owner, string title, string window_type, Lazy<UIElement> content, Action<UIElement, Stream> get_state = null, ImageSource icon = null, string thread_id=null, Action<ShellWindowVM> on_shell_window_vm = null, Action<KeyEventArgs> on_key_down = null) {
+         IShellWindow rv = null;
         if (string.IsNullOrEmpty(thread_id)) {
-            return create<AnonShellWindow>(owner, title, window_type, content, get_state, icon, on_shell_window_vm);
+            rv = create<AnonShellWindow>(owner, title, window_type, content, get_state, icon, on_shell_window_vm);
+            if (on_key_down != null)
+               rv = new KeyListenerWrapper(rv, on_key_down);
         }
         else {
            var res = create<LazyAnonShellWindow>(owner, title, window_type, content, get_state, icon, on_shell_window_vm);
            res.thread_id = thread_id;
-            return res;
+            rv = on_key_down == null ? (ISharedWindow)res : new SharedKeyListenerWrapper(res, on_key_down);
         }
+         return rv;
      }
      static T create<T>(IShellModule owner, string title, string window_type, Lazy<UIElement> content, Action<UIElement,Stream> get_state=null, ImageSource icon=null, Action<ShellWindowVM> on_shell_window_vm = null) where T : AnonShellWindow, new() {
         var result = new T() {
@@ -121,5 +126,56 @@ namespace mbts.ui {
         if (cleanup != null) { window.Closed += (o, e) => cleanup.Dispose(); }
         return window;
      }
+
+      class KeyListenerWrapper<T> : IShellWindow, IKeyListener where T : class, IShellWindow {
+         readonly T _model;
+         readonly Action<KeyEventArgs> _key_down;
+
+         public KeyListenerWrapper(T model, Action<KeyEventArgs> key_down) {
+            _model = model ?? throw new ArgumentNullException(nameof(model));
+            _key_down = key_down ?? throw new ArgumentNullException(nameof(key_down));
+         }
+
+         public event Action TitleChanged {
+            add => _model.TitleChanged += value;
+            remove => _model.TitleChanged -= value;
+         }
+
+         public event Action IconChanged {
+            add => _model.IconChanged += value;
+            remove => _model.IconChanged -= value;
+         }
+
+         public string Title { get => _model.Title; set => _model.Title = value; }
+         public string window_type => _model.window_type;
+         public ImageSource Icon => _model.Icon;
+         public IShellModule Owner => _model.Owner;
+
+         public void Dispose() => _model.Dispose();
+         public ShellWindowUI GetContent() => _model.GetContent();
+         public void GetState(Stream save_here) => _model.GetState(save_here);
+         public void on_shell_window_vm(ShellWindowVM shell_window_vm) => _model.on_shell_window_vm(shell_window_vm);
+         public void key_down(KeyEventArgs e) =>
+            _key_down(e);
+      }
+
+      class KeyListenerWrapper : KeyListenerWrapper<IShellWindow> {
+         public KeyListenerWrapper(IShellWindow model, Action<KeyEventArgs> key_down)
+            : base(model, key_down) { }
+      }
+
+      class SharedKeyListenerWrapper : KeyListenerWrapper<ISharedWindow>, ISharedWindow {
+         readonly ISharedWindow _model;
+         readonly Action<KeyEventArgs> _key_down;
+
+         public SharedKeyListenerWrapper(ISharedWindow model, Action<KeyEventArgs> key_down)
+            : base(model, key_down) {
+            _model = model ?? throw new ArgumentNullException(nameof(model));
+            _key_down = key_down ?? throw new ArgumentNullException(nameof(key_down));
+         }
+
+         public string thread_id => _model.thread_id;
+         public void thread_init() => _model.thread_init();
+      }
   }
 }
@@ -10,6 +10,7 @@ using System.Linq;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using System.Windows;
+using System.Windows.Input;

 namespace mbts.ui.shell {
   // This Class owns the hierarchy of shell Windows
@@ -59,6 +60,14 @@ namespace mbts.ui.shell {
            viewmodel.host_id = state.host_id ?? "";
            viewmodel.TitleOverride = state.custom_title;
         }
+         if (model is IKeyListener key_listener) {
+            content.KeyDown += on_key_down;
+            void on_key_down(object sender, KeyEventArgs e) {
+               viewmodel.Dispatcher.InvokeAsync(() => {
+                  key_listener.key_down(e);
+               });
+            }
+         }
         var window = await CreateWindow(content, state);

         window.Show();
@@ -45,15 +45,16 @@ namespace mbts.spark {
      readonly SecurityImmutable _security;
      readonly MBOSecurityQueryImmutable _query;
      readonly Dictionary<(string,bool), FormattedText> _cache;
+      readonly Func<int, string> _fmt_mbo_qty;
      int _max_order_size = 1;
      double _height = 0;
      double _number_width = 0;

-
-      public MBOPopupModel(MBOService mbo, SecurityImmutable security, MBOSecurityQueryImmutable query) {
+      public MBOPopupModel(MBOService mbo, SecurityImmutable security, MBOSecurityQueryImmutable query, Func<int, string> fmt_mbo_qty) {
         _mbo = mbo;
         _security = security;
         _query = query;
+         _fmt_mbo_qty = fmt_mbo_qty ?? new Func<int, string>(v => v.ToString());

         // prime the cache with numbers on the left hand side
         _cache =
@@ -110,7 +111,7 @@ namespace mbts.spark {

         pdp.row_numbers = p.orders.Select((o, i) => format_text((i+1).ToString(), ismine(o))).ToList();
         pdp.numbers_width = _number_width = Math.Max(_number_width, (int)pdp.row_numbers.Max(r => r.Width) + text_margin);
-         pdp.row_labels = p.orders.Select(o => format_text(o.Size.ToString() + (ismine(o) ? "*" : ""), ismine(o))).ToList();
+         pdp.row_labels = p.orders.Select(o => format_text(_fmt_mbo_qty(o.Size) + (ismine(o) ? "*" : ""), ismine(o))).ToList();
         var max_label_width = pdp.row_labels.Max(l => l.Width) + text_margin;

         var available_width = pdp.width - pdp.numbers_width - max_label_width;
@@ -7,26 +7,53 @@ using System.Windows.Input;
 namespace mbts.spark {
   public class CalculatorLogic : DisposableViewModelBase {
      readonly UserProperty<uint?> _value;
+      readonly OptionalDisplayQuantityMultiplier _display_translator = new OptionalDisplayQuantityMultiplier();
+      IDisposable _prop_changes_echo;
      int[] _buttons;

-      public CalculatorLogic(uint? initial_size) =>
+      public CalculatorLogic(uint? initial_size) {
         _value = new UserProperty<uint?>(backing(nameof(value), initial_size));
+         _echo_props_changed();
+      }

      public CalculatorLogic(uint? initial_size, IObservable<int[]> buttons_source) : this(initial_size) =>
         _dispose = buttons_source.Subscribe(newval => buttons = newval);

-      public uint? value { get => _value.Value; set => _value.Value = value; }
+      public uint display_divisor {
+         get => _display_translator.conversion_data.value;
+         set => _display_translator.conversion_data = new QuantityConversionData(value, QuantityConversionData.OpType.DivideActual);
+      }
+      public uint? value {
+         get => _display_translator.actual_value;
+         set => _display_translator.actual_value = value;
+      }
+      public uint? display_value {
+         get => _display_translator.display_value;
+         set => _display_translator.display_value = value;
+      }
      public bool value_setter_called => _value.setter_called;
-      public IObservable<uint?> value_observable => _value.Select(vals => vals.newval);
      public int[] buttons { get => _buttons; set => Set(ref _buttons, value); }
      public ICommand click => new DelegateCommand<uint>(handle_calculator_click);
-      public ICommand set_value_command => new DelegateCommand<uint>(v => _value.Value = v);
-      public ICommand clear => new DelegateCommand(() => _value.Value = null);
+      public ICommand set_display_value_command => new DelegateCommand<uint>(v => _display_translator.display_value = v);
+      public ICommand set_actual_value_command => new DelegateCommand<uint>(v => _display_translator.actual_value = v);
+      public ICommand clear => new DelegateCommand(() => _display_translator.actual_value = null);

-      public IObservable<uint?> observe_current(bool start_immediately = false) =>
-         _value.observe_current(start_immediately);
+      public IObservable<uint?> observe_actual_value() =>
+         _display_translator.subscribe_actual_value();

-      public void bypass_value_setter(uint value) => _value.bypass_setter(value);
+      // Don't use a default value for 'is_actual_value.'
+      // Quietly multiplying (or not multiplying) the size input is dangerous -
+      // force the caller to be specific.
+      public void bypass_value_setter(uint value, bool is_actual_value) {
+         Disposable.dispose(ref _prop_changes_echo);
+         if (is_actual_value) {
+            this.value = value;
+         } else {
+            display_value = value;
+         }
+         if (_prop_changes_echo != null)
+            _echo_props_changed();
+      }

      public bool validate() {
         if (!value.HasValue || value.Value == 0) {
@@ -38,25 +65,34 @@ namespace mbts.spark {
      public void flash_error() =>
         flash_error(nameof(value)).ignore();

+      protected override void Dispose(bool disposing) {
+         Disposable.dispose(ref _prop_changes_echo);
+         base.Dispose(disposing);
+      }
+
+      void _echo_props_changed() {
+         // dispose the echo to avoid raising prop changed events more than once
+         _prop_changes_echo?.Dispose();
+         _prop_changes_echo = _display_translator.connect_owner(this, nameof(display_value), nameof(value));
+      }
+
      void handle_calculator_click(uint value) {
         if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift) || value == 0) {
-            _value.Value = value;
+            _display_translator.actual_value = value;
         } else if (KeyboardExtensions.IsCtrlDown()) {
-            if (!_value.Value.HasValue)
-               _value.Value = 0;
-            else {
-               if (value > _value.Value)
-                  _value.Value = 0;
-               else
-                  _value.Value -= value;
+            if (!_display_translator.actual_value.HasValue) {
+               _display_translator.actual_value = 0;
+            } else if (value > _display_translator.actual_value) {
+               _display_translator.actual_value = 0;
+            } else {
+               _display_translator.actual_value -= value;
            }
-         }
-         else {
-            if (!_value.Value.HasValue)
-               _value.Value = value;
+         } else {
+            if (!_display_translator.actual_value.HasValue)
+               _display_translator.actual_value = value;
            else
-               _value.Value += value;
+               _display_translator.actual_value += value;
         }
      }
   }
-}
+}
@@ -0,0 +1,172 @@
+using bts.utils;
+using mbts.ui.shell;
+using System;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+
+namespace mbts.ui {
+   interface IDisplayTranslator<T> {
+      T display_value { get; set; }
+      T actual_value { get; set; }
+      event Action value_changed;
+   }
+
+   readonly struct QuantityConversionData : IEquatable<QuantityConversionData> {
+      public QuantityConversionData(uint value, OpType op) {
+         this.value = value;
+         this.op = op;
+      }
+
+      public enum OpType {
+         None,
+         MultiplyActual,
+         DivideActual
+      }
+
+      public uint value { get; }
+      public OpType op { get; }
+
+      public bool Equals(QuantityConversionData other) =>
+         value == other.value &&
+         op == other.op;
+
+      public override bool Equals(object obj) =>
+         obj is QuantityConversionData other && Equals(other);
+
+      public override int GetHashCode() =>
+         EqualityComparer.auto_phase(value.GetHashCode(), op.GetHashCode());
+
+      public static bool operator ==(QuantityConversionData x, QuantityConversionData y) => x.Equals(y);
+      public static bool operator !=(QuantityConversionData x, QuantityConversionData y) => !x.Equals(y);
+   }
+
+   class DisplayQuantityMultiplier : IDisplayTranslator<uint> {
+      uint _actual_value;
+      QuantityConversionData _conversion_data;
+
+      public event Action value_changed;
+
+      public uint actual_value {
+         get => _actual_value;
+         set {
+            if (_actual_value != value) {
+               _actual_value = value;
+               value_changed?.Invoke();
+            }
+         }
+      }
+
+      public uint display_value {
+         get => _conversion_data.to_display(_actual_value);
+         set => actual_value = _conversion_data.from_display(value);
+      }
+
+      public QuantityConversionData conversion_data {
+         get => _conversion_data;
+         set {
+            if (_conversion_data != value) {
+               _conversion_data = value;
+               value_changed?.Invoke();
+            }
+         }
+      }
+   }
+
+   class OptionalDisplayQuantityMultiplier : IDisplayTranslator<uint?> {
+      uint? _actual_value;
+      QuantityConversionData _conversion_data;
+
+      public event Action value_changed;
+
+      public uint? actual_value {
+         get => _actual_value;
+         set {
+            if (_actual_value != value) {
+               _actual_value = value;
+               value_changed?.Invoke();
+            }
+         }
+      }
+
+      public uint? display_value {
+         get => _actual_value.HasValue ? _conversion_data.to_display(_actual_value.Value) : _actual_value;
+         set => actual_value = value.HasValue ? _conversion_data.from_display(value.Value) : value;
+      }
+
+      public QuantityConversionData conversion_data {
+         get => _conversion_data;
+         set {
+            if (_conversion_data != value) {
+               _conversion_data = value;
+               value_changed?.Invoke();
+            }
+         }
+      }
+   }
+
+   static class DisplayTranslatorExtensions {
+      public static IDisposable connect_owner<T>(this IDisplayTranslator<T> display_translator, IRaiseNotifyPropertyChanged owner, params string[] properties) {
+         if (display_translator is null)
+            throw new ArgumentNullException(nameof(display_translator));
+         if (owner is null)
+            throw new ArgumentNullException(nameof(owner));
+         display_translator.value_changed += on_value_changed;
+         return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
+         void on_value_changed() {
+            for (int i = 0; i < properties.Length; i++)
+               owner.raise_notify_property_changed(properties[i]);
+         }
+      }
+
+      public static IObservable<T> subscribe_actual_value<T>(this IDisplayTranslator<T> display_translator) =>
+         subscribe_actual_value(display_translator, EqualityComparer<T>.Default);
+
+      public static IObservable<T> subscribe_actual_value<T>(this IDisplayTranslator<T> display_translator, IEqualityComparer<T> comparer) {
+         if (comparer is null)
+            throw new ArgumentNullException(nameof(comparer));
+         return Observable.Create<T>(o => {
+            var curr = display_translator.actual_value;
+            o.OnNext(curr);
+            display_translator.value_changed += on_value_changed;
+            return Disposable.Create(() => display_translator.value_changed -= on_value_changed);
+            void on_value_changed() {
+               var next = display_translator.actual_value;
+               if (!comparer.Equals(curr, next))
+                  o.OnNext(curr = next);
+            }
+         });
+      }
+
+      public static uint to_display(this QuantityConversionData quantity_conversion_data, uint actual_value) {
+         switch (quantity_conversion_data.op) {
+            case QuantityConversionData.OpType.DivideActual: return actual_value.safe_divide(quantity_conversion_data.value);
+            case QuantityConversionData.OpType.MultiplyActual: return actual_value * quantity_conversion_data.value;
+            default: return actual_value;
+         }
+      }
+
+      public static int to_display(this QuantityConversionData quantity_conversion_data, int actual_value) {
+         switch (quantity_conversion_data.op) {
+            case QuantityConversionData.OpType.DivideActual: return (int)(actual_value.safe_divide(quantity_conversion_data.value));
+            case QuantityConversionData.OpType.MultiplyActual: return (int)(actual_value * quantity_conversion_data.value);
+            default: return actual_value;
+         }
+      }
+
+      public static double to_display(this QuantityConversionData quantity_conversion_data, double actual_value) {
+         switch (quantity_conversion_data.op) {
+            case QuantityConversionData.OpType.DivideActual: return actual_value.safe_divide(quantity_conversion_data.value);
+            case QuantityConversionData.OpType.MultiplyActual: return actual_value * quantity_conversion_data.value;
+            default: return actual_value;
+         }
+      }
+
+      public static uint from_display(this QuantityConversionData quantity_conversion_data, uint display_value) {
+         switch (quantity_conversion_data.op) {
+            case QuantityConversionData.OpType.DivideActual: return display_value * quantity_conversion_data.value;
+            case QuantityConversionData.OpType.MultiplyActual: return display_value.safe_divide(quantity_conversion_data.value);
+            default: return display_value;
+         }
+      }
+   }
+}
@@ -109,6 +109,9 @@ namespace mbts.ui.spark {
      /// These are private members, so any code-readability cost is confined to a limited scope.
      delegate void _SizeFormatter(ref uint merged, ref uint implied, ref StringBuilder sb);
      delegate void _SizeFormatterNPS(ref NativePriceSize nps, ref StringBuilder sb);
+
+      public static Func<uint, string> get_value_formatter(uint divisor) =>
+         value => (value / divisor).ToString();
     
      public static Func<NativePriceSize, string> get_formatter_nps(MarketSizeDisplay size_display) {
         _SizeFormatterNPS implied_absent = _get_formatter_nps(size_display.normal);
@@ -120,6 +123,11 @@ namespace mbts.ui.spark {
         };
      }

+      public static Func<NativePriceSize, string> get_formatter_nps(MarketSizeDisplay size_display, uint display_divisor) {
+         var raw_fmt_size = get_formatter(size_display);
+         return nps => raw_fmt_size((nps.implied_size + nps.direct_size) / display_divisor, nps.implied_size / display_divisor);
+      }
+
      public static SizeFormatter get_formatter(MarketSizeDisplay size_display) {
         _SizeFormatter implied_absent = _get_formatter(size_display.normal);
         _SizeFormatter implied_present = _get_formatter(size_display.implied_present ?? size_display.normal);
@@ -281,4 +289,4 @@ namespace mbts.ui.spark {
         public void refresh() => _display.refresh();
      }
   }
-}
+}
@@ -39,13 +39,18 @@ namespace bts.api {

      static string _format(SecurityImmutable? security) {
         switch (security?.ContractCase) {
-            case ContractOneofCase.Future: return format_future(security?.Symbol, security?.security_desc(), security.Value.Future);
+            case ContractOneofCase.Future:
+               if(security?.HasIce == true)
+                  return _format_ICE(security);
+               return format_future(security?.Symbol, security?.security_desc(), security.Value.Future);
            case ContractOneofCase.Spread:
               if (security?.HasGlbx == true) {
                  // In case we ever bring it back, pretty printed spread names can be found here:
                  // GlbxSecurityFormatter.FormatSpread(security, out string result)
                  return security?.Glbx.SecurityDesc;
               }
+               else if(security?.HasIce == true)
+                  return _format_ICE(security);
               return string.Join("", _format_future_legs(SecurityHelper.get_flat_future_legs(security?.Spread.Legs)));
            case ContractOneofCase.Synthetic: return security?.Synthetic.Name;
            default: return "Unknown-security";
@@ -79,5 +84,28 @@ namespace bts.api {
            default: return $"{fl.quantity:+0;-0}{sym_exp_name}";
         }
      }
+
+      static string _format_ICE (SecurityImmutable? security){
+         string symbol = security?.Symbol,
+                strip = security?.Ice.StripName,
+                md_desc = security?.Ice.MarketDescription,
+                type_append = "";
+  
+         if(md_desc.Contains("25k ICE Lots")){
+            if(md_desc.Contains("TAS"))
+               type_append = "TAS";
+         }
+         else if(md_desc.Contains("ICE Lots")){
+            if(md_desc.Contains("TAS"))
+               type_append = "ICE Lots TAS";
+            else
+               type_append = "ICE Lots";
+         }
+         else if(md_desc.Contains("TAS"))
+            type_append = "TAS";
+         type_append = string.IsNullOrEmpty(type_append) ? 
+                                                " " : $" {type_append} ";
+         return $"{symbol}{type_append}{strip}";
+      }
   }
 }
@@ -110,6 +110,28 @@ namespace bts.utils {
         return epsilon_equals(with_int_value, d);
      }

+      public static bool is_real(this double value) {
+         switch (value) {
+            case double.PositiveInfinity:
+            case double.NegativeInfinity:
+            case double.NaN:
+               return false;
+            default:
+               return true;
+         }
+      }
+
+      public static bool is_real_positive(this double value) =>
+         value > 0 && value != double.PositiveInfinity;
+
+      public static bool is_real_negative(this double value) =>
+         value < 0 && value != double.NegativeInfinity;
+
+      public static bool is_real_non_zero(this double value) =>
+         value > 0 ?
+            !double.IsPositiveInfinity(value) :
+            value < 0 && !double.IsNegativeInfinity(value);
+
      public static double factor_out(double value, params double[] factors) {
         foreach (double f in factors)
            value = factor_out(value, f, out int _);
@@ -129,6 +151,27 @@ namespace bts.utils {
         return value;
      }

+      public static int safe_divide(this int value, int divisor) =>
+         divisor == 0 ? value : value / divisor;
+
+      public static int safe_divide(this int value, uint divisor) =>
+         divisor == 0 ? value : (int)(value / divisor);
+
+      public static double safe_divide(this int value, double divisor) =>
+         divisor.is_real_non_zero() ? value / divisor : value;
+
+      public static uint safe_divide(this uint value, uint divisor) =>
+         divisor == 0 ? value : value / divisor;
+
+      public static double safe_divide(this uint value, double divisor) =>
+         divisor.is_real_non_zero() ? value / divisor : value;
+
+      public static ulong safe_divide(this ulong value, uint divisor) =>
+         divisor == 0 ? value : value / divisor;
+
+      public static double safe_divide(this double value, double divisor) =>
+         divisor.is_real_non_zero() && value.is_real_non_zero() ? value / divisor : value;
+
      /// <summary>
      /// Adds <see cref="mod"/> to the modulos result if negative.
      /// </summary>
@@ -14,6 +14,9 @@ namespace bts.utils {
   }

   public static class FormattingDelegates {
+      public static Func<T, string> default_string<T>() =>
+         v => v.ToString();
+
      public static class Price {
         public static readonly Func<double, string> Value =
            p => double.IsNaN(p) ? "" : p.ToString("#,0.00");
@@ -13,5 +13,8 @@ namespace bts.utils {
      [Pure]
      public static bool IsNullOrEmpty(this string str) =>
         string.IsNullOrEmpty(str);
+
+      public static bool SafeContains(this string str, string value) =>
+         str != null && str.Contains(value);
   }
 }
@@ -15,7 +15,7 @@
        <server name="default">
            <ip>63.247.113.163</ip>
            <port>3000</port>
-            <userName>bluetrd-ps</userName>
+            <userName>katas2f-ps</userName>
            <password>Starts123</password>
            <getStripInfoMessages>N</getStripInfoMessages>
            <strategyPreference>New</strategyPreference>
@@ -24,8 +24,8 @@
        <server name="endex">
            <ip>63.247.113.77</ip>
            <port>3000</port>
-            <userName>Value from ICE Support</userName>
-            <password>Value from ICE Support</password>
+            <userName>katas2f-ps</userName>
+            <password>Starts123</password>
            <getStripInfoMessages>N</getStripInfoMessages>
            <strategyPreference>New</strategyPreference>
            <localNetworkInterface></localNetworkInterface>
@@ -105,14 +105,35 @@ message BasePositionBatch {
  google.protobuf.Timestamp current_as_of = 10;  // UTC
 }

+// security overrides /////////////////////////////////////
+message CppOverride{
+   double value = 1;
+}
+
+message SecurityParameters{
+  uint32 security_key = 1;
+  CppOverride cpp_override = 2;
+  // other overrides
+}
+
+message SecurityParametersBatchOp{
+  repeated SecurityParameters op_params = 1;
+}
+
+message SecurityParametersBatchOpResponse {
+  bool ok = 1;
+  string msg = 2;
+}
+
 service PositionService {
  option (bts.api.service_description) = "Provides Position and PNL, per security, per account";
  
  rpc create_manual_fill (ManualFillBatch) returns (PositionServiceResponse);
  rpc update_manual_fill (ManualFillBatch) returns (PositionServiceResponse);
  rpc remove_manual_fill (ManualFillBatch) returns (PositionServiceResponse);
-  rpc set_base_position (BasePositionBatch) returns (SetBasePositionResponse);
-  
+  rpc set_base_position (BasePositionBatch) returns (SetBasePositionResponse);  
+  rpc update_security_parameters (SecurityParametersBatchOp) returns (SecurityParametersBatchOpResponse);
+
  // subscription
  rpc manual_fills(bts.api.VoidMessage) returns (stream ManualFill);
  rpc position_data(bts.api.VoidMessage) returns (stream PositionUnit);
@@ -1,136 +1,130 @@
-#
-# Common Market data options
-#
-
-MarketDataConfig {
-   rule: "DeploymentType.type == 'PROD'"
-   value {
-      use_sim: false
-   }
-}
-
-PublisherOptions {
-    rule: "DeploymentType.type == 'dev'"
-    value {
-        disable_heartbeat: true
-    }
-}
-
-PlatformMap {
-    value {
-        glbx_platform: "PLATFORM_MDP3ONIXS"
-        ice_platform: "PLATFORM_ICEONIXS"
-    }
-}
-
-PublisherNamespace {
-	value {
-		shared_memory_namespace: @System.os_user
-	}
-}
-
-CMEOptions {
-    value {
-        feed_engine {
-            name: "mdp3feed"
-            # udp_socket_buffer_size: 425984
-            # channels_per_thread: 1
-            spin_time: 0
-        }
-        channel {
-            id: "*"
-            feed_engine: "mdp3feed"
-            use_tcp_replay: false
-        }
-    }
-}
-
-ICEPublisherOptions {
-   value { 
-      network_interface: "eth1"
-   }
-}
-
-#to make this work in dev clone the operations repo
-#go here: c:\\code\\bts\\operations\\ice\\ICE_iMpactMulticastFeed_GettingStarted-1_1_36\\bin\\easyTunnel>
-#modify the easyTunnelProxy.properties file to replace 
-#tunnel.multicast.interface=10.96.18.37 with your local ip
-#run easyTunnelProxy.bat BRENT-FI for Brent Full implied
-#you should see ice data
-
-ICEOptions {
-   value {
-      channel {
-         name: "oil" #these names are arbitrary and are for debugging
-         market_type: 3 
-         uds_market_type: 3
-         market_type: 4 #ICE IPE Gas Oil Futures
-         uds_market_type: 4         
-         market_type: 5 #ICE Futures Brent, IPE Brent Futures
-         uds_market_type: 5
-         market_type: 9 #ICE Futures WTI, ICE WTI Crude Futures                  
-         uds_market_type: 9
-         market_type: 13 #ICE Heating Oil Futures         
-         uds_market_type: 13
-         market_type: 15 #ICE NYH (RBOB) Gasoline Futures
-         uds_market_type: 15
-         ##market_type: 21 #ICE Futures US Agricultures, Coffee C
-         ##uds_market_type: 21
-         ##market_type: 23 #ICE Futures US Agricultures, FCOJ A
-         ##uds_market_type: 23               
-         
-         ##market_type: 26 #ICE Futures US Financials DX
-         ##uds_market_type: 26
-         
-         uds_market_type: 11 #ICE WTI-Brent spreads
-         uds_market_type: 14 #ICE Heating Oil/WTI Futures Crack
-         uds_market_type: 16 #ICE NYH (RBOB) Gasoline/WTI Futures Crack         
-         uds_market_type: 58 #ICE Futures UI Heating Oil / Brent
-         uds_market_type: 59 #ICE NYH (RBOB) Gasoline/Brent Futures Crack 
-         uds_market_type: 66 #ICE NYH (RBOB) Gasoline/Heating Oil Spread
-         uds_market_type: 70 #ICE Heating Oil/LS Gasoil Futures Spread
-         uds_market_type: 71 #ICE LS Gasoil/Brent Futures Crack
-         uds_market_type: 72 #ICE NYH (RBOB) Gasoline/LS Gasoil Futures Spread         
-         
-         #onixs_log_mode: Debug
-      }
-      # channel {
-      #    name: "juice"
-      #    market_type: 26 #ICE Futures US Agricultures, FCOJ A
-      # }
-      ice_config_file: "ConnectivityConfiguration.APITest.xml"      
-      #ice_config_file: "ConnectivityConfiguration.PerfTest.xml"      
-   }
-}
-
-MDBootDelayWindow {
-    rule: "DeploymentType.type == 'dev'"
-    value {
-        delay_seconds: 0
-    }
-}
-
-MDBootDelayWindow {
-    value {
-        delay_seconds: 120
-        standard {
-            start: "16:30"
-            end: "16:40"
-        }
-        sunday {
-            start: "14:00"
-            end: "14:10"
-        }
-    }
-}
-
-DisplayFactorOverride {
-    value {
-        override {
-            symbol: "SOM"
-            exchange: "GLBX"
-            type: "SPREAD"
-            price_multiplier: 1
-        }
-    }
-}
+#
+# Common Market data options
+#
+
+MarketDataConfig {
+   rule: "DeploymentType.type == 'PROD'"
+   value {
+      use_sim: false
+   }
+}
+
+PublisherOptions {
+    rule: "DeploymentType.type == 'dev'"
+    value {
+        disable_heartbeat: true
+    }
+}
+
+PlatformMap {
+    value {
+        glbx_platform: "PLATFORM_MDP3ONIXS"
+        ice_platform: "PLATFORM_ICEONIXS"
+    }
+}
+
+PublisherNamespace {
+	value {
+		shared_memory_namespace: @System.os_user
+	}
+}
+
+CMEOptions {
+    value {
+        feed_engine {
+            name: "mdp3feed"
+            # udp_socket_buffer_size: 425984
+            # channels_per_thread: 1
+            spin_time: 0
+        }
+        channel {
+            id: "*"
+            feed_engine: "mdp3feed"
+            use_tcp_replay: false
+        }
+    }
+}
+
+#to make this work in dev clone the operations repo
+#go here: c:\\code\\bts\\operations\\ice\\ICE_iMpactMulticastFeed_GettingStarted-1_1_36\\bin\\easyTunnel>
+#modify the easyTunnelProxy.properties file to replace 
+#tunnel.multicast.interface=10.96.18.37 with your local ip
+#run easyTunnelProxy.bat BRENT-FI for Brent Full implied
+#you should see ice data
+
+ICEOptions {
+   value {
+      channel {
+         name: "oil" #these names are arbitrary and are for debugging
+         market_type: 3 
+         uds_market_type: 3
+         market_type: 4 #ICE IPE Gas Oil Futures
+         uds_market_type: 4         
+         market_type: 5 #ICE Futures Brent, IPE Brent Futures
+         uds_market_type: 5
+         market_type: 9 #ICE Futures WTI, ICE WTI Crude Futures                  
+         uds_market_type: 9
+         market_type: 13 #ICE Heating Oil Futures         
+         uds_market_type: 13
+         market_type: 15 #ICE NYH (RBOB) Gasoline Futures
+         uds_market_type: 15
+         ##market_type: 21 #ICE Futures US Agricultures, Coffee C
+         ##uds_market_type: 21
+         ##market_type: 23 #ICE Futures US Agricultures, FCOJ A
+         ##uds_market_type: 23               
+         
+         ##market_type: 26 #ICE Futures US Financials DX
+         ##uds_market_type: 26
+         
+         uds_market_type: 11 #ICE WTI-Brent spreads
+         uds_market_type: 14 #ICE Heating Oil/WTI Futures Crack
+         uds_market_type: 16 #ICE NYH (RBOB) Gasoline/WTI Futures Crack         
+         uds_market_type: 58 #ICE Futures UI Heating Oil / Brent
+         uds_market_type: 59 #ICE NYH (RBOB) Gasoline/Brent Futures Crack 
+         uds_market_type: 66 #ICE NYH (RBOB) Gasoline/Heating Oil Spread
+         uds_market_type: 70 #ICE Heating Oil/LS Gasoil Futures Spread
+         uds_market_type: 71 #ICE LS Gasoil/Brent Futures Crack
+         uds_market_type: 72 #ICE NYH (RBOB) Gasoline/LS Gasoil Futures Spread         
+         
+         #onixs_log_mode: Debug
+      }
+      # channel {
+      #    name: "juice"
+      #    market_type: 26 #ICE Futures US Agricultures, FCOJ A
+      # }
+      ice_config_file: "ConnectivityConfiguration.APITest.xml"      
+      #ice_config_file: "ConnectivityConfiguration.PerfTest.xml"      
+   }
+}
+
+MDBootDelayWindow {
+    rule: "DeploymentType.type == 'dev'"
+    value {
+        delay_seconds: 0
+    }
+}
+
+MDBootDelayWindow {
+    value {
+        delay_seconds: 120
+        standard {
+            start: "16:30"
+            end: "16:40"
+        }
+        sunday {
+            start: "14:00"
+            end: "14:10"
+        }
+    }
+}
+
+DisplayFactorOverride {
+    value {
+        override {
+            symbol: "SOM"
+            exchange: "GLBX"
+            type: "SPREAD"
+            price_multiplier: 1
+        }
+    }
+}
@@ -168,4 +168,13 @@ message OffsetAttachUIOptions {

 message ManualFillsOptions {
   optional bool modal_transactions = 1 [default = true];
+}
+
+message SymbolUIConfigurationItem {
+   optional string symbol = 1 [default = ""];
+   optional uint32 display_quantity_divisor = 2 [default = 1];
+}
+
+message SymbolUIConfiguration {
+   repeated SymbolUIConfigurationItem items = 1;
 }
@@ -59,6 +59,10 @@ message EnsureOnScreenWithWorkAreaRect {
   optional bool enabled = 1 [default = false];
 }

+message CustomFormatIceSecurities{
+   optional bool enabled = 1 [default = true];
+}
+
 message IgnoreNansInDayPnL {
   optional bool enabled = 1 [default = true];
 }
@@ -786,9 +786,9 @@ OutFIXPtr make_logon(uint32_t seq_num, uint32_t last_seq_num_processed,
   if(session_cfg.platform() == bts::config::JetFIX_Connection_JetFIXPlatform_ICE || 
      session_cfg.platform() == bts::config::JetFIX_Connection_JetFIXPlatform_SIMICE)
   {
-      buffer.add<ICEApplicationSystemName>(application);
+      buffer.add<ICEApplicationSystemName>("Katallage");
      buffer.add<ICEApplicationSystemVersion>("1.0");
-      buffer.add<ICEApplicationSystemVendor>("BTS");      
+      buffer.add<ICEApplicationSystemVendor>("Katallage");      
      
      buffer.add<UserName>(session_cfg.user_name());      
      buffer.add<RawDataLength>(session_cfg.raw_data().size());
@@ -170,7 +170,7 @@ void NativeOrder::on_init_recovered(OrderRecord const &rec,
   me->sec = serv.sec_db.resolve(SecurityKey(def.security_key()));
   me->previous_working_position = Quantity(0);

-   auto const &native_state = get_native_state(me->state);
+   auto &native_state = get_native_state(me->state);
   switch (me->state.status()) {

   case ORDER_STATUS_WORKING:
@@ -202,6 +202,8 @@ void NativeOrder::on_init_recovered(OrderRecord const &rec,
      }
      // if we made it this far we are good.
      me->routing_record = rq.routing_record; 
+      *native_state.mutable_routing_record() = rq.routing_record;
+      
      if (me->state.status() != ORDER_STATUS_PENDING_WORKING)
         me->exchange_order_id = native_state.exchange_order_id();
      init_fix();
@@ -215,13 +215,6 @@ api::orderman::OrderDefinition
 ICENativeOrder::on_init_from_exe_report(const ExecutionReport& er, const PreActivationOrderServices& os) 
 {
   auto k = er.order_key;
-   auto nextid = me->services->gen_id();
-   if(k.value() < nextid)
-   {
-      k = OrderKey(nextid);
-      LOG(OrderMan, Error, "Updating recovered order id with newly generated id {}", k.value());
-   }
-
   OrderRecord orecord;
   orecord.set_key(k.value());
   orecord.set_parent_key(null_order_key().value());
@@ -627,7 +620,7 @@ OrderOpResult ICENativeOrder::on_update(api::orderman::Update const &update)
      if (me->state.last_msg().size())
         me->state.set_last_msg("");

-      LOG(OrderMan, Warn,
+      LOG(OrderMan, Info,
          "ICE may not honor this update if we recently issued an unacknowledged cancelreplace {}. Update: {}@{}. Buffering",
          key().value(), q.value(), p.value());
      me->buffered_update.emplace(p, q);
@@ -814,7 +807,7 @@ void ICENativeOrder::on_exe_report(const NewExecutionReportEvent &er)
   if(er.data->exec_type == api::orderman::ExecType::EXEC_TYPE_TRADE_CANCEL || 
      er.data->exec_type == api::orderman::ExecType::EXEC_TYPE_TRADE_CORRECT)
   {
-      LOG(OrderMan, Info, "ICENativeOrder ignoring Cancel or Correct execution report {} in order {}", er.data->msg_seq_num, key().value());
+      LOG(OrderMan, Error, "ICENativeOrder ignoring Cancel or Correct execution report {} in order {}", er.data->msg_seq_num, key().value());
      return;      
   }

@@ -941,7 +934,7 @@ void ICENativeOrder::handle_buffered_state(const std::string& condition)
 {
   if (me->buffered_cancel) 
   {
-      LOG(OrderMan, Warn,
+      LOG(OrderMan, Info,
            "Applying buffered cancel to order {}, on ",
            condition,
            key().value());
@@ -950,7 +943,7 @@ void ICENativeOrder::handle_buffered_state(const std::string& condition)
   else if (me->buffered_update.has_value()) 
   {
      auto [p, q] = me->buffered_update.value();
-      LOG(OrderMan, Warn,
+      LOG(OrderMan, Info,
            "Applying buffered update ({}@{}) to order {}, on ",
            condition,
            q.value(),p.value(), key().value());
@@ -1113,14 +1106,14 @@ void ICENativeOrder::init_fix()
   create_encoding.add<fix::Memo>(memo);
   me->create_clordid_bm = create_encoding.add<fix::Int_ClOrdID>(get_clordid(0), ice_orderid_sz());
   create_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));      
-   //create_encoding.add<fix::OnBehalfOfCompID>(""); //optional, unclear if we need 
+   create_encoding.add<fix::OnBehalfOfCompID>("Katallage|Katallage"); 
   std::string cust = rr.cust_order_handing_inst();
   if(cust == "")
      cust = "Y";
   create_encoding.add<fix::CustOrderHandlingInst>(cust);   
   create_encoding.add<fix::SenderSubID>(rr.operator_id());   
   create_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
-   create_encoding.add<fix::OnBehalfOfLocationID>("ISV-BTS|" + rr.authorized_group());
+   create_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
   create_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
   create_encoding.add<fix::HandlInst>('1');
   create_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
@@ -1144,10 +1137,10 @@ void ICENativeOrder::init_fix()
   update_encoding.add<fix::Memo>(memo);
   me->update_orig_clordid_bm = update_encoding.add<fix::Int_OrigClOrdID>(get_clordid(0), ice_orderid_sz());
   update_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));      
-   //update_encoding.add<fix::OnBehalfOfCompID>(""); //optional, unclear if we need 
+   update_encoding.add<fix::OnBehalfOfCompID>("Katallage|Katallage"); 
   update_encoding.add<fix::SenderSubID>(rr.operator_id());   
   update_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
-   update_encoding.add<fix::OnBehalfOfLocationID>("ISV-BTS|" + rr.authorized_group());
+   update_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
   update_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
   update_encoding.add<fix::HandlInst>('1');
   update_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
@@ -1 +1 @@
-set(sources algo/AlgoDefinitionServiceServer.cpp;cmds/AdminReport.cpp;cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/FIXSim.cpp;cmds/Help.cpp;cmds/KeyCode.cpp;cmds/Md.cpp;cmds/ParseHistoricalFIX.cpp;cmds/PrintHedgeOrders.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/Web.cpp;dspark/mirage/quick_queue/quick_queue.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/MultipartFormDecoder.cpp;http/WebServer.cpp;http/tests/MultiPartFormTests.cpp;main.cpp;md/ChannelVolume.cpp;md/MarketDataAuxiliaryServiceServer.cpp;md/VolumeAtPriceState.cpp;md/platforms/IMDPlatform.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/ice_onixs/ICEListener.cpp;md/platforms/ice_onixs/ICEMain.cpp;md/platforms/ice_onixs/tests/ice_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/MarginServiceServer.cpp;position/PositionAggregator.cpp;position/PositionMap.cpp;position/PositionServicePNLHelper.cpp;position/PositionServiceServer.cpp;position/import/BasePositionServiceServer.cpp;position/import/DownloadCommonStateMachine.cpp;position/import/DownloadWindow.cpp;position/import/MoneyFileServiceServer.cpp;position/import/parsing/gmi_parser.cpp;position/import/parsing/money_parser.cpp;position/import/parsing/parser_common.cpp;position/tests/PositionTests.cpp;position/tests/position_tests_internal.cpp;subprocess/SubProcessRunner.cpp;support/ErrorReportService.cpp;support/ShellLatencyServer.cpp;user/AdminServiceServer.cpp;user/AuthServiceServer.cpp;user/tests/admin_service_tests.cpp)
+set(sources algo/AlgoDefinitionServiceServer.cpp;cmds/AdminReport.cpp;cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/FIXSim.cpp;cmds/Help.cpp;cmds/KeyCode.cpp;cmds/Md.cpp;cmds/ParseHistoricalFIX.cpp;cmds/PrintHedgeOrders.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/Web.cpp;dspark/mirage/quick_queue/quick_queue.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/MultipartFormDecoder.cpp;http/WebServer.cpp;http/tests/MultiPartFormTests.cpp;main.cpp;md/ChannelVolume.cpp;md/MarketDataAuxiliaryServiceServer.cpp;md/VolumeAtPriceState.cpp;md/platforms/IMDPlatform.cpp;md/platforms/ice_onixs/ICEListener.cpp;md/platforms/ice_onixs/ICEMain.cpp;md/platforms/ice_onixs/tests/ice_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/MarginServiceServer.cpp;position/PositionAggregator.cpp;position/PositionMap.cpp;position/PositionServicePNLHelper.cpp;position/PositionServiceServer.cpp;position/import/BasePositionServiceServer.cpp;position/import/DownloadCommonStateMachine.cpp;position/import/DownloadWindow.cpp;position/import/MoneyFileServiceServer.cpp;position/import/parsing/gmi_parser.cpp;position/import/parsing/money_parser.cpp;position/import/parsing/parser_common.cpp;position/tests/PositionTests.cpp;position/tests/position_tests_internal.cpp;subprocess/SubProcessRunner.cpp;support/ErrorReportService.cpp;support/ShellLatencyServer.cpp;user/AdminServiceServer.cpp;user/AuthServiceServer.cpp;user/tests/admin_service_tests.cpp)
@@ -1,26 +0,0 @@
-#include "TestCeloxica.h"
-
-#include "server/sparkd/md/platforms/celoxica/CXMain.h"
-#include "server/sparkd/md/platforms/celoxica/CXListener.h"
-
-namespace bts 
-{
-namespace cmd 
-{
-
-int TestCeloxica::execute(const std::vector<std::string>&)
-{
-   bts::md::CXMain main;
-   main.initialize();
-   return 0;
-}
-
-std::string TestCeloxica::help()
-{
-   return "\t test BTS <> Celoxica integration \n";
-} 
-
-}
-}
-
-
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "ICmd.h"
-
-namespace bts 
-{
-namespace cmd 
-{
-
-class TestCeloxica : public ICmd
-{
-public:
-   int execute(std::vector<std::string> const &args);
-   std::string help();
-};
-
-}
-}
-
-
@@ -19,7 +19,6 @@
 #include "server/sparkd/cmds/RunSim.h"
 #include "server/sparkd/cmds/Span.h"
 #include "server/sparkd/cmds/Test.h"
-#include "server/sparkd/cmds/TestCeloxica.h"
 #include "server/sparkd/cmds/Web.h"

 using namespace bts;
@@ -32,7 +31,6 @@ int main(int argc, char **argv) {
   REGISTER(Help);
   REGISTER(Run);
   REGISTER(Md);
-   REGISTER(TestCeloxica);
   REGISTER(ConfigCheck);
   REGISTER(KeyCode);
   REGISTER(RunSim);
@@ -1,88 +0,0 @@
-#include "CXListener.h"
-
-#include "lib/utils/defer.h"
-#include "lib/utils/CallTimer.h"
-#include "lib/utils/helper_macros.h"
-#include <tuple>
-
-namespace celoxica { namespace gmac {} }
-#include "celoxica.h"
-using namespace celoxica::gmac;
-using namespace std;
-
-namespace bts 
-{
-namespace md 
-{
-
-CXListener::CXListener(CXSecurityIndex& index, MDProducer& producer, SecurityIDRecorder& recorder, 
-                       co2::SettlementRecorder& settles, std::vector<MDProducerChannel> channels, 
-                       utils::Dispatcher& disp) :
-    _index(index),
-    _producer(producer),
-    _packet_arrived(),
-    _latest_sequence(0),
-    _security_recorder(recorder),
-    _settlement_recorder(settles),
-    _symbol_filter_storage(),
-    _channels(channels),
-    _background(disp),
-    _security_recorder_input_timer(disp, 900, [&]() { dequeue_securities(); }),
-    _security_recorder_input(),
-    _concurrency_monitor(0),
-    _book_updates()
- {
-    _book_updates.reserve(32);
-    _security_recorder_input_timer.start();
- }
-
-CXListener::~CXListener() 
-{
-   _security_recorder_input_timer.stop();
-}
-
-void CXListener::add_software_filter(const std::string& symbol)
-{
-   _symbol_filter_storage.push_back(symbol);
-   //_symbol_filter.clear();
-   //for (const auto& str : _symbol_filter_storage) {
-   //   _symbol_filter.insert(onixs::StringRef(str));
-   //}
-}
-
-void CXListener::on_GMACMessageOrderDepthV3(const GMACMessageOrderDepthV3*)
-{
-}
-
-
-void CXListener::dequeue_securities()
-{
-}
-
-void CXListener::flush_books() 
-{
-   // This is called at the end of the packet
-   // Write all book updates to shared memory and reset for the next packet
-   //for (auto& entry : _book_updates) {
-   //   // bbo first
-   //   uint16_t sequence = (_latest_sequence & 0xFFFF);
-   //   entry.handle.update_bbo(_packet_arrived, entry.bids[0], entry.asks[0], sequence);
-
-   //   // Perf Note: the remainder of the book update could be done (carefully) with a memcpy
-   //   for (size_t x = 1; x < COCONUT_MAX_DEPTH; ++x) {
-   //      entry.handle.update_bid(_packet_arrived, entry.bids[x], x);
-   //      entry.handle.update_ask(_packet_arrived, entry.asks[x], x);
-   //   }
-   //}
-   //// Reset pending updates
-   //_book_updates.clear();
-}
-
-}
-
-md::CXListener::BookData::BookData(MDProducerHandle & handle) : handle(handle), bids(), asks()
-{ 
-}
-
-}//namespace
-
@@ -1,61 +0,0 @@
-#pragma once
-
-#include "lib/utils/bts_no_copy.h"
-#include "lib/md/coconut2.h"
-#include "lib/utils/Dispatcher.h"
-#include "server/sparkd/md/platforms/celoxica/CXSecurityIndex.h"
-
-#include <tbb/concurrent_queue.h>
-#include <vector>
-#include <atomic>
-
-namespace bts 
-{
-namespace md 
-{
-struct GMACMessageOrderDepthV3;
-
-class CXListener 
-{
-public:
-   CXListener(CXSecurityIndex&, MDProducer&, SecurityIDRecorder&, 
-              co2::SettlementRecorder&, std::vector<MDProducerChannel>, utils::Dispatcher&);
-   ~CXListener();
-
-   void add_software_filter(const std::string& symbol);
-
-   void on_GMACMessageOrderDepthV3(const GMACMessageOrderDepthV3*);
-
-private: 
-   void flush_books();
-   void dequeue_securities();
-
-private:
-   BTS_NO_COPY(CXListener);
-
-   CXSecurityIndex& _index;
-   MDProducer& _producer;
-   utils::TimeStamp _packet_arrived;
-   uint64_t _latest_sequence;
-   SecurityIDRecorder& _security_recorder;
-   co2::SettlementRecorder& _settlement_recorder;
-   std::vector<std::string> _symbol_filter_storage;
-   std::vector<MDProducerChannel> _channels;
-   utils::Dispatcher& _background;
-   utils::DispatcherTimer _security_recorder_input_timer;
-   tbb::concurrent_queue<CXSecurityData*> _security_recorder_input;
-   std::atomic<int> _concurrency_monitor;
-
-   struct BookData {
-      BookData(MDProducerHandle& handle);
-      MDProducerHandle handle;
-      PriceSize bids[10];
-      PriceSize asks[10];
-   };
-
-   std::vector<BookData> _book_updates;   
-};
-
-
-}}//namespace
-
@@ -1,83 +0,0 @@
-#include "CXMain.h"
-
-#include "lib/md/cme/MDP3Utils.h"
-#include "lib/config/config.h"
-#include "lib/md/coconut2.h"
-#include "lib/os/os.h"
-#include "lib/utils/Dispatcher.h"
-#include "lib/utils/proto_helper.h"
-#include "lib/utils/helper_macros.h"
-
-#include "lib/config/protos/MarketData.pb.h"
-#include "lib/config/protos/system.pb.h"
-
-namespace celoxica { namespace gmac {} }
-#include "celoxica.h"
-
-extern "C"
-{
-#define __retcode_start__
-#define __retcode_end__
-}
-
-#include <memory>
-#include <set>
-
-using namespace std;
-using namespace celoxica::gmac;
-
-namespace bts 
-{
-namespace md
-{
-
-void run_cx_server(UserSymbol* psyms, size_t symcount)
-{
-   CXMain main;
-   vector<UserSymbol> symbols;
-   for(size_t x = 0; x < symcount; ++x) {
-      symbols.push_back(psyms[x]);
-   }
-   main.run(symbols);
-}
-
-CXMain::CXMain() :
-   _producer(co2::PLATFORM_CELOXICA),
-   _security_recorder({}),
-   _settlement_recorder(co2::PLATFORM_CELOXICA),
-   _listeners()
-{
-}
-
-CXMain::~CXMain() {}
-
-void CXMain::initialize()
-{
-   //celoxica::gmac::GMACIdentify(stderr);
-   //const auto& options = config::get<CMEOptions>();
-
-}
-
-
-void CXMain::run(std::vector<UserSymbol>& symbols)
-{
-   bts::md::await_cme_config();
-   initialize();
-
-   parse_channels(symbols);
-   // const auto& channels = parse_channels(symbols);
-}
-
-
-
-std::unique_ptr<CXListener> CXMain::prepare_listener(const std::string& channel, const CMEChannel&)
-{
-   UNUSED(channel);
-   return std::unique_ptr<CXListener>();
-}
-
-
-}
-}
-
-
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "lib/utils/bts_no_copy.h"
-#include "lib/md/coconut2.h"
-#include "server/sparkd/md/platforms/celoxica/CXListener.h"
-#include "server/sparkd/md/platforms/celoxica/CXSecurityIndex.h"
-
-#include <memory>
-#include <vector>
-#include <map>
-
-namespace bts 
-{
-namespace md 
-{
-void run_cx_server(UserSymbol* sym, size_t symcount);
-
-struct CMEChannel;
-class CXListener;
-
-/*
- * The CX provider is very simple.  1 CXMain maps to 1 Celoxica Queue, which maps to 1 thread and one bound CPU.
- * Control starts in CXMain which starts the thread, binds to a cpu, provides a (currently unused) list of all the symbols we need 
- * prepare_handler configures an exchange channel to be owned by this queue, and prepare_listener sets up thing that sees 
- * all callbacks which maps the exchange id to the MDProducerHandle and writes to shared mem
- */
-class CXMain
-{
-public:
-   CXMain();
-   ~CXMain();
-
-   void run(std::vector<UserSymbol>&); //call initialize, start the pump
-   void initialize(); //set up channels, etc
-
-   std::unique_ptr<CXListener> prepare_listener(const std::string& channel, const CMEChannel&);
-
-private:
-   BTS_NO_COPY(CXMain);
-
-   CXSecurityIndex _index;
-   MDProducer _producer;
-   SecurityIDRecorder _security_recorder;
-   co2::SettlementRecorder _settlement_recorder;
-   std::vector<std::unique_ptr<CXListener>> _listeners;
-};
-
-}}//namespace
-
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "lib/md/SecurityIndex.h"
-#include <string>
-
-namespace bts 
-{
-namespace md 
-{
-
-struct CXSecurityData 
-{
-   CXSecurityData(uint32_t id, MDProducerHandle& h) : id(id), handle(h) {}
-   uint32_t id; // exchange id
-   MDProducerHandle handle;
-};
-
-using CXSecurityIndex = ConcurrentSecurityIndex<uint32_t, CXSecurityData>;
-
-}}//namespace
-
@@ -1,15 +0,0 @@
-#pragma once
-
-namespace celoxica
-{
-namespace gmac
-{
-
-#include "celoxica/gmac.h"
-#include "celoxica/gmac_template_v3.h"
-#include "celoxica/gmac_info.h"
-
-}
-}
-
-
@@ -1,210 +0,0 @@
-// #include "catch/catch.hpp"
-
-// #include "lib/config/config.h"
-// #include "lib/config/protos/MarketData.pb.h"
-
-// #include <vector>
-// #include <string>
-// #include <functional>
-// #include <stdarg.h>
-
-// #include "../MDP3Utils.h"
-// #include "../onixs.h"
-
-// using namespace bts::md;
-// using namespace std;
-
-
-// namespace bts {
-// namespace md {
-
-// map<string, onixs::FeedEngineSettings> create_feed_engine_settings(const std::vector<CMEChannel>& channels);
-// const CMEOptions::CMEChannel channel_settings_for(const string& id);
-
-// namespace test {
-
-// vector<CMEChannel> test_channels(int count, ...) {
-//    // Doing this the C way because I still haven't updated VS
-//    vector<CMEChannel> result;
-//    va_list ap;
-//    va_start(ap, count);
-//    for (int x = 0; x < count; ++x) {
-//       const char* val = va_arg(ap, char*);
-//       CMEChannel temp;
-//       temp.id = val;
-//       result.push_back(temp);
-//    }
-//    va_end(ap);
-//    return result;
-// }
-   
-
-// TEST_CASE("mdp3_tests","[md]") {
-//    SECTION("test_defaults") {
-//       config::internal::initialize_for_test("CMEOptions {}");
-
-//       vector<CMEChannel> channels = test_channels(1, "310");
-//       auto result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-      
-//       channels = test_channels(2, "310", "311");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-
-//       channels = test_channels(4, "310", "311", "400", "412");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-      
-//       REQUIRE(!channel_settings_for("310").has_feed_engine());
-//       REQUIRE(!channel_settings_for("311").has_feed_engine());
-//       REQUIRE(!channel_settings_for("315").has_feed_engine());
-//    }
-
-//    SECTION("test_segregate_futures") {
-//       config::internal::initialize_for_test(
-//          "CMEOptions {\n"
-//          "    value {\n"
-//          "        feed_engine {\n"
-//          "            name: 'default'\n"
-//          "        }\n"
-//          "        feed_engine {\n"
-//          "            name: 'futures'\n"
-//          "            num_threads: 4\n"
-//          "        }\n"
-//          "        # Futures\n"
-//          "        channel {\n"
-//          "            id: '310'\n"
-//          "            id: '312'\n"
-//          "            feed_engine: 'futures'\n"
-//          "        }\n"
-//          "        # Options\n"
-//          "        channel {\n"
-//          "            id: '311'\n"
-//          "            id: '313'\n"
-//          "            id: '315'\n"
-//          "            feed_engine: 'default'\n"
-//          "        }\n"
-//          "    }\n"
-//          "}");
-      
-//       vector<CMEChannel> channels = test_channels(1, "310");
-//       auto result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 1);
-//       REQUIRE(result.begin()->first == "futures");
-//       REQUIRE(result.begin()->second.threadsCount() == 4);
-      
-//       channels = test_channels(1, "311");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 1);
-//       REQUIRE(result.begin()->first == "default");
-//       REQUIRE(result.begin()->second.threadsCount() == 1);
-      
-//       channels = test_channels(2, "311", "310");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 2);
-//       REQUIRE(result["default"].threadsCount() == 1);
-//       REQUIRE(result["futures"].threadsCount() == 4);
-      
-//       // Test channels not listed in config
-//       channels = test_channels(2, "317", "318");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-//    }
-
-//    SECTION("test_no_default") {
-//       config::internal::initialize_for_test(
-//          "CMEOptions {\n"
-//          "    value {\n"
-//          "        feed_engine {\n"
-//          "            name: 'futures'\n"
-//          "            num_threads: 4\n"
-//          "        }\n"
-//          "        # any channel not listed will use the default feed engine\n"
-//          "        # Futures\n"
-//          "        channel {\n"
-//          "            id: '310'\n"
-//          "            id: '312'\n"
-//          "            feed_engine: 'futures'\n"
-//          "        }\n"
-//          "        # Options\n"
-//          "        channel {\n"
-//          "            id: '311'\n"
-//          "            id: '313'\n"
-//          "            id: '315'\n"
-//          "            use_tcp_replay: false\n"
-//          "        }\n"
-//          "    }\n"
-//          "}");
-      
-//       vector<CMEChannel> channels = test_channels(1, "310");
-//       auto result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 1);
-//       REQUIRE(result.begin()->first == "futures");
-//       REQUIRE(result.begin()->second.threadsCount() == 4);
-      
-//       channels = test_channels(1, "311");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-      
-//       channels = test_channels(2, "311", "310");
-//       result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 1);
-//       REQUIRE(result["futures"].threadsCount() == 4);
-      
-      
-//       REQUIRE(channel_settings_for("310").use_tcp_replay() == true);
-//       REQUIRE(channel_settings_for("311").use_tcp_replay() == false);
-//       REQUIRE(channel_settings_for("315").use_tcp_replay() == false);
-//    }
-
-//    SECTION("test_one_thread_each") {
-//       config::internal::initialize_for_test(
-//          "CMEOptions {\n"
-//          "   value {\n"
-//          "      channel {\n"
-//          "         id: '*'\n"
-//          "      }\n"
-//          "   }\n"
-//          "}\n");
-
-//       vector<CMEChannel> channels = test_channels(1, "310", "311");
-//       auto result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 0);
-
-//       const auto& settings = channel_settings_for("311");
-//       REQUIRE(!settings.has_feed_engine());
-//    }
-
-//    SECTION("test_common_futures_thread") {
-//       config::internal::initialize_for_test(
-//          "CMEOptions {\n"
-//          "   value {\n"
-//          "        feed_engine {\n"
-//          "            name: 'futures'\n"
-//          "            num_threads: 4\n"
-//          "        }\n"
-//          "        channel {\n"
-//          "            id: '310'\n"
-//          "            feed_engine: 'futures'\n"
-//          "            udp_socket_buffer_size: 1234\n"
-//          "        }\n"
-//          "        channel {\n"
-//          "           id: '*'\n"
-//          "        }\n"
-//          "  }\n"
-//          "}\n");
-
-//       vector<CMEChannel> channels = test_channels(6, "310", "311", "315", "100", "10", "42");
-//       auto result = create_feed_engine_settings(channels);
-//       REQUIRE(result.size() == 1);
-//       result = create_feed_engine_settings(test_channels(1, "315"));
-//       REQUIRE(result.size() == 0);
-
-//       REQUIRE(!channel_settings_for("311").has_feed_engine());
-//       REQUIRE(channel_settings_for("310").has_feed_engine());
-//       REQUIRE(channel_settings_for("310").udp_socket_buffer_size() == 1234);
-//       REQUIRE(channel_settings_for("311").has_udp_socket_buffer_size() == false);
-//    }
-// }
-
-// }}}//namespace
@@ -1,421 +1,451 @@
-#include "ICEListener.h"
-#include "lib/utils/datetime.h"
-#include <vector>
-#include "lib/utils/helper_macros.h"
-#include "lib/config/protos/MarketData.pb.h"
-#include "lib/md/protos/co2.pb.h"
-
-using namespace std;
-using namespace bts::co2;
-using namespace bts::md::ice;
-
-namespace bts {
-namespace md {
-namespace ice {
-   
-template <>
-double double_of_price<onixs_ice::Rational>(const onixs_ice::Rational& price, int8_t denominator) 
-{
-   UNUSED(denominator);
-   double dbl = price.convertTo<double>();
-   return dbl;
-}   
-
-template<>
-void ICEListener::set_security_specific<onixs_ice::FuturesProductDefinition>(const onixs_ice::FuturesProductDefinition& def, 
-                                                                             FixedSecurity& fsec)
-{
-   //fsec.cash_per_point = double_of_price(def.tickValue, fsec.ice_price_denominator);
-   //fsec.cash_per_point = def.tickValue;   
-   fsec.cash_per_point = def.unitQuantity;
-}
-
-ICEListener::ICEListener(ICESecurityIndex& index, MDProducer& producer, const std::vector<MDProducerChannel> channels) :
-   _index(index),
-   _producer(producer),
-   _symbol_filter(),
-   _channels(channels),
-   _concurrency_monitor(0)
-{
-}
-
-ICEListener::~ICEListener() {}
-
-std::string ICEListener::parse_contract_symbol(const std::string& sym)
-{
-   auto end = sym.find(' ');
-   if(end == std::string::npos)
-      return sym;
-   else
-      return sym.substr(0, end);
-}
-
-//   
-//State change
-void ICEListener::onHandlerStateChange(const onixs_ice::HandlerStateChange&) 
-{
-}
-   
-void ICEListener::onMarketStateChange(const onixs_ice::MarketStateChange& , const onixs_ice::MessageInfo&)
-{
-}
-
-//
-// Warnings/Errors
-void ICEListener::onError(const onixs_ice::Error& error) 
-{
-   std::string error_desc(error.description());
-   LOG(md,Warn, "OnixS ICE Error: {} - {}", error.toString(), error_desc );
-}
-void ICEListener::onFeedError(onixs_ice::FeedId feedid, onixs_ice::ErrorCode code, const std::string& desc)
-{
-   LOG(md,Warn, "OnixS ICE FeedError: {} - {}", feedid, desc, code);   
-}
-void ICEListener::onWarning(const onixs_ice::Warning& warning) 
-{
-   LOG(md,Warn, "OnixS ICE Warn: {} - {}", warning.toString(), std::string(warning.description()) );
-}
-
-//
-// Security discovery
-void ICEListener::onFuturesProductDefinition(const onixs_ice::FuturesProductDefinition& msg, bool& is_interested) 
-{
-   if(msg.isSpread)
-      on_future_strip(msg, is_interested);
-   else
-      on_future(msg, is_interested);
-}
-
-void ICEListener::onNewExpiry(const onixs_ice::NewExpiry& msg, bool& is_interested, const onixs_ice::MessageInfo& ) 
-{   
-   on_future(msg, is_interested);
-}
-
-void ICEListener::onFuturesStrategyDefinition(const onixs_ice::FuturesStrategyDefinition& def, bool& is_interested) 
-{
-    on_uds_future_spread(def, is_interested);
-}
-//This is only for UDS
-void ICEListener::onNewFuturesStrategyDefinition(const onixs_ice::NewFuturesStrategyDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& )
-{
-   on_uds_future_spread(msg, is_interested);
-}
-   
-void ICEListener::onOptionsProductDefinition(const onixs_ice::OptionsProductDefinition& msg, bool& is_interested) 
-{ 
-   UNUSED(msg);
-   UNUSED(is_interested);
-}
-void ICEListener::onNewOptionsMarketDefinition(const onixs_ice::NewOptionsMarketDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& msg_info)  
-{ 
-   UNUSED(msg);
-   UNUSED(is_interested);
-   UNUSED(msg_info);
-}
-void ICEListener::onOptionsStrategyDefinition(const onixs_ice::OptionsStrategyDefinition& msg, bool& is_interested) 
-{
-   UNUSED(msg);
-   UNUSED(is_interested);
-}
-void ICEListener::onNewOptionsStrategyDefinition(const onixs_ice::NewOptionsStrategyDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& msg_info) 
-{
-   UNUSED(msg);
-   UNUSED(is_interested);
-   UNUSED(msg_info);
-}
-
-//
-
-void ICEListener::onMarketSnapshot(const onixs_ice::MarketSnapshot& msg, const onixs_ice::MessageInfo& msg_info) 
-{
-   UNUSED(msg_info);
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      auto ts = utils::TimeStamp::now();
-      auto settle_denominator = data->handle.security().ice_settle_denominator;
-      if (msg.settlePriceDateTime > 0) {
-         data->handle.update_settlement( ts,  convert_price(msg.settlementPrice, settle_denominator), date_of_timestamp(msg.settlePriceDateTime) );
-      }
-      
-      LOG(md,Diag,"OnixSICE Got Market Snap : {} - {}", std::to_string(data->id), std::to_string(msg.settlementPrice));
-      
-      auto deal_denominator = data->handle.security().ice_deal_denominator;
-      data->handle.update_opening( ts,  double_of_price(msg.openingPrice, deal_denominator), datetime::today() );
-      data->handle.update_session_high( ts,  double_of_price(msg.high, deal_denominator) );
-      data->handle.update_session_low( ts,  double_of_price(msg.low, deal_denominator) );      
-      
-      data->handle.set_last_trade( ts, pricesize_of_price_size(msg.lastTradePrice, deal_denominator, msg.lastTradeQuantity), 
-                                   ll_of_timestamp(msg.lastTradeDateTime), msg.volume );            
-   }        
-}
-
-void ICEListener::onMarketStatistics(const onixs_ice::MarketStatistics& msg, const onixs_ice::MessageInfo& msg_info)
-{
-   UNUSED(msg_info);
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      data->handle.set_total_volume(msg.volume);
-   }   
-}
-
-// Gap Recovery -- This is not necessary if we subscribe to the onOrderBookUpdated callback, they handle the breaks transparently 
-void ICEListener::onMarketSnapshotOrder(const onixs_ice::MarketSnapshotOrder& msg, const onixs_ice::MessageInfo& msg_info) 
-{
-   UNUSED(msg);
-   UNUSED(msg_info);
-}
-
-// Gap Recovery -- This is not necessary if we subscribe to the onOrderBookUpdated callback, they handle the breaks transparently 
-void ICEListener::onMarketSnapshotPriceLevel(const onixs_ice::MarketSnapshotPriceLevel& msg, const onixs_ice::MessageInfo& msg_info) 
-{
-   UNUSED(msg);
-   UNUSED(msg_info);
-}
-
-//
-// Book
-void ICEListener::onOrderBookUpdated(const onixs_ice::OrderBook& onixs_book, const onixs_ice::MessageInfo& msg_info) 
-{
-   //tracepoint (bts_trace,trace_order,(char*) "onBookUpdate", (uint32_t)msg_info.sequenceNumber, (uint16_t) msg_info.sequenceNumber, 0);
-      
-   auto data = _index.get_security(onixs_book.marketId());
-   if (data == nullptr) 
-      return;
-   bts_assert(data->id == onixs_book.marketId());
-   auto denominator = data->handle.security().ice_price_denominator;
-
-   // Overwrite all entries every time
-   size_t bids_size = onixs_book.bids().size();
-   size_t asks_size = onixs_book.offers().size();
-   if (!data->handle.has_depth()) 
-   {
-      bids_size = std::min(bids_size, size_t { 1 });
-      asks_size = std::min(asks_size, size_t { 1 });
-   }
-   std::array<PriceSize,COCONUT_MAX_DEPTH> dbids; dbids.fill(NO_MARKET);
-   std::array<PriceSize,COCONUT_MAX_IMPLIED_DEPTH> ibids; ibids.fill(NO_MARKET);
-   std::array<PriceSize,COCONUT_MAX_DEPTH> dasks; dasks.fill(NO_MARKET);
-   std::array<PriceSize,COCONUT_MAX_IMPLIED_DEPTH> iasks;  iasks.fill(NO_MARKET);
-   for (size_t x = 0; x < bids_size; ++x) 
-   {
-      auto& bid = onixs_book.bids()[x];
-      if(x < COCONUT_MAX_DEPTH)
-         dbids[x] = pricesize_of_price_size(bid.price, denominator, bid.quantity - bid.impliedQuantity);   
-      if(x < COCONUT_MAX_IMPLIED_DEPTH)
-         ibids[x] = pricesize_of_price_size(bid.price, denominator, bid.impliedQuantity);   
-   }      
-   for (size_t x = 0; x < asks_size; ++x) 
-   {
-      auto& ask = onixs_book.offers()[x];
-      if(x < COCONUT_MAX_DEPTH)
-         dasks[x] = pricesize_of_price_size(ask.price, denominator, ask.quantity - ask.impliedQuantity);
-      if(x < COCONUT_MAX_IMPLIED_DEPTH)
-         iasks[x] = pricesize_of_price_size(ask.price, denominator, ask.impliedQuantity);
-   } 
-   data->handle.update_books(TimeStamp::now(), dbids, dasks, ibids, iasks, (uint32_t) msg_info.sequenceNumber);
-} 
-
-
-//
-// Trades
-AggressorSide map_aggressor(onixs_ice::AggressorSide::Enum agside) 
-{
-   switch(agside) {
-      default:
-      case onixs_ice::AggressorSide::NoAggressor:
-         return AGGRESSOR_SIDE_NONE;
-      case onixs_ice::AggressorSide::Buy:
-         return AGGRESSOR_SIDE_BUY;
-      case onixs_ice::AggressorSide::Sell:
-         return AGGRESSOR_SIDE_SELL;
-   }
-}
-
-void on_trade(ICESecurityData* data, const onixs_ice::Price& price, int size, 
-              onixs_ice::AggressorSide::Enum agside, const onixs_ice::DateTime& onixs_date, bool from_spread) 
-{
-   auto ts = utils::TimeStamp::now();
-   PriceSize ps = pricesize_of_price_size(price, data->handle.security().ice_deal_denominator, size);
-   auto date = ll_of_timestamp(onixs_date);
-   data->handle.add_trade(ts, ps, date, map_aggressor(agside), 0u, from_spread);
-}
-
-void ICEListener::onTrade(const onixs_ice::Trade& msg, const onixs_ice::MessageInfo& ) 
-{
-   auto* data = _index.get_security(msg.marketId);
-   if (data != NULL) 
-   {
-      bts_assert(data->id == msg.marketId);
-      auto size = msg.quantity;
-      auto price = msg.price;
-      onixs_ice::AggressorSide::Enum agside = msg.aggressorSide;
-      on_trade(data, price, size, agside, msg.transactDateTime, msg.isSystemPricedLeg);
-   }   
-}
-
-//
-// RFQ
-void ICEListener::onRfq(const onixs_ice::Rfq& msg, const onixs_ice::MessageInfo& ) 
-{
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      auto ts = utils::TimeStamp::now();
-      co2::QuoteRequestMessage message;
-      message.set_key(data->handle.key());
-
-      auto time = ll_of_timestamp(msg.messageTimestamp);
-      message.set_time(time);
-
-      long long rfqid = msg.rfqSystemId;
-      message.set_request_id(std::to_string(rfqid));
-
-      //https://ref.onixs.biz/cpp-ice-impact-handler-guide/struct_onix_s_1_1_i_c_e_1_1i_mpact_1_1_market_data_1_1_side.html#a8150b7776c2a1749101acf22e868d091
-      switch(msg.side) 
-      {
-         case ' ':
-            message.set_side(co2::QuoteRequestMessage::UNDEFINED);
-            break;
-         case '1':
-            message.set_side(co2::QuoteRequestMessage::BUY);
-            break;
-         case '2':
-            message.set_side(co2::QuoteRequestMessage::SELL);
-            break;
-      }
-      message.set_size(msg.quantity);
-      data->handle.add_rfq(ts, message);
-   }   
-}
-
-//
-// Misc
-void ICEListener::onSettlementPrice(const onixs_ice::SettlementPrice& msg, const onixs_ice::MessageInfo& ) 
-{   
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      auto ts = utils::TimeStamp::now();
-      auto price = msg.settlementPrice;
-      auto time = msg.dateTime;
-      auto denominator = data->handle.security().ice_settle_denominator;
-      LOG(md,Diag,"OnixSICE Got Settlement: {} - {}", std::to_string(data->id), std::to_string(price));
-      data->handle.update_settlement(ts, convert_price(price, denominator), date_of_timestamp(time));
-   }   
-}
-
-void ICEListener::onOpenInterest(const onixs_ice::OpenInterest &msg, const onixs_ice::MessageInfo &msg_info) 
-{
-   UNUSED(msg);
-   UNUSED(msg_info);
-}
-
-void ICEListener::onOpenPrice(const onixs_ice::OpenPrice& msg, const onixs_ice::MessageInfo& ) 
-{
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      onixs_ice::Price price = msg.openPrice;
-      onixs_ice::DateTime time = msg.dateTime;
-      auto denominator = data->handle.security().ice_deal_denominator;
-      data->handle.update_opening( utils::TimeStamp::now(),  double_of_price(price, denominator), date_of_timestamp(time));
-   }   
-}
-
-void ICEListener::onClosePrice(const onixs_ice::ClosePrice& msg, const onixs_ice::MessageInfo& ) 
-{
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      onixs_ice::Price price = msg.closePrice;
-      onixs_ice::DateTime time = msg.dateTime;
-      auto denominator = data->handle.security().ice_deal_denominator;
-      data->handle.update_closing( utils::TimeStamp::now(),  double_of_price(price, denominator), date_of_timestamp(time));
-   }     
-}
-
-void ICEListener::onEndOfDayMarketSummary(const onixs_ice::EndOfDayMarketSummary& msg, const onixs_ice::MessageInfo& ) 
-{
-   auto* data = _index.get_security(msg.marketId);
-   if (data != nullptr) 
-   {
-      bts_assert(data->id == msg.marketId);
-      onixs_ice::DateTime time = msg.dateTime;
-      auto ts = utils::TimeStamp::now();
-      auto settle_denominator = data->handle.security().ice_settle_denominator;
-      data->handle.update_settlement( ts,  convert_price(msg.settlementPrice, settle_denominator), date_of_timestamp(time) );
-      
-      LOG(md,Warn,"OnixSICE Got EOD Market : {} - {}", std::to_string(data->id), std::to_string(msg.settlementPrice));
-      
-      auto deal_denominator = data->handle.security().ice_deal_denominator;
-      data->handle.update_opening( ts,  double_of_price(msg.openingPrice, deal_denominator), date_of_timestamp(time) );
-      data->handle.update_session_high( ts,  double_of_price(msg.high, deal_denominator) );
-      data->handle.update_session_low( ts,  double_of_price(msg.low, deal_denominator) );      
-   }        
-}
-
-//
-// Feed
-void ICEListener::onMulticastMessageBlockBegin(onixs_ice::FeedId feedId, const onixs_ice::MessageInfo& ) 
-{
-   UNUSED(feedId);
-}
-
-void ICEListener::onMulticastMessageBlockEnd(onixs_ice::FeedId feedId, const onixs_ice::MarketIds& marketIds) 
-{
-   UNUSED(feedId);
-   UNUSED(marketIds);
-}
-
-void ICEListener::onFeedStarted(onixs_ice::FeedId, const onixs_ice::MarketIds&) 
-{}
-
-void ICEListener::onFeedStopped(onixs_ice::FeedId) 
-{}
-
-void ICEListener::onSessionNumberChange(onixs_ice::FeedId , short , short )
-{}
-
-
-//
-// Non-onixs calls
-void ICEListener::add_filter_symbol(const std::string& symbol) 
-{
-   _symbol_filter.insert(symbol);
-}
-
-void ICEListener::heartbeat() 
-{
-   for (auto& c : _channels) { c.heartbeat(); }
-}
-
-//
-// Private functions
-void ICEListener::add_security(const FixedSecurity& security) 
-{
-   // Set up the shared memory for this security
-   auto handle = _producer.add_security(security);
-   bts_assert(security.numeric_id != 0);
-   // Add it to the index so it can receive messages
-   _index.add_security(security.numeric_id, handle);
-}
-
-void ICEListener::update_all_status(CoconutSecurityStatus status) 
-{
-   _index.walk_security_list([=](ICESecurityData& data) 
-   {
-      data.handle.set_status(status);
-   });
-}
-
-}}} //namespace
-
-
+#include "ICEListener.h"
+#include "lib/utils/datetime.h"
+#include <vector>
+#include "lib/utils/helper_macros.h"
+#include "lib/config/protos/MarketData.pb.h"
+#include "lib/md/protos/co2.pb.h"
+
+using namespace std;
+using namespace bts::co2;
+using namespace bts::md::ice;
+
+namespace bts {
+namespace md {
+namespace ice {
+   
+template <>
+double double_of_price<onixs_ice::Rational>(const onixs_ice::Rational& price, int8_t denominator) 
+{
+   UNUSED(denominator);
+   double dbl = price.convertTo<double>();
+   return dbl;
+}   
+
+template<>
+void ICEListener::set_security_specific<onixs_ice::FuturesProductDefinition>(const onixs_ice::FuturesProductDefinition& def, 
+                                                                             FixedSecurity& fsec)
+{
+   //fsec.cash_per_point = double_of_price(def.tickValue, fsec.ice_price_denominator);
+   //fsec.cash_per_point = def.tickValue;   
+   fsec.cash_per_point = def.unitQuantity;
+}
+
+ICEListener::ICEListener(ICESecurityIndex& index, MDProducer& producer, const std::vector<MDProducerChannel> channels) :
+   _index(index),
+   _producer(producer),
+   _symbol_filter(),
+   _channels(channels),
+   _concurrency_monitor(0)
+{
+}
+
+ICEListener::~ICEListener() {}
+
+std::string ICEListener::parse_contract_symbol(const std::string& sym)
+{
+   auto end = sym.find(' ');
+   if(end == std::string::npos)
+      return sym;
+   else
+      return sym.substr(0, end);
+}
+
+//   
+//State change
+void ICEListener::onHandlerStateChange(const onixs_ice::HandlerStateChange&) 
+{
+}
+   
+void ICEListener::onMarketStateChange(const onixs_ice::MarketStateChange& , const onixs_ice::MessageInfo&)
+{
+}
+
+//
+// Warnings/Errors
+void ICEListener::onError(const onixs_ice::Error& error) 
+{
+   std::string error_desc(error.description());
+   LOG(md,Warn, "OnixS ICE Error: {} - {}", error.toString(), error_desc );
+}
+void ICEListener::onFeedError(onixs_ice::FeedId feedid, onixs_ice::ErrorCode code, const std::string& desc)
+{
+   LOG(md,Warn, "OnixS ICE FeedError: {} - {}", feedid, desc, code);   
+}
+void ICEListener::onWarning(const onixs_ice::Warning& warning) 
+{
+   LOG(md,Warn, "OnixS ICE Warn: {} - {}", warning.toString(), std::string(warning.description()) );
+}
+
+//
+// Security discovery
+void ICEListener::onFuturesProductDefinition(const onixs_ice::FuturesProductDefinition& msg, bool& is_interested) 
+{
+   if(msg.isSpread)
+      on_future_strip(msg, is_interested);
+   else
+      on_future(msg, is_interested);
+   LOG(md,Diag,"ICE_Future,{},{},{},{},{},{},{},{},{},{},{},{},{}",
+       is_interested,
+       msg.productName,       // NG Swing GDD Futures,
+       msg.hubAlias,          // Henry       
+       msg.marketDesc,        // NG Swing GDD Futures - Henry - 10 Jul 20,
+       msg.stripName,         // 10 Jul 20
+       msg.contractSymbol,    // CGS SDN1020.N1020,
+       msg.productId,
+       msg.marketId,
+       msg.requestMarketType,
+       msg.securitySubType,
+       msg.contractSymbolExtra,       
+       msg.clearedAlias,
+       msg.isSpread);
+}
+
+void ICEListener::onNewExpiry(const onixs_ice::NewExpiry& msg, bool& is_interested, const onixs_ice::MessageInfo& ) 
+{   
+   on_future(msg, is_interested);
+}
+
+void ICEListener::onFuturesStrategyDefinition(const onixs_ice::FuturesStrategyDefinition& msg, bool& is_interested) 
+{
+   on_uds_future_spread(msg, is_interested);
+   LOG(md,Diag,"ICE_Strategy,{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
+       is_interested,
+       msg.productName,
+       msg.hubAlias,
+       msg.marketDesc,
+       msg.stripName,
+       msg.contractSymbol,
+       msg.productId,
+       msg.marketId,
+       msg.requestMarketType,
+       msg.securitySubType,
+       log::CharPtrWrapper {""},       
+       msg.clearedAlias,
+       msg.productName,       
+       0);  
+}
+
+void ICEListener::onNewFuturesStrategyDefinition(const onixs_ice::NewFuturesStrategyDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& )
+{
+   on_uds_future_spread(msg, is_interested);
+}
+   
+void ICEListener::onOptionsProductDefinition(const onixs_ice::OptionsProductDefinition& msg, bool& is_interested) 
+{ 
+   UNUSED(msg);
+   UNUSED(is_interested);
+}
+void ICEListener::onNewOptionsMarketDefinition(const onixs_ice::NewOptionsMarketDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& msg_info)  
+{ 
+   UNUSED(msg);
+   UNUSED(is_interested);
+   UNUSED(msg_info);
+}
+void ICEListener::onOptionsStrategyDefinition(const onixs_ice::OptionsStrategyDefinition& msg, bool& is_interested) 
+{
+   UNUSED(msg);
+   UNUSED(is_interested);
+}
+void ICEListener::onNewOptionsStrategyDefinition(const onixs_ice::NewOptionsStrategyDefinition& msg, bool& is_interested, const onixs_ice::MessageInfo& msg_info) 
+{
+   UNUSED(msg);
+   UNUSED(is_interested);
+   UNUSED(msg_info);
+}
+
+//
+
+void ICEListener::onMarketSnapshot(const onixs_ice::MarketSnapshot& msg, const onixs_ice::MessageInfo& msg_info) 
+{
+   UNUSED(msg_info);
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      auto ts = utils::TimeStamp::now();
+      auto settle_denominator = data->handle.security().ice_settle_denominator;
+      if (msg.settlePriceDateTime > 0) {
+         data->handle.update_settlement( ts,  convert_price(msg.settlementPrice, settle_denominator), date_of_timestamp(msg.settlePriceDateTime) );
+      }
+      
+      LOG(md,Diag,"OnixSICE Got Market Snap : {} - {}", std::to_string(data->id), std::to_string(msg.settlementPrice));
+      
+      auto deal_denominator = data->handle.security().ice_deal_denominator;
+      data->handle.update_opening( ts,  double_of_price(msg.openingPrice, deal_denominator), datetime::today() );
+      data->handle.update_session_high( ts,  double_of_price(msg.high, deal_denominator) );
+      data->handle.update_session_low( ts,  double_of_price(msg.low, deal_denominator) );      
+      
+      data->handle.set_last_trade( ts, pricesize_of_price_size(msg.lastTradePrice, deal_denominator, msg.lastTradeQuantity), 
+                                   ll_of_timestamp(msg.lastTradeDateTime), msg.volume );            
+   }        
+}
+
+void ICEListener::onMarketStatistics(const onixs_ice::MarketStatistics& msg, const onixs_ice::MessageInfo& msg_info)
+{
+   UNUSED(msg_info);
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      data->handle.set_total_volume(msg.volume);
+   }   
+}
+
+// Gap Recovery -- This is not necessary if we subscribe to the onOrderBookUpdated callback, they handle the breaks transparently 
+void ICEListener::onMarketSnapshotOrder(const onixs_ice::MarketSnapshotOrder& msg, const onixs_ice::MessageInfo& msg_info) 
+{
+   UNUSED(msg);
+   UNUSED(msg_info);
+}
+
+// Gap Recovery -- This is not necessary if we subscribe to the onOrderBookUpdated callback, they handle the breaks transparently 
+void ICEListener::onMarketSnapshotPriceLevel(const onixs_ice::MarketSnapshotPriceLevel& msg, const onixs_ice::MessageInfo& msg_info) 
+{
+   UNUSED(msg);
+   UNUSED(msg_info);
+}
+
+//
+// Book
+void ICEListener::onOrderBookUpdated(const onixs_ice::OrderBook& onixs_book, const onixs_ice::MessageInfo& msg_info) 
+{
+   //tracepoint (bts_trace,trace_order,(char*) "onBookUpdate", (uint32_t)msg_info.sequenceNumber, (uint16_t) msg_info.sequenceNumber, 0);
+      
+   auto data = _index.get_security(onixs_book.marketId());
+   if (data == nullptr) 
+      return;
+   bts_assert(data->id == onixs_book.marketId());
+   auto denominator = data->handle.security().ice_price_denominator;
+
+   // Overwrite all entries every time
+   size_t bids_size = onixs_book.bids().size();
+   size_t asks_size = onixs_book.offers().size();
+   if (!data->handle.has_depth()) 
+   {
+      bids_size = std::min(bids_size, size_t { 1 });
+      asks_size = std::min(asks_size, size_t { 1 });
+   }
+   std::array<PriceSize,COCONUT_MAX_DEPTH> dbids; dbids.fill(NO_MARKET);
+   std::array<PriceSize,COCONUT_MAX_IMPLIED_DEPTH> ibids; ibids.fill(NO_MARKET);
+   std::array<PriceSize,COCONUT_MAX_DEPTH> dasks; dasks.fill(NO_MARKET);
+   std::array<PriceSize,COCONUT_MAX_IMPLIED_DEPTH> iasks;  iasks.fill(NO_MARKET);
+   for (size_t x = 0; x < bids_size; ++x) 
+   {
+      auto& bid = onixs_book.bids()[x];
+      if(x < COCONUT_MAX_DEPTH)
+         dbids[x] = pricesize_of_price_size(bid.price, denominator, bid.quantity - bid.impliedQuantity);   
+      if(x < COCONUT_MAX_IMPLIED_DEPTH)
+         ibids[x] = pricesize_of_price_size(bid.price, denominator, bid.impliedQuantity);   
+   }      
+   for (size_t x = 0; x < asks_size; ++x) 
+   {
+      auto& ask = onixs_book.offers()[x];
+      if(x < COCONUT_MAX_DEPTH)
+         dasks[x] = pricesize_of_price_size(ask.price, denominator, ask.quantity - ask.impliedQuantity);
+      if(x < COCONUT_MAX_IMPLIED_DEPTH)
+         iasks[x] = pricesize_of_price_size(ask.price, denominator, ask.impliedQuantity);
+   } 
+   data->handle.update_books(TimeStamp::now(), dbids, dasks, ibids, iasks, (uint32_t) msg_info.sequenceNumber);
+} 
+
+
+//
+// Trades
+AggressorSide map_aggressor(onixs_ice::AggressorSide::Enum agside) 
+{
+   switch(agside) {
+      default:
+      case onixs_ice::AggressorSide::NoAggressor:
+         return AGGRESSOR_SIDE_NONE;
+      case onixs_ice::AggressorSide::Buy:
+         return AGGRESSOR_SIDE_BUY;
+      case onixs_ice::AggressorSide::Sell:
+         return AGGRESSOR_SIDE_SELL;
+   }
+}
+
+void on_trade(ICESecurityData* data, const onixs_ice::Price& price, int size, 
+              onixs_ice::AggressorSide::Enum agside, const onixs_ice::DateTime& onixs_date, bool from_spread) 
+{
+   auto ts = utils::TimeStamp::now();
+   PriceSize ps = pricesize_of_price_size(price, data->handle.security().ice_deal_denominator, size);
+   auto date = ll_of_timestamp(onixs_date);
+   data->handle.add_trade(ts, ps, date, map_aggressor(agside), 0u, from_spread);
+}
+
+void ICEListener::onTrade(const onixs_ice::Trade& msg, const onixs_ice::MessageInfo& ) 
+{
+   auto* data = _index.get_security(msg.marketId);
+   if (data != NULL) 
+   {
+      bts_assert(data->id == msg.marketId);
+      auto size = msg.quantity;
+      auto price = msg.price;
+      onixs_ice::AggressorSide::Enum agside = msg.aggressorSide;
+      on_trade(data, price, size, agside, msg.transactDateTime, msg.isSystemPricedLeg);
+   }   
+}
+
+//
+// RFQ
+void ICEListener::onRfq(const onixs_ice::Rfq& msg, const onixs_ice::MessageInfo& ) 
+{
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      auto ts = utils::TimeStamp::now();
+      co2::QuoteRequestMessage message;
+      message.set_key(data->handle.key());
+
+      auto time = ll_of_timestamp(msg.messageTimestamp);
+      message.set_time(time);
+
+      long long rfqid = msg.rfqSystemId;
+      message.set_request_id(std::to_string(rfqid));
+
+      //https://ref.onixs.biz/cpp-ice-impact-handler-guide/struct_onix_s_1_1_i_c_e_1_1i_mpact_1_1_market_data_1_1_side.html#a8150b7776c2a1749101acf22e868d091
+      switch(msg.side) 
+      {
+         case ' ':
+            message.set_side(co2::QuoteRequestMessage::UNDEFINED);
+            break;
+         case '1':
+            message.set_side(co2::QuoteRequestMessage::BUY);
+            break;
+         case '2':
+            message.set_side(co2::QuoteRequestMessage::SELL);
+            break;
+      }
+      message.set_size(msg.quantity);
+      data->handle.add_rfq(ts, message);
+   }   
+}
+
+//
+// Misc
+void ICEListener::onSettlementPrice(const onixs_ice::SettlementPrice& msg, const onixs_ice::MessageInfo& ) 
+{   
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      auto ts = utils::TimeStamp::now();
+      auto price = msg.settlementPrice;
+      auto time = msg.dateTime;
+      auto denominator = data->handle.security().ice_settle_denominator;
+      LOG(md,Info,"OnixSICE Got Settlement: {} - {}", std::to_string(data->id), std::to_string(price));
+      data->handle.update_settlement(ts, convert_price(price, denominator), date_of_timestamp(time));
+   }   
+}
+
+void ICEListener::onOpenInterest(const onixs_ice::OpenInterest &msg, const onixs_ice::MessageInfo &msg_info) 
+{
+   UNUSED(msg);
+   UNUSED(msg_info);
+}
+
+void ICEListener::onOpenPrice(const onixs_ice::OpenPrice& msg, const onixs_ice::MessageInfo& ) 
+{
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      onixs_ice::Price price = msg.openPrice;
+      onixs_ice::DateTime time = msg.dateTime;
+      auto denominator = data->handle.security().ice_deal_denominator;
+      data->handle.update_opening( utils::TimeStamp::now(),  double_of_price(price, denominator), date_of_timestamp(time));
+   }   
+}
+
+void ICEListener::onClosePrice(const onixs_ice::ClosePrice& msg, const onixs_ice::MessageInfo& ) 
+{
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      onixs_ice::Price price = msg.closePrice;
+      onixs_ice::DateTime time = msg.dateTime;
+      auto denominator = data->handle.security().ice_deal_denominator;
+      data->handle.update_closing( utils::TimeStamp::now(),  double_of_price(price, denominator), date_of_timestamp(time));
+   }     
+}
+
+void ICEListener::onEndOfDayMarketSummary(const onixs_ice::EndOfDayMarketSummary& msg, const onixs_ice::MessageInfo& ) 
+{
+   auto* data = _index.get_security(msg.marketId);
+   if (data != nullptr) 
+   {
+      bts_assert(data->id == msg.marketId);
+      onixs_ice::DateTime time = msg.dateTime;
+      auto ts = utils::TimeStamp::now();
+      auto settle_denominator = data->handle.security().ice_settle_denominator;
+      data->handle.update_settlement( ts,  convert_price(msg.settlementPrice, settle_denominator), date_of_timestamp(time) );
+      
+      LOG(md,Info,"OnixSICE Got EOD Market : {} - {}", std::to_string(data->id), std::to_string(msg.settlementPrice));
+      
+      auto deal_denominator = data->handle.security().ice_deal_denominator;
+      data->handle.update_opening( ts,  double_of_price(msg.openingPrice, deal_denominator), date_of_timestamp(time) );
+      data->handle.update_session_high( ts,  double_of_price(msg.high, deal_denominator) );
+      data->handle.update_session_low( ts,  double_of_price(msg.low, deal_denominator) );      
+   }        
+}
+
+//
+// Feed
+void ICEListener::onMulticastMessageBlockBegin(onixs_ice::FeedId feedId, const onixs_ice::MessageInfo& ) 
+{
+   UNUSED(feedId);
+}
+
+void ICEListener::onMulticastMessageBlockEnd(onixs_ice::FeedId feedId, const onixs_ice::MarketIds& marketIds) 
+{
+   UNUSED(feedId);
+   UNUSED(marketIds);
+}
+
+void ICEListener::onFeedStarted(onixs_ice::FeedId, const onixs_ice::MarketIds&) 
+{}
+
+void ICEListener::onFeedStopped(onixs_ice::FeedId) 
+{}
+
+void ICEListener::onSessionNumberChange(onixs_ice::FeedId , short , short )
+{}
+
+
+//
+// Non-onixs calls
+void ICEListener::add_filter_symbol(const std::string& symbol) 
+{
+   LOG(md, Info, "ICEListener::add_filter_symbol: adding {}", symbol);
+   _symbol_filter.insert(symbol);
+}
+
+void ICEListener::heartbeat() 
+{
+   for (auto& c : _channels) { c.heartbeat(); }
+}
+
+//
+// Private functions
+void ICEListener::add_security(const FixedSecurity& security) 
+{
+   // Set up the shared memory for this security
+   auto handle = _producer.add_security(security);
+   bts_assert(security.numeric_id != 0);
+   // Add it to the index so it can receive messages
+   _index.add_security(security.numeric_id, handle);
+}
+
+void ICEListener::update_all_status(CoconutSecurityStatus status) 
+{
+   _index.walk_security_list([=](ICESecurityData& data) 
+   {
+      data.handle.set_status(status);
+   });
+}
+
+}}} //namespace
+
+
@@ -119,7 +119,25 @@ private:
   enum SecurityFilterAction { ADD, SKIP, DELETE };
   
   std::string parse_contract_symbol(const std::string& sym);
-      
+   template<typename Definition>
+   std::string get_contract_symbol(const Definition& def){
+      const auto& sym = def.contractSymbol;
+      // TODO : this is only exception right now but for HHD sstrips
+      // def.contractSymbol is empty ! 
+      if (sym.size() == 0 && 
+         (
+            def.marketDesc.rfind("NG Swing GDD Futures - Henry", 0) == 0 ||
+            def.marketDesc.rfind("NG GDD for LD1 Futures Spr - Henry", 0) == 0
+         ))
+         return "HHD";
+
+      auto end = sym.find(' ');
+      if(end == std::string::npos)
+         return sym;
+      else
+         return sym.substr(0, end);
+   }
+
   template<typename Definition>
   SecurityFilterAction filter_security(int exchange_id, const Definition& def) 
   {
@@ -130,7 +148,7 @@ private:
      }
      if(_symbol_filter.count("*") > 0)
         return ADD;
-      return _symbol_filter.count( parse_contract_symbol(def.contractSymbol) ) > 0 ? ADD : SKIP;
+      return _symbol_filter.count(get_contract_symbol(def)) > 0 ? ADD : SKIP;
   }
   void flush_books();
   void update_all_status(co2::CoconutSecurityStatus status);
@@ -146,7 +164,7 @@ template<typename Definition>
 void ICEListener::set_security_common(const Definition& def, FixedSecurity& fsec) 
 {
   fsec.numeric_id = def.marketId;
-   std::string sym = parse_contract_symbol(def.contractSymbol);
+   std::string sym = get_contract_symbol(def);
   if(!sym.empty())
   {
      fsec.symbol( sym );
@@ -165,7 +183,7 @@ void ICEListener::set_security_common(const Definition& def, FixedSecurity& fsec
   fsec.ice_settle_denominator = (int8_t)(def.settlePriceDenominator - '0');
   double min_tick = double_of_price(def.incrementPrice, fsec.ice_price_denominator);
   fsec.low_tick = fsec.high_tick = min_tick;
-   fsec.price_break = 0.0;    
+   fsec.price_break = 0.0;
   
   fsec.ice_market_description(def.marketDesc);
   fsec.ice_cleared_alias(def.clearedAlias);
@@ -207,12 +225,12 @@ void ICEListener::on_uds_future_spread(const Definition& def, bool& is_intereste
   // auto expiration = date_of_maturity(sec);
   // if (expiration < datetime::today()) return;

-   FixedSpreadSecurityL fsec;
+   FixedSpreadSecurityXL fsec;
   set_security_common(def, fsec);
   fsec.alt_symbol(def.strategySymbol);      
   
-   const auto& legs = def.legs;
-   if (legs.size() > 0) {
+   const auto& legs = def.legs;   
+   if (legs.size() > 0 && legs.size() <= 512) {
      fsec.set_leg_count(legs.size());
      for(size_t x = 0; x < fsec.leg_count(); ++x) 
      {
@@ -238,6 +256,8 @@ void ICEListener::on_uds_future_spread(const Definition& def, bool& is_intereste
      add_security(fsec);
      is_interested = true;            
   }
+   else
+      LOG(md, Error, "Ignoring security {} with {} legs", def.marketDesc, legs.size());
 }


@@ -248,7 +268,7 @@ void ICEListener::on_future_strip(const FutureDefinition& def, bool& is_interest
   auto exchange_id = def.marketId;
   if (filter_security(exchange_id, def) != ADD) return;   

-   FixedSpreadSecurityXS fsec;
+   FixedSpreadSecurityXL fsec;
   set_security_common(def, fsec);
   fsec.alt_symbol(def.stripName);      
   
@@ -73,31 +73,17 @@ onixs_ice::MarketSubscriptions market_subcription_for_channel(const ICEChannel&
   onixs_ice::MarketSubscriptions subs;
   for(const auto& x : chan.market_types)
   {
-      //onixs_ice::MarketSubType::NonImplied
-      if(x == 26)
-      {
-         onixs_ice::MarketSubscription futures(x, onixs_ice::MarketSubType::NonImplied, onixs_ice::SecurityType::Futures, onixs_ice::BookDepth::FOD);
-         subs.push_back(futures);
-      }
-      else
-      {
-         onixs_ice::MarketSubscription futures(x, onixs_ice::MarketSubType::FullImplied, onixs_ice::SecurityType::Futures, onixs_ice::BookDepth::FOD);      
-         subs.push_back(futures);
-      }
+      onixs_ice::MarketSubscription futures(x, onixs_ice::MarketSubType::NonImplied, onixs_ice::SecurityType::Futures, onixs_ice::BookDepth::FOD);
+      subs.push_back(futures);
+
+      onixs_ice::MarketSubscription spreads(x, onixs_ice::MarketSubType::NonImplied, onixs_ice::SecurityType::UdsFuturesMarkets, onixs_ice::BookDepth::FOD);
+      subs.push_back(spreads);
   }
   for(const auto& x : chan.uds_market_types)
   {
-      if(x == 26)
-      {
-         onixs_ice::MarketSubscription spreads(x, onixs_ice::MarketSubType::NonImplied, onixs_ice::SecurityType::UdsFuturesMarkets, onixs_ice::BookDepth::FOD);
-         subs.push_back(spreads);
-      }
-      else
-      {
-         onixs_ice::MarketSubscription spreads(x, onixs_ice::MarketSubType::FullImplied, onixs_ice::SecurityType::UdsFuturesMarkets, onixs_ice::BookDepth::FOD);
-         subs.push_back(spreads);
-      }
-   }   
+      onixs_ice::MarketSubscription spreads(x, onixs_ice::MarketSubType::NonImplied, onixs_ice::SecurityType::UdsFuturesMarkets, onixs_ice::BookDepth::FOD);
+      subs.push_back(spreads);      
+   }
   return subs;
 }

@@ -138,6 +138,7 @@ struct PositionServicePNLHelper::PImpl {
 void PositionServicePNLHelper::compute_pnl(
      const std::map<int, PositionUnit const*>& in_pos,
      const std::map<std::string,uint32_t>& account_map,
+      const std::map<uint32_t,double>& cpp_override_map,
      std::vector<PNLUnit>& out_pnl,      
      std::vector<AccountPNL>& out_account_pnl){
   out_account_pnl.clear();
@@ -145,6 +146,8 @@ void PositionServicePNLHelper::compute_pnl(
      const PositionUnit& pu = *(p.second);
      uint32_t sec_key = pu.security_id();
      double cpp = me->handle_index.get_cpp(SecurityKey(sec_key));
+      auto it = cpp_override_map.find(sec_key);
+      cpp = (it != cpp_override_map.end()) ? it->second : cpp;
      double bid, ask, last, settle;
      me->handle_index.get_md(SecurityKey(sec_key),bid,ask,last,settle);
      PNLUnit pnlu;
@@ -17,7 +17,7 @@ private:
   std::unique_ptr<PImpl> me;
 private:
   double _compute_day_pnl (const bts::api::position::PNLUnit&);
-   double _get_cpp (uint32_t);
+   //double _get_cpp (uint32_t);
   // aggregates [sec, account]->pnl tp [account]->pnl
   void _aggregate_account_pnl(
         const std::vector<api::position::PNLUnit>& in_pnl,
@@ -29,6 +29,7 @@ private:
   ~PositionServicePNLHelper();
   void compute_pnl(const std::map<int, bts::api::position::PositionUnit const*>& in_pos,
                     const std::map<std::string,uint32_t>& account_map,
+                     const std::map<uint32_t,double>& cpp_override_map,
                     std::vector<bts::api::position::PNLUnit>& out_pnl,
                     std::vector<bts::api::position::AccountPNL>& out_account_pnl);
 };
@@ -28,6 +28,7 @@ using namespace bts::api::position;
 using namespace bts::md;

 static auto const manual_fills_ns = "manual_fills";
+static auto const security_params_ns = "security_parameters";

 struct PositionServiceServer::PImpl {
   bts::orderman::PositionMap state;
@@ -37,6 +38,7 @@ struct PositionServiceServer::PImpl {
   int id;
   // manual fills management
   std::unique_ptr<persistence::IStore> manual_fills_store;
+   std::unique_ptr<persistence::IStore> security_params_store;
   PositionServiceBase::Manual_fillsStatefulPublisher manual_fills_publisher;
   // pnl
   PositionServiceBase::Pnl_dataStatefulPublisher pnl_publisher;
@@ -47,6 +49,7 @@ struct PositionServiceServer::PImpl {
   bts::api::admin::AdminService admin_service;
   api::admin::AdminData admin_data;
   std::map<std::string, uint32_t> account_map;
+   std::map<uint32_t, double> cpp_override_map;

   PImpl(
       bts::api::ServiceContext &context,
@@ -64,6 +67,8 @@ struct PositionServiceServer::PImpl {
         // manual fills
         manual_fills_store(
             std::make_unique<persistence::SqliteStore>("manual_fills")),
+         security_params_store(
+             std::make_unique<persistence::SqliteStore>("security_parameters")),
         manual_fills_publisher(manual_fills_publisher),
         // pnl
         pnl_publisher(pnl_publisher),
@@ -73,7 +78,9 @@ struct PositionServiceServer::PImpl {
         // admin
         admin_service(context.locate<bts::api::admin::AdminService>()),
         admin_data(),
-         account_map() {}
+         account_map(),
+         cpp_override_map()
+         {}
 };

 PositionServiceServer::PositionServiceServer(bts::api::ServiceContext &context,
@@ -196,6 +203,27 @@ void PositionServiceServer::_clear_and_publish_pos(){
      me->pos_publisher.add_or_update(*p.second);   
   me->pos_publisher.flush();
 }
+
+void PositionServiceServer::_load_security_params(){
+   me->cpp_override_map.clear();
+   auto all = me->security_params_store->retrieve_all()[security_params_ns];
+   SecurityParameters rec;
+   for (auto const &kvp : all)
+      if (utils::pb::from_string<SecurityParameters>(kvp.second, &rec)){
+         if(rec.has_cpp_override()){
+            LOG(OrderMan, Info, "Overriding cpp, key:{} cpp:{}", 
+                                                   rec.security_key(),
+                                                   rec.cpp_override().value());
+            me->cpp_override_map[rec.security_key()] = rec.cpp_override().value();
+         }
+      }
+      else {
+         LOG(OrderMan, Error,
+             "Could not recover security parameter for security {} from storage. "
+             "This should be investigated",
+             kvp.first);
+      }
+}
 ///////////////////////////////////////////////////////////////////////////////
 /// Manual Fills API //////////////////////////////////////////////////////////
 void PositionServiceServer::create_manual_fill(
@@ -294,6 +322,30 @@ void PositionServiceServer::set_base_position(
   _clear_and_publish_pos();
 }

+void PositionServiceServer::update_security_parameters(
+       const SecurityParametersBatchOp& req,
+       const api::Response<SecurityParametersBatchOpResponse>&){
+   LOG(persist, Info, "PositionServiceServer::update_security_parameters bp count:{}",
+                       req.op_params_size());
+   for (const auto& p : req.op_params()){
+      std::string key_str = std::to_string(p.security_key());
+      auto db_p = me->security_params_store->retrieve_one(security_params_ns, key_str);
+      auto found = db_p.first;
+      if (!found) {
+         me->security_params_store->insert(security_params_ns,
+                                           key_str,
+                                           utils::pb::to_string(p));
+      } 
+      else {
+         me->security_params_store->insert(security_params_ns,
+                                          key_str,
+                                          utils::pb::to_string(p));
+      }
+   }
+   _load_security_params();
+   _compute_pnl_and_publish();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /// PNL helpers ///////////////////////////////////////////////////////////////
 void PositionServiceServer::_compute_pnl_and_publish() {
@@ -301,7 +353,8 @@ void PositionServiceServer::_compute_pnl_and_publish() {
   me->state.get_pos(in_pos);   
   std::vector<PNLUnit> pnl;
   std::vector<AccountPNL> account_pnl;
-   me->pnl_helper.compute_pnl(in_pos, me->account_map, pnl, account_pnl);
+   me->pnl_helper.compute_pnl(in_pos, me->account_map, me->cpp_override_map,
+                              pnl, account_pnl);
   for (const auto &u : pnl)
      me->pnl_publisher.add_or_update(u);
   for (const auto &u : account_pnl)
@@ -52,6 +52,7 @@ class PositionServiceServer : public bts::api::position::PositionServiceBase {
   void _compute_pnl_and_publish();
   void _set_admin_data(const api::admin::AdminData &admin_data);
   void _clear_and_publish_pos();
+   void _load_security_params();
 public:
   PositionServiceServer(bts::api::ServiceContext &context, md::MDClient &);

@@ -74,6 +75,11 @@ class PositionServiceServer : public bts::api::position::PositionServiceBase {
       const ::bts::api::position::BasePositionBatch &request,
       const api::Response<::bts::api::position::SetBasePositionResponse>
           &reply) override;
+   
+   void update_security_parameters(
+       const ::bts::api::position::SecurityParametersBatchOp &request,
+       const api::Response<::bts::api::position::SecurityParametersBatchOpResponse>
+           &reply) override;

   ~PositionServiceServer();
 };
@@ -2,11 +2,6 @@
 export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
 export PATH="$PATH:/root/.dotnet/tools"

-# install npx
-if ! [ -x "$(command -v npx)" ]; then
-    npm install -g npx
-fi
-
 export OUT=${BUILD_DIR:-../../../build}/web
 MODE=manual
 case "$OUT" in
@@ -39,9 +34,6 @@ PROTOC=../../../externals/linux/bin/protoc
 ORANGE='\033[0;33m'
 NOCOLOR='\033[0m'

-npm install
-
-
 # Run pbjs to produce protobuf module
 echo -e \* ${ORANGE} pbjs ${NOCOLOR}
 npx --no-install pbjs -t json-module -w commonjs -o $OUT/api/proto.js $PROTO_LIST
@@ -79,11 +71,10 @@ if [ "$FULL" ==  "1" ]; then
    export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
    echo -e \* ${ORANGE} fable ${NOCOLOR}
    cd ../ui/
-    npm install
    cd src
    mkdir -p $OUT/ui/
    cp -r ../public/* $OUT/ui/
-    dotnet restore
+    dotnet restore -s ../../../../externals/nuget/packages
    if [ "$MODE" == "release" ]; then
        dotnet fable webpack -- --env.BUILD_PATH=$OUT -p
    else
@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.5)
-
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libbase.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libutils.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libfix_lib.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libclxlog.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libade_version.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libade.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libclx.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libgmac_version.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libgmac.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libcputimestamp.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libclxconfig.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libconfigfile.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libac.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/librc.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/liblldt.so")
-LIST(APPEND CELOXICA_LIB "${SPARK_LIB}/celoxica/libregister.so")
-
-file(COPY ${CELOXICA_LIB} DESTINATION ${CMAKE_BINARY_DIR}/src/server/sparkd)
-
-
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+SRC_ROOT=$DIR/../..
+BUILD_ROOT=`readlink -f $SRC_ROOT/build`
+BUILD_TYPE="${1:-clang_debug}"
+BUILD_CMD="ninja -C $BUILD_ROOT/$BUILD_TYPE"
+touch $SRC_ROOT/CMakeLists.txt
+$DIR/execute_in_docker $BUILD_CMD
+
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+SRC_ROOT=$DIR/../..
+BUILD_ROOT=`readlink -f $SRC_ROOT/build`
+cgdb -- -ex start --cd=$BUILD_ROOT/ninja_debug/server --args ./sparkd run
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+SRC_ROOT=$DIR/../..
+
+CMD=$@
+    
+read -d '' docker_cmd << EOF
+docker run \
+      --rm \
+      --net host \
+      -h $(hostname)_spark \
+      -e "TZ=America/New_York" \
+      --security-opt seccomp=unconfined \
+      -v /var/log/syslog:/var/log/syslog \
+      -v /usr/local/share/fonts:/usr/local/share/fonts \
+      -v /usr/share/fonts:/usr/share/fonts \
+      -v /run/user/:/run/user/ \
+      -v /tmp:/tmp \
+      -v /etc/group:/etc/group \
+      -v /etc/passwd:/etc/passwd \
+      -v /tmp:/tmp \
+      -v /etc/sudoers:/etc/sudoers \
+      -v /home:/home \
+      --shm-size=4024m \
+      -w $SRC_ROOT \
+      -u $UID \
+      -t \
+      -i \
+      -e DISPLAY=$DISPLAY \
+      bluetradingsystems/linux_docker
+EOF
+
+if [ -f /.dockerenv ]; then
+    $CMD
+else
+    echo "Running $CMD"
+    $docker_cmd $CMD
+fi
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+$DIR/execute_in_docker /usr/local/bin/rdm $@  
+
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CMD="$DIR/../setup_builds.sh"
+$DIR/execute_in_docker "/bin/bash -c $CMD"
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+SRC_ROOT=$DIR/../
+$DIR/execute_in_docker /bin/bash
+
+
Author	SHA1	Message	Date
Taha Afzal	482c300b72	Merge branch 'DJ_ICE_space_bar_recenter' into DJ_ICE	2020-06-14 21:08:51 -04:00
Pedro Pinto	69ad995ba9	Updated docker	2020-06-14 15:23:18 -04:00
Pedro Pinto	0b26ec1132	Added a few build tools.	2020-06-14 15:21:55 -04:00
John Colvin	3de494c80f	recenter all ladders on spacebar (don't require shift)	2020-06-12 17:05:53 -05:00
John Colvin	7deb25dd1c	fix ladder recenter on spacebar	2020-06-12 13:16:57 -05:00
Pedro Pinto	7a29ae1a83	Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE	2020-06-12 08:44:36 -04:00
Pedro Pinto	6da893128c	Cleaned up logging.	2020-06-12 08:44:20 -04:00
Pedro Pinto	2cb458af2d	Added OnBehalfofcompid tag to ICE as per cert.	2020-06-12 08:42:40 -04:00
Taha Afzal	04db38d627	Merge branch 'DJ_ICE_release_candidates' into DJ_ICE	2020-06-11 21:22:18 -04:00
John Colvin	a144b03361	ladder recenter on spacebar (across thread barrier)	2020-06-11 18:28:37 -05:00
John Colvin	9c89a9a47e	TabDocument forwards key press events to IShellWindows	2020-06-11 18:24:26 -05:00
John Colvin	007af71bb2	fix ladder center-on-settle behavior once and for all	2020-06-11 17:09:05 -05:00
Taha Afzal	a216d1cc81	Fixing sell order check for distance from settlement	2020-06-11 09:19:03 -04:00
Pedro Pinto	f8395c11b5	Fixed application, vendor tags for DJ.	2020-06-11 08:26:26 -04:00
John Colvin	2b0e46ed38	fix ladder center around settle behavior	2020-06-11 00:36:11 -05:00
John Colvin	5f3b243265	'max settlement cross ticks limit' ladder setting	2020-06-10 18:16:52 -05:00
John Colvin	c9ce2d18bf	simplify 'Safety Checks' content alignment in ladder settings dialog	2020-06-10 17:33:13 -05:00
John Colvin	7b563ba66c	ladder centers around settlement price if no bid/ask market	2020-06-10 13:17:01 -05:00
Taha Afzal	3e1be70923	Fix for HHD Balmo spreads	2020-06-10 13:57:19 -04:00
John Colvin	aadd7df6c6	quantity divisor is 1 for 'ICE Lots' secs	2020-06-09 22:49:57 -05:00
John Colvin	8206132a37	quantity conversion in pnl for dj	2020-06-09 17:27:29 -05:00
John Colvin	f8b3fd2e14	QuantityConversionData.to/from_display extensions use 'safe_divide'	2020-06-09 17:10:21 -05:00
John Colvin	8b17ee72ff	quantity conversion in ladder when last size is transposed over volume column	2020-06-09 10:50:06 -05:00
John Colvin	31ed473999	quantity conversion in time and sales for dj	2020-06-08 17:25:13 -05:00
John Colvin	673805a7f4	quantity conversion in fills for dj	2020-06-08 17:10:39 -05:00
John Colvin	91422449e9	quantity conversion in manual fills for dj	2020-06-08 17:02:55 -05:00
John Colvin	438089a1cd	quantity conversion in mview for dj	2020-06-08 16:36:57 -05:00
John Colvin	6a186d1d7e	MarketViewRow - remove unreferenced fields	2020-06-08 16:33:55 -05:00
John Colvin	9d831a2569	fix line endings in MarketViewVM.cs	2020-06-08 16:33:55 -05:00
John Colvin	d47cf1a54e	(Dynamic)DoubleDivisorConverter uses safe_divide extension	2020-06-08 16:33:55 -05:00
John Colvin	8c9f669e72	refactor IsRealNonZero to is_real_positive (orig name was a typo), add a few more similar extensions to MathUtils	2020-06-08 16:33:55 -05:00
John Colvin	f5bda11797	quantity conversion in orderbook for dj	2020-06-08 12:19:43 -05:00
John Colvin	1841a75fec	quantity conversion in ladder/ticket for dj	2020-06-08 12:19:43 -05:00
John Colvin	34cdaeec93	don't use Disposable.replace bc it creates the next disposable before disposing the previous one	2020-06-07 16:01:27 -05:00
Taha Afzal	3230fb9e48	Regular TAS contract's formatting did not have the word TAS in it	2020-06-05 16:42:05 -04:00
Taha Afzal	888b4e22c0	Ignoring strips with > 512 components	2020-06-05 14:11:34 -04:00
Taha Afzal	534ce5a8ec	strips are XL too	2020-06-05 13:12:57 -04:00
Taha Afzal	c2b9ac57dc	Fixing build	2020-06-05 11:55:54 -04:00
Taha Afzal	2783361325	Merge branch 'master' into DJ_ICE	2020-06-05 10:50:42 -04:00
Taha Afzal	46d35131d7	Overridable cpps	2020-06-05 10:01:18 -04:00
Pedro Pinto	3b95154c04	Updated ICE Onixs	2020-06-05 09:11:03 -04:00
Pedro Pinto	1a6b918853	Updated docker	2020-06-04 13:43:25 -04:00
Pedro Pinto	bc22605a25	Added +x	2020-06-04 13:43:00 -04:00
Pedro Pinto	f3d28add1c	Added publishing of new routing info when orders are recorevered from disk	2020-06-04 13:41:34 -04:00
Taha Afzal	63d260a6f8	Security formatting for ICE	2020-06-03 09:42:44 -04:00
Taha Afzal	9b4a63b4a8	Changes to make HNG/HIS/HEN/HHD to work	2020-06-02 11:15:47 -04:00
Pedro Pinto	a502c365e5	Build tweaks	2020-05-28 12:15:16 -04:00
Pedro Pinto	fdacd8b543	Added -f when removing simlinks in build setup.	2020-05-28 12:02:46 -04:00
John Colvin	3d1de9a0c7	nuget_restore.cmd uses externals package source (builds offline)	2020-05-28 12:02:31 -04:00
John Colvin	b2b3fa5949	update jenkinsbuild.cmd to use externals nuget source (for windows)	2020-05-28 12:02:17 -04:00
Pedro Pinto	86ecf69820	Updated external subrepos	2020-05-28 11:53:51 -04:00
Pedro Pinto	8f537a8fda	Merged in build_improvements (pull request #414 ) Build improvements	2020-05-26 16:32:43 +00:00
Pedro Pinto	01b9ff6b47	Dropped celoxica	2020-05-26 12:28:35 -04:00
Pedro Pinto	2609663d3e	Updated setup_builds to work even if its run outside the tree.	2020-05-26 12:06:08 -04:00
Pedro Pinto	fd89241611	Updated externals pointer	2020-05-26 11:49:29 -04:00
John Colvin	a69118c5d3	fix line endings in release_notes	2020-05-22 23:42:27 -05:00