Пример #1
0
        private void popularListaOrdens()
        {
            Console.WriteLine("Buscando ordens pendentes...");
            OrderList orderList = api.obterOrdensPendentes();

            //ListaOrdem.Clear();
            foreach (Ordem ordem in orderList.oReturn)
            {
                bool add = true;

                if (ordem.status == Constantes.STATUS_ORDEM_PENDENTE &&
                    Convert.ToDecimal(ordem.amount) <= quantidadeMaxima)
                {
                    foreach (Ordem cOrdem in ListaOrdem)
                    {
                        if (ordem.id == cOrdem.id)
                        {
                            add = false;
                        }
                    }
                    if (add)
                    {
                        Console.WriteLine("Nova ordem encontrada ID: " + ordem.id);
                        ListaOrdem.Add(ordem);
                    }
                }
            }

            for (int i = ListaOrdem.Count - 1; i >= 0; --i)
            {
                bool  remover = false;
                Ordem ordem   = ListaOrdem[i];
                foreach (Ordem cOrdem in orderList.oReturn)
                {
                    if (ordem.id == cOrdem.id &&
                        cOrdem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_CANCELADA)
                    {
                        remover = true;
                        break;
                    }
                }
                if (remover)
                {
                    Console.WriteLine("Ordem cancelada no site ID: " + ordem.id);
                    ListaOrdem.RemoveAt(i);
                }
            }
        }
Пример #2
0
        private void imprimirComparativo(Ordem ordem, double melhorPreco)
        {
            if (ordem.obterPreco() >= melhorPreco &&
               ordem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE &&
               ordem.action == Constantes.TIPO_ORDEM_COMPRA)
            {
                Console.WriteLine("Meu preço OC: " + ordem.obterPreco() + " Melhor " + melhorPreco + " - OK, tenho o melhor preço de compra");
            }
            else if (ordem.obterPreco() <= melhorPreco &&
               ordem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE &&
               ordem.action == Constantes.TIPO_ORDEM_VENDA)
            {
                Console.WriteLine("Meu preço OV: " + ordem.obterPreco() + " Melhor " + melhorPreco + " - OK, tenho o melhor preço de venda");
            }

        }
Пример #3
0
        private void criarOrdemInversa(Ordem ordem)
        {
            Console.WriteLine("Criando ordem inversa:");
            OrderList orderList = null;

            if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
            {
                orderList = api.criarOrdemVenda(Convert.ToDecimal(ordem.amount), calcularPrecoVenda(Convert.ToDecimal(ordem.price)));
            }
            else if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
            {
                orderList = api.criarOrdemCompra(Convert.ToDecimal(ordem.amount), calcularPrecoCompra(Convert.ToDecimal(ordem.price)));
            }

            atualizarListaOrdens(orderList);
        }
Пример #4
0
        private void criarOrdemResidual(Ordem ordem)
        {
            Console.WriteLine("Criando ordem residual");
            decimal   amount    = Convert.ToDecimal(ordem.amount) - Convert.ToDecimal(ordem.executedAmount);
            OrderList orderList = null;

            if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
            {
                orderList = api.criarOrdemCompra(Convert.ToDecimal(amount), Convert.ToDecimal(ordem.price));
            }
            else if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
            {
                orderList = api.criarOrdemVenda(Convert.ToDecimal(amount), Convert.ToDecimal(ordem.price));
            }

            atualizarListaOrdens(orderList);
        }
Пример #5
0
 private void criarOrdemVendaNova(OrderBook book, Ordem ordemModelo)
 {
     double somaQuantidade = 0;
     for (int i = 0; i < book.bids.Count; i++)
     {
         double quantidadeOrdemBook = book.asks[i][1];
         somaQuantidade = somaQuantidade + quantidadeOrdemBook;//somo as qtds até chegar em 0.001
         if (somaQuantidade >= 0.001)//percorre até a soma das qtd for maior que 0.001
         {
             double precoOrdemBook = book.asks[i][0];
             if (precoOrdemBook >= ordemModelo.precoLimite)
             {
                 precoOrdemBook = precoOrdemBook - api.parametros.incrementoOrdem;
                 criarOrdemVenda(precoOrdemBook, ordemModelo.obterQuantidade(), ordemModelo.precoLimite);
                 break;
             }
         }
     }
 }
