@juicedollar/jusd 1.0.2 → 1.0.4

package/contracts/MintingHubV2/MintingHub.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IWrappedNative} from "../interface/IWrappedNative.sol";
 import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
@@ -36,6 +37,7 @@ contract MintingHub is IMintingHub, ERC165 {
     IJuiceDollar public immutable JUSD; // currency
     PositionRoller public immutable ROLLER; // helper to roll positions
     ILeadrate public immutable RATE; // to determine the interest rate
+    address public immutable WCBTC; // wrapped native token (cBTC) address
 
     Challenge[] public challenges; // list of open challenges
 
@@ -45,6 +47,12 @@ contract MintingHub is IMintingHub, ERC165 {
      */
     mapping(address collateral => mapping(address owner => uint256 amount)) public pendingReturns;
 
+    /**
+     * @notice Tracks whether the first position has been created.
+     * @dev The first position (genesis) can skip the 3-day init period requirement.
+     */
+    bool private _genesisPositionCreated;
+
     struct Challenge {
         address challenger; // the address from which the challenge was initiated
         uint40 start; // the start of the challenge
@@ -75,17 +83,20 @@ contract MintingHub is IMintingHub, ERC165 {
     error InvalidCollateralDecimals();
     error ChallengeTimeTooShort();
     error InitPeriodTooShort();
+    error NativeOnlyForWCBTC();
+    error ValueMismatch();
 
     modifier validPos(address position) {
         if (JUSD.getPositionParent(position) != address(this)) revert InvalidPos();
         _;
     }
 
-    constructor(address _jusd, address _leadrate, address _roller, address _factory) {
+    constructor(address _jusd, address _leadrate, address payable _roller, address _factory, address _wcbtc) {
         JUSD = IJuiceDollar(_jusd);
         RATE = ILeadrate(_leadrate);
         POSITION_FACTORY = IPositionFactory(_factory);
         ROLLER = PositionRoller(_roller);
+        WCBTC = _wcbtc;
     }
 
     /**
@@ -118,15 +129,20 @@ contract MintingHub is IMintingHub, ERC165 {
         uint24 _riskPremium,
         uint256 _liqPrice,
         uint24 _reservePPM
-    ) public returns (address) {
+    ) public payable returns (address) {
         {
             if (_riskPremium > 1_000_000) revert InvalidRiskPremium();
             if (CHALLENGER_REWARD > _reservePPM || _reservePPM > 1_000_000) revert InvalidReservePPM();
             if (IERC20Metadata(_collateralAddress).decimals() > 24) revert InvalidCollateralDecimals(); // leaves 12 digits for price
             if (_challengeSeconds < 1 days) revert ChallengeTimeTooShort();
-            if (_initPeriodSeconds < 6 hours) revert InitPeriodTooShort();
+            // First position (genesis) can skip init period, all others require 3 days minimum
+            if (_genesisPositionCreated) {
+                if (_initPeriodSeconds < 3 days) revert InitPeriodTooShort();
+            } else {
+                _genesisPositionCreated = true;
+            }
             uint256 invalidAmount = IERC20(_collateralAddress).totalSupply() + 1;
-            // TODO: Improve for older tokens that revert with assert, 
+            // TODO: Improve for older tokens that revert with assert,
             // which consumes all gas and makes the entire tx fail (uncatchable)
             try IERC20(_collateralAddress).transfer(address(0x123), invalidAmount) {
                 revert IncompatibleCollateral(); // we need a collateral that reverts on failed transfers
@@ -137,6 +153,7 @@ contract MintingHub is IMintingHub, ERC165 {
             // must start with at least 100 JUSD worth of collateral
             if (_minCollateral * _liqPrice < 100 ether * 10 ** 18) revert InsufficientCollateral();
         }
+
         IPosition pos = IPosition(
             POSITION_FACTORY.createNewPosition(
                 msg.sender,
@@ -154,41 +171,65 @@ contract MintingHub is IMintingHub, ERC165 {
         );
         JUSD.registerPosition(address(pos));
         JUSD.collectProfits(msg.sender, OPENING_FEE);
-        IERC20(_collateralAddress).transferFrom(msg.sender, address(pos), _initialCollateral); // TODO: Use SafeERC20
+
+        // Transfer collateral (handles native coin positions)
+        if (msg.value > 0) {
+            if (_collateralAddress != WCBTC) revert NativeOnlyForWCBTC();
+            if (msg.value != _initialCollateral) revert ValueMismatch();
+            IWrappedNative(WCBTC).deposit{value: msg.value}();
+            IERC20(WCBTC).transfer(address(pos), _initialCollateral);
+        } else {
+            IERC20(_collateralAddress).transferFrom(msg.sender, address(pos), _initialCollateral); // TODO: Use SafeERC20
+        }
 
         emit PositionOpened(msg.sender, address(pos), address(pos), _collateralAddress);
         return address(pos);
     }
 
-    function clone(
-        address parent,
-        uint256 _initialCollateral,
-        uint256 _initialMint,
-        uint40 expiration
-    ) public returns (address) {
-        return clone(msg.sender, parent, _initialCollateral, _initialMint, expiration);
-    }
-
     /**
      * @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.
+     * For native coin positions (WcBTC), send msg.value equal to _initialCollateral.
+     * @param owner The owner of the cloned position
+     * @param parent The parent position to clone from
+     * @param _initialCollateral Amount of collateral to deposit
+     * @param _initialMint Amount of JUSD to mint
+     * @param expiration Expiration timestamp for the clone
+     * @param _liqPrice The liquidation price. If 0, inherits from parent.
      */
     function clone(
         address owner,
         address parent,
         uint256 _initialCollateral,
         uint256 _initialMint,
-        uint40 expiration
-    ) public validPos(parent) returns (address) {
+        uint40 expiration,
+        uint256 _liqPrice
+    ) public payable validPos(parent) returns (address) {
         address pos = POSITION_FACTORY.clonePosition(parent);
         IPosition child = IPosition(pos);
         child.initialize(parent, expiration);
         JUSD.registerPosition(pos);
         IERC20 collateral = child.collateral();
         if (_initialCollateral < child.minimumCollateral()) revert InsufficientCollateral();
-        collateral.transferFrom(msg.sender, pos, _initialCollateral); // collateral must still come from sender for security
+
+        // Transfer collateral (handles native coin positions)
+        if (msg.value > 0) {
+            if (address(collateral) != WCBTC) revert NativeOnlyForWCBTC();
+            if (msg.value != _initialCollateral) revert ValueMismatch();
+            IWrappedNative(WCBTC).deposit{value: msg.value}();
+            collateral.transfer(pos, _initialCollateral);
+        } else {
+            collateral.transferFrom(msg.sender, pos, _initialCollateral); // collateral must still come from sender for security
+        }
+
         emit PositionOpened(owner, address(pos), parent, address(collateral));
         child.mint(owner, _initialMint);
+
+        // Adjust price if requested, incurs cooldown on price increase
+        if (_liqPrice > 0 && _liqPrice != child.price()) {
+            child.adjustPrice(_liqPrice);
+        }
+
         Ownable(address(child)).transferOwnership(owner);
         return address(pos);
     }

package/contracts/MintingHubV2/Position.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import {IMintingHubGateway} from "../gateway/interface/IMintingHubGateway.sol";
+import {IWrappedNative} from "../interface/IWrappedNative.sol";
 import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
 import {IReserve} from "../interface/IReserve.sol";
 import {MathUtil} from "../utils/MathUtil.sol";
@@ -141,6 +142,8 @@ contract Position is Ownable, IPosition, MathUtil {
     error AlreadyInitialized();
     error PriceTooHigh(uint256 newPrice, uint256 maxPrice);
     error InvalidPriceReference();
+    error NativeTransferFailed();
+    error CannotRescueCollateral();
 
     modifier alive() {
         if (block.timestamp >= expiration) revert Expired(uint40(block.timestamp), expiration);
@@ -205,7 +208,7 @@ contract Position is Ownable, IPosition, MathUtil {
         reserveContribution = _reservePPM;
         minimumCollateral = _minCollateral;
         challengePeriod = _challengePeriod;
-        start = uint40(block.timestamp) + _initPeriod; // at least six hours time to deny the position
+        start = uint40(block.timestamp) + _initPeriod; // at least three days time to deny the position
         cooldown = start;
         expiration = start + _duration;
         limit = _initialLimit;
@@ -219,10 +222,10 @@ contract Position is Ownable, IPosition, MathUtil {
      */
     function initialize(address parent, uint40 _expiration) external onlyHub {
         if (expiration != 0) revert AlreadyInitialized();
-        if (_expiration < block.timestamp || _expiration > Position(original).expiration()) revert InvalidExpiration(); // expiration must not be later than original
+        if (_expiration < block.timestamp || _expiration > Position(payable(original)).expiration()) revert InvalidExpiration(); // expiration must not be later than original
         expiration = _expiration;
-        price = Position(parent).price();
-        _fixRateToLeadrate(Position(parent).riskPremiumPPM());
+        price = Position(payable(parent)).price();
+        _fixRateToLeadrate(Position(payable(parent)).riskPremiumPPM());
         _transferOwnership(hub);
     }
 
@@ -268,7 +271,7 @@ contract Position is Ownable, IPosition, MathUtil {
         if (address(this) == original) {
             return limit - totalMinted;
         } else {
-            return Position(original).availableForClones();
+            return Position(payable(original)).availableForClones();
         }
     }
 
@@ -312,27 +315,46 @@ contract Position is Ownable, IPosition, MathUtil {
     /**
      * @notice "All in one" function to adjust the principal, the collateral amount,
      * and the price in one transaction.
+     * @dev For native coin positions (WCBTC), msg.value will be wrapped and added as collateral.
+     *      If withdrawAsNative is true, collateral withdrawals will be unwrapped to native coin.
+     * @param newPrincipal The new principal amount
+     * @param newCollateral The new collateral amount
+     * @param newPrice The new liquidation price
+     * @param withdrawAsNative If true, withdraw collateral as native coin instead of wrapped token
      */
-    function adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice) external onlyOwner {
-        _adjust(newPrincipal, newCollateral, newPrice, address(0));
+    function adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, bool withdrawAsNative) external payable onlyOwner {
+        _adjust(newPrincipal, newCollateral, newPrice, address(0), withdrawAsNative);
     }
 
     /**
      * @notice "All in one" function to adjust the principal, the collateral amount,
      * and the price in one transaction, with optional reference position for cooldown-free price increase.
+     * @dev For native coin positions (WCBTC), msg.value will be wrapped and added as collateral.
+     *      If withdrawAsNative is true, collateral withdrawals will be unwrapped to native coin.
      * @param newPrincipal The new principal amount
      * @param newCollateral The new collateral amount
      * @param newPrice The new liquidation price
      * @param referencePosition Reference position for cooldown-free price increase (address(0) for normal logic with cooldown)
+     * @param withdrawAsNative If true, withdraw collateral as native coin instead of wrapped token
      */
-    function adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, address referencePosition) external onlyOwner {
-        _adjust(newPrincipal, newCollateral, newPrice, referencePosition);
+    function adjustWithReference(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) external payable onlyOwner {
+        _adjust(newPrincipal, newCollateral, newPrice, referencePosition, withdrawAsNative);
     }
 
     /**
      * @dev Internal implementation of adjust() - handles collateral, principal, and price adjustments.
+     * @param newPrincipal The new principal amount
+     * @param newCollateral The new collateral amount
+     * @param newPrice The new liquidation price
+     * @param referencePosition Reference position for cooldown-free price increase (address(0) for normal logic)
+     * @param withdrawAsNative If true and withdrawing collateral, unwrap to native coin
      */
-    function _adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, address referencePosition) internal {
+    function _adjust(uint256 newPrincipal, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) internal {
+        // Handle native coin deposit first (wraps to WCBTC)
+        if (msg.value > 0) {
+            IWrappedNative(address(collateral)).deposit{value: msg.value}();
+        }
+
         uint256 colbal = _collateralBalance();
         if (newCollateral > colbal) {
             collateral.transferFrom(msg.sender, address(this), newCollateral - colbal);
@@ -343,7 +365,11 @@ contract Position is Ownable, IPosition, MathUtil {
             _payDownDebt(debt - newPrincipal);
         }
         if (newCollateral < colbal) {
-            _withdrawCollateral(msg.sender, colbal - newCollateral);
+            if (withdrawAsNative) {
+                _withdrawCollateralAsNative(msg.sender, colbal - newCollateral);
+            } else {
+                _withdrawCollateral(msg.sender, colbal - newCollateral);
+            }
         }
         // Must be called after collateral withdrawal
         if (newPrincipal > principal) {
@@ -359,6 +385,7 @@ contract Position is Ownable, IPosition, MathUtil {
      * @notice Allows the position owner to adjust the liquidation price as long as there is no pending challenge.
      * Lowering the liquidation price can be done with immediate effect, given that there is enough collateral.
      * Increasing the liquidation price triggers a cooldown period of 3 days, during which minting is suspended.
+     * @param newPrice The new liquidation price
      */
     function adjustPrice(uint256 newPrice) public onlyOwner {
         _adjustPrice(newPrice, address(0));
@@ -589,7 +616,7 @@ contract Position is Ownable, IPosition, MathUtil {
         _accrueInterest(); // accrue interest
         _fixRateToLeadrate(riskPremiumPPM); // sync interest rate with leadrate
 
-        Position(original).notifyMint(amount);
+        Position(payable(original)).notifyMint(amount);
         jusd.mintWithReserve(target, amount, reserveContribution);
 
         principal += amount;
@@ -643,7 +670,7 @@ contract Position is Ownable, IPosition, MathUtil {
      */
     function _notifyRepaid(uint256 amount) internal {
         if (amount > principal) revert RepaidTooMuch(amount - principal);
-        Position(original).notifyRepaid(amount);
+        Position(payable(original)).notifyRepaid(amount);
         principal -= amount;
     }
 
@@ -713,36 +740,68 @@ contract Position is Ownable, IPosition, MathUtil {
     }
 
     /**
-     * @notice Withdraw any ERC20 token that might have ended up on this address.
-     * Withdrawing collateral is subject to the same restrictions as withdrawCollateral(...).
+     * @notice Rescue ERC20 tokens that were accidentally sent to this address.
+     * @dev Cannot be used for collateral - use withdrawCollateral() instead.
+     * @param token The ERC20 token to rescue
+     * @param target The address to send rescued tokens to
+     * @param amount The amount of tokens to rescue
      */
-    function withdraw(address token, address target, uint256 amount) external onlyOwner {
-        if (token == address(collateral)) {
-            withdrawCollateral(target, amount);
-        } else {
-            uint256 balance = _collateralBalance();
-            IERC20(token).transfer(target, amount);
-            require(balance == _collateralBalance()); // guard against double-entry-point tokens
-        }
+    function rescueToken(address token, address target, uint256 amount) external onlyOwner {
+        if (token == address(collateral)) revert CannotRescueCollateral();
+        uint256 balance = _collateralBalance();
+        IERC20(token).transfer(target, amount);
+        require(balance == _collateralBalance()); // guard against double-entry-point tokens
     }
 
     /**
      * @notice Withdraw collateral from the position up to the extent that it is still well collateralized afterwards.
      * Not possible as long as there is an open challenge or the contract is subject to a cooldown.
-     *
      * Withdrawing collateral below the minimum collateral amount formally closes the position.
+     * @param target Address to receive the collateral
+     * @param amount Amount of collateral to withdraw
      */
     function withdrawCollateral(address target, uint256 amount) public ownerOrRoller {
         uint256 balance = _withdrawCollateral(target, amount);
         emit MintingUpdate(balance, price, principal);
     }
 
+    /**
+     * @notice Withdraw collateral as native coin (unwrapped).
+     * @dev Only works for wrapped native collateral tokens.
+     * @param target Address to receive the native coin
+     * @param amount Amount of collateral to withdraw and unwrap
+     */
+    function withdrawCollateralAsNative(address target, uint256 amount) public onlyOwner {
+        uint256 balance = _withdrawCollateralAsNative(target, amount);
+        emit MintingUpdate(balance, price, principal);
+    }
+
     function _withdrawCollateral(address target, uint256 amount) internal noCooldown noChallenge returns (uint256) {
         uint256 balance = _sendCollateral(target, amount);
         _checkCollateral(balance, price);
         return balance;
     }
 
+    /**
+     * @dev Internal helper for native coin withdrawal. Used by withdrawCollateralAsNative() and _adjust().
+     *      Does NOT emit MintingUpdate - callers are responsible for emitting.
+     */
+    function _withdrawCollateralAsNative(address target, uint256 amount) internal noCooldown noChallenge returns (uint256) {
+        if (amount > 0) {
+            IWrappedNative(address(collateral)).withdraw(amount);
+            (bool success, ) = target.call{value: amount}("");
+            if (!success) revert NativeTransferFailed();
+        }
+
+        uint256 balance = _collateralBalance();
+        if (balance < minimumCollateral) {
+            _close();
+        }
+
+        _checkCollateral(balance, price);
+        return balance;
+    }
+
     /**
      * @notice Transfer the challenged collateral to the bidder. Only callable by minting hub.
      */
@@ -903,4 +962,15 @@ contract Position is Ownable, IPosition, MathUtil {
 
         return (owner(), _size, principalToPay, interestToPay, reserveContribution);
     }
+
+    /**
+     * @notice Receive native coin and auto-wrap to collateral.
+     * @dev Reverts for non-native positions to prevent stuck funds.
+     * Checks if sender is collateral to prevent unwrap loops.
+     */
+    receive() external payable {
+        if (msg.sender != address(collateral)) {
+            IWrappedNative(address(collateral)).deposit{value: msg.value}();
+        }
+    }
 }

package/contracts/MintingHubV2/PositionFactory.sol

@@ -48,9 +48,9 @@ contract PositionFactory {
      * @return address of the newly created clone position
      */
     function clonePosition(address _parent) external returns (address) {
-        Position parent = Position(_parent);
+        Position parent = Position(payable(_parent));
         parent.assertCloneable();
-        Position clone = Position(_createClone(parent.original()));
+        Position clone = Position(payable(_createClone(parent.original())));
         return address(clone);
     }