Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor
Gleiches ausblenden
Zeilenumbruch aus
Ansicht
Vergleichsgenauigkeit
Syntaxhervorhebung

MasterChef

Erstellt Diff läuft nie ab
667 Entfernungen
732 Zeilen
519 Hinzufügungen
596 Zeilen
/**
/**
*Submitted for verification at BscScan.com on 2020-09-22
* Safetoken Fork (added Antiwhale, Antibot, Antidump Fuction) thx to 0f0crypto for a Safetoken rewrite!
*/
*
* SPDX-License-Identifier: MIT
*/
/**
*
* Super Low Liquidity Token
*
💎Super Low Liquidity Token
✅ Total Supply : 100.000.000
✅ Initial Liquidity : 0.2BNB
✅ First Buy Max Transaction Around : 0,002 BNB


pragma solidity 0.6.12;
💎 Fee:
✅ 4% Liquidity
✅ 4% Redistribution
✅ 1% Burn
✅ 1% Tip to the Dev
✅ 5% Whale Only Fee (Only when your balance is > capWhaleWalletBalance)
✅ Max Transaction : 2% From Total Supply (2.000.000)
✅ Max Wallet Balance : 3 times Max Transaction (6.000.000)


💎 AntiWhale
✅ CapWhaleWalletBalance : 80% From Max Wallet Balance (Balance > 48,000,000)


//
💎 AntiBot and Dump
/**
✅ 15 seconds between each transaction per wallet.
* @dev Wrappers over Solidity's arithmetic operations with added overflow
✅ Cant send multiple transaction in one block per wallet.
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @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) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');


return c;
💎 AntiDump
}
✅ Fee Multiplier after release only sell
✅ x2 in 24 hours after released
✅ x1 after 24 hours after released


/**
💎 Security
* @dev Returns the subtraction of two unsigned integers, reverting on
✅ LP Burn 100%
* 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 sub(a, b, 'SafeMath: subtraction overflow');
}


/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;


return c;
}


/**
TG: https://t.me/wolfclaw
* @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) {
// 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 0;
}


uint256 c = a * b;
*/
require(c / a == b, 'SafeMath: multiplication overflow');
pragma solidity ^0.8.4;


return c;
}


/**
* @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}


/**
import "./safetoken-imports.sol";
* @dev Returns the integer division of two unsigned integers. Reverts 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) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold


return c;
/**
}
* @dev If I did a good job you should not need to change anything apart from the values in the `Tokenomics`,
* the actual name of the contract `SafeTokenV1Beta` at the very bottom **and** the `environment` into which
* you are deploying the contract `SafeToken(Env.Testnet)` or `SafeToken(Env.MainnetV2)` etc.
*
* If you wish to disable a particular tax/fee just set it to zero (or comment it out/remove it).
*
* You can add (in theory) as many custom taxes/fees with dedicated wallet addresses if you want.
* Nevertheless, I do not recommend using more than a few as the contract has not been tested
* for more than the original number of taxes/fees, which is 6 (liquidity, redistribution, burn,
* marketing, charity & tip to the dev). Furthermore, exchanges may impose a limit on the total
* transaction fee (so that, for example, you cannot claim 100%). Usually this is done by limiting the
* max value of slippage, for example, PancakeSwap max slippage is 49.9% and the fees total of more than
* 35% will most likely fail there.
*
* NOTE: You shouldn't really remove the Rfi fee. If you do not wish to use RFI for your token,
* you shouldn't be using this contract at all (you're just wasting gas if you do).
*
* NOTE: ignore the note below (anti-whale mech is not implemented yet)
* If you wish to modify the anti-whale mech (progressive taxation) it will require a bit of coding.
* I tried to make the integration as simple as possible via the `Antiwhale` contract, so the devs
* know exactly where to look and what/how to make the necessary changes. There are many possibilites,
* such as modifying the fees based on the tx amount (as % of TOTAL_SUPPLY), or sender's wallet balance
* (as % of TOTAL_SUPPLY), including (but not limited to):
* - progressive taxation by tax brackets (e.g <1%, 1-2%, 2-5%, 5-10%)
* - progressive taxation by the % over a threshold (e.g. 1%)
* - extra fee (e.g. double) over a threshold
*/
abstract contract Tokenomics {
using SafeMath for uint256;
// --------------------- Token Settings ------------------- //


string internal constant NAME = "GoldenWspp";
string internal constant SYMBOL = "GWSPP";
uint16 internal constant FEES_DIVISOR = 10**3;
uint8 internal constant DECIMALS = 6;
uint256 internal constant ZEROES = 10**DECIMALS;
uint256 private constant MAX = ~uint256(0);
uint256 internal constant TOTAL_SUPPLY = ZEROES;
uint256 internal _reflectedSupply = (MAX - (MAX % TOTAL_SUPPLY));
uint internal TIME_LIMIT_TRANSACTION = 15 seconds;
uint internal TimeContractStart = block.timestamp;
bool internal ANTI_DUMP_MULTIPLAYER = true;
/**
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* @dev Set the maximum transaction amount allowed in a transfer.
* Reverts when dividing by zero.
*
*
* The default value is 1% of the total supply.
* Counterpart to Solidity's `%` operator. This function uses a `revert`
*
* opcode (which leaves remaining gas untouched) while Solidity uses an
* NOTE: set the value to `TOTAL_SUPPLY` to have an unlimited max, i.e.
* invalid opcode to revert (consuming all remaining gas).
* `maxTransactionAmount = TOTAL_SUPPLY;`
*
* Requirements:
*
* - The divisor cannot be zero.
*/
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 internal constant maxTransactionAmount = (TOTAL_SUPPLY / 100); // 2% of the total supply
return mod(a, b, 'SafeMath: modulo by zero');
}