Пример #6
0
        private void criarOrdemInversa(Ordem ordem)
        {
            Console.WriteLine("Criando ordem inversa:");
            OrderList orderList = null;

            if (ordem.action == "buy")
            {
                orderList = api.criarOrdemVenda(Convert.ToDecimal(ordem.amount), calcularPrecoVenda(Convert.ToDecimal(ordem.price)));
            }
            else if (ordem.action == "sell")
            {
                orderList = api.criarOrdemCompra(Convert.ToDecimal(ordem.amount), calcularPrecoCompra(Convert.ToDecimal(ordem.price)));
            }

            foreach (Ordem novaOrdem in orderList.oReturn)
            {
                ListaOrdem.Add(novaOrdem);
            }
        }
Пример #7
0
        public void monitorarOrdens()
        {
            //popularListaOrdens();
            Console.WriteLine("Inicio monitorando ordens: " + ListaOrdem.oReturn.Count);
            for (int i = ListaOrdem.oReturn.Count - 1; i >= 0; --i)
            {
                Ordem ordem  = ListaOrdem.oReturn[i];
                Ordem cOrdem = api.obterOrdemPorID(ordem.id);
                api.imprimirOrdem("Monitorando: ", cOrdem);
                if (cOrdem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_EXECUTADA)
                {
                    Console.Beep(); Console.Beep(); Console.Beep();
                    Console.WriteLine("Ordem executada :" + cOrdem.id);
                    ordem.status = Constantes.STATUS_ORDEM_EXECUTADA;

                    criarOrdemInversa(cOrdem);

                    ListaOrdem.oReturn.RemoveAt(i);
                }
                else if (cOrdem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE)
                {
                    if (Convert.ToDecimal(cOrdem.executedAmount) > 0)
                    {
                        Console.Beep();
                        Console.WriteLine("Ordem parcialmente executada :" + cOrdem.id);
                        deletarOrdem(cOrdem, i);
                        criarOrdemInversa(cOrdem);
                        criarOrdemResidual(cOrdem);
                        ListaOrdem.oReturn.RemoveAt(i);
                    }
                    else
                    {
                        verificarPrecoDolar(ordem, i);
                    }
                }

                verificarPrecoDolar(cOrdem, i);
            }

            Console.WriteLine("Fim do ciclo, qtd ordens :" + ListaOrdem.oReturn.Count);
            System.Threading.Thread.Sleep(3000);
            monitorarOrdens();
        }
Пример #8
0
        private bool menorPrecoVendaEhMeu(OrderBook book, Ordem ordemAtualizada)
        {
            double melhorPrecoVenda = book.asks[0][0];

            if (ordemAtualizada.obterPreco() <= melhorPrecoVenda)
            {
                return true;
            }
            else//verificar se as ordens menores são minhas também
            {
                double somaQuantidade = 0;
                for (int i = 0; i < book.asks.Count; i++)
                {
                    double quantidadeOrdemBook = book.asks[i][1];
                    somaQuantidade = somaQuantidade + quantidadeOrdemBook;//somo as qtds até chegar em 0.001
                    if (somaQuantidade >= 0.001)//percorre até a soma das qtd for maior que 0.001
                    {
                        double precoOrderBook = book.asks[i][0];

                        bool ehMinhaOrdem = false;
                        foreach (Ordem minhaOrdem in ListaOrdem.oReturn)//verifica se é outra ordem minha
                        {
                            if (precoOrderBook == minhaOrdem.obterPreco())
                            {
                                ehMinhaOrdem = true;
                                return true;
                            }
                        }

                        if (!ehMinhaOrdem &&
                            ordemAtualizada.precoLimite < precoOrderBook)
                        {
                            return false;
                        }

                    }
                }
            }

            return false;
            
        }
Пример #9
0
        private void criarOrdemResidualNovoPreco(Ordem ordem, decimal preco)
        {
            Console.WriteLine("Criando ordem residual novo preco");
            decimal   amount    = Convert.ToDecimal(ordem.amount) - Convert.ToDecimal(ordem.executedAmount);
            OrderList orderList = null;

            if (ordem.action == "buy")
            {
                orderList = api.criarOrdemCompra(Convert.ToDecimal(amount), preco);
            }
            else if (ordem.action == "sell")
            {
                orderList = api.criarOrdemVenda(Convert.ToDecimal(amount), preco);
            }

            foreach (Ordem novaOrdem in orderList.oReturn)
            {
                ListaOrdem.Add(novaOrdem);
            }
        }
