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();
}
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));
}
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);
}
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));
}
}
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));
}
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;
}
internal Monnaie GetMonnaie(string idName)
{
return(Monnaie.GetMonnaie(idName));
}
internal Richesse(double qtte, Monnaie monnaie)
{
Quantite = qtte;
Monnaie = monnaie;
}
private Richesse GetRichesse(Monnaie monnaie)
{
return(_richesses[monnaie]);
}
