Real time candle data

[shial4]

Hi, I'm unsure how to get real time candle data. Could you provide quick playground? Thanks

[shial4]

would this be something like:

import Foundation
import Combine
import IBKit

extension IBContract {
    static var sp500 = IBContract.future(localSymbol: "MESM4", currency: "USD", exchange: .CME)
    static var russell2000 = IBContract.future(localSymbol: "M2KM4", currency: "USD", exchange: .CME)
    static var NASDAQ100 = IBContract.future(localSymbol: "MNQM4", currency: "USD", exchange: .CME)
    static var Dow = IBContract.future(localSymbol: "MYMM4", currency: "USD", exchange: .CME)
}

class MarketData {
    let client = IBClient.paper(id: 999)
    var subscriptions: [AnyCancellable] = []
    var currentBar: Bar?
    let barInterval: TimeInterval = 300 // 5 minutes in seconds
    
    deinit {
        client.disconnect()
    }
    
    init() {
        client.eventFeed.sink { event in
            guard let event = event as? IBPriceHistory else { return }
            event.prices.forEach{ print($0) }
        }
        .store(in: &subscriptions)
    }
    
    func connect() {
        do {
            try client.connect()
        } catch {
            print(error.localizedDescription)
        }
    }
    
    public func marketDataPublisher(for contract: IBContract) throws {
        let index = client.nextRequestID
        try client.subscribeMarketData(index, contract: contract)
        
        client.eventFeed
            .compactMap { $0 as? IBTick }
            .filter { $0.requestID == index }
            .sink {[weak self] tick in
                guard let self else { return }
                switch tick.type {
                    case .LastPrice:
                    self.updateBar(with: tick.value)
                default:
                    break
                }
            }
            .store(in: &subscriptions)
    }
    
    private func updateBar(with price: Double) {
        let currentTime = Date().timeIntervalSince1970
        if let bar = currentBar {
            if currentTime > bar.timeOpen + bar.interval {
                // Close current bar and create a new one
                finalizeCurrentBar()
                createNewBar(startingAt: currentTime, withInitialPrice: price)
            } else {
                // Update existing bar
                bar.priceHigh = max(bar.priceHigh, price)
                bar.priceLow = min(bar.priceLow, price)
                bar.priceClose = price
            }
        } else {
            // Create the first bar
            createNewBar(startingAt: currentTime, withInitialPrice: price)
        }
    }
    
    private func createNewBar(startingAt time: TimeInterval, withInitialPrice price: Double) {
        currentBar = Bar(
            timeOpen: time,
            interval: barInterval,
            priceOpen: price,
            priceHigh: price,
            priceLow: price,
            priceClose: price
        )
    }
    
    private func finalizeCurrentBar() {
        if let bar = currentBar {
            print("Bar finalized: \(bar)")
            // Push this bar to a data store or for further analysis
        }
    }
}

[stensoosaar]

Hello!
I have found about three ways to achieve that:

1. build bars from live trades or bid/ask snapshots as you proposed,
2. request live bars (sample below) which sends you 5 second bars of requested contract,
3. request price history without end date using eg IBDuration.continuousUpdates(size:unit)
   the latter one should give you bars in correct resolution and updates the last bar every 5 seconds

BR
Sten

import Foundation
import IBKit
import Combine

public class Datasource{
	
	var api: IBClient
	
	public init() {
		self.api = IBClient.paper(id: 0, type: .gateway)		
	}
	
	public func connect() throws {
		try api.connect()
	}
	
	public func disconnect() {
		api.disconnect()
	}
	
	public func realTimeBarPublisher(contract: IBContract) throws -> AnyPublisher<IBPriceBarUpdate,Never> {
		
		let requestID: Int = api.nextRequestID
		try api.subscribeRealTimeBar(requestID, contract: contract, barSize: .fiveSeconds, barSource: .trades)
		
		return AnyPublisher(api.eventFeed
			.compactMap({$0 as? IBPriceBarUpdate})
			.filter({$0.requestID == requestID} )
			.eraseToAnyPublisher()
		)
		
	}
	
}

let source = Datasource()
try source.connect()

var cancellables: [AnyCancellable] = []

try source.realTimeBarPublisher(contract: IBContract.equity("AAPL", currency: "USD"))
	.sink{
		print($0)
	}
	.store(in: &cancellables)