求助：基于R语言IBrokers API的reqMktDepth日内交易策略实现

Hey Augusto, let's break this down step by step—using IBrokers to build your order book-based intraday strategy is totally doable, even if you're still getting up to speed with R. Here's a practical walkthrough to get you started:

Before you can fetch order book data or send orders, you need to establish a link to TWS. Make sure TWS is running, API access is enabled in its settings, and you know your port number (7497 is the default for paper trading, 7496 for live accounts).

library(IBrokers)

# Connect to TWS (clientId must be unique if multiple connections are active)
tws_conn <- twsConnect(port = 7497, clientId = 1)

reqMktDepth is your tool for pulling market depth (order book) data from IB. It works asynchronously, so you'll need a callback function to handle real-time updates as they come in. Let's build that out:

First, define the contract for the asset you're trading (we'll use S&P 500 E-mini futures as an example—adjust for your target asset):

# Define your trade contract
es_contract <- twsFuture("ES", "GLOBEX", "202403") # symbol, exchange, expiry date

Next, create a callback to capture and store the latest bid/ask levels (we'll use a global list to access this data later for signals):

# Initialize a global list to hold live order book data
order_book <- list(bidPrice = NA, bidSize = NA, askPrice = NA, askSize = NA)

# Callback function to update the order book with real-time data
depth_callback <- function(msg, timestamp, file, ...) {
  # Update best bid data
  if (!is.null(msg$bidPrice)) {
    order_book$bidPrice <<- msg$bidPrice[1] # Top of the buy side
    order_book$bidSize <<- msg$bidSize[1]   # Volume at the best bid
  }
  # Update best ask data
  if (!is.null(msg$askPrice)) {
    order_book$askPrice <<- msg$askPrice[1] # Top of the sell side
    order_book$askSize <<- msg$askSize[1]   # Volume at the best ask
  }
  # Optional: Print updates to monitor live data
  print(paste("Live Book: Bid", order_book$bidPrice, "/", order_book$bidSize, "| Ask", order_book$askPrice, "/", order_book$askSize))
}

Now start streaming market depth data (set depth = 1 to only get the top bid/ask level—increase if you need deeper book data):

# Subscribe to real-time market depth
reqMktDepth(tws_conn, es_contract, depth = 1, eventWrapper = eWrapperMktDepth(), CALLBACK = depth_callback)

Now that you're capturing live bid/ask volumes, you can define your strategy rules. For example, let's say you want to:

• Place a buy limit order below the current market price when buy-side volume is 2x larger than sell-side volume (showing strong buying pressure)
• Place a sell limit order above the current market price when sell-side volume is 2x larger than buy-side volume (showing strong selling pressure)

Here's how to implement that logic:

# Function to check signals and place orders
check_signals <- function() {
  # Skip if we don't have complete data
  if (any(is.na(order_book))) return()
  
  # Calculate volume ratios to gauge pressure
  bid_ask_ratio <- order_book$bidSize / order_book$askSize
  ask_bid_ratio <- order_book$askSize / order_book$bidSize
  
  # Buy signal: Bid volume is double the ask volume
  if (bid_ask_ratio > 2) {
    # Place buy limit order 0.25 points below best bid (adjust for your asset's tick size)
    buy_order <- twsOrder(
      action = "BUY",
      totalQuantity = 1,
      orderType = "LMT",
      lmtPrice = order_book$bidPrice - 0.25
    )
    placeOrder(tws_conn, es_contract, buy_order)
    print("Buy order placed!")
  }
  
  # Sell signal: Ask volume is double the bid volume
  if (ask_bid_ratio > 2) {
    # Place sell limit order 0.25 points above best ask
    sell_order <- twsOrder(
      action = "SELL",
      totalQuantity = 1,
      orderType = "LMT",
      lmtPrice = order_book$askPrice + 0.25
    )
    placeOrder(tws_conn, es_contract, sell_order)
    print("Sell order placed!")
  }
}

# Run the signal checker in a loop (adjust sleep time for how often you want to check conditions)
while (TRUE) {
  check_signals()
  Sys.sleep(1) # Check every 1 second
}

• Order Management: Add logic to cancel existing open orders before placing new ones to avoid duplicate positions. Use reqOpenOrders to check for active orders and cancelOrder to remove them.
• Error Handling: Wrap connection and order functions in tryCatch() blocks to handle disconnections or API errors without crashing your script.
• Tick Size Alignment: Adjust the limit price offset (0.25 in the example) to match your asset's minimum tick size—otherwise your order may be rejected.
• Paper Trade First: Test every part of your strategy in IB's paper trading environment before using real capital.

Don't forget to close the TWS connection when you finish trading or testing:

twsDisconnect(tws_conn)

内容的提问来源于stack exchange，提问作者Augusto