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);
}
}
}
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");
}
}
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);
}
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);
}
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;
}
}
}
}
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);
}
}
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();
}
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;
}
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);
}
}
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];
}
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();
}
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);
}
}
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(" ");
}
}
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);
}
}
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();
}
}
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);
}
}
}
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);
}
}
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(" ");
}
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);
}
}
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();
}
private void deletarOrdem(Ordem ordem, int i)
{
api.cancelarOrdem(ordem);
ListaOrdem.oReturn.RemoveAt(i);
atualizarListaOrdens(ListaOrdem);
}
private void removerOrdem(Ordem ordem, int i)
{
Console.WriteLine("Removendo ordem ID: " + ordem.id);
ListaOrdem.oReturn.RemoveAt(i);
api.armazenarOrderList(this.ListaOrdem);
}
private void cancelarOrdem(Ordem ordem, int i)
{
api.cancelarOrdem(ordem);
ListaOrdem.oReturn.RemoveAt(i);
api.armazenarOrderList(this.ListaOrdem);
}
