"use strict";

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

function _react() {
  const data = _interopRequireDefault(require("react"));

  _react = function _react() {
    return data;
  };

  return data;
}

function _utils() {
  const data = _interopRequireDefault(require("@ddn/utils"));

  _utils = function _utils() {
    return data;
  };

  return data;
}

var _crypto = _interopRequireDefault(require("../utils/crypto"));

var _slots = _interopRequireDefault(require("../time/slots"));

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

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

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

const bignum = _utils().default.bignum;

function getClientFixedTime() {
  return _slots.default.getTime() - _config.config.clientDriftSeconds;
}

function createTransaction(_x, _x2, _x3, _x4, _x5, _x6, _x7) {
  return _createTransaction.apply(this, arguments);
}

function _createTransaction() {
  _createTransaction = _asyncToGenerator(function* (asset, fee, type, recipientId, message, secret, secondSecret) {
    const keys = _crypto.default.getKeys(secret);

    const transaction = {
      type,
      nethash: _config.config.nethash,
      amount: '0',
      fee: `${fee}`,
      recipientId: recipientId,
      senderPublicKey: keys.publicKey,
      timestamp: getClientFixedTime(),
      message,
      asset
    };
    transaction.signature = yield _crypto.default.sign(transaction, keys);

    if (secondSecret) {
      const secondKeys = _crypto.default.getKeys(secondSecret);

      transaction.sign_signature = yield _crypto.default.secondSign(transaction, secondKeys);
    }

    transaction.id = yield _crypto.default.getId(transaction);
    return transaction;
  });
  return _createTransaction.apply(this, arguments);
}

var _default = {
  createIssuer(name, desc, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobIssuer: {
          name,
          desc
        }
      };
      const fee = bignum.multiply(_config.constants.net.fees.aob_issuer, _config.constants.fixedPoint);
      const trs = yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_ISSUER, null, null, secret, secondSecret);
      return trs;
    })();
  },

  createAsset(name, desc, maximum, precision, strategy, allowWriteoff, allowWhitelist, allowBlacklist, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobAsset: {
          name,
          desc,
          maximum,
          precision,
          strategy,
          allow_blacklist: `${allowBlacklist}`,
          allow_whitelist: `${allowWhitelist}`,
          allow_writeoff: `${allowWriteoff}`
        }
      }; // var fee = (500 + (Math.floor(bytes.length / 200) + 1) * 0.1) * constants.fixedPoint

      const fee = bignum.multiply(_config.constants.net.fees.aob_asset, _config.constants.fixedPoint);
      return yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_ASSET, null, null, secret, secondSecret);
    })();
  },

  createFlags(currency, flagType, flag, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobFlags: {
          currency,
          flag_type: flagType,
          flag
        }
      };
      const fee = bignum.multiply(_config.constants.net.fees.aob_flag, _config.constants.fixedPoint);
      return yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_FLAG, null, null, secret, secondSecret);
    })();
  },

  createAcl(currency, operator, flag, list, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobAcl: {
          currency,
          operator,
          flag,
          list
        }
      };
      const fee = bignum.multiply(_config.constants.net.fees.aob_acl, _config.constants.fixedPoint);
      return yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_ACL, null, null, secret, secondSecret);
    })();
  },

  createIssue(currency, amount, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobIssue: {
          currency,
          amount: `${amount}`
        }
      };
      const fee = bignum.multiply(_config.constants.net.fees.aob_issue, _config.constants.fixedPoint);
      const trs = yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_ISSUE, null, null, secret, secondSecret);
      return trs;
    })();
  },

  createTransfer(currency, amount, recipientId, message, content, secret, secondSecret) {
    return _asyncToGenerator(function* () {
      const asset = {
        aobTransfer: {
          currency,
          amount: `${amount}`,
          content
        }
      };
      const fee = bignum.multiply(_config.constants.net.fees.aob_transfer, _config.constants.fixedPoint);
      return yield createTransaction(asset, fee, _utils().default.assetTypes.AOB_TRANSFER, recipientId, message, secret, secondSecret);
    })();
  }

};
exports.default = _default;