Пример #10
0
        public void cancelarOrdem(Ordem ordem)
        {
            if (ordem.status.ToUpper().ToUpper() == Constantes.STATUS_ORDEM_CANCELADA ||
                ordem.status.ToUpper().ToUpper() == Constantes.STATUS_ORDEM_EXECUTADA)
            {
                return;
            }
            Console.WriteLine("Cancelando ordem:" + ordem.id);
            long   IDOrdem = Convert.ToInt64(ordem.id);
            string nonce   = obterNonce();
            string retorno = deleteOrders(parametros.chaveAPI, nonce, gerarAssinatura(nonce), IDOrdem);
            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(OrderList));
            MemoryStream ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes(retorno));

            OrderList createOrder = (OrderList)js.ReadObject(ms);


            ms.Close();

            if (!createOrder.success.Equals("1"))
            {
                Console.WriteLine("Falha ao excluir a ordem ID: " + ordem.id);
                System.Threading.Thread.Sleep(1000);
                cancelarOrdem(ordem);
            }
            else
            {
                if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
                {
                    saldo.saldoBTC = saldo.saldoBTC + (Convert.ToDecimal(ordem.amount) - Convert.ToDecimal(ordem.executedAmount));
                }
                else if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
                {
                    saldo.saldoBRL = saldo.saldoBRL + ((Convert.ToDecimal(ordem.amount) - Convert.ToDecimal(ordem.executedAmount)) * Convert.ToDecimal(ordem.price));
                }
                salvarSaldoLocal();
            }

            //return createOrder.oReturn[0];
        }
Пример #11
0
        public void monitorarOrdens()
        {
            popularListaOrdens();
            Console.WriteLine("Inicio monitorando ordens: " + ListaOrdem.Count);
            for (int i = ListaOrdem.Count - 1; i >= 0; --i)
            {
                Ordem ordem = ListaOrdem[i];


                Ordem cOrdem = api.obterOrdemPorID(ordem.id);
                Console.WriteLine(string.Format("ID {0}, TIPO {1}, PRECO {2}, QTD{3}", ordem.id, ordem.action, ordem.price, ordem.amount));
                if (cOrdem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_EXECUTADA)
                {
                    Console.Beep(); Console.Beep(); Console.Beep();
                    Console.WriteLine("Ordem executada :" + cOrdem.id);
                    ordem.status = Constantes.STATUS_ORDEM_EXECUTADA;

                    criarOrdemInversa(cOrdem);

                    ListaOrdem.RemoveAt(i);
                }
                else if (cOrdem.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE)
                {
                    if (Convert.ToDecimal(cOrdem.executedAmount) > 0)
                    {
                        Console.Beep();
                        Console.WriteLine("Ordem parcialmente executada :" + cOrdem.id);
                        api.cancelarOrdem(cOrdem);
                        criarOrdemInversa(cOrdem);
                        criarOrdemResidual(cOrdem);
                        ListaOrdem.RemoveAt(i);
                    }
                }
            }

            Console.WriteLine("Fim do ciclo, qtd ordens :" + ListaOrdem.Count);
            System.Threading.Thread.Sleep(3000);
            monitorarOrdens();
        }
Пример #12
0
        private void criarOrdemResidual(Ordem ordem)
        {
            try
            {
                Console.WriteLine("Criando ordem de trade residual:");
                decimal   amount    = Convert.ToDecimal(ordem.amount) - Convert.ToDecimal(ordem.executedAmount);
                OrderList orderList = null;
                if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
                {
                    orderList = api.criarOrdemCompra(Convert.ToDecimal(amount), Convert.ToDecimal(ordem.price));
                }
                else if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
                {
                    orderList = api.criarOrdemVenda(Convert.ToDecimal(amount), Convert.ToDecimal(ordem.price));
                }

                atualizarListaOrdens(orderList);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao criar ordem residual " + ex.Message);
            }
        }
