fez5587/Superalgos
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removing Current

Browse Source
This commit is contained in:
Luis Fernando Molina committed 2020-11-20 14:17:04 +01:00
1 parent d6c5e91290
commit a4ed878fcd
4379 files changed
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

TaskServer/node_modules/ccxt/js/rightbtc.js
Generated Vendored
+763
View File
@@ -0,0 +1,763 @@
'use strict';
const Exchange = require ('./base/Exchange');
const { ROUND } = require ('./base/functions/number');
const { ExchangeError, ArgumentsRequired, AuthenticationError, InsufficientFunds, InvalidOrder, OrderNotFound } = require ('./base/errors');
module.exports = class rightbtc extends Exchange {
describe () {
return this.deepExtend (super.describe (), {
'id': 'rightbtc',
'name': 'RightBTC',
'countries': [ 'AE' ],
'has': {
'privateAPI': false,
'fetchTickers': true,
'fetchOHLCV': true,
'fetchOrders': true,
'fetchOpenOrders': true,
'fetchClosedOrders': false,
'fetchOrder': 'emulated',
'fetchMyTrades': true,
},
'timeframes': {
'1m': 'min1',
'5m': 'min5',
'15m': 'min15',
'30m': 'min30',
'1h': 'hr1',
'1d': 'day1',
'1w': 'week',
},
'urls': {
'logo': 'https://user-images.githubusercontent.com/1294454/42633917-7d20757e-85ea-11e8-9f53-fffe9fbb7695.jpg',
'api': 'https://www.rightbtc.com/api',
'www': 'https://www.rightbtc.com',
'doc': [
'https://docs.rightbtc.com/api/',
],
// eslint-disable-next-line no-useless-escape
// 'fees': 'https://www.rightbtc.com/\#\!/support/fee',
},
'api': {
'public': {
'get': [
// 'getAssetsTradingPairs/zh', // 404
'trading_pairs',
'ticker/{trading_pair}',
'tickers',
'depth/{trading_pair}',
'depth/{trading_pair}/{count}',
'trades/{trading_pair}',
'trades/{trading_pair}/{count}',
'candlestick/latest/{trading_pair}',
'candlestick/{timeSymbol}/{trading_pair}',
'candlestick/{timeSymbol}/{trading_pair}/{count}',
],
},
'trader': {
'get': [
'balance/{symbol}',
'balances',
'deposits/{asset}/{page}',
'withdrawals/{asset}/{page}',
'orderpage/{trading_pair}/{cursor}',
'orders/{trading_pair}/{ids}', // ids are a slash-separated list of {id}/{id}/{id}/...
'history/{trading_pair}/{ids}',
'historys/{trading_pair}/{page}',
'trading_pairs',
],
'post': [
'order',
],
'delete': [
'order/{trading_pair}/{ids}',
],
},
},
// HARDCODING IS DEPRECATED, THE FEES BELOW SHOULD BE REWRITTEN
'fees': {
'trading': {
// min trading fees
// 0.0001 BTC
// 0.01 ETP
// 0.001 ETH
// 0.1 BITCNY
'maker': 0.1 / 100,
'taker': 0.2 / 100,
},
'funding': {
'withdraw': {
// 'BTM': n => 3 + n * (1 / 100),
// 'ZDC': n => 1 + n * (0.5 / 100),
// 'ZGC': n => 0.5 + n * (0.5 / 100),
// 'BTS': n => 1 + n * (1 / 100),
// 'DLT': n => 3 + n * (1 / 100),
// 'SNT': n => 10 + n * (1 / 100),
// 'XNC': n => 1 + n * (1 / 100),
// 'ICO': n => 3 + n * (1 / 100),
// 'CMC': n => 1 + n * (0.5 / 100),
// 'GXS': n => 0.2 + n * (1 / 100),
// 'OBITS': n => 0.3 + n * (1 / 100),
// 'ICS': n => 2 + n * (1 / 100),
// 'TIC': n => 2 + n * (1 / 100),
// 'IND': n => 20 + n * (1 / 100),
// 'MVC': n => 20 + n * (1 / 100),
// 'BitCNY': n => 0.1 + n * (1 / 100),
// 'MTX': n => 1 + n * (1 / 100),
'ETP': 0.01,
'BTC': 0.0005,
'ETH': 0.005,
'ETC': 0.01,
'STORJ': 3,
'LTC': 0.01,
'ZEC': 0.001,
'BCC': 0.001,
'XRB': 0,
'NXS': 0.1,
},
},
},
'commonCurrencies': {
'XRB': 'NANO',
},
'exceptions': {
'ERR_USERTOKEN_NOT_FOUND': AuthenticationError,
'ERR_ASSET_NOT_EXISTS': ExchangeError,
'ERR_ASSET_NOT_AVAILABLE': ExchangeError,
'ERR_BALANCE_NOT_ENOUGH': InsufficientFunds,
'ERR_CREATE_ORDER': InvalidOrder,
'ERR_CANDLESTICK_DATA': ExchangeError,
},
});
}
async fetchMarkets (params = {}) {
// let zh = await this.publicGetGetAssetsTradingPairsZh ();
const markets = await this.publicGetTradingPairs (params);
const marketIds = Object.keys (markets);
const result = [];
for (let i = 0; i < marketIds.length; i++) {
const id = marketIds[i];
const market = markets[id];
const baseId = this.safeString (market, 'bid_asset_symbol');
const quoteId = this.safeString (market, 'ask_asset_symbol');
const base = this.safeCurrencyCode (baseId);
const quote = this.safeCurrencyCode (quoteId);
const symbol = base + '/' + quote;
const precision = {
'amount': this.safeInteger (market, 'bid_asset_decimals'),
'price': this.safeInteger (market, 'ask_asset_decimals'),
};
result.push ({
'id': id,
'symbol': symbol,
'base': base,
'quote': quote,
'baseId': baseId,
'quoteId': quoteId,
'active': true,
'precision': precision,
'limits': {
'amount': {
'min': Math.pow (10, -precision['amount']),
'max': Math.pow (10, precision['price']),
},
'price': {
'min': Math.pow (10, -precision['price']),
'max': Math.pow (10, precision['price']),
},
'cost': {
'min': undefined,
'max': undefined,
},
},
'info': market,
});
}
return result;
}
divideSafeFloat (x, key, divisor) {
const value = this.safeFloat (x, key);
if (value !== undefined) {
return value / divisor;
}
return value;
}
parseTicker (ticker, market = undefined) {
const symbol = market['symbol'];
const timestamp = this.safeInteger (ticker, 'date');
const last = this.divideSafeFloat (ticker, 'last', 1e8);
const high = this.divideSafeFloat (ticker, 'high', 1e8);
const low = this.divideSafeFloat (ticker, 'low', 1e8);
const bid = this.divideSafeFloat (ticker, 'buy', 1e8);
const ask = this.divideSafeFloat (ticker, 'sell', 1e8);
const baseVolume = this.divideSafeFloat (ticker, 'vol24h', 1e8);
return {
'symbol': symbol,
'timestamp': timestamp,
'datetime': this.iso8601 (timestamp),
'high': high,
'low': low,
'bid': bid,
'bidVolume': undefined,
'ask': ask,
'askVolume': undefined,
'vwap': undefined,
'open': undefined,
'close': last,
'last': last,
'previousClose': undefined,
'change': undefined,
'percentage': undefined,
'average': undefined,
'baseVolume': baseVolume,
'quoteVolume': undefined,
'info': ticker,
};
}
async fetchTicker (symbol, params = {}) {
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
};
const response = await this.publicGetTickerTradingPair (this.extend (request, params));
const result = this.safeValue (response, 'result');
if (result === undefined) {
throw new ExchangeError (this.id + ' fetchTicker returned an empty response for symbol ' + symbol);
}
return this.parseTicker (result, market);
}
async fetchTickers (symbols = undefined, params = {}) {
await this.loadMarkets ();
const response = await this.publicGetTickers (params);
const tickers = response['result'];
const result = {};
for (let i = 0; i < tickers.length; i++) {
const ticker = tickers[i];
const id = ticker['market'];
if (!(id in this.marketsById)) {
continue;
}
const market = this.marketsById[id];
const symbol = market['symbol'];
result[symbol] = this.parseTicker (ticker, market);
}
return result;
}
async fetchOrderBook (symbol, limit = undefined, params = {}) {
await this.loadMarkets ();
const request = {
'trading_pair': this.marketId (symbol),
};
let method = 'publicGetDepthTradingPair';
if (limit !== undefined) {
method += 'Count';
request['count'] = limit;
}
const response = await this[method] (this.extend (request, params));
const bidsasks = {};
const types = ['bid', 'ask'];
for (let ti = 0; ti < types.length; ti++) {
const type = types[ti];
bidsasks[type] = [];
for (let i = 0; i < response['result'][type].length; i++) {
const [ price, amount, total ] = response['result'][type][i];
bidsasks[type].push ([
price / 1e8,
amount / 1e8,
total / 1e8,
]);
}
}
return this.parseOrderBook (bidsasks, undefined, 'bid', 'ask');
}
parseTrade (trade, market = undefined) {
//
// {
// "order_id": 118735,
// "trade_id": 7,
// "trading_pair": "BTCCNY",
// "side": "B",
// "quantity": 1000000000,
// "price": 900000000,
// "created_at": "2017-06-06T20:45:27.000Z"
// }
//
let timestamp = this.safeInteger (trade, 'date');
if (timestamp === undefined) {
timestamp = this.parse8601 (this.safeString (trade, 'created_at'));
}
let id = this.safeString (trade, 'tid');
id = this.safeString (trade, 'trade_id', id);
const orderId = this.safeString (trade, 'order_id');
const price = this.divideSafeFloat (trade, 'price', 1e8);
let amount = this.safeFloat (trade, 'amount');
amount = this.safeFloat (trade, 'quantity', amount);
if (amount !== undefined) {
amount = amount / 1e8;
}
let symbol = undefined;
if (market === undefined) {
const marketId = this.safeString (trade, 'trading_pair');
if (marketId in this.markets_by_id) {
market = this.markets_by_id[marketId];
}
}
if (market !== undefined) {
symbol = market['symbol'];
}
let cost = this.costToPrecision (symbol, price * amount);
cost = parseFloat (cost);
let side = this.safeStringLower (trade, 'side');
if (side === 'b') {
side = 'buy';
} else if (side === 's') {
side = 'sell';
}
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': this.iso8601 (timestamp),
'symbol': symbol,
'order': orderId,
'type': 'limit',
'side': side,
'takerOrMaker': undefined,
'price': price,
'amount': amount,
'cost': cost,
'fee': undefined,
};
}
async fetchTrades (symbol, since = undefined, limit = undefined, params = {}) {
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
};
const response = await this.publicGetTradesTradingPair (this.extend (request, params));
return this.parseTrades (response['result'], market, since, limit);
}
parseOHLCV (ohlcv, market = undefined, timeframe = '5m', since = undefined, limit = undefined) {
return [
parseInt (ohlcv[0]),
parseFloat (ohlcv[2]) / 1e8,
parseFloat (ohlcv[3]) / 1e8,
parseFloat (ohlcv[4]) / 1e8,
parseFloat (ohlcv[5]) / 1e8,
parseFloat (ohlcv[1]) / 1e8,
];
}
async fetchOHLCV (symbol, timeframe = '5m', since = undefined, limit = undefined, params = {}) {
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'timeSymbol': this.timeframes[timeframe],
};
const response = await this.publicGetCandlestickTimeSymbolTradingPair (this.extend (request, params));
return this.parseOHLCVs (response['result'], market, timeframe, since, limit);
}
async fetchBalance (params = {}) {
await this.loadMarkets ();
const response = await this.traderGetBalances (params);
//
// {
// "status": {
// "success": 1,
// "message": "GET_BALANCES"
// },
// "result": [
// {
// "asset": "ETP",
// "balance": "5000000000000",
// "frozen": "0",
// "state": "1"
// },
// {
// "asset": "CNY",
// "balance": "10000000000000",
// "frozen": "240790000",
// "state": "1"
// }
// ]
// }
//
const result = { 'info': response };
const balances = this.safeValue (response, 'result', []);
for (let i = 0; i < balances.length; i++) {
const balance = balances[i];
const currencyId = this.safeString (balance, 'asset');
const code = this.safeCurrencyCode (currencyId);
const account = this.account ();
// https://github.com/ccxt/ccxt/issues/3873
account['free'] = this.divideSafeFloat (balance, 'balance', 1e8);
account['used'] = this.divideSafeFloat (balance, 'frozen', 1e8);
result[code] = account;
}
return this.parseBalance (result);
}
async createOrder (symbol, type, side, amount, price = undefined, params = {}) {
await this.loadMarkets ();
const market = this.market (symbol);
const order = {
'trading_pair': market['id'],
// We need to use decimalToPrecision here, since
// 0.036*1e8 === 3599999.9999999995
// which would get truncated to 3599999 after parseInt
// which would then be rejected by rightBtc because it's too precise
'quantity': parseInt (this.decimalToPrecision (amount * 1e8, ROUND, 0, this.precisionMode)),
'limit': parseInt (this.decimalToPrecision (price * 1e8, ROUND, 0, this.precisionMode)),
'type': type.toUpperCase (),
'side': side.toUpperCase (),
};
const response = await this.traderPostOrder (this.extend (order, params));
return this.parseOrder (response);
}
async cancelOrder (id, symbol = undefined, params = {}) {
if (symbol === undefined) {
throw new ArgumentsRequired (this.id + ' cancelOrder requires a symbol argument');
}
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'ids': id,
};
const response = await this.traderDeleteOrderTradingPairIds (this.extend (request, params));
return response;
}
parseOrderStatus (status) {
const statuses = {
'NEW': 'open',
'TRADE': 'closed', // TRADE means filled or partially filled orders
'CANCEL': 'canceled',
};
return this.safeString (statuses, status, status);
}
parseOrder (order, market = undefined) {
//
// fetchOrder / fetchOpenOrders
//
// {
// "id": 4180528,
// "quantity": 20000000,
// "rest": 20000000,
// "limit": 1000000,
// "price": null,
// "side": "BUY",
// "created": 1496005693738
// }
//
// fetchOrders
//
// {
// "trading_pair": "ETPCNY",
// "status": "TRADE",
// "fee": 0.23,
// "min_fee": 10000000,
// "created_at": "2017-05-25T00:12:27.000Z",
// "cost": 1152468000000,
// "limit": 3600000000,
// "id": 11060,
// "quantity": 32013000000,
// "filled_quantity": 32013000000
// }
//
const id = this.safeString (order, 'id');
const status = this.parseOrderStatus (this.safeString (order, 'status'));
const marketId = this.safeString (order, 'trading_pair');
if (market === undefined) {
if (marketId in this.markets_by_id) {
market = this.markets_by_id[marketId];
}
}
let symbol = marketId;
if (market !== undefined) {
symbol = market['symbol'];
}
let timestamp = this.safeInteger (order, 'created');
if (timestamp === undefined) {
timestamp = this.parse8601 (this.safeString (order, 'created_at'));
}
if ('time' in order) {
timestamp = order['time'];
} else if ('transactTime' in order) {
timestamp = order['transactTime'];
}
let price = this.safeFloat2 (order, 'limit', 'price');
if (price !== undefined) {
price = price / 1e8;
}
const amount = this.divideSafeFloat (order, 'quantity', 1e8);
let filled = this.divideSafeFloat (order, 'filled_quantity', 1e8);
let remaining = this.divideSafeFloat (order, 'rest', 1e8);
const cost = this.divideSafeFloat (order, 'cost', 1e8);
// lines 483-494 should be generalized into a base class method
if (amount !== undefined) {
if (remaining === undefined) {
if (filled !== undefined) {
remaining = Math.max (0, amount - filled);
}
}
if (filled === undefined) {
if (remaining !== undefined) {
filled = Math.max (0, amount - remaining);
}
}
}
const type = 'limit';
const side = this.safeStringLower (order, 'side');
const feeCost = this.divideSafeFloat (order, 'min_fee', 1e8);
let fee = undefined;
if (feeCost !== undefined) {
let feeCurrency = undefined;
if (market !== undefined) {
feeCurrency = market['quote'];
}
fee = {
'rate': this.safeFloat (order, 'fee'),
'cost': feeCost,
'currency': feeCurrency,
};
}
const trades = undefined;
return {
'info': order,
'id': id,
'clientOrderId': undefined,
'timestamp': timestamp,
'datetime': this.iso8601 (timestamp),
'lastTradeTimestamp': undefined,
'symbol': symbol,
'type': type,
'side': side,
'price': price,
'amount': amount,
'cost': cost,
'filled': filled,
'remaining': remaining,
'status': status,
'fee': fee,
'trades': trades,
'average': undefined,
};
}
async fetchOrder (id, symbol = undefined, params = {}) {
if (symbol === undefined) {
throw new ArgumentsRequired (this.id + ' fetchOrder requires a symbol argument');
}
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'ids': id,
};
const response = await this.traderGetOrdersTradingPairIds (this.extend (request, params));
//
// let response = {
// "status": {
// "success": 1,
// "message": "SUC_LIST_AVTICE_ORDERS"
// },
// "result": [
// {
// "id": 4180528,
// "quantity": 20000000,
// "rest": 20000000,
// "limit": 1000000,
// "price": null,
// "side": "BUY",
// "created": 1496005693738
// }
// ]
// }
//
const orders = this.parseOrders (response['result'], market);
const ordersById = this.indexBy (orders, 'id');
if (!(id in ordersById)) {
throw new OrderNotFound (this.id + ' fetchOrder could not find order ' + id.toString () + ' in open orders.');
}
return ordersById[id];
}
async fetchOpenOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
if (symbol === undefined) {
throw new ArgumentsRequired (this.id + ' fetchOpenOrders requires a symbol argument');
}
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'cursor': 0,
};
const response = await this.traderGetOrderpageTradingPairCursor (this.extend (request, params));
//
// let response = {
// "status": {
// "success": 1,
// "message": "SUC_LIST_AVTICE_ORDERS_PAGE"
// },
// "result": {
// "cursor": "0",
// "orders": [
// {
// "id": 4180528,
// "quantity": 20000000,
// "rest": 20000000,
// "limit": 1000000,
// "price": null,
// "side": "BUY",
// "created": 1496005693738
// }
// ]
// }
// }
//
return this.parseOrders (response['result']['orders'], market, since, limit);
}
async fetchOrders (symbol = undefined, since = undefined, limit = undefined, params = {}) {
let ids = this.safeString (params, 'ids');
if ((symbol === undefined) || (ids === undefined)) {
throw new ArgumentsRequired (this.id + " fetchOrders requires a 'symbol' argument and an extra 'ids' parameter. The 'ids' should be an array or a string of one or more order ids separated with slashes."); // eslint-disable-line quotes
}
if (Array.isArray (ids)) {
ids = ids.join ('/');
}
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'ids': ids,
};
const response = await this.traderGetHistoryTradingPairIds (this.extend (request, params));
//
// let response = {
// "status": {
// "success": 1,
// "message": null
// },
// "result": [
// {
// "trading_pair": "ETPCNY",
// "status": "TRADE",
// "fee": 0.23,
// "min_fee": 10000000,
// "created_at": "2017-05-25T00:12:27.000Z",
// "cost": 1152468000000,
// "limit": 3600000000,
// "id": 11060,
// "quantity": 32013000000,
// "filled_quantity": 32013000000
// }
// ]
// }
//
return this.parseOrders (response['result'], undefined, since, limit);
}
async fetchMyTrades (symbol = undefined, since = undefined, limit = undefined, params = {}) {
if (symbol === undefined) {
throw new ArgumentsRequired (this.id + ' fetchMyTrades requires a symbol argument');
}
await this.loadMarkets ();
const market = this.market (symbol);
const request = {
'trading_pair': market['id'],
'page': 0,
};
const response = await this.traderGetHistorysTradingPairPage (this.extend (request, params));
//
// let response = {
// "status": {
// "success": 1,
// "message": null
// },
// "result": [
// {
// "order_id": 118735,
// "trade_id": 7,
// "trading_pair": "BTCCNY",
// "side": "B",
// "quantity": 1000000000,
// "price": 900000000,
// "created_at": "2017-06-06T20:45:27.000Z"
// },
// {
// "order_id": 118734,
// "trade_id": 7,
// "trading_pair": "BTCCNY",
// "side": "S",
// "quantity": 1000000000,
// "price": 900000000,
// "created_at": "2017-06-06T20:45:27.000Z"
// }
// ]
// }
//
return this.parseTrades (response['result'], undefined, since, limit);
}
sign (path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
const query = this.omit (params, this.extractParams (path));
let url = this.urls['api'] + '/' + api + '/' + this.implodeParams (path, params);
if (api === 'public') {
if (Object.keys (query).length) {
url += '?' + this.urlencode (query);
}
} else {
this.checkRequiredCredentials ();
headers = {
'apikey': this.apiKey,
'signature': this.secret,
};
if (method === 'GET') {
if (Object.keys (query).length) {
url += '?' + this.urlencode (query);
}
} else {
body = this.json (query);
headers['Content-Type'] = 'application/json';
}
}
return { 'url': url, 'method': method, 'body': body, 'headers': headers };
}
handleErrors (httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {
if (response === undefined) {
return; // fallback to default error handler
}
const status = this.safeValue (response, 'status');
if (status !== undefined) {
//
// {"status":{"success":0,"message":"ERR_USERTOKEN_NOT_FOUND"}}
//
const success = this.safeString (status, 'success');
if (success !== '1') {
const message = this.safeString (status, 'message');
const feedback = this.id + ' ' + body;
this.throwExactlyMatchedException (this.exceptions, message, feedback);
throw new ExchangeError (feedback);
}
}
}
};