Files
spark/src/client/spark_api/security/SecurityExtensions.cs
T
John Colvin 9b25857042 fix: Ensure "earliest_expiration" fn actually returns min exp
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.
2024-12-29 13:26:44 -05:00

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