Files
Superalgos/BinanceClient.js
T

541 lines
22 KiB
JavaScript

exports.newBinanceAPIClient = function newBinanceAPIClient(pKey, pSecret, logger) {
const FULL_LOG = true;
const LOG_FILE_CONTENT = true;
const MODULE_NAME = "Binance API Client";
// MAX Decimal numers: 6
/*
/* ATENTION: This Library is used both a the cloud (AACloud) and also at the AAWeb on the server side without any modifications.
/* There is a second version, stripped of all the inner functionality that runs at AAWeb browser side, which channels the requests to the server side one.
/*
/* Documentation @ https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md
/* @ https://support.binance.com/hc/en-us/articles/115000594711-Trading-Rule
*/
let EMPTY_RESPONSE = "";
let NOT_IMPLEMENTED = "Method not implemented yet.";
let newFunction = new API(pKey, pSecret);
let thisObject = {
API: newFunction
};
return thisObject;
function API(key, secret) {
'use strict';
// Module dependencies
var crypto = require('crypto'),
request = require('request');
// Constants
var recvWindow = '10000',
API_URL = 'https://api.binance.com';
// Helper methods
function joinCurrencies(currencyA, currencyB) {
// If only one arg, then return the first
if (typeof currencyB !== 'string') {
return currencyA;
}
return currencyB + '' + currencyA;
}
function getDate() {
let localDate = new Date();
let date = new Date(Date.UTC(
localDate.getUTCFullYear(),
localDate.getUTCMonth(),
localDate.getUTCDate(),
localDate.getUTCHours(),
localDate.getUTCMinutes(),
localDate.getUTCSeconds(),
localDate.getUTCMilliseconds()));
return date.valueOf();
}
function truncDecimals(pFloatValue) {
return parseFloat(parseFloat(pFloatValue).toFixed(6));
}
// Generate headers signed by thisObject user's key and secret.
// The secret is encapsulated and never exposed
function _getSignature(parameters) {
var paramString, signature;
if (!key || !secret) {
throw 'Binance: Error. API key and secret required';
}
// Convert to `arg1=foo&arg2=bar`
paramString = Object.keys(parameters).map(function (param) {
return encodeURIComponent(param) + '=' + encodeURIComponent(parameters[param]);
}).join('&');
signature = crypto.createHmac('sha256', secret).update(paramString).digest('hex');
return {
signature: signature
};
};
// Currently, thisObject fails with `Error: CERT_UNTRUSTED`
// Binance.STRICT_SSL can be set to `false` to avoid thisObject. Use with caution.
// Will be removed in future, once thisObject is resolved.
const STRICT_SSL = true;
// Prototype
let thisObject = {
// Make an API request
_request: function (options, callback) {
if (!('headers' in options)) {
options.headers = {};
}
options.json = true;
options.headers['X-MBX-APIKEY'] = key;
options.strictSSL = STRICT_SSL;
if (LOG_FILE_CONTENT === true) { logger.write(MODULE_NAME, "[INFO] request -> options = " + JSON.stringify(options)); }
request(options, function (err, response, body) {
if (LOG_FILE_CONTENT === true) { logger.write(MODULE_NAME, "[INFO] response -> err = " + JSON.stringify(err) + ". response: " + JSON.stringify(response) + ". body:" + JSON.stringify(body)); }
// Empty response
if (!err && (typeof body === 'undefined' || body === null)) {
err = 'Empty response';
}
thisObject.analizeResponse(err, body, callback);
});
return thisObject;
},
// Make an API request MARKET_DATA or USER_STREAM: Endpoint requires sending a valid API-Key.
_public: function (command, parameters, callback) {
var options;
if (typeof parameters === 'function') {
callback = parameters;
parameters = {};
}
parameters || (parameters = {});
options = {
method: 'GET',
url: API_URL + command,
qs: parameters
};
return thisObject._request(options, callback);
},
// Make an API request MARKET_DATA or USER_STREAM: Endpoint requires sending a valid API-Key.
_signed: function (command, parameters, callback) {
var options;
if (typeof parameters === 'function') {
callback = parameters;
parameters = {};
}
parameters || (parameters = {});
options = {
method: 'GET',
url: API_URL + command,
qs: parameters
};
options.qs.signature = _getSignature(parameters).signature;
return thisObject._request(options, callback);
},
// Make an API request TRADE or USER_DATA: Endpoint requires sending a valid API-Key and signature.
_private: function (command, parameters, callback, pMethod) {
var options;
let method;
if (typeof parameters === 'function') {
callback = parameters;
parameters = {};
}
if (pMethod === 'DELETE') {
method = pMethod;
} else {
method = 'POST'; // Default value
}
parameters || (parameters = {});
options = {
method: method,
url: API_URL + command,
form: parameters,
qs: _getSignature(parameters)
};
return thisObject._request(options, callback);
},
/////// NON SIGNED METHODS
returnTicker: function (currencyA, currencyB, callback) {
var parameters = {
symbol: joinCurrencies(currencyA, currencyB)
};
thisObject._public('/api/v1/ticker/24hr', parameters, processResponse);
function processResponse(err, response) {
let ticker;
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
ticker = {
bid: Number(response.bidPrice),
ask: Number(response.askPrice),
last: Number(response.lastPrice)
};
}
callback(err, ticker);
}
},
return24hVolume: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED , callback);
},
returnOrderBook: function (currencyA, currencyB, depth, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnOrderBooks: function (depth, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnPublicTradeHistory: function (currencyA, currencyB, start, end, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnChartData: function (currencyA, currencyB, period, start, end, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnCurrencies: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnLoanOrders: function (currency, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
/////// SIGNED METHODS
returnBalances: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnCompleteBalances: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnDepositAddresses: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
generateNewAddress: function (currency, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnDepositsWithdrawals: function (start, end, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnOpenOrders: function (currencyA, currencyB, callback) {
var parameters = {
symbol: joinCurrencies(currencyA, currencyB),
recvWindow: recvWindow,
timestamp: getDate().valueOf()
};
thisObject._signed('/api/v3/openOrders', parameters, processResponse);
function processResponse(err, response) {
let exchangePositions = [];
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
for (let i = 0; i < response.length; i++) {
let openPosition = {
id: response[i].orderId,
type: response[i].side.toLowerCase(),
rate: Number(response[i].price),
amountA: truncDecimals(response[i].origQty * response[i].price),
amountB: Number(response[i].origQty),
date: (new Date(response[i].time)).valueOf()
};
exchangePositions.push(openPosition);
}
}
callback(err, exchangePositions);
}
},
returnTradeHistory: function (currencyA, currencyB, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnOrderTrades: function (orderNumber, callback) {
var parameters = {
symbol: joinCurrencies('USDT', 'BTC'), // TODO add parameters
timestamp: getDate().valueOf()
};
thisObject._signed('/api/v3/myTrades', parameters, processResponse);
function processResponse(err, response) {
let exchangeTrades = [];
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
for (let i = 0; i < response.length; i++) {
if (response[i].orderId === orderNumber) {
let type = "sell"
if (response[i].isBuyer === true) {
type = "buy";
}
let trade = {
id: response[i].orderId,
type: type,
rate: Number(response[i].price),
amountA: truncDecimals(response[i].qty * response[i].price),
amountB: Number(response[i].qty),
fee: Number(response[i].commission),
date: (new Date(response[i].time)).valueOf()
};
exchangeTrades.push(trade);
break;
}
}
}
callback(err, exchangeTrades);
}
},
buy: function (currencyA, currencyB, rate, amount, callback) {
thisObject._putOrder(currencyA, currencyB, rate, amount, 'BUY', callback);
},
sell: function (currencyA, currencyB, rate, amount, callback) {
thisObject._putOrder(currencyA, currencyB, rate, amount, 'SELL', callback);
},
_putOrder: function (currencyA, currencyB, rate, amount, side, callback) {
// TODO ERROR management, if total < 10 return error on sells
var parameters = {
symbol: joinCurrencies(currencyA, currencyB),
side: side,
type: 'LIMIT',
quantity: truncDecimals(amount),
price: rate,
timestamp: getDate().valueOf(),
timeInForce: 'GTC'
};
thisObject._private('/api/v3/order', parameters, processResponse);
function processResponse(err, response) {
let orderNumber;
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
orderNumber = response.orderId;
}
callback(err, orderNumber);
}
},
cancelOrder: function (currencyA, currencyB, orderNumber, callback) {
var parameters = {
symbol: joinCurrencies(currencyA, currencyB),
orderId: orderNumber,
timestamp: getDate().valueOf(),
};
thisObject._private('/api/v3/order', parameters, processResponse, 'DELETE');
function processResponse(err, response) {
let orderNumber;
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
orderNumber = response.orderId;
}
callback(err, orderNumber);
}
},
moveOrder: function (position, rate, amount, callback) {
thisObject.cancelOrder('USDT', 'BTC', orderNumber, processResponse); //TODO Maybe we will need to query the order to check executedQty
function processResponse(err, response) {
if (err.result === global.DEFAULT_OK_RESPONSE.result) {
if (position.type === "buy")
thisObject.buy('USDT', 'BTC', rate, truncDecimals(amount), callback);
else
thisObject.sell('USDT', 'BTC', rate, truncDecimals(amount), callback);
} else {
callback(err);
}
}
},
withdraw: function (currency, amount, address, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnFeeInfo: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnAvailableAccountBalances: function (account, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnTradableBalances: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
transferBalance: function (currency, amount, fromAccount, toAccount, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnMarginAccountSummary: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
marginBuy: function (currencyA, currencyB, rate, amount, lendingRate, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
marginSell: function (currencyA, currencyB, rate, amount, lendingRate, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
getMarginPosition: function (currencyA, currencyB, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
closeMarginPosition: function (currencyA, currencyB, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
createLoanOffer: function (currency, amount, duration, autoRenew, lendingRate, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
cancelLoanOffer: function (orderNumber, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnOpenLoanOffers: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnActiveLoans: function (callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
returnLendingHistory: function (start, end, limit, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
toggleAutoRenew: function (orderNumber, callback) {
analizeResponse(EMPTY_RESPONSE, NOT_IMPLEMENTED, callback);
},
analizeResponse: function (exchangeErr, exchangeResponse, callBack) {
/* This function analizes the different situations we might encounter trying to access Binance and returns appropiate standard errors. */
let stringExchangeResponse = JSON.stringify(exchangeResponse);
let stringExchangeErr = JSON.stringify(exchangeErr);
try {
if (FULL_LOG === true) { logger.write(MODULE_NAME, "[INFO] analizeResponse -> exchangeErr = " + stringExchangeErr); }
if (LOG_FILE_CONTENT === true) { logger.write(MODULE_NAME, "[INFO] analizeResponse -> exchangeResponse = " + stringExchangeResponse); }
if (stringExchangeErr.indexOf("ETIMEDOUT") > 0 ||
stringExchangeErr.indexOf("ENOTFOUND") > 0 ||
stringExchangeErr.indexOf("ECONNREFUSED") > 0 ||
stringExchangeErr.indexOf("ESOCKETTIMEDOUT") > 0 ||
stringExchangeErr.indexOf("ECONNRESET") > 0 ||
(stringExchangeResponse !== undefined && (
stringExchangeResponse.indexOf("Connection timed out") > 0 ||
stringExchangeResponse.indexOf("Connection Error") > 0 ||
stringExchangeResponse.indexOf("Bad gateway") > 0 ||
stringExchangeResponse.indexOf("Internal error. Please try again") > 0))) {
logger.write(MODULE_NAME, "[WARN] analizeResponse -> Timeout reached or connection problem while trying to access the Exchange API. Requesting new execution later.");
logger.write(MODULE_NAME, "[WARN] analizeResponse -> stringExchangeErr = " + stringExchangeErr);
callBack(global.DEFAULT_RETRY_RESPONSE);
return;
} else {
if (stringExchangeResponse.indexOf("code") > 0) {
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> Unexpected response from the Exchange.");
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> JSON.stringify(exchangeErr) = " + stringExchangeErr);
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> JSON.stringify(exchangeResponse) = " + stringExchangeResponse);
/* {"error":"Not enough USDT.","success":0}*/
if (stringExchangeResponse.indexOf("Not enough") > 0) {
let err = {
resutl: global.CUSTOM_FAIL_RESPONSE.result,
message: exchangeResponse.error
};
callBack(err);
} else {
callBack(global.DEFAULT_FAIL_RESPONSE);
}
return;
}
if (exchangeErr) {
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> Unexpected error trying to contact the Exchange.");
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> exchangeErr = " + stringExchangeErr);
callBack(global.DEFAULT_FAIL_RESPONSE);
return;
} else {
logger.write(MODULE_NAME, "[INFO] analizeResponse -> No problem found.");
callBack(global.DEFAULT_OK_RESPONSE, exchangeResponse);
return;
}
}
} catch (err) {
logger.write(MODULE_NAME, "[ERROR] analizeResponse -> err.message = " + err.message);
callBack(global.DEFAULT_FAIL_RESPONSE);
return;
}
}
};
return thisObject;
}
}