coinpayment-2.0/lib/util/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 _error = _interopRequireDefault(require("../error"));

var _schema = _interopRequireDefault(require("../config/schema"));

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

var OR_OPERATOR = "|";
var _default = {
  getSchema: function getSchema(cmd) {
    return _schema["default"][cmd];
  },
  assertPayload: function assertPayload(data) {
    var cmd = data.cmd;
    var payload = Object.assign({}, data);
    delete payload.cmd;
    if (!cmd) return new _error["default"]("No method passed");
    var cmdSchema = this.getSchema(cmd);
    if (cmdSchema === undefined) return new _error["default"]("No such method ".concat(cmd));
    var error = "Missing parameters: ";
    var isError = false;

    if (cmd === "create_mass_withdrawal") {
      isError = !this.validateMassWithDrawal(payload);

      if (isError) {
        error = "Invalid mass withdrawal payload";
      }

      return {
        isError: isError,
        error: error
      };
    }

    for (var key in cmdSchema) {
      if (isError) break;
      var rule = cmdSchema[key];

      if (rule.indexOf(OR_OPERATOR) === -1) {
        isError = !this.hasOne(rule, payload);
      } else {
        isError = !this.xor(rule.split(OR_OPERATOR), payload);
      }

      if (isError) {
        error += "".concat(rule, ", ");
      }
    }

    if (isError) {
      error = new _error["default"](error.slice(0, -2));
    }

    return {
      isError: isError,
      error: error
    };
  },
  validateMassWithDrawal: function validateMassWithDrawal(payload) {
    var regex = /wd\[wd[0-9]*\]\[(amount|address|currency|dest_tag)\]/;

    for (var key in payload) {
      if (!regex.test(key)) return false;
    }

    return true;
  },
  hasOne: function hasOne(rule, payload) {
    return payload[rule] !== undefined;
  },
  xor: function xor(rules, payload) {
    var flag = false;

    for (var rule in rules) {
      if (payload[rules[rule]] !== undefined) {
        if (flag) return false;
        flag = true;
      }
    }

    return flag;
  }
};
exports["default"] = _default;