initial

Author: bshevchenko

.babelrc

@@ -0,0 +1,8 @@
+{
+  "presets": ["es2015", "flow"],
+  "plugins": [
+    "transform-object-rest-spread",
+    "transform-class-properties",
+    "transform-react-jsx"
+  ]
+}

.eslintrc

@@ -0,0 +1,3 @@
+{
+  extends: ['plugin:polymath/recommended']
+}

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+.idea
+.DS_Store

README.md

@@ -0,0 +1,29 @@
+# Introducing Polymath.js v2.0
+
+TODO Update
+
+```
+await SecurityTokenRegistrar.createSecurityToken(token)
+```
+This is all you need to create new security token using Polymath.js v2.0. It will:
+1. Format data into the blockchain types (e.g. add decimals for token values).
+2. Properly estimate gas via Web3 1.0.
+3. Make dry run to validate inputs before transaction sending.
+4. Notify callbacks with transaction hash and receipt.
+5. Check whether the transaction was mined without errors or not.
+6. Send necessary requests to the `polymath-api`.
+
+## Key advantages
+1. Web3 1.0. It means that we don't need truffle-contract package anymore and we can use async-await, websockets for events (there was bug with disconnection from them, but now it's fixed), proper auto gas estimation.
+2. No need to wrap each contract function since v2.0 uses JavaScript Proxy API, which in a simplified manner calls original method if it's not overridden.
+```
+await PolyToken.symbol()
+```
+There is no `symbol` entry within the `PolyToken` class, but string above will return you ticker of the Polymath token.
+This is how it works.
+
+No excess wrappers means no excess documentation and tests.
+
+## Needs from polymath-core
+1. Versioned npm package (with changelog for each new version) with built-in contracts artifacts, which should contain contracts addresses for each network.
+2. Complete and up-to-date documentation since Polymath.js will inherit it in many ways.

dist/contracts/Contract.js

@@ -0,0 +1,214 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _web3EthContract = require('web3-eth-contract');
+
+var _web3EthContract2 = _interopRequireDefault(_web3EthContract);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Contract = function () {
+  function Contract(_artifact) {
+    var _this = this;
+
+    _classCallCheck(this, Contract);
+
+    this._artifact = null;
+    this._contract = null;
+    this._methods = null;
+    this.address = null;
+
+    this._artifact = _artifact;
+    return new Proxy(this, {
+      get: function get(target, field) {
+        try {
+          target._init();
+        } catch (e) {
+          // eslint-disable-next-line
+          console.error('Contract init failed', e);
+          return undefined;
+        }
+        if (field in target) {
+          return target[field];
+        }
+        var method = target._contract.methods[field];
+        if (_this._isView(field)) {
+          return function () {
+            return method.apply(undefined, arguments).call();
+          };
+        }
+        return function () {
+          return _this._tx(method.apply(undefined, arguments));
+        };
+      }
+    });
+  }
+
+  _createClass(Contract, [{
+    key: '_newContract',
+
+
+    /** @private */
+    value: function _newContract() {
+      var isWebSockets = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+      return new (isWebSockets ? Contract.params.web3WS : Contract.params.web3).eth.Contract(this._artifact.abi, this.address);
+    }
+
+    /** @private */
+
+  }, {
+    key: '_init',
+    value: function _init() {
+      var address = this._artifact.networks[Contract.params.id].address;
+
+      if (this._contract && this.address === address) {
+        return;
+      }
+      this.address = address;
+      this._contract = this._newContract();
+      this._methods = this._contract.methods;
+    }
+
+    /**
+     * Checks whether a contract function is constant (view) or not.
+     * @param name
+     * @returns {boolean}
+     * @private
+     */
+
+  }, {
+    key: '_isView',
+    value: function _isView(name) {
+      for (var i = 0; i < this._artifact.abi.length; i++) {
+        var method = this._artifact.abi[i];
+        if (method.name === name) {
+          return method.stateMutability === 'view';
+        }
+      }
+      throw new Error('_isView: no method with "' + name + '" found');
+    }
+
+    /**
+     * Checks whether a contract function has boolean output or not.
+     * @param name
+     * @returns {boolean}
+     * @private
+     */
+
+  }, {
+    key: '_isBoolOutput',
+    value: function _isBoolOutput(name) {
+      for (var i = 0; i < this._artifact.abi.length; i++) {
+        var method = this._artifact.abi[i];
+        if (method.name === name) {
+          if (!method.outputs.length) {
+            return false;
+          }
+          return method.outputs[0].name === '' && method.outputs[0].type === 'bool';
+        }
+      }
+      throw new Error('_isBoolOutput: no method with "' + name + '" found');
+    }
+
+    /**
+     * @param method
+     * @returns {Promise.<Object>}
+     * @protected
+     */
+
+  }, {
+    key: '_tx',
+    value: async function _tx(method) {
+      var params = { from: this.account };
+      params.gas = await method.estimateGas(params);
+
+      // dry run
+      try {
+        var okCode = this._isBoolOutput(method._method.name);
+        var dryResult = await method.call(params);
+        if (okCode && dryResult !== okCode) {
+          throw new Error('Expected ' + okCode + ', but received ' + dryResult);
+        }
+      } catch (e) {
+        throw new Error('Transaction dry run failed: ' + e.message);
+      }
+
+      var receipt = await method.send(params, function (error, hash) {
+        if (!error) {
+          Contract.params.txHashCallback(hash);
+        }
+      });
+      Contract.params.txEndCallback(receipt);
+
+      if (receipt.status === '0x0') {
+        throw new Error('Transaction failed');
+      }
+
+      return receipt;
+    }
+  }, {
+    key: 'subscribe',
+    value: async function subscribe(eventName, filter, callback) {
+      try {
+        await this._newContract(true).events[eventName]({ filter: filter }, function (error, event) {
+          if (error) {
+            // eslint-disable-next-line
+            console.error('Event "' + eventName + '" subscription error', error);
+            callback();
+            return;
+          }
+          // eslint-disable-next-line
+          console.log('Emitted ' + eventName + ' event', event);
+          callback(event);
+        });
+        return true;
+      } catch (e) {
+        // eslint-disable-next-line
+        console.error('Event "' + eventName + '" subscription failed', e);
+        return false;
+      }
+    }
+
+    /**
+     * @param v
+     * @returns {string}
+     * @protected
+     */
+
+  }, {
+    key: '_toBytes',
+    value: function _toBytes(v) {
+      return Contract._web3.utils.asciiToHex(v);
+    }
+
+    /**
+     * @param v
+     * @returns {boolean}
+     * @protected
+     */
+
+  }, {
+    key: '_isEmptyAddress',
+    value: function _isEmptyAddress(v) {
+      return v === '0x0000000000000000000000000000000000000000';
+    }
+  }, {
+    key: 'account',
+    get: function get() {
+      return Contract.params.account;
+    }
+  }]);
+
+  return Contract;
+}();
+
+Contract.params = null;
+exports.default = Contract;

