Blocks
Blocks
Uncles
Forked Blocks (Reorgs)
Transactions
Validated
Pending
Tokens
All
Doge
APIs
GraphQL
RPC
Eth RPC
Apps
Mainnet
Mainnets
Dogechain Mainnet
Testnets
Dogechain Testnet
/
Search
/
Search
Connection Lost
New Solidity Smart Contract Verification
Contract Address
The 0x address supplied on contract creation.
Contract Name
Must match the name specified in the code. For example, in
contract MyContract {..}
MyContract
is the contract name.
Include nightly builds
No
Yes
Select yes if you want to show nightly builds.
Compiler
v0.8.25+commit.b61c2a91
v0.8.24+commit.e11b9ed9
v0.8.23+commit.f704f362
v0.8.22+commit.4fc1097e
v0.8.21+commit.d9974bed
v0.8.20+commit.a1b79de6
v0.8.19+commit.7dd6d404
v0.8.18+commit.87f61d96
v0.8.17+commit.8df45f5f
v0.8.16+commit.07a7930e
v0.8.15+commit.e14f2714
v0.8.14+commit.80d49f37
v0.8.13+commit.abaa5c0e
v0.8.12+commit.f00d7308
v0.8.11+commit.d7f03943
v0.8.10+commit.fc410830
v0.8.9+commit.e5eed63a
v0.8.8+commit.dddeac2f
v0.8.7+commit.e28d00a7
v0.8.6+commit.11564f7e
v0.8.5+commit.a4f2e591
v0.8.4+commit.c7e474f2
v0.8.3+commit.8d00100c
v0.8.2+commit.661d1103
v0.8.1+commit.df193b15
v0.8.0+commit.c7dfd78e
v0.7.6+commit.7338295f
v0.7.5+commit.eb77ed08
v0.7.4+commit.3f05b770
v0.7.3+commit.9bfce1f6
v0.7.2+commit.51b20bc0
v0.7.1+commit.f4a555be
v0.7.0+commit.9e61f92b
v0.6.12+commit.27d51765
v0.6.11+commit.5ef660b1
v0.6.10+commit.00c0fcaf
v0.6.9+commit.3e3065ac
v0.6.8+commit.0bbfe453
v0.6.7+commit.b8d736ae
v0.6.6+commit.6c089d02
v0.6.5+commit.f956cc89
v0.6.4+commit.1dca32f3
v0.6.3+commit.8dda9521
v0.6.2+commit.bacdbe57
v0.6.1+commit.e6f7d5a4
v0.6.0+commit.26b70077
v0.5.17+commit.d19bba13
v0.5.16+commit.9c3226ce
v0.5.15+commit.6a57276f
v0.5.14+commit.01f1aaa4
v0.5.13+commit.5b0b510c
v0.5.12+commit.7709ece9
v0.5.11+commit.22be8592
v0.5.10+commit.5a6ea5b1
v0.5.9+commit.c68bc34e
v0.5.8+commit.23d335f2
v0.5.7+commit.6da8b019
v0.5.6+commit.b259423e
v0.5.5+commit.47a71e8f
v0.5.4+commit.9549d8ff
v0.5.3+commit.10d17f24
v0.5.2+commit.1df8f40c
v0.5.1+commit.c8a2cb62
v0.5.0+commit.1d4f565a
v0.4.26+commit.4563c3fc
v0.4.25+commit.59dbf8f1
v0.4.24+commit.e67f0147
v0.4.23+commit.124ca40d
v0.4.22+commit.4cb486ee
v0.4.21+commit.dfe3193c
v0.4.20+commit.3155dd80
v0.4.19+commit.c4cbbb05
v0.4.18+commit.9cf6e910
v0.4.17+commit.bdeb9e52
v0.4.16+commit.d7661dd9
v0.4.15+commit.8b45bddb
v0.4.14+commit.c2215d46
v0.4.13+commit.0fb4cb1a
v0.4.12+commit.194ff033
v0.4.11+commit.68ef5810
v0.4.10+commit.9e8cc01b
The compiler version is specified in
pragma solidity X.X.X
. Use the compiler version rather than the nightly build. If using the Solidity compiler, run
solc —version
to check.
EVM Version
homestead
tangerineWhistle
spuriousDragon
byzantium
constantinople
petersburg
istanbul
berlin
london
default
The EVM version the contract is written for. If the bytecode does not match the version, we try to verify using the latest EVM version.
EVM version details
.
Optimization
No
Yes
If you enabled optimization during compilation, select yes.
Optimization runs
Enter the Solidity Contract Code
// Sources flattened with hardhat v2.9.3 https://hardhat.org // File @openzeppelin/contracts/utils/math/SafeMath.sol@v4.6.0 // SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File @openzeppelin/contracts/proxy/Clones.sol@v4.6.0 // OpenZeppelin Contracts v4.4.1 (proxy/Clones.sol) pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for * deploying minimal proxy contracts, also known as "clones". * * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies * > a minimal bytecode implementation that delegates all calls to a known, fixed address. * * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2` * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the * deterministic method. * * _Available since v3.4._ */ library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create opcode, which should never revert. */ function clone(address implementation) internal returns (address instance) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt, address deployer ) internal pure returns (address predicted) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(implementation, salt, address(this)); } } // File contracts/interfaces/IUniswapV2Factory.sol pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint256 ); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // File contracts/interfaces/IUniswapV2Router02.sol pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns ( uint256 amountA, uint256 amountB, uint256 liquidity ); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountETH, uint256 liquidity ); function removeLiquidity( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityETH( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external returns (uint256 amountToken, uint256 amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityETHWithPermit( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountToken, uint256 amountETH); function swapExactTokensForTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapTokensForExactTokens( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactETHForTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function swapTokensForExactETH( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactTokensForETH( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapETHForExactTokens( uint256 amountOut, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function quote( uint256 amountA, uint256 reserveA, uint256 reserveB ) external pure returns (uint256 amountB); function getAmountOut( uint256 amountIn, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountOut); function getAmountIn( uint256 amountOut, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountIn); function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts); function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external returns (uint256 amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } // File contracts/interfaces/IERC20Extended.sol pragma solidity =0.8.4; interface IERC20Extended { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval( address indexed owner, address indexed spender, uint256 value ); } // File contracts/buyback/Auth.sol pragma solidity =0.8.4; abstract contract Auth { address internal owner; mapping(address => bool) internal authorizations; constructor(address _owner) { owner = _owner; authorizations[_owner] = true; } /** * Function modifier to require caller to be contract owner */ modifier onlyOwner() { require(isOwner(msg.sender), "!OWNER"); _; } /** * Function modifier to require caller to be authorized */ modifier authorized() { require(isAuthorized(msg.sender), "!AUTHORIZED"); _; } /** * Authorize address. Owner only */ function authorize(address adr) public onlyOwner { authorizations[adr] = true; } /** * Remove address' authorization. Owner only */ function unauthorize(address adr) public onlyOwner { authorizations[adr] = false; } /** * Check if address is owner */ function isOwner(address account) public view returns (bool) { return account == owner; } /** * Return address' authorization status */ function isAuthorized(address adr) public view returns (bool) { return authorizations[adr]; } /** * Transfer ownership to new address. Caller must be owner. Leaves old owner authorized */ function transferOwnership(address payable adr) public onlyOwner { owner = adr; authorizations[adr] = true; emit OwnershipTransferred(adr); } event OwnershipTransferred(address owner); } // File contracts/buyback/DividendDistributor.sol pragma solidity =0.8.4; interface IDividendDistributor { function setDistributionCriteria( uint256 _minPeriod, uint256 _minDistribution ) external; function setShare(address shareholder, uint256 amount) external; function deposit() external payable; function process(uint256 gas) external; } contract DividendDistributor is IDividendDistributor { using SafeMath for uint256; address public _token; struct Share { uint256 amount; uint256 totalExcluded; uint256 totalRealised; } IERC20Extended public rewardToken; IUniswapV2Router02 public router; address[] public shareholders; mapping(address => uint256) public shareholderIndexes; mapping(address => uint256) public shareholderClaims; mapping(address => Share) public shares; uint256 public totalShares; uint256 public totalDividends; uint256 public totalDistributed; uint256 public dividendsPerShare; uint256 public dividendsPerShareAccuracyFactor; uint256 public minPeriod; uint256 public minDistribution; uint256 currentIndex; bool initialized; modifier initializer() { require(!initialized); _; initialized = true; } modifier onlyToken() { require(msg.sender == _token); _; } constructor(address rewardToken_, address router_) { _token = msg.sender; rewardToken = IERC20Extended(rewardToken_); router = IUniswapV2Router02(router_); dividendsPerShareAccuracyFactor = 10**36; minPeriod = 1 hours; minDistribution = 1 * (10**rewardToken.decimals()); } function setDistributionCriteria( uint256 _minPeriod, uint256 _minDistribution ) external override onlyToken { minPeriod = _minPeriod; minDistribution = _minDistribution; } function setShare(address shareholder, uint256 amount) external override onlyToken { if (shares[shareholder].amount > 0) { distributeDividend(shareholder); } if (amount > 0 && shares[shareholder].amount == 0) { addShareholder(shareholder); } else if (amount == 0 && shares[shareholder].amount > 0) { removeShareholder(shareholder); } totalShares = totalShares.sub(shares[shareholder].amount).add(amount); shares[shareholder].amount = amount; shares[shareholder].totalExcluded = getCumulativeDividends( shares[shareholder].amount ); } function deposit() external payable override onlyToken { uint256 balanceBefore = rewardToken.balanceOf(address(this)); address[] memory path = new address[](2); path[0] = router.WETH(); path[1] = address(rewardToken); router.swapExactETHForTokensSupportingFeeOnTransferTokens{ value: msg.value }(0, path, address(this), block.timestamp); uint256 amount = rewardToken.balanceOf(address(this)).sub( balanceBefore ); totalDividends = totalDividends.add(amount); dividendsPerShare = dividendsPerShare.add( dividendsPerShareAccuracyFactor.mul(amount).div(totalShares) ); } function process(uint256 gas) external override onlyToken { uint256 shareholderCount = shareholders.length; if (shareholderCount == 0) { return; } uint256 gasUsed = 0; uint256 gasLeft = gasleft(); uint256 iterations = 0; while (gasUsed < gas && iterations < shareholderCount) { if (currentIndex >= shareholderCount) { currentIndex = 0; } if (shouldDistribute(shareholders[currentIndex])) { distributeDividend(shareholders[currentIndex]); } gasUsed = gasUsed.add(gasLeft.sub(gasleft())); gasLeft = gasleft(); currentIndex++; iterations++; } } function shouldDistribute(address shareholder) internal view returns (bool) { return shareholderClaims[shareholder] + minPeriod < block.timestamp && getUnpaidEarnings(shareholder) > minDistribution; } function distributeDividend(address shareholder) internal { if (shares[shareholder].amount == 0) { return; } uint256 amount = getUnpaidEarnings(shareholder); if (amount > 0) { totalDistributed = totalDistributed.add(amount); rewardToken.transfer(shareholder, amount); shareholderClaims[shareholder] = block.timestamp; shares[shareholder].totalRealised = shares[shareholder] .totalRealised .add(amount); shares[shareholder].totalExcluded = getCumulativeDividends( shares[shareholder].amount ); } } function claimDividend() external { distributeDividend(msg.sender); } function getUnpaidEarnings(address shareholder) public view returns (uint256) { if (shares[shareholder].amount == 0) { return 0; } uint256 shareholderTotalDividends = getCumulativeDividends( shares[shareholder].amount ); uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded; if (shareholderTotalDividends <= shareholderTotalExcluded) { return 0; } return shareholderTotalDividends.sub(shareholderTotalExcluded); } function getCumulativeDividends(uint256 share) internal view returns (uint256) { return share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor); } function addShareholder(address shareholder) internal { shareholderIndexes[shareholder] = shareholders.length; shareholders.push(shareholder); } function removeShareholder(address shareholder) internal { shareholders[shareholderIndexes[shareholder]] = shareholders[ shareholders.length - 1 ]; shareholderIndexes[ shareholders[shareholders.length - 1] ] = shareholderIndexes[shareholder]; shareholders.pop(); } } // File contracts/interfaces/ICronosPadAntiBot.sol pragma solidity >=0.5.0; interface ICronosPadAntiBot { function setTokenOwner(address owner) external; function onPreTransferCheck( address from, address to, uint256 amount ) external; } // File contracts/BaseToken.sol pragma solidity =0.8.4; enum TokenType { standard, antiBotStandard, liquidityGenerator, antiBotLiquidityGenerator, baby, antiBotBaby, buybackBaby, antiBotBuybackBaby } abstract contract BaseToken { event TokenCreated( address indexed owner, address indexed token, TokenType tokenType, uint256 version ); } // File contracts/tokens/AntiBotBuybackBabyToken.sol pragma solidity 0.8.4; contract AntiBotBuybackBabyToken is IERC20Extended, Auth, BaseToken { using SafeMath for uint256; uint256 public constant VERSION = 1; address private constant DEAD = address(0xdead); address private constant ZERO = address(0); uint8 private constant _decimals = 9; string private _name; string private _symbol; uint256 private _totalSupply; address public rewardToken; IUniswapV2Router02 public router; address public pair; address public autoLiquidityReceiver; address public marketingFeeReceiver; uint256 public liquidityFee; // default: 200 uint256 public buybackFee; // default: 300 uint256 public reflectionFee; // default: 800 uint256 public marketingFee; // default: 100 uint256 public totalFee; uint256 public feeDenominator; // default: 10000 uint256 public targetLiquidity; // default: 25 uint256 public targetLiquidityDenominator; // default: 100 uint256 public buybackMultiplierNumerator; // default: 200 uint256 public buybackMultiplierDenominator; // default: 100 uint256 public buybackMultiplierTriggeredAt; uint256 public buybackMultiplierLength; // default: 30 mins bool public autoBuybackEnabled; uint256 public autoBuybackCap; uint256 public autoBuybackAccumulator; uint256 public autoBuybackAmount; uint256 public autoBuybackBlockPeriod; uint256 public autoBuybackBlockLast; DividendDistributor public distributor; uint256 public distributorGas; bool public swapEnabled; uint256 public swapThreshold; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; mapping(address => bool) public buyBacker; mapping(address => bool) public isFeeExempt; mapping(address => bool) public isDividendExempt; ICronosPadAntiBot public cronosPadAntiBot; bool public enableAntiBot; event AutoLiquify(uint256 amountBNB, uint256 amountBOG); event BuybackMultiplierActive(uint256 duration); bool inSwap; modifier swapping() { inSwap = true; _; inSwap = false; } modifier onlyBuybacker() { require(buyBacker[msg.sender] == true, "Not a buybacker"); _; } constructor( string memory name_, string memory symbol_, uint256 totalSupply_, address rewardToken_, address router_, address antiBot_, uint256[5] memory feeSettings_, address serviceFeeReceiver_, uint256 serviceFee_ ) payable Auth(msg.sender) { _name = name_; _symbol = symbol_; _totalSupply = totalSupply_; cronosPadAntiBot = ICronosPadAntiBot(antiBot_); cronosPadAntiBot.setTokenOwner(msg.sender); enableAntiBot = true; rewardToken = rewardToken_; router = IUniswapV2Router02(router_); pair = IUniswapV2Factory(router.factory()).createPair( address(this), router.WETH() ); distributor = new DividendDistributor(rewardToken_, router_); _initializeFees(feeSettings_); _initializeLiquidityBuyBack(); distributorGas = 500000; swapEnabled = true; swapThreshold = _totalSupply / 20000; // 0.005% isFeeExempt[msg.sender] = true; isDividendExempt[pair] = true; isDividendExempt[address(this)] = true; isDividendExempt[DEAD] = true; buyBacker[msg.sender] = true; autoLiquidityReceiver = msg.sender; marketingFeeReceiver = msg.sender; _allowances[address(this)][address(router)] = _totalSupply; _allowances[address(this)][address(pair)] = _totalSupply; _balances[msg.sender] = _totalSupply; emit Transfer(address(0), msg.sender, _totalSupply); emit TokenCreated( msg.sender, address(this), TokenType.antiBotBuybackBaby, VERSION ); payable(serviceFeeReceiver_).transfer(serviceFee_); } function _initializeFees(uint256[5] memory feeSettings_) internal { _setFees( feeSettings_[0], // liquidityFee feeSettings_[1], // buybackFee feeSettings_[2], // reflectionFee feeSettings_[3], // marketingFee feeSettings_[4] // feeDenominator ); } function _initializeLiquidityBuyBack() internal { targetLiquidity = 25; targetLiquidityDenominator = 100; buybackMultiplierNumerator = 200; buybackMultiplierDenominator = 100; buybackMultiplierLength = 30 minutes; } function setEnableAntiBot(bool _enable) external authorized { enableAntiBot = _enable; } receive() external payable {} function totalSupply() external view override returns (uint256) { return _totalSupply; } function decimals() external pure override returns (uint8) { return _decimals; } function symbol() external view override returns (string memory) { return _symbol; } function name() external view override returns (string memory) { return _name; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function approveMax(address spender) external returns (bool) { return approve(spender, _totalSupply); } function transfer(address recipient, uint256 amount) external override returns (bool) { return _transferFrom(msg.sender, recipient, amount); } function transferFrom( address sender, address recipient, uint256 amount ) external override returns (bool) { if (_allowances[sender][msg.sender] != _totalSupply) { _allowances[sender][msg.sender] = _allowances[sender][msg.sender] .sub(amount, "Insufficient Allowance"); } return _transferFrom(sender, recipient, amount); } function _transferFrom( address sender, address recipient, uint256 amount ) internal returns (bool) { if (enableAntiBot) { cronosPadAntiBot.onPreTransferCheck(sender, recipient, amount); } if (inSwap) { return _basicTransfer(sender, recipient, amount); } if (shouldSwapBack()) { swapBack(); } if (shouldAutoBuyback()) { triggerAutoBuyback(); } _balances[sender] = _balances[sender].sub( amount, "Insufficient Balance" ); uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, recipient, amount) : amount; _balances[recipient] = _balances[recipient].add(amountReceived); if (!isDividendExempt[sender]) { try distributor.setShare(sender, _balances[sender]) {} catch {} } if (!isDividendExempt[recipient]) { try distributor.setShare(recipient, _balances[recipient]) {} catch {} } try distributor.process(distributorGas) {} catch {} emit Transfer(sender, recipient, amountReceived); return true; } function _basicTransfer( address sender, address recipient, uint256 amount ) internal returns (bool) { _balances[sender] = _balances[sender].sub( amount, "Insufficient Balance" ); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); return true; } function shouldTakeFee(address sender) internal view returns (bool) { return !isFeeExempt[sender]; } function getTotalFee(bool selling) public view returns (uint256) { if (selling) { return getMultipliedFee(); } return totalFee; } function getMultipliedFee() public view returns (uint256) { if ( buybackMultiplierTriggeredAt.add(buybackMultiplierLength) > block.timestamp ) { uint256 remainingTime = buybackMultiplierTriggeredAt .add(buybackMultiplierLength) .sub(block.timestamp); uint256 feeIncrease = totalFee .mul(buybackMultiplierNumerator) .div(buybackMultiplierDenominator) .sub(totalFee); return totalFee.add( feeIncrease.mul(remainingTime).div(buybackMultiplierLength) ); } return totalFee; } function takeFee( address sender, address receiver, uint256 amount ) internal returns (uint256) { uint256 feeAmount = amount.mul(getTotalFee(receiver == pair)).div( feeDenominator ); _balances[address(this)] = _balances[address(this)].add(feeAmount); emit Transfer(sender, address(this), feeAmount); return amount.sub(feeAmount); } function shouldSwapBack() internal view returns (bool) { return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold; } function swapBack() internal swapping { uint256 dynamicLiquidityFee = isOverLiquified( targetLiquidity, targetLiquidityDenominator ) ? 0 : liquidityFee; uint256 amountToLiquify = swapThreshold .mul(dynamicLiquidityFee) .div(totalFee) .div(2); uint256 amountToSwap = swapThreshold.sub(amountToLiquify); address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WETH(); uint256 balanceBefore = address(this).balance; router.swapExactTokensForETHSupportingFeeOnTransferTokens( amountToSwap, 0, path, address(this), block.timestamp ); uint256 amountBNB = address(this).balance.sub(balanceBefore); uint256 totalBNBFee = totalFee.sub(dynamicLiquidityFee.div(2)); uint256 amountBNBLiquidity = amountBNB .mul(dynamicLiquidityFee) .div(totalBNBFee) .div(2); uint256 amountBNBReflection = amountBNB.mul(reflectionFee).div( totalBNBFee ); uint256 amountBNBMarketing = amountBNB.mul(marketingFee).div( totalBNBFee ); try distributor.deposit{value: amountBNBReflection}() {} catch {} payable(marketingFeeReceiver).transfer(amountBNBMarketing); if (amountToLiquify > 0) { router.addLiquidityETH{value: amountBNBLiquidity}( address(this), amountToLiquify, 0, 0, autoLiquidityReceiver, block.timestamp ); emit AutoLiquify(amountBNBLiquidity, amountToLiquify); } } function shouldAutoBuyback() internal view returns (bool) { return msg.sender != pair && !inSwap && autoBuybackEnabled && autoBuybackBlockLast + autoBuybackBlockPeriod <= block.number && // After N blocks from last buyback address(this).balance >= autoBuybackAmount; } function triggerZeusBuyback(uint256 amount, bool triggerBuybackMultiplier) external authorized { buyTokens(amount, DEAD); if (triggerBuybackMultiplier) { buybackMultiplierTriggeredAt = block.timestamp; emit BuybackMultiplierActive(buybackMultiplierLength); } } function clearBuybackMultiplier() external authorized { buybackMultiplierTriggeredAt = 0; } function triggerAutoBuyback() internal { buyTokens(autoBuybackAmount, DEAD); autoBuybackBlockLast = block.number; autoBuybackAccumulator = autoBuybackAccumulator.add(autoBuybackAmount); if (autoBuybackAccumulator > autoBuybackCap) { autoBuybackEnabled = false; } } function buyTokens(uint256 amount, address to) internal swapping { address[] memory path = new address[](2); path[0] = router.WETH(); path[1] = address(this); router.swapExactETHForTokensSupportingFeeOnTransferTokens{ value: amount }(0, path, to, block.timestamp); } function setAutoBuybackSettings( bool _enabled, uint256 _cap, uint256 _amount, uint256 _period ) external authorized { autoBuybackEnabled = _enabled; autoBuybackCap = _cap; autoBuybackAccumulator = 0; autoBuybackAmount = _amount; autoBuybackBlockPeriod = _period; autoBuybackBlockLast = block.number; } function setBuybackMultiplierSettings( uint256 numerator, uint256 denominator, uint256 length ) external authorized { require(numerator / denominator <= 2 && numerator > denominator); buybackMultiplierNumerator = numerator; buybackMultiplierDenominator = denominator; buybackMultiplierLength = length; } function setIsDividendExempt(address holder, bool exempt) external authorized { require(holder != address(this) && holder != pair); isDividendExempt[holder] = exempt; if (exempt) { distributor.setShare(holder, 0); } else { distributor.setShare(holder, _balances[holder]); } } function setIsFeeExempt(address holder, bool exempt) external authorized { isFeeExempt[holder] = exempt; } function setBuyBacker(address acc, bool add) external authorized { buyBacker[acc] = add; } function setFees( uint256 _liquidityFee, uint256 _buybackFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _feeDenominator ) public authorized { _setFees( _liquidityFee, _buybackFee, _reflectionFee, _marketingFee, _feeDenominator ); } function _setFees( uint256 _liquidityFee, uint256 _buybackFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _feeDenominator ) internal { liquidityFee = _liquidityFee; buybackFee = _buybackFee; reflectionFee = _reflectionFee; marketingFee = _marketingFee; totalFee = _liquidityFee.add(_buybackFee).add(_reflectionFee).add( _marketingFee ); feeDenominator = _feeDenominator; require( totalFee < feeDenominator / 4, "Total fee should not be greater than 1/4 of fee denominator" ); } function setFeeReceivers( address _autoLiquidityReceiver, address _marketingFeeReceiver ) external authorized { autoLiquidityReceiver = _autoLiquidityReceiver; marketingFeeReceiver = _marketingFeeReceiver; } function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized { swapEnabled = _enabled; swapThreshold = _amount; } function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized { targetLiquidity = _target; targetLiquidityDenominator = _denominator; } function setDistributionCriteria( uint256 _minPeriod, uint256 _minDistribution ) external authorized { distributor.setDistributionCriteria(_minPeriod, _minDistribution); } function setDistributorSettings(uint256 gas) external authorized { require(gas < 750000, "Gas must be lower than 750000"); distributorGas = gas; } function getCirculatingSupply() public view returns (uint256) { return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO)); } function getLiquidityBacking(uint256 accuracy) public view returns (uint256) { return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply()); } function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) { return getLiquidityBacking(accuracy) > target; } }
We recommend using flattened code. This is necessary if your code utilizes a library or inherits dependencies. Use the
POA solidity flattener or the
truffle flattener
.
Try to fetch constructor arguments automatically
No
Yes
ABI-encoded Constructor Arguments (if required by the contract)
00000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000001e00000000000000000000000000000000000000000000063508a7b5b80db200000000000000000000000000000b7ddc6414bf4f5515b52d8bdd69973ae205ff1010000000000000000000000006258c967337d3faf0c2ba3adae5656ba95419d5f000000000000000000000000aad608899ed545132cb335c4642ff81411a14bdc00000000000000000000000000000000000000000000000000000000000000c8000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000001f400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000002710000000000000000000000000de28c7c4f0021f165681ff7f1c507d3d1e3a223000000000000000000000000000000000000000000000000d8d726b7177a800000000000000000000000000000000000000000000000000000000000000000008426162796e66747a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004424f575500000000000000000000000000000000000000000000000000000000
Add arguments in
ABI hex encoded form
. Constructor arguments are written right to left, and will be found at the end of the input created bytecode. They may also be
parsed here.
Add Contract Libraries
Contract Libraries
Library Name
A library name called in the .sol file. Multiple libraries (up to 5) may be added for each contract. Click the Add Library button to add an additional one.
Library Address
The 0x library address. This can be found in the generated json file or Truffle output (if using truffle).
Library Name
Library Address
Library Name
Library Address
Library Name
Library Address
Library Name
Library Address
Add Library
Loading...
Verify & publish
Cancel
Ok
Ok
Ok
No
Yes