From 43811e21651465a7326ee5de5ee4e33ce3c67372 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Fri, 14 Jun 2019 18:50:19 +0300
Subject: [PATCH 01/14] waterfall - calculate preferred considerations

---
 contracts/modules/Waterfall.sol | 135 ++++++++++++++++++++++++++++++++
 1 file changed, 135 insertions(+)
 create mode 100644 contracts/modules/Waterfall.sol

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
new file mode 100644
index 0000000..a69abb9
--- /dev/null
+++ b/contracts/modules/Waterfall.sol
@@ -0,0 +1,135 @@
+pragma solidity >=0.4.24 <0.5.0;
+
+import "../open-zeppelin/SafeMath.sol";
+import "../interfaces/IToken.sol";
+import "./bases/Module.sol";
+
+/**
+    @title Waterfall Execution Module
+    @dev Issuer level module for distributing payouts in an exit event
+ */
+contract WaterfallModule is IssuerModuleBase {
+
+    using SafeMath for uint256;
+
+    string public name = "Waterfall";
+    uint256 public mergerConsideration;
+    uint256 public adjustmentAmount;
+
+
+    struct Preferred {
+        uint256 liquidationPrefPerShare;
+        IToken token;
+        bool convertible;
+        bool participating;
+        bool senior;
+    }
+
+    address options;
+    IToken commonToken;
+
+    Preferred[] preferredTokens;
+
+    /**
+        @notice Base constructor
+        @param _owner IssuingEntity contract address
+     */
+    constructor(
+        address _owner,
+        IToken _common,
+        address _options
+    )
+        IssuerModuleBase(_owner)
+        public
+    {
+        _checkToken(_common);
+        commonToken = _common;
+        //_checkToken(_options); TODO
+        options = _options;
+        
+    }
+
+    function _checkToken(IToken _token) internal view {
+        bytes32 _id = _token.ownerID();
+        require (_id == ownerID);
+        require(_token != commonToken);
+        require (_token != options); // TODO
+    }
+
+    function addToken(
+        IToken _token,
+        uint256 _liquidationPrefPerShare,
+        bool _convertible,
+        bool _participating,
+        bool _senior
+    )
+        external
+        returns (bool)
+    {
+        if (!_onlyAuthority()) return false;
+        _checkToken(_token);
+        for (uint256 i; i < preferredTokens.length; i++) {
+            require(_token != preferredTokens[i].token);
+        }
+        preferredTokens.length += 1;
+        Preferred storage t = preferredTokens[preferredTokens.length-1];
+        t.liquidationPrefPerShare = _liquidationPrefPerShare;
+        t.token = _token;
+        t.convertible = _convertible;
+        t.participating = _participating;
+        t.senior = _senior;
+        return true;
+    }
+
+    SeriesConsideration[] considerations;
+    struct SeriesConsideration {
+        IToken token;
+        uint256 dividendAmount;
+        uint256 totalPerShareConsideration;
+    }
+
+    function calculateConsiderations(
+        // uint256 escrowAmount, todo
+        uint256[] dividendAmounts
+    )
+        external
+        payable
+        returns (bool)
+    {
+        if (!_onlyAuthority()) return false;
+        require(dividendAmounts.length == preferredTokens.length);
+
+        uint256 pariPasu = 0;
+        uint256 total = 0;
+        uint remaining = address(this).balance;
+        for (uint256 i = pariPasu; i+1 != 0; i--) {
+            considerations.length++;
+            SeriesConsideration storage c = considerations[considerations.length-1];
+
+            c.token = preferredTokens[i].token;
+            preferredTokens[i].token.circulatingSupply();
+            c.dividendAmount = dividendAmounts[i];
+
+            uint256 _supply = c.token.circulatingSupply();
+            c.totalPerShareConsideration = (
+                preferredTokens[i].liquidationPrefPerShare.add(c.dividendAmount.div(_supply))
+            );
+            total += _supply * c.totalPerShareConsideration;
+            if (preferredTokens[i].senior) {
+                if (total > remaining) {
+                    _reduceConsideration(pariPasu, remaining.mul(1000).div(total));
+                    return true; // rekt
+                }
+                pariPasu = considerations.length;
+            }
+        }
+    }
+
+    function _reduceConsideration(uint256 i, uint256 _pct) internal {
+        for (; i < considerations.length; i++) {
+            considerations[i].totalPerShareConsideration = considerations[i].totalPerShareConsideration.mul(_pct).div(1000);
+        }
+    }
+
+
+}

From df3d10a2b4c6cb75e347bdd8db3e7bf38342b12d Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Fri, 14 Jun 2019 19:00:29 +0300
Subject: [PATCH 02/14] cleanup

