Files
spark/src/client/spark_api/security/SecurityExtensions.cs
T

246 lines
12 KiB
C#

namespace bts.api {
using bts.api.domain;
using bts.utils;
using Spark.Api.Data;
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<ExpirationDate> normal_expirations(this SecurityImmutable security) {
return security.ContractCase switch {
Security.ContractOneofCase.Spot => new[] { ExpirationDate.None },
Security.ContractOneofCase.Future => new[] { future_exp(security.Future.expiration_date()) },
Security.ContractOneofCase.Option => new[] { ExpirationDate.FixedDate(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<ExpirationDate>()
};
static ExpirationDate future_exp(DateTime exp_date) =>
Security.is_perpetual_exp(exp_date) ? ExpirationDate.Perpetual : ExpirationDate.FixedDate(exp_date);
}
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 ExpirationDate 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,
Security.ExchangeDataOneofCase.Twse => security.Twse.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.Synthetic => SecurityType.Synthetic,
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.Synthetic => domain.SecurityType.Synthetic,
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.Twse => Venue.Twse,
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.Twse => domain.Venue.Twse,
Venue.Unset => domain.Venue.Unspecified,
_ => throw new NotImplementedException(),
};
public static TickDisplaySettingsImmutable QuantityDisplay(this SecurityImmutable security) {
var qd = Security.Defaults.quantity_display_settings;
if (security.ContractSpec.QuantityInfos.TryGetFirst(out var qtyInfo)) {
qd.ShowDecimalPart = qtyInfo.TickBase.is_real_non_zero() && !(qtyInfo.TickUnit / qtyInfo.TickBase).is_int();
qd.TickFactors = new() {
TickBase = qtyInfo.TickBase,
TickUnit = qtyInfo.TickUnit
};
}
return new(qd);
}
// 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;
}
}
}
}