Merge branch 'bootstrap' into 000-instance-factory

app/components/erc20token.js

@@ -0,0 +1,131 @@
+import EmbarkJS from 'Embark/EmbarkJS';
+import ERC20Token from 'Embark/contracts/ERC20Token';
+import React from 'react';
+import { Form, FormGroup, FormControl, HelpBlock, Button } from 'react-bootstrap';
+ 
+class ERC20TokenUI extends React.Component {
+
+    constructor(props) {
+      super(props);
+      this.state = {
+
+        balanceOf: 0,
+        transferTo: "",
+        transferAmount: 0,
+        logs: []
+      }      
+    }  
+    
+    contractAddress(e){
+      e.preventDefault();
+      var tokenAddress = e.target.value;
+      ERC20Token.options.address = tokenAddress;
+    }
+
+    update_transferTo(e){
+      this.setState({transferTo: e.target.value});
+    }
+
+    update_transferAmount(e){
+      this.setState({transferAmount: e.target.value});
+    }
+
+    transfer(e){
+      var to = this.state.transferTo;
+      var amount = this.state.transferAmount;
+      var tx = ERC20Token.methods.transfer(to, amount).send({from: web3.eth.defaultAccount});
+      this._addToLog(ERC20Token.options.address+".transfer(" + to + ", "+amount+")");
+    }
+
+    approve(e){
+      var to = this.state.transferTo;
+      var amount = this.state.transferAmount;
+      var tx = ERC20Token.methods.approve(to, amount).send({from: web3.eth.defaultAccount});
+      this._addToLog(ERC20Token.options.address+".approve(" + to + ", "+amount+")");
+    }
+
+    balanceOf(e){
+      e.preventDefault();
+      var who = e.target.value;
+      if (EmbarkJS.isNewWeb3()) {
+        ERC20Token.methods.balanceOf(who).call()
+          .then(_value => this.setState({balanceOf: _value}))
+        
+      } else {
+        ERC20Token.balanceOf(who)
+          .then(_value => this.x({balanceOf: _value}));
+      }
+      this._addToLog(ERC20Token.options.address+".balanceOf(" + who + ")");
+    }
+  
+
+    _addToLog(txt){
+      this.state.logs.push(txt);
+      this.setState({logs: this.state.logs});
+    }
+  
+    render(){
+      return (<React.Fragment>
+     
+          <h2> Set token contract address</h2>
+          <Form inline>
+            <FormGroup>
+              <FormControl
+                type="text"
+                onChange={(e) => this.contractAddress(e)} />
+            </FormGroup>
+          </Form>
+
+          
+          <h3> Read account token balance</h3>
+          <Form inline>
+            <FormGroup>
+              <label>
+                Of:
+                <FormControl
+                  type="text"
+                  defaultValue={this.state.accountB}
+                  onChange={(e) => this.balanceOf(e)} />
+              </label>
+              <label>
+                <HelpBlock><span className="balanceOf">{this.state.balanceOf}</span></HelpBlock>
+              </label>
+              
+            </FormGroup>
+          </Form>
+
+          <h3> Transfer/Approve token balance</h3>
+          <Form inline>
+            <FormGroup>
+              <label>
+                To:
+                <FormControl
+                  type="text"
+                  defaultValue={this.state.transferTo}
+                  onChange={(e) => this.update_transferTo(e) } />
+              </label>
+              <label>
+                Amount:
+                <FormControl
+                  type="text"
+                  defaultValue={this.state.transferAmount}
+                  onChange={(e) => this.update_transferAmount(e) } />
+              </label>
+              <Button bsStyle="primary" onClick={(e) => this.transfer(e)}>Transfer</Button>
+              <Button bsStyle="primary" onClick={(e) => this.approve(e)}>Approve</Button>
+            </FormGroup>
+          </Form>
+     
+          <h3> Contract Calls </h3>
+          <p>Javascript calls being made: </p>
+          <div className="logs">
+          {
+            this.state.logs.map((item, i) => <p key={i}>{item}</p>)
+          }
+          </div>
+      </React.Fragment>
+      );
+    }
+  }
+
+  export default ERC20TokenUI;