---
 contracts/modules/Waterfall.sol | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index a69abb9..a5435c6 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -103,19 +103,17 @@ contract WaterfallModule is IssuerModuleBase {
         uint256 total = 0;
         uint remaining = address(this).balance;
         for (uint256 i = pariPasu; i+1 != 0; i--) {
-            considerations.length++;
-            SeriesConsideration storage c = considerations[considerations.length-1];
-
-            c.token = preferredTokens[i].token;
-            preferredTokens[i].token.circulatingSupply();
-            c.dividendAmount = dividendAmounts[i];
-
-            uint256 _supply = c.token.circulatingSupply();
-            c.totalPerShareConsideration = (
-                preferredTokens[i].liquidationPrefPerShare.add(c.dividendAmount.div(_supply))
-            );
-            total += _supply * c.totalPerShareConsideration;
-            if (preferredTokens[i].senior) {
+            Preferred storage p = preferredTokens[i];
+
+            uint256 _supply = p.token.circulatingSupply();
+            uint256 _prefPerShare = p.liquidationPrefPerShare.add(dividendAmounts[i].div(_supply));
+            considerations.push(SeriesConsideration(
+                p.token,
+                dividendAmounts[i],
+                _prefPerShare
+            ));
+            total += _supply * _prefPerShare;
+            if (p.senior) {
                 if (total > remaining) {
                     _reduceConsideration(pariPasu, remaining.mul(1000).div(total));
                     return true; // rekt

From a4dd6ac956a0eccedfda77779db7226af9260401 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 03:22:46 +0300
Subject: [PATCH 03/14] python implementation for reference (so messy)

---
 waterfall.py | 208 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 208 insertions(+)
 create mode 100644 waterfall.py

diff --git a/waterfall.py b/waterfall.py
new file mode 100644
index 0000000..211765f
--- /dev/null
+++ b/waterfall.py
@@ -0,0 +1,208 @@
+#!/usr/bin/python
+
+from copy import deepcopy
+
+
+class Series:
+
+    def __init__(self, series, share_quantity, preference, convertible, participating, seniority):
+        self.series = series
+        self.share_quantity = share_quantity
+        self.preference_per_share = preference
+        self.payout = 0
+        self.seniority = seniority
+
+        self.participating = participating
+        if participating or not convertible:
+            self.converts = False
+        else:
+            self.can_convert = convertible
+            self.converts = None
+            self.participating = None
+
+    def __bool__(self):
+        return self.converts is not None
+
+    def __repr__(self):
+        if self.converts:
+            return (
+                f"<Common quantity='{self.share_quantity}' payout_per="
+                f"'{self.payout / self.share_quantity}'>"
+            )
+        return (
+            f"<Series {self.series} preferred quanity='{self.share_quantity}' preference_per="
+            f"'{self.preference_per_share}' payout_per='{self.payout / self.share_quantity}'>"
+        )
+
+    def preference_total(self):
+        return self.preference_per_share * self.share_quantity
+
+    def would_convert(self, payout_total, common_total, options, junior):
+        if self.converts is not None:
+            if not junior:
+                return [self.converts]
+            return [self.converts] + junior[0].would_convert(
+                payout_total,
+                common_total,
+                options,
+                junior[1:]
+            )
+
+        if not junior:
+            payout_total += self.payout
+            common_total += self.share_quantity
+            if payout_total / common_total * self.share_quantity < self.payout:
+                return [False]
+            payout_adjusted, common_adjusted, _ = adjust_options(
+                payout_total,
+                common_total,
+                options
+            )
+            return [payout_adjusted / common_adjusted * self.share_quantity > self.payout]
+
+        convert_results = junior[0].would_convert(
+            payout_total + self.payout,
+            common_total + self.share_quantity,
+            options,
+            junior[1:]
+        )
+        adjusted_common, adjusted_payout = common_total, payout_total
+        for i, p in zip(convert_results, junior):
+            if i:
+                adjusted_common += p.share_quantity
+                adjusted_payout += p.payout
+
+        if adjusted_payout / adjusted_common * self.share_quantity < self.payout:
+            return [False] + junior[0].would_convert(
+                payout_total,
+                common_total,
+                options,
+                junior[1:]
+            )
+        adjusted_payout, adjusted_common, _ = adjust_options(
+            adjusted_payout,
+            adjusted_common,
+            options
+        )
+        if adjusted_payout / adjusted_common * self.share_quantity > self.payout:
+            return [True] + convert_results
+        return [False] + junior[0].would_convert(payout_total, common_total, options, junior[1:])
+
+    def set_payout(self, per_share):
+        payout = self.share_quantity * per_share
+        self.payout += payout
+        return payout
+
+
+class Option:
+
+    def __init__(self, quantity, call_value):
+        self.quantity = quantity
+        self.call_value = call_value
+
+    def in_the_money(self, common_total, payout):
+        return payout / (self.quantity + common_total) > self.call_value
+
+    def total(self):
+        return self.call_value * self.quantity
+
+    def adjusted_payout(self, per_share):
+        return (per_share - self.call_value) * self.quantity
+
+    def set_payout(self, per_share):
+        self.payout = (per_share - self.call_value) * self.quantity
+        return self.payout
+
+    def __repr__(self):
+        return (
+            f"<Option call_value='{self.call_value}' quantity='{self.quantity}'"
+            f", payout_per='{self.payout / self.quantity}>"
+        )
+
+
+preferred = [  # quantity, pref_per, convertible, participating, seniority
+    Series('A', 10000, 10, True, False, 1),
+    Series('B', 10000, 11, True, True, 1),
+    Series('C', 10000, 15, True, False, 2),
+    Series('D', 10000, 20, True, False, 2)
+]
+options = [
+    Option(10000, 10),
+    Option(10000, 100),
+    Option(10000, 1),
+    Option(10000, 1000)
+]
+
+
+def run(payout, common, options, preferred):
+
+    options = deepcopy(options)
+    preferred = deepcopy(preferred)
+    participating = [Series('.', common, 0, False, True, False)]
+    participating[0].converts = True
+
+    # remove preference amounts from payout
+    seniority = [
+        [p for p in preferred if p.seniority == i] for i in
+        sorted(set(x.seniority for x in preferred), reverse=True)
+    ]
+    for level in seniority:
+        total = sum(i.preference_total() for i in level)
+        if payout <= total:
+            pct = payout / total
+            payout = 0
+            for p in level:
+                p.payout = p.preference_total() * pct
+            payout = 0
+            participating.clear()
+            break
+        payout -= total
+        for p in level:
+            p.payout = p.preference_total()
+            if p.participating:
+                participating.insert(0, p)
+                common += p.share_quantity
+
+    converts = preferred[-1].would_convert(payout, common, options, preferred[-2::-1])
+    converts.reverse()
+
+    for i in range(len(converts)):
+        if preferred[i].converts is not None:
+            continue
+        p = preferred[i]
+        p.converts = converts[i]
+        if converts[i]:
+            payout += p.payout
+            p.payout = 0
+            participating.append(p)
+
+    if payout:
+        payout_adjusted, common_adjusted, options = adjust_options(
+            payout,
+            sum(i.share_quantity for i in participating),
+            options
+        )
+        per_share = payout_adjusted / common_adjusted
+        participating.extend(options)
+    else:
+        per_share = 0
+    for p in participating:
+        payout_adjusted -= p.set_payout(per_share)
+
+    print('\n\npreferred descending...')
+    for i in preferred[::-1]:
+        print(i)
+    print('\nparticipating...')
+    for i in participating:
+        print(i)
+
+
+def adjust_options(payout, common, options):
+    options = sorted(options, key=lambda k: k.call_value)
+    for i in range(len(options)):
+        if not options[i].in_the_money(common, payout):
+            return payout, common, options[:i]
+        payout += options[i].total()
+        common += options[i].quantity
+    # pay pool if options are claimed, total common stock with claimed options,
+    return payout, common, options

From 5c5341180042249d767f7c1b50134ef23f673494 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 13:14:52 +0300
Subject: [PATCH 04/14] waterfall, calculate preferred considerations (deja
 vu?)

---
 contracts/modules/Waterfall.sol | 80 ++++++++++++++++++++-------------
 1 file changed, 48 insertions(+), 32 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index a5435c6..6612dbe 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -28,7 +28,9 @@ contract WaterfallModule is IssuerModuleBase {
     address options;
     IToken commonToken;
 
-    Preferred[] preferredTokens;
+    Preferred[][] preferredTokens;
+    uint256 public preferredTokenCount;
+
 
     /**
         @notice Base constructor
@@ -46,7 +48,7 @@ contract WaterfallModule is IssuerModuleBase {
         commonToken = _common;
         //_checkToken(_options); TODO
         options = _options;
-        
+
     }
 
     function _checkToken(IToken _token) internal view {
@@ -69,7 +71,13 @@ contract WaterfallModule is IssuerModuleBase {
         if (!_onlyAuthority()) return false;
         _checkToken(_token);
         for (uint256 i; i < preferredTokens.length; i++) {
-            require(_token != preferredTokens[i].token);
+            for (uint256 x; x < preferredTokens[i].length; x++) {
+                require(_token != preferredTokens[i][x].token);
+            }
+        }
+        preferredTokenCount += 1;
+        if (_senior) {
+            preferredTokens.length += 1;
         }
         preferredTokens.length += 1;
         Preferred storage t = preferredTokens[preferredTokens.length-1];
@@ -81,11 +89,12 @@ contract WaterfallModule is IssuerModuleBase {
         return true;
     }
 
-    SeriesConsideration[] considerations;
     struct SeriesConsideration {
+        uint256 perShareConsideration;
+        uint256 totalSupply;
         IToken token;
-        uint256 dividendAmount;
-        uint256 totalPerShareConsideration;
+        bool converting;
+        bool participating;
     }
 
     function calculateConsiderations(
@@ -97,35 +106,42 @@ contract WaterfallModule is IssuerModuleBase {
         returns (bool)
     {
         if (!_onlyAuthority()) return false;
-        require(dividendAmounts.length == preferredTokens.length);
-
-        uint256 pariPasu = 0;
-        uint256 total = 0;
-        uint remaining = address(this).balance;
-        for (uint256 i = pariPasu; i+1 != 0; i--) {
-            Preferred storage p = preferredTokens[i];
-
-            uint256 _supply = p.token.circulatingSupply();
-            uint256 _prefPerShare = p.liquidationPrefPerShare.add(dividendAmounts[i].div(_supply));
-            considerations.push(SeriesConsideration(
-                p.token,
-                dividendAmounts[i],
-                _prefPerShare
-            ));
-            total += _supply * _prefPerShare;
-            if (p.senior) {
-                if (total > remaining) {
-                    _reduceConsideration(pariPasu, remaining.mul(1000).div(total));
-                    return true; // rekt
+        require (dividendAmounts.length == preferredTokenCount);
+
+        // * flatten preferredTokens as _preferredConsiderations
+        // * calculate preferred considerations
+        // * get aggregate total supply
+        uint256 _aggTotalSupply = 0;
+        uint256 _remaining = address(this).balance;
+        uint256 _idx;
+        SeriesConsideration[] memory _preferredConsiderations = new SeriesConsideration[](preferredTokenCount);
+        for (uint256 i = preferredTokens.length - 1; i+1 != 0; i--) {
+            Preferred[] storage _tier = preferredTokens[i];
+            uint256 _tierTotalSupply = 0;
+            uint256 _tierTotalPreference = 0;
+
+            for (uint256 x = 0; x == _tier.length; x++) {
+                SeriesConsideration memory p = _preferredConsiderations[_idx];
+                p.totalSupply = _tier[x].token.circulatingSupply();
+                _tierTotalSupply = _tierTotalSupply.add(p.totalSupply);
+                p.perShareConsideration = _tier[x].liquidationPrefPerShare.add(dividendAmounts[_idx].div(p.totalSupply));
+                if (_tier[x].participating) {
+                    p.participating = true;
                 }
-                pariPasu = considerations.length;
+                _tierTotalPreference = _tierTotalPreference.add(p.totalSupply.mul(p.perShareConsideration));
+                _idx += 1;
+            }
+            if (_tierTotalPreference <= _remaining) {
+                _aggTotalSupply = _aggTotalSupply.add(p.totalSupply);
+                _remaining = _remaining.sub(_tierTotalPreference);
+                continue;
             }
-        }
-    }
 
-    function _reduceConsideration(uint256 i, uint256 _pct) internal {
-        for (; i < considerations.length; i++) {
-            considerations[i].totalPerShareConsideration = considerations[i].totalPerShareConsideration.mul(_pct).div(1000);
+            for (x = _idx - _tier.length; x == _idx; x++) {
+                p = _preferredConsiderations[x];
+                p.perShareConsideration = p.perShareConsideration.mul(_remaining).div(_tierTotalPreference);
+            }
+            return; // TODO - we ran out of moneys
         }
     }
 

From a5ba58ec62f425bf781d37aa0e7ee3937cada106 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 14:58:40 +0300
Subject: [PATCH 05/14] recursive checks for preferred conversion

---
 contracts/modules/Waterfall.sol | 125 ++++++++++++++++++++++++++++++--
 waterfall.py                    |   2 +
 2 files changed, 121 insertions(+), 6 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index 6612dbe..2c76372 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -3,6 +3,7 @@ pragma solidity >=0.4.24 <0.5.0;
 import "../open-zeppelin/SafeMath.sol";
 import "../interfaces/IToken.sol";
 import "./bases/Module.sol";
+import "./VestedOptions.sol";
 
 /**
     @title Waterfall Execution Module
@@ -25,7 +26,7 @@ contract WaterfallModule is IssuerModuleBase {
         bool senior;
     }
 
-    address options;
+    VestedOptions options;
     IToken commonToken;
 
     Preferred[][] preferredTokens;
@@ -39,7 +40,7 @@ contract WaterfallModule is IssuerModuleBase {
     constructor(
         address _owner,
         IToken _common,
-        address _options
+        VestedOptions _options
     )
         IssuerModuleBase(_owner)
         public
@@ -55,7 +56,7 @@ contract WaterfallModule is IssuerModuleBase {
         bytes32 _id = _token.ownerID();
         require (_id == ownerID);
         require(_token != commonToken);
-        require (_token != options); // TODO
+        require (address(_token) != address(options));
     }
 
     function addToken(
@@ -93,7 +94,7 @@ contract WaterfallModule is IssuerModuleBase {
         uint256 perShareConsideration;
         uint256 totalSupply;
         IToken token;
-        bool converting;
+        uint8 converting; // 0: unset, 1: no, 2: yes
         bool participating;
     }
 
@@ -111,7 +112,7 @@ contract WaterfallModule is IssuerModuleBase {
         // * flatten preferredTokens as _preferredConsiderations
         // * calculate preferred considerations
         // * get aggregate total supply
-        uint256 _aggTotalSupply = 0;
+        uint256 _commonTotalSupply = commonToken.circulatingSupply();
         uint256 _remaining = address(this).balance;
         uint256 _idx;
         SeriesConsideration[] memory _preferredConsiderations = new SeriesConsideration[](preferredTokenCount);
@@ -127,12 +128,13 @@ contract WaterfallModule is IssuerModuleBase {
                 p.perShareConsideration = _tier[x].liquidationPrefPerShare.add(dividendAmounts[_idx].div(p.totalSupply));
                 if (_tier[x].participating) {
                     p.participating = true;
+                    p.converting = 1;
+                    _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
                 }
                 _tierTotalPreference = _tierTotalPreference.add(p.totalSupply.mul(p.perShareConsideration));
                 _idx += 1;
             }
             if (_tierTotalPreference <= _remaining) {
-                _aggTotalSupply = _aggTotalSupply.add(p.totalSupply);
                 _remaining = _remaining.sub(_tierTotalPreference);
                 continue;
             }
@@ -143,6 +145,117 @@ contract WaterfallModule is IssuerModuleBase {
             }
             return; // TODO - we ran out of moneys
         }
+
+    bool[] memory _convertDecisions = new bool[](preferredTokenCount);
+    _wouldConvert(
+        _remaining,
+        _commonTotalSupply,
+        _preferredConsiderations,
+        options.getOptions(),
+        0,
+        _convertDecisions
+    );
+
+    }
+
+
+    function _wouldConvert(
+        uint256 _remaining,
+        uint256 _commonTotalSupply,
+        SeriesConsideration[] memory _preferredConsiderations,
+        uint256[2][] memory _options,
+        uint256 _idx,
+        bool[] memory _converts
+    )
+        internal
+    {
+        SeriesConsideration memory p = _preferredConsiderations[_idx];
+        if (p.converting == 1) {
+            /** series is preferred participating - already decided not to convert */
+            if (_idx < _preferredConsiderations.length - 1) {
+                _wouldConvert(
+                    _remaining,
+                    _commonTotalSupply,
+                    _preferredConsiderations,
+                    _options,
+                    _idx+1,
+                    _converts
+                );
+            }
+            return;
+        }
+
+        if (_idx < _preferredConsiderations.length - 1) {
+            /** final preferred series, no more recursion needed */
+            _remaining = _remaining.add(p.perShareConsideration.mul(p.totalSupply));
+            _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
+            if (_remaining.div(_commonTotalSupply) < p.perShareConsideration) {
+                _converts[_idx] = false;
+                return;
+            }
+            (_remaining, _commonTotalSupply) = _adjustOptions(_remaining, _commonTotalSupply, _options);
+            _converts[_idx] = _remaining.div(_commonTotalSupply) > p.perShareConsideration;
+            return;
+        }
+
+        /** get results if this series converts */
+        _wouldConvert(
+            _remaining.add(p.perShareConsideration.mul(p.totalSupply)),
+            _commonTotalSupply.add(p.totalSupply),
+            _preferredConsiderations,
+            _options,
+            _idx+1,
+            _converts
+        );
+
+        uint256 _adjustedRemaining = _remaining;
+        uint256 _adjustedCommon = _commonTotalSupply;
+        for (uint256 i = _idx+1; i < _preferredConsiderations.length; i++) {
+            if (!_converts[i]) continue;
+            SeriesConsideration memory t = _preferredConsiderations[i];
+            _adjustedRemaining = _adjustedRemaining.add(t.perShareConsideration.mul(t.totalSupply));
+            _adjustedCommon = _adjustedCommon.add(t.totalSupply);
+
+        }
+        if (_adjustedRemaining.div(_adjustedCommon) >= p.perShareConsideration) {
+            /** check if conversion is still worthwhile after options are exercised */
+            (_adjustedRemaining, _adjustedCommon) = _adjustOptions(_adjustedRemaining, _adjustedCommon, _options);
+            if (_adjustedRemaining.div(_adjustedCommon) > p.perShareConsideration) {
+                /** converts, bools are already set */
+                _converts[_idx] = true;
+                return;
+            }
+        }
+        /** does not convert, need to reset convert booleans */
+        _converts[_idx] = false;
+        _wouldConvert(
+            _remaining,
+            _commonTotalSupply,
+            _preferredConsiderations,
+            _options,
+            _idx+1,
+            _converts
+        );
+    }
+
+    function _adjustOptions(
+        uint256 _remaining,
+        uint256 _commonTotalSupply,
+        uint256[2][] memory _options // [(exercise price, total options at price), .. ]
+    )
+        internal
+        returns (uint256, uint256)
+    {
+        for (uint256 i; i < _options.length; i++) {
+            uint256[2] memory o = _options[i];
+            if (_remaining.div(o[1].add(_commonTotalSupply)) <= o[0]) {
+                // option is not in the money
+                break;
+            }
+            _remaining = _remaining.add(o[0].mul(o[1]));
+            _commonTotalSupply = _commonTotalSupply.add(o[1]);
+        }
+        return (_remaining, _commonTotalSupply);
     }
 
 
diff --git a/waterfall.py b/waterfall.py
index 211765f..8dbc1fb 100644
--- a/waterfall.py
+++ b/waterfall.py
@@ -166,6 +166,8 @@ def run(payout, common, options, preferred):
     converts = preferred[-1].would_convert(payout, common, options, preferred[-2::-1])
     converts.reverse()
 
+    ## finished up to here
+
     for i in range(len(converts)):
         if preferred[i].converts is not None:
             continue

From 90e60367bda37929db65313b16a9afc3359bf118 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 18:47:40 +0300
Subject: [PATCH 06/14] waterfall calculation logic complete

---
 contracts/modules/Waterfall.sol | 56 +++++++++++++++++++++++----------
 waterfall.py                    |  2 --
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index 2c76372..23e6d97 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -26,12 +26,13 @@ contract WaterfallModule is IssuerModuleBase {
         bool senior;
     }
 
-    VestedOptions options;
+    VestedOptions commonOptions;
     IToken commonToken;
 
     Preferred[][] preferredTokens;
     uint256 public preferredTokenCount;
 
+    mapping (address => uint256) perShareConsiderations;
 
     /**
         @notice Base constructor
@@ -47,16 +48,20 @@ contract WaterfallModule is IssuerModuleBase {
     {
         _checkToken(_common);
         commonToken = _common;
-        //_checkToken(_options); TODO
-        options = _options;
+        require(_options.ownerID() == ownerID);
+        commonOptions = _options;
 
     }
 
     function _checkToken(IToken _token) internal view {
-        bytes32 _id = _token.ownerID();
-        require (_id == ownerID);
-        require(_token != commonToken);
-        require (address(_token) != address(options));
+        require(_token.ownerID() == ownerID);
+        require(perShareConsiderations[_token] == 0);
+        perShareConsiderations[_token] = ~uint256(0);
+    }
+
+    function getPerShareConsideration(address _token) external view returns (uint256) {
+        require(perShareConsiderations[_token] != ~uint256(0));
+        return perShareConsiderations[_token];
     }
 
     function addToken(
@@ -71,17 +76,13 @@ contract WaterfallModule is IssuerModuleBase {
     {
         if (!_onlyAuthority()) return false;
         _checkToken(_token);
-        for (uint256 i; i < preferredTokens.length; i++) {
-            for (uint256 x; x < preferredTokens[i].length; x++) {
-                require(_token != preferredTokens[i][x].token);
-            }
-        }
         preferredTokenCount += 1;
         if (_senior) {
             preferredTokens.length += 1;
         }
-        preferredTokens.length += 1;
-        Preferred storage t = preferredTokens[preferredTokens.length-1];
+        uint256 i = preferredTokens.length-1;
+        preferredTokens[i].length += 1;
+        Preferred storage t = preferredTokens[i][preferredTokens[i].length-1];
         t.liquidationPrefPerShare = _liquidationPrefPerShare;
         t.token = _token;
         t.convertible = _convertible;
@@ -115,7 +116,7 @@ contract WaterfallModule is IssuerModuleBase {
         uint256 _commonTotalSupply = commonToken.circulatingSupply();
         uint256 _remaining = address(this).balance;
         uint256 _idx;
-        SeriesConsideration[] memory _preferredConsiderations = new SeriesConsideration[](preferredTokenCount);
+        SeriesConsideration[] memory _preferredConsiderations = new SeriesConsideration[](dividendAmounts.length);
         for (uint256 i = preferredTokens.length - 1; i+1 != 0; i--) {
             Preferred[] storage _tier = preferredTokens[i];
             uint256 _tierTotalSupply = 0;
@@ -146,16 +147,37 @@ contract WaterfallModule is IssuerModuleBase {
             return; // TODO - we ran out of moneys
         }
 
-    bool[] memory _convertDecisions = new bool[](preferredTokenCount);
+    bool[] memory _convertDecisions = new bool[](dividendAmounts.length);
+    uint256[2][] memory _options = commonOptions.getOptions();
     _wouldConvert(
         _remaining,
         _commonTotalSupply,
         _preferredConsiderations,
-        options.getOptions(),
+        _options,
         0,
         _convertDecisions
     );
 
+    for (i = 0; i < _convertDecisions.length; i++) {
+        if (!_convertDecisions[i]) continue;
+        p = _preferredConsiderations[i];
+        _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
+        _remaining = _remaining.add(p.perShareConsideration.mul(p.totalSupply));
+        p.perShareConsideration = 0;
+    }
+    (_remaining, _commonTotalSupply) = _adjustOptions(_remaining, _commonTotalSupply, _options);
+    uint256 _commonPerShareConsideration = _remaining.div(_commonTotalSupply);
+
+    for (i = 0; i < _preferredConsiderations.length; i++) {
+        p = _preferredConsiderations[i];
+        if (p.participating) {
+            perShareConsiderations[p.token] = p.perShareConsideration + _commonPerShareConsideration;
+        } else {
+            perShareConsiderations[p.token] = p.perShareConsideration;
+        }
+    }
+    perShareConsiderations[commonToken] = _commonPerShareConsideration;
+
     }
 
 
diff --git a/waterfall.py b/waterfall.py
index 8dbc1fb..211765f 100644
--- a/waterfall.py
+++ b/waterfall.py
@@ -166,8 +166,6 @@ def run(payout, common, options, preferred):
     converts = preferred[-1].would_convert(payout, common, options, preferred[-2::-1])
     converts.reverse()
 
-    ## finished up to here
-
     for i in range(len(converts)):
         if preferred[i].converts is not None:
             continue

From 050023e831d8e1a573b38b72f1304c703852baa5 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 20:19:13 +0300
Subject: [PATCH 07/14] formatting, rename variables

---
 contracts/modules/Waterfall.sol | 213 +++++++++++++++++---------------
 1 file changed, 116 insertions(+), 97 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index 23e6d97..d5b3c9a 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -15,24 +15,30 @@ contract WaterfallModule is IssuerModuleBase {
 
     string public name = "Waterfall";
     uint256 public mergerConsideration;
-    uint256 public adjustmentAmount;
 
+    VestedOptions commonOptions;
+    IToken commonToken;
+
+    PreferredSeries[][] preferredTokens;
+    uint256 public preferredTokenCount;
+
+    mapping (address => uint256) perShareConsideration;
 
-    struct Preferred {
-        uint256 liquidationPrefPerShare;
+    struct PreferredSeries {
+        uint256 prefPerShare;
         IToken token;
         bool convertible;
         bool participating;
         bool senior;
     }
 
-    VestedOptions commonOptions;
-    IToken commonToken;
-
-    Preferred[][] preferredTokens;
-    uint256 public preferredTokenCount;
-
-    mapping (address => uint256) perShareConsiderations;
+    struct Consideration {
+        uint256 perShare;
+        uint256 totalSupply;
+        IToken token;
+        uint8 converting; // 0: unset, 1: no, 2: yes
+        bool participating;
+    }
 
     /**
         @notice Base constructor
@@ -55,18 +61,24 @@ contract WaterfallModule is IssuerModuleBase {
 
     function _checkToken(IToken _token) internal view {
         require(_token.ownerID() == ownerID);
-        require(perShareConsiderations[_token] == 0);
-        perShareConsiderations[_token] = ~uint256(0);
+        require(perShareConsideration[_token] == 0);
+        perShareConsideration[_token] = ~uint256(0);
     }
 
-    function getPerShareConsideration(address _token) external view returns (uint256) {
-        require(perShareConsiderations[_token] != ~uint256(0));
-        return perShareConsiderations[_token];
+    function getPerShare(
+        address _token
+    )
+        external
+        view
+        returns (uint256)
+    {
+        if (perShareConsideration[_token] == ~uint256(0)) return 0;
+        return perShareConsideration[_token];
     }
 
     function addToken(
         IToken _token,
-        uint256 _liquidationPrefPerShare,
+        uint256 _prefPerShare,
         bool _convertible,
         bool _participating,
         bool _senior
@@ -80,10 +92,10 @@ contract WaterfallModule is IssuerModuleBase {
         if (_senior) {
             preferredTokens.length += 1;
         }
-        uint256 i = preferredTokens.length-1;
+        uint256 i = preferredTokens.length - 1;
         preferredTokens[i].length += 1;
-        Preferred storage t = preferredTokens[i][preferredTokens[i].length-1];
-        t.liquidationPrefPerShare = _liquidationPrefPerShare;
+        PreferredSeries storage t = preferredTokens[i][preferredTokens[i].length-1];
+        t.prefPerShare = _prefPerShare;
         t.token = _token;
         t.convertible = _convertible;
         t.participating = _participating;
@@ -91,14 +103,6 @@ contract WaterfallModule is IssuerModuleBase {
         return true;
     }
 
-    struct SeriesConsideration {
-        uint256 perShareConsideration;
-        uint256 totalSupply;
-        IToken token;
-        uint8 converting; // 0: unset, 1: no, 2: yes
-        bool participating;
-    }
-
     function calculateConsiderations(
         // uint256 escrowAmount, todo
         uint256[] dividendAmounts
@@ -108,97 +112,104 @@ contract WaterfallModule is IssuerModuleBase {
         returns (bool)
     {
         if (!_onlyAuthority()) return false;
-        require (dividendAmounts.length == preferredTokenCount);
+        require(dividendAmounts.length == preferredTokenCount);
 
-        // * flatten preferredTokens as _preferredConsiderations
+        // * flatten preferredTokens as _preferred
         // * calculate preferred considerations
         // * get aggregate total supply
         uint256 _commonTotalSupply = commonToken.circulatingSupply();
-        uint256 _remaining = address(this).balance;
+        uint256 _remainingTotal = address(this).balance;
+        mergerConsideration = _remainingTotal;
         uint256 _idx;
-        SeriesConsideration[] memory _preferredConsiderations = new SeriesConsideration[](dividendAmounts.length);
+        Consideration[] memory _preferred = new Consideration[](dividendAmounts.length);
         for (uint256 i = preferredTokens.length - 1; i+1 != 0; i--) {
-            Preferred[] storage _tier = preferredTokens[i];
-            uint256 _tierTotalSupply = 0;
-            uint256 _tierTotalPreference = 0;
+            PreferredSeries[] storage _tier = preferredTokens[i];
+            uint256 _tierSupply = 0;
+            uint256 _tierTotal = 0;
 
             for (uint256 x = 0; x == _tier.length; x++) {
-                SeriesConsideration memory p = _preferredConsiderations[_idx];
+                Consideration memory p = _preferred[_idx];
                 p.totalSupply = _tier[x].token.circulatingSupply();
-                _tierTotalSupply = _tierTotalSupply.add(p.totalSupply);
-                p.perShareConsideration = _tier[x].liquidationPrefPerShare.add(dividendAmounts[_idx].div(p.totalSupply));
+                _tierSupply = _tierSupply.add(p.totalSupply);
+                p.perShare = _tier[x].prefPerShare.add(
+                    dividendAmounts[_idx].div(p.totalSupply)
+                );
                 if (_tier[x].participating) {
                     p.participating = true;
                     p.converting = 1;
                     _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
                 }
-                _tierTotalPreference = _tierTotalPreference.add(p.totalSupply.mul(p.perShareConsideration));
+                _tierTotal = _tierTotal.add(p.totalSupply.mul(p.perShare));
                 _idx += 1;
             }
-            if (_tierTotalPreference <= _remaining) {
-                _remaining = _remaining.sub(_tierTotalPreference);
+
+            if (_tierTotal <= _remainingTotal) {
+                _remainingTotal = _remainingTotal.sub(_tierTotal);
                 continue;
             }
 
             for (x = _idx - _tier.length; x == _idx; x++) {
-                p = _preferredConsiderations[x];
-                p.perShareConsideration = p.perShareConsideration.mul(_remaining).div(_tierTotalPreference);
+                p = _preferred[x];
+                p.perShare = p.perShare.mul(_remainingTotal).div(_tierTotal);
             }
+
             return; // TODO - we ran out of moneys
         }
 
-    bool[] memory _convertDecisions = new bool[](dividendAmounts.length);
-    uint256[2][] memory _options = commonOptions.getOptions();
-    _wouldConvert(
-        _remaining,
-        _commonTotalSupply,
-        _preferredConsiderations,
-        _options,
-        0,
-        _convertDecisions
-    );
-
-    for (i = 0; i < _convertDecisions.length; i++) {
-        if (!_convertDecisions[i]) continue;
-        p = _preferredConsiderations[i];
-        _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
-        _remaining = _remaining.add(p.perShareConsideration.mul(p.totalSupply));
-        p.perShareConsideration = 0;
-    }
-    (_remaining, _commonTotalSupply) = _adjustOptions(_remaining, _commonTotalSupply, _options);
-    uint256 _commonPerShareConsideration = _remaining.div(_commonTotalSupply);
+        bool[] memory _convertDecisions = new bool[](dividendAmounts.length);
+        uint256[2][] memory _options = commonOptions.getOptions();
+        _wouldConvert(
+            _remainingTotal,
+            _commonTotalSupply,
+            _preferred,
+            _options,
+            0,
+            _convertDecisions
+        );
 
-    for (i = 0; i < _preferredConsiderations.length; i++) {
-        p = _preferredConsiderations[i];
-        if (p.participating) {
-            perShareConsiderations[p.token] = p.perShareConsideration + _commonPerShareConsideration;
-        } else {
-            perShareConsiderations[p.token] = p.perShareConsideration;
+        for (i = 0; i < _convertDecisions.length; i++) {
+            if (!_convertDecisions[i]) continue;
+            p = _preferred[i];
+            _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
+            _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
+            p.perShare = 0;
         }
-    }
-    perShareConsiderations[commonToken] = _commonPerShareConsideration;
+        (_remainingTotal, _commonTotalSupply) = _adjustOptions(
+            _remainingTotal,
+            _commonTotalSupply,
+            _options
+        );
 
+        uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
+        perShareConsideration[commonToken] = _commonPerShare;
+        for (i = 0; i < _preferred.length; i++) {
+            p = _preferred[i];
+            if (p.participating) {
+                perShareConsideration[p.token] = p.perShare.add(_commonPerShare);
+            } else {
+                perShareConsideration[p.token] = p.perShare;
+            }
+        }
     }
 
-
     function _wouldConvert(
-        uint256 _remaining,
+        uint256 _remainingTotal,
         uint256 _commonTotalSupply,
-        SeriesConsideration[] memory _preferredConsiderations,
+        Consideration[] memory _preferred,
         uint256[2][] memory _options,
         uint256 _idx,
         bool[] memory _converts
     )
         internal
     {
-        SeriesConsideration memory p = _preferredConsiderations[_idx];
+        Consideration memory p = _preferred[_idx];
         if (p.converting == 1) {
             /** series is preferred participating - already decided not to convert */
-            if (_idx < _preferredConsiderations.length - 1) {
+            if (_idx < _preferred.length - 1) {
                 _wouldConvert(
-                    _remaining,
+                    _remainingTotal,
                     _commonTotalSupply,
-                    _preferredConsiderations,
+                    _preferred,
                     _options,
                     _idx+1,
                     _converts
@@ -207,42 +218,50 @@ contract WaterfallModule is IssuerModuleBase {
             return;
         }
 
-        if (_idx < _preferredConsiderations.length - 1) {
+        if (_idx < _preferred.length - 1) {
             /** final preferred series, no more recursion needed */
-            _remaining = _remaining.add(p.perShareConsideration.mul(p.totalSupply));
+            _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
             _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
-            if (_remaining.div(_commonTotalSupply) < p.perShareConsideration) {
+            if (_remainingTotal.div(_commonTotalSupply) < p.perShare) {
                 _converts[_idx] = false;
                 return;
             }
-            (_remaining, _commonTotalSupply) = _adjustOptions(_remaining, _commonTotalSupply, _options);
-            _converts[_idx] = _remaining.div(_commonTotalSupply) > p.perShareConsideration;
+            (_remainingTotal, _commonTotalSupply) = _adjustOptions(
+                _remainingTotal,
+                _commonTotalSupply,
+                _options
+            );
+            _converts[_idx] = _remainingTotal.div(_commonTotalSupply) > p.perShare;
             return;
         }
 
         /** get results if this series converts */
         _wouldConvert(
-            _remaining.add(p.perShareConsideration.mul(p.totalSupply)),
+            _remainingTotal.add(p.perShare.mul(p.totalSupply)),
             _commonTotalSupply.add(p.totalSupply),
-            _preferredConsiderations,
+            _preferred,
             _options,
             _idx+1,
             _converts
         );
 
-        uint256 _adjustedRemaining = _remaining;
+        uint256 _adjustedRemaining = _remainingTotal;
         uint256 _adjustedCommon = _commonTotalSupply;
-        for (uint256 i = _idx+1; i < _preferredConsiderations.length; i++) {
+        for (uint256 i = _idx+1; i < _preferred.length; i++) {
             if (!_converts[i]) continue;
-            SeriesConsideration memory t = _preferredConsiderations[i];
-            _adjustedRemaining = _adjustedRemaining.add(t.perShareConsideration.mul(t.totalSupply));
+            Consideration memory t = _preferred[i];
+            _adjustedRemaining = _adjustedRemaining.add(t.perShare.mul(t.totalSupply));
             _adjustedCommon = _adjustedCommon.add(t.totalSupply);
 
         }
-        if (_adjustedRemaining.div(_adjustedCommon) >= p.perShareConsideration) {
+        if (_adjustedRemaining.div(_adjustedCommon) >= p.perShare) {
             /** check if conversion is still worthwhile after options are exercised */
-            (_adjustedRemaining, _adjustedCommon) = _adjustOptions(_adjustedRemaining, _adjustedCommon, _options);
-            if (_adjustedRemaining.div(_adjustedCommon) > p.perShareConsideration) {
+            (_adjustedRemaining, _adjustedCommon) = _adjustOptions(
+                _adjustedRemaining,
+                _adjustedCommon,
+                _options
+            );
+            if (_adjustedRemaining.div(_adjustedCommon) > p.perShare) {
                 /** converts, bools are already set */
                 _converts[_idx] = true;
                 return;
@@ -251,9 +270,9 @@ contract WaterfallModule is IssuerModuleBase {
         /** does not convert, need to reset convert booleans */
         _converts[_idx] = false;
         _wouldConvert(
-            _remaining,
+            _remainingTotal,
             _commonTotalSupply,
-            _preferredConsiderations,
+            _preferred,
             _options,
             _idx+1,
             _converts
@@ -261,7 +280,7 @@ contract WaterfallModule is IssuerModuleBase {
     }
 
     function _adjustOptions(
-        uint256 _remaining,
+        uint256 _remainingTotal,
         uint256 _commonTotalSupply,
         uint256[2][] memory _options // [(exercise price, total options at price), .. ]
     )
@@ -270,14 +289,14 @@ contract WaterfallModule is IssuerModuleBase {
     {
         for (uint256 i; i < _options.length; i++) {
             uint256[2] memory o = _options[i];
-            if (_remaining.div(o[1].add(_commonTotalSupply)) <= o[0]) {
+            if (_remainingTotal.div(o[1].add(_commonTotalSupply)) <= o[0]) {
                 // option is not in the money
                 break;
             }
-            _remaining = _remaining.add(o[0].mul(o[1]));
+            _remainingTotal = _remainingTotal.add(o[0].mul(o[1]));
             _commonTotalSupply = _commonTotalSupply.add(o[1]);
         }
-        return (_remaining, _commonTotalSupply);
+        return (_remainingTotal, _commonTotalSupply);
     }
 
 

From ba60f3fc2b325551418fa3c658404e2a5ad61bac Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 20:21:12 +0300
Subject: [PATCH 08/14] logic for out-of-funds during preferred

---
 contracts/modules/Waterfall.sol | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index d5b3c9a..0445acd 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -148,12 +148,17 @@ contract WaterfallModule is IssuerModuleBase {
                 continue;
             }
 
-            for (x = _idx - _tier.length; x == _idx; x++) {
+            for (x = _idx -1; x + 1 != 0; x--) {
                 p = _preferred[x];
-                p.perShare = p.perShare.mul(_remainingTotal).div(_tierTotal);
+                if (x >= _idx-_tier.length) {
+                    perShareConsideration[p.token] = (
+                        p.perShare.mul(_remainingTotal).div(_tierTotal)
+                    );
+                } else {
+                    perShareConsideration[p.token] = p.perShare;
+                }
             }
-
-            return; // TODO - we ran out of moneys
+            return;
         }
 
         bool[] memory _convertDecisions = new bool[](dividendAmounts.length);

From 0709b972bb67dfaddd0fecd40982d8b878421754 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sun, 16 Jun 2019 22:47:49 +0300
Subject: [PATCH 09/14] change converting uint8 to notConverting bool

---
 contracts/modules/Waterfall.sol | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index 0445acd..b364c29 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -36,10 +36,16 @@ contract WaterfallModule is IssuerModuleBase {
         uint256 perShare;
         uint256 totalSupply;
         IToken token;
-        uint8 converting; // 0: unset, 1: no, 2: yes
+        bool notConverting;
         bool participating;
     }
 
+    function _checkToken(IToken _token) internal {
+        require(_token.ownerID() == ownerID);
+        require(perShareConsideration[_token] == 0);
+        perShareConsideration[_token] = ~uint256(0);
+    }
+
     /**
         @notice Base constructor
         @param _owner IssuingEntity contract address
@@ -59,12 +65,6 @@ contract WaterfallModule is IssuerModuleBase {
 
     }
 
-    function _checkToken(IToken _token) internal view {
-        require(_token.ownerID() == ownerID);
-        require(perShareConsideration[_token] == 0);
-        perShareConsideration[_token] = ~uint256(0);
-    }
-
     function getPerShare(
         address _token
     )
@@ -134,13 +134,17 @@ contract WaterfallModule is IssuerModuleBase {
                 p.perShare = _tier[x].prefPerShare.add(
                     dividendAmounts[_idx].div(p.totalSupply)
                 );
+                _tierTotal = _tierTotal.add(p.totalSupply.mul(p.perShare));
+                _idx += 1;
+                if (_tier[x].convertible && !_tier[x].participating) continue;
+
+                /** if participating or non-convertible, do not convert to common */
+                p.notConverting = true;
                 if (_tier[x].participating) {
+                    /** if preferred participating, increase common total supply */
                     p.participating = true;
-                    p.converting = 1;
                     _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
                 }
-                _tierTotal = _tierTotal.add(p.totalSupply.mul(p.perShare));
-                _idx += 1;
             }
 
             if (_tierTotal <= _remainingTotal) {
@@ -208,7 +212,7 @@ contract WaterfallModule is IssuerModuleBase {
         internal
     {
         Consideration memory p = _preferred[_idx];
-        if (p.converting == 1) {
+        if (p.notConverting) {
             /** series is preferred participating - already decided not to convert */
             if (_idx < _preferred.length - 1) {
                 _wouldConvert(

From df6d0f1e2db0144986cf65f5d0a2cda84db5263e Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Mon, 17 Jun 2019 04:13:13 +0300
Subject: [PATCH 10/14] cleanup, comments

---
 contracts/modules/Waterfall.sol | 90 +++++++++++++++++++++++++--------
 1 file changed, 70 insertions(+), 20 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index b364c29..ab4dac5 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -40,6 +40,10 @@ contract WaterfallModule is IssuerModuleBase {
         bool participating;
     }
 
+    /**
+        @dev check validity and uniqueness of token
+        @param _token token address
+     */
     function _checkToken(IToken _token) internal {
         require(_token.ownerID() == ownerID);
         require(perShareConsideration[_token] == 0);
@@ -49,6 +53,8 @@ contract WaterfallModule is IssuerModuleBase {
     /**
         @notice Base constructor
         @param _owner IssuingEntity contract address
+        @param _common "Common stock" token contract address
+        @param _options "Common stock options" token contract address
      */
     constructor(
         address _owner,
@@ -62,9 +68,13 @@ contract WaterfallModule is IssuerModuleBase {
         commonToken = _common;
         require(_options.ownerID() == ownerID);
         commonOptions = _options;
-
     }
 
+    /**
+        @notice Get the calculated per-share consideration for a token
+        @param _token token contract address
+        @return uint256 per-share consideration
+     */
     function getPerShare(
         address _token
     )
@@ -76,6 +86,16 @@ contract WaterfallModule is IssuerModuleBase {
         return perShareConsideration[_token];
     }
 
+    /**
+        @notice add a new preferred token
+        @dev tokens must be added in order of seniority
+        @param _token token contract address
+        @param _prefPerShare per-share liquidation preference
+        @param _convertible is token convertible to common?
+        @param _participating is token participating?
+        @param _senior is token senior to previous series?
+        @return bool success
+     */
     function addToken(
         IToken _token,
         uint256 _prefPerShare,
@@ -87,6 +107,7 @@ contract WaterfallModule is IssuerModuleBase {
         returns (bool)
     {
         if (!_onlyAuthority()) return false;
+        require(mergerConsideration == 0);
         _checkToken(_token);
         preferredTokenCount += 1;
         if (_senior) {
@@ -103,25 +124,30 @@ contract WaterfallModule is IssuerModuleBase {
         return true;
     }
 
+    /**
+        @notice calculate token waterfall
+        @param _mergerConsideration Total amount of merger consideration
+        @param _dividendAmounts Array of dividend total amounts, descending seniority
+        @return bool success
+     */
     function calculateConsiderations(
-        // uint256 escrowAmount, todo
-        uint256[] dividendAmounts
+        uint256 _mergerConsideration,
+        uint256[] _dividendAmounts
     )
         external
-        payable
         returns (bool)
     {
         if (!_onlyAuthority()) return false;
-        require(dividendAmounts.length == preferredTokenCount);
+        require(mergerConsideration == 0);
+        require(_dividendAmounts.length == preferredTokenCount);
 
-        // * flatten preferredTokens as _preferred
-        // * calculate preferred considerations
-        // * get aggregate total supply
+        mergerConsideration = _mergerConsideration;
+        uint256 _remainingTotal = _mergerConsideration;
         uint256 _commonTotalSupply = commonToken.circulatingSupply();
-        uint256 _remainingTotal = address(this).balance;
-        mergerConsideration = _remainingTotal;
         uint256 _idx;
-        Consideration[] memory _preferred = new Consideration[](dividendAmounts.length);
+        Consideration[] memory _preferred = new Consideration[](_dividendAmounts.length);
+
+        /** calculate preferred considerations */
         for (uint256 i = preferredTokens.length - 1; i+1 != 0; i--) {
             PreferredSeries[] storage _tier = preferredTokens[i];
             uint256 _tierSupply = 0;
@@ -132,7 +158,7 @@ contract WaterfallModule is IssuerModuleBase {
                 p.totalSupply = _tier[x].token.circulatingSupply();
                 _tierSupply = _tierSupply.add(p.totalSupply);
                 p.perShare = _tier[x].prefPerShare.add(
-                    dividendAmounts[_idx].div(p.totalSupply)
+                    _dividendAmounts[_idx].div(p.totalSupply)
                 );
                 _tierTotal = _tierTotal.add(p.totalSupply.mul(p.perShare));
                 _idx += 1;
@@ -148,13 +174,16 @@ contract WaterfallModule is IssuerModuleBase {
             }
 
             if (_tierTotal <= _remainingTotal) {
+                /** total preference for tier is < remaining consideration */
                 _remainingTotal = _remainingTotal.sub(_tierTotal);
                 continue;
             }
 
+            /** no consideration left - save results to storage */
             for (x = _idx -1; x + 1 != 0; x--) {
                 p = _preferred[x];
                 if (x >= _idx-_tier.length) {
+                    /** distrubte remaining consideration pro-rata across tier */
                     perShareConsideration[p.token] = (
                         p.perShare.mul(_remainingTotal).div(_tierTotal)
                     );
@@ -165,9 +194,10 @@ contract WaterfallModule is IssuerModuleBase {
             return;
         }
 
-        bool[] memory _convertDecisions = new bool[](dividendAmounts.length);
+        /** determine rational choices for non-participating convertible */
+        bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
         uint256[2][] memory _options = commonOptions.getOptions();
-        _wouldConvert(
+        _recursiveConversionCheck(
             _remainingTotal,
             _commonTotalSupply,
             _preferred,
@@ -176,6 +206,7 @@ contract WaterfallModule is IssuerModuleBase {
             _convertDecisions
         );
 
+        /** calculate final in-money options and common per-share condsideration */
         for (i = 0; i < _convertDecisions.length; i++) {
             if (!_convertDecisions[i]) continue;
             p = _preferred[i];
@@ -189,6 +220,7 @@ contract WaterfallModule is IssuerModuleBase {
             _options
         );
 
+        /** save results to storage */
         uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
         perShareConsideration[commonToken] = _commonPerShare;
         for (i = 0; i < _preferred.length; i++) {
@@ -201,7 +233,17 @@ contract WaterfallModule is IssuerModuleBase {
         }
     }
 
-    function _wouldConvert(
+    /**
+        @notice Determine whether or not to convert a preferred series
+        @dev Called recursively, modifies _converts in place to pass results
+        @param _remainingTotal remaining merger consideration
+        @param _commonTotalSupply aggregate total common shares
+        @param _preferred array of preferred series data
+        @param _options options data array from VestedOptions.getOptions()
+        @param _idx index of _preferred this call is looking at
+        @param _converts boolean array of conversion decisions
+     */
+    function _recursiveConversionCheck(
         uint256 _remainingTotal,
         uint256 _commonTotalSupply,
         Consideration[] memory _preferred,
@@ -215,7 +257,7 @@ contract WaterfallModule is IssuerModuleBase {
         if (p.notConverting) {
             /** series is preferred participating - already decided not to convert */
             if (_idx < _preferred.length - 1) {
-                _wouldConvert(
+                _recursiveConversionCheck(
                     _remainingTotal,
                     _commonTotalSupply,
                     _preferred,
@@ -245,7 +287,7 @@ contract WaterfallModule is IssuerModuleBase {
         }
 
         /** get results if this series converts */
-        _wouldConvert(
+        _recursiveConversionCheck(
             _remainingTotal.add(p.perShare.mul(p.totalSupply)),
             _commonTotalSupply.add(p.totalSupply),
             _preferred,
@@ -278,7 +320,7 @@ contract WaterfallModule is IssuerModuleBase {
         }
         /** does not convert, need to reset convert booleans */
         _converts[_idx] = false;
-        _wouldConvert(
+        _recursiveConversionCheck(
             _remainingTotal,
             _commonTotalSupply,
             _preferred,
@@ -288,10 +330,18 @@ contract WaterfallModule is IssuerModuleBase {
         );
     }
 
+    /**
+        @notice Calculate adjusted consideration and supply from in-money options
+        @param _remainingTotal remaining merger consideration
+        @param _commonTotalSupply aggregate total common shares
+        @param _options options data array from VestedOptions.getOptions()
+                        [(exercise price, total options at price), .. ]
+        @return adjusted consideration, adjusted total common shares
+     */
     function _adjustOptions(
         uint256 _remainingTotal,
         uint256 _commonTotalSupply,
-        uint256[2][] memory _options // [(exercise price, total options at price), .. ]
+        uint256[2][] memory _options
     )
         internal
         returns (uint256, uint256)
@@ -299,7 +349,7 @@ contract WaterfallModule is IssuerModuleBase {
         for (uint256 i; i < _options.length; i++) {
             uint256[2] memory o = _options[i];
             if (_remainingTotal.div(o[1].add(_commonTotalSupply)) <= o[0]) {
-                // option is not in the money
+                /** options >= this price are not in the money */
                 break;
             }
             _remainingTotal = _remainingTotal.add(o[0].mul(o[1]));

From 4c60f78f8e4fc499a11a4cab6039b0ed0eb7e41b Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Wed, 19 Jun 2019 02:03:15 +0000
Subject: [PATCH 11/14] getters

---
 contracts/modules/VestedOptions.sol | 49 +++++++++++++++++++++++++++--
 contracts/modules/Waterfall.sol     |  6 ++--
 2 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/contracts/modules/VestedOptions.sol b/contracts/modules/VestedOptions.sol
index c27cce0..2a7651b 100644
--- a/contracts/modules/VestedOptions.sol
+++ b/contracts/modules/VestedOptions.sol
@@ -303,6 +303,51 @@ contract VestedOptions is STModuleBase {
         return (_optionCount, _totalExercisePrice);
     }
 
+    function getInMoneyOptions(
+        bytes32 _id,
+        uint256 _perShareConsideration
+    )
+        external
+        view
+        returns (
+            uint256 _optionCount,
+            uint256 _totalExercicePrice
+        )
+    {
+        Option[] storage o = optionData[_id];
+        for (uint i; i < o.length; i++) {
+            if (o[i].exercisePrice >= _perShareConsideration) continue;
+            uint256 _price = uint256(o[i].amount).mul(o[i].exercisePrice);
+            _totalExercicePrice = _totalExercicePrice.add(_price);
+            _optionCount = _optionCount.add(o[i].amount);
+        }
+        return (_optionCount, _totalExercicePrice);
+    }
+
+    function getOptions(
+        bytes32 _id,
+        uint256 _index
+    )
+        external
+        view
+        returns (
+            uint256 _amount,
+            uint256 _exercisePrice,
+            uint256 _creationDate,
+            uint256 _vestDate,
+            uint256 _expiryDate
+        )
+    {
+        Option storage o = optionData[_id][_index];
+        return (
+            o.amount,
+            o.exercisePrice,
+            o.creationDate,
+            o.vestDate,
+            uint256(o.creationDate).add(_expiryDate)
+        );
+    }
+
     /**
         @notice Modify eth peg
         @dev
@@ -345,7 +390,7 @@ contract VestedOptions is STModuleBase {
         Option storage o = _saveOption(_id, _price, _iso);
 
         uint32 _total;
-        uint256[2] memory _max = [t.length - 1, uint256(expirationMonths)]; 
+        uint256[2] memory _max = [t.length - 1, uint256(expirationMonths)];
 
         for (uint256 i; i < _amount.length; i++) {
             require(_monthsToVest[i] < _max[1]); // dev: vest > expiration
@@ -577,7 +622,7 @@ contract VestedOptions is STModuleBase {
     function _accellerateOrTerminate(
         OptionBase storage b,
         uint32 _price,
-        uint32 _gracePeriod 
+        uint32 _gracePeriod
     )
         internal
         returns (uint32 _total)
diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index ab4dac5..1a87f45 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -196,7 +196,7 @@ contract WaterfallModule is IssuerModuleBase {
 
         /** determine rational choices for non-participating convertible */
         bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
-        uint256[2][] memory _options = commonOptions.getOptions();
+        uint256[2][] memory _options = commonOptions.sortedTotals();
         _recursiveConversionCheck(
             _remainingTotal,
             _commonTotalSupply,
@@ -239,7 +239,7 @@ contract WaterfallModule is IssuerModuleBase {
         @param _remainingTotal remaining merger consideration
         @param _commonTotalSupply aggregate total common shares
         @param _preferred array of preferred series data
-        @param _options options data array from VestedOptions.getOptions()
+        @param _options options data array from VestedOptions.sortedTotals()
         @param _idx index of _preferred this call is looking at
         @param _converts boolean array of conversion decisions
      */
@@ -334,7 +334,7 @@ contract WaterfallModule is IssuerModuleBase {
         @notice Calculate adjusted consideration and supply from in-money options
         @param _remainingTotal remaining merger consideration
         @param _commonTotalSupply aggregate total common shares
-        @param _options options data array from VestedOptions.getOptions()
+        @param _options options data array from VestedOptions.sortedTotals()
                         [(exercise price, total options at price), .. ]
         @return adjusted consideration, adjusted total common shares
      */

From cf066d0846a9e42a94388815a7d037c4eddc6028 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Sat, 29 Jun 2019 00:43:38 +0300
Subject: [PATCH 12/14] change getter function name

---
 contracts/modules/Waterfall.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index 1a87f45..a0c982d 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -196,7 +196,7 @@ contract WaterfallModule is IssuerModuleBase {
 
         /** determine rational choices for non-participating convertible */
         bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
-        uint256[2][] memory _options = commonOptions.sortedTotals();
+        uint256[2][] memory _options = commonOptions.getSortedTotals();
         _recursiveConversionCheck(
             _remainingTotal,
             _commonTotalSupply,

From 120dd1ae32db25f9ccc0bbad5332e8855ccba823 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Mon, 1 Jul 2019 14:22:57 +0400
Subject: [PATCH 13/14] fix nested memory arrays issue (and some merge mess)

---
 contracts/modules/VestedOptions.sol |  45 ---------
 contracts/modules/Waterfall.sol     | 140 +++++++++++++++++-----------
 2 files changed, 88 insertions(+), 97 deletions(-)

diff --git a/contracts/modules/VestedOptions.sol b/contracts/modules/VestedOptions.sol
index 2a7651b..3dc62e7 100644
--- a/contracts/modules/VestedOptions.sol
+++ b/contracts/modules/VestedOptions.sol
@@ -303,51 +303,6 @@ contract VestedOptions is STModuleBase {
         return (_optionCount, _totalExercisePrice);
     }
 
-    function getInMoneyOptions(
-        bytes32 _id,
-        uint256 _perShareConsideration
-    )
-        external
-        view
-        returns (
-            uint256 _optionCount,
-            uint256 _totalExercicePrice
-        )
-    {
-        Option[] storage o = optionData[_id];
-        for (uint i; i < o.length; i++) {
-            if (o[i].exercisePrice >= _perShareConsideration) continue;
-            uint256 _price = uint256(o[i].amount).mul(o[i].exercisePrice);
-            _totalExercicePrice = _totalExercicePrice.add(_price);
-            _optionCount = _optionCount.add(o[i].amount);
-        }
-        return (_optionCount, _totalExercicePrice);
-    }
-
-    function getOptions(
-        bytes32 _id,
-        uint256 _index
-    )
-        external
-        view
-        returns (
-            uint256 _amount,
-            uint256 _exercisePrice,
-            uint256 _creationDate,
-            uint256 _vestDate,
-            uint256 _expiryDate
-        )
-    {
-        Option storage o = optionData[_id][_index];
-        return (
-            o.amount,
-            o.exercisePrice,
-            o.creationDate,
-            o.vestDate,
-            uint256(o.creationDate).add(_expiryDate)
-        );
-    }
-
     /**
         @notice Modify eth peg
         @dev
diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index a0c982d..d7ef0f8 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -75,7 +75,7 @@ contract WaterfallModule is IssuerModuleBase {
         @param _token token contract address
         @return uint256 per-share consideration
      */
-    function getPerShare(
+    function getPerShareConsideration(
         address _token
     )
         external
@@ -142,21 +142,75 @@ contract WaterfallModule is IssuerModuleBase {
         require(_dividendAmounts.length == preferredTokenCount);
 
         mergerConsideration = _mergerConsideration;
-        uint256 _remainingTotal = _mergerConsideration;
-        uint256 _commonTotalSupply = commonToken.circulatingSupply();
+        (
+            uint256 _remainingTotal,
+            uint256 _commonTotalSupply,
+            Consideration[] memory _preferred
+        ) = _calculatePreferred(_mergerConsideration, _dividendAmounts);
+
+        /** determine rational choices for non-participating convertible */
+        bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
+        uint256[][2] memory _options;
+        (_options[0], _options[1]) = commonOptions.getSortedTotals();
+        _recursiveConversionCheck(
+            _remainingTotal,
+            _commonTotalSupply,
+            _preferred,
+            _options,
+            0,
+            _convertDecisions
+        );
+
+        /** calculate final in-money options and common per-share condsideration */
+        for (uint256 i; i < _convertDecisions.length; i++) {
+            if (!_convertDecisions[i]) continue;
+            Consideration memory p = _preferred[i];
+            _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
+            _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
+            p.perShare = 0;
+        }
+        (_remainingTotal, _commonTotalSupply) = _adjustOptions(
+            _remainingTotal,
+            _commonTotalSupply,
+            _options
+        );
+
+        /** save results to storage */
+        uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
+        perShareConsideration[commonToken] = _commonPerShare;
+        for (i = 0; i < _preferred.length; i++) {
+            p = _preferred[i];
+            if (p.participating) {
+                perShareConsideration[p.token] = p.perShare.add(_commonPerShare);
+            } else {
+                perShareConsideration[p.token] = p.perShare;
+            }
+        }
+    }
+
+    function _calculatePreferred(
+        uint256 _remainingTotal,
+        uint256[] _dividendAmounts
+    )
+        internal
+        returns (
+            uint256,
+            uint256 _commonTotalSupply,
+            Consideration[] memory _preferred
+        )
+    {
+        _commonTotalSupply = commonToken.circulatingSupply();
         uint256 _idx;
-        Consideration[] memory _preferred = new Consideration[](_dividendAmounts.length);
+        _preferred = new Consideration[](_dividendAmounts.length);
 
         /** calculate preferred considerations */
         for (uint256 i = preferredTokens.length - 1; i+1 != 0; i--) {
             PreferredSeries[] storage _tier = preferredTokens[i];
-            uint256 _tierSupply = 0;
             uint256 _tierTotal = 0;
 
-            for (uint256 x = 0; x == _tier.length; x++) {
+            for (uint256 x = 0; x < _tier.length; x++) {
                 Consideration memory p = _preferred[_idx];
                 p.totalSupply = _tier[x].token.circulatingSupply();
-                _tierSupply = _tierSupply.add(p.totalSupply);
                 p.perShare = _tier[x].prefPerShare.add(
                     _dividendAmounts[_idx].div(p.totalSupply)
                 );
@@ -193,44 +247,7 @@ contract WaterfallModule is IssuerModuleBase {
             }
             return;
         }
-
-        /** determine rational choices for non-participating convertible */
-        bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
-        uint256[2][] memory _options = commonOptions.getSortedTotals();
-        _recursiveConversionCheck(
-            _remainingTotal,
-            _commonTotalSupply,
-            _preferred,
-            _options,
-            0,
-            _convertDecisions
-        );
-
-        /** calculate final in-money options and common per-share condsideration */
-        for (i = 0; i < _convertDecisions.length; i++) {
-            if (!_convertDecisions[i]) continue;
-            p = _preferred[i];
-            _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
-            _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
-            p.perShare = 0;
-        }
-        (_remainingTotal, _commonTotalSupply) = _adjustOptions(
-            _remainingTotal,
-            _commonTotalSupply,
-            _options
-        );
-
-        /** save results to storage */
-        uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
-        perShareConsideration[commonToken] = _commonPerShare;
-        for (i = 0; i < _preferred.length; i++) {
-            p = _preferred[i];
-            if (p.participating) {
-                perShareConsideration[p.token] = p.perShare.add(_commonPerShare);
-            } else {
-                perShareConsideration[p.token] = p.perShare;
-            }
-        }
+        return (_remainingTotal, _commonTotalSupply, _preferred);
     }
 
     /**
@@ -247,7 +264,7 @@ contract WaterfallModule is IssuerModuleBase {
         uint256 _remainingTotal,
         uint256 _commonTotalSupply,
         Consideration[] memory _preferred,
-        uint256[2][] memory _options,
+        uint256[][2] memory _options,
         uint256 _idx,
         bool[] memory _converts
     )
@@ -341,22 +358,41 @@ contract WaterfallModule is IssuerModuleBase {
     function _adjustOptions(
         uint256 _remainingTotal,
         uint256 _commonTotalSupply,
-        uint256[2][] memory _options
+        uint256[][2] memory _options
     )
         internal
+        pure
         returns (uint256, uint256)
     {
-        for (uint256 i; i < _options.length; i++) {
-            uint256[2] memory o = _options[i];
-            if (_remainingTotal.div(o[1].add(_commonTotalSupply)) <= o[0]) {
+        for (uint256 i; i < _options[0].length; i++) {
+            if (_remainingTotal.div(_options[i][1].add(_commonTotalSupply)) <= _options[i][0]) {
                 /** options >= this price are not in the money */
                 break;
             }
-            _remainingTotal = _remainingTotal.add(o[0].mul(o[1]));
-            _commonTotalSupply = _commonTotalSupply.add(o[1]);
+            _remainingTotal = _remainingTotal.add(_options[i][0].mul(_options[i][1]));
+            _commonTotalSupply = _commonTotalSupply.add(_options[i][1]);
         }
         return (_remainingTotal, _commonTotalSupply);
     }
 
+    /**
+        @notice supply permissions and hook points when attaching module
+        @dev
+            permissions: 0x40c10f19 - mint
+            hooks: 0x741b5078 - totalSupplyChanged
+            hookBools - all true
+     */
+    function getPermissions()
+        external
+        pure
+        returns
+    (
+        bytes4[] permissions,
+        bytes4[] hooks,
+        uint256 hookBools
+    )
+    {
+        return (permissions, hooks, ~uint256(0));
+    }
 
 }

From a406c45291e7e5f8b00d1b200bc6105113088dd0 Mon Sep 17 00:00:00 2001
From: iamdefinitelyahuman <ben.hauser@hyperlink.technology>
Date: Tue, 2 Jul 2019 20:20:21 +0400
Subject: [PATCH 14/14] it works!

---
 contracts/modules/Waterfall.sol | 152 +++++++++++++++++++++-----------
 1 file changed, 101 insertions(+), 51 deletions(-)

diff --git a/contracts/modules/Waterfall.sol b/contracts/modules/Waterfall.sol
index d7ef0f8..e392a74 100644
--- a/contracts/modules/Waterfall.sol
+++ b/contracts/modules/Waterfall.sol
@@ -40,6 +40,14 @@ contract WaterfallModule is IssuerModuleBase {
         bool participating;
     }
 
+    event WaterfallCalculations(
+        address[] preferredToken,
+        bool[] converts,
+        bool[] participates,
+        uint256[] perShareConsideration,
+        uint256 commonConsideration
+    );
+
     /**
         @dev check validity and uniqueness of token
         @param _token token address
@@ -78,7 +86,7 @@ contract WaterfallModule is IssuerModuleBase {
     function getPerShareConsideration(
         address _token
     )
-        external
+        public
         view
         returns (uint256)
     {
@@ -124,6 +132,7 @@ contract WaterfallModule is IssuerModuleBase {
         return true;
     }
 
+
     /**
         @notice calculate token waterfall
         @param _mergerConsideration Total amount of merger consideration
@@ -148,44 +157,52 @@ contract WaterfallModule is IssuerModuleBase {
             Consideration[] memory _preferred
         ) = _calculatePreferred(_mergerConsideration, _dividendAmounts);
 
-        /** determine rational choices for non-participating convertible */
-        bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
-        uint256[][2] memory _options;
-        (_options[0], _options[1]) = commonOptions.getSortedTotals();
-        _recursiveConversionCheck(
-            _remainingTotal,
-            _commonTotalSupply,
-            _preferred,
-            _options,
-            0,
-            _convertDecisions
-        );
+        if (_remainingTotal > 0) {
+            /** determine rational choices for non-participating convertible */
+            bool[] memory _convertDecisions = new bool[](_dividendAmounts.length);
+            uint256[][2] memory _options;
+            (_options[0], _options[1]) = commonOptions.getSortedTotals();
+            _recursiveConversionCheck(
+                _remainingTotal,
+                _commonTotalSupply,
+                _preferred,
+                _options,
+                0,
+                _convertDecisions
+            );
 
-        /** calculate final in-money options and common per-share condsideration */
-        for (uint256 i; i < _convertDecisions.length; i++) {
-            if (!_convertDecisions[i]) continue;
-            Consideration memory p = _preferred[i];
-            _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
-            _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
-            p.perShare = 0;
-        }
-        (_remainingTotal, _commonTotalSupply) = _adjustOptions(
-            _remainingTotal,
-            _commonTotalSupply,
-            _options
-        );
+            /** calculate final in-money options and common per-share consideration */
+            for (uint256 i; i < _convertDecisions.length; i++) {
+                if (!_convertDecisions[i]) {
+                    p.notConverting = true;
+                    continue;
+                }
+                Consideration memory p = _preferred[i];
+                _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
+                _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
+                p.perShare = 0;
+                p.participating = true;
+                p.notConverting = false;
+            }
+            (_remainingTotal, _commonTotalSupply) = _adjustOptions(
+                _remainingTotal,
+                _commonTotalSupply,
+                _options
+            );
 
-        /** save results to storage */
-        uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
-        perShareConsideration[commonToken] = _commonPerShare;
-        for (i = 0; i < _preferred.length; i++) {
-            p = _preferred[i];
-            if (p.participating) {
-                perShareConsideration[p.token] = p.perShare.add(_commonPerShare);
-            } else {
-                perShareConsideration[p.token] = p.perShare;
+            /** save results to storage */
+            uint256 _commonPerShare = _remainingTotal.div(_commonTotalSupply);
+            perShareConsideration[commonToken] = _commonPerShare;
+            for (i = 0; i < _preferred.length; i++) {
+                p = _preferred[i];
+                if (p.participating) {
+                    perShareConsideration[p.token] = p.perShare.add(_commonPerShare);
+                } else {
+                    perShareConsideration[p.token] = p.perShare;
+                }
             }
         }
+        _emitResults(_preferred);
     }
 
     function _calculatePreferred(
@@ -210,6 +227,7 @@ contract WaterfallModule is IssuerModuleBase {
 
             for (uint256 x = 0; x < _tier.length; x++) {
                 Consideration memory p = _preferred[_idx];
+                p.token = _tier[x].token;
                 p.totalSupply = _tier[x].token.circulatingSupply();
                 p.perShare = _tier[x].prefPerShare.add(
                     _dividendAmounts[_idx].div(p.totalSupply)
@@ -227,7 +245,7 @@ contract WaterfallModule is IssuerModuleBase {
                 }
             }
 
-            if (_tierTotal <= _remainingTotal) {
+            if (_tierTotal < _remainingTotal) {
                 /** total preference for tier is < remaining consideration */
                 _remainingTotal = _remainingTotal.sub(_tierTotal);
                 continue;
@@ -252,13 +270,13 @@ contract WaterfallModule is IssuerModuleBase {
 
     /**
         @notice Determine whether or not to convert a preferred series
-        @dev Called recursively, modifies _converts in place to pass results
+        @dev Called recursively, modifies _convertDecisions in place to pass results
         @param _remainingTotal remaining merger consideration
         @param _commonTotalSupply aggregate total common shares
         @param _preferred array of preferred series data
         @param _options options data array from VestedOptions.sortedTotals()
         @param _idx index of _preferred this call is looking at
-        @param _converts boolean array of conversion decisions
+        @param _convertDecisions boolean array of conversion decisions
      */
     function _recursiveConversionCheck(
         uint256 _remainingTotal,
@@ -266,7 +284,7 @@ contract WaterfallModule is IssuerModuleBase {
         Consideration[] memory _preferred,
         uint256[][2] memory _options,
         uint256 _idx,
-        bool[] memory _converts
+        bool[] memory _convertDecisions
     )
         internal
     {
@@ -280,18 +298,18 @@ contract WaterfallModule is IssuerModuleBase {
                     _preferred,
                     _options,
                     _idx+1,
-                    _converts
+                    _convertDecisions
                 );
             }
             return;
         }
 
-        if (_idx < _preferred.length - 1) {
+        if (_idx == _preferred.length - 1) {
             /** final preferred series, no more recursion needed */
             _remainingTotal = _remainingTotal.add(p.perShare.mul(p.totalSupply));
             _commonTotalSupply = _commonTotalSupply.add(p.totalSupply);
             if (_remainingTotal.div(_commonTotalSupply) < p.perShare) {
-                _converts[_idx] = false;
+                _convertDecisions[_idx] = false;
                 return;
             }
             (_remainingTotal, _commonTotalSupply) = _adjustOptions(
@@ -299,7 +317,7 @@ contract WaterfallModule is IssuerModuleBase {
                 _commonTotalSupply,
                 _options
             );
-            _converts[_idx] = _remainingTotal.div(_commonTotalSupply) > p.perShare;
+            _convertDecisions[_idx] = _remainingTotal.div(_commonTotalSupply) > p.perShare;
             return;
         }
 
@@ -310,13 +328,13 @@ contract WaterfallModule is IssuerModuleBase {
             _preferred,
             _options,
             _idx+1,
-            _converts
+            _convertDecisions
         );
 
         uint256 _adjustedRemaining = _remainingTotal;
         uint256 _adjustedCommon = _commonTotalSupply;
         for (uint256 i = _idx+1; i < _preferred.length; i++) {
-            if (!_converts[i]) continue;
+            if (!_convertDecisions[i]) continue;
             Consideration memory t = _preferred[i];
             _adjustedRemaining = _adjustedRemaining.add(t.perShare.mul(t.totalSupply));
             _adjustedCommon = _adjustedCommon.add(t.totalSupply);
@@ -331,19 +349,19 @@ contract WaterfallModule is IssuerModuleBase {
             );
             if (_adjustedRemaining.div(_adjustedCommon) > p.perShare) {
                 /** converts, bools are already set */
-                _converts[_idx] = true;
+                _convertDecisions[_idx] = true;
                 return;
             }
         }
         /** does not convert, need to reset convert booleans */
-        _converts[_idx] = false;
+        _convertDecisions[_idx] = false;
         _recursiveConversionCheck(
             _remainingTotal,
             _commonTotalSupply,
             _preferred,
             _options,
             _idx+1,
-            _converts
+            _convertDecisions
         );
     }
 
@@ -365,12 +383,12 @@ contract WaterfallModule is IssuerModuleBase {
         returns (uint256, uint256)
     {
         for (uint256 i; i < _options[0].length; i++) {
-            if (_remainingTotal.div(_options[i][1].add(_commonTotalSupply)) <= _options[i][0]) {
+            if (_remainingTotal.div(_options[1][i].add(_commonTotalSupply)) <= _options[0][i]) {
                 /** options >= this price are not in the money */
                 break;
             }
-            _remainingTotal = _remainingTotal.add(_options[i][0].mul(_options[i][1]));
-            _commonTotalSupply = _commonTotalSupply.add(_options[i][1]);
+            _remainingTotal = _remainingTotal.add(_options[0][i].mul(_options[1][i]));
+            _commonTotalSupply = _commonTotalSupply.add(_options[1][i]);
         }
         return (_remainingTotal, _commonTotalSupply);
     }
@@ -395,4 +413,36 @@ contract WaterfallModule is IssuerModuleBase {
         return (permissions, hooks, ~uint256(0));
     }
 
+    function _emitResults(Consideration[] memory _preferred) internal {
+
+        uint256 _length = _preferred.length;
+        for (uint256 i; i < _preferred.length; i++) {
+            if (getPerShareConsideration(_preferred[i].token) == 0) {
+                _length = i;
+                break;
+            }
+        }
+
+        address[] memory _tokens = new address[](_length);
+        bool[] memory _convertDecisions = new bool[](_length);
+        bool[] memory _participates = new bool[](_length);
+        uint256[] memory _consideration = new uint256[](_length);
+
+        for (i = 0; i < _length; i++) {
+            Consideration memory c = _preferred[i];
+            _tokens[i] = c.token;
+            _convertDecisions[i] = !c.notConverting;
+            _participates[i] = c.participating;
+            _consideration[i] = getPerShareConsideration(c.token);
+        }
+
+        emit WaterfallCalculations(
+            _tokens,
+            _convertDecisions,
+            _participates,
+            _consideration,
+            getPerShareConsideration(commonToken)
+        );
+    }
+
 }