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

interface IApproveAndCallReceiver {
    function receiveApproval(address from, uint256 amount, address token, bytes calldata extraData) external;
}

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

interface IWhitelist {
    function checkWhitelist(address from, address to, uint256 amount) external;
}

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/token/ERC20/extensions/ERC20Permit.sol";


import {IApproveAndCallReceiver} from "./interfaces/IApproveAndCallReceiver.sol";

contract Token is ERC20, ERC20Burnable, ERC20Permit, Ownable {
    constructor() ERC20("Goodle", "GOODLE") ERC20Permit("Goodle") {
        _mint(_msgSender(), 100_000_000_000 * 1e18);
    }

    function approveAndCall(address spender, uint256 amount, bytes calldata extraData) external returns (bool) {
        // Approve the spender to spend the tokens
        _approve(msg.sender, spender, amount);

        // Call the receiveApproval function on the spender contract
        IApproveAndCallReceiver(spender).receiveApproval(msg.sender, amount, address(this), extraData);

        return true;
    }
}

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

import {Token} from "./Token.sol";
import {IWhitelist} from "./interfaces/IWhitelist.sol";

/**
 * @title Extended token contract with whitelist contract interactions
 * @notice During whitelist period, `_beforeTokenTransfer` function will call `checkWhitelist` function of whitelist contract
 * @notice If whitelist period is ended, owner will set whitelist contract address back to address(0) and tokens will be transferred freely
 */
contract TokenWhitelisted is Token {
    /// @notice whitelist contract address
    address private _whitelistContract;

    /// @notice Returns current whitelist contract address
    function whitelistContract() external view returns (address) {
        return _whitelistContract;
    }

    /// @notice Ownable function to set new whitelist contract address
    function setWhitelistContract(address newWhitelistContract) external onlyOwner {
        _whitelistContract = newWhitelistContract;
    }

    /// @notice Before token transfer hook
    /// @dev It will call `checkWhitelist` function and if it's succsessful, it will transfer tokens, unless revert
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {
        require(to != address(this), "Cannot transfer to the token contract address");
        if (_whitelistContract != address(0)) {
            IWhitelist(_whitelistContract).checkWhitelist(from, to, amount);
        }
        super._beforeTokenTransfer(from, to, amount);
    }
}

{
  "compilationTarget": {
    "contracts/TokenWhitelisted.sol": "TokenWhitelisted"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}