/// <summary>
        /// Vrifico se ci sono bolle particolamente vecchie da eliminare
        /// </summary>
        private void CheckBubblesToCancel()
        {
            //recupero le vecchie bolle solo se sono in una situazione di stallo e mi mancano bolle
            if (_market.Bubbles.Count + this.WishList.Count < _configuration.MaxBubbles*(decimal) 0.8)
            {
                return;
            }

            // ne creo solo una (distruggere le bolle costa)
            foreach (CBubble bubble in _market.Bubbles)
            {
                if (bubble.SellAt > _market.Ask * BubbleDestructionLevel)
                {
                    // distruggi la bolla 
                    var marketValue = _market.Ask;
                    var orderId = "";
                    _market.DoOrder(CUtility.OrderType.Sell, marketValue, bubble.Coins, ref orderId, true);
                    CUtility.Log("*** Bubble destroyed");
                    bubble.Deleted = true;
                    _bubblesCanceled++;

                    // crea una bolla in wishlist
                    WishList.Add(CBubble.Create(_market, CUtility.OrderType.Buy, bubble.Coins, bubble.BuyAt, _configuration.Gain,orderId));

                    break;
                }
            }
            var removed = _market.Bubbles.RemoveAll(o => o.Deleted == true);
        }
        private void CreateBubble()
        {
            // CUtility.Log("*** order buy");
            var    marketValue = Market.Bid;
            string orderId     = "";

            // non compro perchè il valore di mercato è circa il 10% di altre bolle presenti
            if (Market.Bubbles.Any(o => Math.Abs(o.MarketValue - marketValue) / marketValue <= (decimal)0.25))
            {
                return;
            }

            // soldi nel wallet, ma non piu' del massimo consentito
            decimal availableMoney = Market.TotMoney;

            if (availableMoney > MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest)
            {
                availableMoney = MainConfiguration.Configuration.ManagerConservativeMaxMoneyToInvest;
            }

            // come creo una bolla ?
            var money = availableMoney / ConfigurationHoldAndBuy.MaxBubbles;
            var coins = money / marketValue;

            if (coins > ConfigurationHoldAndBuy.MaxCoinsPerBubble)
            {
                coins = ConfigurationHoldAndBuy.MaxCoinsPerBubble;
            }

            // verifico di non aver impiegato troppi soldi
            if (coins < ConfigurationHoldAndBuy.MinimumCoinsPerBubble)
            {
                // bolla troppo piccola...
                if ((decimal)ConfigurationHoldAndBuy.MinimumCoinsPerBubble * marketValue <= availableMoney)
                {
                    coins = ConfigurationHoldAndBuy.MinimumCoinsPerBubble;
                }
            }

            // verifico di non aver superato le soglie minime di coins e soldi

            Market.DoOrder(CUtility.OrderType.Buy, marketValue, coins, ref orderId, true);
            // CUtility.Log("*** Bubble added");
            _bubblesCreated++;
            Market.Bubbles.Add(CBubble.Create(Market, CUtility.OrderType.Buy, coins, marketValue,
                                              ConfigurationHoldAndBuy.Gain, orderId));
        }
        private void CreateBubble()
        {

            CUtility.Log("*** order buy");
            var marketValue = _market.Bid;
            string orderId = "";

            // non compro perchè il valore di mercato è circa il 10% di altre bolle presenti
            if (_market.Bubbles.Any(o => Math.Abs(o.MarketValue - marketValue) <= marketValue/10))
            {
                return;
            }


            // soldi nel wallet, ma non piu' del massimo consentito
            decimal availableMoney = _market.TotMoney;
            if (availableMoney > _configuration.MaxMoney)
            {
                availableMoney = _configuration.MaxMoney;
            }

            // come creo una bolla ? 
            var money = availableMoney / _configuration.MaxBubbles;
            var coins = money / marketValue;

            if (coins > _configuration.MaxCoinsPerBubble)
            {
                coins = _configuration.MaxCoinsPerBubble;
            }

            // verifico di non aver impiegato troppi soldi
            

            // verifico di non aver superato le soglie minime di coins e soldi

            _market.DoOrder(CUtility.OrderType.Buy, marketValue, coins, ref orderId, true);
            CUtility.Log("*** Bubble added");
            _bubblesCreated++;
            _market.Bubbles.Add(CBubble.Create(_market, CUtility.OrderType.Buy, coins, marketValue,
                _configuration.Gain, orderId));           
        }
