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

/*

Wrapped MitoBlobs (wBLOBS)
Turn your BLOBs into wBLOBS that can be fractionally traded on Uniswap.

@MitoBlobs
https://mitoblobs.xyz

*/

interface Callable {
    function tokenCallback(
        address _from,
        uint256 _tokens,
        bytes calldata _data
    ) external returns (bool);
}

interface MB {
    function balanceOf(address) external view returns (uint256);

    function allowance(address, address) external view returns (uint256);

    function isApprovedForAll(address, address) external view returns (bool);

    function transfer(address _to, uint256 _tokens) external returns (bool);

    function transferFrom(
        address _from,
        address _to,
        uint256 _tokens
    ) external returns (bool);
}

contract wBLOBS {
    uint256 private constant UINT_MAX = type(uint256).max;

    MB public mitoblobs;

    string public constant name = "Wrapped Blobs";
    string public constant symbol = "wBLOBS";
    uint8 public constant decimals = 18;

    struct User {
        uint256 balance;
        mapping(address => uint256) allowance;
    }

    struct Info {
        mapping(address => User) users;
    }
    Info private info;

    event Transfer(address indexed from, address indexed to, uint256 tokens);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 tokens
    );
    event Wrap(address indexed owner, uint256 tokens);
    event Unwrap(address indexed owner, uint256 tokens);
    
    constructor(address _mitoblobs) {
        mitoblobs = MB(_mitoblobs);
    }

    function wrap(uint256 tokenId) public {
        uint256 _balanceBefore = mitoblobs.balanceOf(address(this));
        mitoblobs.transferFrom(msg.sender, address(this), tokenId);
        uint256 _wrapped = mitoblobs.balanceOf(address(this)) - _balanceBefore;
        require(_wrapped > 0);
        info.users[msg.sender].balance += _wrapped * 1e18;
        emit Transfer(address(0x0), msg.sender, _wrapped * 1e18);
        emit Wrap(msg.sender, _wrapped);
    }

    function wrapMultiple(uint256[] memory tokenIds) external {
        for (uint256 i; i < tokenIds.length; i++) {
            wrap(tokenIds[i]);
        }
    }

    function unwrap(uint256 _tokens) external {
        require(_tokens > 0);
        require(balanceOf(msg.sender) >= _tokens * 1e18);
        info.users[msg.sender].balance -= _tokens * 1e18;
        mitoblobs.transfer(msg.sender, _tokens);
        emit Transfer(msg.sender, address(0x0), _tokens * 1e18);
        emit Unwrap(msg.sender, _tokens);
    }

    function multisend(address[] memory recipients, uint256 amount) external {
        require(balanceOf(msg.sender) >= recipients.length * amount, "Your balance is too low");
        for (uint256 i; i < recipients.length; i++) {
            _transfer(msg.sender, recipients[i], amount);
        }
    }

    function transfer(address _to, uint256 _tokens) external returns (bool) {
        return _transfer(msg.sender, _to, _tokens);
    }

    function approve(
        address _spender,
        uint256 _tokens
    ) external returns (bool) {
        info.users[msg.sender].allowance[_spender] = _tokens;
        emit Approval(msg.sender, _spender, _tokens);
        return true;
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _tokens
    ) external returns (bool) {
        uint256 _allowance = allowance(_from, msg.sender);
        require(_allowance >= _tokens);
        if (_allowance != UINT_MAX) {
            info.users[_from].allowance[msg.sender] -= _tokens;
        }
        return _transfer(_from, _to, _tokens);
    }

    function transferAndCall(
        address _to,
        uint256 _tokens,
        bytes calldata _data
    ) external returns (bool) {
        _transfer(msg.sender, _to, _tokens);
        uint32 _size;
        assembly {
            _size := extcodesize(_to)
        }
        if (_size > 0) {
            require(Callable(_to).tokenCallback(msg.sender, _tokens, _data));
        }
        return true;
    }

    function totalSupply() public view returns (uint256) {
        return mitoblobs.balanceOf(address(this)) * 1e18;
    }

    function balanceOf(address _user) public view returns (uint256) {
        return info.users[_user].balance;
    }

    function allowance(
        address _user,
        address _spender
    ) public view returns (uint256) {
        return info.users[_user].allowance[_spender];
    }

    function allInfoFor(
        address _user
    )
        external
        view
        returns (
            uint256 totalTokens,
            uint256 userBLOBs,
            uint256 userAllowance,
            bool userApprovedForAll,
            uint256 userBalance
        )
    {
        totalTokens = totalSupply();
        userBLOBs = mitoblobs.balanceOf(_user);
        userAllowance = mitoblobs.allowance(_user, address(this));
        userApprovedForAll = mitoblobs.isApprovedForAll(_user, address(this));
        userBalance = balanceOf(_user);
    }

    function _transfer(
        address _from,
        address _to,
        uint256 _tokens
    ) internal returns (bool) {
        unchecked {
            require(balanceOf(_from) >= _tokens);
            info.users[_from].balance -= _tokens;
            info.users[_to].balance += _tokens;
            emit Transfer(_from, _to, _tokens);
            return true;
        }
    }
}

{
  "compilationTarget": {
    "wBLOBS.sol": "wBLOBS"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}