@juicedollar/jusd 3.0.1 → 4.0.1

package/contracts/Leadrate.sol

@@ -56,7 +56,7 @@ contract Leadrate {
         if (currentRatePPM == nextRatePPM) revert NoPendingChange();
         uint40 timeNow = uint40(block.timestamp);
         if (timeNow < nextChange) revert ChangeNotReady();
-        ticksAnchor += (timeNow - anchorTime) * currentRatePPM;
+        ticksAnchor += uint64(timeNow - anchorTime) * currentRatePPM;
         anchorTime = timeNow;
         currentRatePPM = nextRatePPM;
         emit RateChanged(currentRatePPM);

package/contracts/{MintingHubV2 → MintingHubV3}/MintingHub.sol

@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: MIT
 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 {IReserve} from "../interface/IReserve.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ILeadrate} from "../interface/ILeadrate.sol";
+import {Leadrate} from "../Leadrate.sol";
 import {IMintingHub} from "./interface/IMintingHub.sol";
 import {IPositionFactory} from "./interface/IPositionFactory.sol";
 import {IPosition} from "./interface/IPosition.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
 import {PositionRoller} from "./PositionRoller.sol";
 
 /**
@@ -18,8 +20,12 @@ import {PositionRoller} from "./PositionRoller.sol";
  * @notice The central hub for creating, cloning, and challenging collateralized JuiceDollar positions.
  * @dev Only one instance of this contract is required, whereas every new position comes with a new position
  * contract. Pending challenges are stored as structs in an array.
+ *
+ * Unsupported collateral token types (enforced via governance):
+ * - Fee-on-transfer tokens: break collateral accounting (actual balance < recorded amount)
+ * - Rebasing tokens: break challenge accounting (challengedAmount becomes stale after rebase)
  */
-contract MintingHub is IMintingHub, ERC165 {
+contract MintingHub is IMintingHub, ERC165, Leadrate {
     /**
      * @notice Irrevocable fee in JUSD when proposing a new position (but not when cloning an existing one).
      */
@@ -32,20 +38,11 @@ contract MintingHub is IMintingHub, ERC165 {
     uint256 public constant CHALLENGER_REWARD = 20000; // 2%
     uint256 public constant EXPIRED_PRICE_FACTOR = 10;
 
-    /**
-     * @dev Maximum allowed message length for denial messages (prevents gas griefing attacks).
-     *      This constant is intentionally duplicated in Position.sol for defense-in-depth.
-     *      Hub validates as a second layer of protection; Position validates first to fail early.
-     *      If changing this value, update Position.MAX_MESSAGE_LENGTH as well.
-     */
-    uint256 private constant MAX_MESSAGE_LENGTH = 500;
-
     IPositionFactory private immutable POSITION_FACTORY; // position contract to clone
 
     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
+    PositionRoller public immutable ROLLER; // helper to roll positions
 
     Challenge[] public challenges; // list of open challenges
 
@@ -55,12 +52,6 @@ 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 14-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
@@ -95,24 +86,43 @@ contract MintingHub is IMintingHub, ERC165 {
     error NativeOnlyForWCBTC();
     error ValueMismatch();
     error NativeTransferFailed();
-    error MessageTooLong(uint256 length, uint256 maxLength);
-    error EmptyMessage();
 
     modifier validPos(address position) {
         if (JUSD.getPositionParent(position) != address(this)) revert InvalidPos();
         _;
     }
 
-    constructor(address _jusd, address _leadrate, address payable _roller, address _factory, address _wcbtc) {
+    constructor(
+        address _jusd,
+        uint24 _initialRatePPM,
+        address payable _roller,
+        address _factory,
+        address _wcbtc
+    ) Leadrate(IReserve(IJuiceDollar(_jusd).reserve()), _initialRatePPM) {
         JUSD = IJuiceDollar(_jusd);
-        RATE = ILeadrate(_leadrate);
         POSITION_FACTORY = IPositionFactory(_factory);
-        ROLLER = PositionRoller(_roller);
         WCBTC = _wcbtc;
+        ROLLER = PositionRoller(_roller);
+    }
+
+    /**
+     * @notice Backward-compatible view returning this contract as the ILeadrate implementation.
+     */
+    function RATE() public view returns (ILeadrate) {
+        return ILeadrate(address(this));
+    }
+
+    // Events for centralized position monitoring
+    function emitPositionUpdate(uint256 _collateral, uint256 _price, uint256 _principal) external validPos(msg.sender) {
+        emit PositionUpdate(msg.sender, _collateral, _price, _principal);
+    }
+
+    function emitPositionDenied(address denier, string calldata message) external validPos(msg.sender) {
+        emit PositionDeniedByGovernance(msg.sender, denier, message);
     }
 
     /**
-     * @notice Open a collateralized loan position. See also https://docs.JUSD.com/positions/open .
+     * @notice Open a collateralized loan position.
      * @dev For a successful call, you must set an allowance for the collateral token, allowing
      * the minting hub to transfer the initial collateral amount to the newly created position and to
      * withdraw the fees.
@@ -147,12 +157,7 @@ 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();
-            // First position (genesis) can skip init period, all others require 14 days minimum
-            if (_genesisPositionCreated) {
-                if (_initPeriodSeconds < 14 days) revert InitPeriodTooShort();
-            } else {
-                _genesisPositionCreated = true;
-            }
+            if (_initPeriodSeconds < 14 days) revert InitPeriodTooShort();
             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)
@@ -298,11 +303,27 @@ contract MintingHub is IMintingHub, ERC165 {
      *                                  challenger refund and bidder acquisition are returned as native.
      */
     function bid(
-        uint32 _challengeNumber,
+        uint256 _challengeNumber,
         uint256 size,
         bool postponeCollateralReturn,
         bool returnCollateralAsNative
-    ) public {
+    ) external {
+        _bid(_challengeNumber, size, postponeCollateralReturn, returnCollateralAsNative);
+    }
+
+    /**
+     * @notice Post a bid in JUSD given an open challenge (backward compatible version).
+     */
+    function bid(uint256 _challengeNumber, uint256 size, bool postponeCollateralReturn) external {
+        _bid(_challengeNumber, size, postponeCollateralReturn, false);
+    }
+
+    function _bid(
+        uint256 _challengeNumber,
+        uint256 size,
+        bool postponeCollateralReturn,
+        bool returnCollateralAsNative
+    ) internal {
         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
@@ -327,18 +348,14 @@ contract MintingHub is IMintingHub, ERC165 {
         }
     }
 
-    /**
-     * @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,
         bool asNative
     ) internal returns (uint256, uint256) {
+        // Read challenge price BEFORE state mutation
+        uint256 unitPrice = _challengeUnitPrice(_challenge);
+
         // 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
             .position
@@ -346,7 +363,7 @@ contract MintingHub is IMintingHub, ERC165 {
 
         // No overflow possible thanks to invariant (col * price <= limit * 10**18)
         // enforced in Position.setPrice and knowing that collateral <= col.
-        uint256 offer = _calculateOffer(_challenge, collateral);
+        uint256 offer = (unitPrice * collateral) / 10 ** 18;
 
         JUSD.transferFrom(msg.sender, address(this), offer); // get money from bidder
         uint256 reward = (offer * CHALLENGER_REWARD) / 1_000_000;
@@ -369,7 +386,7 @@ contract MintingHub is IMintingHub, ERC165 {
         } else if (fundsAvailable < repayment + interest) {
             JUSD.coverLoss(address(this), repayment + interest - fundsAvailable); // ensure we have enough to pay everything
         }
-        JUSD.burnWithoutReserve(repayment, reservePPM); // Repay the challenged part, example: 50 deur leading to 10 deur in implicit profits
+        JUSD.burnWithoutReserve(repayment, reservePPM); // Repay the challenged part, example: 50 JUSD leading to 10 JUSD in implicit profits
         JUSD.collectProfits(address(this), interest); // Collect interest as profits
 
         // Transfer collateral to bidder (handles native coin if requested)
@@ -387,7 +404,7 @@ contract MintingHub is IMintingHub, ERC165 {
 
     function _avertChallenge(
         Challenge memory _challenge,
-        uint32 number,
+        uint256 number,
         uint256 liqPrice,
         uint256 size,
         bool asNative
@@ -423,7 +440,7 @@ contract MintingHub is IMintingHub, ERC165 {
      */
     function _returnChallengerCollateral(
         Challenge memory _challenge,
-        uint32 number,
+        uint256 number,
         uint256 amount,
         bool postpone,
         bool asNative
@@ -455,12 +472,12 @@ contract MintingHub is IMintingHub, ERC165 {
     }
 
     /**
-     * @notice Calculates the offer amount for the given challenge.
-     * @dev The offer is calculated as the current price times the collateral amount.
+     * @notice Returns the current unit price for the given challenge's Dutch auction.
+     * @dev Must be called before notifyChallengeSucceeded() which mutates challengedAmount/principal.
      */
-    function _calculateOffer(Challenge memory _challenge, uint256 collateral) internal view returns (uint256) {
+    function _challengeUnitPrice(Challenge memory _challenge) internal view returns (uint256) {
         (uint256 liqPrice, uint40 phase) = _challenge.position.challengeData();
-        return (_calculatePrice(_challenge.start + phase, phase, liqPrice) * collateral) / 10 ** 18;
+        return _calculatePrice(_challenge.start + phase, phase, liqPrice);
     }
 
     /**
@@ -468,7 +485,7 @@ contract MintingHub is IMintingHub, ERC165 {
      * @dev The price comes with (36 - collateral.decimals()) digits, so multiplying it with the raw collateral amount
      * always yields a price with 36 digits, or 18 digits after dividing by 10**18 again.
      */
-    function price(uint32 challengeNumber) public view returns (uint256) {
+    function price(uint256 challengeNumber) public view returns (uint256) {
         Challenge memory _challenge = challenges[challengeNumber];
         if (_challenge.challenger == address(0x0)) {
             return 0;
@@ -484,7 +501,18 @@ contract MintingHub is IMintingHub, ERC165 {
      * @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, bool asNative) public {
+    function returnPostponedCollateral(address collateral, address target, bool asNative) external {
+        _returnPostponedCollateral(collateral, target, asNative);
+    }
+
+    /**
+     * @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 _returnPostponedCollateral(address collateral, address target, bool asNative) internal {
         uint256 amount = pendingReturns[collateral][msg.sender];
         delete pendingReturns[collateral][msg.sender];
         if (asNative && collateral == WCBTC) {
@@ -496,13 +524,6 @@ contract MintingHub is IMintingHub, ERC165 {
         }
     }
 
-    /**
-     * @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,
@@ -565,8 +586,20 @@ contract MintingHub is IMintingHub, ERC165 {
      * @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, bool receiveAsNative) public validPos(address(pos)) returns (uint256) {
-        uint256 max = pos.collateral().balanceOf(address(pos));
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount, bool receiveAsNative) external validPos(address(pos)) returns (uint256) {
+        return _buyExpiredCollateral(pos, upToAmount, receiveAsNative);
+    }
+
+    /**
+     * Buys up to the desired amount of the collateral asset from the given expired position (backward compatible).
+     */
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external validPos(address(pos)) returns (uint256) {
+        return _buyExpiredCollateral(pos, upToAmount, false);
+    }
+
+    function _buyExpiredCollateral(IPosition pos, uint256 upToAmount, bool receiveAsNative) internal returns (uint256) {
+        address collateralAddr = address(pos.collateral());
+        uint256 max = IERC20(collateralAddr).balanceOf(address(pos));
         uint256 amount = upToAmount > max ? max : upToAmount;
         uint256 forceSalePrice = expiredPurchasePrice(pos);
 
@@ -575,12 +608,10 @@ contract MintingHub is IMintingHub, ERC165 {
         if (max - amount > 0 && ((forceSalePrice * (max - amount)) / 10 ** 18) < OPENING_FEE) {
             revert LeaveNoDust(max - amount);
         }
-
-        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);
+            JUSD.approve(address(pos), costs);
             // Route through hub to unwrap
             pos.forceSale(address(this), amount, costs);
             IWrappedNative(WCBTC).withdraw(amount);
@@ -594,48 +625,10 @@ contract MintingHub is IMintingHub, ERC165 {
         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}.
-     */
-    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+    function supportsInterface(bytes4 interfaceId) public view override virtual returns (bool) {
         return interfaceId == type(IMintingHub).interfaceId || super.supportsInterface(interfaceId);
     }
 
-    /**
-     * @notice Allows Position contracts to emit state updates through the hub for centralized monitoring.
-     * @dev Only callable by registered positions. Emits PositionUpdate event with the caller as position.
-     * @param _collateral Current collateral balance of the position
-     * @param _price Current liquidation price of the position
-     * @param _principal Current principal (debt) of the position
-     */
-    function emitPositionUpdate(
-        uint256 _collateral,
-        uint256 _price,
-        uint256 _principal
-    ) external virtual validPos(msg.sender) {
-        emit PositionUpdate(msg.sender, _collateral, _price, _principal);
-    }
-
-    /**
-     * @notice Allows Position contracts to emit governance denial events through the hub.
-     * @dev Only callable by registered positions. Emits PositionDeniedByGovernance event.
-     * @param denier Address of the governance participant who denied the position
-     * @param message Reason for denial (max 500 bytes to prevent gas exhaustion attacks)
-     */
-    function emitPositionDenied(address denier, string calldata message) external virtual validPos(msg.sender) {
-        uint256 messageLength = bytes(message).length;
-        if (messageLength == 0) revert EmptyMessage();
-        if (messageLength > MAX_MESSAGE_LENGTH) revert MessageTooLong(messageLength, MAX_MESSAGE_LENGTH);
-        emit PositionDeniedByGovernance(msg.sender, denier, message);
-    }
-
     /**
      * @notice Required to receive native coin when unwrapping WcBTC.
      */

package/contracts/{MintingHubV2 → MintingHubV3}/Position.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 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";
@@ -10,7 +9,6 @@ import {IMintingHub} from "./interface/IMintingHub.sol";
 import {IPosition} from "./interface/IPosition.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /**
  * @title Position
@@ -80,7 +78,7 @@ contract Position is Ownable, IPosition, MathUtil {
     /**
      * @notice The original position to help identify clones.
      */
-    address public immutable original;
+    address payable public immutable original;
 
     /**
      * @notice Pointer to the minting hub.
@@ -150,7 +148,7 @@ contract Position is Ownable, IPosition, MathUtil {
      * @param sender The address that triggered the denial
      * @param message Reason for denial (1-500 bytes, prevents gas griefing and ensures meaningful messages)
      */
-    function _emitDenied(address sender, string memory message) internal {
+    function _emitDenied(address sender, string calldata message) internal {
         uint256 messageLength = bytes(message).length;
         if (messageLength == 0) revert EmptyMessage();
         if (messageLength > MAX_MESSAGE_LENGTH) revert MessageTooLong(messageLength, MAX_MESSAGE_LENGTH);
@@ -177,6 +175,7 @@ contract Position is Ownable, IPosition, MathUtil {
     error PriceTooHigh(uint256 newPrice, uint256 maxPrice);
     error InvalidPriceReference();
     error NativeTransferFailed();
+    error NativeOnlyForWCBTC();
     error CannotRescueCollateral();
 
     modifier alive() {
@@ -234,7 +233,7 @@ contract Position is Ownable, IPosition, MathUtil {
         uint256 _liqPrice,
         uint24 _reservePPM
     ) Ownable(_owner) {
-        original = address(this);
+        original = payable(address(this));
         hub = _hub;
         jusd = IJuiceDollar(_jusd);
         collateral = IERC20(_collateral);
@@ -256,7 +255,7 @@ 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(payable(original)).expiration())
+        if (_expiration < block.timestamp || _expiration > Position(original).expiration())
             revert InvalidExpiration(); // expiration must not be later than original
         expiration = _expiration;
         price = Position(payable(parent)).price();
@@ -306,7 +305,7 @@ contract Position is Ownable, IPosition, MathUtil {
         if (address(this) == original) {
             return limit - totalMinted;
         } else {
-            return Position(payable(original)).availableForClones();
+            return Position(original).availableForClones();
         }
     }
 
@@ -404,6 +403,7 @@ contract Position is Ownable, IPosition, MathUtil {
     ) internal {
         // Handle native coin deposit first (wraps to WCBTC)
         if (msg.value > 0) {
+            if (address(collateral) != IMintingHub(hub).WCBTC()) revert NativeOnlyForWCBTC();
             IWrappedNative(address(collateral)).deposit{value: msg.value}();
         }
 
@@ -516,6 +516,15 @@ contract Position is Ownable, IPosition, MathUtil {
         // 9. Reference must have principal > 0 (actively used)
         if (ref.principal() == 0) return false;
 
+        // 10. Reference principal >= 1000 JUSD (meaningful skin-in-the-game)
+        if (ref.principal() < 1000 * 10 ** 18) return false;
+
+        // 11. Reference has been out of cooldown for >= challengePeriod
+        if (ref.cooldown() + ref.challengePeriod() > block.timestamp) return false;
+
+        // 12. Reference has meaningful remaining life (can still be challenged)
+        if (ref.expiration() <= block.timestamp + ref.challengePeriod()) return false;
+
         return true;
     }
 
@@ -669,7 +678,7 @@ contract Position is Ownable, IPosition, MathUtil {
         _accrueInterest(); // accrue interest
         _fixRateToLeadrate(riskPremiumPPM); // sync interest rate with leadrate
 
-        Position(payable(original)).notifyMint(amount);
+        Position(original).notifyMint(amount);
         jusd.mintWithReserve(target, amount, reserveContribution);
 
         principal += amount;
@@ -723,18 +732,15 @@ contract Position is Ownable, IPosition, MathUtil {
      */
     function _notifyRepaid(uint256 amount) internal {
         if (amount > principal) revert RepaidTooMuch(amount - principal);
-        Position(payable(original)).notifyRepaid(amount);
+        Position(original).notifyRepaid(amount);
         principal -= amount;
     }
 
     /**
-     * @notice Updates outstanding interest and notifies the minting hub gateway that interest has been paid.
+     * @notice Updates outstanding interest tracking when interest is paid.
      */
     function _notifyInterestPaid(uint256 amount) internal {
         if (amount > interest) revert RepaidTooMuch(amount - interest);
-        if (IERC165(hub).supportsInterface(type(IMintingHubGateway).interfaceId)) {
-            IMintingHubGateway(hub).notifyInterestPaid(amount);
-        }
         interest -= amount;
     }
 
@@ -1026,6 +1032,7 @@ contract Position is Ownable, IPosition, MathUtil {
      */
     receive() external payable {
         if (msg.sender != address(collateral)) {
+            if (address(collateral) != IMintingHub(hub).WCBTC()) revert NativeOnlyForWCBTC();
             IWrappedNative(address(collateral)).deposit{value: msg.value}();
         }
     }

package/contracts/{MintingHubV2 → MintingHubV3}/PositionRoller.sol

@@ -2,12 +2,9 @@
 pragma solidity ^0.8.0;
 
 import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-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";
 
@@ -55,7 +52,6 @@ contract PositionRoller {
      * Like rollFully, but with a custom expiration date for the new position.
      */
     function rollFullyWithExpiration(IPosition source, IPosition target, uint40 expiration) public {
-        require(source.collateral() == target.collateral());
         (uint256 repay, uint256 collWithdraw, uint256 mint, uint256 collDeposit) = _calculateRollParams(
             source,
             target,
@@ -96,7 +92,7 @@ contract PositionRoller {
             if (needsClone) {
                 targetCollateral.transferFrom(msg.sender, address(this), collDeposit);
                 targetCollateral.approve(target.hub(), collDeposit);
-                target = _cloneTargetPosition(target, source, collDeposit, mint, expiration);
+                target = _cloneTargetPosition(target, collDeposit, mint, expiration);
             } else {
                 // We can roll into the provided existing position.
                 // We do not verify whether the target position was created by the known minting hub in order
@@ -131,7 +127,6 @@ contract PositionRoller {
      * 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,
@@ -166,21 +161,21 @@ contract PositionRoller {
         uint256 collDeposit,
         uint40 expiration
     ) public payable valid(source) valid(target) own(source) {
-        address collateral = address(source.collateral());
+        IERC20 collateralToken = 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}();
+            IWrappedNative(address(collateralToken)).deposit{value: msg.value}();
         }
 
         if (mint > 0) {
-            IERC20 targetCollateral = IERC20(collateral);
+            IERC20 targetCollateral = IERC20(target.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);
+                target = _cloneTargetPosition(target, collDeposit, mint, expiration);
             } else {
                 targetCollateral.transfer(address(target), collDeposit);
                 target.mint(msg.sender, mint);
@@ -194,9 +189,9 @@ contract PositionRoller {
         jusd.burnFrom(msg.sender, repay); // repay the flash loan
 
         // Return excess as native coin
-        uint256 remaining = IERC20(collateral).balanceOf(address(this));
+        uint256 remaining = collateralToken.balanceOf(address(this));
         if (remaining > 0) {
-            IWrappedNative(collateral).withdraw(remaining);
+            IWrappedNative(address(collateralToken)).withdraw(remaining);
             (bool success, ) = msg.sender.call{value: remaining}("");
             if (!success) revert NativeTransferFailed();
         }
@@ -213,6 +208,7 @@ contract PositionRoller {
         IPosition target,
         uint256 extraCollateral
     ) internal view returns (uint256 repay, uint256 collWithdraw, uint256 mint, uint256 collDeposit) {
+        require(source.collateral() == target.collateral());
         uint256 principal = source.principal();
         uint256 interest = source.getInterest();
         uint256 usableMint = source.getUsableMint(principal) + interest;
@@ -221,13 +217,14 @@ contract PositionRoller {
         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;
+            mintAmount = (depositAmount * targetPrice) / 10 ** 18;
         }
-
-        return (principal + interest, collateralAvailable, mintAmount, depositAmount);
+        repay = principal + interest;
+        collWithdraw = collateralAvailable;
+        mint = mintAmount;
+        collDeposit = depositAmount;
     }
 
     /**
@@ -235,31 +232,14 @@ contract PositionRoller {
      */
     function _cloneTargetPosition(
         IPosition target,
-        IPosition source,
         uint256 collDeposit,
         uint256 mint,
         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
-                    )
-                );
-        } 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)
+            );
     }
 
     modifier own(IPosition pos) {

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

@@ -28,10 +28,10 @@ interface IMintingHub {
         uint256 minimumPrice
     ) external payable returns (uint256);
 
-    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn) external;
+    function bid(uint256 _challengeNumber, uint256 size, bool postponeCollateralReturn) external;
 
     function bid(
-        uint32 _challengeNumber,
+        uint256 _challengeNumber,
         uint256 size,
         bool postponeCollateralReturn,
         bool returnCollateralAsNative