Yield Delegation / Rebasing Token Rewrite

contracts/contracts/token/OUSD.sol

@@ -14,7 +14,8 @@
 import { InitializableERC20Detailed } from "../utils/InitializableERC20Detailed.sol";
 import { StableMath } from "../utils/StableMath.sol";
 import { Governable } from "../governance/Governable.sol";
-
+// TODO DELETE
+import "hardhat/console.sol";
 /**
  * NOTE that this is an ERC20 token but the invariant that the sum of
  * balanceOf(x) for all x is not >= totalSupply(). This is a consequence of the
@@ -32,17 +33,35 @@
     );
     event AccountRebasingEnabled(address account);
     event AccountRebasingDisabled(address account);
+    event YieldDelegationStart(address fromAccount, address toAccount, uint256 rebasingCreditsPerToken);
+    event YieldDelegationStop(address fromAccount, address toAccount, uint256 rebasingCreditsPerToken);
 
     enum RebaseOptions {
         NotSet,
         OptOut,
-        OptIn
+        OptIn,
+        Delegator,
+        Delegatee
     }
 
     uint256 private constant MAX_SUPPLY = ~uint128(0); // (2^128) - 1
     uint256 public _totalSupply;
     mapping(address => mapping(address => uint256)) private _allowances;
     address public vaultAddress = address(0);
+    /**
+     * This used to represent rebasing credits where balance would be derived using 
+     * global contract `rebasingCreditsPerToken`. Or non rebasing where balance is derived
+     * using the account specific `nonRebasingCreditsPerToken`.
+     * 
+     * While the above functionality still stands the _creditBalances alone only partly represents
+     * the third type of accounts which are part of yield delegation (delegators and delegatees). 
+     * In those cases the _creditBalances express the amount of balance that counts towards the
+     * yield of a specific account. The `_amountAdjustement` supplements the balances logic and 
+     * subtracts token balances from yield delegatees and adds to yield delegators to make up the
+     * exact token balances. The `_amountAdjustement` retain their value between rebases.
+     * TODO (might need more in dept explanation of _amountAdjustement)
+     *
+     */
     mapping(address => uint256) private _creditBalances;
     uint256 private _rebasingCredits;
     uint256 private _rebasingCreditsPerToken;
@@ -52,6 +71,18 @@
     mapping(address => uint256) public nonRebasingCreditsPerToken;
     mapping(address => RebaseOptions) public rebaseState;
     mapping(address => uint256) public isUpgraded;
+    /**
+     * Facilitates the correct token balances in accounts affected by yield delegation
+     */
+    mapping(address => uint256) private _amountAdjustement;
+    /**
+     * @dev accounts delegating yield to another account
+     */
+    mapping(address => address) public yieldDelegateFrom;
+    /**
+     * @dev accounts having yield delegated from another account
+     */
+    mapping(address => address) public yieldDelegateTo;
 
     uint256 private constant RESOLUTION_INCREASE = 1e9;
 
