text: 'use strict';
  
  // ---------------------------------------------------------------------------
  
  const bittrex = require ('./bittrex.js');
  const { ExchangeError, AuthenticationError, InvalidOrder, InsufficientFunds } = require ('./base/errors');
  
  // ---------------------------------------------------------------------------
  
  module.exports = class bleutrade extends bittrex {
      describe () {
          return this.deepExtend (super.describe (), {
              'id': 'bleutrade',
              'name': 'Bleutrade',
              'countries': [ 'BR' ], // Brazil
              'rateLimit': 1000,
              'version': 'v2',
              'certified': false,
              'has': {
                  'CORS': true,
                  'fetchTickers': true,
                  'fetchOrders': true,
                  'fetchClosedOrders': true,
              },
              'urls': {
                  'logo': 'https://user-images.githubusercontent.com/1294454/30303000-b602dbe6-976d-11e7-956d-36c5049c01e7.jpg',
                  'api': {
                      'public': 'https://bleutrade.com/api',
                      'account': 'https://bleutrade.com/api',
                      'market': 'https://bleutrade.com/api',
                  },
                  'www': 'https://bleutrade.com',
                  'doc': 'https://bleutrade.com/help/API',
                  'fees': 'https://bleutrade.com/help/fees_and_deadlines',
              },
              'fees': {
                  'funding': {
                      'withdraw': {
                          'ADC': 0.1,
                          'BTA': 0.1,
                          'BITB': 0.1,
                          'BTC': 0.001,
                          'BCC': 0.001,
                          'BTCD': 0.001,
                          'BTG': 0.001,
                          'BLK': 0.1,
                          'CDN': 0.1,
                          'CLAM': 0.01,
                          'DASH': 0.001,
                          'DCR': 0.05,
                          'DGC': 0.1,
                          'DP': 0.1,
                          'DPC': 0.1,
                          'DOGE': 10.0,
                          'EFL': 0.1,
                          'ETH': 0.01,
                          'EXP': 0.1,
                          'FJC': 0.1,
                          'BSTY': 0.001,
                          'GB': 0.1,
                          'NLG': 0.1,
                          'HTML': 1.0,
                          'LTC': 0.001,
                          'MONA': 0.01,
                          'MOON': 1.0,
                          'NMC': 0.015,
                          'NEOS': 0.1,
                          'NVC': 0.05,
                          'OK': 0.1,
                          'PPC': 0.1,
                          'POT': 0.1,
                          'XPM': 0.001,
                          'QTUM': 0.1,
                          'RDD': 0.1,
                          'SLR': 0.1,
                          'START': 0.1,
                          'SLG': 0.1,
                          'TROLL': 0.1,
                          'UNO': 0.01,
                          'VRC': 0.1,
                          'VTC': 0.1,
                          'XVP': 0.1,
                          'WDC': 0.001,
                          'ZET': 0.1,
                      },
                  },
              },
              'commonCurrencies': {
                  'EPC': 'Epacoin',
              },
              'exceptions': {
                  'Insufficient funds!': InsufficientFunds,
                  'Invalid Order ID': InvalidOrder,
                  'Invalid apikey or apisecret': AuthenticationError,
              },
              'options': {
                  'parseOrderStatus': true,
              },
          });
      }
  
      async fetchMarkets () {
          let markets = await this.publicGetMarkets ();
          let result = [];
          for (let p = 0; p < markets['result'].length; p++) {
              let market = markets['result'][p];
              let id = market['MarketName'];
              let baseId = market['MarketCurrency'];
              let quoteId = market['BaseCurrency'];
              let base = this.commonCurrencyCode (baseId);
              let quote = this.commonCurrencyCode (quoteId);
              let symbol = base + '/' + quote;
              let precision = {
                  'amount': 8,
                  'price': 8,
              };
              let active = this.safeString (market, 'IsActive');
              if (active === 'true') {
                  active = true;
              } else if (active === 'false') {
                  active = false;
              }
              result.push ({
                  'id': id,
                  'symbol': symbol,
                  'base': base,
                  'quote': quote,
                  'baseId': baseId,
                  'quoteId': quoteId,
                  'active': active,
                  'info': market,
                  'precision': precision,
                  'limits': {
                      'amount': {
                          'min': market['MinTradeSize'],
                          'max': undefined,
                      },
                      'price': {
                          'min': undefined,
                          'max': undefined,
                      },
                      'cost': {
                          'min': 0,
                          'max': undefined,
                      },
                  },
              });
          }
          return result;
      }
  
      parseOrderStatus (status) {
          let statuses = {
              'OK': 'closed',
              'OPEN': 'open',
              'CANCELED': 'canceled',
          };
          if (status in statuses) {
              return statuses[status];
          } else {
              return status;
          }
      }
  
      async fetchOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
          // Possible params
          // orderstatus (ALL, OK, OPEN, CANCELED)
          // ordertype (ALL, BUY, SELL)
          // depth (optional, default is 500, max is 20000)
          await this.loadMarkets ();
          let market = undefined;
          if (typeof symbol !== 'undefined') {
              await this.loadMarkets ();
              market = this.market (symbol);
          } else {
              market = undefined;
          }
          let response = await this.accountGetOrders (this.extend ({ 'market': 'ALL', 'orderstatus': 'ALL' }, params));
          return this.parseOrders (response['result'], market, since, limit);
      }
  
      async fetchClosedOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
          let response = await this.fetchOrders (symbol, since, limit, params);
          return this.filterBy (response, 'status', 'closed');
      }
  
      getOrderIdField () {
          return 'orderid';
      }
  
      async fetchOrderBook (symbol, limit = undefined, params = {}) {
          await this.loadMarkets ();
          let request = {
              'market': this.marketId (symbol),
              'type': 'ALL',
          };
          if (typeof limit !== 'undefined')
              request['depth'] = limit; // 50
          let response = await this.publicGetOrderbook (this.extend (request, params));
          let orderbook = this.safeValue (response, 'result');
          if (!orderbook)
              throw new ExchangeError (this.id + ' publicGetOrderbook() returneded no result ' + this.json (response));
          return this.parseOrderBook (orderbook, undefined, 'buy', 'sell', 'Rate', 'Quantity');
      }
  };
  