public Order Convert(TradingPair pair)
{
return(new Order(
Conversion.ToDecimalInvariant(Amount),
pair,
Id.ToString(),
Conversion.ToDecimalInvariant(Price),
Type == 0 ? OrderType.Buy : OrderType.Sell,
Conversion.ToDateTimeInvariant(Datetime),
ExchangeType.BitStamp
));
}
/// <summary>
/// Scans all trading pairs for a coin to find the best offer
/// which meets the criteria specified.
/// </summary>
/// <param name="onlyOnTheseExchanges">
/// If specified, only consider trades on one of these exchanges
/// </param>
public static TradingPair FindBestOffer(
this Coin quoteCoin,
Coin baseCoin,
OrderType orderType,
ExchangeName[] onlyOnTheseExchanges = null)
{
TradingPair bestPair = null;
decimal? bestValue = null;
foreach (TradingPair pair in quoteCoin.allTradingPairs)
{
if (onlyOnTheseExchanges != null)
{ // Filter by exchange (optional)
for (int i = 0; i < onlyOnTheseExchanges.Length; i++)
{
if (pair.exchange.exchangeName != onlyOnTheseExchanges[i])
{
continue;
}
}
}
if (pair.baseCoin != baseCoin)
{ // Filter by baseCoin
continue;
}
if (pair.isInactive)
{ // Ignore inactive pairs
continue;
}
decimal value = orderType == OrderType.Buy
? pair.askPriceOrOfferYouCanBuy
: pair.bidPriceOrOfferYouCanSell;
if (value <= 0)
{ // No bid/ask to consider here
continue;
}
if (bestValue == null ||
orderType == OrderType.Buy && value < bestValue.Value ||
orderType == OrderType.Sell && value > bestValue.Value)
{
bestValue = value;
bestPair = pair;
}
}
return(bestPair);
}
public void StandardMovingAverageFourCandles()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 15
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 4);
var sma = candles.StandardMovingAverage();
Assert.Equal(6.5525M, sma);
}
public void ConstructorHappyFlow()
{
var left = new Currency("BNB");
var right = new Currency("ETH");
int quantityDecimals = 1;
int priceDecimals = 2;
var pair = new TradingPair(left, right, quantityDecimals, priceDecimals);
Assert.Equal(left, pair.Left);
Assert.Equal(right, pair.Right);
Assert.Equal(quantityDecimals, pair.QuantityDecimals);
Assert.Equal(priceDecimals, pair.PriceDecimals);
}
public async Task LastTrade()
{
CrypnosticConfig config = new CrypnosticConfig(exchangeName);
monitor = new CrypnosticController(config);
await monitor.StartAsync();
TradingPair tradingPair = popularQuoteCoin.GetTradingPair(popularBaseCoin, exchangeName);
LastTrade lastTrade = tradingPair.lastTrade;
await lastTrade.RefreshAsync();
Assert.IsTrue(lastTrade.price > 0);
}
public void AverageTrueRangeSingleEdge()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 25
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2);
var atr = candles.AverageTrueRange();
Assert.Equal(2.6M, atr);
}
private static OrderUpdate GetSomeOrder(OrderTypes type, decimal setPrice = 0)
{
return(new OrderUpdate(
orderId: 0,
tradeId: 0,
orderStatus: OrderUpdate.OrderStatus.Filled,
orderType: type,
createdTimestamp: 0,
setPrice: setPrice,
side: OrderSide.Buy,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 0));
}
public Tick Convert(TradingPair pair)
{
return(new Tick(
Conversion.ToDecimalInvariant(ask),
Conversion.ToDecimalInvariant(bid),
Conversion.ToDecimalInvariant(price),
Conversion.ToDecimalInvariant(volume),
pair,
ExchangeType.Gdax,
(long)time.ToUnixTime()));
/*{"trade_id":6442532,"price":"372.63","size":"0.31379","bid":"372.54","ask":"372.64","volume":"6866.60379037","time":"2016-02-03T01:05:02.047318Z"}*/
}
/// <summary>
/// Initializes a new instance of the <see cref="Startup"/> class.
/// Sets configuration.
/// </summary>
/// <param name="filepath">Location of the configuration file.</param>
public Startup(string filepath)
{
// Download all currencies from Binance
TradingPair.Sync();
using (var file = new StreamReader(filepath))
{
var configuration = new DeserializerBuilder()
.Build()
.Deserialize <Configuration>(file);
configuration.Bind();
ConfigurationValidator.ValidateConstraintsRecursively(configuration);
}
}
public void GetCustomCandlesNoPivotThirtyMinutes()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 30
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 2);
Assert.Equal(5.6M, candles[0].Close);
Assert.Equal(5.7M, candles[1].Close);
}
/// <inheritdoc/>
public override ResponseObject <decimal> GetCurrentPriceLastTrade(TradingPair pair)
{
var client = _communications.Client;
var response = client.GetPrice(pair.ToString());
if (!response.Success)
{
Logger.LogWarning($"Could not fetch price for {pair} from binance");
return(new ResponseObject <decimal>(ResponseCode.Error));
}
return(new ResponseObject <decimal>(ResponseCode.Success, response.Data.Price));
}
public void GetCandlesTimestampIncreasing(int limit)
{
var candles = _container.DataProvider.GetCandles(
TradingPair.Parse("EOSETH"),
limit);
var increment = (long)TimeSpan.FromMinutes((int)Configuration.Instance.CandleWidth).TotalMilliseconds;
var diffs = candles.Pairwise((a, b) => b.OpenTimestamp - a.OpenTimestamp);
foreach (var diff in diffs)
{
Assert.Equal(increment, diff);
}
}
public BExError Convert(TradingPair pair)
{
var sb = new StringBuilder();
foreach (var line in error.__all__)
{
sb.Append(line);
}
return(new BExError(ExchangeType.BitStamp)
{
Message = sb.ToString()
});
}
static void Main(string[] args)
{
Console.WriteLine("CryptoSharp Sample");
var adapter = new BittrexAdapter(new BittrexClient());
var tradingPair = new TradingPair("ETH", "BTC");
var ticker = adapter.GetTickerAsync(tradingPair).Result;
Console.WriteLine(ticker);
Console.ReadKey();
}
public void GetCustomCandlesMultiple()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 15
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderHappyFlowImplementation>(config);
var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 3);
Assert.Equal(8.01M, candles[0].Close);
Assert.Equal(5.6M, candles[1].Close);
Assert.Equal(6.9M, candles[2].Close);
}
public void HighestHighIsMaximumOfCandleHighs()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 5
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProvider <DataProviderGetCandlesImplementation>(config);
var pair = TradingPair.Parse("EOSETH");
var candles = data.GetCandles(pair, 1300);
var highestHigh = data.GetHighestHigh(pair, 1300);
Assert.Equal(candles.Max(x => x.High), highestHigh);
}
public void LowestLowIsMaximumOfCandleLows()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 5
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProvider <DataProviderGetCandlesImplementation>(config);
var pair = TradingPair.Parse("EOSETH");
var candles = data.GetCandles(pair, 1300);
var lowestLow = data.GetLowestLow(pair, 1300);
Assert.Equal(candles.Min(x => x.Low), lowestLow);
}
/// <summary>
/// Get converted information for all trading pairs
/// </summary>
/// <param name="service">BuzzexDotNet service</param>
/// <returns>Collection of TradingPair objects</returns>
public static async Task <List <TradingPair> > GetAllInfoConverted(this IBuzzexDotNet service)
{
var pairs = await GetAllInfo(service);
var tradingPairs = new List <TradingPair>();
foreach (var pair in pairs)
{
var tradingPair = new TradingPair(pair.Key, pair.Value);
tradingPairs.Add(tradingPair);
}
return(tradingPairs);
}
/// <summary>
/// Get a certain number of minute candles ordered from present -> past.
/// </summary>
/// <param name="pair">TradingPair.</param>
/// <param name="numberOfCandles">Number of minute candles to request (>0).</param>
/// <returns>Array of candles.</returns>
public BacktestingCandle[] GetCandles(TradingPair pair, int numberOfCandles)
{
Guard.Argument(pair).NotNull(nameof(pair));
Guard.Argument(numberOfCandles).NotZero().NotNegative();
var query = HelperMethods.RetryMethod(
() => Implementation.GetCustomCandles(pair, numberOfCandles, CandleWidth), _logger, 5, 1000);
return(query.Success
? query.Data.Length == numberOfCandles
? query.Data
: throw new InvalidExchangeDataException($"Requested {numberOfCandles} candles but received {query.Data.Length}")
: throw new ExchangeConnectionException(query.Message));
}
/// <summary>
/// Place a sell market order using the full allocation.
/// </summary>
/// <param name="pair">TradingPair to consider.</param>
/// <param name="portion">The portion of funds to use (0 ... 1).</param>
/// <returns>ResponseObject with an OrderUpdate.</returns>
public OrderUpdate ExecutePartialMarketOrderSell(TradingPair pair, decimal portion)
{
Guard.Argument(pair).NotNull(nameof(pair));
Guard.Argument(portion).NotZero(nameof(portion)).NotNegative().InRange(0M, 1M);
var currency = pair.Left;
var balance = _allocationManager.GetAvailableFunds(currency).Free *portion;
if (balance == 0.0M)
{
throw new OutOfFundsException();
}
return(ExecuteMarketOrderSell(pair, balance));
}
/// <summary>
/// Constructor for service
/// </summary>
public TradingForexService()
{
ForexTradingContext forexTradingContext = new ForexTradingContext();
_clients = new Dictionary <ITradingForexClient, KeyValuePair <string, TradingPair> >();
logs = new Queue <string>();
_defaultTradingPair = (from x in forexTradingContext.TraidingPairs select x).FirstOrDefault();
System.Timers.Timer aTimer = new System.Timers.Timer();
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
aTimer.Interval = 500;
aTimer.Enabled = true;
}
/// <summary>
/// Place a buy market order given a non base quantity.
/// </summary>
/// <param name="pair">TradingPair to consider.</param>
/// <param name="quantity">Quantity of non base currency.</param>
/// <returns>ResponseObject containing an OrderUpdate.</returns>
public OrderUpdate ExecuteMarketOrderBuy(TradingPair pair, decimal quantity)
{
_logger.LogDebug($"Executing buy market order with pair {pair}, quantity {quantity}");
Guard.Argument(pair).NotNull(nameof(pair));
Guard.Argument(quantity).NotZero(nameof(quantity)).NotNegative();
var currency = pair.Right;
var priceEstimate = _dataProvider.GetCurrentPriceTopAsk(pair);
var proposal = new TradeProposal(pair, new Balance(currency, quantity * priceEstimate, 0));
var result = _allocationManager.QueueTrade(proposal, () =>
{
var orderQuery = HelperMethods.RetryMethod(
() =>
{
var attempt = Implementation.ExecuteMarketOrder(pair, OrderSide.Buy, quantity, TradeId);
if (attempt.Success)
{
return(attempt);
}
_logger.LogInformation($"Retrying with slightly lower quantity");
quantity *= 0.999M;
return(new ResponseObject <OrderUpdate>(ResponseCode.Error, attempt.Message));
}, _logger);
if (orderQuery.Success)
{
_openOrders.Add(orderQuery.Data.OrderId, orderQuery.Data);
return(WaitForOrderStatus(orderQuery.Data.OrderId, OrderUpdate.OrderStatus.Filled));
}
throw new OrderFailedException(orderQuery.Message);
});
if (!result.Success)
{
throw new OrderRefusedException(result.Message);
}
if (Program.CommandLineArgs.Trading)
{
_logger.LogInformation($"Executed Market Buy: {JsonConvert.SerializeObject(result)}");
}
return(result.Data
.IsBuy()
.IsMarket()
.IsFilled());
}
internal void ParseFromMarketCancelledOrderInvalid(OrderSide side)
{
var order = new OrderUpdate(
orderId: 0,
tradeId: 0,
orderType: Market,
orderStatus: Cancelled,
createdTimestamp: 0,
setPrice: 0.2M,
side: side,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 100M);
Assert.Throws <ArgumentException>(() => TradeExecution.FromOrder(order));
}
/// <inheritdoc/>
public override ResponseObject <decimal> GetCurrentPriceTopAsk(TradingPair pair)
{
var client = _communications.Client;
var response = client.GetOrderBook(pair.ToString());
if (!response.Success)
{
Logger.LogWarning($"Could not fetch top ask for {pair} from binance");
return(new ResponseObject <decimal>(ResponseCode.Error));
}
decimal ret = response.Data.Asks.Min(x => x.Price);
return(new ResponseObject <decimal>(ResponseCode.Success, ret));
}
/// <inheritdoc />
public override ResponseObject CancelOrder(TradingPair pair, long orderId)
{
var client = _communications.Client;
var query = client.CancelOrder(
symbol: pair.ToString(),
orderId: orderId,
origClientOrderId: null,
newClientOrderId: null,
receiveWindow: _communications.ReceiveWindow);
return(query.Success
? new ResponseObject(ResponseCode.Success)
: new ResponseObject(BinanceUtilities.ToInternalError(query.Error.Code), query.Error.Message));
}
public void AverageTrueRangeMultipleEdges()
{
const string source = @"
TradingPairs: [EOSETH]
CandleWidth: 15
";
var config = ParseAlgorithmConfiguration(source);
var data = GetDataProviderWithTimer <DataProviderImplementation, TimerProviderNoPivotImplementation>(config);
var candles = data.GetCandles(TradingPair.Parse("EOSETH"), 4);
Logger.LogCritical(JsonConvert.SerializeObject(candles));
var atr = candles.AverageTrueRange();
Assert.Equal(2.2666666666666666666666666667M, atr);
}
/// <summary>
/// Place a buy market order using the full allocation.
/// </summary>
/// <param name="pair">TradingPair to consider.</param>
/// <param name="portion">The portion of funds to use, (0 ... 1).</param>
/// <returns>ResponseObject with an OrderUpdate.</returns>
public OrderUpdate ExecutePartialMarketOrderBuy(TradingPair pair, decimal portion)
{
Guard.Argument(pair).NotNull();
Guard.Argument(portion).NotZero().NotNegative().InRange(0, 1);
var currency = pair.Right;
var balance = _allocationManager.GetAvailableFunds(currency);
var quantity = GetBuyQuantityEstimate(pair, balance.Free) * portion;
if (quantity == 0.0M)
{
throw new OutOfFundsException();
}
return(ExecuteMarketOrderBuy(pair, quantity));
}
/// <summary>
/// Place a sell stoploss order with the full allocation.
/// </summary>
/// <param name="pair">Trading pair.</param>
/// <param name="price">Price to set the order at.</param>
/// <param name="portion">The portion of funds to use.</param>
/// <returns>ResponseObject containing an OrderUpdate.</returns>
public OrderUpdate PlacePartialStoplossSell(TradingPair pair, decimal price, decimal portion)
{
Guard.Argument(pair).NotNull(nameof(pair));
Guard.Argument(price).NotZero(nameof(price)).NotNegative();
Guard.Argument(portion).NotZero(nameof(portion)).NotNegative().InRange(0M, 1M);
var currency = pair.Left;
decimal quantity = _allocationManager.GetAvailableFunds(currency).Free *portion;
if (quantity == 0.0M)
{
throw new OutOfFundsException();
}
return(PlaceStoplossSell(pair, quantity, price));
}
public void AddParseEntryOverwrites()
{
var pre = GetTradingPair("BNB", "ETH", 0, 0);
TradingPair.AddParseEntry("BNBETH", pre);
var post = GetTradingPair("BNB", "ETH", 1, 1);
TradingPair.AddParseEntry("BNBETH", post);
var postParse = TradingPair.Parse("BNBETH");
Assert.NotEqual(pre.QuantityDecimals, postParse.QuantityDecimals);
Assert.NotEqual(pre.PriceDecimals, postParse.PriceDecimals);
}
/// <summary>
///
/// </summary>
/// <param name="response"></param>
/// <returns></returns>
private static List <TradingPair> ConvertTradingPairs(List <Dictionary <string, TradingPairBase> > response)
{
var pairList = new List <TradingPair>();
foreach (var item in response)
{
foreach (var kvp in item)
{
var tradingPair = new TradingPair(kvp.Key, kvp.Value);
pairList.Add(tradingPair);
}
}
return(pairList);
}