/**
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* @dev Set the maximum allowed balance in a wallet.
* Reverts with custom message when dividing by zero.
*
*
* The default value is 2% of the total supply.
* Counterpart to Solidity's `%` operator. This function uses a `revert`
*
* opcode (which leaves remaining gas untouched) while Solidity uses an
* NOTE: set the value to 0 to have an unlimited max.
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
*
* - The divisor cannot be zero.
* IMPORTANT: This value MUST be greater than `numberOfTokensToSwapToLiquidity` set below,
*/
* otherwise the liquidity swap will never be executed
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}

function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}

// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}

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

/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);

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

/**
* @dev Returns the token name.
*/
*/
function name() external view returns (string memory);
uint256 internal maxWalletBalance = maxTransactionAmount * 3; // 10 * maxTransactionAmount


/**
/**
* @dev Returns the bep token owner.
* @dev Set the Cap balance in a wallet to identification Whale.
*
* The default value is 75% of the maxWalletBalance.
*
* NOTE: set the value to maxWalletBalance to disable.
*
* IMPORTANT: This value MUST be greater than `numberOfTokensToSwapToLiquidity` set below,
* otherwise the liquidity swap will never be executed
*/
*/
function getOwner() external view returns (address);
uint16 internal constant WHALE_FEE_IN_PERCENT = 50;

uint256 internal capWhaleWalletBalance = (80 * maxWalletBalance) / 100; // 80% of the maxWalletBalance
/**
/**
* @dev Returns the amount of tokens owned by `account`.
* @dev Set the number of tokens to swap and add to liquidity.
*
* Whenever the contract's balance reaches this number of tokens, swap & liquify will be
* executed in the very next transfer (via the `_beforeTokenTransfer`)
*
* If the `FeeType.Liquidity` is enabled in `FeesSettings`, the given % of each transaction will be first
* sent to the contract address. Once the contract's balance reaches `numberOfTokensToSwapToLiquidity` the
* `swapAndLiquify` of `Liquifier` will be executed. Half of the tokens will be swapped for ETH
* (or BNB on BSC) and together with the other half converted into a Token-ETH/Token-BNB LP Token.
*
* See: `Liquifier`
*/
*/
function balanceOf(address account) external view returns (uint256);
uint256 internal constant numberOfTokensToSwapToLiquidity = TOTAL_SUPPLY / 1000; // 0.1% of the total supply


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


