public HistoricalPosition(DateTime closeDate, decimal realisedPnl, PositionEnum type, ref IContractModel instrument)
 {
     CloseDate   = closeDate;
     RealisedPnl = realisedPnl;
     Type        = type;
     Instrument  = instrument;
 }
        public bool AddPosition(ref IContractModel instrument, PositionEnum type, int amount, decimal price)
        {
            if (instrument.IsValidContractAmount(amount) && CalculateBTCMarginRequirement(instrument, type, amount, price) < BTCBalance)
            {
                var localInstrument  = instrument;
                var existingPosition = Positions.FirstOrDefault(x => x.Instrument.Name == localInstrument.Name);
                if (existingPosition == null)
                {
                    Positions.Add(new Position(amount, price, type, ref instrument));
                    BTCBalance -= instrument.MarketFee(amount / price);
                    OnBalanceChangeMessage(new BalanceChangeEventArgs(BTCBalance));
                }
                else
                {
                    if (existingPosition.Type == type)
                    {
                        existingPosition.Amount += amount;
                        existingPosition.Price   = decimal.Round((existingPosition.Amount + amount) / ((existingPosition.Amount / existingPosition.Price) + (amount / price)), 2);
                    }
                    else
                    {
                        existingPosition.Amount -= amount;
                        var realisedPnl  = existingPosition.UnrealisedPnl;
                        var positionType = existingPosition.Type;
                        if (existingPosition.Amount < 0)
                        {
                            existingPosition.Type          = existingPosition.Type == PositionEnum.Buy ? PositionEnum.Sell : PositionEnum.Buy;
                            existingPosition.Amount       *= -1;
                            existingPosition.Price         = price;
                            existingPosition.UnrealisedPnl = 0M;
                        }
                        else if (existingPosition.Amount == 0)
                        {
                            Positions.Remove(existingPosition);
                        }
                        else
                        {
                            if (existingPosition.Type == PositionEnum.Buy)
                            {
                                existingPosition.UnrealisedPnl = (existingPosition.Amount / existingPosition.Price) - (existingPosition.Amount / price);
                            }
                            else
                            {
                                existingPosition.UnrealisedPnl = (existingPosition.Amount / price) - (existingPosition.Amount / existingPosition.Price);
                            }
                            realisedPnl -= existingPosition.UnrealisedPnl;
                        }

                        BTCBalance += realisedPnl - instrument.MarketFee(amount / price);
                        OnBalanceChangeMessage(new BalanceChangeEventArgs(BTCBalance));
                        OnHistoricalPositionAddedMessage(new HistoricalPositionAddedEventArgs(new HistoricalPosition(DateTime.Now, realisedPnl, positionType, ref instrument)));
                    }
                }

                CalculateLiquidationPrice();
                return(true);
            }

            return(false);
        }
Beispiel #3
0
 public Position(int amount, decimal price, PositionEnum type, ref IContractModel instrument)
 {
     Amount        = amount;
     Price         = price;
     Type          = type;
     Instrument    = instrument;
     OpenDate      = DateTime.UtcNow;
     UnrealisedPnl = 0M;
 }
        public OrderChildControl(IContractModel instrument, PositionManager?positionManager, DeribitClient?client)
        {
            InitializeComponent();

            Instrument = instrument;
            InstrumentNameText.Content = Instrument.Name;
            PositionManager            = positionManager;
            Client = client;
            if (Client != null)
            {
                Client.ClientSubscriptionMessage += ClientSubscriptionMessage;
            }
        }
        private decimal CalculateBTCMarginRequirement(IContractModel instrument, PositionEnum type, int amount, decimal price)
        {
            var marginUsed     = CurrentMarginUsed();
            var marginRequired = instrument.InitialMargin(amount / price);

            if (type == PositionEnum.Buy)
            {
                marginRequired = marginRequired + marginUsed.Item1 - marginUsed.Item2;
            }
            else
            {
                marginRequired = marginRequired + marginUsed.Item2 - marginUsed.Item1;
            }

            if (marginRequired < 0)
            {
                marginRequired = 0;
            }
            return(marginRequired);
        }
Beispiel #6
0
 public ContractModelPresenter(IContractModel view)
 {
     this.contractModelView = view;
 }