public void Arbitrage(ArbitrageOptions options)
{
lock (syncRoot)
{
PauseTasks();
try
{
if (CanArbitrage(options, out string message))
{
if (CanBuy(new BuyOptions(options.Pair)
{
Amount = 1
}, out message))
{
options.Metadata.Arbitrage = $"{options.Arbitrage.Market}-" + options.Arbitrage.Type ?? "All";
options.Metadata.ArbitragePercentage = options.Arbitrage.Percentage;
loggingService.Info($"{options.Arbitrage.Type} arbitrage {options.Pair} on {options.Arbitrage.Market}. Percentage: {options.Arbitrage.Percentage:0.00}");
if (options.Arbitrage.Type == ArbitrageType.Direct)
{
ArbitrageDirect(options);
}
else if (options.Arbitrage.Type == ArbitrageType.Reverse)
{
ArbitrageReverse(options);
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}: {message}");
}
}
else
{
loggingService.Info(message);
}
}
finally
{
ContinueTasks();
}
}
}
public bool CanArbitrage(ArbitrageOptions options, out string message)
{
if (Account.HasTradingPair(options.Pair))
{
message = $"Cancel arbitrage request {options.Pair}. Reason: pair already exist";
return(false);
}
else if (!options.ManualOrder && !GetPairConfig(options.Pair).BuyEnabled)
{
message = $"Cancel arbitrage request for {options.Pair}. Reason: buying not enabled";
return(false);
}
else if (!Exchange.GetMarketPairs(Config.Market).Contains(options.Pair))
{
message = $"Cancel arbitrage request for {options.Pair}. Reason: {options.Pair} is not a valid pair";
return(false);
}
message = null;
return(true);
}
private void ArbitrageReverse(ArbitrageOptions options)
{
string marketPair = Exchange.GetArbitrageMarketPair(options.Arbitrage.Market);
ITradingPair existingMarketPair = Account.GetTradingPair(marketPair);
IPairConfig pairConfig = GetPairConfig(options.Pair);
bool useExistingMarketPair = (existingMarketPair != null && existingMarketPair.CurrentCost > pairConfig.BuyMaxCost &&
existingMarketPair.AveragePrice <= existingMarketPair.CurrentPrice);
var buyMarketPairOptions = new BuyOptions(marketPair)
{
Arbitrage = true,
MaxCost = pairConfig.BuyMaxCost,
ManualOrder = options.ManualOrder,
IgnoreBalance = useExistingMarketPair,
Metadata = options.Metadata
};
if (CanBuy(buyMarketPairOptions, out string message))
{
IOrderDetails buyMarketPairOrderDetails = null;
if (useExistingMarketPair)
{
buyMarketPairOrderDetails = Account.AddBlankOrder(buyMarketPairOptions.Pair,
buyMarketPairOptions.MaxCost.Value / GetPrice(buyMarketPairOptions.Pair, TradePriceType.Ask),
includeFees: false);
loggingService.Info($"Use existing market pair for arbitrage: {marketPair}. " +
$"Average price: {existingMarketPair.AveragePrice}, Current price: {existingMarketPair.CurrentPrice}");
}
else
{
buyMarketPairOrderDetails = orderingService.PlaceBuyOrder(buyMarketPairOptions);
}
if (buyMarketPairOrderDetails.Result == OrderResult.Filled)
{
decimal buyArbitragePairMultiplier = pairConfig.ArbitrageBuyMultiplier ?? DEFAULT_ARBITRAGE_BUY_MULTIPLIER;
decimal buyMarketPairFees = CalculateOrderFees(buyMarketPairOrderDetails);
string arbitragePair = Exchange.ChangeMarket(options.Pair, options.Arbitrage.Market.ToString());
decimal buyArbitragePairAmount = options.Arbitrage.Market == ArbitrageMarket.USDT ?
buyMarketPairOrderDetails.AmountFilled * GetPrice(buyMarketPairOrderDetails.Pair, TradePriceType.Ask, normalize: false) / GetPrice(arbitragePair, TradePriceType.Ask) :
buyMarketPairOrderDetails.AmountFilled / GetPrice(arbitragePair, TradePriceType.Ask);
var buyArbitragePairOptions = new BuyOptions(arbitragePair)
{
Arbitrage = true,
ManualOrder = options.ManualOrder,
Amount = buyArbitragePairAmount * buyArbitragePairMultiplier,
Metadata = options.Metadata
};
IOrderDetails buyArbitragePairOrderDetails = orderingService.PlaceBuyOrder(buyArbitragePairOptions);
if (buyArbitragePairOrderDetails.Result == OrderResult.Filled)
{
decimal buyArbitragePairFees = CalculateOrderFees(buyArbitragePairOrderDetails);
options.Metadata.FeesNonDeductible = buyMarketPairFees * buyArbitragePairMultiplier;
var sellArbitragePairOptions = new SellOptions(buyArbitragePairOrderDetails.Pair)
{
Arbitrage = true,
Amount = buyArbitragePairOrderDetails.AmountFilled,
ManualOrder = options.ManualOrder,
Metadata = options.Metadata
};
TradingPair existingArbitragePair = Account.GetTradingPair(buyArbitragePairOrderDetails.Pair) as TradingPair;
existingArbitragePair.OverrideCost(buyArbitragePairOrderDetails.Cost + buyArbitragePairFees * 2);
IOrderDetails sellArbitragePairOrderDetails = orderingService.PlaceSellOrder(sellArbitragePairOptions);
existingArbitragePair.OverrideCost(null);
if (sellArbitragePairOrderDetails.Result == OrderResult.Filled)
{
loggingService.Info($"{pairConfig.ArbitrageType} arbitrage successful: {marketPair} -> {arbitragePair} -> {existingArbitragePair.Pair}");
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to sell arbitrage pair {arbitragePair}");
notificationService.Notify($"Unable to arbitrage {options.Pair}: Failed to sell arbitrage pair {arbitragePair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to buy arbitrage pair {arbitragePair}");
notificationService.Notify($"Unable to arbitrage {options.Pair}: Failed to buy arbitrage pair {arbitragePair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to buy market pair {marketPair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}: {message}");
}
}
private void ArbitrageDirect(ArbitrageOptions options)
{
string arbitragePair = options.Pair;
ITradingPair existingArbitragePair = this.Account.GetTradingPair(arbitragePair);
IPairConfig pairConfig = this.GetPairConfig(options.Pair);
bool useExistingArbitragePair = (existingArbitragePair != null && existingArbitragePair.CurrentCost > pairConfig.BuyMaxCost &&
existingArbitragePair.AveragePrice <= existingArbitragePair.CurrentPrice);
var buyArbitragePairOptions = new BuyOptions(arbitragePair)
{
Arbitrage = true,
MaxCost = pairConfig.BuyMaxCost,
ManualOrder = options.ManualOrder,
IgnoreBalance = useExistingArbitragePair,
Metadata = options.Metadata
};
if (this.CanBuy(buyArbitragePairOptions, out string message))
{
IOrderDetails buyArbitragePairOrderDetails = null;
if (useExistingArbitragePair)
{
buyArbitragePairOrderDetails = this.Account.AddBlankOrder(buyArbitragePairOptions.Pair,
buyArbitragePairOptions.MaxCost.Value / this.GetPrice(buyArbitragePairOptions.Pair, TradePriceType.Ask),
includeFees: false);
loggingService.Info($"Use existing arbitrage pair for arbitrage: {arbitragePair}. " +
$"Average price: {existingArbitragePair.AveragePrice}, Current price: {existingArbitragePair.CurrentPrice}");
}
else
{
buyArbitragePairOrderDetails = orderingService.PlaceBuyOrder(buyArbitragePairOptions);
}
if (buyArbitragePairOrderDetails.Result == OrderResult.Filled)
{
decimal buyArbitragePairFees = this.CalculateOrderFees(buyArbitragePairOrderDetails);
string flippedArbitragePair = this.Exchange.ChangeMarket(arbitragePair, options.Arbitrage.Market.ToString());
var sellArbitragePairOptions = new SellOptions(flippedArbitragePair)
{
Arbitrage = true,
Amount = buyArbitragePairOrderDetails.AmountFilled,
ManualOrder = options.ManualOrder,
Metadata = options.Metadata.MergeWith(new OrderMetadata
{
IsTransitional = true
})
};
IOrderDetails sellArbitragePairOrderDetails = orderingService.PlaceSellOrder(sellArbitragePairOptions);
if (sellArbitragePairOrderDetails.Result == OrderResult.Filled)
{
decimal sellArbitragePairMultiplier = pairConfig.ArbitrageSellMultiplier ?? DEFAULT_ARBITRAGE_SELL_MULTIPLIER;
decimal sellArbitragePairFees = this.CalculateOrderFees(sellArbitragePairOrderDetails);
options.Metadata.FeesNonDeductible = buyArbitragePairFees * sellArbitragePairMultiplier;
decimal sellMarketPairAmount = sellArbitragePairOrderDetails.AmountFilled * this.GetPrice(flippedArbitragePair, TradePriceType.Bid, normalize: false) * sellArbitragePairMultiplier;
string marketPair = this.Exchange.GetArbitrageMarketPair(options.Arbitrage.Market);
var sellMarketPairOptions = new SellOptions(marketPair)
{
Arbitrage = true,
Amount = sellMarketPairAmount,
ManualOrder = options.ManualOrder,
Metadata = options.Metadata.MergeWith(new OrderMetadata
{
IsTransitional = false,
OriginalPair = arbitragePair
})
};
existingArbitragePair = this.Account.GetTradingPair(marketPair);
existingArbitragePair.OverrideCost((buyArbitragePairOrderDetails.Cost + sellArbitragePairFees * 2) * sellArbitragePairMultiplier);
IOrderDetails sellMarketPairOrderDetails = orderingService.PlaceSellOrder(sellMarketPairOptions);
existingArbitragePair.OverrideCost(null);
if (sellMarketPairOrderDetails.Result == OrderResult.Filled)
{
loggingService.Info($"{pairConfig.ArbitrageType} arbitrage successful: {arbitragePair} -> {flippedArbitragePair} -> {marketPair}");
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to sell market pair {arbitragePair}");
notificationService.Notify($"Unable to arbitrage {options.Pair}: Failed to sell market pair {arbitragePair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to sell arbitrage pair {flippedArbitragePair}");
notificationService.Notify($"Unable to arbitrage {options.Pair}: Failed to sell arbitrage pair {flippedArbitragePair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}. Reason: failed to buy arbitrage pair {arbitragePair}");
}
}
else
{
loggingService.Info($"Unable to arbitrage {options.Pair}: {message}");
}
}
