/// <summary>
/// Sets an account. Returns true if the account was updated.
/// </summary>
/// <param name="account"></param>
/// <returns></returns>
public async Task <bool> SetAccountAsync(Account account, DbContext context = null)
{
context = context ?? this.DbContext;
if (await account.SaveAsync(context))
{
OnAccountAdd?.Invoke(account);
return(true);
}
else
{
OnAccountUpdate?.Invoke(account);
return(false);
}
}
public async Task Connect()
{
try
{
if (connection.IsConnected)
{
return;
}
//initialize a connection
connection = new Connection(Config);
//subscribe to events
connection.OnClose += Connection_OnClose;
connection.OnException += Connection_OnException;
//try to connect
await connection.Connect();
//fetch current account state
AccountState = await GetAccountData();
//track state on the client side
if (AccountState != null && OnAccountUpdate != null)
{
_ = Task.Factory.StartNew(() => OnAccountUpdate.Invoke(AccountState));
}
}
catch (Exception e)
{
//failed to connect - dispose everything
if (connection != null)
{
await connection.CloseConnection(WebSocketCloseStatus.ProtocolError);
connection.Dispose();
connection = null;
}
throw new Exception("Failed to connect to Centaurus Alpha server", e);
}
}
private void HandleQuantumResult(MessageEnvelope envelope)
{
if (!(envelope.Message is IEffectsContainer effectsMessage))
{
return;
}
if (effectsMessage.Effects.Count > 0)
{
try
{
//apply effects to the client-side state
foreach (var effect in effectsMessage.Effects)
{
AccountState.ApplyAccountStateChanges(effect);
}
//notify subscribers about the account state update
OnAccountUpdate?.Invoke(AccountState);
}
catch (Exception e)
{
OnException?.Invoke(e);
}
}
}
private void handleAccountUpdates(
JsonAccountUpdate update)
{
OnAccountUpdate?.Invoke(update);
}
private void handleAccountUpdate(
JToken token) =>
OnAccountUpdate.DeserializeAndInvoke<IAccountUpdate, JsonAccountUpdate>(token);
private void HandleAccountUpdates(IAccountUpdate update)
{
OnAccountUpdate?.Invoke(update);
}
private void ResultMessageHandler(MessageEnvelope envelope)
{
lock (processedEffectsMessages)
{
if (AccountData == null ||
!(envelope.Message is IEffectsContainer effectsMessage) ||
processedEffectsMessages.Any(r => r == envelope.Message.MessageId))
{
return;
}
RegisterNewEffectsMessage(envelope.Message.MessageId);
try
{
foreach (var effect in effectsMessage.Effects)
{
switch (effect)
{
case NonceUpdateEffect nonceUpdateEffect:
AccountData.Nonce = nonceUpdateEffect.Nonce;
break;
case BalanceCreateEffect balanceCreateEffect:
AccountData.AddBalance(balanceCreateEffect.Asset, constellation);
break;
case BalanceUpdateEffect balanceUpdateEffect:
AccountData.UpdateBalance(balanceUpdateEffect.Asset, balanceUpdateEffect.Amount);
break;
case OrderPlacedEffect orderPlacedEffect:
{
AccountData.AddOrder(orderPlacedEffect.OrderId, orderPlacedEffect.Amount, orderPlacedEffect.Price, constellation);
var decodedId = OrderIdConverter.Decode(orderPlacedEffect.OrderId);
if (decodedId.Side == OrderSide.Buy)
{
AccountData.UpdateLiabilities(0, orderPlacedEffect.QuoteAmount);
}
else
{
AccountData.UpdateLiabilities(decodedId.Asset, orderPlacedEffect.Amount);
}
}
break;
case OrderRemovedEffect orderRemoveEffect:
{
AccountData.RemoveOrder(orderRemoveEffect.OrderId);
var decodedId = OrderIdConverter.Decode(orderRemoveEffect.OrderId);
if (decodedId.Side == OrderSide.Buy)
{
AccountData.UpdateLiabilities(0, -orderRemoveEffect.QuoteAmount);
}
else
{
AccountData.UpdateLiabilities(decodedId.Asset, -orderRemoveEffect.Amount);
}
}
break;
case TradeEffect tradeEffect:
{
AccountData.UpdateOrder(tradeEffect.OrderId, tradeEffect.AssetAmount);
var decodedId = OrderIdConverter.Decode(tradeEffect.OrderId);
if (decodedId.Side == OrderSide.Buy)
{
if (!tradeEffect.IsNewOrder)
{
AccountData.UpdateLiabilities(0, -tradeEffect.QuoteAmount);
}
AccountData.UpdateBalance(0, -tradeEffect.QuoteAmount);
AccountData.UpdateBalance(decodedId.Asset, tradeEffect.AssetAmount);
}
else
{
if (!tradeEffect.IsNewOrder)
{
AccountData.UpdateLiabilities(decodedId.Asset, -tradeEffect.AssetAmount);
}
AccountData.UpdateBalance(decodedId.Asset, -tradeEffect.AssetAmount);
AccountData.UpdateBalance(0, tradeEffect.QuoteAmount);
}
}
break;
case WithdrawalCreateEffect withdrawalCreateEffect:
foreach (var withdrawalItem in withdrawalCreateEffect.Items)
{
AccountData.UpdateLiabilities(withdrawalItem.Asset, withdrawalItem.Amount);
}
break;
case WithdrawalRemoveEffect withdrawalRemoveEffect:
foreach (var withdrawalItem in withdrawalRemoveEffect.Items)
{
if (withdrawalRemoveEffect.IsSuccessful)
{
AccountData.UpdateBalance(withdrawalItem.Asset, -withdrawalItem.Amount);
}
AccountData.UpdateLiabilities(withdrawalItem.Asset, -withdrawalItem.Amount);
}
break;
default:
break;
}
}
OnAccountUpdate?.Invoke(AccountData);
}
catch (Exception exc)
{
OnException?.Invoke(exc);
}
}
}
protected void OnAccountUpdateHandler(AccountDataEventArgs e)
{
OnAccountUpdate?.Invoke(this, e);
}