/**
/**
* @dev Returns the remaining number of tokens that `spender` will be
* @dev To add/edit/remove fees scroll down to the `addFees` function below
* 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 `amount` as the allowance of `spender` over the caller's tokens.
* @dev You can change the value of the burn address to pretty much anything
*
* that's (clearly) a non-random address, i.e. for which the probability of
* Returns a boolean value indicating whether the operation succeeded.
* someone having the private key is (virtually) 0. For example, 0x00.....1,
* 0x111...111, 0x12345.....12345, etc.
*
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* NOTE: This does NOT need to be the zero address, adress(0) = 0x000...000;
* 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.
* Trasfering tokens to the burn address is good for optics/marketing. Nevertheless
*/
* if the burn address is excluded from rewards (unlike in Safemoon), sending tokens
function approve(address spender, uint256 amount) external returns (bool);
* to the burn address actually improves redistribution to holders (as they will

* have a larger % of tokens in non-excluded accounts)
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
*
* Returns a boolean value indicating whether the operation succeeded.
* p.s. the address below is the speed of light in vacuum in m/s (expressed in decimals),
* the hex value is 0x0000000000000000000000000000000011dE784A; :)
*
*
* Emits a {Transfer} event.
* Here are the values of some other fundamental constants to use:
* 0x0000000000000000000000000000000602214076 (Avogardo constant)
* 0x0000000000000000000000000000000001380649 (Boltzmann constant)
* 0x2718281828459045235360287471352662497757 (e)
* 0x0000000000000000000000000000001602176634 (elementary charge)
* 0x0000000000000000000000000200231930436256 (electron g-factor)
* 0x0000000000000000000000000000091093837015 (electron mass)
* 0x0000000000000000000000000000137035999084 (fine structure constant)
* 0x0577215664901532860606512090082402431042 (Euler-Mascheroni constant)
* 0x1618033988749894848204586834365638117720 (golden ratio)
* 0x0000000000000000000000000000009192631770 (hyperfine transition fq)
* 0x0000000000000000000000000000010011659208 (muom g-2)
* 0x3141592653589793238462643383279502884197 (pi)
* 0x0000000000000000000000000000000662607015 (Planck's constant)
* 0x0000000000000000000000000000001054571817 (reduced Planck's constant)
* 0x1414213562373095048801688724209698078569 (sqrt(2))
*/
*/
function transferFrom(
address internal burnAddress = 0x000000000000000000000000000000000000dEaD;
address sender,
address recipient,
uint256 amount
) external returns (bool);


/**
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* @dev You can disable this but if you feel generous I'd appreciate the 0.1%
* another (`to`).
* donation for rewriting Safemoon and making everyone's life a little easier
*
*
* Note that `value` may be zero.
* If you keep this tip enabled, let me know in Discord: https://discord.gg/zn86MDCQcM
*/
* and you'll be added to the partners section to promote your token.
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);
address internal tipToTheDev = 0x5fd3d666afA636dD70A9d33Ef20799aa53DcbB37;
}


