Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live
Ocultar espacios en blanco
Ocultar sin cambios
Sin ajuste de línea
Vista
Nivel de detalle
Estilos de texto
Resaltado de sintaxis

MasterChef

Creado El diff nunca expira
644 eliminaciones
732 líneas
548 adiciones
596 líneas
/**
*Submitted for verification at BscScan.com on 2020-09-22
*/

pragma solidity 0.6.12;


//
/**
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* Safetoken Fork (added Antiwhale, Antibot, Antidump Fuction) thx to 0f0crypto for a Safetoken rewrite!
* 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
* SPDX-License-Identifier: MIT
* 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;
}

/**
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
*
* Requirements:
* Super Low Liquidity Token
*
*
* - Subtraction cannot overflow.
💎Super Low Liquidity Token
✅ Total Supply : 100.000.000
✅ Initial Liquidity : 0.2BNB
✅ First Buy Max Transaction Around : 0,002 BNB

💎 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.
✅ Cant send multiple transaction in one block per wallet.

💎 AntiDump
✅ Fee Multiplier after release only sell
✅ x2 in 24 hours after released
✅ x1 after 24 hours after released

💎 Security
✅ LP Burn 100%



TG: https://t.me/wolfclaw

*/
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
pragma solidity ^0.8.4;
}



import "./safetoken-imports.sol";


/**
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* @dev If I did a good job you should not need to change anything apart from the values in the `Tokenomics`,
* overflow (when the result is negative).
* 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.
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
*
* - Subtraction cannot overflow.
* If you wish to disable a particular tax/fee just set it to zero (or comment it out/remove it).
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;

return c;
}

/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
*
* Counterpart to Solidity's `*` operator.
* 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.
*
*
* Requirements:
* 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).
*
*
* - Multiplication cannot overflow.
* 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
*/
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
abstract contract Tokenomics {
// 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;
using SafeMath for uint256;
require(c / a == b, 'SafeMath: multiplication overflow');
// --------------------- Token Settings ------------------- //


return c;
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 integer division of two unsigned integers. Reverts on
* @dev Set the maximum transaction amount allowed in a transfer.
* 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 default value is 1% of the total supply.
*
*
* - The divisor cannot be zero.
* NOTE: set the value to `TOTAL_SUPPLY` to have an unlimited max, i.e.
* `maxTransactionAmount = TOTAL_SUPPLY;`
*/
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 internal constant maxTransactionAmount = (TOTAL_SUPPLY / 100); // 2% of the total supply
return div(a, b, 'SafeMath: division by zero');
}

/**
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* @dev Set the maximum allowed balance in a wallet.
* division by zero. The result is rounded towards zero.
*
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* The default value is 2% of the total supply.
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
*
* Requirements:
* NOTE: set the value to 0 to have an unlimited max.
*
*
* - The divisor cannot be zero.
* IMPORTANT: This value MUST be greater than `numberOfTokensToSwapToLiquidity` set below,
* otherwise the liquidity swap will never be executed
*/
*/
function div(
uint256 internal maxWalletBalance = maxTransactionAmount * 3; // 10 * maxTransactionAmount
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 Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* @dev Set the Cap balance in a wallet to identification Whale.
* Reverts when dividing by zero.
*
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* The default value is 75% of the maxWalletBalance.
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
*
* Requirements:
* NOTE: set the value to maxWalletBalance to disable.
*
*
* - 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) internal pure returns (uint256) {
uint16 internal constant WHALE_FEE_IN_PERCENT = 50;
return mod(a, b, 'SafeMath: modulo by zero');
uint256 internal capWhaleWalletBalance = (80 * maxWalletBalance) / 100; // 80% of the maxWalletBalance
}

