// Token: 0x060001E0 RID: 480 RVA: 0x00007F2C File Offset: 0x0000612C
public override List <Currency> GetBalance()
{
List <Currency> result;
try
{
List <Currency> list = new List <Currency>();
BalancesResponse balances = this._client.GetBalances();
list.Add(new Currency
{
Name = "BTC_EXCH",
Amount = balances.exchange.BTC.ToString()
});
list.Add(new Currency
{
Name = "BTC_DSPT",
Amount = balances.deposit.BTC.ToString()
});
list.Add(new Currency
{
Name = "BTC_TRDNG",
Amount = balances.trading.BTC.ToString()
});
list = (from x in list
orderby x.Amount descending
select x).ToList <Currency>();
result = list;
}
catch
{
result = new List <Currency>();
}
return(result);
}
public BalancesResponse GetBalances()
{
BalancesRequest req = new BalancesRequest(Nonce);
string response = SendRequest(req, "GET");
BalancesResponse resp = BalancesResponse.FromJSON(response);
return(resp);
}
public BitfinexRestAPI()
{
var secret = ConfigurationManager.AppSettings["ApiSecret"];
var key = ConfigurationManager.AppSettings["ApiKey"];
api = new BitfinexApiV1(key, secret);
bal = api.GetBalances();
}
public override async Task <BalancesResponse> GetBalances(Empty request, ServerCallContext context)
{
var walletId = context.GetHttpContext().User.GetWalletId();
var balances = await _balanceService.GetBalancesAsync(walletId);
var res = new BalancesResponse();
res.Payload.AddRange(_mapper.Map <List <Balance> >(balances));
return(res);
}
public void HandlePurchasingNorbertsGambitRequirement(PendingOrder curNgRequirement, bool firstTime = true)
{
if (firstTime)
{
Console.WriteLine("Currency conversion (Norberts Gambit) is required to purchase some securities in USD.");
}
if (curNgRequirement.Quantity <= 0)
{
Console.WriteLine("Order quantity reduced to zero.");
Console.WriteLine("Skipping order.");
return;
}
if (curNgRequirement.TargetValue < ACCEPTABLE_NG_VALUE_THRESHOLD)
{
Console.WriteLine("Current conversion amount is below acceptable threshold of: " + ACCEPTABLE_NG_VALUE_THRESHOLD);
Console.WriteLine("Skipping conversion.");
return;
}
var orderImpact = GetMarketOrderImpact(curNgRequirement);
BalancesResponse balances = GetBalances(curNgRequirement.AccountNumber);
var cashLevel = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == curNgRequirement.Symbol.currency).cash;
if (cashLevel < Math.Abs(orderImpact.buyingPowerEffect))
{
if (firstTime)
{
Console.WriteLine("Order of " + Math.Abs(orderImpact.buyingPowerEffect) + " exceeds current cash level: " + cashLevel);
Console.WriteLine("Attempting to reduce quantity purchased...");
curNgRequirement.Quantity = (int)Math.Floor(cashLevel / orderImpact.price);
}
else
{
curNgRequirement.Quantity -= 1;
}
HandlePurchasingNorbertsGambitRequirement(curNgRequirement, false);
return;
}
Console.WriteLine("Proceeding to purchace $" + Math.Abs(orderImpact.buyingPowerEffect) + " in " + NG_SYMBOL_CAD);
var success = CreateMarketOrder(curNgRequirement);
if (success)
{
EmailHelper.SendNorbertsGambitEmail(curNgRequirement.AccountNumber, curNgRequirement.Quantity, db);
}
}
public override async Task <BalancesResponse> GetBalances(Empty request, ServerCallContext context)
{
var clientId = context.GetClientId();
var balances = await _balancesClient.GetClientBalances(clientId);
var res = new BalancesResponse {
Body = new BalancesResponse.Types.Body()
};
res.Body.Balances.AddRange(_mapper.Map <List <Balance> >(balances));
return(res);
}
public void OutputFinalResults()
{
foreach (var curAccount in curUser.accounts)
{
Console.WriteLine("\nAccount: " + curAccount.type);
Console.WriteLine("Account number: " + curAccount.number);
BalancesResponse balances = GetBalances(curAccount.number);
Console.WriteLine("CAD Cash: " + balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_CAD).cash);
Console.WriteLine("USD Cash: " + balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_USD).cash);
var breakdownPendingOrders = GetAccountBreakdown(curAccount.number);
Console.WriteLine("\n-- Account Breakdown --");
OutputPendingOrdersTable(breakdownPendingOrders);
}
}
public List <PendingOrder> GetPendingOrdersForAccount(string accountNumber)
{
var pendingOrders = new List <PendingOrder>();
PositionsResponse positions = GetPositions(accountNumber);
BalancesResponse balances = GetBalances(accountNumber);
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == accountNumber);
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
var quote = GetQuote(symbol.symbolId);
var curPosition = positions.positions.FirstOrDefault(p => p.symbol == curStockTarget.Symbol);
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
double curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
double accountTargetPercent = ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100)) * 100;
double percentOfTarget = (curPercentOwned / accountTargetPercent) * 100;
if (percentOfTarget < 100)
{
var valueToBuy = ((accountTargetPercent - curPercentOwned) / 100) * totalEquity;
int numSharesToBuy = (int)Math.Floor(valueToBuy / quote.askPrice);
if (numSharesToBuy > 0)
{
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
IsBuyOrder = true,
TargetValue = valueToBuy,
Quantity = numSharesToBuy,
TargetPercent = accountTargetPercent,
OwnedPercent = curPercentOwned,
});
}
}
}
}
return(pendingOrders);
}
public bool HandlePurchaseOfPendingOrder(PendingOrder pendingOrder, bool firstTime = true)
{
if (firstTime)
{
Console.WriteLine("\nAttempting to purchase: " + pendingOrder.Symbol.symbol + " on account # " + pendingOrder.AccountNumber);
}
if (pendingOrder.Quantity <= 0)
{
Console.WriteLine("Order quantity reduced to zero.");
Console.WriteLine("Skipping order.");
return(false);
}
var orderImpact = GetMarketOrderImpact(pendingOrder);
if (orderImpact.estimatedCommissions / (orderImpact.price * pendingOrder.Quantity) > ACCEPTABLE_COMMISSION_PERCENT_THRESHOLD)
{
Console.WriteLine("Trade value calculation: " + orderImpact.tradeValueCalculation);
Console.WriteLine("Commission: " + orderImpact.estimatedCommissions);
Console.WriteLine("Commissions greater than " + ACCEPTABLE_COMMISSION_PERCENT_THRESHOLD * 100 + "% of value purchased.");
Console.WriteLine("Skipping order.");
return(false);
}
BalancesResponse balances = GetBalances(pendingOrder.AccountNumber);
var cashLevel = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == pendingOrder.Symbol.currency).cash;
if (cashLevel < Math.Abs(orderImpact.buyingPowerEffect))
{
if (firstTime)
{
Console.WriteLine("Order of " + Math.Abs(orderImpact.buyingPowerEffect) + " exceeds current cash level: " + cashLevel);
Console.WriteLine("Attempting to reduce quantity purchased...");
pendingOrder.Quantity = (int)Math.Floor(cashLevel / orderImpact.price);
}
else
{
pendingOrder.Quantity -= 1;
}
return(HandlePurchaseOfPendingOrder(pendingOrder, false));
}
return(CreateMarketOrder(pendingOrder));
}
public async Task <ActionResult> BalanceInformation()
{
var memberApi = GetMemberApiProxy(Request);
BalancesResponse balances = null;
BalanceSetResponse balansesSet = null;
try
{
balances = await memberApi.GetBalancesAsync(new BalancesRequest());
balansesSet = await memberApi.GetBalancesSetAsync();
}
catch (MemberApiProxyException) { }
var settings = new AppSettings();
var brandId = settings.BrandId;
var offlineDeposit = await memberApi.GetOfflineDepositFormDataAsync(brandId);
var fundTransfer = await memberApi.GetFundTransferFormDataAsync(brandId);
var withdrawal = await memberApi.GetWithdrawalFormDataAsync(brandId);
var pedingDeposits = await memberApi.GetPendingDeposits();
var wallets = await memberApi.GetWalletsAsync(brandId);
var onlineDeposit = await memberApi.GetOnlineDepositFormDataAsync(brandId);
var model = new BalanceInformationModel
{
Wallets = wallets,
Balances = balances,
OfflineDeposit = offlineDeposit,
OnlineDeposit = onlineDeposit,
FundTransfer = fundTransfer,
Withdrawal = withdrawal,
PendingDeposits = pedingDeposits,
WalletsBalanceSet = balansesSet
};
return(View(model));
}
public override async Task <BalancesResponse> GetBalances(Empty request, ServerCallContext context)
{
var session = SessionFromContext(context);
var balances = await _matchingEngineClient.Balances.GetAllAsync(new BalancesGetAllRequest
{
BrokerId = session.TenantId,
WalletId = (ulong)session.ClientId,
});
var response = new BalancesResponse();
foreach (var balance in balances.Balances)
{
response.Payload.Add(new Balance
{
AssetId = balance.AssetId,
Available = balance.Amount.ToString(CultureInfo.InvariantCulture),
Reserved = balance.Reserved.ToString(CultureInfo.InvariantCulture),
Timestamp = balances.Timestamp
});
}
return(response);
}
public bool CreateMarketOrder(string accountNumber, string symbol, int symbolId, bool isBuyOrder, int quantity)
{
if (quantity <= 0)
{
throw new Exception("Attempting market order of 0 quantity.");
}
var action = isBuyOrder ? "Buy" : "Sell";
var orderImpact = GetMarketOrderImpact(accountNumber, symbolId, isBuyOrder, quantity);
if (IS_LIVE)
{
BalancesResponse balances = GetBalances(accountNumber);
var cashLevelCAD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_CAD).cash;
var cashLevelUSD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_USD).cash;
Console.WriteLine("\n-- Attempthing market order --");
Console.WriteLine("Account: " + accountNumber);
Console.WriteLine("Symbol: " + symbol);
Console.WriteLine("Action: " + action);
Console.WriteLine("Value: " + orderImpact.tradeValueCalculation);
Console.WriteLine("Estimated Commissions: " + orderImpact.estimatedCommissions);
Console.WriteLine("Buying Power Effect: " + orderImpact.buyingPowerEffect);
Console.WriteLine("Current Cash CAD: " + cashLevelCAD);
Console.WriteLine("Current Cash USD: " + cashLevelUSD);
Console.WriteLine("Allow? Y for yes");
var input = Console.ReadLine().Trim();
if (input != "y" && input != "Y")
{
Console.WriteLine("Market order cancelled.");
return(false);
}
}
if (orderImpact.buyingPowerResult < 0)
{
throw new Exception("Order would cause negative buying power.");
}
if (orderImpact.estimatedCommissions / (orderImpact.price * quantity) > ACCEPTABLE_COMMISSION_PERCENT_THRESHOLD)
{
throw new Exception("Commissions greater than " + ACCEPTABLE_COMMISSION_PERCENT_THRESHOLD * 100 + "% of value purchased.");
}
var request = new RestRequest("/v1/accounts/{accountNumber}/orders", Method.POST);
request.AddUrlSegment("accountNumber", accountNumber);
var body = new
{
accountNumber = accountNumber,
symbolId = symbolId,
quantity = quantity,
isAllOrNone = false,
isAnonymous = false,
orderType = "Market",
timeInForce = "Day",
action = action,
primaryRoute = "AUTO",
secondaryRoute = "AUTO",
};
request.RequestFormat = DataFormat.Json;
request.AddBody(body);
var response = client.Execute(request);
if (response.StatusCode == HttpStatusCode.OK)
{
Console.WriteLine("-- Create Market Order Post --");
Console.WriteLine("Action: " + action);
Console.WriteLine("Symbol: " + symbol);
Console.WriteLine("Quantity: " + quantity);
Console.WriteLine("Response: " + response.Content);
Console.WriteLine("");
return(true);
}
else
{
throw new Exception("Create market order request failed.");
}
}
public List <PendingOrder> GetAccountBreakdown(string accountNumber)
{
var pendingOrders = new List <PendingOrder>();
PositionsResponse positions = GetPositions(accountNumber);
BalancesResponse balances = GetBalances(accountNumber);
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == accountNumber);
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
var quote = GetQuote(symbol.symbolId);
var curPosition = positions.positions.FirstOrDefault(p => p.symbol == curStockTarget.Symbol);
double curPercentOwned = 0;
double curValue = 0;
int curQuantity = 0;
if (curPosition != null)
{
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
curValue = curPosition.currentMarketValue;
curQuantity = (int)curPosition.openQuantity;
}
double accountTargetPercent = ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100)) * 100;
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
TargetValue = curValue,
Quantity = curQuantity,
TargetPercent = accountTargetPercent,
OwnedPercent = curPercentOwned,
});
}
}
// add owned stocks that are not on the target list
foreach (var curPosition in positions.positions)
{
if (pendingOrders.FirstOrDefault(p => p.Symbol.symbol == curPosition.symbol) == null)
{
var symbol = GetSymbol(curPosition.symbol);
var quote = GetQuote(symbol.symbolId);
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
double curPercentOwned = curPosition != null ? (curPosition.currentMarketValue / totalEquity) * 100 : 0;
pendingOrders.Add(new PendingOrder()
{
AccountNumber = accountNumber,
Symbol = symbol,
Quote = quote,
TargetValue = curPosition.currentMarketValue,
Quantity = (int)curPosition.openQuantity,
TargetPercent = 0,
OwnedPercent = curPercentOwned,
});
}
}
return(pendingOrders);
}
public List <PendingOrder> GetNorbertsGambitRequirements(List <PendingOrder> pendingOrders)
{
var NGSymbolUSD = GetSymbol(NG_SYMBOL_USD);
var NGQuoteUSD = GetQuote(NGSymbolUSD.symbolId);
var pendingNGOrders = new List <PendingOrder>();
var pendingOrderGroups = pendingOrders.GroupBy(p => p.AccountNumber);
foreach (var curPendingOrderGroup in pendingOrderGroups)
{
var curAccountNumber = curPendingOrderGroup.Key;
// sell all NG stocks that are already converted to US
SellAllUSNGStocks(curAccountNumber);
// get total USD required
double requiredUSD = 0;
foreach (var curPendingOrder in curPendingOrderGroup)
{
if (curPendingOrder.Symbol.currency == CURRENCY_USD)
{
requiredUSD += curPendingOrder.TargetValue;
}
}
//get total USD that is waiting to be converted
BalancesResponse balances = GetBalances(curAccountNumber);
var curBalanceUSD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_USD);
// calculate value already being converted
PositionsResponse positions = GetPositions(curAccountNumber);
var ngPositionCAD = positions.positions.FirstOrDefault(p => p.symbol == NG_SYMBOL_CAD);
var pendingNGValueUSD = 0.0;
if (ngPositionCAD != null)
{
pendingNGValueUSD = ngPositionCAD.openQuantity * NGQuoteUSD.bidPrice;
}
var remainingUSDRequired = requiredUSD - (curBalanceUSD.cash + pendingNGValueUSD);
if (remainingUSDRequired > 0)
{
var numNGSharesNeeded = (int)Math.Ceiling(remainingUSDRequired / NGQuoteUSD.bidPrice);
var NGSymbolCAD = GetSymbol(NG_SYMBOL_CAD);
var NGQuoteCAD = GetQuote(NGSymbolCAD.symbolId);
pendingNGOrders.Add(new PendingOrder()
{
AccountNumber = curAccountNumber,
Symbol = NGSymbolCAD,
Quote = NGQuoteCAD,
Quantity = numNGSharesNeeded,
IsBuyOrder = true,
TargetValue = numNGSharesNeeded * NGQuoteCAD.askPrice
});
}
}
return(pendingNGOrders);
}
public List <PendingOrder> GetNorbertsGambitRequirements()
{
var NGSymbolUSD = GetSymbol(NG_SYMBOL_USD);
var NGQuoteUSD = GetQuote(NGSymbolUSD.symbolId);
var pendingNGOrders = new List <PendingOrder>();
foreach (var curAccount in curUser.accounts)
{
// sell all NG stocks that are already converted to US
SellAllUSNGStocks(curAccount.number);
BalancesResponse balances = GetBalances(curAccount.number);
// calculate total amount of USD that should be in the account
var accountCategories = db.AccountCategories.Where(p => p.Account.Number == curAccount.number);
double requiredUSDValue = 0;
foreach (var curAccountCategory in accountCategories)
{
foreach (var curStockTarget in curAccountCategory.Category.StockTargets)
{
var symbol = GetSymbol(curStockTarget.Symbol);
if (symbol.currency == CURRENCY_USD)
{
double totalEquity = balances.combinedBalances.FirstOrDefault(p => p.currency == symbol.currency).totalEquity;
requiredUSDValue += totalEquity * ((curAccountCategory.Percent / 100) * (curStockTarget.TargetPercent / 100));
}
}
}
// reduce required amount by USD assets already owned
PositionsResponse positions = GetPositions(curAccount.number);
foreach (var curPosition in positions.positions)
{
var symbol = GetSymbol(curPosition.symbol);
if (symbol.currency == CURRENCY_USD)
{
requiredUSDValue -= curPosition.currentMarketValue;
}
}
// reduce required amount by the value that is already being processed
var ngPositionCAD = positions.positions.FirstOrDefault(p => p.symbol == NG_SYMBOL_CAD);
if (ngPositionCAD != null)
{
requiredUSDValue -= ngPositionCAD.openQuantity * NGQuoteUSD.bidPrice;
}
if (requiredUSDValue > 0)
{
var numNGSharesNeeded = (int)Math.Ceiling(requiredUSDValue / NGQuoteUSD.bidPrice);
var NGSymbolCAD = GetSymbol(NG_SYMBOL_CAD);
var NGQuoteCAD = GetQuote(NGSymbolCAD.symbolId);
var valueToBuyCAD = numNGSharesNeeded * NGQuoteCAD.askPrice;
// if required to buy is greater than cash on hand, truncate to cash level.
var curCashCAD = balances.perCurrencyBalances.FirstOrDefault(p => p.currency == CURRENCY_CAD).cash;
if (valueToBuyCAD > curCashCAD)
{
numNGSharesNeeded = (int)Math.Floor(curCashCAD / NGQuoteCAD.askPrice);
valueToBuyCAD = numNGSharesNeeded * NGQuoteCAD.askPrice;
}
pendingNGOrders.Add(new PendingOrder()
{
AccountNumber = curAccount.number,
Symbol = NGSymbolCAD,
Quote = NGQuoteCAD,
Quantity = numNGSharesNeeded,
IsBuyOrder = true,
TargetValue = valueToBuyCAD
});
}
}
return(pendingNGOrders);
}
