@juicedollar/jusd 1.0.0

package/contracts/StablecoinBridge.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJuiceDollar} from "./interface/IJuiceDollar.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+/**
+ * @title Stablecoin Bridge
+ * @notice A minting contract for another USD stablecoin ('source stablecoin') that we trust.
+ */
+contract StablecoinBridge {
+    using SafeERC20 for IERC20;
+
+    IERC20 public immutable usd; // the source stablecoin
+    IJuiceDollar public immutable JUSD; // the JUSD
+    uint8 private immutable usdDecimals;
+    uint8 private immutable JUSDDecimals;
+
+    /**
+     * @notice The time horizon after which this bridge expires and needs to be replaced by a new contract.
+     */
+    uint256 public immutable horizon;
+
+    /**
+     * @notice The maximum amount of outstanding converted source stablecoins.
+     */
+    uint256 public immutable limit;
+    uint256 public minted;
+
+    error Limit(uint256 amount, uint256 limit);
+    error Expired(uint256 time, uint256 expiration);
+    error UnsupportedToken(address token);
+
+    constructor(address other, address JUSDAddress, uint256 limit_, uint256 weeks_) {
+        usd = IERC20(other);
+        JUSD = IJuiceDollar(JUSDAddress);
+        usdDecimals = IERC20Metadata(other).decimals();
+        JUSDDecimals = IERC20Metadata(JUSDAddress).decimals();
+        horizon = block.timestamp + weeks_ * 1 weeks;
+        limit = limit_;
+        minted = 0;
+    }
+
+    /**
+     * @notice Convenience method for mint(msg.sender, amount)
+     */
+    function mint(uint256 amount) external {
+        mintTo(msg.sender, amount);
+    }
+
+    /**
+     * @notice Mint the target amount of JUSD, taking the equal amount of source coins from the sender.
+     * @dev This only works if an allowance for the source coins has been set and the caller has enough of them.
+     * @param amount The amount of the source stablecoin to bridge (convert).
+     */
+    function mintTo(address target, uint256 amount) public {
+        usd.safeTransferFrom(msg.sender, address(this), amount);
+        
+        uint256 targetAmount = _convertAmount(amount, usdDecimals, JUSDDecimals);
+        _mint(target, targetAmount);
+    }
+
+    function _mint(address target, uint256 amount) internal {
+        if (block.timestamp > horizon) revert Expired(block.timestamp, horizon);
+        JUSD.mint(target, amount);
+        minted += amount;
+        if (minted > limit) revert Limit(amount, limit);
+    }
+
+    /**
+     * @notice Convenience method for burnAndSend(msg.sender, amount)
+     * @param amount The amount of JUSD to burn.
+     */
+    function burn(uint256 amount) external {
+        _burn(msg.sender, msg.sender, amount);
+    }
+
+    /**
+     * @notice Burn the indicated amount of JUSD and send the same number of source coins to the caller.
+     */
+    function burnAndSend(address target, uint256 amount) external {
+        _burn(msg.sender, target, amount);
+    }
+
+    function _burn(address JUSDHolder, address target, uint256 amount) internal {
+        uint256 sourceAmount = _convertAmount(amount, JUSDDecimals, usdDecimals);
+        JUSD.burnFrom(JUSDHolder, amount);
+        usd.safeTransfer(target, sourceAmount);
+        minted -= amount;
+    }
+
+    /**
+     * @notice Converts an amount between two tokens with different decimal places.
+     * @param amount The amount to convert.
+     * @param fromDecimals The decimal places of the source token.
+     * @param toDecimals The decimal places of the target token.
+     */
+    function _convertAmount(uint256 amount, uint8 fromDecimals, uint8 toDecimals) internal pure returns (uint256) {
+        if (fromDecimals < toDecimals) {
+            return amount * 10**(toDecimals - fromDecimals);
+        } else if (fromDecimals > toDecimals) {
+            return amount / 10**(fromDecimals - toDecimals);
+        } else {
+            return amount;
+        }
+    }
+}

