public void TryMatchMarketOrder(IMarketOrder order)
{
switch (order.Way)
{
case WayEnum.Buy:
if (SellOrders.Count == 0)
{
return;
}
while (order.Quantity > 0 && SellOrders.Count > 0)
{
marketOrderMatchingAlgorithm.TryMatch(order, SellOrders[0]);
}
break;
case WayEnum.Sell:
if (BuyOrders.Count == 0)
{
return;
}
while (order.Quantity > 0 && BuyOrders.Count > 0)
{
marketOrderMatchingAlgorithm.TryMatch(BuyOrders[0], order);
}
break;
}
}
public async Task <bool> TryCreateAsync(IMarketOrder marketOrder)
{
var byOrderEntity = MarketOrderEntity.ByOrderId.Create(marketOrder);
var byClientEntity = MarketOrderEntity.ByClientId.Create(marketOrder);
return(await _tableStorage.TryInsertAsync(byOrderEntity) && await _tableStorage.TryInsertAsync(byClientEntity));
}
public static ApiMarketOrder ConvertToApiModel(this IMarketOrder marketOrder, AssetPair assetPair, int accuracy)
{
var rate =
(!marketOrder.Straight ? 1 / marketOrder.Price : marketOrder.Price).TruncateDecimalPlaces(
marketOrder.Straight ? assetPair.Accuracy : assetPair.InvertedAccuracy, marketOrder.OrderAction() == OrderAction.Buy);
double converted = (rate * marketOrder.Volume).TruncateDecimalPlaces(accuracy, marketOrder.OrderAction() == OrderAction.Buy);
var totalCost = marketOrder.OrderAction() == OrderAction.Sell ? marketOrder.Volume : converted;
var volume = marketOrder.OrderAction() == OrderAction.Sell ? converted : marketOrder.Volume;
return(new ApiMarketOrder
{
Id = marketOrder.Id,
OrderType = marketOrder.OrderAction().ToString(),
AssetPair = marketOrder.AssetPairId,
Volume = Math.Abs(volume),
Comission = 0,
Position = marketOrder.Volume,
TotalCost = Math.Abs(totalCost),
DateTime = marketOrder.CreatedAt.ToIsoDateTime(),
Accuracy = assetPair.Accuracy,
Price = rate,
BaseAsset = marketOrder.Straight ? assetPair.BaseAssetId : assetPair.QuotingAssetId
});
}
private void TryMatchMarketOrder(IMarketOrder marketOrder)
{
if (marketOrder.Quantity == 0)
{
return;
}
switch (marketOrder.Way)
{
case WayEnum.Buy:
if (!orderBookBestBidAsk.BestAskPrice.HasValue)
{
return;
}
PriceSlots[orderBookBestBidAsk.BestAskPrice.Value].TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
TryMatchMarketOrder(marketOrder);
break;
case WayEnum.Sell:
if (!orderBookBestBidAsk.BestBidPrice.HasValue)
{
return;
}
PriceSlots[orderBookBestBidAsk.BestBidPrice.Value].TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
TryMatchMarketOrder(marketOrder);
break;
}
}
public static MarketOrderEntity Create(IMarketOrder marketOrder)
{
var entity = CreateNew(marketOrder);
entity.RowKey = GenerateRowKey(marketOrder.Id);
entity.PartitionKey = GeneratePartitionKey(marketOrder.ClientId);
return(entity);
}
public async Task CreateAsync(IMarketOrder marketOrder)
{
var byOrderEntity = MarketOrderEntity.ByOrderId.Create(marketOrder);
var byClientEntity = MarketOrderEntity.ByClientId.Create(marketOrder);
await _tableStorage.InsertAsync(byOrderEntity);
await _tableStorage.InsertAsync(byClientEntity);
}
public void HandleMarketOrder(IMarketOrder marketOrder)
{
string symbol = marketOrder.Symbol;
if (!OrderBooks.ContainsKey(symbol))
{
return;
}
OrderBooks[symbol].HandleMarketOrder(marketOrder);
}
public static MarketOrderEntity CreateNew(IMarketOrder marketOrder)
{
return(new MarketOrderEntity
{
AssetPairId = marketOrder.AssetPairId,
ClientId = marketOrder.ClientId,
CreatedAt = marketOrder.CreatedAt,
Id = marketOrder.Id,
MatchedAt = marketOrder.MatchedAt,
Price = marketOrder.Price,
Status = marketOrder.Status,
Straight = marketOrder.Straight,
Volume = marketOrder.Volume
});
}
public void TryMatch(ILimitOrder buyLimitOrder, IMarketOrder sellMarketOrder)
{
if (sellMarketOrder.Way != WayEnum.Sell || buyLimitOrder.Way != WayEnum.Buy)
{
return;
}
if (sellMarketOrder.Symbol != buyLimitOrder.Symbol)
{
return;
}
if (sellMarketOrder.Quantity == 0 || buyLimitOrder.Quantity == 0)
{
return;
}
int matchQuantity = FindMatchQuantity(sellMarketOrder, buyLimitOrder);
if (matchQuantity == 0)
{
return;
}
double matchPrice = buyLimitOrder.Price;
sellMarketOrder.Modify(sellMarketOrder.Quantity - matchQuantity);
buyLimitOrder.Modify(buyLimitOrder.Quantity - matchQuantity);
var execution = new NewExecution(buyLimitOrder, sellMarketOrder, matchQuantity, matchPrice, dateService.UtcNow());
for (int i = 0; i < executionHandlers.Count; i++)
{
executionHandlers[i].Invoke(execution);
}
}
public void TryMatch(ILimitOrder buyLimitOrder, IMarketOrder sellMarketOrder)
{
if (sellMarketOrder.Way != WayEnum.Sell || buyLimitOrder.Way != WayEnum.Buy)
return;
if (sellMarketOrder.Symbol != buyLimitOrder.Symbol)
return;
if (sellMarketOrder.Quantity == 0 || buyLimitOrder.Quantity == 0)
return;
int matchQuantity = FindMatchQuantity(sellMarketOrder, buyLimitOrder);
if (matchQuantity == 0)
return;
double matchPrice = buyLimitOrder.Price;
sellMarketOrder.Modify(sellMarketOrder.Quantity - matchQuantity);
buyLimitOrder.Modify(buyLimitOrder.Quantity - matchQuantity);
var execution = new NewExecution(buyLimitOrder, sellMarketOrder, matchQuantity, matchPrice, dateService.UtcNow());
for (int i = 0; i < executionHandlers.Count; i++)
executionHandlers[i].Invoke(execution);
}
public void TryMatchMarketOrder(IMarketOrder order)
{
switch (order.Way)
{
case WayEnum.Buy:
if (SellOrders.Count == 0)
return;
while (order.Quantity > 0 && SellOrders.Count > 0)
marketOrderMatchingAlgorithm.TryMatch(order, SellOrders[0]);
break;
case WayEnum.Sell:
if (BuyOrders.Count == 0)
return;
while (order.Quantity > 0 && BuyOrders.Count > 0)
marketOrderMatchingAlgorithm.TryMatch(BuyOrders[0], order);
break;
}
}
private int FindMatchQuantity(IMarketOrder marketOrder, ILimitOrder limitOrder)
{
return Math.Min(marketOrder.Quantity, limitOrder.Quantity);
}
public void HandleMarketOrder(IMarketOrder marketOrder)
{
TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
}
private int FindMatchQuantity(IMarketOrder marketOrder, ILimitOrder limitOrder)
{
return(Math.Min(marketOrder.Quantity, limitOrder.Quantity));
}
public static IClientTrade[] GetTradeRecords(this TradeQueueItem.TradeInfo trade, IMarketOrder marketOrder,
string btcTransactionId, IWalletCredentials walletCredentialsMarket,
IWalletCredentials walletCredentialsLimit)
{
var result = new List <IClientTrade>();
result.AddRange(CreateTradeRecordsForClient(trade, marketOrder, btcTransactionId, walletCredentialsMarket, walletCredentialsLimit, true));
result.AddRange(CreateTradeRecordsForClient(trade, marketOrder, btcTransactionId, walletCredentialsMarket, walletCredentialsLimit, false));
return(result.ToArray());
}
private void TryMatchMarketOrder(IMarketOrder marketOrder)
{
if (marketOrder.Quantity == 0)
return;
switch (marketOrder.Way)
{
case WayEnum.Buy:
if (!orderBookBestBidAsk.BestAskPrice.HasValue)
return;
PriceSlots[orderBookBestBidAsk.BestAskPrice.Value].TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
TryMatchMarketOrder(marketOrder);
break;
case WayEnum.Sell:
if (!orderBookBestBidAsk.BestBidPrice.HasValue)
return;
PriceSlots[orderBookBestBidAsk.BestBidPrice.Value].TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
TryMatchMarketOrder(marketOrder);
break;
}
}
private static IClientTrade[] CreateTradeRecordsForClientWithVolumes(TradeQueueItem.TradeInfo trade, IMarketOrder marketOrder,
string btcTransactionId, IWalletCredentials walletCredentialsMarket, IWalletCredentials walletCredentialsLimit,
bool isMarketClient, double marketVolume, double limitVolume)
{
var clientId = isMarketClient ? walletCredentialsMarket?.ClientId : walletCredentialsLimit?.ClientId;
if (!isMarketClient && string.IsNullOrWhiteSpace(clientId))
{
return(new IClientTrade[0]);
}
clientId = clientId ?? marketOrder.ClientId;
var mutlisig = isMarketClient ? walletCredentialsMarket?.MultiSig : walletCredentialsLimit?.MultiSig;
var fromMultisig = isMarketClient ? walletCredentialsLimit?.MultiSig : walletCredentialsMarket?.MultiSig;
var marketAssetRecord = CreateCommonPartForTradeRecord(trade, marketOrder, btcTransactionId);
var limitAssetRecord = CreateCommonPartForTradeRecord(trade, marketOrder, btcTransactionId);
marketAssetRecord.ClientId = limitAssetRecord.ClientId = clientId;
marketAssetRecord.AddressFrom = limitAssetRecord.AddressFrom = fromMultisig;
marketAssetRecord.AddressTo = limitAssetRecord.AddressTo = mutlisig;
marketAssetRecord.Multisig = limitAssetRecord.Multisig = mutlisig;
marketAssetRecord.Amount = marketVolume * (isMarketClient ? -1 : 1);
marketAssetRecord.AssetId = trade.MarketAsset;
limitAssetRecord.Amount = limitVolume * (isMarketClient ? 1 : -1);
limitAssetRecord.AssetId = trade.LimitAsset;
marketAssetRecord.Id = Utils.GenerateRecordId(marketAssetRecord.DateTime);
limitAssetRecord.Id = Utils.GenerateRecordId(limitAssetRecord.DateTime);
return(new IClientTrade[] { marketAssetRecord, limitAssetRecord });
}
private static IClientTrade[] CreateTradeRecordsForClient(TradeQueueItem.TradeInfo trade, IMarketOrder marketOrder,
string btcTransactionId, IWalletCredentials walletCredentialsMarket, IWalletCredentials walletCredentialsLimit,
bool isMarketClient)
{
return(CreateTradeRecordsForClientWithVolumes(trade, marketOrder, btcTransactionId, walletCredentialsMarket,
walletCredentialsLimit, isMarketClient, trade.MarketVolume, trade.LimitVolume));
}
public void HandleMarketOrder(IMarketOrder marketOrder)
{
TryMatchMarketOrder(marketOrder);
SetBestBidAndAsk();
}
private static ClientTrade CreateCommonPartForTradeRecord(TradeQueueItem.TradeInfo trade, IMarketOrder marketOrder,
string btcTransactionId)
{
return(new ClientTrade
{
DateTime = trade.Timestamp,
Price = trade.Price.GetValueOrDefault(),
LimitOrderId = trade.LimitOrderId,
MarketOrderId = marketOrder.Id,
TransactionId = btcTransactionId
});
}
public void HandleMarketOrder(IMarketOrder marketOrder)
{
string symbol = marketOrder.Symbol;
if (!OrderBooks.ContainsKey(symbol))
return;
OrderBooks[symbol].HandleMarketOrder(marketOrder);
}
