@juicedollar/jusd 1.0.2 → 1.0.3

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
 
@@ -75,17 +77,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 _roller, address _factory, address _wcbtc) {
         JUSD = IJuiceDollar(_jusd);
         RATE = ILeadrate(_leadrate);
         POSITION_FACTORY = IPositionFactory(_factory);
         ROLLER = PositionRoller(_roller);
+        WCBTC = _wcbtc;
     }
 
     /**
@@ -118,15 +123,15 @@ 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();
+            if (_initPeriodSeconds < 3 days) revert InitPeriodTooShort();
             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 +142,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 +160,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);
     }
 

package/contracts/MintingHubV2/PositionRoller.sol

@@ -137,12 +137,13 @@ contract PositionRoller {
                     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)
+                IMintingHub(target.hub()).clone(msg.sender, address(target), collDeposit, mint, expiration, 0)
             );
         }
     }

package/contracts/MintingHubV2/interface/IMintingHub.sol

@@ -22,5 +22,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

@@ -13,8 +13,9 @@ contract MintingHubGateway is MintingHub, IMintingHubGateway {
         address _leadrate,
         address _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");
+    }
+}