public async Task <HedgeSettings> GetAsync()
{
HedgeSettings hedgeSettings = _cache.Get(CacheKey);
if (hedgeSettings == null)
{
hedgeSettings = await _hedgeSettingsRepository.GetAsync();
if (hedgeSettings == null)
{
hedgeSettings = new HedgeSettings
{
MarketOrderMarkup = .02m,
ThresholdDown = 1000,
ThresholdUp = 5000,
ThresholdDownBuy = 1000,
ThresholdDownSell = 1000,
ThresholdUpBuy = 5000,
ThresholdUpSell = 5000,
ThresholdCritical = 10000
};
}
_cache.Initialize(new[] { hedgeSettings });
bool isDirty = false;
if (hedgeSettings.ThresholdDownBuy == default(decimal))
{
hedgeSettings.ThresholdDownBuy = hedgeSettings.ThresholdDown;
isDirty = true;
}
if (hedgeSettings.ThresholdDownSell == default(decimal))
{
hedgeSettings.ThresholdDownSell = hedgeSettings.ThresholdDown;
isDirty = true;
}
if (hedgeSettings.ThresholdUpBuy == default(decimal))
{
hedgeSettings.ThresholdUpBuy = hedgeSettings.ThresholdUp;
isDirty = true;
}
if (hedgeSettings.ThresholdUpSell == default(decimal))
{
hedgeSettings.ThresholdUpSell = hedgeSettings.ThresholdUp;
isDirty = true;
}
if (isDirty)
{
await UpdateAsync(hedgeSettings);
}
}
return(hedgeSettings);
}
public async Task InsertOrReplaceAsync(HedgeSettings hedgeSettings)
{
var entity = new HedgeSettingsEntity(GetPartitionKey(), GetRowKey());
Mapper.Map(hedgeSettings, entity);
await _storage.InsertOrReplaceAsync(entity);
}
public static SettingsHedgeGlobalNoSql Create(HedgeSettings settings)
{
return(new SettingsHedgeGlobalNoSql()
{
PartitionKey = GeneratePartitionKey(),
RowKey = GenerateRowKey(),
Settings = settings
});
}
private async Task <IReadOnlyCollection <HedgeLimitOrder> > CreateLimitOrdersAsync(
IEnumerable <AssetInvestment> assetInvestments)
{
HedgeSettings hedgeSettings = await _hedgeSettingsService.GetAsync();
var hedgeLimitOrders = new List <HedgeLimitOrder>();
foreach (AssetInvestment assetInvestment in assetInvestments)
{
AssetHedgeSettings assetHedgeSettings =
await _assetHedgeSettingsService.EnsureAsync(assetInvestment.AssetId);
LimitOrderType limitOrderType = assetInvestment.RemainingAmount > 0
? LimitOrderType.Sell
: LimitOrderType.Buy;
if (!CanCreateHedgeLimitOrder(assetInvestment, assetHedgeSettings, hedgeSettings, limitOrderType))
{
continue;
}
decimal commonThresholdUp = limitOrderType == LimitOrderType.Buy
? hedgeSettings.ThresholdUpBuy
: hedgeSettings.ThresholdUpSell;
LimitOrderPrice limitOrderPrice = LimitOrderPriceCalculator.Calculate(assetInvestment.Quote,
Math.Abs(assetInvestment.RemainingAmount), limitOrderType,
assetHedgeSettings.ThresholdUp ?? commonThresholdUp, hedgeSettings.MarketOrderMarkup);
decimal price = limitOrderPrice.Price;
decimal volume = Math.Abs(assetInvestment.RemainingAmount / assetInvestment.Quote.Mid);
HedgeLimitOrder hedgeLimitOrder = HedgeLimitOrder.Create(assetHedgeSettings.Exchange,
assetHedgeSettings.AssetId, assetHedgeSettings.AssetPairId, limitOrderType, limitOrderPrice.Type,
price, volume);
hedgeLimitOrder.Context = assetInvestment.ToJson();
hedgeLimitOrders.Add(hedgeLimitOrder);
}
return(hedgeLimitOrders);
}
public async Task <HedgeSettings> GetAsync()
{
HedgeSettings hedgeSettings = _cache.Get(CacheKey);
if (hedgeSettings == null)
{
hedgeSettings = await _hedgeSettingsRepository.GetAsync();
if (hedgeSettings == null)
{
hedgeSettings = new HedgeSettings
{
MarketOrderMarkup = .02m,
ThresholdDown = 1000,
ThresholdUp = 5000,
ThresholdCritical = 10000
};
}
_cache.Initialize(new[] { hedgeSettings });
}
return(hedgeSettings);
}
private static bool CanCreateHedgeLimitOrder(AssetInvestment assetInvestment,
AssetHedgeSettings assetHedgeSettings, HedgeSettings hedgeSettings, LimitOrderType limitOrderType)
{
if (assetInvestment.IsDisabled)
{
return(false);
}
decimal absoluteRemainingAmount = Math.Abs(assetInvestment.RemainingAmount);
if (absoluteRemainingAmount <= 0)
{
return(false);
}
decimal thresholdCritical = assetHedgeSettings.ThresholdCritical ?? hedgeSettings.ThresholdCritical;
if (0 < thresholdCritical && thresholdCritical <= absoluteRemainingAmount)
{
return(false);
}
decimal commonThresholdDown = limitOrderType == LimitOrderType.Buy ? hedgeSettings.ThresholdDownBuy : hedgeSettings.ThresholdDownSell;
decimal thresholdDown = assetHedgeSettings.ThresholdDown ?? commonThresholdDown;
if (assetHedgeSettings.Exchange != ExchangeNames.Virtual && absoluteRemainingAmount < thresholdDown)
{
return(false);
}
if (assetHedgeSettings.Mode != AssetHedgeMode.Auto && assetHedgeSettings.Mode != AssetHedgeMode.Idle)
{
return(false);
}
if (assetInvestment.Quote == null)
{
return(false);
}
return(true);
}
public Task UpdateSettingsAsync(HedgeSettings settings)
{
throw new System.NotImplementedException();
}
public async Task UpdateAsync(HedgeSettings hedgeSettings)
{
await _hedgeSettingsRepository.InsertOrReplaceAsync(hedgeSettings);
_cache.Set(hedgeSettings);
}
public async Task <HedgeSettingsModel> GetHedgeSettingsAsync()
{
HedgeSettings hedgeSettings = await _hedgeSettingsService.GetAsync();
return(Mapper.Map <HedgeSettingsModel>(hedgeSettings));
}
public Task UpdateSettingsAsync(HedgeSettings request)
{
return(_settingsManager.UpdateSettingsAsync(request));
}
private async Task <IReadOnlyCollection <PositionReport> > CreateReports()
{
IReadOnlyCollection <Position> positions = await _positionService.GetAllAsync();
IReadOnlyCollection <AssetInvestment> assetInvestments = _investmentService.GetAll();
IReadOnlyCollection <HedgeLimitOrder> hedgeLimitOrders = _hedgeLimitOrderService.GetAll();
HedgeSettings hedgeSettings = await _hedgeSettingsService.GetAsync();
IReadOnlyCollection <AssetHedgeSettings>
assetsHedgeSettings = await _assetHedgeSettingsService.GetAllAsync();
string[] assets = positions.Select(o => o.AssetId)
.Union(assetInvestments.Select(o => o.AssetId))
.Union(assetsHedgeSettings.Select(o => o.AssetId))
.ToArray();
var positionReports = new List <PositionReport>();
foreach (string assetId in assets)
{
AssetHedgeSettings assetHedgeSettings = await _assetHedgeSettingsService.EnsureAsync(assetId);
Position currentPosition = positions
.SingleOrDefault(o => o.AssetId == assetId && o.Exchange == assetHedgeSettings.Exchange);
HedgeLimitOrder hedgeLimitOrder = hedgeLimitOrders.SingleOrDefault(o => o.AssetId == assetId);
AssetInvestment assetInvestment = assetInvestments.SingleOrDefault(o => o.AssetId == assetId);
decimal?volumeInUsd = null;
if (currentPosition != null)
{
volumeInUsd = GetVolumeInUsd(currentPosition.AssetId, currentPosition.Exchange,
currentPosition.Volume);
}
Quote assetQuote;
if (assetInvestment == null)
{
assetQuote = _rateService.GetQuoteUsd(assetHedgeSettings.AssetId, assetHedgeSettings.Exchange);
}
else
{
assetQuote = assetInvestment.Quote;
}
positionReports.Add(new PositionReport
{
AssetId = assetId,
Exchange = assetHedgeSettings.Exchange,
Quote = assetQuote,
Volume = currentPosition?.Volume,
VolumeInUsd = volumeInUsd,
OppositeVolume = currentPosition?.OppositeVolume,
PnL = volumeInUsd.HasValue ? currentPosition.OppositeVolume + volumeInUsd : null,
HedgeLimitOrder = hedgeLimitOrder,
AssetInvestment = assetInvestment,
Error = ValidateAssetHedgeSettings(assetHedgeSettings)
?? ValidateInvestments(assetInvestment)
?? ValidateThresholdCritical(assetInvestment, hedgeSettings, assetHedgeSettings)
?? ValidateQuote(assetQuote)
});
IEnumerable <Position> otherPositions = positions
.Where(o => o.AssetId == assetId && o.Exchange != assetHedgeSettings.Exchange);
foreach (Position position in otherPositions)
{
Quote otherPositionQuote = _rateService.GetQuoteUsd(position.AssetId, position.Exchange);
volumeInUsd = GetVolumeInUsd(position.AssetId, position.Exchange, position.Volume);
positionReports.Add(new PositionReport
{
AssetId = assetId,
Exchange = position.Exchange,
Quote = otherPositionQuote,
Volume = position.Volume,
VolumeInUsd = volumeInUsd,
OppositeVolume = position.OppositeVolume,
PnL = volumeInUsd.HasValue ? position.OppositeVolume + volumeInUsd : null,
HedgeLimitOrder = null,
AssetInvestment = null,
Error = ValidateAssetHedgeSettings(assetHedgeSettings)
?? ValidateQuote(otherPositionQuote)
});
}
}
foreach (PositionReport positionReport in positionReports)
{
if (positionReport.Exchange == ExchangeNames.Virtual)
{
positionReport.ActualPnL = -1 * positionReport.PnL;
}
else
{
positionReport.ActualPnL = positionReport.PnL;
}
}
return(positionReports
.OrderBy(o => o.AssetId)
.ToArray());
}
private static string ValidateThresholdCritical(AssetInvestment assetInvestment, HedgeSettings hedgeSettings,
AssetHedgeSettings assetHedgeSettings)
{
decimal thresholdCritical = assetHedgeSettings.ThresholdCritical ?? hedgeSettings.ThresholdCritical;
if (assetInvestment != null && thresholdCritical <= Math.Abs(assetInvestment.RemainingAmount))
{
return("Critical delta threshold exceeded");
}
return(null);
}