package/contracts/StartUSD.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+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
+ * 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);
+    }
+}

package/contracts/gateway/CoinLendingGateway.sol

@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {IMintingHubGateway} from "./interface/IMintingHubGateway.sol";
+import {ICoinLendingGateway} from "./interface/ICoinLendingGateway.sol";
+import {IPosition} from "../MintingHubV2/interface/IPosition.sol";
+import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
+
+interface IWrappedCBTC is IERC20 {
+    function deposit() external payable;
+    function withdraw(uint256 wad) external;
+}
+
+/**
+ * @title Coin Lending Gateway
+ * @notice An improved gateway that enables true single-transaction native coin lending with custom liquidation prices
+ * @dev This version handles the ownership transfer timing issue to allow price adjustments in the same transaction
+ */
+contract CoinLendingGateway is ICoinLendingGateway, Ownable, ReentrancyGuard, Pausable {
+    IMintingHubGateway public immutable MINTING_HUB;
+    IWrappedCBTC public immutable WCBTC;
+    IJuiceDollar public immutable JUSD;
+
+    error InsufficientCoin();
+    error InvalidPosition();
+    error TransferFailed();
+    error PriceAdjustmentFailed();
+    error DirectCBTCNotAccepted();
+
+    event CoinRescued(address indexed to, uint256 amount);
+    event TokenRescued(address indexed token, address indexed to, uint256 amount);
+
+    /**
+     * @notice Initializes the Coin Lending Gateway
+     * @param _mintingHub The address of the MintingHubGateway contract
+     * @param _wcbtc The address of the Wrapped cBTC (WcBTC) token contract
+     * @param _jusd The address of the JuiceDollar contract
+     */
+    constructor(address _mintingHub, address _wcbtc, address _jusd) Ownable(_msgSender()) {
+        MINTING_HUB = IMintingHubGateway(_mintingHub);
+        WCBTC = IWrappedCBTC(_wcbtc);
+        JUSD = IJuiceDollar(_jusd);
+    }
+
+    /**
+     * @notice Creates a lending position using native cBTC in a single transaction
+     * @dev This improved version uses a two-step clone process to handle ownership and price adjustment correctly
+     * @param parent The parent position to clone from
+     * @param initialMint The amount of JUSD to mint
+     * @param expiration The expiration timestamp for the position
+     * @param frontendCode The frontend referral code
+     * @param liquidationPrice The desired liquidation price (0 to skip adjustment)
+     * @return position The address of the newly created position
+     */
+    function lendWithCoin(
+        address parent,
+        uint256 initialMint,
+        uint40 expiration,
+        bytes32 frontendCode,
+        uint256 liquidationPrice
+    ) external payable nonReentrant whenNotPaused returns (address position) {
+        if (msg.value == 0) revert InsufficientCoin();
+
+        return _lendWithCoin(
+            _msgSender(),
+            parent,
+            initialMint,
+            expiration,
+            frontendCode,
+            liquidationPrice
+        );
+    }
+
+    /**
+     * @notice Creates a lending position for another owner using native cBTC
+     * @dev Same as lendWithCoin but allows specifying a different owner
+     * @param owner The address that will own the position
+     * @param parent The parent position to clone from
+     * @param initialMint The amount of JUSD to mint
+     * @param expiration The expiration timestamp for the position
+     * @param frontendCode The frontend referral code
+     * @param liquidationPrice The desired liquidation price (0 to skip adjustment)
+     * @return position The address of the newly created position
+     */
+    function lendWithCoinFor(
+        address owner,
+        address parent,
+        uint256 initialMint,
+        uint40 expiration,
+        bytes32 frontendCode,
+        uint256 liquidationPrice
+    ) external payable nonReentrant whenNotPaused returns (address position) {
+        if (msg.value == 0) revert InsufficientCoin();
+        if (owner == address(0)) revert InvalidPosition();
+
+        return _lendWithCoin(
+            owner,
+            parent,
+            initialMint,
+            expiration,
+            frontendCode,
+            liquidationPrice
+        );
+    }
+
+    /**
+     * @dev Internal function containing the core lending logic
+     * @param owner The address that will own the position
+     * @param parent The parent position to clone from
+     * @param initialMint The amount of JUSD to mint
+     * @param expiration The expiration timestamp for the position
+     * @param frontendCode The frontend referral code
+     * @param liquidationPrice The desired liquidation price (0 to skip adjustment)
+     * @return position The address of the newly created position
+     */
+    function _lendWithCoin(
+        address owner,
+        address parent,
+        uint256 initialMint,
+        uint40 expiration,
+        bytes32 frontendCode,
+        uint256 liquidationPrice
+    ) internal returns (address position) {
+        WCBTC.deposit{value: msg.value}();
+
+        WCBTC.approve(address(MINTING_HUB), msg.value);
+
+        // This contract must be initial owner to call adjustPrice before transferring ownership
+        position = MINTING_HUB.clone(
+            address(this),   // temporary owner (this contract)
+            parent,          // parent position
+            msg.value,       // collateral amount
+            initialMint,     // mint amount
+            expiration,
+            frontendCode
+        );
+
+        if (position == address(0)) revert InvalidPosition();
+
+        if (liquidationPrice > 0) {
+            uint256 currentPrice = IPosition(position).price();
+
+            if (liquidationPrice != currentPrice) {
+                try IPosition(position).adjustPrice(liquidationPrice) {
+                    // Price adjustment succeeded
+                } catch {
+                    revert PriceAdjustmentFailed();
+                }
+            }
+        }
+
+        uint256 jusdBalance = JUSD.balanceOf(address(this));
+        if (jusdBalance > 0) {
+            JUSD.transfer(owner, jusdBalance);
+        }
+
+        Ownable(position).transferOwnership(owner);
+
+        emit PositionCreatedWithCoin(
+            owner,
+            position,
+            msg.value,
+            initialMint,
+            liquidationPrice
+        );
+
+        return position;
+    }
+
+    /**
+     * @notice Rescue function to withdraw accidentally sent native cBTC
+     * @dev Only owner can call this function
+     */
+    function rescueCoin() external onlyOwner {
+        uint256 balance = address(this).balance;
+        if (balance > 0) {
+            (bool success, ) = owner().call{value: balance}("");
+            if (!success) revert TransferFailed();
+            emit CoinRescued(owner(), balance);
+        }
+    }
+
+    /**
+     * @notice Rescue function to withdraw accidentally sent tokens
+     * @dev Only owner can call this function
+     * @param token The address of the token to rescue
+     * @param to The address to send the tokens to
+     * @param amount The amount of tokens to rescue
+     */
+    function rescueToken(address token, address to, uint256 amount) external onlyOwner {
+        if (to == address(0)) revert TransferFailed();
+        bool success = IERC20(token).transfer(to, amount);
+        if (!success) revert TransferFailed();
+        emit TokenRescued(token, to, amount);
+    }
+
+    /**
+     * @notice Pause the contract (only owner)
+     * @dev Prevents lendWithCoin functions from being called
+     */
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    /**
+     * @notice Unpause the contract (only owner)
+     * @dev Re-enables lendWithCoin functions
+     */
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
+    /**
+     * @dev Reject direct cBTC transfers to prevent stuck funds
+     */
+    receive() external payable {
+        revert DirectCBTCNotAccepted();
+    }
+}

