Beispiel #1
0
        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 ValeurEchange(string idName, Monnaie monnaieDeBase, Monnaie monnaieDeQuote, Monnaie feeVolumeMonnaie, JsonObject valeurEchange)
        {
            IdName           = idName;
            MonnaieDeBase    = monnaieDeBase;
            MonnaieDeQuote   = monnaieDeQuote;
            FeeVolumeMonnaie = feeVolumeMonnaie;
            Name             = (string)valeurEchange["altname"];
            LotDecimals      = ((JsonNumber)valeurEchange["lot_decimals"]).ToInt32();
            PairDecimals     = ((JsonNumber)valeurEchange["pair_decimals"]).ToInt32();
            LotMultiplier    = ((JsonNumber)valeurEchange["lot_multiplier"]).ToInt32();
            Fees             = new TreeSet <Fee>();
            foreach (JsonArray feeJson in (JsonArray)valeurEchange["fees"])
            {
                Fees.Add(new Fee(feeJson));
            }
            FeesMaker = new TreeSet <Fee>();
            var feesMakerJson = (JsonArray)valeurEchange["fees_maker"];

            if (feesMakerJson == null)
            {
                return;
            }
            foreach (JsonArray feeJson in feesMakerJson)
            {
                FeesMaker.Add(new Fee(feeJson));
            }
            MarginCall = ((JsonNumber)valeurEchange["margin_call"]).ToInt32();
            MarginStop = ((JsonNumber)valeurEchange["margin_stop"]).ToInt32();
            Profondeur = new Profondeur(MonnaieDeBase, MonnaieDeQuote);
            MetAJourProfondeur();
        }
Beispiel #3
0
 private void AddDictionnaire(Monnaie mbase, Monnaie quote, ValeurEchange ve)
 {
     BaseEtQuoteToVe.Add(mbase, quote, ve);
     Pairs.Add(ve);
     MonnaieTradable.Add(mbase);
     MonnaieTradable.Add(quote);
 }
 internal Position(JsonArray jsonAsk, Monnaie mbase, Monnaie quote)
 {
     this.monnaieDeBase  = mbase;
     this.monnaieDeQuote = quote;
     PrixBase            = double.Parse((string)jsonAsk[0], CultureInfo.InvariantCulture.NumberFormat);
     VolumeBase          = double.Parse((string)jsonAsk[1], CultureInfo.InvariantCulture.NumberFormat);
     Date = new DateTime(((JsonNumber)jsonAsk[2]).ToInt64());
 }
 internal Position(double prixBase, double volumeBase, DateTime date, Monnaie mbase, Monnaie quote)
 {
     this.monnaieDeBase  = mbase;
     this.monnaieDeQuote = quote;
     PrixBase            = prixBase;
     VolumeBase          = VolumeBase;
     Date = date;
 }
        internal Richesse GetRichesseToTrade(Monnaie m1, int i)
        {
            List <Position>         l      = Profondeur.PositionsVente(m1);
            Func <Position, double> volume = m1 == MonnaieDeBase ? Position.getVolumeBase : Position.getVolumeQuote;
            double qtte = 0;

            for (int j = 0; j <= i && j < l.Count - 1; j++)
            {
                qtte += volume(l[j]);
            }
            return(new Richesse(qtte, m1));
        }
Beispiel #7
0
        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);
        }
Beispiel #8
0
        internal Site()
        {
            BaseEtQuoteToVe = new InterchangableBiKeyDictionnary <Monnaie, ValeurEchange>();
            var requeteMonnaies = client.GetActiveAssets();
            var listeMonnaies   = (JsonObject)requeteMonnaies["result"];

            foreach (string key in listeMonnaies.Names)
            {
                new Monnaie(key, (JsonObject)listeMonnaies[key]);
            }
            var requeteValeursEchanges = client.GetAssetPairs();
            var valeursEchanges        = (JsonObject)requeteValeursEchanges["result"];
            var exceptions             = new ConcurrentQueue <Exception>();

            Parallel.ForEach(valeursEchanges.Names.Cast <string>(), (key) =>//foreach (string key in valeursEchanges.Names)
            {
                try
                {
                    if (!key.Contains(".d"))
                    {
                        var valeurEchange        = (JsonObject)valeursEchanges[key];
                        Monnaie monnaieDeBase    = GetMonnaie((string)valeurEchange["base"]);
                        Monnaie monnaieDeQuote   = GetMonnaie((string)valeurEchange["quote"]);
                        Monnaie feeVolumeMonnaie = GetMonnaie((string)valeurEchange["fee_volume_currency"]);
                        var ve = new ValeurEchange(key, monnaieDeBase, monnaieDeQuote, feeVolumeMonnaie, valeurEchange);
                        if (!ve.FeesMaker.IsEmpty)
                        {
                            AddDictionnaire(monnaieDeBase, monnaieDeQuote, ve);
                        }
                    }
                }
                catch (Exception ex)
                {
                    exceptions.Enqueue(ex);
                }
            });
            if (exceptions.Count > 0)
            {
                throw new AggregateException(exceptions);
            }
            Parallel.ForEach(MonnaieTradable, (monnaie) =>
            {
                if (BaseEtQuoteToVe.ContainsKeys(monnaie, EURO) && BaseEtQuoteToVe.ContainsKeys(monnaie, USD))
                {
                    MonnaieTradableEURUSD.Add(monnaie);
                }
            });
        }
        private void MetAJourRichesses()
        {
            _richesses.Clear();
            JsonObject json = Site.client.GetBalance();

            if (((JsonArray)json["error"]).Count != 0)
            {
                throw new Exception("erreur a la récupération des richesses du portefeuille");
            }
            var balances = (JsonObject)json["result"];

            foreach (string key in balances.Names)
            {
                Monnaie monnaie = Monnaie.GetMonnaie(key);
                double  qtte    = double.Parse((string)balances[key]);
                _richesses.Add(monnaie, new Richesse(qtte, monnaie));
            }
        }
