@juicedollar/jusd 1.0.1 → 1.0.3

package/README.md

@@ -139,9 +139,8 @@ yarn install
 Create a `.env` file (see `.env.example`):
 
 ```bash
-# Required: Use EITHER private key OR seed phrase
+# Required: Deployer wallet private key
 DEPLOYER_PRIVATE_KEY=your_private_key_here
-# DEPLOYER_ACCOUNT_SEED="twelve word seed phrase goes here"
 
 # Optional: For contract verification on Citrea explorer
 # CITREA_EXPLORER_API_KEY=your_api_key_here

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
@@ -134,9 +139,10 @@ contract MintingHub is IMintingHub, ERC165 {
                 bytes memory /*lowLevelData*/
             ) {}
             if (_initialCollateral < _minCollateral) revert InsufficientCollateral();
-            // must start with at least 5000 JUSD worth of collateral
-            if (_minCollateral * _liqPrice < 5000 ether * 10 ** 18) revert InsufficientCollateral();
+            // 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";
@@ -140,6 +141,9 @@ contract Position is Ownable, IPosition, MathUtil {
     error InvalidExpiration();
     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);
@@ -204,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;
@@ -218,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);
     }
 
@@ -267,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();
         }
     }
 
@@ -311,8 +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 {
+    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 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, 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);
@@ -323,14 +365,18 @@ 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) {
             _mint(msg.sender, newPrincipal - principal, newCollateral);
         }
         if (newPrice != price) {
-            _adjustPrice(newPrice);
+            _adjustPrice(newPrice, referencePosition);
         }
         emit MintingUpdate(newCollateral, newPrice, newPrincipal);
     }
@@ -339,21 +385,98 @@ 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);
+        _adjustPrice(newPrice, address(0));
+        emit MintingUpdate(_collateralBalance(), price, principal);
+    }
+
+    /**
+     * @notice Adjusts the liquidation price without cooldown if a valid reference position is provided.
+     * @dev The reference position must be active (not in cooldown, not expired, not challenged, not closed),
+     *      have the same collateral, and have a price >= newPrice.
+     *      Note: For price decreases (newPrice <= current price), the reference position is ignored
+     *      and only the collateral check is performed, as price decreases don't require cooldown protection.
+     * @param newPrice The new liquidation price
+     * @param referencePosition An active position with the same collateral and at least this price (only used for price increases)
+     */
+    function adjustPriceWithReference(uint256 newPrice, address referencePosition) external onlyOwner {
+        _adjustPrice(newPrice, referencePosition);
         emit MintingUpdate(_collateralBalance(), price, principal);
     }
 
-    function _adjustPrice(uint256 newPrice) internal noChallenge alive backed noCooldown {
+    /**
+     * @dev Unified internal price adjustment logic.
+     * @param newPrice The new liquidation price
+     * @param referencePosition For price increases: address(0) triggers 3-day cooldown,
+     *                          valid reference allows cooldown-free adjustment.
+     *                          For price decreases: ignored (only collateral check performed).
+     *                          Price decreases are allowed even during cooldown since they make the position safer.
+     */
+    function _adjustPrice(uint256 newPrice, address referencePosition) internal noChallenge alive backed {
         if (newPrice > price) {
-            _restrictMinting(3 days);
+            if (block.timestamp <= cooldown) revert Hot();
+            if (referencePosition == address(0)) {
+                _restrictMinting(3 days);
+            } else if (!_isValidPriceReference(referencePosition, newPrice)) {
+                revert InvalidPriceReference();
+            }
         } else {
             _checkCollateral(_collateralBalance(), newPrice);
         }
         _setPrice(newPrice, principal + availableForMinting());
     }
 
+    /**
+     * @notice Checks if a reference position is valid for a cooldown-free price increase.
+     * @param referencePosition The address of the reference position to validate
+     * @param newPrice The new price that should be validated against the reference
+     * @return True if the reference position is valid, false otherwise
+     */
+    function _isValidPriceReference(address referencePosition, uint256 newPrice) internal view returns (bool) {
+        // 1. Reference must be registered in the same hub
+        if (jusd.getPositionParent(referencePosition) != hub) return false;
+
+        IPosition ref = IPosition(referencePosition);
+
+        // 2. Reference must not be this position itself
+        if (referencePosition == address(this)) return false;
+
+        // 3. Same collateral
+        if (address(ref.collateral()) != address(collateral)) return false;
+
+        // 4. Reference must be active (not in cooldown)
+        if (block.timestamp <= ref.cooldown()) return false;
+
+        // 5. Reference must not be expired
+        if (block.timestamp >= ref.expiration()) return false;
+
+        // 6. Reference must not be challenged
+        if (ref.challengedAmount() > 0) return false;
+
+        // 7. Reference must not be closed
+        if (ref.isClosed()) return false;
+
+        // 8. New price must be <= reference price
+        if (newPrice > ref.price()) return false;
+
+        // 9. Reference must have principal > 0 (actively used)
+        if (ref.principal() == 0) return false;
+
+        return true;
+    }
+
+    /**
+     * @notice Checks if a reference position is valid for a cooldown-free price increase.
+     * @param referencePosition The address of the reference position to validate
+     * @param newPrice The new price that should be validated against the reference
+     * @return True if the reference position is valid, false otherwise
+     */
+    function isValidPriceReference(address referencePosition, uint256 newPrice) external view returns (bool) {
+        return _isValidPriceReference(referencePosition, newPrice);
+    }
+
     function _setPrice(uint256 newPrice, uint256 bounds) internal {
         uint256 colBalance = _collateralBalance();
         if (block.timestamp >= start && newPrice > 2 * price) {
@@ -493,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;
@@ -547,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;
     }
 
@@ -617,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.
      */
@@ -807,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,10 +56,18 @@ 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 adjustWithReference(uint256 newMinted, uint256 newCollateral, uint256 newPrice, address referencePosition, bool withdrawAsNative) external payable;
+
+    function isValidPriceReference(address referencePosition, uint256 newPrice) external view returns (bool);
+
+    function isClosed() external view returns (bool);
+
     function mint(address target, uint256 amount) external;
 
     function getDebt() external view returns (uint256);
@@ -72,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/StartUSD.sol

@@ -6,11 +6,11 @@ import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 /**
  * @title StartUSD
  * @notice A minimal genesis stablecoin used to bootstrap the JuiceDollar protocol.
- * @dev Mints 10,000 SUSD to the deployer. Used to initialize the protocol with initial
+ * @dev Mints 100,000,000 SUSD to the deployer. Used to initialize the protocol with initial
  * JUSD supply through a StablecoinBridge, which then creates the initial JUICE tokens.
  */
 contract StartUSD is ERC20 {
     constructor() ERC20("StartUSD", "SUSD") {
-        _mint(msg.sender, 10_000 * 10 ** 18);
+        _mint(msg.sender, 100_000_000 * 10 ** 18);
     }
 }

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;
+}