cc-zos-vouching/lib/kernel/createKernelContracts.js

Vouching logic for the EVM packages of the ZeppelinOS smart contract platform

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.createBasicJurisdiction = createBasicJurisdiction;
exports.createZEPToken = createZEPToken;
exports.createOrganizationsValidator = createOrganizationsValidator;
exports.createVouching = createVouching;

var _log = require('../helpers/log');

var _log2 = _interopRequireDefault(_log);

var _zos = require('zos');

var _ccZosLib = require('cc-zos-lib');

var _constants = require('../constants');

var _fetchKernelContracts = require('./fetchKernelContracts');

var _printKernelInformation = require('./printKernelInformation');

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

const { create } = _zos.scripts;
const { ZosPackageFile } = _zos.files;
const { buildCallData, callDescription } = _ccZosLib.ABI;

exports.default = async function createKernelContracts(options) {
  const owner = options.txParams.from;
  const networkFile = new ZosPackageFile().networkFile(options.network);
  const jurisdiction = await createBasicJurisdiction(owner, options, networkFile);
  const zepToken = await createZEPToken(owner, jurisdiction, options, networkFile);
  const vouching = await createVouching(zepToken, options, networkFile);
  const validator = await createOrganizationsValidator(owner, jurisdiction, options, networkFile);
  const app = networkFile.app;
  return { app, jurisdiction, validator, zepToken, vouching };
};

async function createBasicJurisdiction(owner, options, networkFile) {
  (0, _printKernelInformation.printJurisdictionInformation)(owner);
  const jurisdiction = (0, _fetchKernelContracts.fetchJurisdiction)(networkFile);
  if (jurisdiction) {
    _log2.default.warn(` -  Reusing BasicJurisdiction instance at ${jurisdiction.address}`);
    return jurisdiction;
  }

  const packageName = 'tpl-contracts-eth';
  const contractAlias = 'BasicJurisdiction';
  const initMethod = 'initialize';
  const initArgs = [owner];
  try {
    const basicJurisdiction = await create(_extends({ packageName, contractAlias, initMethod, initArgs }, options));
    _log2.default.info(` ✔ BasicJurisdiction created at ${basicJurisdiction.address}`);
    return basicJurisdiction;
  } catch (error) {
    const BasicJurisdiction = _ccZosLib.Contracts.getFromNodeModules(packageName, contractAlias);
    const { method } = buildCallData(BasicJurisdiction, initMethod, initArgs);
    _log2.default.error(` ✘ Could not create basic jurisdiction by calling ${callDescription(method, initArgs)}`);
    throw error;
  }
}

async function createZEPToken(owner, basicJurisdiction, options, networkFile) {
  (0, _printKernelInformation.printZepTokenInformation)(owner, basicJurisdiction);
  const zepToken = (0, _fetchKernelContracts.fetchZepToken)(networkFile);
  if (zepToken) {
    _log2.default.warn(` -  Reusing ZEPToken instance at ${zepToken.address}`);
    return zepToken;
  }

  const packageName = 'zos-vouching';
  const contractAlias = 'ZEPToken';
  const initMethod = 'initialize';
  const initArgs = [owner, basicJurisdiction.address, _constants.ZEPTOKEN_ATTRIBUTE_ID];
  try {
    const zepToken = await create(_extends({ packageName, contractAlias, initMethod, initArgs }, options));
    _log2.default.info(` ✔ ZEPToken created at ${zepToken.address}`);
    return zepToken;
  } catch (error) {
    const ZEPToken = _ccZosLib.Contracts.getFromLocal(contractAlias);
    const { method } = buildCallData(ZEPToken, initMethod, initArgs);
    _log2.default.error(` ✘ Could not create ZEP token by calling ${callDescription(method, initArgs)}`);
    throw error;
  }
}

async function createOrganizationsValidator(owner, basicJurisdiction, options, networkFile) {
  (0, _printKernelInformation.printOrganizationsValidatorInformation)(owner, basicJurisdiction);
  const validator = (0, _fetchKernelContracts.fetchValidator)(networkFile);
  if (validator) {
    _log2.default.warn(` -  Reusing Organizations validator instance at ${validator.address}`);
    return validator;
  }

  const packageName = 'tpl-contracts-eth';
  const contractAlias = 'OrganizationsValidator';
  const initMethod = 'initialize';
  const initArgs = [basicJurisdiction.address, _constants.ZEPTOKEN_ATTRIBUTE_ID, owner];
  try {
    const validator = await create(_extends({ packageName, contractAlias, initMethod, initArgs }, options));
    _log2.default.info(` ✔ Organizations validator created at ${validator.address}`);
    return validator;
  } catch (error) {
    const OrganizationsValidator = _ccZosLib.Contracts.getFromNodeModules(packageName, contractAlias);
    const { method } = buildCallData(OrganizationsValidator, initMethod, initArgs);
    _log2.default.error(` ✘ Could not create Organizations validator by calling ${callDescription(method, initArgs)}`);
    throw error;
  }
}

async function createVouching(zepToken, options, networkFile) {
  (0, _printKernelInformation.printVouchingInformation)(zepToken);
  const vouching = (0, _fetchKernelContracts.fetchVouching)(networkFile);
  if (vouching) {
    _log2.default.warn(` -  Reusing Vouching instance at ${vouching.address}`);
    return vouching;
  }

  const packageName = 'zos-vouching';
  const contractAlias = 'Vouching';
  const initMethod = 'initialize';
  const initArgs = [_constants.VOUCHING_MIN_STAKE, zepToken.address];
  try {
    const vouching = await create(_extends({ packageName, contractAlias, initMethod, initArgs }, options));
    _log2.default.info(` ✔ Vouching created at ${vouching.address}`);
    return vouching;
  } catch (error) {
    const Vouching = _ccZosLib.Contracts.getFromLocal(contractAlias);
    const { method } = buildCallData(Vouching, initMethod, initArgs);
    _log2.default.error(` ✘ Could not create vouching contract by calling ${callDescription(method, initArgs)}`);
    throw error;
  }
}