//
enum FeeType { Antiwhale, Burn, Liquidity, Rfi, External, ExternalToETH }
/**
struct Fee {
* @dev Collection of functions related to the address type
FeeType name;
*/
uint256 value;
library Address {
address recipient;
/**
uint256 total;
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
}


/**
Fee[] internal fees;
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
uint256 internal sumOfFees;
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');


// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
constructor() {
(bool success, ) = recipient.call{value: amount}('');
_addFees();
require(success, 'Address: unable to send value, recipient may have reverted');
}
}


/**
function _addFee(FeeType name, uint256 value, address recipient) private {
* @dev Performs a Solidity function call using a low level `call`. A
fees.push( Fee(name, value, recipient, 0 ) );
* plain`call` is an unsafe replacement for a function call: use this
sumOfFees += value;
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
}


/**
function _addFees() private {
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with

* `errorMessage` as a fallback revert reason when `target` reverts.
/**
*
* The RFI recipient is ignored but we need to give a valid address value
* _Available since v3.1._
*
*/
* CAUTION: If you don't want to use RFI this implementation isn't really for you!
function functionCall(
* There are much more efficient and cleaner token contracts without RFI
address target,
* so you should use one of those
bytes memory data,
*
string memory errorMessage
* The value of fees is given in part per 1000 (based on the value of FEES_DIVISOR),
) internal returns (bytes memory) {
* e.g. for 5% use 50, for 3.5% use 35, etc.
return _functionCallWithValue(target, data, 0, errorMessage);
*/
_addFee(FeeType.Rfi, 40, address(this) ); // 4% Redistribute to holders
_addFee(FeeType.Burn, 10, burnAddress ); // 1% Burn
_addFee(FeeType.Liquidity, 40, address(this) ); // 4% added to liquidity
_addFee(FeeType.ExternalToETH, 10, tipToTheDev ); // 1% Tips to the Dev
_addFee(FeeType.Antiwhale, WHALE_FEE_IN_PERCENT, tipToTheDev ); // 5% if you have balance more than capWhaleWalletBalance
}
}


/**
function _getFeesCount() internal view returns (uint256){ return fees.length; }
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],

* but also transferring `value` wei to `target`.
function _getFeeStruct(uint256 index) private view returns(Fee storage){
*
require( index >= 0 && index < fees.length, "FeesSettings._getFeeStruct: Fee index out of bounds");
* Requirements:
return fees[index];
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
}

function _getFee(uint256 index) internal view returns (FeeType, uint256, address, uint256){
/**
Fee memory fee = _getFeeStruct(index);
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
return ( fee.name, fee.value, fee.recipient, fee.total );
* with `errorMessage` as a fallback revert reason when `target` reverts.
}
*
function _addFeeCollectedAmount(uint256 index, uint256 amount) internal {
* _Available since v3.1._
Fee storage fee = _getFeeStruct(index);
*/
fee.total = fee.total.add(amount);
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
}


function _functionCallWithValue(
// function getCollectedFeeTotal(uint256 index) external view returns (uint256){
address target,
function getCollectedFeeTotal(uint256 index) internal view returns (uint256){
bytes memory data,
Fee memory fee = _getFeeStruct(index);
uint256 weiValue,
return fee.total;
string memory errorMessage
}
) private returns (bytes memory) {
}
require(isContract(target), 'Address: call to non-contract');

// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly


// solhint-disable-next-line no-inline-assembly
abstract contract Presaleable is Manageable {
assembly {
bool internal isInPresale;
let returndata_size := mload(returndata)
function setPreseableEnabled(bool value) external onlyManager {
revert(add(32, returndata), returndata_size)
isInPresale = value;
}
} else {
revert(errorMessage);
}
}
}
}
}
}


