@juicedollar/jusd 3.0.0 → 4.0.0

package/contracts/{MintingHubV2 → MintingHubV3}/interface/IPosition.sol

@@ -16,7 +16,7 @@ interface IPosition {
 
     function challengedAmount() external view returns (uint256);
 
-    function original() external view returns (address);
+    function original() external view returns (address payable);
 
     function expiration() external view returns (uint40);
 
@@ -56,13 +56,13 @@ interface IPosition {
 
     function getMintAmount(uint256 usableMint) external view returns (uint256);
 
-    function adjust(uint256 newMinted, uint256 newCollateral, uint256 newPrice, bool withdrawAsNative) external payable;
+    function adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, bool withdrawAsNative) external payable;
 
     function adjustPrice(uint256 newPrice) external;
 
     function adjustPriceWithReference(uint256 newPrice, address referencePosition) external;
 
-    function adjustWithReference(uint256 newMinted, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) external payable;
+    function adjustWithReference(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) external payable;
 
     function isValidPriceReference(address referencePosition, uint256 newPrice) external view returns (bool);
 

package/contracts/Savings.sol

@@ -19,6 +19,8 @@ contract Savings is Leadrate {
     IERC20 public immutable jusd;
 
     mapping(address => Account) public savings;
+    mapping(address => bool) public nonCompounding;
+    mapping(address => uint192) public claimableInterest;
 
     struct Account {
         uint192 saved;
@@ -26,8 +28,9 @@ contract Savings is Leadrate {
     }
 
     event Saved(address indexed account, uint192 amount);
-    event InterestCollected(address indexed account, uint256 interest);
+    event InterestCollected(address indexed account, uint256 interest, bool compounded);
     event Withdrawn(address indexed account, uint192 amount);
+    event InterestClaimed(address indexed account, uint192 amount);
 
     // The module is considered disabled if the interest is zero or about to become zero within three days.
     error ModuleDisabled();
@@ -53,16 +56,20 @@ contract Savings is Leadrate {
         return refresh(owner).saved;
     }
 
-    function refresh(address accountOwner) virtual internal returns (Account storage) {
+    function refresh(address accountOwner) internal returns (Account storage) {
         Account storage account = savings[accountOwner];
         uint64 ticks = currentTicks();
         if (ticks > account.ticks) {
             uint192 earnedInterest = calculateInterest(account, ticks);
             if (earnedInterest > 0) {
-                // collect interest as you go and trigger accounting event
                 (IJuiceDollar(address(jusd))).distributeProfits(address(this), earnedInterest);
-                account.saved += earnedInterest;
-                emit InterestCollected(accountOwner, earnedInterest);
+                bool compounded = !nonCompounding[accountOwner];
+                if (compounded) {
+                    account.saved += earnedInterest;
+                } else {
+                    claimableInterest[accountOwner] += earnedInterest;
+                }
+                emit InterestCollected(accountOwner, earnedInterest, compounded);
             }
             account.ticks = ticks;
         }
@@ -93,12 +100,21 @@ contract Savings is Leadrate {
     }
 
     /**
-     * Save 'amount'.
+     * Save 'amount' with default compounding behavior.
      */
     function save(uint192 amount) public {
         save(msg.sender, amount);
     }
 
+    /**
+     * Save 'amount' and set the compounding preference.
+     * Pending interest is settled under the OLD mode before applying the new preference.
+     */
+    function save(uint192 amount, bool compound) public {
+        save(msg.sender, amount);
+        nonCompounding[msg.sender] = !compound;
+    }
+
     function adjust(uint192 targetAmount) public {
         Account storage balance = refresh(msg.sender);
         if (balance.saved < targetAmount) {
@@ -138,4 +154,18 @@ contract Savings is Leadrate {
         emit Withdrawn(msg.sender, amount);
         return amount;
     }
+
+    /**
+     * Claim accumulated non-compounding interest and transfer to target.
+     */
+    function claimInterest(address target) public returns (uint192) {
+        refresh(msg.sender);
+        uint192 interest = claimableInterest[msg.sender];
+        if (interest > 0) {
+            claimableInterest[msg.sender] = 0;
+            jusd.transfer(target, interest);
+            emit InterestClaimed(msg.sender, interest);
+        }
+        return interest;
+    }
 }

package/contracts/interface/ISavingsJUSD.sol

@@ -10,8 +10,9 @@ interface ISavingsJUSD {
 	// ---------------------------------------------------------------------------------------
 
 	event Saved(address indexed account, uint192 amount);
-	event InterestCollected(address indexed account, uint256 interest);
+	event InterestCollected(address indexed account, uint256 interest, bool compounded);
 	event Withdrawn(address indexed account, uint192 amount);
+	event InterestClaimed(address indexed account, uint192 amount);
 
 	// ---------------------------------------------------------------------------------------
 
@@ -21,6 +22,10 @@ interface ISavingsJUSD {
 
 	function savings(address account) external view returns (Account memory);
 
+	function nonCompounding(address account) external view returns (bool);
+
+	function claimableInterest(address account) external view returns (uint192);
+
 	// ---------------------------------------------------------------------------------------
 
 	function currentTicks() external view returns (uint64);
@@ -37,6 +42,8 @@ interface ISavingsJUSD {
 
 	function save(uint192 amount) external;
 
+	function save(uint192 amount, bool compound) external;
+
 	function save(address owner, uint192 amount) external;
 
 	function withdraw(address target, uint192 amount) external returns (uint256);
@@ -46,4 +53,6 @@ interface ISavingsJUSD {
 	function refreshMyBalance() external returns (uint192);
 
 	function refreshBalance(address owner) external returns (uint192);
+
+	function claimInterest(address target) external returns (uint192);
 }

package/contracts/test/PositionExpirationTest.sol

@@ -1,59 +1,38 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {Position} from "../MintingHubV2/Position.sol";
-import {MintingHubGateway} from "../gateway/MintingHubGateway.sol";
-import {IMintingHubGateway} from "../gateway/interface/IMintingHubGateway.sol";
+import {Position} from "../MintingHubV3/Position.sol";
+import {MintingHub} from "../MintingHubV3/MintingHub.sol";
 import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
 import {TestToken} from "./TestToken.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 contract PositionExpirationTest {
-    MintingHubGateway public hub;
+    MintingHub public hub;
     TestToken public col;
     IJuiceDollar public jusd;
-    bytes32 public frontendCode;
 
     constructor(address payable hub_) {
-        hub = MintingHubGateway(hub_);
+        hub = MintingHub(hub_);
         col = new TestToken("Some Collateral", "COL", uint8(0));
         jusd = hub.JUSD();
     }
 
-    function openPositionFor(address owner, bytes32 frontendCode_) public returns (address) {
-        frontendCode = frontendCode_;
+    function openPositionFor(address owner) public returns (address) {
         col.mint(address(this), 100);
         col.approve(address(hub), 100);
         jusd.approve(address(hub), hub.OPENING_FEE());
-        address pos;
-        if (IERC165(hub).supportsInterface(type(IMintingHubGateway).interfaceId)) {
-            pos = hub.openPosition(
-                address(col),
-                10,
-                100 /* collateral */,
-                1000000 * 10 ** 18,
-                14 days,
-                30 days,
-                1 days,
-                50000,
-                1000 * 10 ** 36 /* price */,
-                200000,
-                frontendCode
-            );
-        } else {
-            pos = hub.openPosition(
-                address(col),
-                10,
-                100 /* collateral */,
-                1000000 * 10 ** 18,
-                14 days,
-                30 days,
-                1 days,
-                50000,
-                1000 * 10 ** 36 /* price */,
-                200000
-            );
-        }
+        address pos = hub.openPosition(
+            address(col),
+            10,
+            100 /* collateral */,
+            1000000 * 10 ** 18,
+            14 days,
+            30 days,
+            1 days,
+            50000,
+            1000 * 10 ** 36 /* price */,
+            200000
+        );
         Position(payable(pos)).transferOwnership(owner);
         return pos;
     }

package/contracts/test/PositionRollingTest.sol

@@ -4,10 +4,10 @@ pragma solidity ^0.8.0;
 // import "./Strings.sol";
 import "./TestToken.sol";
 import "../Equity.sol";
-import "../MintingHubV2/Position.sol";
-import "../MintingHubV2/MintingHub.sol";
+import "../MintingHubV3/Position.sol";
+import "../MintingHubV3/MintingHub.sol";
 import "../StablecoinBridge.sol";
-import "../MintingHubV2/interface/IPosition.sol";
+import "../MintingHubV3/interface/IPosition.sol";
 import "../interface/IReserve.sol";
 import "../interface/IJuiceDollar.sol";
 

package/contracts/test/ReentrantAttacker.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {IPosition} from "../MintingHubV2/interface/IPosition.sol";
+import {IPosition} from "../MintingHubV3/interface/IPosition.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 
 /**