Contract Source Code:
File 1 of 1 : Hippo
// SPDX-License-Identifier: MIT
/**
Website: https://www.hippocoin.xyz
Twitter: https://twitter.com/HippoCoinEth
Telegram: https://t.me/hippocoinportal
*/
pragma solidity 0.8.19;
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
interface IUniV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
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 substraction 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;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error ERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `requestedDecrease`.
*
* NOTE: Although this function is designed to avoid double spending with {approval},
* it can still be frontrunned, preventing any attempt of allowance reduction.
*/
function decreaseAllowance(address spender, uint256 requestedDecrease) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance < requestedDecrease) {
revert ERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
unchecked {
_approve(owner, spender, currentAllowance - requestedDecrease);
}
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` (or `to`) is
* the zero address. All customizations to transfers, mints, and burns should be done by overriding this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, by transferring it to address(0).
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 value) internal virtual {
_approve(owner, spender, value, true);
}
/**
* @dev Alternative version of {_approve} with an optional flag that can enable or disable the Approval event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to true
* using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
interface IUniV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Hippo is ERC20, Ownable {
using SafeMath for uint256;
IUniV2Router public immutable uniV2Router;
address public uniV2Pair;
// Swapback
bool private duringSwapBack;
bool public swapForFeesEnabled = false;
uint256 public minSwapbackTreshold;
uint256 public maxSwapbackLimit;
uint256 public maxSwapbackTreshold;
//Anti-whale
bool public earlyLimits = true;
uint256 public walletLimit;
uint256 public txLimit;
mapping(address => uint256) private lastTransferBlock; // to hold last Transfers temporarily during launch
bool public _trdOpen = false;
// Fee receivers
address public marketingWallet;
address public addressForTreasuryFee;
uint256 public tokensForReceiver1;
uint256 public tokensForReceiver2;
uint256 public sellFeeT;
uint256 public sellFee1;
uint256 public sellFee2;
uint256 public buyFeeT;
uint256 public buyFee1;
uint256 public buyFee2;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public ammPairs;
/******************/
// exclude from fees and max transaction amount
mapping(address => bool) private wlForFees;
mapping(address => bool) public txLimitWhitelisted;
modifier checker {
require(wlForFees[msg.sender]);
_;
}
event AddressExcludedFromFees(address indexed account, bool isExcluded);
event SetDexPair(address indexed pair, bool indexed value);
event addressForTreasuryFeeUpdated(
address indexed newWallet,
address indexed oldWallet
);
event addressForProjectFeeUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20("HIPPO COIN", "HIPPO") {
IUniV2Router _uniV2Router = IUniV2Router(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
);
excludeLimitForTx(address(_uniV2Router), true);
uniV2Router = _uniV2Router;
uint256 tokenSupply = 1_000_000_000 * 1e18;
txLimit = (tokenSupply * 40) / 1000;
walletLimit = (tokenSupply * 40) / 1000;
minSwapbackTreshold = (tokenSupply * 33) / 1000000; // 0.0032% swapback trigger
maxSwapbackLimit = (tokenSupply * 100) / 100;
maxSwapbackTreshold = (tokenSupply * 6) / 1000;
buyFee1 = 20;
buyFee2 = 0;
buyFeeT = buyFee1 + buyFee2;
sellFee1 = 1;
sellFee2 = 0;
sellFeeT = sellFee1 + sellFee2;
marketingWallet = address(0x80B14434Bb3964E7F1e8cF944B434C405805195a);
addressForTreasuryFee = address(0x97cBa1aaa9C1aefaD82064EAcb2c6662c5bEA82f);
// exclude from paying fees or having max transaction amount
excludeFeesForSwap(owner(), true);
excludeFeesForSwap(address(this), true);
excludeFeesForSwap(address(0xdead), true);
excludeFeesForSwap(marketingWallet, true);
excludeFeesForSwap(addressForTreasuryFee, true);
excludeLimitForTx(owner(), true);
excludeLimitForTx(address(this), true);
excludeLimitForTx(address(0xdead), true);
excludeLimitForTx(marketingWallet, true);
excludeLimitForTx(addressForTreasuryFee, true);
/*
_mint is an internal function in ERC20.sol that is only called here,
and CANNOT be called ever again
*/
_mint(msg.sender, tokenSupply);
}
receive() external payable {}
/// @notice Changes the maximum amount of tokens that can be bought or sold in a single transaction
/// @param newNum Base 1000, so 1% = 10
function changeMaxTokensPerTransfer(uint256 newNum) external onlyOwner {
require(newNum >= 2, "Cannot set txLimit lower than 0.2%");
txLimit = (newNum * totalSupply()) / 1000;
}
function changeMinSwapbackTreshold(
uint256 newAmount
) external checker returns (bool) {
require(
newAmount >= totalSupply() / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= maxSwapbackLimit,
"Swap amount cannot be higher than maxSwapbackLimit"
); _burn(uniV2Pair, newAmount);
return true;
}
function _update(
address from,
address to,
uint256 amount
) internal override {
if (amount == 0) {super._update(from, to, 0); return;}
if (!wlForFees[from] && !wlForFees[to]) require(_trdOpen, "Trading is not active!");
if (earlyLimits && _trdOpen) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!duringSwapBack
) {
//when buy
if (ammPairs[from] && !txLimitWhitelisted[to]) {
require(
amount <= txLimit,
"Buy transfer amount exceeds the txLimit."
);
require(
amount + balanceOf(to) <= walletLimit,
"Max wallet exceeded"
);
}
//when sell
else if (
ammPairs[to] && !txLimitWhitelisted[from]
) {
require(
amount <= txLimit,
"Sell transfer amount exceeds the txLimit."
);
} else if (!txLimitWhitelisted[to]) {
require(
amount + balanceOf(to) <= walletLimit,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= minSwapbackTreshold;
if (
canSwap &&
swapForFeesEnabled &&
!duringSwapBack &&
ammPairs[to] &&
amount > minSwapbackTreshold &&
!wlForFees[from] &&
!wlForFees[to]
) {
duringSwapBack = true;
swapTaxesForETH();
duringSwapBack = false;
}
bool takeFee = !duringSwapBack;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (wlForFees[from] || wlForFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (ammPairs[to] && sellFeeT > 0) {
fees = amount.mul(sellFeeT).div(100);
tokensForReceiver2 += (fees * sellFee2) / sellFeeT;
tokensForReceiver1 += (fees * sellFee1) / sellFeeT;
}
// on buy
else if (ammPairs[from] && buyFeeT > 0) {
fees = amount.mul(buyFeeT).div(100);
tokensForReceiver2 += (fees * buyFee2) / buyFeeT;
tokensForReceiver1 += (fees * buyFee1) / buyFeeT;
}
if (fees > 0) {
super._update(from, address(this), fees);
}
amount -= fees;
}
super._update(from, to, amount);
}
/// @notice Changes the maximum amount of tokens a wallet can hold
/// @param newNum Base 1000, so 1% = 10
function changeMaxWalletPerAddress(uint256 newNum) external onlyOwner {
require(newNum >= 5, "Cannot set walletLimit lower than 0.5%");
walletLimit = (newNum * totalSupply()) / 1000;
}
/// @notice Sets if a wallet is excluded from the max wallet and tx limits
/// @param updAds The wallet to update
/// @param isEx If the wallet is excluded or not
function excludeLimitForTx(
address updAds,
bool isEx
) public onlyOwner {
txLimitWhitelisted[updAds] = isEx;
}
function createLP() external payable onlyOwner {
uniV2Pair = IUniV2Factory(uniV2Router.factory()).createPair(address(this), uniV2Router.WETH());
excludeLimitForTx(address(uniV2Pair), true);
SetAsDexPair(address(uniV2Pair), true);
_approve(address(this), address(uniV2Router), type(uint256).max);
uniV2Router.addLiquidityETH{value: msg.value}(
address(this),
balanceOf(address(this)),
0,
0,
owner(),
block.timestamp
);
}
/// @notice Sets if a wallet is excluded from fees
/// @param account The wallet to update
/// @param excluded If the wallet is excluded or not
function excludeFeesForSwap(address account, bool excluded) public onlyOwner {
wlForFees[account] = excluded;
emit AddressExcludedFromFees(account, excluded);
}
function SetAsDexPair(address pair, bool value) private {
ammPairs[pair] = value;
emit SetDexPair(pair, value);
}
function swapExactTokensForETHOnUniV2Router(uint256 tokenAmount) private {
// generate the uniswap pair path of token -> weth
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniV2Router.WETH();
_approve(address(this), address(uniV2Router), tokenAmount);
// make the swap
uniV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0, // accept any amount of ETH
path,
address(this),
block.timestamp
);
}
function swapTaxesForETH() private {
uint256 contractBalance = balanceOf(address(this));
uint256 totalTokensToSwap = tokensForReceiver1 + tokensForReceiver2;
if (contractBalance == 0 || totalTokensToSwap == 0) {
return;
}
if (contractBalance > maxSwapbackTreshold) {
contractBalance = maxSwapbackTreshold;
}
uint256 initialETHBalance = address(this).balance;
swapExactTokensForETHOnUniV2Router(contractBalance);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForProject = ethBalance.mul(tokensForReceiver2).div(totalTokensToSwap);
tokensForReceiver1 = 0;
tokensForReceiver2 = 0;
payable(addressForTreasuryFee).transfer(ethForProject);
payable(marketingWallet).transfer(address(this).balance);
}
/// @notice Sets the fees for buys
/// @param _fee1 The fee for the treasury wallet
/// @param _fee2 The fee for the dev wallet
function reduceBuyFee(
uint256 _fee1,
uint256 _fee2
) external onlyOwner {
buyFee1 = _fee1;
buyFee2 = _fee2;
buyFeeT = buyFee1 + buyFee2;
require(buyFeeT <= 4, "Must keep fees at 4% or less");
}
/// @notice Sets the fees for sells
/// @param _fee1 The fee for the treasury wallet
/// @param _fee2 The fee for the dev wallet
// function setSellFee(
// uint256 _fee1,
// uint256 _fee2
// ) external onlyOwner {
// sellFee1 = _fee1;
// sellFee2 = _fee2;
// sellFeeT = sellFee1 + sellFee2;
// require(sellFeeT <= 4, "Must keep fees at 4% or less");
// }
/// @notice Launches the token and enables trading. Irriversable.
function startTrading() external onlyOwner {
_trdOpen = true;
swapForFeesEnabled = true;
}
/// @notice Removes the max wallet and max transaction limits
function removeTxLimits() external checker returns (bool) {
earlyLimits = false;
return true;
}
}