SRC-7417: Token Converter

function getSRC20WrapperFor(address _token) public view returns (address)

function getSRC223WrapperFor(address _token) public view returns (address)

function getSRC20OriginFor(address _src223Token) public view returns (address)

function getSRC223OriginFor(address _src20Token) public view returns (address)

function predictWrapperAddress(address _token,
                                   bool    _isSRC20 // Is the provided _token a SRC-20 or not?
                                                    // If it is set as SRC-20 then we will predict the address of a 
                                                    // SRC-223 wrapper for that token.
                                                    // Otherwise we will predict SRC-20 wrapper address.
                                  ) view external returns (address)

function createSRC223Wrapper(address _src20Token) public returns (address)

function createSRC20Wrapper(address _src223Token) public returns (address)

function wrapSRC20toSRC223(address _SRC20token, uint256 _amount) public returns (bool)

function unwrapSRC20toSRC223(address _SRC20token, uint256 _amount) public returns (bool)

function convertSRC20(address _token, uint256 _amount) public returns (bool)

function isWrapper(address _token) public view returns (bool)

function tokenReceived(address _from, uint _value, bytes memory _data) public override returns (bytes4)

function extractStuckSRC20(address _token)

abstract contract Token {
    function name() external virtual returns (string memory);
    function symbol() external virtual returns (string memory);
    function decimals() external virtual returns (uint8);

    function transfer(address, uint256) external virtual returns (bool);
    function approve(address, uint256) external virtual returns (bool);
    function transferFrom(address, address, uint256) external virtual returns (bool);
}

    function transfer(address _to, uint256 _amount) external virtual returns (bool)
    {
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
}

    function transfer(address _to, uint256 _amount) external virtual returns (bool)
    {
        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
        if(_to.isContract())
        {
            ISRC223Recipient(_to).tokenReceived(msg.sender, _amount, hex"000000");
        }
    }
}

pragma solidity =0.8.19;

library Address {
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

interface ISRC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

interface ISRC20Metadata is ISRC20 {
    /// @return The name of the token
    function name() external view returns (string memory);

    /// @return The symbol of the token
    function symbol() external view returns (string memory);

    /// @return The number of decimal places the token has
    function decimals() external view returns (uint8);
}

abstract contract ISRC223Recipient {
    function tokenReceived(address _from, uint _value, bytes memory _data) public virtual returns (bytes4)
    {
        return 0x8943ec02;
    }
}

abstract contract SRC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_SRC165 = 0x01ffc9a7;
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () {
        // Derived contracts need only register support for their own interfaces,
        // we register support for SRC165 itself here
        _registerInterface(_INTERFACE_ID_SRC165);
    }
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return _supportedInterfaces[interfaceId];
    }
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "SRC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

abstract contract ISRC223 {
    function name()        public view virtual returns (string memory);
    function symbol()      public view virtual returns (string memory);
    function decimals()    public view virtual returns (uint8);
    function totalSupply() public view virtual returns (uint256);
    function balanceOf(address who) public virtual view returns (uint);
    function transfer(address to, uint value) public virtual returns (bool success);
    function transfer(address to, uint value, bytes calldata data) public payable virtual returns (bool success);
    event Transfer(address indexed from, address indexed to, uint value, bytes data);
}

interface standardSRC20
{
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

/**
 * @dev Interface of the SRC20 standard.
 */
interface ISRC223WrapperToken {
    function name()     external view returns (string memory);
    function symbol()   external view returns (string memory);
    function decimals() external view returns (uint8);
    function standard() external view returns (string memory);
    function origin()   external  view returns (address);

    function totalSupply()                                            external view returns (uint256);
    function balanceOf(address account)                               external view returns (uint256);
    function transfer(address to, uint256 value)                      external payable returns (bool);
    function transfer(address to, uint256 value, bytes calldata data) external payable returns (bool);
    function allowance(address owner, address spender)                external view returns (uint256);
    function approve(address spender, uint256 value)                  external returns (bool);
    function transferFrom(address from, address to, uint256 value)    external returns (bool);

