@nodeswork/applet/dist/accounts/digital-currencies/kraken-accounts.js

Nodeswork Applet Framework

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const _ = require("underscore");
const request = require("request-promise");
const account_1 = require("../../account");
const services_1 = require("../../services");
const def_1 = require("./def");
const defaultRequest = request.defaults({ json: true });
let KrakenAccount = class KrakenAccount extends def_1.BaseDigitalCurrencyAccount {
    constructor($request) {
        super($request);
        this.$request = $request;
    }
    static $acceptCurrencies() {
        return [
            def_1.dc.currencies.BTC,
            def_1.dc.currencies.LTC,
            def_1.dc.currencies.ETH,
            def_1.dc.currencies.USD,
        ];
    }
    static $acceptTradings() {
        return [
            [def_1.dc.currencies.BTC, def_1.dc.currencies.USD],
            [def_1.dc.currencies.LTC, def_1.dc.currencies.BTC],
            [def_1.dc.currencies.LTC, def_1.dc.currencies.USD],
            [def_1.dc.currencies.ETH, def_1.dc.currencies.BTC],
            [def_1.dc.currencies.ETH, def_1.dc.currencies.USD],
        ];
    }
    async $getBalance() {
        const balance = (await this.$operate({
            name: 'getBalance',
            ref: 'Balance',
            method: 'GET',
        })).result;
        const result = {};
        _.each(balance, (value, name) => {
            const globalName = toGlobalName(name);
            if (globalName != null) {
                result[globalName] = Number.parseFloat(value);
            }
        });
        return result;
    }
    static async $getDepths(pairs) {
        const localPairs = _.map(pairs, (pair) => toLocalPair(pair));
        const depths = await this.getDepths(localPairs);
        const result = {};
        _.each(depths, (depth, localPair) => {
            const globalPair = toGlobalPair(localPair);
            const globalPairString = def_1.dc.pairToString(globalPair);
            const asks = _.map(depth.asks, toGlobalDepthInfo);
            const bids = _.map(depth.bids, toGlobalDepthInfo);
            result[globalPairString] = { asks, bids };
        });
        return result;
    }
    static async getDepths(pairs) {
        const result = {};
        for (const pair of pairs) {
            const resp = await defaultRequest.get(`https://api.kraken.com/0/public/Depth?pair=${pair}`);
            _.extend(result, resp.result);
        }
        return result;
    }
};
KrakenAccount = __decorate([
    account_1.Account({
        accountType: 'KrakenAccount',
        provider: 'kraken',
    }),
    __metadata("design:paramtypes", [services_1.RequestService])
], KrakenAccount);
exports.KrakenAccount = KrakenAccount;
function toLocalPair(pair) {
    const s = toLocalName(pair[0]);
    const t = toLocalName(pair[1]);
    if (s == null || t == null) {
        return null;
    }
    return s + t;
}
function toGlobalPair(pair) {
    const x = [pair.substring(0, 4), pair.substring(4, 8)];
    return [toGlobalName(x[0]), toGlobalName(x[1])];
}
function toLocalName(name) {
    switch (name) {
        case def_1.dc.currencies.BTC:
            return 'XXBT';
        case def_1.dc.currencies.LTC:
            return 'XLTC';
        case def_1.dc.currencies.ETH:
            return 'XETH';
        case def_1.dc.currencies.USD:
            return 'ZUSD';
        default:
            return null;
    }
}
function toGlobalName(name) {
    switch (name) {
        case 'XXBT':
            return def_1.dc.currencies.BTC;
        case 'XLTC':
            return def_1.dc.currencies.LTC;
        case 'XETH':
            return def_1.dc.currencies.ETH;
        case 'ZUSD':
            return def_1.dc.currencies.USD;
        default:
            return null;
    }
}
function toGlobalDepthInfo([price, volume, ts]) {
    return {
        price: Number.parseFloat(price),
        volume: Number.parseFloat(volume),
        ts,
    };
}

//# sourceMappingURL=kraken-accounts.js.map