@juicedollar/jusd 1.0.4 → 1.0.6

package/contracts/MintingHubV2/MintingHub.sol

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

package/contracts/MintingHubV2/interface/IMintingHub.sol

@@ -16,13 +16,19 @@ interface IMintingHub {
         address _positionAddr,
         uint256 _collateralAmount,
         uint256 minimumPrice
-    ) external returns (uint256);
+    ) external payable returns (uint256);
 
     function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn) external;
 
+    function bid(uint32 _challengeNumber, uint256 size, bool postponeCollateralReturn, bool returnCollateralAsNative) external;
+
     function returnPostponedCollateral(address collateral, address target) external;
 
+    function returnPostponedCollateral(address collateral, address target, bool asNative) external;
+
     function buyExpiredCollateral(IPosition pos, uint256 upToAmount) external returns (uint256);
 
+    function buyExpiredCollateral(IPosition pos, uint256 upToAmount, bool receiveAsNative) external returns (uint256);
+
     function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, uint256 _liqPrice) external payable returns (address);
 }

package/contracts/test/PositionExpirationTest.sol

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

package/contracts/test/PositionRollingTest.sol

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

package/dist/index.d.mts

@@ -11,6 +11,7 @@ interface ChainAddress {
     startUSD: Address;
     roller: Address;
     positionFactoryV2: Address;
+    genesisPosition: Address;
 }
 declare const ADDRESS: Record<number, ChainAddress>;
 
@@ -2827,6 +2828,10 @@ declare const MintingHubGatewayABI: readonly [{
     readonly inputs: readonly [];
     readonly name: "NativeOnlyForWCBTC";
     readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NativeTransferFailed";
+    readonly type: "error";
 }, {
     readonly inputs: readonly [];
     readonly name: "UnexpectedPrice";
@@ -3073,6 +3078,46 @@ declare const MintingHubGatewayABI: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "_challengeNumber";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "size";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "postponeCollateralReturn";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "returnCollateralAsNative";
+        readonly type: "bool";
+    }];
+    readonly name: "bid";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IPosition";
+        readonly name: "pos";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "upToAmount";
+        readonly type: "uint256";
+    }];
+    readonly name: "buyExpiredCollateral";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "contract IPosition";
@@ -3082,6 +3127,10 @@ declare const MintingHubGatewayABI: readonly [{
         readonly internalType: "uint256";
         readonly name: "upToAmount";
         readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "receiveAsNative";
+        readonly type: "bool";
     }];
     readonly name: "buyExpiredCollateral";
     readonly outputs: readonly [{
@@ -3111,7 +3160,7 @@ declare const MintingHubGatewayABI: readonly [{
         readonly name: "";
         readonly type: "uint256";
     }];
-    readonly stateMutability: "nonpayable";
+    readonly stateMutability: "payable";
     readonly type: "function";
 }, {
     readonly inputs: readonly [{
@@ -3371,6 +3420,24 @@ declare const MintingHubGatewayABI: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "collateral";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "asNative";
+        readonly type: "bool";
+    }];
+    readonly name: "returnPostponedCollateral";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "address";
@@ -3399,6 +3466,9 @@ declare const MintingHubGatewayABI: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
 }];
 
 declare const SavingsGatewayABI: readonly [{
@@ -7734,6 +7804,10 @@ declare const MintingHubV2ABI: readonly [{
     readonly inputs: readonly [];
     readonly name: "NativeOnlyForWCBTC";
     readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NativeTransferFailed";
+    readonly type: "error";
 }, {
     readonly inputs: readonly [];
     readonly name: "UnexpectedPrice";
@@ -7970,6 +8044,46 @@ declare const MintingHubV2ABI: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "_challengeNumber";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "size";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "postponeCollateralReturn";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "returnCollateralAsNative";
+        readonly type: "bool";
+    }];
+    readonly name: "bid";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IPosition";
+        readonly name: "pos";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "upToAmount";
+        readonly type: "uint256";
+    }];
+    readonly name: "buyExpiredCollateral";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "contract IPosition";
@@ -7979,6 +8093,10 @@ declare const MintingHubV2ABI: readonly [{
         readonly internalType: "uint256";
         readonly name: "upToAmount";
         readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "receiveAsNative";
+        readonly type: "bool";
     }];
     readonly name: "buyExpiredCollateral";
     readonly outputs: readonly [{
@@ -8008,7 +8126,7 @@ declare const MintingHubV2ABI: readonly [{
         readonly name: "";
         readonly type: "uint256";
     }];
-    readonly stateMutability: "nonpayable";
+    readonly stateMutability: "payable";
     readonly type: "function";
 }, {
     readonly inputs: readonly [{
@@ -8166,6 +8284,24 @@ declare const MintingHubV2ABI: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "collateral";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "target";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "asNative";
+        readonly type: "bool";
+    }];
+    readonly name: "returnPostponedCollateral";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "address";
@@ -8194,6 +8330,9 @@ declare const MintingHubV2ABI: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
 }];
 
 declare const SavingsABI: readonly [{