/**
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* @dev Set the number of tokens to swap and add to liquidity.
* Reverts with custom message when dividing by zero.
*
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* Whenever the contract's balance reaches this number of tokens, swap & liquify will be
* opcode (which leaves remaining gas untouched) while Solidity uses an
* executed in the very next transfer (via the `_beforeTokenTransfer`)
* invalid opcode to revert (consuming all remaining gas).
*
*
* Requirements:
* 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.
*
*
* - The divisor cannot be zero.
* See: `Liquifier`
*/
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;
}
Text moved with changes to lines 509-513 (65.0% similarity)
} 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);

/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);

/**
* @dev Returns the amount of tokens owned by `account`.
*/
*/
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);
address internal tipToTheDev = 0x5fd3d666afA636dD70A9d33Ef20799aa53DcbB37;


/**
enum FeeType { Antiwhale, Burn, Liquidity, Rfi, External, ExternalToETH }
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
struct Fee {
* a call to {approve}. `value` is the new allowance.
FeeType name;
*/
uint256 value;
event Approval(address indexed owner, address indexed spender, uint256 value);
address recipient;
uint256 total;
}
}


//
Fee[] internal fees;
/**
uint256 internal sumOfFees;
* @dev Collection of functions related to the address type

*/
constructor() {
library Address {
_addFees();
/**
* @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);
}
}


/**
function _addFee(FeeType name, uint256 value, address recipient) private {
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
fees.push( Fee(name, value, recipient, 0 ) );
* `recipient`, forwarding all available gas and reverting on errors.
sumOfFees += value;
*
* 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
(bool success, ) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
}

function _addFees() private {


/**
/**
* @dev Performs a Solidity function call using a low level `call`. A
* The RFI recipient is ignored but we need to give a valid address value
* plain`call` is an unsafe replacement for a function call: use this
* 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.
* CAUTION: If you don't want to use RFI this implementation isn't really for you!
* - calling `target` with `data` must not revert.
* There are much more efficient and cleaner token contracts without RFI
* so you should use one of those
*
*
* _Available since v3.1._
* The value of fees is given in part per 1000 (based on the value of FEES_DIVISOR),
* e.g. for 5% use 50, for 3.5% use 35, etc.
*/
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
_addFee(FeeType.Rfi, 40, address(this) ); // 4% Redistribute to holders
return functionCall(target, data, 'Address: low-level call failed');
_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 with

* `errorMessage` as a fallback revert reason when `target` reverts.
function _getFeeStruct(uint256 index) private view returns(Fee storage){
*
require( index >= 0 && index < fees.length, "FeesSettings._getFeeStruct: Fee index out of bounds");
* _Available since v3.1._
return fees[index];
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
}

function _getFee(uint256 index) internal view returns (FeeType, uint256, address, uint256){
/**
Fee memory fee = _getFeeStruct(index);
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
return ( fee.name, fee.value, fee.recipient, fee.total );
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - 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 _addFeeCollectedAmount(uint256 index, uint256 amount) internal {
/**
Fee storage fee = _getFeeStruct(index);
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
fee.total = fee.total.add(amount);
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
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
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}

abstract contract Presaleable is Manageable {
bool internal isInPresale;
function setPreseableEnabled(bool value) external onlyManager {
isInPresale = value;
}
}
}
}


//
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));

emit Transfer(address(0), owner(), TOTAL_SUPPLY);
}
}

function safeTransferFrom(
/** Functions required by IERC20Metadat **/
IBEP20 token,
function name() external pure override returns (string memory) { return NAME; }
address from,
function symbol() external pure override returns (string memory) { return SYMBOL; }
address to,
function decimals() external pure override returns (uint8) { return DECIMALS; }
uint256 value
) internal {
/** Functions required by IERC20Metadat - END **/
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
/** Functions required by IERC20 **/
function totalSupply() external pure override returns (uint256) {
return TOTAL_SUPPLY;
}
}

/**
function balanceOf(address account) public view override returns (uint256){
* @dev Deprecated. This function has issues similar to the ones found in
if (_isExcludedFromRewards[account]) return _balances[account];
* {IBEP20-approve}, and its usage is discouraged.
return tokenFromReflection(_reflectedBalances[account]);
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
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(
function transfer(address recipient, uint256 amount) external override returns (bool){
IBEP20 token,
_transfer(_msgSender(), recipient, amount);
address spender,
return true;
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}

function safeDecreaseAllowance(
function allowance(address owner, address spender) external view override returns (uint256){
IBEP20 token,
return _allowances[owner][spender];
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(
value,
'SafeBEP20: decreased allowance below zero'
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}

/**
function approve(address spender, uint256 amount) external override returns (bool) {
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
_approve(_msgSender(), spender, amount);
* on the return value: the return value is optional (but if data is returned, it must not be false).
return true;
* @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 {
// 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');
function getAddressLastTransaction(address owner ) external view returns(uint)
if (returndata.length > 0) {
{
// Return data is optional
return _getLastTransaction(owner);
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
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;
* @dev Provides information about the current execution context, including the
}
* sender of the transaction and its data. While these are generally available
* 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
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* 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) {
function setMaxWalletBalance(uint256 amount) external onlyManager{
return msg.sender;
maxWalletBalance = amount;
}
}

function _msgData() internal view returns (bytes memory) {
function getMaxWalletBalance() external view returns(uint256)
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
{
return msg.data;
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 Contract module which provides a basic access control mechanism, where
* @dev this is really a "soft" burn (total supply is not reduced). RFI holders
* there is an account (an owner) that can be granted exclusive access to
* get two benefits from burning tokens:
* specific functions.
*
*
* By default, the owner account will be the one that deploys the contract. This
* 1) Tokens in the burn address increase the % of tokens held by holders not
* can later be changed with {transferOwnership}.
* 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)
*
*
* 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
* In RFI holders already get % of each transaction so the value of their tokens
* the owner.
* 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).
*/
*/
contract Ownable is Context {
function burn(uint256 amount) external {
address private _owner;


event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address sender = _msgSender();
require(sender != address(0), "BaseRfiToken: burn from the zero address");
require(sender != address(burnAddress), "BaseRfiToken: burn from the burn address");


/**
uint256 balance = balanceOf(sender);
* @dev Initializes the contract setting the deployer as the initial owner.
require(balance >= amount, "BaseRfiToken: burn amount exceeds balance");
*/

constructor() internal {
uint256 reflectedAmount = amount.mul(_getCurrentRate());
address msgSender = _msgSender();

_owner = msgSender;
// remove the amount from the sender's balance first
emit OwnershipTransferred(address(0), msgSender);
_reflectedBalances[sender] = _reflectedBalances[sender].sub(reflectedAmount);
if (_isExcludedFromRewards[sender])
_balances[sender] = _balances[sender].sub(amount);

_burnTokens( sender, amount, reflectedAmount );
}
}

/**
/**
* @dev Returns the address of the current owner.
* @dev "Soft" burns the specified amount of tokens by sending them
* to the burn address
*/
*/
function owner() public view returns (address) {
function _burnTokens(address sender, uint256 tBurn, uint256 rBurn) internal {
return _owner;
}


/**
/**
* @dev Throws if called by any account other than the owner.
* @dev Do not reduce _totalSupply and/or _reflectedSupply. (soft) burning by sending
* tokens to the burn address (which should be excluded from rewards) is sufficient
* in RFI
*/
*/
modifier onlyOwner() {
_reflectedBalances[burnAddress] = _reflectedBalances[burnAddress].add(rBurn);
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
if (_isExcludedFromRewards[burnAddress])
_;
_balances[burnAddress] = _balances[burnAddress].add(tBurn);
}


/**
/**
* @dev Leaves the contract without owner. It will not be possible to call
* @dev Emit the event so that the burn address balance is updated (on bscscan)
* `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 {
emit Transfer(sender, burnAddress, tBurn);
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}


/**
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
* @dev Transfers ownership of the contract to a new account (`newOwner`).
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
* Can only be called by the current owner.
return true;
*/
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
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;
}
function isExcludedFromReward(address account) external view returns (bool) {
return _isExcludedFromRewards[account];
}
}


/**
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* @dev Calculates and returns the reflected amount for the given amount with or without
* the transfer fees (deductTransferFee true/false)
*/
*/
function _transferOwnership(address newOwner) internal {
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) external view returns(uint256) {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
require(tAmount <= TOTAL_SUPPLY, "Amount must be less than supply");
emit OwnershipTransferred(_owner, newOwner);
if (!deductTransferFee) {
_owner = newOwner;
(uint256 rAmount,,,,) = _getValues(tAmount,0);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount,_getSumOfFees(_msgSender(), tAmount));
return rTransferAmount;
}
}
}
}