Пример #13
0
        private void criarOrdemInversa(Ordem ordem)
        {
            try
            {
                Console.WriteLine("Criando ordem de trade inversa:");
                OrderList orderList = null;
                if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
                {
                    orderList = api.criarOrdemVenda(Convert.ToDecimal(ordem.amount), calcularPrecoVenda(Convert.ToDecimal(ordem.price)), Constantes.TIPO_ORDEM_TRADE);
                }
                else if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
                {
                    orderList = api.criarOrdemCompra(Convert.ToDecimal(ordem.amount), calcularPrecoCompra(Convert.ToDecimal(ordem.price)), Constantes.TIPO_ORDEM_TRADE);
                }

                atualizarListaOrdens(orderList);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao criar ordem inversa " + ex.Message);
                Console.WriteLine(" ");
            }
        }
Пример #14
0
        private void criarOrdemResidual(OrderBook book, Ordem ordem)
        {
            try
            {
                Console.WriteLine("Criando ordem de trade residual:");
                ordem.definirQuantidade(ordem.obterQuantidade() - ordem.obterQuantidadeExecutada());
                OrderList orderList = null;
                if (ordem.action == Constantes.TIPO_ORDEM_COMPRA)
                {
                    criarOrdemCompraNova(book, ordem);
                }
                else if (ordem.action == Constantes.TIPO_ORDEM_VENDA)
                {
                    criarOrdemVendaNova(book, ordem);
                }

                // atualizarListaOrdens(orderList, ordem.precoLimite);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao criar ordem residual " + ex.Message);
            }
        }
Пример #15
0
        private void verificarOrdensDolar()
        {
            bool criarOCDolar = true;
            bool criarOVDolar = true;

            if (null != ListaOrdem.oReturn && ListaOrdem.oReturn.Count != 0)
            {
                for (int i = ListaOrdem.oReturn.Count - 1; i >= 0; --i)
                {
                    Ordem ordemAtualizada = api.obterOrdemPorID(ListaOrdem.oReturn[i].id);
                    Ordem ordemLocal      = ListaOrdem.oReturn[i];
                    if (ordemLocal.tipoRobo.Equals(Constantes.TIPO_ORDEM_DOLAR))
                    {
                        tratarOrdemDolar(ref criarOCDolar, ref criarOVDolar, ordemAtualizada, i);
                    }
                    else if (ordemLocal.tipoRobo.Equals(Constantes.TIPO_ORDEM_TRADE))
                    {
                        tratarOrdemTrade(ordemAtualizada, i);
                    }
                }
            }
            else
            {
                criarOrdemCompraDolar();
                criarOCDolar = false;
                criarOrdemVendaDolar();
                criarOVDolar = false;
            }
            if (criarOCDolar)
            {
                criarOrdemCompraDolar();
            }
            if (criarOVDolar)
            {
                criarOrdemVendaDolar();
            }
        }
Пример #16
0
 private void tratarOrdemTrade(Ordem ordemAtualizada, int i)
 {
     api.imprimirOrdem("Ordem trade encontrada", ordemAtualizada);
     if (ordemAtualizada.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_EXECUTADA)
     {
         Console.Beep(); Console.Beep(); Console.Beep();
         Console.WriteLine("Ordem executada :" + ordemAtualizada.id);
         removerOrdem(ordemAtualizada, i);
         criarOrdemInversa(ordemAtualizada);
         api.atualizarSaldoOrdemExecutada(ordemAtualizada);
     }
     else if (ordemAtualizada.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE)
     {
         if (Convert.ToDecimal(ordemAtualizada.executedAmount) > 0)
         {
             Console.Beep();
             Console.WriteLine("Ordem parcialmente executada :" + ordemAtualizada.id);
             cancelarOrdem(ordemAtualizada, i);
             criarOrdemResidual(ordemAtualizada);
             criarOrdemInversaResidual(ordemAtualizada);
             api.atualizarSaldoOrdemExecutada(ordemAtualizada);
         }
     }
 }