//
abstract contract BaseRfiToken is IERC20, IERC20Metadata, Ownable, Presaleable, Tokenomics {
/**

* @title SafeBEP20
* @dev Wrappers around BEP20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeBEP20 {
using SafeMath for uint256;
using SafeMath for uint256;
using Address for address;
using Address for address;


function safeTransfer(
mapping (address => uint256) internal _reflectedBalances;
IBEP20 token,
mapping (address => uint256) internal _balances;
address to,
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 value
) internal {
mapping (address => bool) internal _isExcludedFromFee;
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
mapping (address => bool) internal _isExcludedFromRewards;
}
address[] private _excluded;
constructor() {
_reflectedBalances[owner()] = _reflectedSupply;
// exclude owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
// exclude the owner and this contract from rewards
_exclude(owner());
_exclude(address(this));


function safeTransferFrom(
emit Transfer(address(0), owner(), TOTAL_SUPPLY);
IBEP20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
}
/** Functions required by IERC20Metadat **/
function name() external pure override returns (string memory) { return NAME; }
function symbol() external pure override returns (string memory) { return SYMBOL; }
function decimals() external pure override returns (uint8) { return DECIMALS; }
/** Functions required by IERC20Metadat - END **/
/** Functions required by IERC20 **/
function totalSupply() external pure override returns (uint256) {
return TOTAL_SUPPLY;
}
function balanceOf(address account) public view override returns (uint256){
if (_isExcludedFromRewards[account]) return _balances[account];
return tokenFromReflection(_reflectedBalances[account]);
}
function transfer(address recipient, uint256 amount) external override returns (bool){
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256){
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function getAddressLastTransaction(address owner ) external view returns(uint)
{
return _getLastTransaction(owner);
}
function getContractStartTime() external view returns(uint){
return TimeContractStart;
}
function setTimeLimitTransaction(uint inSecond) external onlyManager{
TIME_LIMIT_TRANSACTION = inSecond;
}
function getTimeLimitTransaction() external view returns(uint) {
return TIME_LIMIT_TRANSACTION;
}
function setMaxWalletBalance(uint256 amount) external onlyManager{
maxWalletBalance = amount;
}
function getMaxWalletBalance() external view returns(uint256)
{
return maxWalletBalance;
}
function setCapWhaleWalletBalance(uint256 amount) external onlyManager{
capWhaleWalletBalance = amount;
}
function getCapWhaleWalletBalance() external view returns(uint256)
{
return capWhaleWalletBalance;
}
function setIsAntiDump(bool isActive) external onlyManager{
ANTI_DUMP_MULTIPLAYER = isActive;
}
function getAntiDump() external view returns(bool)
{
return ANTI_DUMP_MULTIPLAYER;
}
function checkAddress(address checkAdd) external view returns(uint256)
{
return _getLastTransaction(checkAdd);
}
function checkAddress2(address checkAdd) external view returns(uint256)
{
return _getLastBlock(checkAdd);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool){
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
/** Functions required by IERC20 - END **/


/**
/**
* @dev Deprecated. This function has issues similar to the ones found in
* @dev this is really a "soft" burn (total supply is not reduced). RFI holders
* {IBEP20-approve}, and its usage is discouraged.
* get two benefits from burning tokens:
*
*
* Whenever possible, use {safeIncreaseAllowance} and
* 1) Tokens in the burn address increase the % of tokens held by holders not
* {safeDecreaseAllowance} instead.
* excluded from rewards (assuming the burn address is excluded)
* 2) Tokens in the burn address cannot be sold (which in turn draing the
* liquidity pool)
*
*
* In RFI holders already get % of each transaction so the value of their tokens
* increases (in a way). Therefore there is really no need to do a "hard" burn
* (reduce the total supply). What matters (in RFI) is to make sure that a large
* amount of tokens cannot be sold = draining the liquidity pool = lowering the
* value of tokens holders own. For this purpose, transfering tokens to a (vanity)
* burn address is the most appropriate way to "burn".
*
* There is an extra check placed into the `transfer` function to make sure the
* burn address cannot withdraw the tokens is has (although the chance of someone
* having/finding the private key is virtually zero).
*/
*/
function safeApprove(
function burn(uint256 amount) external {
IBEP20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance'
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}


function safeIncreaseAllowance(
address sender = _msgSender();
IBEP20 token,
require(sender != address(0), "BaseRfiToken: burn from the zero address");
address spender,
require(sender != address(burnAddress), "BaseRfiToken: burn from the burn address");
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}


function safeDecreaseAllowance(
uint256 balance = balanceOf(sender);
IBEP20 token,
require(balance >= amount, "BaseRfiToken: burn amount exceeds balance");
address spender,

uint256 value
uint256 reflectedAmount = amount.mul(_getCurrentRate());
) internal {

uint256 newAllowance = token.allowance(address(this), spender).sub(
// remove the amount from the sender's balance first
value,
_reflectedBalances[sender] = _reflectedBalances[sender].sub(reflectedAmount);
'SafeBEP20: decreased allowance below zero'
if (_isExcludedFromRewards[sender])
);
_balances[sender] = _balances[sender].sub(amount);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));

_burnTokens( sender, amount, reflectedAmount );
}
}

/**
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* @dev "Soft" burns the specified amount of tokens by sending them
* on the return value: the return value is optional (but if data is returned, it must not be false).
* to the burn address
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
*/
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
function _burnTokens(address sender, uint256 tBurn, uint256 rBurn) internal {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.

bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}


//
/**
/*
* @dev Do not reduce _totalSupply and/or _reflectedSupply. (soft) burning by sending
* @dev Provides information about the current execution context, including the
* tokens to the burn address (which should be excluded from rewards) is sufficient
* sender of the transaction and its data. While these are generally available
* in RFI
* via msg.sender and msg.data, they should not be accessed in such a direct
*/
* manner, since when dealing with GSN meta-transactions the account sending and
_reflectedBalances[burnAddress] = _reflectedBalances[burnAddress].add(rBurn);
* paying for execution may not be the actual sender (as far as an application
if (_isExcludedFromRewards[burnAddress])
* is concerned).
_balances[burnAddress] = _balances[burnAddress].add(tBurn);
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}