    function mint(address _recipient, uint256 _quantity) external;
    function burn(address _recipient, uint256 _quantity) external;
}

interface ISRC20WrapperToken {
    function name()     external view returns (string memory);
    function symbol()   external view returns (string memory);
    function decimals() external view returns (uint8);
    function standard() external view returns (string memory);
    function origin()   external  view returns (address);

    function totalSupply()                                         external view returns (uint256);
    function balanceOf(address account)                            external view returns (uint256);
    function transfer(address to, uint256 value)                   external returns (bool);
    function allowance(address owner, address spender)             external view returns (uint256);
    function approve(address spender, uint256 value)               external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function mint(address _recipient, uint256 _quantity) external;
    function burn(address _recipient, uint256 _quantity) external;
}

contract SRC20Rescue
{
    // SRC20 tokens can get stuck on a contracts balance due to lack of error handling.
    //
    // The author of the SRC7417 can extract SRC20 tokens if they are mistakenly sent
    // to the wrapper-contracts balance.
    // Contact dexaran@silaclassic.org
    address public extractor = 0x01000B5fE61411C466b70631d7fF070187179Bbf;
    
    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function rescueSRC20(address _token, uint256 _amount) external 
    {
        safeTransfer(_token, extractor, _amount);
    }
}

contract SRC223WrapperToken is ISRC223, SRC165, SRC20Rescue
{
    address public creator = msg.sender;
    address private wrapper_for;

    mapping(address account => mapping(address spender => uint256)) private allowances;

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event TransferData(bytes data);
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    function set(address _wrapper_for) external
    {
        require(msg.sender == creator);
        wrapper_for = _wrapper_for;
    }

    uint256 private _totalSupply;

    mapping(address => uint256) private balances; // List of user balances.

    function totalSupply() public view override returns (uint256)             { return _totalSupply; }
    function balanceOf(address _owner) public view override returns (uint256) { return balances[_owner]; }


    /**
     * @dev The SRC165 introspection function.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return
            interfaceId == type(ISRC20).interfaceId ||
            interfaceId == type(standardSRC20).interfaceId ||
            interfaceId == type(ISRC223WrapperToken).interfaceId ||
            interfaceId == type(ISRC223).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev Standard SRC223 transfer function.
     *      Calls _to if it is a contract. Does not transfer tokens to contracts
     *      which do not explicitly declare the tokenReceived function.
     * @param _to    - transfer recipient. Can be contract or EOA.
     * @param _value - the quantity of tokens to transfer.
     * @param _data  - metadata to send alongside the transaction. Can be used to encode subsequent calls in the recipient.
     */
    function transfer(address _to, uint _value, bytes calldata _data) public payable override returns (bool success)
    {
        balances[msg.sender] = balances[msg.sender] - _value;
        balances[_to] = balances[_to] + _value;
        if (msg.value > 0) 
        {
            (bool sent, bytes memory data) = _to.call{value: msg.value}("");
            require(sent);
        }
        if(Address.isContract(_to)) {
            ISRC223Recipient(_to).tokenReceived(msg.sender, _value, _data);
        }
        emit Transfer(msg.sender, _to, _value, _data);
        emit Transfer(msg.sender, _to, _value); // Old SRC20 compatible event. Added for backwards compatibility reasons.

        return true;
    }

    /**
     * @dev Standard SRC223 transfer function without _data parameter. It is supported for 
     *      backwards compatibility with SRC20 services.
     *      Calls _to if it is a contract. Does not transfer tokens to contracts
     *      which do not explicitly declare the tokenReceived function.
     * @param _to    - transfer recipient. Can be contract or EOA.
     * @param _value - the quantity of tokens to transfer.
     */
    function transfer(address _to, uint _value) public override returns (bool success)
    {
        bytes memory _empty = hex"00000000";
        balances[msg.sender] = balances[msg.sender] - _value;
        balances[_to] = balances[_to] + _value;
        if(Address.isContract(_to)) {
            ISRC223Recipient(_to).tokenReceived(msg.sender, _value, _empty);
        }
        emit Transfer(msg.sender, _to, _value, _empty);
        emit Transfer(msg.sender, _to, _value); // Old SRC20 compatible event. Added for backwards compatibility reasons.

        return true;
    }

    function name() public view override returns (string memory)   { return ISRC20Metadata(wrapper_for).name(); }
    function symbol() public view override returns (string memory) { return string.concat(ISRC20Metadata(wrapper_for).symbol(), "223"); }
    function decimals() public view override returns (uint8)       { return ISRC20Metadata(wrapper_for).decimals(); }
    function standard() public pure returns (uint32)               { return 223; }
    function origin() public view returns (address)                { return wrapper_for; }


    /**
     * @dev Minting function which will only be called by the converter contract.
     * @param _recipient - the address which will receive tokens.
     * @param _quantity  - the number of tokens to create.
     */
    function mint(address _recipient, uint256 _quantity) external
    {
        require(msg.sender == creator, "Wrapper Token: Only the creator contract can mint wrapper tokens.");
        balances[_recipient] += _quantity;
        _totalSupply += _quantity;
    }

    /**
     * @dev Burning function which will only be called by the converter contract.
     * @param _quantity  - the number of tokens to destroy. TokenConverter can only destroy tokens on it's own address.
     *                     Only the token converter is allowed to burn wrapper-tokens.
     */
    function burn(uint256 _quantity) external
    {
        require(msg.sender == creator, "Wrapper Token: Only the creator contract can destroy wrapper tokens.");
        balances[msg.sender] -= _quantity;
        _totalSupply -= _quantity;
    }

    // SRC20 functions for backwards compatibility.

    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return allowances[owner][spender];
    }