Exemplo n.º 4
0
        private decimal _lastCoin  = -1; // non si puo' usare decimal.MinValue


        public override bool OnHeartBeat()
        {
            // devo vendere o devo comprare?
            var action = this.SuggestedAction;

            // mi salvo il massimo value
            if (Market.TotValue > this.MaxValue)
            {
                this.MaxValue = Market.TotValue;
            }

            if (Market.TotCoins > this.MaxCoins)
            {
                this.MaxCoins = Market.TotCoins;
            }

            /**************************************************************
            *  CHECK CONFERMA (DOPPIO COMANDO)
            **************************************************************/

            // questa parte di codice esegue l'operazione se c'è una conferma
            if (action != TechnicalAnalysis.TradeAction.SellStopLoss && action != TradeAction.StrongBuy && action != TradeAction.StrongSell)
            {
                if (action != _lastTradeActionSuggested)
                {
                    _lastTradeActionSuggested = action;
                    action = TradeAction.Unknown;
                }
            }
            else
            {
                _lastTradeActionSuggested = TradeAction.Unknown;
            }

            /**************************************************************
            *  VERIFICA BOLLA
            **************************************************************/

            const decimal gain = 0.02M;

            if (_bubble == null)
            {
                if (Market.TotCoins > 0)
                {
                    // ho comprato quindi ho coins
                    _bubble = CBubble.Create(Market, CUtility.OrderType.Buy, Market.TotCoins, Market.Bid, gain, "");
                }
                else
                {
                    // ho venduto, quindi ho soldi
                    // _bubble = CBubble.Create(Market, CUtility.OrderType.Sell, 0, Market.Ask, gain, "");
                }
            }

            /**************************************************************
            *  DEVO VENDERE
            **************************************************************/
            if (_bubble != null)
            {
                // è una bolla creata comprando bitcoins, quindi devo venderli
                if (Market.Ask > _bubble.SellAt)
                {
                    string orderId = "";
                    var    amount  = Market.TotCoins;

                    if (amount * Market.Ask >
                        MainConfiguration.Configuration.StartWalletCoins *
                        MainConfiguration.Configuration.StartWalletMoney)
                    {
                        if (amount > MinBitCoin)
                        {
                            Market.DoOrder(CUtility.OrderType.Sell, Market.Ask, amount, ref orderId, true);
                            _bubble = null;
                            TotAsk++;
                        }
                    }
                    goto exitif;
                }
            }

            /**************************************************************
            *  DEVO COMPRARE
            **************************************************************/
            if (_bubble == null)
            {
                if (SuggestedAction == TradeAction.StrongBuy || (SuggestedAction == TradeAction.Buy))
                {
                    string orderId = "";
                    var    amount  = Market.TotMoney / Market.Bid;

                    if (amount > MinBitCoin)
                    {
                        Market.DoOrder(CUtility.OrderType.Buy, Market.Bid, amount, ref orderId, true);
                        _bubble = CBubble.Create(Market, CUtility.OrderType.Buy, amount, Market.Bid, gain, orderId);
                        TotBid++;
                    }
                }
            }

exitif:

            /**************************************************************
            *  LOG
            **************************************************************/
            Log(string.Format("Bids:{0} Asks:{1} Stop:{2} Max$:{3} Max:{4}", TotBid, TotAsk, TotStopLoss, Math.Round(this.MaxValue, 4).ToString(CultureInfo.InvariantCulture), Math.Round(this.MaxCoins, 4).ToString(CultureInfo.InvariantCulture)));

            return(true);
        }