@juicedollar/jusd 1.0.3 → 1.0.5

package/contracts/MintingHubV2/MintingHub.sol

@@ -47,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
@@ -79,13 +85,14 @@ contract MintingHub is IMintingHub, ERC165 {
     error InitPeriodTooShort();
     error NativeOnlyForWCBTC();
     error ValueMismatch();
+    error NativeTransferFailed();
 
     modifier validPos(address position) {
         if (JUSD.getPositionParent(position) != address(this)) revert InvalidPos();
         _;
     }
 
-    constructor(address _jusd, address _leadrate, address _roller, address _factory, address _wcbtc) {
+    constructor(address _jusd, address _leadrate, address payable _roller, address _factory, address _wcbtc) {
         JUSD = IJuiceDollar(_jusd);
         RATE = ILeadrate(_leadrate);
         POSITION_FACTORY = IPositionFactory(_factory);
@@ -129,7 +136,12 @@ contract MintingHub is IMintingHub, ERC165 {
             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 < 3 days) 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,
             // which consumes all gas and makes the entire tx fail (uncatchable)
@@ -225,6 +237,7 @@ contract MintingHub is IMintingHub, ERC165 {
 
     /**
      * @notice Launch a challenge (Dutch auction) on a position
+     * @dev For native coin positions (WcBTC), send msg.value equal to _collateralAmount.
      * @param _positionAddr address of the position we want to challenge
      * @param _collateralAmount amount of the collateral we want to challenge
      * @param minimumPrice guards against the minter front-running with a price change
@@ -234,14 +247,24 @@ contract MintingHub is IMintingHub, ERC165 {
         address _positionAddr,
         uint256 _collateralAmount,
         uint256 minimumPrice
-    ) external validPos(_positionAddr) returns (uint256) {
+    ) external payable validPos(_positionAddr) returns (uint256) {
         IPosition position = IPosition(_positionAddr);
         // challenger should be ok if front-run by owner with a higher price
         // in case owner front-runs challenger with small price decrease to prevent challenge,
         // the challenger should set minimumPrice to market price
         uint256 liqPrice = position.virtualPrice();
         if (liqPrice < minimumPrice) revert UnexpectedPrice();
-        IERC20(position.collateral()).transferFrom(msg.sender, address(this), _collateralAmount);
+
+        // Transfer collateral (handles native coin positions)
+        address collateralAddr = address(position.collateral());
+        if (msg.value > 0) {
+            if (collateralAddr != WCBTC) revert NativeOnlyForWCBTC();
+            if (msg.value != _collateralAmount) revert ValueMismatch();
+            IWrappedNative(WCBTC).deposit{value: msg.value}();
+        } else {
+            IERC20(collateralAddr).transferFrom(msg.sender, address(this), _collateralAmount);
+        }
+
         uint256 pos = challenges.length;
         challenges.push(Challenge(msg.sender, uint40(block.timestamp), position, _collateralAmount));
         position.notifyChallengeStarted(_collateralAmount, liqPrice);
@@ -259,25 +282,36 @@ contract MintingHub is IMintingHub, ERC165 {
      * @param size                      how much of the collateral the caller wants to bid for at most
      *                                  (automatically reduced to the available amount)
      * @param postponeCollateralReturn  To postpone the return of the collateral to the challenger. Usually false.
+     * @param returnCollateralAsNative  If true, return collateral as native coin (only for WcBTC positions).
+     *                                  In phase 1 (aversion): bidder receives native. In phase 2 (liquidation): both
+     *                                  challenger refund and bidder acquisition are returned as native.
      */
-    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn) external {
+    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn, bool returnCollateralAsNative) public {
         Challenge memory _challenge = challenges[_challengeNumber];
         (uint256 liqPrice, uint40 phase) = _challenge.position.challengeData();
         size = _challenge.size < size ? _challenge.size : size; // cannot bid for more than the size of the challenge
 
         if (block.timestamp <= _challenge.start + phase) {
-            _avertChallenge(_challenge, _challengeNumber, liqPrice, size);
+            _avertChallenge(_challenge, _challengeNumber, liqPrice, size, returnCollateralAsNative);
             emit ChallengeAverted(address(_challenge.position), _challengeNumber, size);
         } else {
-            _returnChallengerCollateral(_challenge, _challengeNumber, size, postponeCollateralReturn);
-            (uint256 transferredCollateral, uint256 offer) = _finishChallenge(_challenge, size);
+            _returnChallengerCollateral(_challenge, _challengeNumber, size, postponeCollateralReturn, returnCollateralAsNative);
+            (uint256 transferredCollateral, uint256 offer) = _finishChallenge(_challenge, size, returnCollateralAsNative);
             emit ChallengeSucceeded(address(_challenge.position), _challengeNumber, offer, transferredCollateral, size);
         }
     }
 
+    /**
+     * @notice Post a bid in JUSD given an open challenge (backward compatible version).
+     */
+    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn) external {
+        bid(_challengeNumber, size, postponeCollateralReturn, false);
+    }
+
     function _finishChallenge(
         Challenge memory _challenge,
-        uint256 size
+        uint256 size,
+        bool asNative
     ) internal returns (uint256, uint256) {
         // Repayments depend on what was actually minted, whereas bids depend on the available collateral
         (address owner, uint256 collateral, uint256 repayment, uint256 interest, uint32 reservePPM) = _challenge
@@ -311,11 +345,21 @@ contract MintingHub is IMintingHub, ERC165 {
         }
         JUSD.burnWithoutReserve(repayment, reservePPM); // Repay the challenged part, example: 50 deur leading to 10 deur in implicit profits
         JUSD.collectProfits(address(this), interest); // Collect interest as profits
-        _challenge.position.transferChallengedCollateral(msg.sender, collateral); // transfer the collateral to the bidder
+
+        // Transfer collateral to bidder (handles native coin if requested)
+        if (asNative && address(_challenge.position.collateral()) == WCBTC) {
+            _challenge.position.transferChallengedCollateral(address(this), collateral);
+            IWrappedNative(WCBTC).withdraw(collateral);
+            (bool success, ) = msg.sender.call{value: collateral}("");
+            if (!success) revert NativeTransferFailed();
+        } else {
+            _challenge.position.transferChallengedCollateral(msg.sender, collateral);
+        }
+
         return (collateral, offer);
     }
 
-    function _avertChallenge(Challenge memory _challenge, uint32 number, uint256 liqPrice, uint256 size) internal {
+    function _avertChallenge(Challenge memory _challenge, uint32 number, uint256 liqPrice, uint256 size, bool asNative) internal {
         require(block.timestamp != _challenge.start); // do not allow to avert the challenge in the same transaction, see CS-ZCHF-037
         if (msg.sender == _challenge.challenger) {
             // allow challenger to cancel challenge without paying themselves
@@ -324,13 +368,22 @@ contract MintingHub is IMintingHub, ERC165 {
         }
 
         _challenge.position.notifyChallengeAverted(size);
-        _challenge.position.collateral().transfer(msg.sender, size);
+
         if (size < _challenge.size) {
             challenges[number].size = _challenge.size - size;
         } else {
             require(size == _challenge.size);
             delete challenges[number];
         }
+
+        // Transfer collateral to bidder (handles native coin if requested)
+        if (asNative && address(_challenge.position.collateral()) == WCBTC) {
+            IWrappedNative(WCBTC).withdraw(size);
+            (bool success, ) = msg.sender.call{value: size}("");
+            if (!success) revert NativeTransferFailed();
+        } else {
+            _challenge.position.collateral().transfer(msg.sender, size);
+        }
     }
 
     /**
@@ -340,9 +393,9 @@ contract MintingHub is IMintingHub, ERC165 {
         Challenge memory _challenge,
         uint32 number,
         uint256 amount,
-        bool postpone
+        bool postpone,
+        bool asNative
     ) internal {
-        _returnCollateral(_challenge.position.collateral(), _challenge.challenger, amount, postpone);
         if (_challenge.size == amount) {
             // bid on full amount
             delete challenges[number];
@@ -350,6 +403,7 @@ contract MintingHub is IMintingHub, ERC165 {
             // bid on partial amount
             challenges[number].size -= amount;
         }
+        _returnCollateral(_challenge.position.collateral(), _challenge.challenger, amount, postpone, asNative);
     }
 
     /**
@@ -394,18 +448,39 @@ contract MintingHub is IMintingHub, ERC165 {
 
     /**
      * @notice Challengers can call this method to withdraw collateral whose return was postponed.
+     * @param collateral The collateral token address
+     * @param target The address to receive the collateral
+     * @param asNative If true and collateral is WcBTC, unwrap and send as native coin
      */
-    function returnPostponedCollateral(address collateral, address target) external {
+    function returnPostponedCollateral(address collateral, address target, bool asNative) public {
         uint256 amount = pendingReturns[collateral][msg.sender];
         delete pendingReturns[collateral][msg.sender];
-        IERC20(collateral).transfer(target, amount);
+        if (asNative && collateral == WCBTC) {
+            IWrappedNative(WCBTC).withdraw(amount);
+            (bool success, ) = target.call{value: amount}("");
+            if (!success) revert NativeTransferFailed();
+        } else {
+            IERC20(collateral).transfer(target, amount);
+        }
+    }
+
+    /**
+     * @notice Challengers can call this method to withdraw collateral whose return was postponed (backward compatible).
+     */
+    function returnPostponedCollateral(address collateral, address target) external {
+        returnPostponedCollateral(collateral, target, false);
     }
 
-    function _returnCollateral(IERC20 collateral, address recipient, uint256 amount, bool postpone) internal {
+    function _returnCollateral(IERC20 collateral, address recipient, uint256 amount, bool postpone, bool asNative) internal {
         if (postpone) {
             // Postponing helps in case the challenger was blacklisted or otherwise cannot receive at the moment.
             pendingReturns[address(collateral)][recipient] += amount;
             emit PostponedReturn(address(collateral), recipient, amount);
+        } else if (asNative && address(collateral) == WCBTC) {
+            // Unwrap and return as native coin
+            IWrappedNative(WCBTC).withdraw(amount);
+            (bool success, ) = recipient.call{value: amount}("");
+            if (!success) revert NativeTransferFailed();
         } else {
             collateral.transfer(recipient, amount); // return the challenger's collateral
         }
@@ -447,8 +522,12 @@ contract MintingHub is IMintingHub, ERC165 {
      *
      * To prevent dust either the remaining collateral needs to be bought or collateral with a value
      * of at least OPENING_FEE (1000 JUSD) needs to remain in the position for a different buyer
+     *
+     * @param pos The expired position to buy collateral from
+     * @param upToAmount Maximum amount of collateral to buy
+     * @param receiveAsNative If true and collateral is WcBTC, receive as native coin
      */
-    function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external returns (uint256) {
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount, bool receiveAsNative) public returns (uint256) {
         uint256 max = pos.collateral().balanceOf(address(pos));
         uint256 amount = upToAmount > max ? max : upToAmount;
         uint256 forceSalePrice = expiredPurchasePrice(pos);
@@ -459,11 +538,31 @@ contract MintingHub is IMintingHub, ERC165 {
             revert LeaveNoDust(max - amount);
         }
 
-        pos.forceSale(msg.sender, amount, costs);
+        address collateralAddr = address(pos.collateral());
+        if (receiveAsNative && collateralAddr == WCBTC) {
+            // Pull JUSD from user to Hub, then approve Position to spend it
+            JUSD.transferFrom(msg.sender, address(this), costs);
+            IERC20(address(JUSD)).approve(address(pos), costs);
+            // Route through hub to unwrap
+            pos.forceSale(address(this), amount, costs);
+            IWrappedNative(WCBTC).withdraw(amount);
+            (bool success, ) = msg.sender.call{value: amount}("");
+            if (!success) revert NativeTransferFailed();
+        } else {
+            pos.forceSale(msg.sender, amount, costs);
+        }
+
         emit ForcedSale(address(pos), amount, forceSalePrice);
         return amount;
     }
 
+    /**
+     * Buys up to the desired amount of the collateral asset from the given expired position (backward compatible).
+     */
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external returns (uint256) {
+        return buyExpiredCollateral(pos, upToAmount, false);
+    }
+
     /**
      * @dev See {IERC165-supportsInterface}.
      */
@@ -472,4 +571,9 @@ contract MintingHub is IMintingHub, ERC165 {
             interfaceId == type(IMintingHub).interfaceId ||
             super.supportsInterface(interfaceId);
     }
+
+    /**
+     * @notice Required to receive native coin when unwrapping WcBTC.
+     */
+    receive() external payable {}
 }

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,24 +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,
-                    0, // inherit price from parent
-                    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, 0)
-            );
+            return
+                IPosition(
+                    IMintingHub(target.hub()).clone(msg.sender, address(target), collDeposit, mint, expiration, 0)
+                );
         }
     }
 
@@ -157,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,17 +10,25 @@ interface IMintingHub {
 
     function ROLLER() external view returns (PositionRoller);
 
+    function WCBTC() external view returns (address);
+
     function challenge(
         address _positionAddr,
         uint256 _collateralAmount,
         uint256 minimumPrice
-    ) external returns (uint256);
+    ) external payable returns (uint256);
 
     function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn) external;
 
+    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn, bool returnCollateralAsNative) external;
+
     function returnPostponedCollateral(address collateral, address target) external;
 
+    function returnPostponedCollateral(address collateral, address target, bool asNative) external;
+
     function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external returns (uint256);
 
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount, bool receiveAsNative) external returns (uint256);
+
     function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, uint256 _liqPrice) external payable returns (address);
 }

package/contracts/gateway/MintingHubGateway.sol

@@ -11,7 +11,7 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
     constructor(
         address _jusd,
         address _leadrate,
-        address _roller,
+        address payable _roller,
         address _factory,
         address _gateway,
         address _wcbtc

package/contracts/test/PositionExpirationTest.sol

@@ -14,7 +14,7 @@ contract PositionExpirationTest {
     IJuiceDollar public jusd;
     bytes32 public frontendCode;
 
-    constructor(address hub_) {
+    constructor(address payable hub_) {
         hub = MintingHubGateway(hub_);
         col = new TestToken("Some Collateral", "COL", uint8(0));
         jusd = hub.JUSD();

package/contracts/test/PositionRollingTest.sol

@@ -20,7 +20,7 @@ contract PositionRollingTest {
     IPosition public p1;
     IPosition public p2;
 
-    constructor(address hub_) {
+    constructor(address payable hub_) {
         hub = MintingHub(hub_);
         col = new TestToken("Some Collateral", "COL", uint8(0));
         jusd = hub.JUSD();