@juicedollar/jusd 1.0.2 → 1.0.4

package/contracts/MintingHubV2/PositionRoller.sol

@@ -8,6 +8,7 @@ import {IMintingHubGateway} from "../gateway/interface/IMintingHubGateway.sol";
 import {IMintingHub} from "./interface/IMintingHub.sol";
 import {IPosition} from "./interface/IPosition.sol";
 import {IReserve} from "../interface/IReserve.sol";
+import {IWrappedNative} from "../interface/IWrappedNative.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 
 /**
@@ -15,13 +16,19 @@ import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
  *
  * Helper to roll over a debt from an old position to a new one.
  * Both positions should have the same collateral. Otherwise, it does not make much sense.
+ *
+ * For standard ERC20 positions, use roll/rollFully/rollFullyWithExpiration.
+ * Collateral flows through the user's wallet and requires approval.
+ *
+ * For native coin positions (e.g., WCBTC), use rollNative/rollFullyNative/rollFullyNativeWithExpiration.
+ * Collateral flows through the roller, no approval needed, and excess is returned as native coin.
  */
 contract PositionRoller {
     IJuiceDollar private jusd;
 
     error NotOwner(address pos);
     error NotPosition(address pos);
-    error Log(uint256, uint256, uint256);
+    error NativeTransferFailed();
 
     event Roll(address source, uint256 collWithdraw, uint256 repay, address target, uint256 collDeposit, uint256 mint);
 
@@ -32,8 +39,8 @@ contract PositionRoller {
     /**
      * Convenience method to roll an old position into a new one.
      *
-     * Pre-condition: an allowance for the roller to spend the collateral asset on behalf of the caller,
-     * i.e., one should set collateral.approve(roller, collateral.balanceOf(sourcePosition)).
+     * Pre-condition: an allowance for the roller to spend the collateral asset
+     * on behalf of the caller, i.e., collateral.approve(roller, collateral.balanceOf(sourcePosition)).
      *
      * The following is assumed:
      * - If the limit of the target position permits, the user wants to roll everything.
@@ -49,21 +56,12 @@ contract PositionRoller {
      */
     function rollFullyWithExpiration(IPosition source, IPosition target, uint40 expiration) public {
         require(source.collateral() == target.collateral());
-        uint256 principal = source.principal();
-        uint256 interest = source.getInterest();
-        uint256 usableMint = source.getUsableMint(principal) + interest; // Roll interest into principal
-        uint256 mintAmount = target.getMintAmount(usableMint);
-        uint256 collateralToWithdraw = IERC20(source.collateral()).balanceOf(address(source));
-        uint256 targetPrice = target.price();
-        uint256 depositAmount = (mintAmount * 10 ** 18 + targetPrice - 1) / targetPrice; // round up
-        if (depositAmount > collateralToWithdraw) {
-            // If we need more collateral than available from the old position, we opt for taking
-            // the missing funds from the caller instead of requiring additional collateral.
-            depositAmount = collateralToWithdraw;
-            mintAmount = (depositAmount * target.price()) / 10 ** 18; // round down, rest will be taken from caller
-        }
-
-        roll(source, principal + interest, collateralToWithdraw, target, mintAmount, depositAmount, expiration);
+        (uint256 repay, uint256 collWithdraw, uint256 mint, uint256 collDeposit) = _calculateRollParams(
+            source,
+            target,
+            0
+        );
+        roll(source, repay, collWithdraw, target, mint, collDeposit, expiration);
     }
 
     /**
@@ -72,12 +70,12 @@ contract PositionRoller {
      * It is the responsibility of the caller to ensure that both positions are valid contracts.
      *
      * @param source The source position, must be owned by the msg.sender.
-     * @param repay The amount of principal to repay from the source position using a flash loan, freeing up some or all collateral .
-     * @param collWithdraw Collateral to move from the source position to the msg.sender.
+     * @param repay The amount of principal to repay from the source position using a flash loan.
+     * @param collWithdraw Collateral to withdraw from the source position.
      * @param target The target position. If not owned by msg.sender or if it does not have the desired expiration,
      *               it is cloned to create a position owned by the msg.sender.
-     * @param mint The amount to be minted from the target position using collateral from msg.sender.
-     * @param collDeposit The amount of collateral to be sent from msg.sender to the target position.
+     * @param mint The amount to be minted from the target position.
+     * @param collDeposit The amount of collateral to deposit into the target position.
      * @param expiration The desired expiration date for the target position.
      */
     function roll(
@@ -94,9 +92,10 @@ contract PositionRoller {
         source.withdrawCollateral(msg.sender, collWithdraw);
         if (mint > 0) {
             IERC20 targetCollateral = IERC20(target.collateral());
-            if (Ownable(address(target)).owner() != msg.sender || expiration != target.expiration()) {
-                targetCollateral.transferFrom(msg.sender, address(this), collDeposit); // get the new collateral
-                targetCollateral.approve(target.hub(), collDeposit); // approve the new collateral and clone:
+            bool needsClone = Ownable(address(target)).owner() != msg.sender || expiration != target.expiration();
+            if (needsClone) {
+                targetCollateral.transferFrom(msg.sender, address(this), collDeposit);
+                targetCollateral.approve(target.hub(), collDeposit);
                 target = _cloneTargetPosition(target, source, collDeposit, mint, expiration);
             } else {
                 // We can roll into the provided existing position.
@@ -116,10 +115,125 @@ contract PositionRoller {
         emit Roll(address(source), collWithdraw, repay, address(target), collDeposit, mint);
     }
 
+    /**
+     * Convenience method to roll a native coin position into a new one.
+     *
+     * No collateral approval is needed - collateral flows through the roller
+     * and excess is returned as native coin.
+     *
+     * Additional collateral can be provided via msg.value.
+     */
+    function rollFullyNative(IPosition source, IPosition target) external payable {
+        rollFullyNativeWithExpiration(source, target, target.expiration());
+    }
+
+    /**
+     * Like rollFullyNative, but with a custom expiration date for the new position.
+     */
+    function rollFullyNativeWithExpiration(IPosition source, IPosition target, uint40 expiration) public payable {
+        require(source.collateral() == target.collateral());
+        (uint256 repay, uint256 collWithdraw, uint256 mint, uint256 collDeposit) = _calculateRollParams(
+            source,
+            target,
+            msg.value
+        );
+        rollNative(source, repay, collWithdraw, target, mint, collDeposit, expiration);
+    }
+
+    /**
+     * Rolls a native coin position into the target position using a flash loan.
+     * Collateral is routed through the roller and returned as native coin,
+     * eliminating the need for users to interact with wrapped native tokens directly.
+     *
+     * If additional collateral is needed (collDeposit > collWithdraw), it can be provided
+     * as native coin via msg.value.
+     *
+     * @param source The source position, must be owned by the msg.sender.
+     * @param repay The amount of principal to repay from the source position using a flash loan.
+     * @param collWithdraw Collateral to withdraw from the source position.
+     * @param target The target position. If not owned by msg.sender or if it does not have the desired expiration,
+     *               it is cloned to create a position owned by the msg.sender.
+     * @param mint The amount to be minted from the target position.
+     * @param collDeposit The amount of collateral to deposit into the target position.
+     * @param expiration The desired expiration date for the target position.
+     */
+    function rollNative(
+        IPosition source,
+        uint256 repay,
+        uint256 collWithdraw,
+        IPosition target,
+        uint256 mint,
+        uint256 collDeposit,
+        uint40 expiration
+    ) public payable valid(source) valid(target) own(source) {
+        address collateral = address(source.collateral());
+
+        jusd.mint(address(this), repay); // take a flash loan
+        uint256 used = source.repay(repay);
+        source.withdrawCollateral(address(this), collWithdraw);
+        if (msg.value > 0) {
+            IWrappedNative(collateral).deposit{value: msg.value}();
+        }
+
+        if (mint > 0) {
+            IERC20 targetCollateral = IERC20(collateral);
+            bool needsClone = Ownable(address(target)).owner() != msg.sender || expiration != target.expiration();
+            if (needsClone) {
+                targetCollateral.approve(target.hub(), collDeposit);
+                target = _cloneTargetPosition(target, source, collDeposit, mint, expiration);
+            } else {
+                targetCollateral.transfer(address(target), collDeposit);
+                target.mint(msg.sender, mint);
+            }
+        }
+
+        // Transfer remaining flash loan to caller for repayment
+        if (repay > used) {
+            jusd.transfer(msg.sender, repay - used);
+        }
+        jusd.burnFrom(msg.sender, repay); // repay the flash loan
+
+        // Return excess as native coin
+        uint256 remaining = IERC20(collateral).balanceOf(address(this));
+        if (remaining > 0) {
+            IWrappedNative(collateral).withdraw(remaining);
+            (bool success, ) = msg.sender.call{value: remaining}("");
+            if (!success) revert NativeTransferFailed();
+        }
+
+        emit Roll(address(source), collWithdraw, repay, address(target), collDeposit, mint);
+    }
+
+    /**
+     * Calculates the parameters for a roll operation.
+     * @param extraCollateral Additional collateral provided via msg.value (for native rolls).
+     */
+    function _calculateRollParams(
+        IPosition source,
+        IPosition target,
+        uint256 extraCollateral
+    ) internal view returns (uint256 repay, uint256 collWithdraw, uint256 mint, uint256 collDeposit) {
+        uint256 principal = source.principal();
+        uint256 interest = source.getInterest();
+        uint256 usableMint = source.getUsableMint(principal) + interest;
+        uint256 mintAmount = target.getMintAmount(usableMint);
+        uint256 collateralAvailable = IERC20(source.collateral()).balanceOf(address(source));
+        uint256 totalAvailable = collateralAvailable + extraCollateral;
+        uint256 targetPrice = target.price();
+        uint256 depositAmount = (mintAmount * 10 ** 18 + targetPrice - 1) / targetPrice;
+
+        if (depositAmount > totalAvailable) {
+            depositAmount = totalAvailable;
+            mintAmount = (depositAmount * target.price()) / 10 ** 18;
+        }
+
+        return (principal + interest, collateralAvailable, mintAmount, depositAmount);
+    }
+
     /**
      * Clones the target position and mints the specified amount using the given collateral.
      */
-    function _cloneTargetPosition (
+    function _cloneTargetPosition(
         IPosition target,
         IPosition source,
         uint256 collDeposit,
@@ -127,23 +241,24 @@ contract PositionRoller {
         uint40 expiration
     ) internal returns (IPosition) {
         if (IERC165(target.hub()).supportsInterface(type(IMintingHubGateway).interfaceId)) {
-            bytes32 frontendCode = IMintingHubGateway(target.hub()).GATEWAY().getPositionFrontendCode(
-                address(source)
-            );
-            return IPosition(
-                IMintingHubGateway(target.hub()).clone(
-                    msg.sender,
-                    address(target),
-                    collDeposit,
-                    mint,
-                    expiration,
-                    frontendCode // use the same frontend code
-                )
-            );
+            bytes32 frontendCode = IMintingHubGateway(target.hub()).GATEWAY().getPositionFrontendCode(address(source));
+            return
+                IPosition(
+                    IMintingHubGateway(target.hub()).clone(
+                        msg.sender,
+                        address(target),
+                        collDeposit,
+                        mint,
+                        expiration,
+                        0, // inherit price from parent
+                        frontendCode // use the same frontend code
+                    )
+                );
         } else {
-            return IPosition(
-                IMintingHub(target.hub()).clone(msg.sender, address(target), collDeposit, mint, expiration)
-            );
+            return
+                IPosition(
+                    IMintingHub(target.hub()).clone(msg.sender, address(target), collDeposit, mint, expiration, 0)
+                );
         }
     }
 
@@ -156,4 +271,7 @@ contract PositionRoller {
         if (jusd.getPositionParent(address(pos)) == address(0x0)) revert NotPosition(address(pos));
         _;
     }
+
+    /// @notice Required to receive native coin when unwrapping
+    receive() external payable {}
 }

package/contracts/MintingHubV2/interface/IMintingHub.sol

@@ -10,6 +10,8 @@ interface IMintingHub {
 
     function ROLLER() external view returns (PositionRoller);
 
+    function WCBTC() external view returns (address);
+
     function challenge(
         address _positionAddr,
         uint256 _collateralAmount,
@@ -22,5 +24,5 @@ interface IMintingHub {
 
     function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external returns (uint256);
 
-    function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration) external returns (address);
+    function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, uint256 _liqPrice) external payable returns (address);
 }

package/contracts/MintingHubV2/interface/IPosition.sol

@@ -56,13 +56,13 @@ interface IPosition {
 
     function getMintAmount(uint256 usableMint) external view returns (uint256);
 
-    function adjust(uint256 newMinted, uint256 newCollateral, uint256 newPrice) external;
+    function adjust(uint256 newMinted, uint256 newCollateral, uint256 newPrice, bool withdrawAsNative) external payable;
 
     function adjustPrice(uint256 newPrice) external;
 
     function adjustPriceWithReference(uint256 newPrice, address referencePosition) external;
 
-    function adjust(uint256 newMinted, uint256 newCollateral, uint256 newPrice, address referencePosition) external;
+    function adjustWithReference(uint256 newMinted, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) external payable;
 
     function isValidPriceReference(address referencePosition, uint256 newPrice) external view returns (bool);
 
@@ -80,10 +80,12 @@ interface IPosition {
 
     function forceSale(address buyer, uint256 colAmount, uint256 proceeds) external;
 
-    function withdraw(address token, address target, uint256 amount) external;
+    function rescueToken(address token, address target, uint256 amount) external;
 
     function withdrawCollateral(address target, uint256 amount) external;
 
+    function withdrawCollateralAsNative(address target, uint256 amount) external;
+
     function transferChallengedCollateral(address target, uint256 amount) external;
 
     function challengeData() external view returns (uint256 liqPrice, uint40 phase);

package/contracts/gateway/MintingHubGateway.sol

@@ -11,10 +11,11 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
     constructor(
         address _jusd,
         address _leadrate,
-        address _roller,
+        address payable _roller,
         address _factory,
-        address _gateway
-    ) MintingHub(_jusd, _leadrate, _roller, _factory) {
+        address _gateway,
+        address _wcbtc
+    ) MintingHub(_jusd, _leadrate, _roller, _factory, _wcbtc) {
         GATEWAY = IFrontendGateway(_gateway);
     }
 
@@ -30,8 +31,8 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
         uint256 _liqPrice,
         uint24 _reservePPM,
         bytes32 _frontendCode
-    ) public returns (address) {
-        address position = openPosition(
+    ) public payable returns (address) {
+        address position = MintingHub.openPosition(
             _collateralAddress,
             _minCollateral,
             _initialCollateral,
@@ -47,19 +48,12 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
         return position;
     }
 
-    function clone(
-        address parent,
-        uint256 _initialCollateral,
-        uint256 _initialMint,
-        uint40 expiration,
-        bytes32 frontendCode
-    ) public returns (address) {
-        return clone(msg.sender, parent, _initialCollateral, _initialMint, expiration, frontendCode);
-    }
-
     /**
-     * @notice Clones an existing position and immediately tries to mint the specified amount using the given collateral.
-     * @dev This needs an allowance to be set on the collateral contract such that the minting hub can get the collateral.
+     * @notice Clones an existing position and immediately tries to mint the specified amount using the given collateral. 
+     * @dev For native coin positions (WcBTC), send msg.value equal to _initialCollateral.
+     * For ERC20 collateral, ensure prior approval for the minting hub to transfer _initialCollateral.
+     * @param _liqPrice Optionally adjust price of new position after minting. Set to 0 to inherit parent's price.
+     * @param frontendCode Optionally register the position with a frontend code.
      */
     function clone(
         address owner,
@@ -67,9 +61,10 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
         uint256 _initialCollateral,
         uint256 _initialMint,
         uint40 expiration,
+        uint256 _liqPrice,
         bytes32 frontendCode
-    ) public returns (address) {
-        address position = clone(owner, parent, _initialCollateral, _initialMint, expiration);
+    ) public payable returns (address) {
+        address position = MintingHub.clone(owner, parent, _initialCollateral, _initialMint, expiration, _liqPrice);
         GATEWAY.registerPosition(position, frontendCode);
         return position;
     }

package/contracts/gateway/interface/IMintingHubGateway.sol

@@ -7,6 +7,6 @@ import {IFrontendGateway} from "./IFrontendGateway.sol";
 interface IMintingHubGateway {
     function GATEWAY() external view returns (IFrontendGateway);
     function notifyInterestPaid(uint256 amount) external;
-    function openPosition(address _collateralAddress, uint256 _minCollateral, uint256 _initialCollateral, uint256 _mintingMaximum, uint40 _initPeriodSeconds, uint40 _expirationSeconds, uint40 _challengeSeconds, uint24 _riskPremium, uint256 _liqPrice, uint24 _reservePPM, bytes32 _frontendCode) external returns (address);
-    function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, bytes32 frontendCode) external returns (address);
+    function openPosition(address _collateralAddress, uint256 _minCollateral, uint256 _initialCollateral, uint256 _mintingMaximum, uint40 _initPeriodSeconds, uint40 _expirationSeconds, uint40 _challengeSeconds, uint24 _riskPremium, uint256 _liqPrice, uint24 _reservePPM, bytes32 _frontendCode) external payable returns (address);
+    function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, uint256 _liqPrice, bytes32 frontendCode) external payable returns (address);
 }

package/contracts/interface/IWrappedNative.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Interface for wrapped native tokens (e.g., WcBTC, WETH)
+ */
+interface IWrappedNative {
+    function deposit() external payable;
+    function withdraw(uint256) external;
+}

package/contracts/test/PositionExpirationTest.sol

@@ -54,7 +54,7 @@ contract PositionExpirationTest {
                 200000
             );
         }
-        Position(pos).transferOwnership(owner);
+        Position(payable(pos)).transferOwnership(owner);
         return pos;
     }
 
@@ -63,10 +63,10 @@ contract PositionExpirationTest {
     }
 
     function forceBuy(address pos, uint256 amount) public {
-        uint256 price = hub.expiredPurchasePrice(Position(pos));
+        uint256 price = hub.expiredPurchasePrice(Position(payable(pos)));
         uint256 balanceBefore = jusd.balanceOf(address(this));
         uint256 colBalBefore = col.balanceOf(address(this));
-        amount = hub.buyExpiredCollateral(Position(pos), amount);
+        amount = hub.buyExpiredCollateral(Position(payable(pos)), amount);
         uint256 balanceAfter = jusd.balanceOf(address(this));
         uint256 colBalAfter = col.balanceOf(address(this));
         require(colBalAfter - colBalBefore == amount, "collateral amount");

package/contracts/test/ReentrantAttacker.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPosition} from "../MintingHubV2/interface/IPosition.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title ReentrantAttacker
+ * @notice Test contract that attempts reentrancy attack on Position.withdrawCollateralAsNative()
+ * @dev Used to verify Position is safe against reentrancy
+ */
+contract ReentrantAttacker is Ownable {
+    IPosition public targetPosition;
+    uint256 public attackCount;
+    uint256 public withdrawAmount;
+    bool public attackSucceeded;
+    string public lastRevertReason;
+
+    event AttackAttempted(uint256 count, bool success, string reason);
+
+    constructor() Ownable(msg.sender) {}
+
+    /**
+     * @notice Sets the target position for the attack
+     * @param _position The position contract to attack
+     */
+    function setTarget(address _position) external onlyOwner {
+        targetPosition = IPosition(_position);
+    }
+
+    /**
+     * @notice Initiates the reentrancy attack
+     * @param _amount Amount to withdraw in each attempt
+     */
+    function attack(uint256 _amount) external onlyOwner {
+        require(address(targetPosition) != address(0), "Target not set");
+        withdrawAmount = _amount;
+        attackCount = 0;
+        attackSucceeded = false;
+        lastRevertReason = "";
+
+        targetPosition.withdrawCollateralAsNative(address(this), _amount);
+    }
+
+    /**
+     * @notice Called when receiving native coin - attempts reentrancy
+     */
+    receive() external payable {
+        attackCount++;
+
+        if (attackCount < 2) {
+            // Attempt reentrancy on second receive
+            try targetPosition.withdrawCollateralAsNative(address(this), withdrawAmount) {
+                // If this succeeds, reentrancy attack worked
+                attackSucceeded = true;
+                emit AttackAttempted(attackCount, true, "Attack succeeded - VULNERABILITY!");
+            } catch Error(string memory reason) {
+                lastRevertReason = reason;
+                emit AttackAttempted(attackCount, false, reason);
+            } catch (bytes memory) {
+                lastRevertReason = "Unknown revert";
+                emit AttackAttempted(attackCount, false, "Unknown revert");
+            }
+        }
+    }
+
+    /**
+     * @notice Allows owner to withdraw any native coin from this contract
+     */
+    function withdrawAll() external onlyOwner {
+        (bool success, ) = owner().call{value: address(this).balance}("");
+        require(success, "Withdraw failed");
+    }
+}

package/contracts/test/RejectNative.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title RejectNative
+ * @notice Test helper contract that rejects all native coin transfers
+ * @dev Used to test NativeTransferFailed error in Position.withdrawCollateralAsNative()
+ */
+contract RejectNative {
+    receive() external payable {
+        revert("I reject native coin");
+    }
+
+    fallback() external payable {
+        revert("I reject native coin");
+    }
+}