package/contracts/gateway/FrontendGateway.sol

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {Equity} from "../Equity.sol";
+import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
+import {SavingsGateway} from "./SavingsGateway.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Context} from "@openzeppelin/contracts/utils/Context.sol";
+import {IFrontendGateway} from "./interface/IFrontendGateway.sol";
+import {IMintingHubGateway} from "./interface/IMintingHubGateway.sol";
+
+contract FrontendGateway is IFrontendGateway, Context, Ownable {
+    IERC20 public immutable JUSD;
+    Equity public immutable EQUITY;
+
+    // solhint-disable-next-line var-name-mixedcase
+    IMintingHubGateway public MINTING_HUB;
+
+    // solhint-disable-next-line var-name-mixedcase
+    SavingsGateway public SAVINGS;
+
+    uint24 public feeRate; // Fee rate in PPM (parts per million), for example 10'000 = 1%
+    uint24 public savingsFeeRate; // Fee rate of savings in PPM (parts per million), for example 10 = 1%
+    uint24 public mintingFeeRate; // Reward rate of newly minted positions in PPM (parts per million), for example 10 = 1%
+    uint24 public nextFeeRate;
+    uint24 public nextSavingsFeeRate;
+    uint24 public nextMintingFeeRate;
+    uint256 public changeTimeLock;
+
+    mapping(bytes32 => FrontendCode) public frontendCodes;
+    mapping(address => bytes32) public referredPositions;
+    mapping(address => bytes32) public lastUsedFrontendCode;
+
+    modifier frontendCodeOwnerOnly(bytes32 frontendCode) {
+        if (frontendCodes[frontendCode].owner != _msgSender()) revert NotFrontendCodeOwner();
+        _;
+    }
+
+    modifier onlyGatewayService(address service) {
+        if (_msgSender() != address(service)) revert NotGatewayService();
+        _;
+    }
+
+    constructor(address jusd_) Ownable(_msgSender()) {
+        JUSD = IERC20(jusd_);
+        EQUITY = Equity(address(IJuiceDollar(jusd_).reserve()));
+        feeRate = 10_000; // 10_000/1_000_000 = 1% fee
+        savingsFeeRate = 50_000; // 50_000/1_000_000 = 5% fee of the of the savings interest
+        mintingFeeRate = 50_000; // 50_000/1_000_000 = 5% fee of the of the interest paid by the position owner
+    }
+
+    /**
+     * @notice Call this a wrapper method to obtain newly minted pool shares in exchange for
+     * JuiceDollars and reward frontend providers with a small commission.
+     * No allowance required (i.e., it is hard-coded in the JuiceDollar token contract).
+     * Make sure to invest at least 10e-12 * market cap to avoid rounding losses.
+     *
+     * @dev If equity is close to zero or negative, you need to send enough JUSD to bring equity back to 1_000 JUSD.
+     *
+     * @param amount            JuiceDollars to invest
+     * @param expectedShares    Minimum amount of expected shares for front running protection
+     * @param frontendCode      Code of the used frontend or referrer
+     */
+    function invest(uint256 amount, uint256 expectedShares, bytes32 frontendCode) external returns (uint256) {
+        uint256 actualShares = EQUITY.investFor(_msgSender(), amount, expectedShares);
+
+        uint256 reward = updateFrontendAccount(frontendCode, amount);
+        emit InvestRewardAdded(frontendCode, _msgSender(), amount, reward);
+        return actualShares;
+    }
+
+    function redeem(
+        address target,
+        uint256 shares,
+        uint256 expectedProceeds,
+        bytes32 frontendCode
+    ) external returns (uint256) {
+        uint256 actualProceeds = EQUITY.redeemFrom(_msgSender(), target, shares, expectedProceeds);
+
+        uint256 reward = updateFrontendAccount(frontendCode, actualProceeds);
+        emit RedeemRewardAdded(frontendCode, _msgSender(), actualProceeds, reward);
+        return actualProceeds;
+    }
+
+    ///////////////////
+    // Accounting Logic
+    ///////////////////
+
+    function updateFrontendAccount(bytes32 frontendCode, uint256 amount) internal returns (uint256) {
+        if (frontendCode == bytes32(0)) return 0;
+        lastUsedFrontendCode[_msgSender()] = frontendCode;
+        uint256 reward = (amount * feeRate) / 1_000_000;
+        frontendCodes[frontendCode].balance += reward;
+        return reward;
+    }
+
+    function updateSavingCode(
+        address savingsOwner,
+        bytes32 frontendCode
+    ) external onlyGatewayService(address(SAVINGS)) {
+        if (frontendCode == bytes32(0)) return;
+        lastUsedFrontendCode[savingsOwner] = frontendCode;
+    }
+
+    function updateSavingRewards(address saver, uint256 interest) external onlyGatewayService(address(SAVINGS)) {
+        bytes32 frontendCode = lastUsedFrontendCode[saver];
+        if (frontendCode == bytes32(0)) return;
+
+        uint256 reward = (interest * savingsFeeRate) / 1_000_000;
+        frontendCodes[frontendCode].balance += reward;
+
+        emit SavingsRewardAdded(frontendCode, saver, interest, reward);
+    }
+
+    function registerPosition(
+        address position,
+        bytes32 frontendCode
+    ) external onlyGatewayService(address(MINTING_HUB)) {
+        if (frontendCode == bytes32(0)) return;
+
+        referredPositions[position] = frontendCode;
+        emit NewPositionRegistered(position, frontendCode);
+    }
+
+    function updatePositionRewards(address position, uint256 amount) external onlyGatewayService(address(MINTING_HUB)) {
+        bytes32 frontendCode = referredPositions[position];
+        if (frontendCode == bytes32(0)) return;
+        
+        uint256 reward = (amount * mintingFeeRate) / 1_000_000;
+        frontendCodes[frontendCode].balance += reward;
+
+        emit PositionRewardAdded(frontendCode, position, amount, reward);
+    }
+
+    function getPositionFrontendCode(address position) external view returns (bytes32) {
+        return referredPositions[position];
+    }
+
+    //////////////////////
+    // Frontend Code Logic
+    //////////////////////
+
+    function registerFrontendCode(bytes32 frontendCode) external returns (bool) {
+        if (frontendCodes[frontendCode].owner != address(0) || frontendCode == bytes32(0))
+            revert FrontendCodeAlreadyExists();
+        frontendCodes[frontendCode].owner = _msgSender();
+        emit FrontendCodeRegistered(_msgSender(), frontendCode);
+        return true;
+    }
+
+    function transferFrontendCode(
+        bytes32 frontendCode,
+        address to
+    ) external frontendCodeOwnerOnly(frontendCode) returns (bool) {
+        frontendCodes[frontendCode].owner = to;
+        emit FrontendCodeTransferred(_msgSender(), to, frontendCode);
+        return true;
+    }
+
+    function withdrawRewards(bytes32 frontendCode) external frontendCodeOwnerOnly(frontendCode) returns (uint256) {
+        return _withdrawRewardsTo(frontendCode, _msgSender());
+    }
+
+    function withdrawRewardsTo(
+        bytes32 frontendCode,
+        address to
+    ) external frontendCodeOwnerOnly(frontendCode) returns (uint256) {
+        return _withdrawRewardsTo(frontendCode, to);
+    }
+
+    function _withdrawRewardsTo(bytes32 frontendCode, address to) internal returns (uint256) {
+        uint256 amount = frontendCodes[frontendCode].balance;
+
+        if (IJuiceDollar(address(JUSD)).equity() < amount) revert EquityTooLow();
+
+        frontendCodes[frontendCode].balance = 0;
+        IJuiceDollar(address(JUSD)).distributeProfits(to, amount);
+        emit FrontendCodeRewardsWithdrawn(to, amount, frontendCode);
+        return amount;
+    }
+
+    /**
+     * @notice Proposes new referral rates that will available to be executed after seven days.
+     * To cancel a proposal, just overwrite it with a new one proposing the current rate.
+     */
+    function proposeChanges(
+        uint24 newFeeRatePPM_,
+        uint24 newSavingsFeeRatePPM_,
+        uint24 newMintingFeeRatePPM_,
+        address[] calldata helpers
+    ) external {
+        if (newFeeRatePPM_ > 20_000 || newSavingsFeeRatePPM_ > 1_000_000 || newMintingFeeRatePPM_ > 1_000_000)
+            revert ProposedChangesToHigh();
+        EQUITY.checkQualified(_msgSender(), helpers);
+        nextFeeRate = newFeeRatePPM_;
+        nextSavingsFeeRate = newSavingsFeeRatePPM_;
+        nextMintingFeeRate = newMintingFeeRatePPM_;
+        changeTimeLock = block.timestamp + 7 days;
+        emit RateChangesProposed(
+            _msgSender(),
+            newFeeRatePPM_,
+            newSavingsFeeRatePPM_,
+            newMintingFeeRatePPM_,
+            changeTimeLock
+        );
+    }
+
+    function executeChanges() external {
+        if (nextFeeRate == feeRate && nextSavingsFeeRate == savingsFeeRate && nextMintingFeeRate == mintingFeeRate)
+            revert NoOpenChanges();
+        if (block.timestamp < changeTimeLock) revert NotDoneWaiting(changeTimeLock);
+        feeRate = nextFeeRate;
+        savingsFeeRate = nextSavingsFeeRate;
+        mintingFeeRate = nextMintingFeeRate;
+        emit RateChangesExecuted(_msgSender(), feeRate, savingsFeeRate, mintingFeeRate);
+    }
+
+    function init(address savings, address mintingHub) external onlyOwner {
+        SAVINGS = SavingsGateway(savings);
+        MINTING_HUB = IMintingHubGateway(mintingHub);
+        renounceOwnership();
+    }
+}

