abstract contract FixinTokenSpender {

    // Mask of the lower 20 bytes of a bytes32.
    uint256 constant private ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;

    /// @dev Transfers ERC20 tokens from `owner` to `to`.
    /// @param token The token to spend.
    /// @param owner The owner of the tokens.
    /// @param to The recipient of the tokens.
    /// @param amount The amount of `token` to transfer.
    function _transferERC20Tokens(
        IERC20TokenV06 token,
        address owner,
        address to,
        uint256 amount
    )
        internal
    {
        require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF");

        assembly {
            let ptr := mload(0x40) // free memory pointer

            // selector for transferFrom(address,address,uint256)
            mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
            mstore(add(ptr, 0x04), and(owner, ADDRESS_MASK))
            mstore(add(ptr, 0x24), and(to, ADDRESS_MASK))
            mstore(add(ptr, 0x44), amount)

            let success := call(
                gas(),
                and(token, ADDRESS_MASK),
                0,
                ptr,
                0x64,
                ptr,
                32
            )

            let rdsize := returndatasize()

            // Check for ERC20 success. ERC20 tokens should return a boolean,
            // but some don't. We accept 0-length return data as success, or at
            // least 32 bytes that starts with a 32-byte boolean true.
            success := and(
                success,                             // call itself succeeded
                or(
                    iszero(rdsize),                  // no return data, or
                    and(
                        iszero(lt(rdsize, 32)),      // at least 32 bytes
                        eq(mload(ptr), 1)            // starts with uint256(1)
                    )
                )
            )

            if iszero(success) {
                returndatacopy(ptr, 0, rdsize)
                revert(ptr, rdsize)
            }
        }
    }

    /// @dev Gets the maximum amount of an ERC20 token `token` that can be
    ///      pulled from `owner` by this address.
    /// @param token The token to spend.
    /// @param owner The owner of the tokens.
    /// @return amount The amount of tokens that can be pulled.
    function _getSpendableERC20BalanceOf(
        IERC20TokenV06 token,
        address owner
    )
        internal
        view
        returns (uint256)
    {
        return LibSafeMathV06.min256(
            token.allowance(owner, address(this)),
            token.balanceOf(owner)
        );
    }
}
/// @dev Helpers for moving tokens around.
function _transferERC20Tokens(
    IERC20TokenV06 token,
    address owner,
    address to,
    uint256 amount
)
    internal
{
    require(address(token) != address(this), "FixinTokenSpender/CANNOT_INVOKE_SELF");

    assembly {
        let ptr := mload(0x40) // free memory pointer

        // selector for transferFrom(address,address,uint256)
        mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
        mstore(add(ptr, 0x04), and(owner, ADDRESS_MASK))
        mstore(add(ptr, 0x24), and(to, ADDRESS_MASK))
        mstore(add(ptr, 0x44), amount)

        let success := call(
            gas(),
            and(token, ADDRESS_MASK),
            0,
            ptr,
            0x64,
            ptr,
            32
        )

        let rdsize := returndatasize()

        // Check for ERC20 success. ERC20 tokens should return a boolean,
        // but some don't. We accept 0-length return data as success, or at
        // least 32 bytes that starts with a 32-byte boolean true.
        success := and(
            success,                             // call itself succeeded
            or(
                iszero(rdsize),                  // no return data, or
                and(
                    iszero(lt(rdsize, 32)),      // at least 32 bytes
                    eq(mload(ptr), 1)            // starts with uint256(1)
                )
            )
        )

        if iszero(success) {
            returndatacopy(ptr, 0, rdsize)
            revert(ptr, rdsize)
        }
    }
}

/// @dev Transfers ERC20 tokens from `owner` to `to`.
/// @param token The token to spend.
/// @param owner The owner of the tokens.
/// @param to The recipient of the tokens.
/// @param amount The amount of `token` to transfer.