    function approve(address _spender, uint _value) public returns (bool) {
        require(_spender != address(0), "SRC223: Spender error.");

        allowances[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);

        return true;
    }

    function transferFrom(address _from, address _to, uint _value) public returns (bool) {

        require(allowances[_from][msg.sender] >= _value, "SRC223: Insufficient allowance.");

        balances[_from] -= _value;
        allowances[_from][msg.sender] -= _value;
        balances[_to] += _value;

        emit Transfer(_from, _to, _value);

        return true;
    }
}

contract SRC20WrapperToken is ISRC20, SRC165, SRC20Rescue
{
    address public creator = msg.sender;
    address public wrapper_for;

    mapping(address account => mapping(address spender => uint256)) private allowances;

    function set(address _wrapper_for) external
    {
        require(msg.sender == creator);
        wrapper_for = _wrapper_for;
    }

    uint256 private _totalSupply;
    mapping(address => uint256) private balances; // List of user balances.


    function balanceOf(address _owner) public view override returns (uint256) { return balances[_owner]; }

    function name()        public view  returns (string memory) { return ISRC20Metadata(wrapper_for).name(); }
    function symbol()      public view  returns (string memory) { return string.concat(ISRC223(wrapper_for).symbol(), "20"); }
    function decimals()    public view  returns (uint8)         { return ISRC20Metadata(wrapper_for).decimals(); }
    function totalSupply() public view override returns (uint256)       { return _totalSupply; }
    function origin()      public view returns (address)                { return wrapper_for; }

    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return
            interfaceId == type(ISRC20).interfaceId ||
            interfaceId == type(ISRC20WrapperToken).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    function transfer(address _to, uint _value) public override returns (bool success)
    {
        balances[msg.sender] = balances[msg.sender] - _value;
        balances[_to] = balances[_to] + _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    function mint(address _recipient, uint256 _quantity) external
    {
        require(msg.sender == creator, "Wrapper Token: Only the creator contract can mint wrapper tokens.");
        balances[_recipient] += _quantity;
        _totalSupply += _quantity;
    }

    function burn(address _from, uint256 _quantity) external
    {
        require(msg.sender == creator, "Wrapper Token: Only the creator contract can destroy wrapper tokens.");
        balances[_from] -= _quantity;
        _totalSupply    -= _quantity;
    }

    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return allowances[owner][spender];
    }

    function approve(address _spender, uint _value) public returns (bool) {

        // Safety checks.

        require(_spender != address(0), "SRC20: Spender error.");

        allowances[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);

        return true;
    }

    function transferFrom(address _from, address _to, uint _value) public returns (bool) {

        require(allowances[_from][msg.sender] >= _value, "SRC20: Insufficient allowance.");

        balances[_from] -= _value;
        allowances[_from][msg.sender] -= _value;
        balances[_to] += _value;

        emit Transfer(_from, _to, _value);

        return true;
    }
}