//
/**
/**
* @dev Implementation of the {IBEP20} interface.
* @dev Calculates and returns the amount of tokens corresponding to the given reflected amount.
*
* 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 {
function tokenFromReflection(uint256 rAmount) internal view returns(uint256) {
using SafeMath for uint256;
require(rAmount <= _reflectedSupply, "Amount must be less than total reflections");
using Address for address;
uint256 currentRate = _getCurrentRate();
return rAmount.div(currentRate);
}

mapping(address => uint256) private _balances;
function excludeFromReward(address account) external onlyOwner() {
require(!_isExcludedFromRewards[account], "Account is not included");
_exclude(account);
}

mapping(address => mapping(address => uint256)) private _allowances;
function _exclude(address account) internal {
if(_reflectedBalances[account] > 0) {
_balances[account] = tokenFromReflection(_reflectedBalances[account]);
}
_isExcludedFromRewards[account] = true;
_excluded.push(account);
}


uint256 private _totalSupply;
function includeInReward(address account) external onlyOwner() {
require(_isExcludedFromRewards[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_balances[account] = 0;
_isExcludedFromRewards[account] = false;
Text moved with changes from lines 189-193 (65.0% similarity)
_excluded.pop();
break;
}
}
}

string private _name;
function setExcludedFromFee(address account, bool value) external onlyOwner { _isExcludedFromFee[account] = value; }
string private _symbol;
function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; }
uint8 private _decimals;
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 Sets the values for {name} and {symbol}, initializes {decimals} with
emit Approval(owner, spender, amount);
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
}

/**
/**
* @dev Returns the bep token owner.
*/
*/
function getOwner() external override view returns (address) {
function _isUnlimitedSender(address account) internal view returns(bool){
return owner();
// the owner should be the only whitelisted sender
return (account == owner());
}
}

