Previously, it assumed the first leg would have the earliest exp. While this may be true for most securities, it isn't guarenteed by our data model.
219 lines
11 KiB
C#
219 lines
11 KiB
C#
namespace bts.api {
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection.Metadata.Ecma335;
|
|
|
|
public static class SecurityExtensions {
|
|
public static Security.ContractOneofCase contract_case(this SecurityType type) =>
|
|
type switch {
|
|
SecurityType.Future => Security.ContractOneofCase.Future,
|
|
SecurityType.Option => Security.ContractOneofCase.Option,
|
|
SecurityType.Spread => Security.ContractOneofCase.Spread,
|
|
SecurityType.Synthetic => Security.ContractOneofCase.Synthetic,
|
|
_ => Security.ContractOneofCase.None
|
|
};
|
|
|
|
public static SecurityType security_type(this Security s) =>
|
|
s is null ? SecurityType.Unset : s.ContractCase.security_type();
|
|
|
|
public static SecurityType security_type(this Security.ContractOneofCase contract_case) =>
|
|
contract_case switch {
|
|
Security.ContractOneofCase.Spot => SecurityType.Spot,
|
|
Security.ContractOneofCase.Future => SecurityType.Future,
|
|
Security.ContractOneofCase.Option => SecurityType.Option,
|
|
Security.ContractOneofCase.Spread => SecurityType.Spread,
|
|
Security.ContractOneofCase.Synthetic => SecurityType.Synthetic,
|
|
_ => SecurityType.Unset,
|
|
};
|
|
|
|
public static DateTime? security_expiration(this SecurityImmutable s) {
|
|
return s.ContractCase switch {
|
|
Security.ContractOneofCase.Future => s.Future.expiration_date(),
|
|
Security.ContractOneofCase.Option => s.Option.expiration_date(),
|
|
Security.ContractOneofCase.Spread => DateTime.MinValue,
|
|
Security.ContractOneofCase.Synthetic => DateTime.MinValue,
|
|
_ => null,
|
|
};
|
|
}
|
|
|
|
public static IEnumerable<DateTime> normal_expirations(this SecurityImmutable security) =>
|
|
security.ContractCase switch {
|
|
Security.ContractOneofCase.Future => new[] { security.Future.expiration_date() },
|
|
Security.ContractOneofCase.Option => new[] { security.Option.expiration_date() },
|
|
Security.ContractOneofCase.Spread => security.Spread.Legs.SelectMany(l => l.Security.normal_expirations()),
|
|
Security.ContractOneofCase.Synthetic => security.Synthetic.Legs.SelectMany(l => l.Security.normal_expirations()),
|
|
_ => Enumerable.Empty<DateTime>()
|
|
};
|
|
|
|
public static ProductImmutable product(this SecurityImmutable security) =>
|
|
new(new() {
|
|
Exchange = security.Exchange,
|
|
Type = security.security_type(),
|
|
Symbol = security.Symbol
|
|
});
|
|
|
|
public static DateTime date_time(this Expiration exp) =>
|
|
date_time(new ExpirationImmutable(exp));
|
|
|
|
public static DateTime date_time(this ExpirationImmutable exp) =>
|
|
new((int)exp.ExpirationYear, (int)exp.ExpirationMonth, (int)exp.ExpirationDay);
|
|
|
|
public static DateTime expiration_date(this OptionContractImmutable option) =>
|
|
new((int)option.ExpirationYear, (int)option.ExpirationMonth, (int)option.ExpirationDay);
|
|
|
|
public static DateTime expiration_date(this FutureContract future) =>
|
|
new((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay);
|
|
|
|
public static DateTime expiration_date(this FutureContractImmutable future) =>
|
|
new((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay);
|
|
|
|
internal static DateTime earliest_expiration(this SecurityImmutable security) =>
|
|
security.normal_expirations().Min();
|
|
|
|
public static double strike(this SecurityImmutable security) =>
|
|
security.HasOption ? security.Option.Strike : double.NaN;
|
|
|
|
internal static double signed_quantity(this ContractLegImmutable leg) =>
|
|
leg.Side == Side.Buy ? leg.Quantity : -leg.Quantity;
|
|
|
|
internal static double signed_quantity(this ContractLeg leg) =>
|
|
leg.Side == Side.Buy ? leg.Quantity : -leg.Quantity;
|
|
|
|
internal static string force_symbol(this SecurityImmutable security) {
|
|
if (security.ContractCase != Security.ContractOneofCase.Synthetic) {
|
|
return security.Symbol;
|
|
}
|
|
foreach (var leg in security.Synthetic.Legs) {
|
|
if (!leg.HasSecurity) {
|
|
throw new ArgumentException("Synthetic leg security undefined", nameof(security));
|
|
}
|
|
if (leg.Security == security) {
|
|
throw new ArgumentException("Synthetic leg security is the synthetic security itself (leg recursion detected)",
|
|
nameof(security));
|
|
}
|
|
return leg.Security.Symbol;
|
|
}
|
|
throw new ArgumentException("Synthetic security has no legs", nameof(security));
|
|
}
|
|
|
|
public static string display_exchange(this SecurityImmutable security) =>
|
|
security.ContractCase == Security.ContractOneofCase.Synthetic ?
|
|
$"[{string.Join(",", new ContractLegEnumerable(security).Select(leg => leg.Security.Exchange.ToString()).Distinct().OrderBy(e => e))}]" :
|
|
security.Exchange.ToString();
|
|
|
|
public static string security_desc(this SecurityImmutable security) =>
|
|
security.ExchangeDataCase switch {
|
|
Security.ExchangeDataOneofCase.Glbx => security.Glbx.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Ice => security.Ice.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Deribit => security.Deribit.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Ftx => security.Ftx.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Binance => security.Binance.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.BinanceCoinFutures => security.BinanceCoinFutures.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.BinanceUs => security.BinanceUs.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.BinanceUsdsFutures => security.BinanceUsdsFutures.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Coinbase => security.Coinbase.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Okx => security.Okx.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Cboe => security.Cboe.SecurityDesc,
|
|
Security.ExchangeDataOneofCase.Taifex => security.Taifex.SecurityDesc,
|
|
_ => throw new NotImplementedException("security_desc not implemented for exchange")
|
|
};
|
|
|
|
public static SecurityType security_type(this SecurityImmutable security) =>
|
|
security.ContractCase.security_type();
|
|
|
|
public static Side other_side(this Side side) =>
|
|
side switch {
|
|
Side.Buy => Side.Sell,
|
|
Side.Sell => Side.Buy,
|
|
_ => side,
|
|
};
|
|
|
|
public static SecurityType to_security_type(this domain.SecurityType api_security_type) =>
|
|
api_security_type switch {
|
|
domain.SecurityType.Spot => SecurityType.Spot,
|
|
domain.SecurityType.Future => SecurityType.Future,
|
|
domain.SecurityType.Option => SecurityType.Option,
|
|
domain.SecurityType.Spread => SecurityType.Spread,
|
|
domain.SecurityType.Unspecified => SecurityType.Unset,
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
|
|
public static domain.SecurityType to_api_security_type(this SecurityType api_security_type) =>
|
|
api_security_type switch {
|
|
SecurityType.Spot => domain.SecurityType.Spot,
|
|
SecurityType.Future => domain.SecurityType.Future,
|
|
SecurityType.Option => domain.SecurityType.Option,
|
|
SecurityType.Spread => domain.SecurityType.Spread,
|
|
SecurityType.Unset => domain.SecurityType.Unspecified,
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
|
|
public static Venue to_venue(this domain.Venue api_venue) =>
|
|
api_venue switch {
|
|
domain.Venue.Bts => Venue.Bts,
|
|
domain.Venue.Sim => Venue.Sim,
|
|
domain.Venue.Deribit => Venue.Deribit,
|
|
domain.Venue.Ftx => Venue.Ftx,
|
|
domain.Venue.Binance => Venue.Binance,
|
|
domain.Venue.BinanceCoinFutures => Venue.BinanceCoinFutures,
|
|
domain.Venue.BinanceUs => Venue.BinanceUs,
|
|
domain.Venue.BinanceUsdsFutures => Venue.BinanceUsdsFutures,
|
|
domain.Venue.Glbx => Venue.Glbx,
|
|
domain.Venue.Coinbase => Venue.Coinbase,
|
|
domain.Venue.Okx => Venue.Okx,
|
|
domain.Venue.Cboe => Venue.Cboe,
|
|
domain.Venue.Taifex => Venue.Taifex,
|
|
|
|
|
|
domain.Venue.Unspecified => Venue.Unset,
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
|
|
public static domain.Venue to_api_venue(this Venue venue) =>
|
|
venue switch {
|
|
Venue.Bts => domain.Venue.Bts,
|
|
Venue.Sim => domain.Venue.Sim,
|
|
Venue.Deribit => domain.Venue.Deribit,
|
|
Venue.Ftx => domain.Venue.Ftx,
|
|
Venue.Binance => domain.Venue.Binance,
|
|
Venue.BinanceCoinFutures => domain.Venue.BinanceCoinFutures,
|
|
Venue.BinanceUs => domain.Venue.BinanceUs,
|
|
Venue.BinanceUsdsFutures => domain.Venue.BinanceUsdsFutures,
|
|
Venue.Coinbase => domain.Venue.Coinbase,
|
|
Venue.Glbx => domain.Venue.Glbx,
|
|
Venue.Okx => domain.Venue.Okx,
|
|
Venue.Cboe => domain.Venue.Cboe,
|
|
Venue.Taifex => domain.Venue.Taifex,
|
|
|
|
Venue.Unset => domain.Venue.Unspecified,
|
|
_ => throw new NotImplementedException(),
|
|
};
|
|
|
|
// ICE specific properties
|
|
public static string market_description(this SecurityImmutable security) => security.HasIce ? security.Ice.MarketDescription : string.Empty;
|
|
public static string product_name(this SecurityImmutable security) => security.HasIce ? security.Ice.ProductName : string.Empty;
|
|
public static string cleared_alias(this SecurityImmutable security) => security.HasIce ? security.Ice.ClearedAlias : string.Empty;
|
|
public static string hub_alias(this SecurityImmutable security) => security.HasIce ? security.Ice.HubAlias : string.Empty;
|
|
public static string strip_name(this SecurityImmutable security) => security.HasIce ? security.Ice.StripName : string.Empty;
|
|
public static string mic_code(this SecurityImmutable security) => security.HasIce ? security.Ice.MicCode : string.Empty;
|
|
|
|
public static bool is_exchange_security(this SecurityImmutable? security) =>
|
|
security.HasValue && is_exchange_security(security.Value);
|
|
|
|
public static bool is_exchange_security(this SecurityImmutable security) {
|
|
switch (security.Exchange) {
|
|
case Venue.Bts:
|
|
case Venue.Unset: return false;
|
|
}
|
|
switch (security.ContractCase) {
|
|
case Security.ContractOneofCase.Future:
|
|
case Security.ContractOneofCase.Spread:
|
|
return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|