Oda/managing-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docker files fixes from liaqat

Browse Source
This commit is contained in:
alirehmani
2024-05-03 16:39:25 +05:00
commit 464a8730e8
587 changed files with 44288 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/Managing.Domain/Shared/Helpers/RiskHelpers.cs Normal file
View File

@@ -0,0 +1,52 @@
using Managing.Domain.MoneyManagements;
using static Managing.Common.Enums;
namespace Managing.Domain.Shared.Helpers
{
public static class RiskHelpers
{
public static decimal GetStopLossPrice(TradeDirection direction, decimal price, MoneyManagement moneyManagement)
{
return direction == TradeDirection.Long ?
price -= price * moneyManagement.StopLoss :
price += price * moneyManagement.StopLoss;
}
public static decimal GetBalanceAtRisk(decimal balance, MoneyManagement moneyManagement)
{
decimal amountToRisk = balance * moneyManagement.BalanceAtRisk;
if (amountToRisk <= 1)
{
throw new Exception("Cannot open trade, not enough balance");
}
return amountToRisk;
}
public static decimal GetTakeProfitPrice(TradeDirection direction, decimal price, MoneyManagement moneyManagement, int count = 1)
{
decimal percentage = moneyManagement.TakeProfit * count;
price = direction == TradeDirection.Short ? price -= price * percentage : price += price * percentage;
return price;
}
public static RiskLevel GetRiskFromConfidence(Confidence confidence)
{
switch (confidence)
{
case Confidence.Low:
return RiskLevel.Low;
case Confidence.Medium:
return RiskLevel.Medium;
case Confidence.High:
return RiskLevel.High;
case Confidence.None:
break;
}
return RiskLevel.Low;
}
}
}

161
src/Managing.Domain/Shared/Helpers/TradingBox.cs Normal file
View File

@@ -0,0 +1,161 @@
using Managing.Core;
using Managing.Domain.Candles;
using Managing.Domain.MoneyManagements;
using Managing.Domain.Strategies;
using Managing.Domain.Trades;
using static Managing.Common.Enums;
namespace Managing.Domain.Shared.Helpers;
public static class TradingBox
{
public static Signal GetSignal(HashSet<Candle> newCandles, HashSet<IStrategy> strategies, HashSet<Signal> previousSignal)
{
var signalOnCandles = new HashSet<Signal>();
foreach (var strategy in strategies)
{
strategy.UpdateCandles(newCandles);
var signals = strategy.Run();
if (signals == null || signals.Count == 0) continue;
foreach (var signal in signals.Where(s => s.Date == newCandles.Last().Date))
{
if (previousSignal.SingleOrDefault(s => s.Identifier == signal.Identifier) == null)
{
if (previousSignal.Count == 0 || previousSignal.Last().Date < signal.Date)
{
signalOnCandles.Add(signal);
}
}
}
}
if (signalOnCandles.Count != strategies.Count)
return null;
var data = newCandles.First();
return ComputeSignals(strategies, signalOnCandles, MiscExtensions.ParseEnum<Ticker>(data.Ticker), data.Timeframe);
}
public static Signal ComputeSignals(HashSet<IStrategy> strategies, HashSet<Signal> signalOnCandles, Ticker ticker, Timeframe timeframe)
{
Signal signal = null;
if (strategies.Count > 1)
{
var trendSignal = signalOnCandles.Where(s => s.SignalType == SignalType.Trend);
var signals = signalOnCandles.Where(s => s.SignalType == SignalType.Signal);
var contextStrategiesCount = strategies.Count(s => s.SignalType == SignalType.Context);
var validContext = true;
if (contextStrategiesCount > 0 &&
signalOnCandles.Count(s => s.SignalType == SignalType.Context) != contextStrategiesCount)
{
validContext = false;
}
if (signals.All(s => s.Direction == TradeDirection.Long) && trendSignal.All(t => t.Direction == TradeDirection.Long) && validContext)
{
signal = new Signal(
ticker,
TradeDirection.Long,
Confidence.High,
signals.Last().Candle,
signals.Last().Date,
signals.Last().Exchange,
timeframe,
StrategyType.Composite, SignalType.Signal);
}
else if (signals.All(s => s.Direction == TradeDirection.Short) && trendSignal.All(t => t.Direction == TradeDirection.Short) && validContext)
{
signal = new Signal(
ticker,
TradeDirection.Short,
Confidence.High,
signals.Last().Candle,
signals.Last().Date,
signals.Last().Exchange,
timeframe,
StrategyType.Composite, SignalType.Signal);
}
}
else
{
// Only one strategy, we just add the single signal to the bot
signal = signalOnCandles.Single();
}
return signal;
}
public static MoneyManagement GetBestMoneyManagement(List<Candle> candles, List<Position> positions, MoneyManagement originMoneyManagement)
{
// Foreach positions, identitify the price when the position is open
// Then, foreach candles, get the maximum price before the next position
// Then, identify the lowest price before the maximum price
// Base on that, return the best StopLoss and TakeProfit to use and build a
var moneyManagement = new MoneyManagement();
var stoplossPercentage = new List<decimal>();
var takeProfitsPercentage = new List<decimal>();
if (positions.Count == 0)
return null;
for (var i = 0; i < positions.Count; i++)
{
var position = positions[i];
var nextPosition = i + 1 < positions.Count ? positions[i + 1] : null;
var (stopLoss, takeProfit) = GetBestSLTPForPosition(candles, position, nextPosition);
stoplossPercentage.Add(stopLoss);
takeProfitsPercentage.Add(takeProfit);
}
moneyManagement.StopLoss = stoplossPercentage.Average();
moneyManagement.TakeProfit = takeProfitsPercentage.Average();
moneyManagement.BalanceAtRisk = originMoneyManagement.BalanceAtRisk * 100;
moneyManagement.Timeframe = originMoneyManagement.Timeframe;
moneyManagement.Leverage = originMoneyManagement.Leverage;
moneyManagement.Name = "Optimized";
return moneyManagement;
}
public static (decimal Stoploss, decimal TakeProfit) GetBestSLTPForPosition(List<Candle> candles, Position position, Position nextPosition)
{
var stopLoss = 0M;
var takeProfit = 0M;
var candlesBeforeNextPosition = candles.Where(c => c.Date >= position.Date && c.Date <= (nextPosition == null ? candles.Last().Date : nextPosition.Date));
if (position.OriginDirection == TradeDirection.Long)
{
var maxPrice = candlesBeforeNextPosition.Max(c => c.High);
var minPrice = candlesBeforeNextPosition.TakeWhile(c => c.High <= maxPrice).Min(c => c.Low);
stopLoss = GetPercentageFromEntry(position.Open.Price, minPrice);
takeProfit = GetPercentageFromEntry(position.Open.Price, maxPrice);
}
else if (position.OriginDirection == TradeDirection.Short)
{
var minPrice = candlesBeforeNextPosition.Min(c => c.Low);
var maxPrice = candlesBeforeNextPosition.TakeWhile(c => c.Low >= minPrice).Max(c => c.High);
stopLoss = GetPercentageFromEntry(position.Open.Price, maxPrice);
takeProfit = GetPercentageFromEntry(position.Open.Price, minPrice);
}
return (stopLoss, takeProfit);
}
private static decimal GetPercentageFromEntry(decimal entry, decimal price)
{
return Math.Abs(100 - ((100 * price) / entry));
}
public static ProfitAndLoss GetProfitAndLoss(Position position, decimal quantity, decimal price)
{
var orders = new List<Tuple<decimal, decimal>>
{
new Tuple<decimal, decimal>(position.Open.Quantity, position.Open.Price),
new Tuple<decimal, decimal>(-quantity, price)
};
return new ProfitAndLoss(orders, position.OriginDirection);
}
}

