Position Reserve (PR) Orders

When an order is placed via TT Core SDK, it is routed to the TT risk system. If it passes the necessary risk checks, it is then routed to a TT component called the Order Connector which then routes it to the exchange. If it does not pass the necessary risk checks, it is rejected. Use of Position Reserve (PR) orders allows position risk to be reserved ahead of time so that the TT risk system can be skipped when orders are placed. This can result in a significant latency reduction in terms of routing new/change/cancel order messages.

To reserve position risk, you must specify:

• Instrument
• Account
• Side
• Total Quantity
• Maximum Clip Size

It is intended for Position Reserve orders to be submitted when your application initializes or at least before any latency sensitive aspect of your application executes. Once successfully submitted, any subsequent orders for the same instrument and account will undergo a quick local risk check to confirm that they do not exceed the limits specified in the Position Reserve order. The behavior of this risk check varies depending upon whether you submit only a buy PR order, only a sell PR order, or both buy and sell PR orders for a given instrument / account.

Specifically:

• Buy side only -> for buy orders, SDK sums worst-case-position of all buys (fills + working quantity) and checks against this limit. Sell orders are risk checked by the standard TT risk system.
• Sell side only -> for sell orders, SDK sums worst-case-position of all sells (fills + working quantity) and checks against this limit. Buy orders are risk checked by the standard TT risk system.
• Both -> SDK sums worst-case-position of all buys and sells (fills + working quantity) and checks all buy/sell orders against this limit.

Position Reserve orders are persistent in the TT system. As such, it is important that PR orders be deleted (released) as part of stopping your application.

The following code snippet demonstrates one way of using and managing Position Reserve orders when NOT running as an Application Server. If you are running as an Application Server, see the Initializing a Server Application section for further details.

std::condition_variable releaseReady;
std::condition_variable reserveReady;

class PositionReserveManager {

    public:

    PositionReserveManager()
    {
    }

    virtual ~PositionReserveManager()
    {
        ReleaseAllRisk();
    }

    void ReleaseAllRisk()
    {  
        for (auto itr = positionReserves_.cbegin(); itr != positionReserves_.cend();)
        {
            if (!ttsdk::ReleaseRisk(std::get(*iter), std::get(*iter), std::get(*iter))
                std::cout (*iter).GetInstrumentId() (*iter) (*iter))  release_lock(releaseMutex);
            {
                if (releaseReady.wait_for(release_lock, std::chrono::seconds(300)) == std::cv_status::timeout)
                    std::cout GetAlias()  reserve_lock(reserveMutex);
        {
            if (reserveReady.wait_for(reserve_lock, std::chrono::seconds(300)) == std::cv_status::timeout)
            {
                std::cout  release_lock(releaseMutex);
        {
            if (releaseReady.wait_for(release_lock, std::chrono::seconds(300)) == std::cv_status::timeout)
            {
                std::cout > positionReserves_;
};


class MyOrderBookHandler : public ttsdk::IOrderBookEventHandler
{
    //
    //  ...
    //

    // Fired in response to a Position Reserve order being created

    virtual void OnRiskReserved(const uint64_t instrumentId, const uint64_t accountId, const ttsdk::RiskSide side, const bool successful)
    {
        if (!successful)
        {
            std::cout GetOrderId() GetOrderId() 

The SDK also stores a collection of handles to PR orders. Access to specific PR orders can be obtained via the GetRiskBucket() function.

        
// Returns the current Position Reserve bucket for the given instrument and account
PositionReserveBucket GetRiskBucket(InstrumentPtr instrument, const uint64_t accountId) noexcept;