Beispiel #1
0
        public decimal GetInitMarginForOrder(Order order)
        {
            var accountAsset =
                _tradingInstrumentsCache.GetTradingInstrument(order.TradingConditionId, order.AssetPairId);
            var marginRate = _cfdCalculatorService.GetQuoteRateForBaseAsset(order.AccountAssetId, order.AssetPairId,
                                                                            order.LegalEntity, order.Direction == OrderDirection.Buy);
            var accountBaseAssetAccuracy = _assetsCache.GetAssetAccuracy(order.AccountAssetId);

            return(Math.Round(
                       GetMargins(accountAsset, Math.Abs(order.Volume), marginRate).MarginInit,
                       accountBaseAssetAccuracy));
        }
Beispiel #2
0
        public void Is_GetQuoteRateForBaseAsset_Correct()
        {
            const string instrument = "BTCUSD";

            _bestPriceConsumer.SendEvent(this, new BestPriceChangeEventArgs(new InstrumentBidAskPair {
                Instrument = instrument, Ask = 905.35M, Bid = 905.1M
            }));

            var quote = _quoteCacheService.GetQuote(instrument);

            Assert.IsNotNull(quote);
            Assert.AreEqual(905.1, quote.Bid);
            Assert.AreEqual(905.35, quote.Ask);

            var quoteRate = _cfdCalculatorService.GetQuoteRateForBaseAsset(Accounts[0].BaseAssetId, instrument, "LYKKEVU");

            Assert.AreEqual(905.35, quoteRate);

            quoteRate = _cfdCalculatorService.GetQuoteRateForBaseAsset(Accounts[0].BaseAssetId, instrument, "LYKKEVU", false);

            Assert.AreEqual(905.1, quoteRate);
        }
Beispiel #3
0
        public void CalculateMargin(IOrder order, FplData fplData)
        {
            var accountAsset = _accountAssetsCacheService.GetAccountAsset(order.TradingConditionId, order.AccountAssetId, order.Instrument);

            fplData.MarginRate = _cfdCalculatorService.GetQuoteRateForBaseAsset(order.AccountAssetId, order.Instrument,
                                                                                order.LegalEntity);
            fplData.MarginInit =
                Math.Round(Math.Abs(order.Volume) * fplData.MarginRate / accountAsset.LeverageInit,
                           fplData.AccountBaseAssetAccuracy);
            fplData.MarginMaintenance =
                Math.Round(Math.Abs(order.Volume) * fplData.MarginRate / accountAsset.LeverageMaintenance,
                           fplData.AccountBaseAssetAccuracy);
        }
Beispiel #4
0
        private decimal GetSwaps(string accountAssetId, string instrument, OrderDirection type, DateTime?openDate, DateTime?closeDate, decimal volume, decimal swapRate)
        {
            decimal result = 0;

            if (openDate.HasValue)
            {
                var close   = closeDate ?? DateTime.UtcNow;
                var seconds = (decimal)(close - openDate.Value).TotalSeconds;

                const int secondsInYear = 31536000;
                var       quote         = _calculator.GetQuoteRateForBaseAsset(accountAssetId, instrument);
                var       swaps         = quote * volume * swapRate * seconds / secondsInYear;
                result = Math.Round(swaps, _assetsCache.GetAssetAccuracy(accountAssetId));
            }

            return(result);
        }
Beispiel #5
0
        private decimal GetSwaps(string accountAssetId, string instrument, DateTime?openDate, DateTime?closeDate,
                                 decimal volume, decimal swapRate, string legalEntity)
        {
            decimal result = 0;

            if (openDate.HasValue)
            {
                var close   = closeDate ?? DateTime.UtcNow;
                var seconds = (decimal)(close - openDate.Value).TotalSeconds;

                const int secondsInYear = 31536000;
                var       quote         = _cfdCalculatorService.GetQuoteRateForBaseAsset(accountAssetId, instrument, legalEntity,
                                                                                         volume * swapRate > 0);
                var swaps = quote * volume * swapRate * seconds / secondsInYear;
                result = Math.Round(swaps, AssetsConstants.DefaultAssetAccuracy);
            }

            return(result);
        }