99
src/Managing.Domain/Shared/Helpers/TradingHelpers.cs Normal file
View File

@@ -0,0 +1,99 @@
using Exilion.TradingAtomics;
using Managing.Domain.Accounts;
using Managing.Domain.Statistics;
using static Managing.Common.Enums;
namespace Managing.Domain.Shared.Helpers;
public static class TradingHelpers
{
public static decimal GetHodlPercentage(Candles.Candle candle1, Candles.Candle candle2)
{
return candle2.Close * 100 / candle1.Close - 100;
}
public static decimal GetGrowthFromInitalBalance(decimal balance, decimal finalPnl)
{
var growth = balance + finalPnl;
return growth * 100 / balance - 100;
}
public static PerformanceMetrics GetStatistics(Dictionary<DateTime, decimal> pnls)
{
var priceSeries = new TimePriceSeries(pnls);
return priceSeries.CalculatePerformanceMetrics();
}
public static decimal GetFeeAmount(decimal fee, decimal amount)
{
return fee * amount;
}
public static decimal GetFeeAmount(decimal fee, decimal amount, TradingExchanges exchange)
{
if (exchange.Equals(TradingExchanges.Evm))
return fee;
return GetFeeAmount(fee, amount);
}
public static bool IsAGoodTrader(Trader trader)
{
return trader.Winrate > 80
&& trader.TradeCount > 8
&& trader.AverageWin > Math.Abs(trader.AverageLoss) * 3
&& trader.Pnl > 0;
}
public static bool IsABadTrader(Trader trader)
{
return trader.Winrate < 30
&& trader.TradeCount > 8
&& trader.AverageWin * 3 < Math.Abs(trader.AverageLoss)
&& trader.Pnl < 0;
}
public static List<Trader> FindBadTrader(this List<Trader> traders)
{
var filteredTrader = new List<Trader>();
foreach (var trader in traders)
{
if (IsABadTrader(trader))
{
filteredTrader.Add(trader);
}
}
return filteredTrader;
}
public static List<Trader> FindGoodTrader(this List<Trader> traders)
{
var filteredTrader = new List<Trader>();
foreach (var trader in traders)
{
if (IsAGoodTrader(trader))
{
filteredTrader.Add(trader);
}
}
return filteredTrader;
}
public static List<Trader> MapToTraders(this List<Account> accounts)
{
var traders = new List<Trader>();
foreach (var account in accounts)
{
traders.Add(new Trader
{
Address = account.Key
});
}
return traders;
}
}