coinpayment-2.0/lib/index.js

CoinPayments is a cloud wallet solution that offers an easy way to integrate a checkout system for numerous cryptocurrencies. Coinpayments now also offers coin conversion via Shapeshift.io.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _https = _interopRequireDefault(require("https"));

var _crypto = _interopRequireDefault(require("crypto"));

var _querystring = _interopRequireDefault(require("querystring"));

var _config = _interopRequireDefault(require("./config"));

var _error = _interopRequireDefault(require("./error"));

var _util = _interopRequireDefault(require("./util"));

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"); } }

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); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var API_VERSION = _config["default"].API_VERSION,
    API_PROTOCOL = _config["default"].API_PROTOCOL,
    API_HOST = _config["default"].API_HOST,
    API_PATH = _config["default"].API_PATH;

var Coinpayments =
/*#__PURE__*/
function () {
  function Coinpayments(_ref) {
    var _ref$key = _ref.key,
        key = _ref$key === void 0 ? "" : _ref$key,
        _ref$secret = _ref.secret,
        secret = _ref$secret === void 0 ? "" : _ref$secret;

    _classCallCheck(this, Coinpayments);

    if (!key) throw new _error["default"]("Missing public key");
    if (!secret) throw new _error["default"]("Missing private key");
    this.credentials = {
      key: key,
      secret: secret
    };
    this.getBasicInfo = this.getBasicInfo.bind(this);
    this.rates = this.rates.bind(this);
    this.balances = this.balances.bind(this);
    this.getDepositAddress = this.getDepositAddress.bind(this);
    this.createTransaction = this.createTransaction.bind(this);
    this.getCallbackAddress = this.getCallbackAddress.bind(this);
    this.getTx = this.getTx.bind(this);
    this.getTxList = this.getTxList.bind(this);
    this.getTxMulti = this.getTxMulti.bind(this);
    this.createTransfer = this.createTransfer.bind(this);
    this.convertCoins = this.convertCoins.bind(this);
    this.convertLimits = this.convertLimits.bind(this);
    this.getWithdrawalHistory = this.getWithdrawalHistory.bind(this);
    this.getWithdrawalInfo = this.getWithdrawalInfo.bind(this);
    this.getConversionInfo = this.getConversionInfo.bind(this);
    this.getProfile = this.getProfile.bind(this);
    this.tagList = this.tagList.bind(this);
    this.updateTagProfile = this.updateTagProfile.bind(this);
    this.claimTag = this.claimTag.bind(this);
  }

  _createClass(Coinpayments, [{
    key: "_getPrivateHeaders",
    value: function _getPrivateHeaders(parameters) {
      var _this$credentials = this.credentials,
          secret = _this$credentials.secret,
          key = _this$credentials.key;
      parameters.key = key;

      var paramString = _querystring["default"].stringify(parameters);

      var signature = _crypto["default"].createHmac("sha512", secret).update(paramString).digest("hex");

      return {
        "Content-Type": "application/x-www-form-urlencoded",
        HMAC: signature
      };
    }
  }, {
    key: "request",
    value: function request(parameters, callback) {
      var assertResult = _util["default"].assertPayload(parameters);

      if (assertResult.isError) {
        if (callback) return callback(assertResult.error);
        return Promise.reject(assertResult.error);
      }

      parameters.version = API_VERSION;
      var options = {
        protocol: API_PROTOCOL,
        method: "post",
        host: API_HOST,
        path: API_PATH,
        headers: this._getPrivateHeaders(parameters)
      };

      var query = _querystring["default"].stringify(parameters);

      if (callback) {
        return this.callbackRequest(options, query, callback);
      } else {
        return this.promiseRequest(options, query);
      }
    }
  }, {
    key: "callbackRequest",
    value: function callbackRequest(options, query, callback) {
      var req = _https["default"].request(options, function (res) {
        var data = "";
        res.setEncoding("utf8");
        res.on("data", function (chunk) {
          data += chunk;
        });
        res.on("end", function () {
          try {
            data = JSON.parse(data);
          } catch (e) {
            return callback(new _error["default"]("Invalid response", data));
          }

          if (data.error !== "ok") {
            return callback(new _error["default"](data.error, data));
          }

          return callback(null, data.result);
        });
      });

      req.on("error", callback);
      req.write(query);
      req.end();
    }
  }, {
    key: "promiseRequest",
    value: function promiseRequest(options, query) {
      return new Promise(function (resolve, reject) {
        var req = _https["default"].request(options, function (res) {
          var data = "";
          res.setEncoding("utf8");
          res.on("data", function (chunk) {
            data += chunk;
          });
          res.on("end", function () {
            try {
              data = JSON.parse(data);
            } catch (e) {
              return reject(new _error["default"]("Invalid response", data));
            }

            if (data.error !== "ok") {
              return reject(new _error["default"](data.error, data));
            }

            return resolve(data.result);
          });
        });

        req.on("error", reject);
        req.write(query);
        req.end();
      });
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "createTransaction",
    value: function createTransaction(options, callback) {
      options = Object.assign({}, options, {
        cmd: "create_transaction"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} [options]
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "rates",
    value: function rates() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var callback = arguments.length > 1 ? arguments[1] : undefined;

      if (typeof options == "function") {
        callback = options;
        options = {};
      }

      options = Object.assign({}, options, {
        cmd: "rates"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} [options]
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "balances",
    value: function balances() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var callback = arguments.length > 1 ? arguments[1] : undefined;

      if (typeof options == "function") {
        callback = options;
        options = {};
      }

      options = Object.assign({}, options, {
        cmd: "balances"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "createWithdrawal",
    value: function createWithdrawal(options, callback) {
      options = Object.assign({
        auto_confirm: 1
      }, options, {
        cmd: "create_withdrawal"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Array} withdrawalArray
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "createMassWithdrawal",
    value: function createMassWithdrawal(withdrawalArray, callback) {
      if (!(withdrawalArray instanceof Array)) {
        return callback(new _error["default"]("Invalid withdrawal array".withdrawalArray));
      }

      withdrawalArray = withdrawalArray.filter(function (w) {
        return w.currency && w.amount && w.address;
      });
      if (!withdrawalArray.length) return callback(new _error["default"]("Invalid withdrawal array".withdrawalArray));
      var options = {
        cmd: "create_mass_withdrawal"
      };
      withdrawalArray.reduce(function (options, w, index) {
        options["wd[wd".concat(index + 1, "][amount]")] = w.amount;
        options["wd[wd".concat(index + 1, "][address]")] = w.address;
        options["wd[wd".concat(index + 1, "][currency]")] = w.currency;

        if (w.dest_tag) {
          options["wd[wd".concat(index + 1, "][dest_tag]")] = w.dest_tag;
        }

        return options;
      }, options);
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getTx",
    value: function getTx(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_tx_info"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getWithdrawalInfo",
    value: function getWithdrawalInfo(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_withdrawal_info"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Array} tx_id_array
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getTxMulti",
    value: function getTxMulti() {
      var tx_id_array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var callback = arguments.length > 1 ? arguments[1] : undefined;
      var options = {};

      if (!(tx_id_array instanceof Array) || !tx_id_array.length) {
        return callback(new _error["default"]("Invalid argument", tx_id_array));
      }

      Object.assign(options, {
        txid: tx_id_array.join("|")
      }, {
        cmd: "get_tx_info_multi"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} [options]
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getTxList",
    value: function getTxList() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var callback = arguments.length > 1 ? arguments[1] : undefined;

      if (typeof options == "function") {
        callback = options;
        options = {};
      }

      options = Object.assign({}, options, {
        cmd: "get_tx_ids"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getBasicInfo",
    value: function getBasicInfo(callback) {
      var options = {
        cmd: "get_basic_info"
      };
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getDepositAddress",
    value: function getDepositAddress(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_deposit_address"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getCallbackAddress",
    value: function getCallbackAddress(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_callback_address"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "createTransfer",
    value: function createTransfer(options, callback) {
      options = Object.assign({
        auto_confirm: 1
      }, options, {
        cmd: "create_transfer"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "convertCoins",
    value: function convertCoins(options, callback) {
      options = Object.assign({}, options, {
        cmd: "convert"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "convertLimits",
    value: function convertLimits(options, callback) {
      options = Object.assign({}, options, {
        cmd: "convert_limits"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} [options]
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getWithdrawalHistory",
    value: function getWithdrawalHistory() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var callback = arguments.length > 1 ? arguments[1] : undefined;

      if (typeof options == "function") {
        callback = options;
        options = {};
      }

      options = Object.assign({}, options, {
        cmd: "get_withdrawal_history"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getConversionInfo",
    value: function getConversionInfo(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_conversion_info"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "getProfile",
    value: function getProfile(options, callback) {
      options = Object.assign({}, options, {
        cmd: "get_pbn_info"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "tagList",
    value: function tagList(callback) {
      var options = {
        cmd: "get_pbn_list"
      };
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "updateTagProfile",
    value: function updateTagProfile(options, callback) {
      options = Object.assign({}, options, {
        cmd: "update_pbn_tag"
      });
      return this.request(options, callback);
    }
    /**
     *
     * @param {Object} options
     * @param {Function} [callback]
     * @returns {(Function|Promise)}
     */

  }, {
    key: "claimTag",
    value: function claimTag(options, callback) {
      options = Object.assign({}, options, {
        cmd: "claim_pbn_tag"
      });
      return this.request(options, callback);
    }
  }]);

  return Coinpayments;
}();

var _default = Coinpayments;
exports["default"] = _default;