package/contracts/gateway/MintingHubGateway.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {MintingHub} from "../MintingHubV2/MintingHub.sol";
+import {IFrontendGateway} from "./interface/IFrontendGateway.sol";
+import {IMintingHubGateway} from "./interface/IMintingHubGateway.sol";
+
+contract MintingHubGateway is MintingHub, IMintingHubGateway {
+    IFrontendGateway public immutable GATEWAY;
+
+    constructor(
+        address _jusd,
+        address _leadrate,
+        address _roller,
+        address _factory,
+        address _gateway
+    ) MintingHub(_jusd, _leadrate, _roller, _factory) {
+        GATEWAY = IFrontendGateway(_gateway);
+    }
+
+    function openPosition(
+        address _collateralAddress,
+        uint256 _minCollateral,
+        uint256 _initialCollateral,
+        uint256 _mintingMaximum,
+        uint40 _initPeriodSeconds,
+        uint40 _expirationSeconds,
+        uint40 _challengeSeconds,
+        uint24 _riskPremium,
+        uint256 _liqPrice,
+        uint24 _reservePPM,
+        bytes32 _frontendCode
+    ) public returns (address) {
+        address position = openPosition(
+            _collateralAddress,
+            _minCollateral,
+            _initialCollateral,
+            _mintingMaximum,
+            _initPeriodSeconds,
+            _expirationSeconds,
+            _challengeSeconds,
+            _riskPremium,
+            _liqPrice,
+            _reservePPM
+        );
+        GATEWAY.registerPosition(position, _frontendCode);
+        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.
+     */
+    function clone(
+        address owner,
+        address parent,
+        uint256 _initialCollateral,
+        uint256 _initialMint,
+        uint40 expiration,
+        bytes32 frontendCode
+    ) public returns (address) {
+        address position = clone(owner, parent, _initialCollateral, _initialMint, expiration);
+        GATEWAY.registerPosition(position, frontendCode);
+        return position;
+    }
+
+    function notifyInterestPaid(uint256 amount) external validPos(msg.sender) {
+        GATEWAY.updatePositionRewards(msg.sender, amount);
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return interfaceId == type(IMintingHubGateway).interfaceId || super.supportsInterface(interfaceId);
+    }
+}