crypto-client/dist/exchanges/binance.js

An unified client for all cryptocurrency exchanges.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.withdraw = exports.fetchCurrencies = exports.getWithdrawalFees = exports.getDepositAddresses = exports.queryAllBalances = exports.queryOrder = exports.cancelOrder = exports.placeOrder = void 0;
const assert_1 = require("assert");
const binance_api_node_1 = __importDefault(require("binance-api-node"));
const config_1 = require("../config");
const util_1 = require("../util");
function createAuthenticatedClient() {
    assert_1.strict.ok(config_1.USER_CONFIG.BINANCE_API_KEY);
    assert_1.strict.ok(config_1.USER_CONFIG.BINANCE_API_SECRET);
    return binance_api_node_1.default({
        apiKey: config_1.USER_CONFIG.BINANCE_API_KEY,
        apiSecret: config_1.USER_CONFIG.BINANCE_API_SECRET,
    });
}
async function placeOrder(market, price, quantity, sell) {
    try {
        assert_1.strict.ok(market);
        const client = createAuthenticatedClient();
        const [priceStr, quantityStr] = util_1.convertPriceAndQuantityToStrings(market, price, quantity, sell);
        const order = await client
            .order({
            symbol: market.id,
            type: 'LIMIT',
            side: sell ? 'SELL' : 'BUY',
            quantity: quantityStr,
            price: priceStr,
        })
            .catch((e) => {
            return e;
        });
        if (order instanceof Error)
            return order;
        return order.orderId.toString();
    }
    catch (e) {
        return e;
    }
}
exports.placeOrder = placeOrder;
async function cancelOrder(market, orderId) {
    assert_1.strict.ok(market);
    const client = createAuthenticatedClient();
    const cancelResult = await client.cancelOrder({
        symbol: market.id,
        orderId: parseInt(orderId, 10),
    });
    return cancelResult.orderId === parseInt(orderId, 10);
}
exports.cancelOrder = cancelOrder;
async function queryOrder(market, orderId) {
    assert_1.strict.ok(market);
    const client = createAuthenticatedClient();
    const orderResult = client.getOrder({
        symbol: market.id,
        orderId: parseInt(orderId, 10),
    });
    return orderResult;
}
exports.queryOrder = queryOrder;
async function queryAllBalances(all = false) {
    const client = createAuthenticatedClient();
    const account = await client.accountInfo().catch((e) => {
        return e;
    });
    if (account instanceof Error)
        return account;
    const result = {};
    account.balances.forEach((balance) => {
        result[balance.asset] = all
            ? parseFloat(balance.free) + parseFloat(balance.locked)
            : parseFloat(balance.free);
    });
    return result;
}
exports.queryAllBalances = queryAllBalances;
async function getDepositAddresses(symbols) {
    if (!symbols.includes('ETH'))
        symbols.push('ETH');
    if (!symbols.includes('TRX'))
        symbols.push('TRX');
    if (!symbols.includes('BNB'))
        symbols.push('BNB');
    const client = createAuthenticatedClient();
    const addresses = [];
    for (let i = 0; i < symbols.length; i += 1) {
        const symbol = symbols[i];
        // eslint-disable-next-line no-await-in-loop
        const address = await client.depositAddress({ asset: symbol });
        if (address.success) {
            addresses.push(address);
        }
        else {
            assert_1.strict.notEqual(symbol, 'ETH');
            assert_1.strict.notEqual(symbol, 'TRX');
            assert_1.strict.notEqual(symbol, 'BNB');
        }
    }
    const ethAddress = addresses.filter((address) => address.asset === 'ETH')[0].address;
    assert_1.strict.ok(ethAddress);
    const trxAddress = addresses.filter((address) => address.asset === 'TRX')[0].address;
    assert_1.strict.ok(trxAddress);
    const bnbAddress = addresses.filter((address) => address.asset === 'BNB')[0].address;
    assert_1.strict.ok(bnbAddress);
    // TODO: use sapi/v1/capital/deposit/address to get USDT-OMNI and USDT-TRC20
    const result = {};
    addresses
        .filter((address) => symbols.includes(address.asset))
        .forEach((address) => {
        const symbol = address.asset;
        if (!(symbol in result))
            result[symbol] = {};
        let platform = symbol;
        if (address.address === ethAddress && symbol !== 'ETH' && symbol !== 'ETC') {
            platform = 'ERC20';
            assert_1.strict.equal(platform, util_1.detectPlatform(address.address, symbol));
        }
        if (address.address === trxAddress && symbol !== 'TRX') {
            platform = symbol === 'BTT' ? 'TRC10' : 'TRC20';
            assert_1.strict.equal(platform, util_1.detectPlatform(address.address, symbol));
        }
        if (address.address === bnbAddress && symbol !== 'BNB') {
            platform = 'BEP2';
            assert_1.strict.equal(platform, util_1.detectPlatform(address.address, symbol));
        }
        if (symbol === 'WTC')
            platform = 'WTC';
        if (symbol === 'CTXC')
            platform = 'CTXC';
        const depositAddress = {
            symbol,
            platform,
            address: address.address,
        };
        if (address.addressTag)
            depositAddress.memo = address.addressTag;
        result[symbol][platform] = depositAddress;
    });
    return result;
}
exports.getDepositAddresses = getDepositAddresses;
async function getWithdrawalFees() {
    const result = {};
    const client = createAuthenticatedClient();
    const assetDetail = await client.assetDetail();
    if (!assetDetail.success)
        return result;
    // console.info(JSON.stringify(assetDetail.assetDetail, undefined, 2));
    const depositAddresses = await getDepositAddresses(Object.keys(assetDetail.assetDetail));
    const tokenPlatformMap = util_1.calcTokenPlatform(depositAddresses);
    Object.keys(assetDetail.assetDetail).forEach((symbol) => {
        const detail = assetDetail.assetDetail[symbol];
        if (detail === undefined)
            return;
        let platform = tokenPlatformMap[symbol] || symbol;
        if (symbol === 'WTC')
            platform = 'WTC';
        if (!(symbol in result))
            result[symbol] = {};
        result[symbol][platform] = {
            symbol,
            platform,
            fee: detail.withdrawFee,
            min: detail.minWithdrawAmount,
        };
    });
    return result;
}
exports.getWithdrawalFees = getWithdrawalFees;
async function fetchCurrencies() {
    const result = {};
    const client = createAuthenticatedClient();
    const assetDetail = await client.assetDetail();
    if (!assetDetail.success)
        return result;
    // console.info(JSON.stringify(assetDetail.assetDetail, undefined, 2));
    Object.keys(assetDetail.assetDetail).forEach((symbol) => {
        const detail = assetDetail.assetDetail[symbol];
        result[symbol] = {
            symbol,
            active: detail.depositStatus && detail.withdrawStatus,
            depositEnabled: detail.depositStatus,
            withdrawalEnabled: detail.withdrawStatus,
        };
    });
    return result;
}
exports.fetchCurrencies = fetchCurrencies;
async function withdraw(symbol, address, amount, platform, memo) {
    const client = createAuthenticatedClient();
    const params = {
        asset: symbol,
        address,
        amount,
    };
    if (memo) {
        params.addressTag = memo;
    }
    if (symbol !== platform) {
        const platformNetworkMap = {
            ERC20: 'ETH',
            OMNI: 'BTC',
            TRC10: 'TRX',
            TRC20: 'TRX',
        };
        const network = platformNetworkMap[platform];
        if (network === undefined)
            return new Error(`Binance ${symbol} ${platform} can NOT find network`);
        params.network = network;
    }
    const data = (await client.withdraw(params));
    if (data.success) {
        return data.id;
    }
    return new Error(JSON.stringify(data));
}
exports.withdraw = withdraw;