app/components/testtoken.js

@@ -0,0 +1,88 @@
+import EmbarkJS from 'Embark/EmbarkJS';
+import TestToken from 'Embark/contracts/TestToken';
+import React from 'react';
+import { Form, FormGroup, FormControl, HelpBlock, Button } from 'react-bootstrap';
+ 
+class TestTokenUI extends React.Component {
+
+    constructor(props) {
+      super(props);
+      this.state = {
+        amountToMint: 100,
+        accountBalance: 0,
+        accountB: web3.eth.defaultAccount,
+        balanceOf: 0,
+        logs: []
+      }      
+    }
+  
+    handleMintAmountChange(e){
+      this.setState({amountToMint: e.target.value});
+    }
+    
+    mint(e){
+      e.preventDefault();
+  
+      var value = parseInt(this.state.amountToMint, 10);
+  
+      if (EmbarkJS.isNewWeb3()) {
+        TestToken.methods.mint(value).send({from: web3.eth.defaultAccount});
+      } else {
+        TestToken.mint(value);
+        this._addToLog("#blockchain", "TestToken.mint(" + value + ")");
+      }
+      this._addToLog(TestToken.options.address +".mint("+value+").send({from: " + web3.eth.defaultAccount + "})");
+    }
+  
+    getBalance(e){
+      e.preventDefault();
+      
+      if (EmbarkJS.isNewWeb3()) {
+        TestToken.methods.balanceOf(web3.eth.defaultAccount).call()
+          .then(_value => this.setState({accountBalance: _value}))
+      } else {
+        TestToken.balanceOf(web3.eth.defaultAccount)
+          .then(_value => this.x({valueGet: _value}))
+      }
+      this._addToLog(TestToken.options.address + ".balanceOf(" + web3.eth.defaultAccount + ")");
+    }
+  
+    _addToLog(txt){
+      this.state.logs.push(txt);
+      this.setState({logs: this.state.logs});
+    }
+  
+    render(){
+      return (<React.Fragment>
+          <h3> 1. Mint Test Token</h3>
+          <Form inline>
+            <FormGroup>
+              <FormControl
+                type="text"
+                defaultValue={this.state.amountToMint}
+                onChange={(e) => this.handleMintAmountChange(e)} />
+              <Button bsStyle="primary" onClick={(e) => this.mint(e)}>Mint</Button>
+            </FormGroup>
+          </Form>
+          
+          <h3> 2. Read your account token balance </h3>
+          <Form inline>
+            <FormGroup>
+              <HelpBlock>Your test token balance is <span className="accountBalance">{this.state.accountBalance}</span></HelpBlock>
+              <Button bsStyle="primary" onClick={(e) => this.getBalance(e)}>Get Balance</Button>
+            </FormGroup>
+          </Form>
+     
+          <h3> 3. Contract Calls </h3>
+          <p>Javascript calls being made: </p>
+          <div className="logs">
+          {
+            this.state.logs.map((item, i) => <p key={i}>{item}</p>)
+          }
+          </div>
+      </React.Fragment>
+      );
+    }
+  }
+
+  export default TestTokenUI;

app/dapp.css

@@ -0,0 +1,53 @@
+
+div {
+  margin: 15px;
+}
+
+.logs {
+  background-color: black;
+  font-size: 14px;
+  color: white;
+  font-weight: bold;
+  padding: 10px;
+  border-radius: 8px;
+}
+
+.tab-content {
+  border-left: 1px solid #ddd;
+  border-right: 1px solid #ddd;
+  border-bottom: 1px solid #ddd;
+  padding: 10px;
+  margin: 0px;
+}
+
+.nav-tabs {
+  margin-bottom: 0;
+}
+
+.status-offline {
+  vertical-align: middle;
+  margin-left: 5px;
+  margin-top: 4px;
+  width: 12px;
+  height: 12px;
+  background: red;
+  -moz-border-radius: 10px;
+  -webkit-border-radius: 10px;
+  border-radius: 10px;
+}
+
+.status-online {
+  vertical-align: middle;
+  margin-left: 5px;
+  margin-top: 4px;
+  width: 12px;
+  height: 12px;
+  background: mediumseagreen;
+  -moz-border-radius: 10px;
+  -webkit-border-radius: 10px;
+  border-radius: 10px;
+}
+
+input.form-control {
+  margin: 5px;
+}

