Wrapped CellMates

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

/*

Wrapped CellMates (wCELL)
Turn your CELLs into wCELLs that can be fractionally traded on Uniswap.

https://cellmates.io

*/

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

interface CM {
	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 wCELL {

	uint256 constant private UINT_MAX = type(uint256).max;

	CM constant public cellmates = CM(0x7F59B64C6Ee521C0d7E590CF8e4B843cAa236F96);

	string constant public name = "Wrapped CellMates";
	string constant public symbol = "wCELL";
	uint8 constant public 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);


	function wrap(uint256 _tokensOrTokenId) external {
		uint256 _balanceBefore = cellmates.balanceOf(address(this));
		cellmates.transferFrom(msg.sender, address(this), _tokensOrTokenId);
		uint256 _wrapped = cellmates.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 unwrap(uint256 _tokens) external {
		require(_tokens > 0);
		require(balanceOf(msg.sender) >= _tokens * 1e18);
		info.users[msg.sender].balance -= _tokens * 1e18;
		cellmates.transfer(msg.sender, _tokens);
		emit Transfer(msg.sender, address(0x0), _tokens * 1e18);
		emit Unwrap(msg.sender, _tokens);
	}

	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 cellmates.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 userCELLs, uint256 userAllowance, bool userApprovedForAll, uint256 userBalance) {
		totalTokens = totalSupply();
		userCELLs = cellmates.balanceOf(_user);
		userAllowance = cellmates.allowance(_user, address(this));
		userApprovedForAll = cellmates.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": {
    "wCELL.sol": "wCELL"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}