function _msgSender() internal view returns (address payable) {
/**
return msg.sender;
* @dev Emit the event so that the burn address balance is updated (on bscscan)
*/
emit Transfer(sender, burnAddress, tBurn);
}
}


function _msgData() internal view returns (bytes memory) {
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return msg.data;
return true;
}
}
}

function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
//
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
/**
return true;
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
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() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
}

/**
function isExcludedFromReward(address account) external view returns (bool) {
* @dev Returns the address of the current owner.
return _isExcludedFromRewards[account];
*/
function owner() public view returns (address) {
return _owner;
}
}


/**
/**
* @dev Throws if called by any account other than the owner.
* @dev Calculates and returns the reflected amount for the given amount with or without
* the transfer fees (deductTransferFee true/false)
*/
*/
modifier onlyOwner() {
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) external view returns(uint256) {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
require(tAmount <= TOTAL_SUPPLY, "Amount must be less than supply");
_;
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount,0);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount,_getSumOfFees(_msgSender(), tAmount));
return rTransferAmount;
}
}
}


/**
/**
* @dev Leaves the contract without owner. It will not be possible to call
* @dev Calculates and returns the amount of tokens corresponding to the given reflected amount.
* `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 onlyOwner {
function tokenFromReflection(uint256 rAmount) internal view returns(uint256) {
emit OwnershipTransferred(_owner, address(0));
require(rAmount <= _reflectedSupply, "Amount must be less than total reflections");
_owner = address(0);
uint256 currentRate = _getCurrentRate();
return rAmount.div(currentRate);
}
}

/**
function excludeFromReward(address account) external onlyOwner() {
* @dev Transfers ownership of the contract to a new account (`newOwner`).
require(!_isExcludedFromRewards[account], "Account is not included");
* Can only be called by the current owner.
_exclude(account);
*/
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
}

/**
function _exclude(address account) internal {
* @dev Transfers ownership of the contract to a new account (`newOwner`).
if(_reflectedBalances[account] > 0) {
*/
_balances[account] = tokenFromReflection(_reflectedBalances[account]);
function _transferOwnership(address newOwner) internal {
}
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_isExcludedFromRewards[account] = true;
emit OwnershipTransferred(_owner, newOwner);
_excluded.push(account);
_owner = newOwner;
}
}
}

//
/**
* @dev Implementation of the {IBEP20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {BEP20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-BEP20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of BEP20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IBEP20-approve}.
*/
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;

mapping(address => uint256) private _balances;

mapping(address => mapping(address => uint256)) private _allowances;

uint256 private _totalSupply;

string private _name;
string private _symbol;
uint8 private _decimals;


