minter-js-sdk/dist/cjs/tx-data/create-coin.js

JS SDK for Minter Blockchain

'use strict';

var minterjsTx = require('minterjs-tx');
var minterjsUtil = require('minterjs-util');
var utils = require('../utils.js');

/**
 * @param {object} txData
 * @param {string} [txData.name]
 * @param {string} txData.symbol
 * @param {number|string} txData.initialAmount
 * @param {number|string} txData.initialReserve
 * @param {number|string} txData.constantReserveRatio
 * @param {number|string} [txData.maxSupply]
 * @param {TxOptions} [options]
 * @constructor
 */
function CreateCoinTxData(_ref) {
  var _ref$name = _ref.name,
    name = _ref$name === void 0 ? '' : _ref$name,
    symbol = _ref.symbol,
    initialAmount = _ref.initialAmount,
    initialReserve = _ref.initialReserve,
    constantReserveRatio = _ref.constantReserveRatio,
    _ref$maxSupply = _ref.maxSupply,
    maxSupply = _ref$maxSupply === void 0 ? minterjsUtil.COIN_MAX_MAX_SUPPLY : _ref$maxSupply;
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  if (!options.disableValidation) {
    utils.validateTicker(symbol, 'symbol');
    utils.validateAmount(initialAmount, 'initialAmount');
    utils.validateAmount(initialReserve, 'initialReserve');
    utils.validateMaxSupply(maxSupply, initialAmount);
  }
  this.name = name;
  this.symbol = symbol;
  this.initialAmount = initialAmount;
  this.initialReserve = initialReserve;
  this.constantReserveRatio = constantReserveRatio;
  this.maxSupply = maxSupply;
  this.txData = new minterjsTx.TxDataCreateCoin({
    name: Buffer.from(name.toString(), 'utf8'),
    symbol: minterjsUtil.coinToBuffer(symbol),
    initialAmount: "0x".concat(minterjsUtil.convertToPip(initialAmount, 'hex')),
    initialReserve: "0x".concat(minterjsUtil.convertToPip(initialReserve, 'hex')),
    constantReserveRatio: utils.integerToHexString(constantReserveRatio),
    maxSupply: "0x".concat(minterjsUtil.convertToPip(maxSupply, 'hex'))
  }, {
    forceDefaultValues: true
  });
  utils.proxyNestedTxData(this);
}

/**
 * @param {object} txData
 * @param {Buffer|string} txData.name
 * @param {Buffer|string} txData.symbol
 * @param {Buffer|string|number} txData.initialAmount
 * @param {Buffer|string|number} txData.initialReserve
 * @param {Buffer|string|number} txData.constantReserveRatio
 * @param {number|string|number} txData.maxSupply
 * @param {TxOptions} [options]
 * @return {CreateCoinTxData}
 */
CreateCoinTxData.fromBufferFields = function fromBufferFields(_ref2) {
  var name = _ref2.name,
    symbol = _ref2.symbol,
    initialAmount = _ref2.initialAmount,
    initialReserve = _ref2.initialReserve,
    constantReserveRatio = _ref2.constantReserveRatio,
    maxSupply = _ref2.maxSupply;
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  return new CreateCoinTxData({
    name: minterjsUtil.toBuffer(name).toString('utf8'),
    symbol: minterjsUtil.bufferToCoin(minterjsUtil.toBuffer(symbol)),
    initialAmount: utils.dataPipToAmount(initialAmount),
    initialReserve: utils.dataPipToAmount(initialReserve),
    constantReserveRatio: utils.dataToInteger(constantReserveRatio),
    maxSupply: utils.dataPipToAmount(maxSupply)
  }, options);
};

/**
 * @param {Buffer|string} data
 * @return {CreateCoinTxData}
 */
CreateCoinTxData.fromRlp = function fromRlp(data) {
  return CreateCoinTxData.fromBufferFields(new minterjsTx.TxDataCreateCoin(data));
};

module.exports = CreateCoinTxData;