@colony/colony-js-contract-loader/lib/ContractLoader.js

Contract loader interfaces

'use strict';

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

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _defaults = require('./defaults');

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

var assert = require('assert');

var validateField = function validateField(assertion, field) {
  return assert(assertion, 'Invalid contract definition: ' + field + ' is missing or invalid');
};

var ContractLoader = function () {
  (0, _createClass3.default)(ContractLoader, null, [{
    key: 'defaultTransform',


    /**
     * The default `transform` function is simply returns the input object as the
     * default behaviour.
     */
    value: function defaultTransform() {
      /* eslint-disable no-unused-vars */
      return function (inputObj, query, requiredProps) {
        return inputObj;
      };
      /* eslint-enable no-unused-vars */
    }
  }, {
    key: 'validateContractDefinition',
    value: function validateContractDefinition(contractDef, requiredProps) {
      assert(Object.getOwnPropertyNames(contractDef).length > 0, 'Missing contract definition');

      var address = contractDef.address,
          abi = contractDef.abi;


      if (requiredProps.address) validateField(typeof address === 'string' && address.length > 0, 'address');

      if (requiredProps.bytecode) validateField(typeof contractDef.bytecode === 'string' && contractDef.bytecode.length > 0, 'bytecode');

      if (requiredProps.abi) validateField(Array.isArray(abi) && abi.length > 0, 'abi');

      return true;
    }
  }]);

  function ContractLoader() {
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        _ref$transform = _ref.transform,
        transform = _ref$transform === undefined ? this.constructor.defaultTransform() : _ref$transform;

    (0, _classCallCheck3.default)(this, ContractLoader);

    assert(typeof transform === 'function', 'A `transform` function must be provided');
    this._transform = transform;
  }

  /* eslint-disable class-methods-use-this,no-unused-vars */


  (0, _createClass3.default)(ContractLoader, [{
    key: '_load',
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(query, requiredProps) {
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                throw new Error('ContractLoader._load() is expected to be defined in a derived class');

              case 1:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function _load(_x2, _x3) {
        return _ref2.apply(this, arguments);
      }

      return _load;
    }()

    /* eslint-enable class-methods-use-this,no-unused-vars */

  }, {
    key: 'load',
    value: function () {
      var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(query) {
        var requiredProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _defaults.DEFAULT_REQUIRED_CONTRACT_PROPS;
        var contractName, contractAddress, routerName, routerAddress, otherQuery, firstQuery, result, routerContract;
        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                contractName = query.contractName, contractAddress = query.contractAddress, routerName = query.routerName, routerAddress = query.routerAddress, otherQuery = (0, _objectWithoutProperties3.default)(query, ['contractName', 'contractAddress', 'routerName', 'routerAddress']);

                if (contractName || contractAddress) {
                  _context2.next = 3;
                  break;
                }

                throw new TypeError('The field `contractName` or `contractAddress` must be supplied');

              case 3:

                // Load the contract definition by either the contract name or address
                firstQuery = (0, _extends3.default)({}, contractName ? { contractName: contractName } : { contractAddress: contractAddress }, otherQuery);
                _context2.next = 6;
                return this._load(firstQuery, requiredProps);

              case 6:
                result = _context2.sent;

                if (!(result == null)) {
                  _context2.next = 9;
                  break;
                }

                throw new Error('Unable to load contract definition (' + JSON.stringify(firstQuery) + ')');

              case 9:
                if (!contractAddress) {
                  _context2.next = 13;
                  break;
                }

                // If we have a specific contractAddress, set it directly.
                result.address = contractAddress;
                _context2.next = 22;
                break;

              case 13:
                if (!routerAddress) {
                  _context2.next = 17;
                  break;
                }

                // If we have the router address, set it directly.
                result.address = routerAddress;
                _context2.next = 22;
                break;

              case 17:
                if (!routerName) {
                  _context2.next = 22;
                  break;
                }

                _context2.next = 20;
                return this._load((0, _extends3.default)({}, otherQuery, {
                  contractName: routerName
                }), requiredProps);

              case 20:
                routerContract = _context2.sent;

                if (routerContract != null) result.address = routerContract.address;

              case 22:

                this.constructor.validateContractDefinition(result, requiredProps);

                return _context2.abrupt('return', result);

              case 24:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function load(_x5) {
        return _ref3.apply(this, arguments);
      }

      return load;
    }()
  }]);
  return ContractLoader;
}();

exports.default = ContractLoader;
//# sourceMappingURL=ContractLoader.js.map