Пример #17
0
 private void tratarOrdemDolar(ref bool criarOCDolar, ref bool criarOVDolar, Ordem ordemAtualizada, int i)
 {
     if (ordemAtualizada.action == Constantes.TIPO_ORDEM_COMPRA)
     {
         criarOCDolar = false;
     }
     else if (ordemAtualizada.action == Constantes.TIPO_ORDEM_VENDA)
     {
         criarOVDolar = false;
     }
     api.imprimirOrdem("Ordem dolar encontrada", ordemAtualizada);
     if (ordemAtualizada.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_CANCELADA)
     {
         removerOrdem(ordemAtualizada, i);
         criarOrdemDolarDoMesmoTipo(ordemAtualizada);
     }
     else if (ordemAtualizada.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_EXECUTADA)
     {
         removerOrdem(ordemAtualizada, i);
         criarOrdemDolarDoMesmoTipo(ordemAtualizada);
         criarOrdemInversa(ordemAtualizada);
         api.atualizarSaldoOrdemExecutada(ordemAtualizada);
     }
     else if (ordemAtualizada.status.ToUpper().Trim() == Constantes.STATUS_ORDEM_PENDENTE &&
              Convert.ToDecimal(ordemAtualizada.executedAmount) > 0)
     {
         cancelarOrdem(ordemAtualizada, i);
         criarOrdemDolarDoMesmoTipo(ordemAtualizada); //Criar nova ordem dolar cheia do mesmo tipo
         criarOrdemInversaResidual(ordemAtualizada);  //criar ordem inversa de trade
         api.atualizarSaldoOrdemExecutada(ordemAtualizada);
     }
     else
     {
         ajustarPrecoDolar(ordemAtualizada, i);
     }
 }
Пример #18
0
 public void imprimirOrdem(string descricao, Ordem ordem)
 {
     Console.WriteLine(string.Format(descricao + " ID {0}, TIPO {1}, PRECO {2}, QTD {3}, EXEC {4}, TIPO {7}, STATUS {5}, DATA {6}",
                                     ordem.id, ordem.action, ordem.price, ordem.amount, ordem.executedAmount, ordem.status.ToUpper(), ordem.dateCreated, ordem.tipoRobo));
     Console.WriteLine(" ");
 }
Пример #19
0
        private void monitorar()
        {
            bool criarOrdemCompra = true;
            bool criarOrdemVenda = true;
            OrderBook book = api.obterLivroOrdens();//TODO: ACABEI DE TIRAR DO FOR
            //verifica se tem ordem minha criada
            if (ListaOrdem != null && ListaOrdem.oReturn != null && ListaOrdem.oReturn.Count > 0)
            {

                double melhorPrecoCompra = book.bids[0][0];
                double melhorPrecoVenda = book.asks[0][0];

                for (int i = ListaOrdem.oReturn.Count - 1; i >= 0; --i)
                {

                    Ordem ordemAtualizada = api.obterOrdemPorID(ListaOrdem.oReturn[i].id);
                    ordemAtualizada.precoLimite = ListaOrdem.oReturn[i].precoLimite;
                    ordemAtualizada.ordemPai = ListaOrdem.oReturn[i].ordemPai;
                    if (ordemAtualizada.action == Constantes.TIPO_ORDEM_COMPRA)
                    {
                        criarOrdemCompra = false;
                        imprimirComparativo(ordemAtualizada, melhorPrecoCompra);
                        //TODO: TROCAR != POR < E REVER LOGICA ABAIXO
                        bool executada = verificarSeFoiExecutada(book, ordemAtualizada, i);//trata se foi executada

                        if (!executada && !melhorPrecoCompraEhMeu(book, ordemAtualizada) && !meuPrecoJaEstaNoLimite(book, ordemAtualizada))//verifica se minha OC pendente é a melhor
                        {
                            if (ordemAtualizada.ordemPai)
                            {
                                ordemAtualizada.precoLimite = (melhorPrecoVenda - api.parametros.spreadCompraVenda);
                            }
                            cancelarOrdem(ordemAtualizada, i);
                            criarOrdemCompraNova(book, ordemAtualizada);
                        }
                    }
                    else if (ordemAtualizada.action == Constantes.TIPO_ORDEM_VENDA)
                    {
                        criarOrdemVenda = false;
                        imprimirComparativo(ordemAtualizada, melhorPrecoVenda);
                        bool executada = verificarSeFoiExecutada(book, ordemAtualizada, i);//trata se foi executada

                        if (!executada && !menorPrecoVendaEhMeu(book, ordemAtualizada) && !meuPrecoJaEstaNoLimite(book, ordemAtualizada))//verifica se minha OC pendente é a melhor
                        {
                            if (ordemAtualizada.ordemPai)
                            {
                                ordemAtualizada.precoLimite = (melhorPrecoCompra + api.parametros.spreadCompraVenda);
                            }
                            cancelarOrdem(ordemAtualizada, i);
                            criarOrdemVendaNova(book, ordemAtualizada);
                        }
                    }
                }

            }
            else
            {
                criarOrdemCompra = false;
                criarOrdemVenda = false;
                inicializar();
            }

            if (criarOrdemCompra)
            {
                criarOrdemCompra = false;
                inicializarOrdemCompra(book);
            }
            if (criarOrdemVenda)
            {
                criarOrdemVenda = false;
                inicializarOrdemVenda(book);
            }
        }
