public DisposableAlpacaDataSubscription(
IAlpacaDataSubscription <TItem> subscription,
IAlpacaDataStreamingClient client)
{
_subscription = subscription;
_client = client;
_client.Subscribe(_subscription);
}
public AlpacaClient(AlpacaConfig config)
{
_config = config;
_alpacaTradingClient = config.Alpaca_Use_Live_Api
? Environments.Live.GetAlpacaTradingClient(new SecretKey(_config.Alpaca_Live_App_Id, _config.Alpaca_Live_Secret_Key))
: Environments.Paper.GetAlpacaTradingClient(new SecretKey(_config.Alpaca_Paper_App_Id, _config.Alpaca_Paper_Secret_Key));
_alpacaDataClient = config.Alpaca_Use_Live_Api
? Environments.Live.GetAlpacaDataClient(new SecretKey(_config.Alpaca_Live_App_Id, _config.Alpaca_Live_Secret_Key))
: Environments.Paper.GetAlpacaDataClient(new SecretKey(_config.Alpaca_Paper_App_Id, _config.Alpaca_Paper_Secret_Key));
_alpacaStreamingClient = config.Alpaca_Use_Live_Api
? Environments.Live.GetAlpacaDataStreamingClient(new SecretKey(_config.Alpaca_Live_App_Id, _config.Alpaca_Live_Secret_Key))
: Environments.Paper.GetAlpacaDataStreamingClient(new SecretKey(_config.Alpaca_Paper_App_Id, _config.Alpaca_Paper_Secret_Key));
}
public AlpacaClient(
IAlpacaTradingClient alpacaTradingClient,
IAlpacaStreamingClient alpacaTradingStreamingClient,
IAlpacaDataClient alpacaDataClient,
IAlpacaDataStreamingClient alpacaDataStreamingClient
)
{
_alpacaTradingClient = alpacaTradingClient ?? throw new ArgumentNullException(nameof(alpacaTradingClient));
_alpacaTradingStreamingClient = alpacaTradingStreamingClient ?? throw new ArgumentNullException(nameof(alpacaTradingStreamingClient));
_alpacaDataClient = alpacaDataClient ?? throw new ArgumentNullException(nameof(alpacaDataClient));
_alpacaDataStreamingClient = alpacaDataStreamingClient ?? throw new ArgumentNullException(nameof(alpacaDataStreamingClient));
_stockActions = new Dictionary <string, List <Action <StockInput> > >(StringComparer.OrdinalIgnoreCase);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_client = Alpaca.Markets.Environments.Paper
.GetAlpacaDataStreamingClient(new SecretKey(_configuration.GetSection("AlpacaAPI").GetSection("KeyId").Value,
_configuration.GetSection("AlpacaAPI").GetSection("SecretKey").Value));
await _client.ConnectAndAuthenticateAsync();
var stocks = await GetStocksForStreaming();
foreach (var stock in stocks)
{
var subscription = _client.GetQuoteSubscription(stock);
_subscriptions.Add(subscription);
subscription.Received += async(result) => await SubscriptionResult_Received(result);
}
_client.Subscribe(_subscriptions);
}
public static IAlpacaDataSubscription <IBar> GetMinuteBarSubscription(
this IAlpacaDataStreamingClient client,
params String[] symbols) =>
getMinuteBarSubscription(
client.EnsureNotNull(nameof(client)),
symbols.EnsureNotNull(nameof(symbols)));
public static IAlpacaDataSubscription <IQuote> GetQuoteSubscription(
this IAlpacaDataStreamingClient client,
IEnumerable <String> symbols) =>
getQuoteSubscription(
client.EnsureNotNull(nameof(client)),
symbols.EnsureNotNull(nameof(symbols)));
private static IAlpacaDataSubscription <IBar> getDailyBarSubscription(
IAlpacaDataStreamingClient client,
IEnumerable <String> symbols) =>
getSubscription(client.GetDailyBarSubscription, symbols);
private static IAlpacaDataSubscription <IQuote> getQuoteSubscription(
IAlpacaDataStreamingClient client,
IEnumerable <String> symbols) =>
getSubscription(client.GetQuoteSubscription, symbols);
public static ValueTask <IDisposableAlpacaDataSubscription <IBar> > SubscribeDailyBarAsync(
this IAlpacaDataStreamingClient client,
IEnumerable <String> symbols) =>
DisposableAlpacaDataSubscription <IBar> .CreateAsync(
client.EnsureNotNull(nameof(client)).GetDailyBarSubscription(symbols),
client);
public static ValueTask <IDisposableAlpacaDataSubscription <IBar> > SubscribeMinuteBarAsync(
this IAlpacaDataStreamingClient client,
params String[] symbols) =>
DisposableAlpacaDataSubscription <IBar> .CreateAsync(
client.EnsureNotNull(nameof(client)).GetMinuteBarSubscription(symbols),
client);
public static ValueTask <IDisposableAlpacaDataSubscription <IQuote> > SubscribeQuoteAsync(
this IAlpacaDataStreamingClient client,
String symbol) =>
DisposableAlpacaDataSubscription <IQuote> .CreateAsync(
client.EnsureNotNull(nameof(client)).GetQuoteSubscription(symbol),
client);
public static IAlpacaDataStreamingClient WithReconnect(
this IAlpacaDataStreamingClient client,
ReconnectionParameters parameters) =>
new ClientWithReconnection(client, parameters);
public static IAlpacaDataStreamingClient WithReconnect(
this IAlpacaDataStreamingClient client) =>
WithReconnect(client, ReconnectionParameters.Default);
public async Task Run()
{
alpacaTradingClient = Environments.Paper.GetAlpacaTradingClient(new SecretKey(API_KEY, API_SECRET));
alpacaDataClient = Environments.Paper.GetAlpacaDataClient(new SecretKey(API_KEY, API_SECRET));
// Connect to Alpaca's websocket and listen for updates on our orders.
alpacaStreamingClient = Environments.Paper.GetAlpacaStreamingClient(new SecretKey(API_KEY, API_SECRET));
alpacaStreamingClient.ConnectAndAuthenticateAsync().Wait();
alpacaStreamingClient.OnTradeUpdate += HandleTradeUpdate;
// First, cancel any existing orders so they don't impact our buying power.
var orders = await alpacaTradingClient.ListOrdersAsync(new ListOrdersRequest());
foreach (var order in orders)
{
await alpacaTradingClient.DeleteOrderAsync(order.OrderId);
}
// Figure out when the market will close so we can prepare to sell beforehand.
var calendars = (await alpacaTradingClient
.ListCalendarAsync(new CalendarRequest().SetTimeInterval(DateTime.Today.GetInclusiveIntervalFromThat())))
.ToList();
var calendarDate = calendars.First().TradingDateUtc;
var closingTime = calendars.First().TradingCloseTimeUtc;
closingTime = new DateTime(calendarDate.Year, calendarDate.Month, calendarDate.Day, closingTime.Hour, closingTime.Minute, closingTime.Second);
var today = DateTime.Today;
// TODO: olegra - temporary disable for the transition period
// Get the first group of bars from today if the market has already been open.
//var bars = await alpacaDataClient.ListAggregatesAsync(
// new AggregatesRequest(symbol, new AggregationPeriod(1, AggregationPeriodUnit.Minute))
// .SetInclusiveTimeInterval(today, today.AddDays(1)));
//var lastBars = bars.Items.Skip(Math.Max(0, bars.Items.Count() - 20));
//foreach (var bar in lastBars)
//{
// if (bar.TimeUtc?.Date == today)
// {
// closingPrices.Add(bar.Close);
// }
//}
Console.WriteLine("Waiting for market open...");
await AwaitMarketOpen();
Console.WriteLine("Market opened.");
// Connect to Polygon's websocket and listen for price updates.
alpacaDataStreamingClient = Environments.Live.GetAlpacaDataStreamingClient(new SecretKey(API_KEY, API_SECRET));
alpacaDataStreamingClient.ConnectAndAuthenticateAsync().Wait();
Console.WriteLine("Polygon client opened.");
var subscription = alpacaDataStreamingClient.GetMinuteAggSubscription(symbol);
subscription.Received += async(agg) =>
{
// If the market's close to closing, exit position and stop trading.
TimeSpan minutesUntilClose = closingTime - DateTime.UtcNow;
if (minutesUntilClose.TotalMinutes < 15)
{
Console.WriteLine("Reached the end of trading window.");
await ClosePositionAtMarket();
await alpacaDataStreamingClient.DisconnectAsync();
}
else
{
// Decide whether to buy or sell and submit orders.
await HandleMinuteAgg(agg);
}
};
alpacaDataStreamingClient.Subscribe(subscription);
}
/// <summary>
/// Wraps instance of <see cref="IAlpacaDataStreamingClient"/> into the helper class
/// with automatic reconnection support and provide optional reconnection parameters.
/// </summary>
/// <param name="client">Original streaming client for wrapping.</param>
/// <param name="parameters">Reconnection parameters (or default if missing).</param>
/// <returns>Wrapped version of the <paramref name="client"/> object with reconnect.</returns>
public static IAlpacaDataStreamingClient WithReconnect(
this IAlpacaDataStreamingClient client,
ReconnectionParameters?parameters = null) =>
new ClientWithReconnection(client, parameters ?? ReconnectionParameters.Default);
