minter-js-sdk/dist/cjs/tx-data/create-multisig.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 {Array} txData.addresses
 * @param {Array} txData.weights
 * @param {number|string} txData.threshold
 * @param {TxOptions} [options]
 * @constructor
 */
function CreateMultisigTxData(_ref) {
  var addresses = _ref.addresses,
    weights = _ref.weights,
    threshold = _ref.threshold;
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  if (!options.disableValidation) {
    utils.validateUintArray(weights, 'weights');
    utils.validateUint(threshold);
  }
  this.addresses = addresses;
  this.weights = weights;
  this.threshold = threshold;
  if (!Array.isArray(addresses)) {
    throw new TypeError('Field `addresses` is not an array');
  }
  if (addresses.length > 32) {
    throw new Error('Invalid `addresses` count, it must not be greater than 32');
  }
  if (weights.length !== addresses.length) {
    throw new Error('Invalid `weights` count, it must be equal to addresses count');
  }
  addresses.forEach(function (address, index) {
    try {
      utils.validateAddress(address, "addresses[".concat(index, "]"));
    } catch (error) {
      throw new Error("Field `addresses` contains invalid address at index: ".concat(index, ". ").concat(error.message));
    }
  });
  weights.forEach(function (weight, index) {
    if (weight > 1023 || weight < 0) {
      throw new Error("`weights` field contains invalid weight at index: ".concat(index, ", it should be between 0 and 1023"));
    }
  });
  this.txData = new minterjsTx.TxDataCreateMultisig({
    addresses: addresses.map(function (address) {
      return minterjsUtil.toBuffer(address);
    }),
    weights: weights.map(function (weight) {
      return utils.integerToHexString(weight);
    }),
    threshold: utils.integerToHexString(threshold)
  });
  utils.proxyNestedTxData(this);
}

/**
 * @param {object} txData
 * @param {Array<Buffer>} txData.addresses
 * @param {Array<Buffer>} txData.weights
 * @param {Buffer|string} txData.threshold
 * @param {TxOptions} [options]
 * @return {CreateMultisigTxData}
 */
CreateMultisigTxData.fromBufferFields = function fromBufferFields(_ref2) {
  var addresses = _ref2.addresses,
    weights = _ref2.weights,
    threshold = _ref2.threshold;
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  return new CreateMultisigTxData({
    // @TODO replace with dataToXXX methods?
    addresses: addresses.map(function (item) {
      return minterjsUtil.addressToString(item);
    }),
    weights: weights.map(function (item) {
      return utils.bufferToInteger(item);
    }),
    threshold: utils.bufferToInteger(threshold)
  }, options);
};

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

module.exports = CreateMultisigTxData;