public void RequestTrade(Player playerA, ITradeable itemA, Player playerB, ITradeable itemB)
{
if (playerA == playerB)
{
return;
}
if (playerB == null)
{
Money money = itemA as Money;
Field field = itemB as Field;
if (money != null && field != null && money.GetAmount() >= field.Price)
{
FinalizeTrade(playerA, itemA, playerB, itemB);
}
return;
}
TradeMessage tradeMessage = new TradeMessage(playerA, itemA, playerB, itemB);
if (playerA != null)
{
playerA.Messages.Add(tradeMessage);
playerB.Messages.Add(tradeMessage);
}
}
public async Task <IActionResult> OnPostAsync(int?id, string postMessage)
{
var trade = await DbContext.Trades.FindAsync(id);
if (trade == null)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(postMessage))
{
var userContext = CoreService.GetUserContext();
var tm = new TradeMessage
{
Message = postMessage,
TradeId = trade.Id,
VetMemberId = userContext.CurrentUser.Id
};
DbContext.TradeMessages.Add(tm);
DbContext.SaveChanges();
await SendMessages(trade, userContext.CurrentUser, postMessage);
PostMessage = null;
}
return(await OnGetAsync(id));
}
public async Task <IActionResult> OnPostAsync(int?id, string postMessage)
{
var trade = await DbContext.Trades
.Include(c => c.VetMember)
.FirstOrDefaultAsync(c => c.Id == id);
if (trade == null)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(postMessage))
{
var userContext = CoreService.GetUserContext();
var tm = new TradeMessage
{
Message = postMessage,
TradeId = trade.Id,
VetMemberId = userContext.CurrentUser.Id
};
DbContext.TradeMessages.Add(tm);
DbContext.SaveChanges();
await SendMessages(trade, userContext.CurrentUser, postMessage);
PostMessage = null;
}
return(RedirectToPage("./Details", new { id = id }));
}
public void CreateFromString_()
{
var rawMessageString = TestSocketMessages.TradeMessage;
var tradesMessage = TradeMessage.CreateFromString(rawMessageString);
Assert.NotNull(tradesMessage);
Assert.Equal(0, tradesMessage.ChannelId);
Assert.Equal(2, tradesMessage.Trades.Length);
}
private void HandleTradeMessage(TradeMessage message)
{
if (message.Trade.BuyOrSell == "Buy")
{
Buy(message.Trade);
}
if (message.Trade.BuyOrSell == "Sell")
{
Sell(message.Trade);
}
}
internal BitMexTrade(int instrumentId, TradeMessage message)
{
InstrumentId = instrumentId;
Timestamp = message.Timestamp.ToClientValue() ?? default;
Side = message.Side.ToClientValue();
Price = message.Price;
Size = message.Size;
TickDirection = message.TickDirection.ToClientValue();
TradeMatchId = Guid.TryParse(message.TradeMatchId, out var id) ? id : default;
GrossValue = message.GrossValue;
HomeNotional = message.HomeNotional;
ForeignNotional = message.ForeignNotional;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="message">Original message. <see cref="TradeMessage"/></param>
public Trade(TradeMessage message, Symbol symbol)
{
TradeTraderId = message.TradeTraderId;
TradeTimeStamp = DWConverter.FromLongDateTime(message.TradeTimestamp);
Position = message.Position;
Price = DWConverter.FromProtoDecimal(message.Price);
Quantity = DWConverter.FromProtoDecimal(message.Quantity);
PaidPrice = DWConverter.FromProtoDecimal(message.PaidPrice);
LiquidationPrice = DWConverter.FromProtoDecimal(message.LiquidationPrice);
ExitPrice = DWConverter.FromProtoDecimal(message.ExitPrice);
Leverage = message.Leverage;
ContractId = message.ContractId;
OldContractId = message.OldContractId;
OldClientId = DWConverter.FromProtoUuid(message.OldClientId);
IsIncrease = message.IsIncrease;
IsLiquidation = message.IsLiquidation;
Symbol = symbol;
}
public void PostTrades([FromBody] string tradeStream)
{
var message = new TradeMessage(tradeStream);
try
{
List <OMSTradeData> trades = JsonConvert.DeserializeObject <List <OMSTradeData> >(tradeStream);
foreach (var trade in trades)
{
var tradeResult = _endpointInstance.Publish(trade);
}
}
catch
{
message.ValidityType = MessageValidityType.Failure;
}
var messageResult = _endpointInstance.Publish(message);
}
private void SellPosition(Trade trade)
{
//Search owned positions for a match with the trade's ticker
var position = _portfolioPositions.Find(p => p.Ticker == trade.Ticker);
var securityType = position.GetSecurityType();
var ticker = trade.Ticker;
var shares = trade.Shares;
if (shares == position.SharesOwned)
{
//User selling all shares, so find and remove the security from portfolio
var securityToRemove = _portfolioSecurities.Find(s => s.Ticker == ticker);
_portfolioSecurities.Remove(securityToRemove);
//Find and remove all taxlots
var originalTaxLots = new List <Taxlot>(_portfolioTaxlots);
var taxlotsToRemove = originalTaxLots.Where(t => t.Ticker == ticker);
foreach (var lot in taxlotsToRemove)
{
_portfolioTaxlots.Remove(lot);
}
//Remove the position
_portfolioPositions.Remove(position);
}
else if (shares > position.SharesOwned)
{
//User trying to sell too many shares
var message = new TradeMessage()
{
Shares = shares, Ticker = ticker, Message = "Order quantity exceeds shares owned!"
};
Messenger.Default.Send(message);
}
else
{
//User selling partial position
position.SellShares(shares);
}
}
private void HandleData(KrakenMessageEventArgs eventArgs, SubscriptionStatus subscription)
{
var dataType = subscription.Subscription.Name;
if (dataType == SubscribeOptionNames.Ticker)
{
var tickerMessage = TickerMessage.CreateFromString(eventArgs.RawContent, subscription);
TickerReceived.InvokeAll(this, new TickerEventArgs(subscription.ChannelId.Value, subscription.Pair, tickerMessage));
}
if (dataType == SubscribeOptionNames.OHLC)
{
var ohlcMessage = OhlcMessage.CreateFromString(eventArgs.RawContent);
OhlcReceived.InvokeAll(this, new OhlcEventArgs(subscription.ChannelId.Value, subscription.Pair, ohlcMessage));
}
if (dataType == SubscribeOptionNames.Trade)
{
var tradeMessage = TradeMessage.CreateFromString(eventArgs.RawContent);
TradeReceived.InvokeAll(this, new TradeEventArgs(subscription.ChannelId.Value, subscription.Pair, tradeMessage));
}
if (dataType == SubscribeOptionNames.Spread)
{
var spreadMessage = SpreadMessage.CreateFromString(eventArgs.RawContent);
SpreadReceived.InvokeAll(this, new SpreadEventArgs(subscription.ChannelId.Value, subscription.Pair, spreadMessage));
}
if (dataType == SubscribeOptionNames.Book)
{
if (eventArgs.RawContent.Contains(@"""as"":") && eventArgs.RawContent.Contains(@"""bs"":"))
{
var bookSnapshotMessage = BookSnapshotMessage.CreateFromString(eventArgs.RawContent);
BookSnapshotReceived.InvokeAll(this, new KrakenDataEventArgs <BookSnapshotMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookSnapshotMessage));
}
if (eventArgs.RawContent.Contains(@"""a"":") || eventArgs.RawContent.Contains(@"""b"":"))
{
var bookUpdateMessage = BookUpdateMessage.CreateFromString(eventArgs.RawContent);
BookUpdateReceived.InvokeAll(this, new KrakenDataEventArgs <BookUpdateMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookUpdateMessage));
}
}
}
public void MPSMessageHander(MPSMessage message)
{
// pre-checks
// Push message to the queue
// Optional ACK. This would mean local resilience would be required for processing queue.
TradeMessageHeader header = message.Header as TradeMessageHeader;
ITrade trade = message.Payload as ITrade;
if (header == null)
{
logger.Error($"Failed to parse message with header key: {message.Header.MessageKey}");
return;
}
if (trade == null)
{
logger.Error($"Failed to parse message with header key: {header.MessageKey} and sequence no: {header.SequenceNumber}");
return;
}
TradeMessage tradeMessage = new TradeMessage()
{
Header = header, Trade = trade
};
try
{
AddMessage(tradeMessage);
}
catch (Exception ex)
{
logger.Warn(ex, $"Error while adding message with sequence number {tradeMessage.Header.SequenceNumber} to queue. Retrying ...");
if (!RetryHandler(AddMessage, tradeMessage))
{
logger.Error($"Retries failed for sequence number : {tradeMessage.Header.SequenceNumber}");
}
}
}
public void AddMessage(string message, Trade trade, RuleAttribute attribute = null, RewardRule rule = null)
{
if (trade != null)
{
TradeMessage tradeMessage = new TradeMessage
{
TradeId = trade.Id,
Message = message,
};
if (attribute != null)
{
tradeMessage.RuleId = attribute.Id;
tradeMessage.RuleName = attribute.Name;
tradeMessage.Type = Resolve <IRuleModuleService>().GetRuleType(attribute.Id)?.FullName;
}
if (rule != null)
{
tradeMessage.ConfigId = rule.Id;
tradeMessage.RuleName = rule.Base?.Name;
}
Resolve <ITradeMessageService>().Add(tradeMessage);
}
}
private void AddMessage(TradeMessage message)
{
queues[message.Trade.Type].Enqueue(message);
}
public async Task TestMappedStateSizeLimit()
{
var stateSizeLimit = SmartContractConstants.StateSizeLimit;
{
var str = Encoding.UTF8.GetString(new byte[stateSizeLimit]);
var txResult = await TestBasicSecurityContractStub.TestMappedState.SendWithExceptionAsync(
new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
StringValue = str
}
});
txResult.TransactionResult.Error.ShouldContain($"exceeds limit of {stateSizeLimit}");
await TestBasicSecurityContractStub.TestMappedState.SendAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
Int64Value = 1
}
});
var queryResult = await TestBasicSecurityContractStub.QueryMappedState.CallAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
Int64Value = 1
}
});
queryResult.Int64Value.ShouldBe(1);
(await TestBasicSecurityContractStub.QueryMappedState.CallAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
Int64Value = 2
}
})).ShouldBe(new ProtobufMessage());
}
{
var str = Encoding.UTF8.GetString(new byte[stateSizeLimit]);
var txResult = await TestBasicSecurityContractStub.TestMapped1State.SendWithExceptionAsync(
new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
StringValue = str
}
});
txResult.TransactionResult.Error.ShouldContain($"exceeds limit of {stateSizeLimit}");
var str1 = Encoding.UTF8.GetString(new byte[10]);
var message = new ProtobufMessage
{
BoolValue = true,
Int64Value = 1,
StringValue = str1
};
await TestBasicSecurityContractStub.TestMapped1State.SendAsync(new ProtobufInput
{
ProtobufValue = message
});
var queryResult = await TestBasicSecurityContractStub.QueryMappedState1.CallAsync(new ProtobufInput
{
ProtobufValue = message
});
queryResult.ShouldBe(message);
(await TestBasicSecurityContractStub.QueryMappedState1.CallAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
BoolValue = true,
Int64Value = 2,
StringValue = str1
}
})).ShouldBe(new ProtobufMessage());
}
{
var str = Encoding.UTF8.GetString(new byte[stateSizeLimit]);
var txResult = await TestBasicSecurityContractStub.TestMapped2State.SendWithExceptionAsync(
new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
StringValue = str
}
});
await TestBasicSecurityContractStub.TestMapped2State.SendAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
}
});
txResult.TransactionResult.Error.ShouldContain($"exceeds limit of {stateSizeLimit}");
var str1 = Encoding.UTF8.GetString(new byte[10]);
var message = new ProtobufMessage
{
BoolValue = true,
Int64Value = 1,
StringValue = str1
};
await TestBasicSecurityContractStub.TestMapped2State.SendAsync(new ProtobufInput
{
ProtobufValue = message
});
var queryResult = await TestBasicSecurityContractStub.QueryMappedState2.CallAsync(new ProtobufInput
{
ProtobufValue = message
});
queryResult.ShouldBe(message);
(await TestBasicSecurityContractStub.QueryMappedState2.CallAsync(new ProtobufInput
{
ProtobufValue = new ProtobufMessage
{
BoolValue = true,
Int64Value = 2,
StringValue = str1
}
})).ShouldBe(new ProtobufMessage());
}
{
var str = Encoding.UTF8.GetString(new byte[stateSizeLimit]);
var message = new TradeMessage
{
FromAmount = 1024
};
var txResult = await TestBasicSecurityContractStub.TestMapped3State.SendWithExceptionAsync(
new Complex3Input
{
TradeDetails = new TradeMessage
{
FromAmount = 1,
Memo = str
}
});
txResult.TransactionResult.Error.ShouldContain($"exceeds limit of {stateSizeLimit}");
var str1 = Encoding.UTF8.GetString(new byte[10]);
var complex3Input = new Complex3Input
{
From = str1,
To = str1,
TradeDetails = message
};
await TestBasicSecurityContractStub.TestMapped3State.SendAsync(complex3Input);
var queryResult = await TestBasicSecurityContractStub.QueryMappedState3.CallAsync(complex3Input);
queryResult.FromAmount.ShouldBe(message.FromAmount);
(await TestBasicSecurityContractStub.QueryMappedState3.CallAsync(new Complex3Input
{
From = str1,
To = str1,
PairA = str1,
TradeDetails = message
})).ShouldBe(new TradeMessage());
}
}
public function process(TradeMessage msg)
{
//logic
}
public bool CommitMessage(TradeMessage message)
{
Messages.AddRange(message);
SaveChanges();
return(true);
}
public void ProcessMessage(TradeMessage message)
{
// Base processing
}
private void HandleIncomingMessage(object sender, KrakenMessageEventArgs eventArgs)
{
logger.LogDebug("Handling incoming '{event}' message", eventArgs.Event);
switch (eventArgs.Event)
{
case Heartbeat.EventName:
var heartbeat = serializer.Deserialize <Heartbeat>(eventArgs.RawContent);
logger.LogTrace("Heartbeat received: {heartbeat}", heartbeat);
HeartbeatReceived.InvokeAll(this, heartbeat);
break;
case SystemStatus.EventName:
var systemStatus = serializer.Deserialize <SystemStatus>(eventArgs.RawContent);
logger.LogTrace("System status changed: {systemStatus}", systemStatus);
SystemStatus = systemStatus;
SystemStatusChanged.InvokeAll(this, systemStatus);
break;
case SubscriptionStatus.EventName:
var subscriptionStatus = serializer.Deserialize <SubscriptionStatus>(eventArgs.RawContent);
logger.LogTrace("Subscription status changed: {subscriptionStatus}", subscriptionStatus);
SynchronizeSubscriptions(subscriptionStatus);
SubscriptionStatusChanged.InvokeAll(this, subscriptionStatus);
break;
case "data":
var subscription = Subscriptions.ContainsKey(eventArgs.ChannelId.Value) ? Subscriptions[eventArgs.ChannelId.Value] : null;
if (subscription == null)
{
logger.LogWarning("Didn't find a subscription for channelId {channelId}", eventArgs.ChannelId);
break;
}
var dataType = subscription.Subscription.Name;
if (dataType == SubscribeOptionNames.Ticker)
{
var tickerMessage = TickerMessage.CreateFromString(eventArgs.RawContent, subscription);
TickerReceived.InvokeAll(this, new TickerEventArgs(subscription.ChannelId.Value, subscription.Pair, tickerMessage));
}
if (dataType == SubscribeOptionNames.OHLC)
{
var ohlcMessage = OhlcMessage.CreateFromString(eventArgs.RawContent);
OhlcReceived.InvokeAll(this, new OhlcEventArgs(subscription.ChannelId.Value, subscription.Pair, ohlcMessage));
}
if (dataType == SubscribeOptionNames.Trade)
{
var tradeMessage = TradeMessage.CreateFromString(eventArgs.RawContent);
TradeReceived.InvokeAll(this, new TradeEventArgs(subscription.ChannelId.Value, subscription.Pair, tradeMessage));
}
if (dataType == SubscribeOptionNames.Spread)
{
var spreadMessage = SpreadMessage.CreateFromString(eventArgs.RawContent);
SpreadReceived.InvokeAll(this, new SpreadEventArgs(subscription.ChannelId.Value, subscription.Pair, spreadMessage));
}
if (dataType == SubscribeOptionNames.Book)
{
if (eventArgs.RawContent.Contains(@"""as"":") && eventArgs.RawContent.Contains(@"""bs"":"))
{
var bookSnapshotMessage = BookSnapshotMessage.CreateFromString(eventArgs.RawContent);
BookSnapshotReceived.InvokeAll(this, new KrakenDataEventArgs <BookSnapshotMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookSnapshotMessage));
}
if (eventArgs.RawContent.Contains(@"""a"":") || eventArgs.RawContent.Contains(@"""b"":"))
{
var bookUpdateMessage = BookUpdateMessage.CreateFromString(eventArgs.RawContent);
BookUpdateReceived.InvokeAll(this, new KrakenDataEventArgs <BookUpdateMessage>(eventArgs.ChannelId.Value, subscription.Pair, bookUpdateMessage));
}
}
break;
default:
logger.LogWarning("Could not handle incoming message: {message}", eventArgs.RawContent);
break;
}
}
public void WebSocketMessageHandler(MessageArgs e)
{
//cout(e.Text);
string text = e.Text.Replace("\u0000", string.Empty);
if (text.StartsWith("["))
{
JArray array = JArray.Parse(text);
int chanId = array[0].Value <int>();
// Check the ChannelId of the message
if (m_tickerChannelIds.ContainsKey(chanId)) // is this channel id in our TICKER list?
{
string symbol = m_tickerChannelIds[chanId];
JArray ja = array[1] as JArray;
if (ja == null)
{
string msgtype = array[1].Value <string>();
if (msgtype == "hb")
{
//dout("BITFINEX:HEARTBEAT");
}
else
{
ErrorMessage("Bitfinex::WebSocketMessageHandler=> Unknown ticker message type: {0}", msgtype);
}
return;
}
var tim = new TickerMessage(ja);
// TODO: Fire event with this ticker update
cout("BITFINEX Ticker: {0} {1}", symbol, tim.ToString());
return;
}
else if (m_tradeChannelIds.ContainsKey(chanId)) // is this channel id in our TRADE list?
{
string symbol = m_tradeChannelIds[chanId];
JArray ja = array[1] as JArray;
if (ja == null)
{
string msgtype = array[1].Value <string>();
if (msgtype == "hb")
{
//dout("BITFINEX:HEARTBEAT");
}
else if (msgtype == "te")
{
ja = array[2] as JArray;
var trm = new TradeMessage(ja);
// TODO: Fire event with this trade execution
cout("BITFINEX Trade Execution: {0} {1}", symbol, trm.ToString());
}
else if (msgtype == "tu")
{
ja = array[2] as JArray;
var trm = new TradeMessage(ja);
// TODO: Fire event with this trade execution update
cout("BITFINEX Trade Execution Update: {0} {1}", symbol, trm.ToString());
}
else
{
ErrorMessage("Bitfinex::WebSocketMessageHandler=> Unknown trade message type: {0}", msgtype);
}
return;
}
foreach (JArray t in ja)
{
var trm = new TradeMessage(t);
// TODO: Fire event with this trade update
cout("BITFINEX Trade: {0} {1}", symbol, trm.ToString());
}
return;
}
if (array[1] is JArray)
{
JArray book = array[1].Value <JArray>();
if (book[0] is JArray)
{
//m_orderBook.Clear();
for (int i = 0; i < book.Count; ++i)
{
var bookEntry = book[i].Value <JArray>();
float price = bookEntry[0].Value <float>();
int ordersAtLevel = bookEntry[1].Value <int>();
float amount = bookEntry[2].Value <float>();
//cout("{0} {1} {2}", price, ordersAtLevel, amount);
if (ordersAtLevel == 0)
{
m_orderBook.UpdateBid(price.ToString(), 0);
m_orderBook.UpdateAsk(price.ToString(), 0);
}
else
{
if (amount >= 0) // bid
{
m_orderBook.UpdateBid(price.ToString(), amount.ToString());
}
if (amount <= 0) // ask
{
m_orderBook.UpdateAsk(price.ToString(), (-amount).ToString());
}
}
}
FireOrderBookUpdate();
}
else // only contains a SINGLE book entry (a single list containing 3 values)
{
float price = book[0].Value <float>();
int ordersAtLevel = book[1].Value <int>();
float amount = book[2].Value <float>();
//cout("{0} {1} {2}", price, ordersAtLevel, amount);
if (ordersAtLevel == 0)
{
m_orderBook.UpdateBid(price.ToString(), 0);
m_orderBook.UpdateAsk(price.ToString(), 0);
}
else
{
if (amount >= 0) // bid
{
m_orderBook.UpdateBid(price.ToString(), amount.ToString());
}
if (amount <= 0) // ask
{
m_orderBook.UpdateAsk(price.ToString(), (-amount).ToString());
}
}
FireOrderBookUpdate();
}
}
else
{
if (array[1].Type == JTokenType.String && array[1].Value <string>() == "hb")
{
dout("{0} BITFINEX:HEARTBEAT", DateTime.Now.ToString("HH:mm:ss"));
}
else
{
ErrorMessage("BITFINEX: Unknown message: {0}", array[1]);
}
}
}
else
{
JObject msg = JObject.Parse(text);
if (msg["event"] != null)
{
string msgType = msg["event"].Value <string>();
if (msgType == "info")
{
var version = msg["version"];
if (version != null)
{
int iversion = version.Value <int>();
JObject platform = msg["platform"] as JObject;
int status = platform["status"].Value <int>();
dout("BITFINEX: info version={0} status={1}", iversion, status);
}
var code = msg["code"];
if (code != null)
{
int icode = code.Value <int>();
string message = msg["msg"].Value <string>();
dout("BITFINEX: info code={0} message:{1}", icode, message);
}
}
else if (msgType == "subscribed")
{
//dout("BITFINEX: subscribed");
string channel = msg["channel"].Value <string>();
int chanId = msg["chanId"].Value <int>();
string symbol = msg["symbol"].Value <string>();
string pair = msg["pair"].Value <string>();
if (channel == "ticker")
{
m_tickerChannelIds[chanId] = pair;
}
else if (channel == "trades")
{
m_tradeChannelIds[chanId] = pair;
}
else
{
ErrorMessage("Bitfinex::WebSocketMessageHandler=> Unknown channel in 'subscribed' message: {0}", channel);
}
dout("BITFINEX:subscribed channel={0} chanId={1} symbol={2} pair={3}", channel, chanId, symbol, pair);
}
}
else
{
ErrorMessage("Unknown message type: ", Str(msg));
}
}
return;
}
private void SetAlertMessage(TradeMessage message)
{
AlertBoxMessage = message.Message;
AlertBoxVisible = true;
}
/// <summary>
/// Send a message to the hub
/// </summary>
/// <param name="message">message to send</param>
public async Task SendAsync(TradeMessage message)
{
await SendAsyncObject("SendTradeMessage", message);
}
/// <summary>
/// Handle an inbound message from a hub
/// </summary>
/// <param name="method">event name</param>
/// <param name="message">message content</param>
private void HandleReceiveMessage(TradeMessage tradeMessage)
{
// raise an event to subscribers
//MessageReceived?.Invoke(this, new MessageReceivedEventArgs(tradeMessage));
}
/// <summary>
/// Retries for configurable number of time. This should be part of common utility.
/// </summary>
/// <param name="retryTask">Method to invoke</param>
/// <returns>True if invocation is success, else false is returned after maximum retries. </returns>
private bool RetryHandler(Action <TradeMessage> retryTask, TradeMessage message)
{
return(true);
}