Пример #20
0
        public void monitorarArbitragem()
        {
            //Se preço variar em 0.1% cancela ordens e cria outra
            TickerBitstamp bitstamp      = api.obterTickerBitstamp();
            decimal        dolar         = api.obterCotacaoDolar();
            decimal        precoBitstamp = Convert.ToDecimal(bitstamp.last);
            bool           temOC         = false;
            bool           temOV         = false;

            popularListaOrdens();
            Console.WriteLine("Inicio monitorando ordens Arbitragem: " + ListaOrdem.Count);
            for (int i = ListaOrdem.Count - 1; i >= 0; --i)
            {
                Ordem ordem = ListaOrdem[i];
                api.imprimirOrdem("", ordem);
                if (ordem.action == "buy")
                {
                    temOC = true;
                    decimal precoCompraBRL             = obterPrecoCompraBRL();
                    decimal precoOrdemAtual            = Convert.ToDecimal(ordem.price);
                    decimal limitePrecoCompraPermitido = (precoCompraBRL * 0.1M / 100) + precoCompraBRL;

                    if (precoOrdemAtual > limitePrecoCompraPermitido)
                    {
                        api.cancelarOrdem(ordem);
                        ListaOrdem.RemoveAt(i);

                        criarOrdemResidualNovoPreco(ordem, obterPrecoCompraBRL());
                    }
                }
                else if (ordem.action == "sell")
                {
                    temOV = true;
                    decimal precoVendaBRL             = obterPrecoVendaBRL();
                    decimal precoOrdemAtual           = Convert.ToDecimal(ordem.price);
                    decimal limitePrecoVendaPermitido = precoVendaBRL - (precoVendaBRL * 0.1M / 100);
                    if (precoOrdemAtual < limitePrecoVendaPermitido)
                    {
                        api.cancelarOrdem(ordem);
                        ListaOrdem.RemoveAt(i);

                        criarOrdemResidualNovoPreco(ordem, obterPrecoVendaBRL());
                    }
                }
            }

            if (!temOC)
            {
                temOC = false;
                criarOrdemCompraArbitragem();
            }
            if (!temOV)
            {
                temOV = false;
                criarOrdemVendaArbitragem();
            }

            Console.WriteLine("Fim do ciclo arbitragem, qtd ordens :" + ListaOrdem.Count);
            System.Threading.Thread.Sleep(3000);
            monitorarArbitragem();
        }
Пример #21
0
 private void deletarOrdem(Ordem ordem, int i)
 {
     api.cancelarOrdem(ordem);
     ListaOrdem.oReturn.RemoveAt(i);
     atualizarListaOrdens(ListaOrdem);
 }
Пример #22
0
 private void removerOrdem(Ordem ordem, int i)
 {
     Console.WriteLine("Removendo ordem ID: " + ordem.id);
     ListaOrdem.oReturn.RemoveAt(i);
     api.armazenarOrderList(this.ListaOrdem);
 }
Пример #23
0
 private void cancelarOrdem(Ordem ordem, int i)
 {
     api.cancelarOrdem(ordem);
     ListaOrdem.oReturn.RemoveAt(i);
     api.armazenarOrderList(this.ListaOrdem);
 }