internal TradeEurUsd(Richesse richesseEurToTrade, ValeurEchange veEURO, ValeurEchange veUSD) : base(veEURO, veUSD)
{
Investissement = richesseEurToTrade;
EtapePivot = veEURO.RichesseApresTrade(richesseEurToTrade);
richesseUsdApresTrade = veUSD.RichesseApresTrade(EtapePivot);
ApresTrade = Portefeuille.ConvertUsdEnEuro(richesseUsdApresTrade);
}
internal TradeCirculaire(ValeurEchange m1m2, Richesse etapeM2, ValeurEchange m2m3, ValeurEchange m3m1) : base(3)
{
Investissement = m1m2.RichesseAvantTrade(etapeM2);
EtapeM2 = Investissement.Quantite > 0 ? etapeM2 : new Richesse(0, etapeM2.Monnaie);
EtapeM3 = m2m3.RichesseApresTrade(EtapeM2);
ApresTrade = m3m1.RichesseApresTrade(EtapeM3);
}
internal override void Execute(Site site)
{
Richesse pivotAvecMarge = EtapePivot * (1 - 0.0025);
SimpleMarketTrade tradeBuyPivot = new SimpleMarketTrade(GetValeurEchangeBuyPivot(), OrderType.buy, pivotAvecMarge);
SimpleMarketTrade tradeSellPivot = new SimpleMarketTrade(GetValeurEchangeSellPivot(), OrderType.sell, pivotAvecMarge);
bool ok1, ok2 = false;
try
{
ok1 = tradeBuyPivot.Execute(site);
int compteur = 0;
while (ok1 && !ok2 || compteur++ < 5)
{
ok2 = tradeSellPivot.Execute(site);
}
if (ok1 && !ok2)
{
Portefeuille.EnvoyerMail(new System.Net.Mail.MailAddress("*****@*****.**"), "probleme dans le deuxieme trades Kraken", "http://www.kraken.com/login on est coincé avec " + pivotAvecMarge.ToString());
throw new Exception();
}
}
catch (Exception ex)
{
Portefeuille.EnvoyerMail(new System.Net.Mail.MailAddress("*****@*****.**"), "probleme dans les trades Kraken", "http://www.kraken.com/login je ne sais pas ou on en est");
throw;
}
}
private static TradePivot MeilleurEchangeDepuis(Richesse dispo, ValeurEchange veEURO, ValeurEchange veUSD, Monnaie monnaiePivot)
{
Monnaie monnaieInitiale = dispo.Monnaie; // EURO ou USD
var newTradePivot = monnaieInitiale == EURO ? TradePivot.newTradeEurUsd : TradePivot.newTradeUsdEur;
ValeurEchange valeurEchangeInitiale = monnaieInitiale == EURO ? veEURO : veUSD;
ValeurEchange valeurEchangeFinale = monnaieInitiale == EURO ? veUSD : veEURO;
TradePivot tmp = null;
Richesse richesseToTrade = new Richesse(0, monnaieInitiale);
Richesse etape;
TradePivot bestTrade = newTradePivot(richesseToTrade, veEURO, veUSD);
int i = 0, j = 0;
while (tmp == null || tmp.GainFee > bestTrade.GainFee)
{
if (tmp != null)
{
bestTrade = tmp;
}
etape = TrouveProchaineEtape(monnaieInitiale, monnaiePivot, valeurEchangeInitiale, valeurEchangeFinale, ref i, ref j);
richesseToTrade = etape < dispo ? etape : dispo;
tmp = newTradePivot(richesseToTrade, veEURO, veUSD);
}
if (bestTrade.GainFee.Quantite > 0)
{
return(bestTrade);
}
return(null);
}
internal TradeCirculaire(Richesse richesseInitialeM1, ValeurEchange m1m2, ValeurEchange m2m3, ValeurEchange m3m1) : base(3)
{
Investissement = richesseInitialeM1;
EtapeM2 = m1m2.RichesseApresTrade(richesseInitialeM1);
EtapeM3 = m2m3.RichesseApresTrade(EtapeM2);
ApresTrade = m3m1.RichesseApresTrade(EtapeM3);
}
private static Richesse TrouveProchaineEtape(Monnaie monnaieInitiale, Monnaie monnaiePivot, ValeurEchange valeurEchangeInitiale, ValeurEchange valeurEchangeFinale, ref int i, ref int j)
{
Richesse etapeSensNaturelle = valeurEchangeInitiale.GetRichesseToTrade(monnaieInitiale, i);
Richesse etapeSensInverse = valeurEchangeInitiale.RichesseAvantTrade(valeurEchangeFinale.GetRichesseToTrade(monnaiePivot, j));
if (etapeSensNaturelle < etapeSensInverse)
{
++i;
return(etapeSensNaturelle);
}
++j;
return(etapeSensInverse);
}
private void AjouteGain(Richesse gain, Dictionary <Monnaie, Richesse> dico)
{
lock (dico)
{
if (!dico.TryGetValue(gain.Monnaie, out Richesse dejaLa))
{
dico.Add(gain.Monnaie, gain);
}
else
{
dico[gain.Monnaie] = dejaLa + gain;
}
}
}
private TradeCirculaire CalculTradeCirculaireEnPartantDe(Monnaie m, ValeurEchange veInitiale, ValeurEchange ve12, ValeurEchange ve23, ValeurEchange ve31,
Func <Richesse, ValeurEchange, ValeurEchange, ValeurEchange, TradeCirculaire> constructeurDepuisEtape)
{
TradeCirculaire tmp = null;
TradeCirculaire bestTrade = constructeurDepuisEtape(new Richesse(0, m), ve12, ve23, ve31);
int i = 0;
while (tmp == null || tmp.Gain > bestTrade.Gain)
{
if (tmp != null)
{
bestTrade = tmp;
}
Richesse etape = veInitiale.GetRichesseToTrade(m, i++);
tmp = constructeurDepuisEtape(etape, ve12, ve23, ve31);
}
return(bestTrade);
}
internal Richesse RichesseApresTrade(Richesse richesseAvantTrade)
{
List <Position> positions = PositionsVente(richesseAvantTrade.Monnaie);
Func <Position, double> volumeMaxVendue = richesseAvantTrade.Monnaie == monnaieDeBase ? Position.getVolumeBase : Position.getVolumeQuote;
Func <Position, double, double> volumeAchetePour = richesseAvantTrade.Monnaie == monnaieDeBase ? Position.volumeQuotePour : Position.volumeBasePour;
Monnaie monnaieAAcheter = richesseAvantTrade.Monnaie == monnaieDeBase ? monnaieDeQuote : monnaieDeBase;
double qtteAVendre = richesseAvantTrade.Quantite;
double qtteAchetee = 0;
int i = 0;
while (qtteAVendre > 0 && i < positions.Count)
{
Position positionEnCours = positions[i++];
double volumeVendu = Math.Min(volumeMaxVendue(positionEnCours), qtteAVendre);
qtteAVendre -= volumeVendu;
qtteAchetee += volumeAchetePour(positionEnCours, volumeVendu);
}
return(new Richesse(qtteAchetee, monnaieAAcheter));
}
internal TreeSet <TradePivot> TrouveMeilleurEchangeEURUSD(Richesse dispoEuro, Richesse dispoUSD)
{
TreeSet <TradePivot> ret = new TreeSet <TradePivot>();
foreach (Monnaie monnaiePivot in MonnaieTradableEURUSD)
{
if (BaseEtQuoteToVe.TryGetValue(EURO, monnaiePivot, out ValeurEchange veEURO) && BaseEtQuoteToVe.TryGetValue(USD, monnaiePivot, out ValeurEchange veUSD))
{
TradePivot bestTrade = MeilleurEchangeDepuis(dispoEuro, veEURO, veUSD, monnaiePivot);
if (bestTrade == null)
{
bestTrade = MeilleurEchangeDepuis(dispoUSD, veEURO, veUSD, monnaiePivot);
}
if (bestTrade != null)
{
ret.Add(bestTrade);
}
}
}
return(ret);
}
internal Richesse RichesseAvantTrade(Richesse richesseApresTrade)
{
List <Position> positions = PositionsAchat(richesseApresTrade.Monnaie);
Func <Position, double> volumeMaxAchetee = richesseApresTrade.Monnaie == monnaieDeBase ? Position.getVolumeBase : Position.getVolumeQuote;
Func <Position, double, double> volumeVenduPour = richesseApresTrade.Monnaie == monnaieDeBase ? Position.volumeQuotePour : Position.volumeBasePour;
Monnaie monnaieVendue = richesseApresTrade.Monnaie == monnaieDeBase ? monnaieDeQuote : monnaieDeBase;
double qtteVendue = 0;
double qtteAchetee = richesseApresTrade.Quantite;
int i = 0;
while (qtteAchetee > 0 && i < positions.Count)
{
Position positionEnCours = positions[i++];
double volumeAchete = Math.Min(volumeMaxAchetee(positionEnCours), qtteAchetee);
qtteAchetee -= volumeAchete;
qtteVendue += volumeVenduPour(positionEnCours, volumeAchete);
}
if (qtteAchetee > 0)
{
qtteVendue = 0; //le trade n'aurait pas été possible
}
return(new Richesse(qtteVendue, monnaieVendue));
}
internal Richesse RichesseAvantTrade(Richesse richesseApresTrade)
{
return(Profondeur.RichesseAvantTrade(richesseApresTrade));
}
public SimpleMarketTrade(ValeurEchange pair, OrderType action, Richesse objetRichesse) : base(pair, action, objetRichesse)
{
}
internal Trade(ValeurEchange pair, OrderType action, Richesse objetRichesse)
{
this.pair = pair;
this.action = action;
this.objetRichesse = objetRichesse;
}
/*
*
* PAS DE PRISE EN COMPTE DE SPREAD SUR LE TAUX EURO DOLLAR (REVOLUT)
*
* /**
* combien il aurait fallu fournir de richesse en euro pour avoir cette richesse USD
* /
* internal static Richesse ConvertFromEuroToUsd(Richesse richesseEnUsd)
* {
* double euros = richesseEnUsd.Quantite * USD_EUR_ASK;
* return new Richesse(euros, Monnaie.EURO);
* }
*
* /**
* combien on peut avoir en euro a partir d'une richesse en USD
* /
* internal static Richesse ConvertFromUsdToEuro(Richesse richesseEnUsd)
* {
* double euros = richesseEnUsd.Quantite * USD_EUR_BID;
* return new Richesse(euros, Monnaie.EURO);
* }
*
*/
internal static Richesse ConvertUsdEnEuro(Richesse richesseEnUsd)
{
return(new Richesse(richesseEnUsd.Quantite * USD_EUR, Monnaie.EURO));
}