dist/contracts/PolyToken.js

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _bignumber = require('bignumber.js');
+
+var _bignumber2 = _interopRequireDefault(_bignumber);
+
+var _PolyToken = require('../../tmp/PolyToken.json');
+
+var _PolyToken2 = _interopRequireDefault(_PolyToken);
+
+var _Contract2 = require('./Contract');
+
+var _Contract3 = _interopRequireDefault(_Contract2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // TODO @bshevchenko: will be replaced with artifact from polymath-core_v2 npm package
+
+
+var PolyToken = function (_Contract) {
+  _inherits(PolyToken, _Contract);
+
+  function PolyToken() {
+    var _ref;
+
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, PolyToken);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = PolyToken.__proto__ || Object.getPrototypeOf(PolyToken)).call.apply(_ref, [this].concat(args))), _this), _this.decimals = 18, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  _createClass(PolyToken, [{
+    key: 'addDecimals',
+    value: function addDecimals(n) {
+      return new _bignumber2.default(10).toPower(this.decimals).times(n);
+    }
+  }, {
+    key: 'removeDecimals',
+    value: function removeDecimals(n) {
+      return new _bignumber2.default(n).div(new _bignumber2.default(10).toPower(this.decimals));
+    }
+  }, {
+    key: 'balanceOf',
+    value: async function balanceOf(account) {
+      return this.removeDecimals((await this._methods.balanceOf(account).call()));
+    }
+  }, {
+    key: 'myBalance',
+    value: async function myBalance() {
+      return this.balanceOf(this.account);
+    }
+  }, {
+    key: 'allowance',
+    value: async function allowance(owner, spender) {
+      return this.removeDecimals((await this._methods.allowance(owner, spender).call()));
+    }
+  }, {
+    key: 'getTokens',
+    value: async function getTokens(amount) {
+      await this._tx(this._methods.getTokens(this.addDecimals(amount)));
+    }
+  }, {
+    key: 'approve',
+    value: async function approve(spender, amount) {
+      await this._tx(this._methods.approve(spender, this.addDecimals(amount)));
+    }
+  }]);
+
+  return PolyToken;
+}(_Contract3.default);
+
+exports.default = new PolyToken(_PolyToken2.default);