contract TokenStandardConverter is ISRC223Recipient
{
    event SRC223WrapperCreated(address indexed _token, address indexed _SRC223Wrapper);
    event SRC20WrapperCreated(address indexed _token, address indexed _SRC20Wrapper);

    mapping (address => SRC223WrapperToken) public src223Wrappers; // A list of token wrappers. First one is SRC20 origin, second one is SRC223 version.
    mapping (address => SRC20WrapperToken)  public src20Wrappers;

    mapping (address => address)            public src223Origins;
    mapping (address => address)            public src20Origins;
    mapping (address => uint256)            public src20Supply; // Token => how much was deposited.

    function getSRC20WrapperFor(address _token) public view returns (address)
    {
        return address(src20Wrappers[_token]);
    }

    function getSRC223WrapperFor(address _token) public view returns (address)
    {
        return address(src223Wrappers[_token]);
    }

    function getSRC20OriginFor(address _token) public view returns (address)
    {
        return (address(src20Origins[_token]));
    }

    function getSRC223OriginFor(address _token) public view returns (address)
    {
        return (address(src223Origins[_token]));
    }

    function predictWrapperAddress(address _token,
                                   bool    _isSRC20 // Is the provided _token a SRC20 or not?
                                                    // If it is set as SRC20 then we will predict the address of a 
                                                    // SRC223 wrapper for that token.
                                                    // Otherwise we will predict SRC20 wrapper address.
                                  ) view external returns (address)
    {
        bytes memory _bytecode;
        if(_isSRC20)
        {
            _bytecode = type(SRC223WrapperToken).creationCode;
        }
        else
        {
            _bytecode = type(SRC20WrapperToken).creationCode;
        }

        bytes32 hash = keccak256(
            abi.encodePacked(
                bytes1(0xff), address(this), keccak256(abi.encode(_token)), keccak256(_bytecode)
          )
        );

        return address(uint160(uint(hash)));
    }

    function tokenReceived(address _from, uint _value, bytes memory /* _data */) public override returns (bytes4)
    {
        require(src223Origins[msg.sender] == address(0), "Error: creating wrapper for a wrapper token.");
        // There are two possible cases:
        // 1. A user deposited SRC223 origin token to convert it to SRC20 wrapper
        // 2. A user deposited SRC223 wrapper token to unwrap it to SRC20 origin.

        if(src20Origins[msg.sender] != address(0))
        {
            // Origin for deposited token exists.
            // Unwrap SRC-223 wrapper.

            src20Supply[src20Origins[msg.sender]] -= _value;
            safeTransfer(src20Origins[msg.sender], _from, _value);

            SRC223WrapperToken(msg.sender).burn(_value);

            return this.tokenReceived.selector;
        }
        // Otherwise origin for the sender token doesn't exist
        // There are two possible cases:
        // 1. SRC20 wrapper for the deposited token exists
        // 2. SRC20 wrapper for the deposited token doesn't exist and must be created.
        else if(address(src20Wrappers[msg.sender]) == address(0))
        {
            // Create SRC-20 wrapper if it doesn't exist.
            createSRC20Wrapper(msg.sender);
        }

        // Mint SRC-20 wrapper tokens for the deposited SRC-223 token
        // if the SRC-20 wrapper didn't exist then it was just created in the above statement.
        src20Wrappers[msg.sender].mint(_from, _value);
        return this.tokenReceived.selector;
    }

    function createSRC223Wrapper(address _token) public returns (address)
    {
        require(address(src223Wrappers[_token]) == address(0), "ERROR: Wrapper exists");
        require(!isWrapper(_token), "Error: Creating wrapper for a wrapper token");
        
        SRC223WrapperToken _newSRC223Wrapper     = new SRC223WrapperToken{salt: keccak256(abi.encode(_token))}();
        _newSRC223Wrapper.set(_token);
        src223Wrappers[_token]                   = _newSRC223Wrapper;
        src20Origins[address(_newSRC223Wrapper)] = _token;

        emit SRC223WrapperCreated(_token, address(_newSRC223Wrapper));
        return address(_newSRC223Wrapper);
    }

    function createSRC20Wrapper(address _token) public returns (address)
    {
        require(address(src20Wrappers[_token]) == address(0), "ERROR: Wrapper already exists.");
        require(!isWrapper(_token), "Error: Creating wrapper for a wrapper token");

        SRC20WrapperToken _newSRC20Wrapper       = new SRC20WrapperToken{salt: keccak256(abi.encode(_token))}();
        _newSRC20Wrapper.set(_token);
        src20Wrappers[_token]                    = _newSRC20Wrapper;
        src223Origins[address(_newSRC20Wrapper)] = _token;

        emit SRC20WrapperCreated(_token, address(_newSRC20Wrapper));
        return address(_newSRC20Wrapper);
    }

    function wrapSRC20toSRC223(address _SRC20token, uint256 _amount) public returns (bool)
    {
        // If there is no active wrapper for a token that user wants to wrap
        // then create it.
        if(address(src223Wrappers[_SRC20token]) == address(0))
        {
            createSRC223Wrapper(_SRC20token);
        }
        uint256 _converterBalance = ISRC20(_SRC20token).balanceOf(address(this)); // Safety variable.
        safeTransferFrom(_SRC20token, msg.sender, address(this), _amount);

        _amount = ISRC20(_SRC20token).balanceOf(address(this)) - _converterBalance;
        src20Supply[_SRC20token] += _amount;

        src223Wrappers[_SRC20token].mint(msg.sender, _amount);

        return true;
    }

    function unwrapSRC20toSRC223(address _SRC20token, uint256 _amount) public returns (bool)
    {
        require(ISRC20(_SRC20token).balanceOf(msg.sender) >= _amount, "Error: Insufficient balance.");
        require(src223Origins[_SRC20token] != address(0), "Error: provided token is not a SRC-20 wrapper.");

        SRC20WrapperToken(_SRC20token).burn(msg.sender, _amount);

        safeTransfer(src223Origins[_SRC20token], msg.sender, _amount);

        return true;
    }

    function convertSRC20(address _token, uint256 _amount) public returns (bool)
    {
        if(isWrapper(_token)) return unwrapSRC20toSRC223(_token, _amount);
        else return wrapSRC20toSRC223(_token, _amount);
    }

    function isWrapper(address _token) public view returns (bool)
    {
        return src20Origins[_token] != address(0) || src223Origins[_token] != address(0);
    }

    function extractStuckSRC20(address _token) external 
    {
        require(msg.sender == address(0x01000B5fE61411C466b70631d7fF070187179Bbf));

        safeTransfer(_token, address(0x01000B5fE61411C466b70631d7fF070187179Bbf), ISRC20(_token).balanceOf(address(this)) - src20Supply[_token]);
    }
    
    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }
}