/**
/**
* @dev Returns the token name.
*/
*/
function name() public override view returns (string memory) {
function _isUnlimitedRecipient(address account) internal view returns(bool){
return _name;
// 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 {
require(sender != address(0), "BaseRfiToken: transfer from the zero address");
require(recipient != address(0), "BaseRfiToken: transfer to the zero address");
require(sender != address(burnAddress), "BaseRfiToken: transfer from the burn address");
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; }
else {
/**
/**
* @dev Returns the token decimals.
* Check the amount is within the max allowed limit as long as a
* unlimited sender/recepient is not involved in the transaction
*/
*/
function decimals() public override view returns (uint8) {
if ( amount > maxTransactionAmount && !_isUnlimitedSender(sender) && !_isUnlimitedRecipient(recipient) ){
return _decimals;
revert("Transfer amount exceeds the maxTxAmount.");
}
}

/**
/**
* @dev Returns the token symbol.
* 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
*/
*/
function symbol() public override view returns (string memory) {
if ( maxWalletBalance > 0 && !_isUnlimitedSender(sender) && !_isUnlimitedRecipient(recipient) && !_isV2Pair(recipient)){
return _symbol;
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))
* @dev See {BEP20-totalSupply}.
{
*/
//AntiBot Using Block Check
function totalSupply() public override view returns (uint256) {
require(block.number > _getLastBlock(tx.origin), "You cant send more than one transaction in one block.");
return _totalSupply;
_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
Diferencias guardadas