PayoutContract: Fixing payout distribution, and tests

contracts/security-token/tests/PayoutContract.sol

@@ -7,7 +7,6 @@ contract PayoutContract is InvestorInteractionContract {
   ERC20 payoutToken;
   address from;
   uint256 initialBalance;
-  uint256 oneUnit;
 
   function PayoutContract(CheckpointToken _token, ERC20 _payoutToken, KYCInterface _KYC, bytes32 name, bytes32 URI, uint256 _type, uint256 _hash, bytes32[] _options) InvestorInteractionContract(_token, _KYC, name, URI, _type, _hash, 0, _options) {
     payoutToken = _payoutToken;
@@ -21,11 +20,10 @@ contract PayoutContract is InvestorInteractionContract {
     payoutToken.transferFrom(from, address(this), allowed);
 
     initialBalance = payoutToken.balanceOf(address(this));
-    oneUnit = initialBalance / maximumSupply;
   }
 
   function transferTrigger(address from, address to, uint256 amount) internal {
-    payoutToken.transfer(from, amount * oneUnit);
+    payoutToken.transfer(from, (amount * initialBalance) / maximumSupply);
     super.transferTrigger(from, to, amount);
   }
 

ico/tests/contracts/test_security_token.py

@@ -121,7 +121,7 @@ def security_token_url() -> str:
     return "http://tokenmarket.net/"
 
 @pytest.fixture
-def security_token_initial_supply() -> str:
+def security_token_initial_supply() -> int:
     return 999999999000000000000000000
 
 
@@ -189,18 +189,18 @@ def payout_contract(chain, team_multisig, mock_kyc, security_token, test_token,
 
 @pytest.fixture
 def test_token(chain, team_multisig, token_name, token_symbol, security_token_initial_supply, release_agent, customer) -> Contract:
-    """Create a Crowdsale token where transfer restrictions have been lifted."""
+    """Create a Crowdsale token where transfer restrictions have been lifted. Double the security_token_initial_supply"""
+    """Tokens must be minted in the respective testing functions to test different scenarios"""
 
-    args = [token_name, token_symbol, security_token_initial_supply, 18, True]  # Owner set
+    args = [token_name, token_symbol, 0, 18, True]  # Owner set
 
     tx = {
         "from": team_multisig
     }
 
     token, hash = chain.provider.deploy_contract('CrowdsaleToken', deploy_args=args, deploy_transaction=tx)
-
     token.transact({"from": team_multisig}).setReleaseAgent(team_multisig)
-    token.transact({"from": team_multisig}).releaseTokenTransfer()
+    token.transact({"from": team_multisig}).setMintAgent(team_multisig, True)
 
     return token
 
@@ -504,10 +504,12 @@ def test_voting_contract(chain, voting_contract, security_token, team_multisig,
     check_gas(chain, voting_contract.transact({"from": team_multisig}).transferInvestorTokens(customer, 123))
     check_gas(chain, voting_contract.transact({"from": customer}).importInvestor(customer))
     check_gas(chain, voting_contract.transact({"from": customer}).act(123))
-    return
 
 
-def test_payout_contract(chain, payout_contract, security_token, test_token, team_multisig, customer):
+def test_payout_contract(chain, payout_contract, security_token, security_token_initial_supply, test_token, team_multisig, customer):
+    test_token.transact({"from": team_multisig}).mint(team_multisig, security_token_initial_supply * 2)
+    test_token.transact({"from": team_multisig}).releaseTokenTransfer()
+
     start_balance = test_token.call().balanceOf(team_multisig)
     assert start_balance > 0
     check_gas(chain, test_token.transact({"from": team_multisig}).approve(payout_contract.address, start_balance))
@@ -521,8 +523,27 @@ def test_payout_contract(chain, payout_contract, security_token, test_token, tea
     assert test_token.call().balanceOf(team_multisig) > initial_balance
     # check balance in payout contract
     # 0x0000000000000000000000000000000000000064 is default address(100)
-    assert payout_contract.functions.balanceOf('0x0000000000000000000000000000000000000064').call()
-    return
+    assert payout_contract.functions.balanceOf('0x0000000000000000000000000000000000000064').call() == 123
+
+    remaining_balance = security_token.call().balanceOf(team_multisig) - 123
+    check_gas(chain, payout_contract.transact({"from": team_multisig}).act(remaining_balance))
+    assert payout_contract.functions.balanceOf('0x0000000000000000000000000000000000000064').call() == remaining_balance + 123
+
+    assert test_token.call().balanceOf(team_multisig) == start_balance
+
+
+def test_payout_contract_with_transfer(chain, payout_contract, security_token, security_token_initial_supply, test_token, team_multisig, customer):
+    test_token.transact({"from": team_multisig}).mint(team_multisig, int(security_token_initial_supply / 2))
+    test_token.transact({"from": team_multisig}).releaseTokenTransfer()
+
+    start_balance = test_token.call().balanceOf(team_multisig)
+    assert start_balance > 0
+    check_gas(chain, test_token.transact({"from": team_multisig}).approve(payout_contract.address, start_balance))
+    check_gas(chain, payout_contract.transact({"from": customer}).fetchTokens())
+
+    check_gas(chain, payout_contract.transact({"from": team_multisig}).transfer(customer, security_token.call().balanceOf(team_multisig)))
+    check_gas(chain, payout_contract.transact({"from": customer}).act(security_token.call().balanceOf(team_multisig)))
+    assert test_token.call().balanceOf(customer) == start_balance
 
 
 def test_erc865(chain, security_token, team_multisig, customer, private_key, signer_address):