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);
 }
Exemple #2
0
 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);
        }
Exemple #5
0
 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));
 }
Exemple #13
0
 public SimpleMarketTrade(ValeurEchange pair, OrderType action, Richesse objetRichesse) : base(pair, action, objetRichesse)
 {
 }
Exemple #14
0
 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));
        }