zaif/lib/zaif.js

Zaif API wrapper for Node.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _requestPromise = require('request-promise');

var _requestPromise2 = _interopRequireDefault(_requestPromise);

var _qs = require('qs');

var _qs2 = _interopRequireDefault(_qs);

var _rx = require('rx');

var _websocket = require('websocket');

var _config = require('./config');

var _config2 = _interopRequireDefault(_config);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Zaif = function () {
  function Zaif(key, secret) {
    _classCallCheck(this, Zaif);

    this.key = key;
    this.secret = secret;
  }

  _createClass(Zaif, [{
    key: '_createNonce',
    value: function _createNonce() {
      return Math.floor(new Date().getTime() / 1000);
    }
  }, {
    key: '_createSignature',
    value: function _createSignature(canonicalString) {
      return _crypto2.default.createHmac('sha512', this.secret).update(canonicalString).digest('hex');
    }
  }, {
    key: '_createHeader',
    value: function _createHeader(params) {
      var canonicalString = _qs2.default.stringify(params);
      var signature = this._createSignature(canonicalString);
      return {
        'Content-Type': 'application/x-www-form-urlencoded',
        Key: this.key,
        Sign: signature
      };
    }
  }, {
    key: '_privateRequest',
    value: function _privateRequest(method) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      if (this.key !== undefined && this.secret !== undefined) {
        params.method = method;
        params.nonce = this._createNonce();
        return (0, _requestPromise2.default)({
          headers: this._createHeader(params),
          url: _config2.default.baseUrl.private,
          method: 'POST',
          form: params,
          json: true
        });
      } else {
        throw new Error('Private API requires secret token and key.');
      }
    }
  }, {
    key: '_publicRequest',
    value: function _publicRequest(path) {
      return (0, _requestPromise2.default)({
        url: '' + _config2.default.baseUrl.public + path,
        method: 'GET',
        json: true
      });
    }
  }, {
    key: 'lastPrice',
    value: function lastPrice(currencyPair) {
      return this._publicRequest('/last_price/' + currencyPair);
    }
  }, {
    key: 'ticker',
    value: function ticker(currencyPair) {
      return this._publicRequest('/ticker/' + currencyPair);
    }
  }, {
    key: 'trades',
    value: function trades(currencyPair) {
      return this._publicRequest('/trades/' + currencyPair);
    }
  }, {
    key: 'depth',
    value: function depth(currencyPair) {
      return this._publicRequest('/depth/' + currencyPair);
    }
  }, {
    key: 'getInfo',
    value: function getInfo() {
      return this._privateRequest('get_info');
    }
  }, {
    key: 'getInfo2',
    value: function getInfo2() {
      return this._privateRequest('get_info2');
    }
  }, {
    key: 'getPersonalInfo',
    value: function getPersonalInfo() {
      return this._privateRequest('get_personal_info');
    }
  }, {
    key: 'tradeHistory',
    value: function tradeHistory(params) {
      return this._privateRequest('trade_history', params);
    }
  }, {
    key: 'activeOrders',
    value: function activeOrders() {
      var currencyPair = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

      return this._privateRequest('active_orders', {
        currency_pair: currencyPair
      });
    }
  }, {
    key: 'trade',
    value: function trade(currencyPair, action, price, amount) {
      var limit = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;

      return this._privateRequest('trade', {
        currency_pair: currencyPair,
        action: action,
        price: price,
        amount: amount,
        limit: limit
      });
    }
  }, {
    key: 'cancelOrder',
    value: function cancelOrder(orderId) {
      return this._privateRequest('cancel_order', {
        order_id: orderId
      });
    }
  }, {
    key: 'withdraw',
    value: function withdraw(currency, address, amount) {
      var params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

      return this._privateRequest('withdraw', Object.assign({
        currency: currency,
        address: address,
        amount: amount
      }, params));
    }
  }, {
    key: 'dopositHistory',
    value: function dopositHistory(currency) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      params.currency = currency;
      return this._privateRequest('depositHistory', params);
    }
  }, {
    key: 'withdrawHistory',
    value: function withdrawHistory(currency) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      params.currency = currency;
      return this._privateRequest('withdrawHistory', params);
    }
  }, {
    key: 'stream',
    value: function stream(currencyPair) {
      var subject = new _rx.AsyncSubject();
      var client = new _websocket.client();

      client.connect(_config2.default.baseUrl.stream + '?currency_pair=' + currencyPair);

      client.on('connectFailed', function (error) {
        subject.onError(error);
      });

      client.on('connect', function (connection) {
        console.log('WebSocket Client Connected');
        var receiver = _rx.Observable.create(function (observer) {
          connection.on('error', function (error) {
            observer.onError(error);
          });
          connection.on('close', function () {
            observer.onCompleted();
          });
          connection.on('message', function (msg) {
            if (msg.type === 'utf8') {
              observer.onNext(msg.utf8Data);
            }
          });
        });
        subject.onNext(receiver);
        subject.onCompleted();
      });

      return subject.asObservable().selectMany(function (receiver) {
        return receiver;
      });
    }
  }]);

  return Zaif;
}();

exports.default = Zaif;