Address

• cdaimintermaxdaiborrow.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface ICEther {
    function mint() external payable;
}

interface ICDAI {
    function mint(uint256 amount) external returns (uint256);
    function borrow(uint256 amount) external returns (uint256);
    function redeem(uint256 redeemTokens) external returns (uint256);
}

interface IComptroller {
    function enterMarkets(address[] calldata markets) external returns (uint256[] memory);
    function getAccountLiquidity(address account) external view returns (uint256 errCode, uint256 liquidity, uint256 shortfall);
}

interface IBalancerVault {
    function flashLoan(
        address recipient,
        address[] calldata tokens,
        uint256[] calldata amounts,
        bytes calldata userData
    ) external;
}

contract UnlockedLeverageManager {
    address public immutable owner;
    mapping(address => bool) public whitelist;

    // Checksummed Contract Addresses (Ethereum Mainnet / PulseChain Clones)
    address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    address public constant cDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
    address public constant cETH = 0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5;
    address public constant COMPTROLLER = 0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B;
    address public constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;

    // ⚡ UPDATED PARAMETERS
    uint256 public constant TARGET_DAI_LOAN = 16716154688817063125616309; // ~16.7M DAI (with 18 decimals)
    address public constant TOKEN_TO_SWEEP = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643; // cDAI
    uint256 public constant FIXED_DEPOSIT = 11020 * 1e18; // 11,020 Native Tokens (PLS with 18 decimals)

    event MaxLeverageExecuted(address indexed caller, uint256 nativeDeposit, uint256 flashLoanedDAI);
    event YieldSwept(address indexed owner, uint256 amount);

    modifier onlyOwner() {
        require(msg.sender == owner, "Owner only");
        _;
    }

    modifier onlyWhitelisted() {
        require(whitelist[msg.sender], "Not authorized");
        _;
    }

    constructor() {
        owner = msg.sender;
        whitelist[msg.sender] = true;
    }

    function setWhitelist(address user, bool allowed) external onlyOwner {
        whitelist[user] = allowed;
    }

    /**
     * @notice Cleaned interface requiring no input arguments.
     * @dev Automatically reads the hardcoded ~16.7M DAI target, cDAI token target, and enforces the 11,020 native token supply.
     */
    function executeAndSweepInOneTx() external payable onlyWhitelisted {
        // Enforce that your wallet forwarded precisely the required 11,020 native token buffer
        require(msg.value == FIXED_DEPOSIT, "Transaction must carry exactly 11,020 native tokens");

        // 1. Core loop executed internally using the fixed parameter configurations
        _executeInternalRecipe(TARGET_DAI_LOAN, msg.value);

        // 2. Core sweep executed internally right after flash loan completes
        _sweepInternalTokens(TOKEN_TO_SWEEP);
    }

    /**
     * @dev Original standalone entry-point adapted to rely strictly on the hardcoded settings.
     */
    function executeInfiniteLoopRecipe() external payable onlyWhitelisted {
        require(msg.value == FIXED_DEPOSIT, "Transaction must carry exactly 11,020 native tokens");
        _executeInternalRecipe(TARGET_DAI_LOAN, msg.value);
    }

    function _executeInternalRecipe(uint256 targetDAILoanAmount, uint256 depositAmount) internal {
        ICEther(cETH).mint{value: depositAmount}();

        address[] memory markets = new address[](2);
        markets[0] = cETH;
        markets[1] = cDAI;
        IComptroller(COMPTROLLER).enterMarkets(markets);

        address[] memory tokens = new address[](1);
        tokens[0] = DAI;

        uint256[] memory amounts = new uint256[](1);
        amounts[0] = targetDAILoanAmount;

        bytes memory userData = abi.encode(targetDAILoanAmount);

        IBalancerVault(BALANCER_VAULT).flashLoan(
            address(this),
            tokens,
            amounts,
            userData
        );

        emit MaxLeverageExecuted(msg.sender, depositAmount, targetDAILoanAmount);
    }

    function receiveFlashLoan(
        address[] memory tokens,
        uint256[] memory amounts,
        uint256[] memory feeAmounts,
        bytes memory userData
    ) external {
        require(msg.sender == BALANCER_VAULT, "Unauthorized caller");
        uint256 flashLoanAmount = abi.decode(userData, (uint256));

        require(IERC20(DAI).approve(cDAI, flashLoanAmount), "Approval failed");
        require(ICDAI(cDAI).mint(flashLoanAmount) == 0, "cDAI mint failed");

        (uint256 errCode, uint256 liquidity, ) = IComptroller(COMPTROLLER).getAccountLiquidity(address(this));
        require(errCode == 0 && liquidity > 0, "Insufficient backing for this position size");

        uint256 repaymentAmount = amounts[0] + feeAmounts[0];

        require(ICDAI(cDAI).borrow(repaymentAmount) == 0, "Max loan capacity exceeded");
        require(IERC20(tokens[0]).transfer(BALANCER_VAULT, repaymentAmount), "Flash loan repayment failed");
    }

    function sweepYieldTokens(address token) external onlyOwner {
        _sweepInternalTokens(token);
    }

    function _sweepInternalTokens(address token) internal {
        uint256 balance = IERC20(token).balanceOf(address(this));
        if (balance > 0) {
            require(IERC20(token).transfer(owner, balance), "Yield sweep failed");
            emit YieldSwept(owner, balance);
        }
    }

    function withdrawNative() external onlyOwner {
        (bool success, ) = payable(owner).call{value: address(this).balance}("");
        require(success, "Native withdrawal failed");
    }

    receive() external payable {}
}