app/dapp.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { Tabs, Tab } from 'react-bootstrap';
+
+import EmbarkJS from 'Embark/EmbarkJS';
+import TestTokenUI from './components/testtoken';
+import ERC20TokenUI from './components/erc20token';
+
+import './dapp.css';
+
+class App extends React.Component {
+
+  constructor(props) {
+    super(props);
+
+    
+  }
+
+  componentDidMount(){ 
+    __embarkContext.execWhenReady(() => {
+      
+    });
+  }
+
+
+  _renderStatus(title, available){
+    let className = available ? 'pull-right status-online' : 'pull-right status-offline';
+    return <React.Fragment>
+      {title} 
+      <span className={className}></span>
+    </React.Fragment>;
+  }
+
+  render(){
+    return (<div><h3>Status.im Contracts</h3>
+      <Tabs defaultActiveKey={1} id="uncontrolled-tab-example">
+      <Tab eventKey={1} title="TestToken">
+          <TestTokenUI />
+      </Tab>
+      <Tab eventKey={2} title="ERC20Token">
+          <ERC20TokenUI />
+      </Tab>
+      </Tabs>
+    </div>);
+  }
+}
+
+ReactDOM.render(<App></App>, document.getElementById('app'));

app/index.html

@@ -0,0 +1,12 @@
+<html>
+  <head>
+    <title>Status.im - Contracts</title>
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
+  </head>
+  <body class="container">
+      <div id="app">
+      </div>
+      <script src="js/dapp.js"></script>
+  </body>
+</html>

config/blockchain.json

@@ -9,12 +9,12 @@
     "maxpeers": 0,
     "rpcHost": "localhost",
     "rpcPort": 8545,
-    "rpcCorsDomain": "http://localhost:8000",
+    "rpcCorsDomain": "auto",
     "account": {
       "password": "config/development/password"
     },
     "targetGasLimit": 8000000,
-    "wsOrigins": "http://localhost:8000",
+    "wsOrigins": "auto",
     "wsRPC": true,
     "wsHost": "localhost",
     "wsPort": 8546,

config/development/genesis.json

