LaCulex

{{
  "language": "Solidity",
  "sources": {
    "contracts/LaCulex.sol": {
      "content": "// SPDX-License-Identifier: MIT
/*


???? ENTER AT YOUR OWN RISK: THE SWARM AWAITS ????

Welcome to La Culex ($CULEX) – where the swarm never sleeps, diamond hands buzz, and the sting is eternal.

???? Rug? Not in our hive. Liquidity locked for 18 months from launch.
???? Staking? 80% APY awaits in the Nectar Vault.
???? Deflationary? That’s the buzz. Swarm stronger, sting harder.


If you’re reading this, you’re either joining the swarm or about to get bit. Either way — welcome to the buzz.


⚠️ DO NOT SEND ETH TO THIS CONTRACT. This is a mosquito zone, not a swap zone. You’ve been warned.


???? Website: www.laculex.com
???? Twitter: x.com/laculex
???? Telegram: t.me/laculexofficial

*/


pragma solidity 0.8.28;

import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Context.sol";


contract LaCulex is Context, IERC20, IERC20Metadata {
    // ====================================================
    //                   State Variables
    // ====================================================


    mapping(address => uint256) private _bloodReserve;
    mapping(address => mapping(address => uint256)) private _wingAllowance;
    uint256 private _totalSupply;
    string private _name;
    string private _symbol;
    uint8 private immutable _decimals;
    // ====================================================
    //                   Custom Errors
    // ====================================================


    error NoBuzzForYou();
    error AccessDenied();
    error NotEnoughJuice();
    error TryAgainSwarmling();


    // ====================================================
    //                   Constructor
    // ====================================================


    constructor() {
        _name = "La Culex";
        _symbol = "$CULEX";
        _decimals = 18;
        _mint(msg.sender, 200_000_000_000 * 10**18); // 200B tokens
    }


    // ====================================================
    //                External View Functions
    // ====================================================


    function whyDoWeBuzz() external pure returns (string memory) {
        return "To swarm, obviously.";
    }
    function name() external view override returns (string memory) {
        return _name;
    }
    function symbol() external view override returns (string memory) {
        return _symbol;
    }
    function decimals() external view override returns (uint8) {
        return _decimals;
    }
    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }
    function balanceOf(address account) external view override returns (uint256) {
        return _bloodReserve[account];
    }
    function allowance(address tokenOwner, address spender) external view override returns (uint256) {
        return _wingAllowance[tokenOwner][spender];
    }


    // ====================================================
    //             External Mutating Functions
    // ====================================================


    function transfer(address to, uint256 amount) external override returns (bool) {
        address tokenOwner = _msgSender();
        _sting(tokenOwner, to, amount);
        return true;
    }
    function approve(address spender, uint256 amount) external override returns (bool) {
        address tokenOwner = _msgSender();
        _buzzApprove(tokenOwner, spender, amount);
        return true;
    }
    function transferFrom(address from, address to, uint256 amount) external override returns (bool) {
        address spender = _msgSender();
        _spendBuzzAllowance(from, spender, amount);
        _sting(from, to, amount);
        return true;
    }
    function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
        address tokenOwner = _msgSender();
        _buzzApprove(tokenOwner, spender, _wingAllowance[tokenOwner][spender] + addedValue);
        return true;
    }
    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
        address tokenOwner = _msgSender();
        uint256 currentAllowance = _wingAllowance[tokenOwner][spender];
        if (currentAllowance < subtractedValue) revert NoBuzzForYou();
        unchecked {
            _buzzApprove(tokenOwner, spender, currentAllowance - subtractedValue);
        }
        return true;
    }


    // ====================================================
    //               Internal Functions
    // ====================================================

    
    function _sting(address from, address to, uint256 amount) internal {
        if (from == address(0)) revert AccessDenied();
        if (to == address(0)) revert AccessDenied();
        uint256 fromBalance = _bloodReserve[from];
        if (fromBalance < amount) revert NotEnoughJuice();
        unchecked {
            _bloodReserve[from] = fromBalance - amount;
            _bloodReserve[to] += amount;
        }
        emit Transfer(from, to, amount);}
    function _mint(address account, uint256 amount) internal {
        if (account == address(0)) revert AccessDenied();
        _totalSupply += amount;
        unchecked {
            _bloodReserve[account] += amount;
        }
        emit Transfer(address(0), account, amount);
    }
    function _buzzApprove(address tokenOwner, address spender, uint256 amount) internal {
        if (tokenOwner == address(0)) revert AccessDenied();
        if (spender == address(0)) revert AccessDenied();
        _wingAllowance[tokenOwner][spender] = amount;
        emit Approval(tokenOwner, spender, amount);
    }
    function _spendBuzzAllowance(address tokenOwner, address spender, uint256 amount) internal {
        uint256 currentAllowance = _wingAllowance[tokenOwner][spender];
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < amount) revert TryAgainSwarmling();
            unchecked {
                _buzzApprove(tokenOwner, spender, currentAllowance - amount);
            }
        }
    }
}"
    },
    "@openzeppelin/contracts/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}
"
    },
    "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity >=0.6.2;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}
"
    },
    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "abi"
        ]
      }
    },
    "remappings": [],
    "evmVersion": "paris"
  }
}}