@@ -121,9 +152,27 @@
         override
         returns (uint256)
     {
-        if (_creditBalances[_account] == 0) return 0;
-        return
-            _creditBalances[_account].divPrecisely(_creditsPerToken(_account));
+        uint256 nonDelegatedBalance;
+        if (_creditBalances[_account] == 0) nonDelegatedBalance = 0;
+        else {
+            nonDelegatedBalance = _creditBalances[_account].divPrecisely(_creditsPerToken(_account));
+        } 
+
+        return _adjustBalanceForYieldDelegation(_account, nonDelegatedBalance);
+    }
+
+    function _adjustBalanceForYieldDelegation(address _account, uint256 _nonDelegatedBalance)
+        internal
+        view
+        returns(uint256)
+    {
+
+        if (rebaseState[_account] == RebaseOptions.Delegator) {
+            return _nonDelegatedBalance + _amountAdjustement[_account];
+        } else if (rebaseState[_account] == RebaseOptions.Delegatee) {
+            return _nonDelegatedBalance - _amountAdjustement[_account];
+        }
+        return _nonDelegatedBalance;
     }
 
     /**
@@ -138,6 +187,7 @@
         view
         returns (uint256, uint256)
     {
+        // TODO add yield delegation
         uint256 cpt = _creditsPerToken(_account);
         if (cpt == 1e27) {
             // For a period before the resolution upgrade, we created all new
@@ -167,6 +217,7 @@
             bool
         )
     {
+        // TODO add yield delegation
         return (
             _creditBalances[_account],
             _creditsPerToken(_account),
@@ -242,11 +293,38 @@
         uint256 creditsCredited = _value.mulTruncate(_creditsPerToken(_to));
         uint256 creditsDeducted = _value.mulTruncate(_creditsPerToken(_from));
 
-        _creditBalances[_from] = _creditBalances[_from].sub(
-            creditsDeducted,
-            "Transfer amount exceeds balance"
-        );
-        _creditBalances[_to] = _creditBalances[_to].add(creditsCredited);
+        if (rebaseState[_from] == RebaseOptions.Delegator) {
+            address delegatee = yieldDelegateFrom[_from];
+            // adjust delegator and delegatee fixed amounts
+            _amountAdjustement[_from] -= _value;
+            _amountAdjustement[delegatee] -= _value;
+            // also adjust the reduced yield of the delegatee
+            _creditBalances[delegatee] = _creditBalances[delegatee].sub(
+                creditsDeducted,
+                //"Transfer amount exceeds balance"
+                "Transfer amount exceeds balance delegatee"
+            );
+        } else {
+            // can not deduct _creditBalances that have been delegated since
+            // balance checks in transfer & transferFrom prevent it
+            _creditBalances[_from] = _creditBalances[_from].sub(
+                creditsDeducted,
+                "Transfer amount exceeds balance"
+            );
+
+        }
+
+        if (rebaseState[_to] == RebaseOptions.Delegator) {
+            address delegator = yieldDelegateTo[_to];
+            // adjust delegator and delegatee fixed amounts
+            _amountAdjustement[_to] += _value;
+            _amountAdjustement[delegator] += _value;
+            // also adjust the additional yield of the delegator
+            _creditBalances[delegator] = _creditBalances[delegator]
+                .add(creditsCredited);
+        } else {
+            _creditBalances[_to] = _creditBalances[_to].add(creditsCredited);
+        }
 
         if (isNonRebasingTo && !isNonRebasingFrom) {
             // Transfer to non-rebasing account from rebasing account, credits
@@ -460,6 +538,7 @@
     function _isNonRebasingAccount(address _account) internal returns (bool) {
         bool isContract = Address.isContract(_account);
         if (isContract && rebaseState[_account] == RebaseOptions.NotSet) {
+            // TODO: make sure this never executes with yield delegators or delegatees
             _ensureRebasingMigration(_account);
         }
         return nonRebasingCreditsPerToken[_account] > 0;
@@ -559,6 +638,39 @@
         emit AccountRebasingDisabled(msg.sender);
     }
 
+    function governanceDelegateYield(address _accountSource, address _accountReceiver)
+        public
+        onlyGovernor
+    {
+        if (rebaseState[_accountSource] == RebaseOptions.OptOut) {
+            _rebaseOptIn(_accountSource);
+        }
+        if (rebaseState[_accountReceiver] == RebaseOptions.OptOut) {
+            _rebaseOptIn(_accountSource);
+        }
+        uint256 accountSourceBalance = balanceOf(_accountSource);
+
+        rebaseState[_accountSource] = RebaseOptions.Delegator;
+        rebaseState[_accountReceiver] = RebaseOptions.Delegatee;
+
+        // delegate all yield and adjust for balances
+        _creditBalances[_accountReceiver] += _creditBalances[_accountSource];
+        _creditBalances[_accountSource] = 0;
+        _amountAdjustement[_accountSource] = accountSourceBalance;
+        _amountAdjustement[_accountReceiver] = accountSourceBalance; 
+        yieldDelegateFrom[_accountSource] = _accountReceiver;
+        yieldDelegateTo[_accountReceiver] = _accountSource;
+
+        emit YieldDelegationStart(_accountSource, _accountReceiver, _rebasingCreditsPerToken);
+    }
+
+    function governanceStopYieldDelegation(address _accountSource)
+        public
+        onlyGovernor
+    {
+        require(false, "Needs implementation");
+    }
+
     /**
      * @dev Modify the supply without minting new tokens. This uses a change in
      *      the exchange rate between "credits" and OUSD tokens to change balances.

contracts/test/token/ousd.js

@@ -849,4 +849,77 @@
     await checkTransferOut(5);
     await checkTransferOut(9);
   });
+
+  describe.only("Delegating yield", function () {
+    it("Should delegate rebase to another account", async () => {
+      let { ousd, vault, matt, josh, anna, usdc, governor } = fixture;
+
+      await ousd.connect(matt).transfer(anna.address, ousdUnits("10"));
+      await ousd.connect(matt).transfer(josh.address, ousdUnits("10"));
+
+      await expect(josh).has.an.approxBalanceOf("110.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("80.00", ousd);
+      await expect(anna).has.an.approxBalanceOf("10", ousd);
+
+      await ousd
+        .connect(governor)
+        // matt delegates yield to anna
+        .governanceDelegateYield(matt.address, anna.address);
+
+      // Transfer USDC into the Vault to simulate yield
+      await usdc.connect(matt).transfer(vault.address, usdcUnits("200"));
+      await vault.rebase();
+
+      await expect(josh).has.an.approxBalanceOf("220.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("80.00", ousd);
+      // 10 of own rebase + 80 from matt + 10 existing balance
+      await expect(anna).has.an.balanceOf("100", ousd);
+
+      await ousd.connect(anna).transfer(josh.address, ousdUnits("10"));
+
+      await expect(josh).has.an.approxBalanceOf("230.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("80.00", ousd);
+      await expect(anna).has.an.balanceOf("90", ousd);
+
+      console.log("Matt transfering to josh");
+      await ousd.connect(matt).transfer(josh.address, ousdUnits("80"));
+      console.log("Anna transfering to josh");
+      await ousd.connect(anna).transfer(josh.address, ousdUnits("90"))
+
+      await expect(josh).has.an.approxBalanceOf("400", ousd);
+      await expect(matt).has.an.approxBalanceOf("0", ousd);
+      await expect(anna).has.an.balanceOf("0", ousd);
+    });
+
+    it("Should delegate rebase to another account initially having 0 balance", async () => {
+      let { ousd, vault, matt, josh, anna, usdc, governor } = fixture;
+
+      await expect(josh).has.an.approxBalanceOf("100.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("100.00", ousd);
+      await expect(anna).has.an.balanceOf("0", ousd);
+
+      await ousd
+        .connect(governor)
+        // matt delegates yield to anna
+        .governanceDelegateYield(matt.address, anna.address);
+
+      // Transfer USDC into the Vault to simulate yield
+      await usdc.connect(matt).transfer(vault.address, usdcUnits("200"));
+      await vault.rebase();
+
+      await expect(josh).has.an.approxBalanceOf("200.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("100.00", ousd);
+      await expect(anna).has.an.balanceOf("100", ousd);
+
+      await ousd.connect(anna).transfer(josh.address, ousdUnits("10"));
+
+      await expect(josh).has.an.approxBalanceOf("210.00", ousd);
+      await expect(matt).has.an.approxBalanceOf("100.00", ousd);
+      await expect(anna).has.an.balanceOf("90", ousd);
+    });
+
+    it("should be able to chenge yield delegation", async () => {
+      //A Should delegate to account B, rebase with profit, delegate to account C and all have correct balances
+    });
+  });
 });