@@ -1,6 +1,8 @@
 {
     "config": {
-      "homesteadBlock": 1
+      "homesteadBlock": 1,
+      "byzantiumBlock": 1,
+      "daoForkSupport": true
     },
     "nonce": "0x0000000000000042",
     "difficulty": "0x0",

contracts/common/Controlled.sol

@@ -10,7 +10,7 @@ contract Controlled {
 
     address public controller;
 
-    constructor() public { 
+    constructor() internal { 
         controller = msg.sender; 
     }
 

contracts/common/MessageSigned.sol

@@ -0,0 +1,77 @@
+pragma solidity ^0.4.21;
+
+/** 
+ * @notice Uses ethereum signed messages
+ */
+contract MessageSigned {
+    
+    constructor() internal {
+
+    }
+
+    /**
+     * @notice recovers address who signed the message
+     * @param _signHash operation ethereum signed message hash
+     * @param _messageSignature message `_signHash` signature
+     */
+    function recoverAddress(
+        bytes32 _signHash, 
+        bytes _messageSignature
+    )
+        pure
+        internal
+        returns(address) 
+    {
+        uint8 v;
+        bytes32 r;
+        bytes32 s;
+        (v,r,s) = signatureSplit(_messageSignature);
+        return ecrecover(
+            _signHash,
+            v,
+            r,
+            s
+        );
+    }
+
+    /**
+     * @notice Hash a hash with `"\x19Ethereum Signed Message:\n32"`
+     * @param _hash Sign to hash.
+     * @return signHash Hash to be signed.
+     */
+    function getSignHash(
+        bytes32 _hash
+    )
+        pure
+        internal
+        returns (bytes32 signHash)
+    {
+        signHash = keccak256("\x19Ethereum Signed Message:\n32", _hash);
+    }
+
+    /**
+     * @dev divides bytes signature into `uint8 v, bytes32 r, bytes32 s` 
+     */
+    function signatureSplit(bytes _signature)
+        pure
+        internal
+        returns (uint8 v, bytes32 r, bytes32 s)
+    {
+        // The signature format is a compact form of:
+        //   {bytes32 r}{bytes32 s}{uint8 v}
+        // Compact means, uint8 is not padded to 32 bytes.
+        assembly {
+            r := mload(add(_signature, 32))
+            s := mload(add(_signature, 64))
+            // Here we are loading the last 32 bytes, including 31 bytes
+            // of 's'. There is no 'mload8' to do this.
+            //
+            // 'byte' is not working due to the Solidity parser, so lets
+            // use the second best option, 'and'
+            v := and(mload(add(_signature, 65)), 0xff)
+        }
+
+        require(v == 27 || v == 28);
+    }
+    
+}

contracts/common/Owned.sol

@@ -14,7 +14,7 @@ contract Owned {
     address public owner;
 
     /// @notice The Constructor assigns the message sender to be `owner`
-    constructor() public {
+    constructor() internal {
         owner = msg.sender;
     }
 

contracts/token/ERC20Token.sol

@@ -1,48 +1,52 @@
-pragma solidity ^0.4.17;
+pragma solidity ^0.4.23;
 
 // Abstract contract for the full ERC 20 Token standard
 // https://github.com/ethereum/EIPs/issues/20
 
-contract ERC20Token {
-    /* This is a slight change to the ERC20 base standard.
-    function totalSupply() constant returns (uint256 supply);
-    is replaced with:
-    uint256 public totalSupply;
-    This automatically creates a getter function for the totalSupply.
-    This is moved to the base contract since public getter functions are not
-    currently recognised as an implementation of the matching abstract
-    function by the compiler.
-    */
-    /// total amount of tokens
-    uint256 public totalSupply;
+interface ERC20Token {
 
-    /// @notice send `_value` token to `_to` from `msg.sender`
-    /// @param _to The address of the recipient
-    /// @param _value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transfer(address _to, uint256 _value) public returns (bool success);
+    /**
+     * @notice send `_value` token to `_to` from `msg.sender`
+     * @param _to The address of the recipient
+     * @param _value The amount of token to be transferred
+     * @return Whether the transfer was successful or not
+     */
+    function transfer(address _to, uint256 _value) external returns (bool success);
 
-    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
-    /// @param _spender The address of the account able to transfer the tokens
-    /// @param _value The amount of tokens to be approved for transfer
-    /// @return Whether the approval was successful or not
-    function approve(address _spender, uint256 _value) public returns (bool success);
+    /**
+     * @notice `msg.sender` approves `_spender` to spend `_value` tokens
+     * @param _spender The address of the account able to transfer the tokens
+     * @param _value The amount of tokens to be approved for transfer
+     * @return Whether the approval was successful or not
+     */
+    function approve(address _spender, uint256 _value) external returns (bool success);
 
-    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
-    /// @param _from The address of the sender
-    /// @param _to The address of the recipient
-    /// @param _value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
+    /**
+     * @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+     * @param _from The address of the sender
+     * @param _to The address of the recipient
+     * @param _value The amount of token to be transferred
+     * @return Whether the transfer was successful or not
+     */
+    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
 
-    /// @param _owner The address from which the balance will be retrieved
-    /// @return The balance
-    function balanceOf(address _owner) public view returns (uint256 balance);
+    /**
+     * @param _owner The address from which the balance will be retrieved
+     * @return The balance
+     */
+    function balanceOf(address _owner) external view returns (uint256 balance);
 
-    /// @param _owner The address of the account owning tokens
-    /// @param _spender The address of the account able to transfer the tokens
-    /// @return Amount of remaining tokens allowed to spent
-    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
+    /**
+     * @param _owner The address of the account owning tokens
+     * @param _spender The address of the account able to transfer the tokens
+     * @return Amount of remaining tokens allowed to spent
+     */
+    function allowance(address _owner, address _spender) external view returns (uint256 remaining);
+
+    /**
+     * @notice return total supply of tokens
+     */
+    function totalSupply() external view returns (uint256 supply);
 
     event Transfer(address indexed _from, address indexed _to, uint256 _value);
     event Approval(address indexed _owner, address indexed _spender, uint256 _value);

contracts/token/StandardToken.sol

@@ -4,23 +4,24 @@ import "./ERC20Token.sol";
 
 contract StandardToken is ERC20Token {
 
+    uint256 private supply;
     mapping (address => uint256) balances;
     mapping (address => mapping (address => uint256)) allowed;
 
     constructor() internal { }
-
+    
     function transfer(
         address _to,
         uint256 _value
     ) 
-        public 
+        external 
         returns (bool success)
     {
         return transfer(msg.sender, _to, _value);    
     }
 
     function approve(address _spender, uint256 _value) 
-        public
+        external
         returns (bool success) 
     {
         allowed[msg.sender][_spender] = _value;
@@ -33,7 +34,7 @@ contract StandardToken is ERC20Token {
         address _to,
         uint256 _value
     )
-        public
+        external
         returns (bool success)
     {
         if (balances[_from] >= _value &&
@@ -47,7 +48,7 @@ contract StandardToken is ERC20Token {
     }
 
     function allowance(address _owner, address _spender) 
-        public 
+        external 
         view 
         returns (uint256 remaining)
     {
@@ -55,12 +56,31 @@ contract StandardToken is ERC20Token {
     }
 
     function balanceOf(address _owner) 
-        public 
+        external 
         view 
         returns (uint256 balance) 
     {
         return balances[_owner];
     }
+    
+    function totalSupply() 
+        external 
+        view 
+        returns(uint256 currentTotalSupply) 
+    {
+        return supply;
+    }
+
+    function mint(
+        address _to,
+        uint256 _amount
+    ) 
+        internal
+    {
+        balances[_to] += _amount;
+        supply += _amount;
+        emit Transfer(0x0, _to, _amount);
+    }
 
     function transfer(
         address _from, 

contracts/token/TestToken.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.4.23;
+
+import "./StandardToken.sol";
+
+/**
+ * @notice ERC20Token for test scripts, can be minted by anyone.
+ */
+contract TestToken is StandardToken {
+    
+    constructor() public { }
+
+    /**
+     * @notice any caller can mint any `_amount` 
+     * @param _amount how much to be minted
+     */
+    function mint(uint256 _amount) public {
+        mint(msg.sender, _amount);
+    }
+}

embark.json

@@ -1,10 +1,17 @@
 {
   "contracts": ["contracts/**"],
+  "app": {
+    "js/dapp.js": ["app/dapp.js"],
+    "index.html": "app/index.html",
+    "images/": ["app/images/**"]
+  },
   "buildDir": "dist/",
   "config": "config/",
-  "plugins": {
-  },
   "versions": {
-    "solc": "0.4.23"
+    "web3": "1.0.0-beta",
+    "solc": "0.4.23",
+    "ipfs-api": "17.2.4"
+  },
+  "plugins": {
   }
 }

package.json

@@ -1,6 +1,7 @@
 {
   "name": "status-contracts",
-  "version": "1.0.0",
+  "version": "0.0.1",
+  "description": "",
   "scripts": {
     "solidity-coverage": "./node_modules/.bin/solidity-coverage",
     "test": "embark test"
@@ -15,13 +16,6 @@
     "url": "https://github.com/status-im/contracts/issues"
   },
   "homepage": "https://github.com/status-im/contracts#readme",
-  "devDependencies": {
-    "solidity-coverage": "^0.5.0",
-    "elliptic": "^6.4.0"
-  },
-  "dependencies": {
-    "embark": "^2.7.0",
-    "elliptic-curve": "^0.1.0",
-    "ethereumjs-util": "^5.1.5"
+  "dependencies": { 
   }
 }

test/erc20token.js

@@ -0,0 +1,66 @@
+describe("ERC20Token", async function() {
+  this.timeout(0);
+  var ERC20Token;
+  var accountsArr;
+  before(function(done) {
+    this.timeout(0);
+    var contractsConfig = {
+      "TestToken": {
+      }
+    };
+    EmbarkSpec.deployAll(contractsConfig, async function(accounts) { 
+      ERC20Token = TestToken;
+      accountsArr = accounts; 
+      for(i=0;i<accountsArr.length;i++){
+        await ERC20Token.methods.mint(100).send({from: accountsArr[i]})
+      }
+      done()
+    });
+  });
+
+  it("should transfer 1 token", async function() {
+    let initialBalance0 = await ERC20Token.methods.balanceOf(accountsArr[0]).call();
+    let initialBalance1 = await ERC20Token.methods.balanceOf(accountsArr[1]).call();
+    await ERC20Token.methods.transfer(accountsArr[1],1).send({from: accountsArr[0]});
+    let result0 = await ERC20Token.methods.balanceOf(accountsArr[0]).call();
+    let result1 = await ERC20Token.methods.balanceOf(accountsArr[1]).call();
+    
+    assert.equal(result0, +initialBalance0-1);
+    assert.equal(result1, +initialBalance1+1);
+  });
+
+  it("should set approved amount", async function() {
+    await ERC20Token.methods.approve(accountsArr[2],10000000).send({from: accountsArr[0]});
+    let result = await ERC20Token.methods.allowance(accountsArr[0], accountsArr[2]).call();
+    assert.equal(result, 10000000);
+  });
+
+  it("should consume allowance amount", async function() {
+    let initialAllowance = await ERC20Token.methods.allowance(accountsArr[0], accountsArr[2]).call();
+    await ERC20Token.methods.transferFrom(accountsArr[0], accountsArr[0],1).send({from: accountsArr[2]});
+    let result = await ERC20Token.methods.allowance(accountsArr[0], accountsArr[2]).call();
+    
+    assert.equal(result, +initialAllowance-1);
+  });
+  
+  it("should transfer approved amount", async function() {
+    let initialBalance0 = await ERC20Token.methods.balanceOf(accountsArr[0]).call();
+    let initialBalance1 = await ERC20Token.methods.balanceOf(accountsArr[1]).call();
+    await ERC20Token.methods.transferFrom(accountsArr[0], accountsArr[1],1).send({from: accountsArr[2]});
+    let result0 = await ERC20Token.methods.balanceOf(accountsArr[0]).call();
+    let result1 = await ERC20Token.methods.balanceOf(accountsArr[1]).call();
+    
+    assert.equal(result0, +initialBalance0-1);
+    assert.equal(result1, +initialBalance1+1);
+  });
+
+
+  it("should unset approved amount", async function() {
+    await ERC20Token.methods.approve(accountsArr[2],0).send({from: accountsArr[0]});
+    let result = await ERC20Token.methods.allowance(accountsArr[0], accountsArr[2]).call();
+    assert.equal(result, 0);
+  });
+
+  //TODO: include checks for expected events fired
+
+});

test/testtoken.js

@@ -0,0 +1,34 @@
+describe("TestToken", function() {
+  this.timeout(0);
+  var accountsArr;
+  before(function(done) {
+    this.timeout(0);
+    var contractsConfig = {
+      "TestToken": {
+      }
+    };
+    EmbarkSpec.deployAll(contractsConfig, (accounts) => { accountsArr = accounts; done() });
+  });
+
+  
+  it("should start totalSupply 0", async function() {
+    let result = await TestToken.methods.totalSupply().call();
+    assert.equal(result, 0);
+  });
+
+  it("should increase totalSupply in mint", async function() {
+    let initialSupply = await TestToken.methods.balanceOf(accountsArr[0]).call();
+    await TestToken.methods.mint(100).send({from: accountsArr[0]});
+    let result = await TestToken.methods.totalSupply().call();
+    assert.equal(result, 100);
+  });
+
+  it("should increase accountBalance in mint", async function() {
+    let initialBalance = await TestToken.methods.balanceOf(accountsArr[0]).call();
+    await TestToken.methods.mint(100).send({from: accountsArr[0]});
+    let result = await TestToken.methods.totalSupply().call();
+    assert.equal(result, +initialBalance+100);
+  });
+
+
+});