Beispiel #10
0
        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 Monnaie(string nomId, JsonObject jsonObject)
        {
            NomId           = nomId;
            Nom             = (string)jsonObject["altname"];
            Decimal         = ((JsonNumber)jsonObject["decimals"]).ToInt32();
            DisplayDecimals = ((JsonNumber)jsonObject["display_decimals"]).ToInt32();
            switch (Nom)
            {
            case "EUR":
                EURO = this;
                break;

            case "USD":
                USD = this;
                break;
            }
            monnaies.Add(NomId, this);
        }
        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 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));
        }
Beispiel #14
0
        private TradeCirculaire CalculTradeCirculaire(Monnaie m1, Monnaie m2, Monnaie m3)
        {
            if (!BaseEtQuoteToVe.TryGetValue(m1, m2, out ValeurEchange ve12) ||
                !BaseEtQuoteToVe.TryGetValue(m2, m3, out ValeurEchange ve23) ||
                !BaseEtQuoteToVe.TryGetValue(m3, m1, out ValeurEchange ve31))
            {
                return(null);
            }
            TradeCirculaire partantDeM1 = CalculTradeCirculaireEnPartantDe(m1, ve12, ve12, ve23, ve31, TradeCirculaire.constructeurFromM1);
            TradeCirculaire partantDeM2 = CalculTradeCirculaireEnPartantDe(m2, ve23, ve12, ve23, ve31, TradeCirculaire.constructeurFromM2);
            TradeCirculaire partantDeM3 = CalculTradeCirculaireEnPartantDe(m3, ve31, ve12, ve23, ve31, TradeCirculaire.constructeurFromM3);

            TradeCirculaire best = partantDeM1;

            if (best.Gain < partantDeM2.Gain)
            {
                best = partantDeM2;
            }
            if (best.Gain < partantDeM3.Gain)
            {
                best = partantDeM3;
            }
            return(best);
        }
        internal List <Position> PositionsAchat(Monnaie monnaieAchetee)
        {
            Monnaie monnaieAVendre = monnaieAchetee == monnaieDeBase ? monnaieDeQuote : monnaieDeBase;

            return(PositionsVente(monnaieAVendre));
        }
 internal List <Position> PositionsVente(Monnaie monnaieAVendre)
 {
     return(monnaieAVendre == monnaieDeBase?PositionsVenteBase.ConvertAll(x => (Position)x) : PositionsAchatBase.ConvertAll(x => (Position)x));
 }
 internal PositionVenteBase(JsonArray jsonAsk, Monnaie mbase, Monnaie quote) : base(jsonAsk, mbase, quote)
 {
 }
 internal TradePivot(ValeurEchange veEURO, ValeurEchange veUSD) : base(2)
 {
     this.veEuro  = veEURO;
     this.veUSD   = veUSD;
     monnaiePivot = veEURO.MonnaieDeQuote == Monnaie.EURO ? veEURO.MonnaieDeBase : veEURO.MonnaieDeQuote;
 }
 internal Profondeur(Monnaie monnaieDeBase, Monnaie monnaieDeQuote)
 {
     this.monnaieDeBase  = monnaieDeBase;
     this.monnaieDeQuote = monnaieDeQuote;
 }
Beispiel #20
0
 internal Monnaie GetMonnaie(string idName)
 {
     return(Monnaie.GetMonnaie(idName));
 }
Beispiel #21
0
 internal Richesse(double qtte, Monnaie monnaie)
 {
     Quantite = qtte;
     Monnaie  = monnaie;
 }
 private Richesse GetRichesse(Monnaie monnaie)
 {
     return(_richesses[monnaie]);
 }