@juicedollar/jusd 1.0.0

package/contracts/test/Math.sol

@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Standard math utilities missing in the Solidity language.
+ */
+library Math {
+    enum Rounding {
+        Down, // Toward negative infinity
+        Up, // Toward infinity
+        Zero // Toward zero
+    }
+
+    /**
+     * @dev Returns the largest of two numbers.
+     */
+    function max(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a > b ? a : b;
+    }
+
+    /**
+     * @dev Returns the smallest of two numbers.
+     */
+    function min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    /**
+     * @dev Returns the average of two numbers. The result is rounded towards
+     * zero.
+     */
+    function average(uint256 a, uint256 b) internal pure returns (uint256) {
+        // (a + b) / 2 can overflow.
+        return (a & b) + (a ^ b) / 2;
+    }
+
+    /**
+     * @dev Returns the ceiling of the division of two numbers.
+     *
+     * This differs from standard division with `/` in that it rounds up instead
+     * of rounding down.
+     */
+    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
+        // (a + b - 1) / b can overflow on addition, so we distribute.
+        return a == 0 ? 0 : (a - 1) / b + 1;
+    }
+
+    /**
+     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+     * with further edits by Uniswap Labs also under MIT license.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
+        unchecked {
+            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+            // variables such that product = prod1 * 2^256 + prod0.
+            uint256 prod0; // Least significant 256 bits of the product
+            uint256 prod1; // Most significant 256 bits of the product
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            // Handle non-overflow cases, 256 by 256 division.
+            if (prod1 == 0) {
+                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
+                // The surrounding unchecked block does not change this fact.
+                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
+                return prod0 / denominator;
+            }
+
+            // Make sure the result is less than 2^256. Also prevents denominator == 0.
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            ///////////////////////////////////////////////
+            // 512 by 256 division.
+            ///////////////////////////////////////////////
+
+            // Make division exact by subtracting the remainder from [prod1 prod0].
+            uint256 remainder;
+            assembly {
+                // Compute remainder using mulmod.
+                remainder := mulmod(x, y, denominator)
+
+                // Subtract 256 bit number from 512 bit number.
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+            // See https://cs.stackexchange.com/q/138556/92363.
+
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by twos.
+                denominator := div(denominator, twos)
+
+                // Divide [prod1 prod0] by twos.
+                prod0 := div(prod0, twos)
+
+                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2^4.
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2^8
+            inverse *= 2 - denominator * inverse; // inverse mod 2^16
+            inverse *= 2 - denominator * inverse; // inverse mod 2^32
+            inverse *= 2 - denominator * inverse; // inverse mod 2^64
+            inverse *= 2 - denominator * inverse; // inverse mod 2^128
+            inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    /**
+     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
+        uint256 result = mulDiv(x, y, denominator);
+        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
+            result += 1;
+        }
+        return result;
+    }
+
+    /**
+     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
+     *
+     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
+     */
+    function sqrt(uint256 a) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+
+        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
+        //
+        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
+        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
+        //
+        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
+        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
+        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
+        //
+        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
+        uint256 result = 1 << (log2(a) >> 1);
+
+        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
+        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
+        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
+        // into the expected uint128 result.
+        unchecked {
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            result = (result + a / result) >> 1;
+            return min(result, a / result);
+        }
+    }
+
+    /**
+     * @notice Calculates sqrt(a), following the selected rounding direction.
+     */
+    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
+        unchecked {
+            uint256 result = sqrt(a);
+            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
+        }
+    }
+
+    /**
+     * @dev Return the log in base 2, rounded down, of a positive value.
+     * Returns 0 if given 0.
+     */
+    function log2(uint256 value) internal pure returns (uint256) {
+        uint256 result = 0;
+        unchecked {
+            if (value >> 128 > 0) {
+                value >>= 128;
+                result += 128;
+            }
+            if (value >> 64 > 0) {
+                value >>= 64;
+                result += 64;
+            }
+            if (value >> 32 > 0) {
+                value >>= 32;
+                result += 32;
+            }
+            if (value >> 16 > 0) {
+                value >>= 16;
+                result += 16;
+            }
+            if (value >> 8 > 0) {
+                value >>= 8;
+                result += 8;
+            }
+            if (value >> 4 > 0) {
+                value >>= 4;
+                result += 4;
+            }
+            if (value >> 2 > 0) {
+                value >>= 2;
+                result += 2;
+            }
+            if (value >> 1 > 0) {
+                result += 1;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
+     * Returns 0 if given 0.
+     */
+    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
+        unchecked {
+            uint256 result = log2(value);
+            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
+        }
+    }
+
+    /**
+     * @dev Return the log in base 10, rounded down, of a positive value.
+     * Returns 0 if given 0.
+     */
+    function log10(uint256 value) internal pure returns (uint256) {
+        uint256 result = 0;
+        unchecked {
+            if (value >= 10 ** 64) {
+                value /= 10 ** 64;
+                result += 64;
+            }
+            if (value >= 10 ** 32) {
+                value /= 10 ** 32;
+                result += 32;
+            }
+            if (value >= 10 ** 16) {
+                value /= 10 ** 16;
+                result += 16;
+            }
+            if (value >= 10 ** 8) {
+                value /= 10 ** 8;
+                result += 8;
+            }
+            if (value >= 10 ** 4) {
+                value /= 10 ** 4;
+                result += 4;
+            }
+            if (value >= 10 ** 2) {
+                value /= 10 ** 2;
+                result += 2;
+            }
+            if (value >= 10 ** 1) {
+                result += 1;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
+     * Returns 0 if given 0.
+     */
+    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
+        unchecked {
+            uint256 result = log10(value);
+            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
+        }
+    }
+
+    /**
+     * @dev Return the log in base 256, rounded down, of a positive value.
+     * Returns 0 if given 0.
+     *
+     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
+     */
+    function log256(uint256 value) internal pure returns (uint256) {
+        uint256 result = 0;
+        unchecked {
+            if (value >> 128 > 0) {
+                value >>= 128;
+                result += 16;
+            }
+            if (value >> 64 > 0) {
+                value >>= 64;
+                result += 8;
+            }
+            if (value >> 32 > 0) {
+                value >>= 32;
+                result += 4;
+            }
+            if (value >> 16 > 0) {
+                value >>= 16;
+                result += 2;
+            }
+            if (value >> 8 > 0) {
+                result += 1;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
+     * Returns 0 if given 0.
+     */
+    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
+        unchecked {
+            uint256 result = log256(value);
+            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
+        }
+    }
+}

package/contracts/test/MockEquity.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {Equity} from "../Equity.sol";
+import {JuiceDollar} from "../JuiceDollar.sol";
+
+contract MockEquity is Equity {
+    constructor(JuiceDollar JUSD_) Equity(JUSD_) {
+        require(block.chainid == 31337, "MockEquity: TEST ONLY");
+    }
+
+    function mintForTesting(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}

package/contracts/test/PositionExpirationTest.sol

@@ -0,0 +1,75 @@
+// 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 {IJuiceDollar} from "../interface/IJuiceDollar.sol";
+import {TestToken} from "./TestToken.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+contract PositionExpirationTest {
+    MintingHubGateway public hub;
+    TestToken public col;
+    IJuiceDollar public jusd;
+    bytes32 public frontendCode;
+
+    constructor(address hub_) {
+        hub = MintingHubGateway(hub_);
+        col = new TestToken("Some Collateral", "COL", uint8(0));
+        jusd = hub.JUSD();
+    }
+
+    function openPositionFor(address owner, bytes32 frontendCode_) public returns (address) {
+        frontendCode = frontendCode_;
+        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,
+                7 days,
+                30 days,
+                1 days,
+                50000,
+                1000 * 10 ** 36 /* price */,
+                200000,
+                frontendCode
+            );
+        } else {
+            pos = hub.openPosition(
+                address(col),
+                10,
+                100 /* collateral */,
+                1000000 * 10 ** 18,
+                7 days,
+                30 days,
+                1 days,
+                50000,
+                1000 * 10 ** 36 /* price */,
+                200000
+            );
+        }
+        Position(pos).transferOwnership(owner);
+        return pos;
+    }
+
+    function approveJUSD(address spender, uint256 amount) external {
+        jusd.approve(spender, amount);
+    }
+
+    function forceBuy(address pos, uint256 amount) public {
+        uint256 price = hub.expiredPurchasePrice(Position(pos));
+        uint256 balanceBefore = jusd.balanceOf(address(this));
+        uint256 colBalBefore = col.balanceOf(address(this));
+        amount = hub.buyExpiredCollateral(Position(pos), amount);
+        uint256 balanceAfter = jusd.balanceOf(address(this));
+        uint256 colBalAfter = col.balanceOf(address(this));
+        require(colBalAfter - colBalBefore == amount, "collateral amount");
+        require((balanceBefore - balanceAfter) == ((amount * price) / 10 ** 18), "price paid");
+    }
+}

package/contracts/test/PositionRollingTest.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// import "./Strings.sol";
+import "./TestToken.sol";
+import "../Equity.sol";
+import "../MintingHubV2/Position.sol";
+import "../MintingHubV2/MintingHub.sol";
+import "../StablecoinBridge.sol";
+import "../MintingHubV2/interface/IPosition.sol";
+import "../interface/IReserve.sol";
+import "../interface/IJuiceDollar.sol";
+
+contract PositionRollingTest {
+    MintingHub hub;
+    TestToken col;
+    IJuiceDollar jusd;
+    PositionRoller roller;
+
+    IPosition public p1;
+    IPosition public p2;
+
+    constructor(address hub_) {
+        hub = MintingHub(hub_);
+        col = new TestToken("Some Collateral", "COL", uint8(0));
+        jusd = hub.JUSD();
+        roller = hub.ROLLER();
+    }
+
+    function openTwoPositions() public {
+        jusd.approve(address(hub), hub.OPENING_FEE());
+        p1 = IPosition(openPosition(100, uint40(3 days)));
+        jusd.approve(address(hub), hub.OPENING_FEE());
+        p2 = IPosition(openPosition(10, uint40(7 days)));
+    }
+
+    function mintFromFirstPosition(uint256 amount) public {
+        p1.mint(address(this), amount);
+    }
+
+    function openPosition(uint256 collateral, uint40 initializationDelay) public returns (address) {
+        col.mint(address(this), collateral);
+        col.approve(address(hub), collateral);
+        return
+            hub.openPosition(
+                address(col),
+                10,
+                collateral,
+                1000000 * 10 ** 18,
+                initializationDelay,
+                30 days,
+                1 days,
+                50000,
+                1000 * 10 ** 36,
+                200000
+            );
+    }
+
+    function roll() public {
+        col.approve(address(roller), col.balanceOf(address(p1))); // approve full balance
+        roller.rollFully(p1, p2);
+        require(p1.getDebt() == 0);
+        require(jusd.balanceOf(address(this)) == 0);
+    }
+}

package/contracts/test/TestFlashLoan.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IEquity is IERC20 {
+    function invest(uint256 amount, uint256 expected) external returns (uint256);
+    function investFor(address investor, uint256 amount, uint256 expected) external returns (uint256);
+    function redeem(address target, uint256 shares) external returns (uint256);
+    function redeemExpected(address target, uint256 shares, uint256 expectedProceeds) external returns (uint256);
+    function redeemFrom(
+        address owner,
+        address target,
+        uint256 shares,
+        uint256 expectedProceeds
+    ) external returns (uint256);
+}
+
+/**
+ * @title TestFlashLoan
+ * @notice Helper contract to test same-block flash loan protection in Equity contract
+ */
+contract TestFlashLoan {
+    IERC20 public immutable jusd;
+    IEquity public immutable equity;
+
+    constructor(address _jusd, address _equity) {
+        jusd = IERC20(_jusd);
+        equity = IEquity(_equity);
+    }
+
+    /**
+     * @notice Attempts to invest and redeem in the same block
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptInvestAndRedeem(uint256 amount) external returns (uint256) {
+        uint256 shares = equity.invest(amount, 0);
+        uint256 proceeds = equity.redeem(address(this), shares);
+        jusd.transfer(msg.sender, proceeds);
+        return proceeds;
+    }
+
+    /**
+     * @notice Attempts to redeem shares that were received in the current block
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptReceiveAndRedeem() external {
+        uint256 msgSenderShares = equity.balanceOf(msg.sender);
+        require(msgSenderShares > 0, "Message sender has no shares");
+        equity.transferFrom(msg.sender, address(this), msgSenderShares);
+        equity.redeem(address(this), msgSenderShares);
+    }
+
+    /**
+     * @notice Attempts redeemExpected in same block as receiving shares
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptRedeemExpected() external {
+        uint256 msgSenderShares = equity.balanceOf(msg.sender);
+        require(msgSenderShares > 0, "Message sender has no shares");
+        equity.transferFrom(msg.sender, address(this), msgSenderShares);
+        equity.redeemExpected(address(this), msgSenderShares, 0);
+    }
+
+    /**
+     * @notice Attempts invest and redeemExpected in the same block
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptInvestAndRedeemExpected(uint256 amount) external returns (uint256) {
+        uint256 shares = equity.invest(amount, 0);
+        uint256 proceeds = equity.redeemExpected(address(this), shares, 0);
+        return proceeds;
+    }
+
+    /**
+     * @notice Attempts investFor and redeemFrom on behalf of another investor in the same block
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptInvestForAndRedeemFrom(uint256 amount, address investor) external returns (uint256) {
+        uint256 shares = equity.investFor(investor, amount, 0);
+        uint256 proceeds = equity.redeemFrom(investor, address(this), shares, 0);
+        return proceeds;
+    }
+}

package/contracts/test/TestFlashLoanGateway.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IFrontendGateway {
+    function invest(uint256 amount, uint256 expectedShares, bytes32 frontendCode) external returns (uint256);
+    function redeem(address target, uint256 shares, uint256 expectedProceeds, bytes32 frontendCode) external returns (uint256);
+}
+
+interface IEquity is IERC20 {
+    function approve(address spender, uint256 amount) external returns (bool);
+}
+
+/**
+ * @title TestFlashLoanGateway
+ * @notice Helper contract to test same-block flash loan protection via FrontendGateway
+ */
+contract TestFlashLoanGateway {
+    IERC20 public immutable jusd;
+    IEquity public immutable equity;
+    IFrontendGateway public immutable gateway;
+
+    constructor(address _jusd, address _equity, address _gateway) {
+        jusd = IERC20(_jusd);
+        equity = IEquity(_equity);
+        gateway = IFrontendGateway(_gateway);
+    }
+
+    /**
+     * @notice Attempts to invest and immediately redeem via FrontendGateway in the same transaction
+     * @dev Should revert with SameBlockRedemption
+     */
+    function attemptInvestAndRedeemViaGateway(
+        uint256 amount,
+        bytes32 frontendCode
+    ) external returns (uint256) {
+        jusd.approve(address(gateway), amount);
+        jusd.approve(address(equity), amount);
+
+        uint256 shares = gateway.invest(amount, 0, frontendCode);
+        
+        equity.approve(address(gateway), shares);
+        uint256 proceeds = gateway.redeem(address(this), shares, 0, frontendCode);
+
+        jusd.transfer(msg.sender, proceeds);
+        return proceeds;
+    }
+}

package/contracts/test/TestMathUtil.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../utils/MathUtil.sol";
+
+contract TestMathUtil is MathUtil {
+    uint256 public result;
+
+    constructor() {
+        result = 1;
+    }
+
+    function calculateShares(
+        uint256 totalShares,
+        uint256 capitalBefore,
+        uint256 investment
+    ) external pure returns (uint256) {
+        uint256 newTotalShares = _mulD18(totalShares, _tenthRoot(_divD18(capitalBefore + investment, capitalBefore)));
+        return newTotalShares - totalShares;
+    }
+
+    function mulD18(uint256 _a, uint256 _b) external pure returns (uint256) {
+        return _mulD18(_a, _b);
+    }
+
+    function divD18(uint256 _a, uint256 _b) external pure returns (uint256) {
+        return _divD18(_a, _b);
+    }
+
+    function power10(uint256 _x) external pure returns (uint256) {
+        return _power10(_x);
+    }
+
+    function tenthRoot(uint256 a, bool recordResult) external {
+        uint256 r = _tenthRoot(a);
+        if (recordResult) {
+            result = r;
+        }
+    }
+}