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 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() }; 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; } } } }