Self.algorithm.Transactions.GetOrders

The OrderId you get from the OrderTicket in QuantConnect is an internal identifier used by the LEAN engine to track orders. It is unique for each order placed within the algorithm. However, this OrderId is not the same as the order ID assigned by the brokerage, such as Interactive Brokers (IB).

In live trading, the brokerage may assign its own ID to the order. You can access orders that correspond to a brokerage-assigned ID using the get_orders_by_brokerage_id method of the Transactions object:

orders_by_brokerage_id = self.transactions.get_orders_by_brokerage_id(brokerageId)

However, please note that QuantConnect does not save your brokerage account credentials when you deploy live algorithms with a brokerage like Oanda or IB.

If you encounter any issues with live trading, you can contact support@quantconnect.com for assistance.

Sources:

• Forum Discussion on Order ID
• Documentation on Transaction Manager
• Documentation on Oanda Brokerage
• Forum Discussion on IB Paper Trading

In live trading, After the OnWarmupFinished event, I want to reconcile my open positions which are stored in the object_store with brokerage open positions so I call below methods to get brokerage's open positions. In below Orders have IB orders or internal QC orders ?

 def get_open_positions(self):
        open_positions = []
        orders = self.algorithm.Transactions.GetOrders(
            lambda x: x.Status in {OrderStatus.Filled, OrderStatus.PartiallyFilled})

        # Iterate over all securities in the portfolio
        for security in self.algorithm.Portfolio.Values:
            if security.Invested:
                symbol = security.Symbol.Value
                lots = []

                # Find all orders related to this security
                related_orders = [order for order in orders if order.Symbol.Value == symbol]

                for order in related_orders:
                    # Check if order's date is before or at the current holding's entry date
                    if order.Status == OrderStatus.Filled:
                        lots.append({
                            'Symbol': symbol,
                            'Quantity': order.Quantity,
                            'entryPrice': order.Price,
                            'entryDate': order.Time.date().isoformat(),
                            'OrderId': order.Id
                        })

                # Append lots to open positions
                open_positions.extend(lots)

        return open_positions

The GetOrders method in your code retrieves orders that have been placed by your algorithm and are tracked by the LEAN engine. These orders include those that have been filled or partially filled. The OrderId in this context is the internal ID used by LEAN, not the order ID assigned by the brokerage like Interactive Brokers (IB).

When your algorithm is deployed in live trading, LEAN fetches the cashbook, open positions, and open orders from the brokerage at the start. This information is used to create a portfolio representing your account. However, past orders are not fetched.

If you want to reconcile your open positions stored in the Object Store with the brokerage's open positions, you might need to save the orders to the Object Store as well.

Here is an example of how you can save insights between deployments:

self.ObjectStore.Save("my-insight", insight)

You can then load the saved insights when you need them:

insight = self.ObjectStore.Read("my-insight")

Please note that the Object Store is a simple key-value store and does not support complex queries.

Sources:

• Forum Discussion on Fetching Orders
• Documentation on Object Store

Below method calculate the total_exposure of the portfolio. Is this exposure getting from brokerage account ?

    def current_invested_exposure(self):
        total_exposure = sum(holding.HoldingsValue for holding in self.algorithm.Portfolio.Values if holding.Invested)
        return total_exposure

The current_invested_exposure method you've shared calculates the total exposure of your portfolio based on the positions currently held in your algorithm's portfolio. The HoldingsValue for each security is calculated by the LEAN engine and represents the size of the holding in account currency.

When your algorithm is deployed in live trading, LEAN fetches the cashbook, open positions, and open orders from the brokerage at the start. This information is used to create a portfolio representing your account. Therefore, the exposure calculated by this method should match the exposure in your brokerage account, assuming no external trades have been made.

However, please note that this method does not fetch live data from the brokerage account during the algorithm execution. It uses the data already available in the algorithm's portfolio. If you make trades outside of the algorithm, they won't be reflected in this calculation.

Sources:

• Forum Discussion on Portfolio Value
• Forum Discussion on Order ID

How to reconcile the positions/orders which were made outside lean engine ?

QuantConnect's LEAN engine does not support interfering with the brokerage. Any detected external orders will cause the algorithm to stop immediately. This is because the algorithm maintains its own state and any external changes could lead to discrepancies and unexpected behavior.

For example, if you have an algorithm that ensures a 20% allocation to a certain asset, and manual orders keep trying to sell the position, the algorithm would immediately rebuy the stocks, leading to potential issues.

If you need to reconcile positions or orders made outside of the LEAN engine, you would need to stop the algorithm, make your external trades, and then restart the algorithm. However, please note that past orders are not fetched when the algorithm is restarted.

Sources:

• Forum Discussion on External Orders
• Forum Discussion on Fetching Orders