/**
function includeInReward(address account) external onlyOwner() {
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
require(_isExcludedFromRewards[account], "Account is not excluded");
* a default value of 18.
for (uint256 i = 0; i < _excluded.length; i++) {
*
if (_excluded[i] == account) {
* To select a different value for {decimals}, use {_setupDecimals}.
_excluded[i] = _excluded[_excluded.length - 1];
*
_balances[account] = 0;
* All three of these values are immutable: they can only be set once during
_isExcludedFromRewards[account] = false;
* construction.
_excluded.pop();
*/
break;
constructor(string memory name, string memory symbol) public {
}
_name = name;
}
_symbol = symbol;
_decimals = 18;
}
}
function setExcludedFromFee(address account, bool value) external onlyOwner { _isExcludedFromFee[account] = value; }
function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BaseRfiToken: approve from the zero address");
require(spender != address(0), "BaseRfiToken: approve to the zero address");


/**
_allowances[owner][spender] = amount;
* @dev Returns the bep token owner.
emit Approval(owner, spender, amount);
*/
function getOwner() external override view returns (address) {
return owner();
}
}

/**
/**
* @dev Returns the token name.
*/
*/
function name() public override view returns (string memory) {
function _isUnlimitedSender(address account) internal view returns(bool){
return _name;
// the owner should be the only whitelisted sender
return (account == owner());
}
}

/**
/**
* @dev Returns the token decimals.
*/
*/
function decimals() public override view returns (uint8) {
function _isUnlimitedRecipient(address account) internal view returns(bool){
return _decimals;
// the owner should be a white-listed recipient
// and anyone should be able to burn as many tokens as
// he/she wants
return (account == owner() || account == burnAddress);
}
}


/**
function _transfer(address sender, address recipient, uint256 amount) private {
* @dev Returns the token symbol.
require(sender != address(0), "BaseRfiToken: transfer from the zero address");
*/
require(recipient != address(0), "BaseRfiToken: transfer to the zero address");
function symbol() public override view returns (string memory) {
require(sender != address(burnAddress), "BaseRfiToken: transfer from the burn address");
return _symbol;
require(amount > 0, "Transfer amount must be greater than zero");
}
// indicates whether or not feee should be deducted from the transfer
bool takeFee = true;


/**
if ( isInPresale ){ takeFee = false; }
* @dev See {BEP20-totalSupply}.
else {
*/
/**
function totalSupply() public override view returns (uint256) {
* Check the amount is within the max allowed limit as long as a
return _totalSupply;
* unlimited sender/recepient is not involved in the transaction
*/
if ( amount > maxTransactionAmount && !_isUnlimitedSender(sender) && !_isUnlimitedRecipient(recipient) ){
revert("Transfer amount exceeds the maxTxAmount.");
}
/**
* The pair needs to excluded from the max wallet balance check;
* selling tokens is sending them back to the pair (without this
* check, selling tokens would not work if the pair's balance
* was over the allowed max)
*
* Note: This does NOT take into account the fees which will be deducted
* from the amount. As such it could be a bit confusing
*/
if ( maxWalletBalance > 0 && !_isUnlimitedSender(sender) && !_isUnlimitedRecipient(recipient) && !_isV2Pair(recipient)){
uint256 recipientBalance = balanceOf(recipient);
require(recipientBalance + amount <= maxWalletBalance, "New balance would exceed the maxWalletBalance");
}
if(TIME_LIMIT_TRANSACTION > 0 && !_isUnlimitedSender(sender) && !_isUnlimitedRecipient(recipient) && sender != address(this))
{
//AntiBot Using Block Check
require(block.number > _getLastBlock(tx.origin), "You cant send more than one transaction in one block.");
_setLastBlock(tx.origin);
//AntiBot Using Time Between Transaction
if(_getLastTransaction(tx.origin) > 0)
{
require(_getLastTransaction(tx.origin) <= block.timestamp, "You need to wait TIME_LIMIT_TRANSACTION before perform another transaction.");
}
_setLastTransaction(tx.origin);
}
}
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){ takeFee = false; }

_beforeTokenTransfer(sender, recipient, amount, takeFee);
_transferTokens(sender, recipient, amount, takeFee);
}
}


/*
func
Gespeicherte Diffs