Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

WSFvsFLibero

Created 3 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

826 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

796 lines

/**

*Submitted for verification at BscScan.com on 2022-03-28

*Submitted for verification at FtmScan.com on 2022-03-29

// SPDX-License-Identifier: Unlicensed

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.4;

abstract contract Context {

function _msgSender() internal view virtual returns (address payable) {

return payable(msg.sender);

}

function _msgData() internal view virtual returns (bytes memory) {

this;

return msg.data;

}

abstract contract Auth is Context{

address owner;

mapping (address => bool) private authorizations;

constructor(address _owner) {

owner = _owner;

Text moved with changes from lines 345-350 (85.7% similarity)

authorizations[_owner] = true;

}

modifier onlyOwner() {

require(isOwner(msg.sender)); _;

}

modifier authorized() {

require(isAuthorized(msg.sender)); _;

}

function authorize(address adr) public onlyOwner {

authorizations[adr] = true;

emit Authorized(adr);

}

function unauthorize(address adr) public onlyOwner {

authorizations[adr] = false;

emit Unauthorized(adr);

}

function isOwner(address account) public view returns (bool) {

return account == owner;

}

function isAuthorized(address adr) public view returns (bool) {

return authorizations[adr];

}

function transferOwnership(address payable adr) public onlyOwner {

owner = adr;

authorizations[adr] = true;

emit OwnershipTransferred(adr);

}

event OwnershipTransferred(address owner);

event Authorized(address adr);

event Unauthorized(address adr);

}

library SafeMathInt {

int256 private constant MIN_INT256 = int256(1) << 255;

int256 private constant MAX_INT256 = ~(int256(1) << 255);

function mul(int256 a, int256 b) internal pure returns (int256) {

int256 c = a * b;

require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));

require((b == 0) || (c / b == a));

return c;

}

function div(int256 a, int256 b) internal pure returns (int256) {

require(b != -1 || a != MIN_INT256);

return a / b;

}

function sub(int256 a, int256 b) internal pure returns (int256) {

int256 c = a - b;

require((b >= 0 && c <= a) || (b < 0 && c > a));

return c;

}

function add(int256 a, int256 b) internal pure returns (int256) {

int256 c = a + b;

require((b >= 0 && c >= a) || (b < 0 && c < a));

return c;

}

function abs(int256 a) internal pure returns (int256) {

require(a != MIN_INT256);

return a < 0 ? -a : a;

}

library SafeMath {

function add(uint256 a, uint256 b) internal pure returns (uint256) {

uint256 c = a + b;

require(c >= a, "SafeMath: addition overflow");

return c;

}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {

return sub(a, b, "SafeMath: subtraction overflow");

}

function sub(

uint256 a,

uint256 b,

string memory errorMessage

) internal pure returns (uint256) {

require(b <= a, errorMessage);

uint256 c = a - b;

return c;

}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {

if (a == 0) {

return 0;

}

uint256 c = a * b;

require(c / a == b, "SafeMath: multiplication overflow");

return c;

}

function div(uint256 a, uint256 b) internal pure returns (uint256) {

return div(a, b, "SafeMath: division by zero");

}

function div(

uint256 a,

uint256 b,

string memory errorMessage

) internal pure returns (uint256) {

require(b > 0, errorMessage);

uint256 c = a / b;

return c;

}

function mod(uint256 a, uint256 b) internal pure returns (uint256) {

require(b != 0);

return a % b;

}

interface IERC20 {

function totalSupply() external view returns (uint256);

function balanceOf(address who) external view returns (uint256);

function allowance(address owner, address spender)

function allowance(address owner, address spender) external view returns (uint256);

external

view

returns (uint256);

function transfer(address to, uint256 value) external returns (bool);

function approve(address spender, uint256 value) external returns (bool);

function transferFrom(

function transferFrom(address from, address to, uint256 value) external returns (bool);

address from,

address to,

uint256 value

) external returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);

event Approval(

event Approval(address indexed owner, address indexed spender, uint256 value);

address indexed owner,

address indexed spender,

uint256 value

);

}

interface IPancakeSwapPair {

interface InterfaceLP {

event Approval(address indexed owner, address indexed spender, uint value);

event Transfer(address indexed from, address indexed to, uint value);

function name() external pure returns (string memory);

function symbol() external pure returns (string memory);

function decimals() external pure returns (uint8);

function totalSupply() external view returns (uint);

function balanceOf(address owner) external view returns (uint);

function allowance(address owner, address spender) external view returns (uint);

function approve(address spender, uint value) external returns (bool);

function transfer(address to, uint value) external returns (bool);

function transferFrom(address from, address to, uint value) external returns (bool);

function DOMAIN_SEPARATOR() external view returns (bytes32);

function PERMIT_TYPEHASH() external pure returns (bytes32);

function nonces(address owner) external view returns (uint);

function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

event Mint(address indexed sender, uint amount0, uint amount1);

event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);

event Swap(

address indexed sender,

uint amount0In,

uint amount1In,

uint amount0Out,

uint amount1Out,

address indexed to

);

event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint);

function factory() external view returns (address);

function token0() external view returns (address);

function token1() external view returns (address);

function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

function price0CumulativeLast() external view returns (uint);

function price1CumulativeLast() external view returns (uint);

function kLast() external view returns (uint);

function mint(address to) external returns (uint liquidity);

function burn(address to) external returns (uint amount0, uint amount1);

function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;

function skim(address to) external;

function sync() external;

function initialize(address, address) external;

}

interface IPancakeSwapRouter{

function factory() external pure returns (address);

Text moved with changes to lines 232-242 (97.4% similarity)

function WETH() external pure returns (address);

function addLiquidity(

address tokenA,

address tokenB,

uint amountADesired,

uint amountBDesired,

uint amountAMin,

uint amountBMin,

address to,

uint deadline

) external returns (uint amountA, uint amountB, uint liquidity);

function addLiquidityETH(

address token,

uint amountTokenDesired,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

) external payable returns (uint amountToken, uint amountETH, uint liquidity);

function removeLiquidity(

address tokenA,

address tokenB,

uint liquidity,

uint amountAMin,

uint amountBMin,

address to,

uint deadline

) external returns (uint amountA, uint amountB);

function removeLiquidityETH(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

) external returns (uint amountToken, uint amountETH);

function removeLiquidityWithPermit(

address tokenA,

address tokenB,

uint liquidity,

uint amountAMin,

uint amountBMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountA, uint amountB);

function removeLiquidityETHWithPermit(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountToken, uint amountETH);

function swapExactTokensForTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external returns (uint[] memory amounts);

function swapTokensForExactTokens(

uint amountOut,

uint amountInMax,

address[] calldata path,

address to,

uint deadline

) external returns (uint[] memory amounts);

function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)

external

payable

returns (uint[] memory amounts);

function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)

external

returns (uint[] memory amounts);

function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)

external

returns (uint[] memory amounts);

function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)

external

payable

returns (uint[] memory amounts);

function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);

function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);

function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);

function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);

function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);

function removeLiquidityETHSupportingFeeOnTransferTokens(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

) external returns (uint amountETH);

function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountETH);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external payable;

Text moved with changes to lines 282-292 (93.8% similarity)

function swapExactTokensForETHSupportingFeeOnTransferTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external;

}

interface IPancakeSwapFactory {

event PairCreated(address indexed token0, address indexed token1, address pair, uint);

function feeTo() external view returns (address);

function feeToSetter() external view returns (address);

function getPair(address tokenA, address tokenB) external view returns (address pair);

function allPairs(uint) external view returns (address pair);

function allPairsLength() external view returns (uint);

function createPair(address tokenA, address tokenB) external returns (address pair);

function setFeeTo(address) external;

function setFeeToSetter(address) external;

}

contract Ownable {

library Roles {

address private _owner;

struct Role {

mapping (address => bool) bearer;

event OwnershipRenounced(address indexed previousOwner);

event OwnershipTransferred(

address indexed previousOwner,

address indexed newOwner

);

constructor() {

_owner = msg.sender;

}

function owner() public view returns (address) {

Text moved with changes to lines 26-31 (85.7% similarity)

return _owner;

}

modifier onlyOwner() {

require(isOwner());

}

function isOwner() public view returns (bool) {

return msg.sender == _owner;

}

function renounceOwnership() public onlyOwner {

function add(Role storage role, address account) internal {

emit OwnershipRenounced(_owner);

require(!has(role, account), "Roles: account already has role");

_owner = address(0);

role.bearer[account] = true;

}

function transferOwnership(address newOwner) public onlyOwner {

function remove(Role storage role, address account) internal {

_transferOwnership(newOwner);

require(has(role, account), "Roles: account does not have role");

role.bearer[account] = false;

}

function _transferOwnership(address newOwner) internal {

function has(Role storage role, address account) internal view returns (bool) {

require(newOwner != address(0));

require(account != address(0), "Roles: account is the zero address");

emit OwnershipTransferred(_owner, newOwner);

return role.bearer[account];

_owner = newOwner;

}

abstract contract ERC20Detailed is IERC20 {

string private _name;

string private _symbol;

uint8 private _decimals;

constructor(

string memory name_,

string memory _tokenName,

string memory symbol_,

string memory _tokenSymbol,

uint8 decimals_

uint8 _tokenDecimals

) {

_name = name_;

_name = _tokenName;

_symbol = symbol_;

_symbol = _tokenSymbol;

_decimals = decimals_;

_decimals = _tokenDecimals;

}

function name() public view returns (string memory) {

return _name;

}

function symbol() public view returns (string memory) {

return _symbol;

}

function decimals() public view returns (uint8) {

return _decimals;

}

contract WallStreetFinance is ERC20Detailed, Ownable {

interface IDEXRouter {

function factory() external pure returns (address);

Text moved with changes from lines 184-194 (97.4% similarity)

function WETH() external pure returns (address);

function addLiquidity(

address tokenA,

address tokenB,

uint256 amountADesired,

uint256 amountBDesired,

uint256 amountAMin,

uint256 amountBMin,

address to,

uint256 deadline

)

external

returns (

uint256 amountA,

uint256 amountB,

uint256 liquidity

);

function addLiquidityETH(

address token,

uint256 amountTokenDesired,

uint256 amountTokenMin,

uint256 amountETHMin,

address to,

uint256 deadline

)

external

payable

returns (

uint256 amountToken,

uint256 amountETH,

uint256 liquidity

);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(

uint256 amountIn,

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external payable;

Text moved with changes from lines 305-315 (93.8% similarity)

function swapExactTokensForETHSupportingFeeOnTransferTokens(

uint256 amountIn,

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external;

}

interface IDEXFactory {

function createPair(address tokenA, address tokenB)

external

returns (address pair);

}

contract FLiberoToken is ERC20Detailed, Auth {

using SafeMath for uint256;

using SafeMathInt for int256;

bool public initialDistributionFinished = false;

bool public autoRebase = false;

bool public feesOnNormalTransfers = true;

bool public isLiquidityInFtm = true;

bool public isRfvInFtm = true;

bool public isLiquidityEnabled = true;

string public _name = "WallStreet Finance";

uint256 public rewardYield = 1402777;

string public _symbol = "WSF";

uint256 public rebaseFrequency = 600;

uint8 public _decimals = 5;

uint256 public nextRebase = block.timestamp + 31536000;

uint256 public maxSellTransactionAmount = 2000000 * 10 ** 18;

uint256 public swapThreshold = 400000 * 10**18;

IPancakeSwapPair public pairContract;

mapping(address => bool) _isFeeExempt;

address[] private _makerPairs;

mapping (address => bool) public automatedMarketMakerPairs;

Text moved to lines 362-365

modifier validRecipient(address to) {

uint256 private constant REWARD_YIELD_DENOMINATOR = 10000000000;

require(to != address(0x0));

uint256 private constant MAX_TOTAL_BUY_FEE_RATE = 250;

uint256 private constant MAX_TOTAL_SELL_FEE_RATE = 500;

}

uint256 private constant FEE_DENOMINATOR = 1000;

uint256 private constant MIN_MAX_SELL_AMOUNT = 1000 * 10**18;

uint256 private constant MAX_REBASE_FREQUENCY = 1800;

uint256 private constant DECIMALS = 18;

uint256 private constant MAX_UINT256 = ~uint256(0);

uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 15 * 10**8 * 10**DECIMALS;

uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);

uint256 private constant MAX_SUPPLY = ~uint128(0);

uint256 public constant DECIMALS = 5;

address private constant DEAD = 0x000000000000000000000000000000000000dEaD;

uint256 public constant MAX_UINT256 = ~uint256(0);

address private constant ZERO = 0x0000000000000000000000000000000000000000;

uint8 public constant RATE_DECIMALS = 7;

address public constant usdcToken = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;

address public liquidityReceiver = 0x730736E3cdffc531b74eb8B30bD2CC50beb8Ab3c;

address public treasuryReceiver = 0x3ff8970f17d463b83D289827B7B8E5Eed61Cc3e8;

address public riskFreeValueReceiver = 0x14c02711A4678fc7De388e77e99B07753C856e84;

address public xLiberoReceiver = 0x8689EDAb5Bdb17b11273a5C9412C4BBC8f2Ec4F8;

uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 10 * 10**6 * 10**DECIMALS;

IDEXRouter public router;

address public pair;

uint256 public liquidityFee = 40;

uint256 public treasuryFee = 20;

uint256 public treasuryFee = 30;

uint256 public insuranceFee = 60;

uint256 public buyFeeRFV = 50;

uint256 public wsfBankFee = 20;

uint256 public buyBurnFee = 20;

uint256 public nftHolderFee = 20;

uint256 public buyxLiberoFee = 0;

uint256 public sellFeeTreasuryAdded = 20;

uint256 public sellFee = wsfBankFee.add(nftHolderFee);

uint256 public sellFeeRFVAdded = 40;

uint256 public burnFee = 10;

uint256 public sellBurnFeeAdded = 0;

uint256 public totalFee = liquidityFee.add(treasuryFee).add(insuranceFee).add(burnFee);

uint256 public sellxLiberoFeeAdded = 0;

uint256 public feeDenominator = 1000;

uint256 public totalBuyFee = liquidityFee.add(treasuryFee).add(buyFeeRFV).add(buyBurnFee).add(buyxLiberoFee);

uint256 public totalSellFee = totalBuyFee.add(sellFeeTreasuryAdded).add(sellFeeRFVAdded).add(sellBurnFeeAdded).add(sellxLiberoFeeAdded);

address DEAD = 0x000000000000000000000000000000000000dEaD;

address ZERO = 0x0000000000000000000000000000000000000000;

address public wsfBankReceiver;

bool inSwap;

address public nftHolderReceiver;

address public lpReceiver;

address public treasuryReceiver;

address public insuranceReceiver;

address public firePit;

address public pairAddress;

bool public swapEnabled = true;

IPancakeSwapRouter public router;

address public pair;

bool inSwap = false;

modifier swapping() {

inSwap = true;

inSwap = false;

}

Text moved from lines 415-418

uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);

modifier validRecipient(address to) {

uint256 private constant MAX_SUPPLY = 10 * 10**10 * 10**DECIMALS;

require(to != address(0x0));

// BOOL Variables

}

bool public _autoRebase = true;

bool public _autoAddLiquidity = true;

// INT Variables

uint256 private _totalSupply;

uint256 public _initRebaseStartTime;

uint256 public _lastRebasedTime;

uint256 public _lastAddLiquidityTime;

uint256 public _totalSupply;

uint256 private _gonsPerFragment;

// MAPPING

mapping(address => uint256) private _gonBalances;

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

mapping(address => bool) public blacklist;

// EVENT

event Rebased(uint256 indexed epoch, uint256 totalSupply);

constructor() ERC20Detailed("WallStreet Finance", "WSF", uint8(DECIMALS)) Ownable() {

router = IPancakeSwapRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);

pair = IPancakeSwapFactory(router.factory()).createPair(

router.WETH(),

address(this)

);

lpReceiver = 0x5562640B953b6c2f79a655E930aFa68b2a65C627;

constructor() ERC20Detailed("Fantom Libero Financial Freedom", "FLIBERO", uint8(DECIMALS)) Auth(msg.sender) {

treasuryReceiver = 0xa9fe433E3014772bbfeA2B56F8F23CD7b87B2cbb;

router = IDEXRouter(0xF491e7B69E4244ad4002BC14e878a34207E38c29);

insuranceReceiver = 0x180f8387A0538ee058D305877df5acdBa0947498;

pair = IDEXFactory(router.factory()).createPair(address(this), router.WETH());

wsfBankReceiver = 0xEF0935155365db7496304bedc964470C589b9916;

address pairUsdc = IDEXFactory(router.factory()).createPair(address(this), usdcToken);

nftHolderReceiver = 0x741490Fa4c7C67c395C0b5F78a1D6Baaaaa75a09;

firePit = 0x0000000000000000000000000000000000000000;

_allowedFragments[address(this)][address(router)] = uint256(-1);

pairAddress = pair;

_allowedFragments[address(this)][pair] = uint256(-1);

pairContract = IPancakeSwapPair(pair);

_allowedFragments[address(this)][address(this)] = uint256(-1);

_allowedFragments[address(this)][pairUsdc] = uint256(-1);

setAutomatedMarketMakerPair(pair, true);

setAutomatedMarketMakerPair(pairUsdc, true);

_totalSupply = INITIAL_FRAGMENTS_SUPPLY;

_gonBalances[owner()] = TOTAL_GONS;

_gonBalances[msg.sender] = TOTAL_GONS;

_gonsPerFragment = TOTAL_GONS.div(_totalSupply);

_initRebaseStartTime = block.timestamp;

_lastRebasedTime = block.number;

_isFeeExempt[owner()] = true;

_isFeeExempt[treasuryReceiver] = true;

_isFeeExempt[riskFreeValueReceiver] = true;

_isFeeExempt[address(this)] = true;

_isFeeExempt[msg.sender] = true;

emit Transfer(address(0x0), owner(), _totalSupply);

IERC20(usdcToken).approve(address(router), uint256(-1));

IERC20(usdcToken).approve(address(pairUsdc), uint256(-1));

IERC20(usdcToken).approve(address(this), uint256(-1));

emit Transfer(address(0x0), msg.sender, _totalSupply);

}

function setZeroFees() external onlyOwner {

receive() external payable {}

liquidityFee = 0;

treasuryFee = 0;

insuranceFee = 0;

wsfBankFee = 0;

nftHolderFee = 0;

burnFee = 0;

sellFee = 0;

function totalSupply() external view override returns (uint256) {

totalFee = 0;

return _totalSupply;

}

function setNormalFees() external onlyOwner {

function allowance(address owner_, address spender) external view override returns (uint256){

liquidityFee = 40;

return _allowedFragments[owner_][spender];

treasuryFee = 20;

insuranceFee = 60;

wsfBankFee = 20;

nftHolderFee = 20;

burnFee = 10;

sellFee = wsfBankFee.add(nftHolderFee);

totalFee = liquidityFee.add(treasuryFee).add(insuranceFee).add(burnFee);

}

function manualRebase() external onlyOwner {

function balanceOf(address who) public view override returns (uint256) {

rebase();

return _gonBalances[who].div(_gonsPerFragment);

}

function rebase() internal {

function checkFeeExempt(address _addr) external view returns (bool) {

return _isFeeExempt[_addr];

if ( inSwap ) return;

}

uint deno = 10**7 * 10**18;

function shouldRebase() internal view returns (bool) {

uint rebaseRate = 858 * 10**18;

return nextRebase <= block.timestamp;

uint minuteRebaseRate = 17100 * 10**18;

}

uint hourRebaseRate = 1000000 * 10**18;

uint dayRebaseRate = 188800000 * 10**18;

uint blockCount = block.number.sub(_lastRebasedTime);

function shouldTakeFee(address from, address to) internal view returns (bool) {

uint tmp = _totalSupply;

if(_isFeeExempt[from] || _isFeeExempt[to]){

for (uint idx = 0; idx < blockCount.mod(20); idx++) { // 3 sec rebase

return false;

// S' = S(1+p)^r

}else if (feesOnNormalTransfers){

tmp = tmp.mul(deno.mul(100).add(rebaseRate)).div(deno.mul(100));

return true;

}else{

return (automatedMarketMakerPairs[from] || automatedMarketMakerPairs[to]);

}

for (uint idx = 0; idx < blockCount.div(20).mod(60); idx++) { // 1 min rebase

function shouldSwapBack() internal view returns (bool) {

// S' = S(1+p)^r

return

tmp = tmp.mul(deno.mul(100).add(minuteRebaseRate)).div(deno.mul(100));

!automatedMarketMakerPairs[msg.sender] &&

}

!inSwap &&

swapThreshold > 0 &&

totalBuyFee.add(totalSellFee) > 0 &&

balanceOf(address(this)) >= swapThreshold;

}

for (uint idx = 0; idx < blockCount.div(20 * 60).mod(24); idx++) { // 1 hour rebase

function getCirculatingSupply() public view returns (uint256) {

// S' = S(1+p)^r

return (TOTAL_GONS.sub(_gonBalances[DEAD]).sub(_gonBalances[ZERO])).div(_gonsPerFragment);

tmp = tmp.mul(deno.mul(100).add(hourRebaseRate)).div(deno.mul(100));

}

for (uint idx = 0; idx < blockCount.div(20 * 60 * 24); idx++) { // 1 day rebase

function manualSync() public {

// S' = S(1+p)^r

for(uint i = 0; i < _makerPairs.length; i++){

tmp = tmp.mul(deno.mul(100).add(dayRebaseRate)).div(deno.mul(100));

try InterfaceLP(_makerPairs[i]).sync() {

}catch Error (string memory reason) {

emit GenericErrorEvent("manualSync(): _makerPairs.sync() Failed");

emit GenericErrorEvent(reason);

}

_totalSupply = tmp;

_gonsPerFragment = TOTAL_GONS.div(tmp);

_lastRebasedTime = block.number;

pairContract.sync();

emit Rebased(block.timestamp, _totalSupply);

}

function transfer(address to, uint256 value)

function transfer(address to, uint256 value) external override validRecipient(to) returns (bool){

external

override

validRecipient(to)

returns (bool)

{

_transferFrom(msg.sender, to, value);

return true;

}

function transferFrom(

function _basicTransfer(address from, address to, uint256 amount) internal returns (bool) {

address from,

address to,

uint256 value

) external override validRecipient(to) returns (bool) {

Text moved to lines 520-523

if (_allowedFragments[from][msg.sender] != uint256(-1)) {

_allowedFragments[from][msg.sender] = _allowedFragments[from][

msg.sender

].sub(value, "Insufficient Allowance");

}

Text moved to lines 526-528

_transferFrom(from, to, value);

return true;

}

function _basicTransfer(

address from,

address to,

uint256 amount

) internal returns (bool) {

uint256 gonAmount = amount.mul(_gonsPerFragment);

_gonBalances[from] = _gonBalances[from].sub(gonAmount);

_gonBalances[to] = _gonBalances[to].add(gonAmount);

emit Transfer(from, to, amount);

return true;

}

function _transferFrom(

function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {

address sender,

bool excludedAccount = _isFeeExempt[sender] || _isFeeExempt[recipient];

address recipient,

uint256 amount

) internal returns (bool) {

require(!blacklist[sender] && !blacklist[recipient], "in_blacklist");

require(initialDistributionFinished || excludedAccount, "Trading not started");

if (

automatedMarketMakerPairs[recipient] &&

!excludedAccount

) {

require(amount <= maxSellTransactionAmount, "Error amount");

}

if (inSwap) {

return _basicTransfer(sender, recipient, amount);

}

if (shouldRebase()) {

rebase();

}

if (shouldAddLiquidity()) {

uint256 gonAmount = amount.mul(_gonsPerFragment);

addLiquidity();

}

if (shouldSwapBack()) {

swapBack();

}

uint256 gonAmount = amount.mul(_gonsPerFragment);

_gonBalances[sender] = _gonBalances[sender].sub(gonAmount);

uint256 gonAmountReceived = shouldTakeFee(sender, recipient)

? takeFee(sender, recipient, gonAmount)

: gonAmount;

_gonBalances[recipient] = _gonBalances[recipient].add(

gonAmountReceived

);

uint256 gonAmountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, gonAmount) : gonAmount;

_gonBalances[recipient] = _gonBalances[recipient].add(gonAmountReceived);

emit Transfer(

sender,

recipient,

gonAmountReceived.div(_gonsPerFragment)

);

if(

shouldRebase() &&

autoRebase &&

!automatedMarketMakerPairs[sender] &&

!automatedMarketMakerPairs[recipient]

) {

_rebase();

manualSync();

}

return true;

}

function takeFee(

function transferFrom(address from, address to, uint256 value) external override validRecipient(to) returns (bool) {

Text moved from lines 596-599

address sender,

if (_allowedFragments[from][msg.sender] != uint256(-1)) {

address recipient,

_allowedFragments[from][msg.sender] = _allowedFragments[from][

uint256 gonAmount

msg.sender

) internal returns (uint256) {

].sub(value, "Insufficient Allowance");

uint256 _totalFee = totalFee;

if (recipient == pair) {

_totalFee = totalFee.add(sellFee);

}

Text moved from lines 601-603

uint256 feeAmount = gonAmount.div(feeDenominator).mul(_totalFee);

_transferFrom(from, to, value);

return true;

}

_gonBalances[firePit] = _gonBalances[firePit].add(

function _swapAndLiquify(uint256 contractTokenBalance) private {

gonAmount.div(feeDenominator).mul(burnFee)

uint256 half = contractTokenBalance.div(2);

);

uint256 otherHalf = contractTokenBalance.sub(half);

uint256 maintainFee = _totalFee - burnFee - liquidityFee;

_gonBalances[address(this)] = _gonBalances[address(this)].add(

if(isLiquidityInFtm){

gonAmount.div(feeDenominator).mul(maintainFee)

uint256 initialBalance = address(this).balance;

);

_gonBalances[lpReceiver] = _gonBalances[lpReceiver].add(

gonAmount.div(feeDenominator).mul(liquidityFee)

);

emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));

_swapTokensForFTM(half, address(this));

return gonAmount.sub(feeAmount);

uint256 newBalance = address(this).balance.sub(initialBalance);

_addLiquidity(otherHalf, newBalance);

emit SwapAndLiquify(half, newBalance, otherHalf);

}else{

uint256 initialBalance = IERC20(usdcToken).balanceOf(address(this));

_swapTokensForUsdc(half, address(this));

uint256 newBalance = IERC20(usdcToken).balanceOf(address(this)).sub(initialBalance);

addLiquidityUsdc(otherHalf, newBalance);

emit SwapAndLiquifyUsdc(half, newBalance, otherHalf);

}

function addLiquidity() internal swapping {

function _addLiquidity(uint256 tokenAmount, uint256 ftmAmount) private {

uint256 autoLiquidityAmount = _gonBalances[lpReceiver].div(

router.addLiquidityETH{value: ftmAmount}(

_gonsPerFragment

address(this),

tokenAmount,

liquidityReceiver,

block.timestamp

);

_gonBalances[address(this)] = _gonBalances[address(this)].add(

}

_gonBalances[lpReceiver]

function addLiquidityUsdc(uint256 tokenAmount, uint256 usdcAmount) private {

router.addLiquidity(

address(this),

usdcToken,

tokenAmount,

usdcAmount,

liquidityReceiver,

block.timestamp

);

_gonBalances[lpReceiver] = 0;

}

uint256 amountToLiquify = autoLiquidityAmount.div(2);

uint256 amountToSwap = autoLiquidityAmount.sub(amountToLiquify);

if( amountToSwap == 0 ) {

function _swapTokensForFTM(uint256 tokenAmount, address receiver) private {

return;

}

address[] memory path = new address[](2);

path[0] = address(this);

path[1] = router.WETH();

uint256 balanceBefore = address(this).balance;

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

amountToSwap,

tokenAmount,

path,

address(this),

receiver,

block.timestamp

);

uint256 amountETHLiquidity = address(this).balance.sub(balanceBefore);

if (amountToLiquify > 0&&amountETHLiquidity > 0) {

router.addLiquidityETH{value: amountETHLiquidity}(

address(this),

amountToLiquify,

owner(),

block.timestamp

);

}

_lastAddLiquidityTime = block.timestamp;

}

function _swapTokensForUsdc(uint256 tokenAmount, address receiver) private {

function swapBack() internal swapping {

address[] memory path = new address[](3);

uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);

if( amountToSwap == 0) {

return;

}

uint256 balanceBefore = address(this).balance;

address[] memory path = new address[](2);

path[0] = address(this);

path[1] = router.WETH();

path[2] = usdcToken;

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

router.swapExactTokensForTokensSupportingFeeOnTransferTokens(

amountToSwap,

tokenAmount,

path,

address(this),

receiver,

block.timestamp

);

}

uint256 currentBalance = address(this).balance.sub(

function swapBack() internal swapping {

balanceBefore

uint256 realTotalFee = totalBuyFee.add(totalSellFee);

);

uint256 _currentFee = treasuryFee.add(insuranceFee).add(wsfBankFee).add(nftHolderFee);

uint256 dynamicLiquidityFee = isLiquidityEnabled ? liquidityFee : 0;

uint256 contractTokenBalance = _gonBalances[address(this)].div(_gonsPerFragment);

(bool success, ) = payable(treasuryReceiver).call{

uint256 amountToLiquify = contractTokenBalance.mul(dynamicLiquidityFee.mul(2)).div(realTotalFee);

value: currentBalance.mul(treasuryFee).div(

uint256 amountToBurn = contractTokenBalance.mul(buyBurnFee.mul(2).add(sellBurnFeeAdded)).div(realTotalFee);

_currentFee

uint256 amountToRFV = contractTokenBalance.mul(buyFeeRFV.mul(2).add(sellFeeRFVAdded)).div(realTotalFee);

uint256 amountToxLibero = contractTokenBalance.mul(buyxLiberoFee.mul(2).add(sellxLiberoFeeAdded)).div(realTotalFee);

gas: 30000

uint256 amountToTreasury = contractTokenBalance.sub(amountToLiquify).sub(amountToBurn).sub(amountToRFV).sub(amountToxLibero);

}("");

(success, ) = payable(insuranceReceiver).call{

if(amountToLiquify > 0){

value: currentBalance.mul(insuranceFee).div(

_swapAndLiquify(amountToLiquify);

_currentFee

}

gas: 30000

}("");

(success, ) = payable(wsfBankReceiver).call{

if(amountToBurn > 0){

value: currentBalance.mul(wsfBankFee).div(

_basicTransfer(address(this), DEAD, amountToBurn);

_currentFee

}

gas: 30000

}("");

(success, ) = payable(nftHolderReceiver).call{

if(amountToRFV > 0){

value: currentBalance.mul(nftHolderFee).div(

if(isRfvInFtm){

_currentFee

_swapTokensForFTM(amountToRFV, riskFreeValueReceiver);

}else{

gas: 30000

_swapTokensForUsdc(amountToRFV, riskFreeValueReceiver);

}("");

}

if(amountToxLibero > 0){

_swapTokensForUsdc(amountToxLibero, xLiberoReceiver);

}

if(amountToTreasury > 0){

_swapTokensForFTM(amountToTreasury, treasuryReceiver);

}

emit SwapBack(contractTokenBalance, amountToLiquify, amountToRFV, amountToTreasury);

}

function withdrawAllToTreasury() external swapping onlyOwner {

function takeFee(address sender, address recipient, uint256 gonAmount) internal returns (uint256){

uint256 _realFee = totalBuyFee;

if(automatedMarketMakerPairs[recipient]) _realFee = totalSellFee;

uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);

uint256 feeAmount = gonAmount.mul(_realFee).div(FEE_DENOMINATOR);

require( amountToSwap > 0,"There is no token deposited in token contract");

address[] memory path = new address[](2);

_gonBalances[address(this)] = _gonBalances[address(this)].add(feeAmount);

path[0] = address(this);

emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));

path[1] = router.WETH();

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

return gonAmount.sub(feeAmount);

amountToSwap,

}

path,

function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool){

treasuryReceiver,

uint256 oldValue = _allowedFragments[msg.sender][spender];

block.timestamp

if (subtractedValue >= oldValue) {

_allowedFragments[msg.sender][spender] = 0;

} else {

_allowedFragments[msg.sender][spender] = oldValue.sub(

subtractedValue

);

}

emit Approval(

msg.sender,

spender,

_allowedFragments[msg.sender][spender]

);

return true;

}

function shouldTakeFee(address from, address to)

function increaseAllowance(address spender, uint256 addedValue) external returns (bool){

internal

_allowedFragments[msg.sender][spender] = _allowedFragments[msg.sender][

view

spender

returns (bool)

].add(addedValue);

{

emit Approval(

return

msg.sender,

(pair == from || pair == to) &&

spender,

!_isFeeExempt[from];

_allowedFragments[msg.sender][spender]

);

return true;

}

function shouldRebase() internal view returns (bool) {

function approve(address spender, uint256 value) external override returns (bool){

return

_allowedFragments[msg.sender][spender] = value;

_autoRebase &&

emit Approval(msg.sender, spender, value);

(_totalSupply < MAX_SUPPLY) &&

return true;

msg.sender != pair &&

!inSwap &&

block.number >= (_lastRebasedTime + 1);

}

function shouldAddLiquidity() internal view returns (bool) {

function _rebase() private {

return

if(!inSwap) {

_autoAddLiquidity &&

int256 supplyDelta = int256(_totalSupply.mul(rewardYield).div(REWARD_YIELD_DENOMINATOR));

!inSwap &&

coreRebase(supplyDelta);

}

function coreRebase(int256 supplyDelta) private returns (uint256) {

uint256 epoch = block.timestamp;

if (supplyDelta == 0) {

emit LogRebase(epoch, _totalSupply);

return _totalSupply;

}

if (supplyDelta < 0) {

_totalSupply = _totalSupply.sub(uint256(-supplyDelta));

} else {

_totalSupply = _totalSupply.add(uint256(supplyDelta));

}

if (_totalSupply > MAX_SUPPLY) {

_totalSupply = MAX_SUPPLY;

}

_gonsPerFragment = TOTAL_GONS.div(_totalSupply);

nextRebase = epoch + rebaseFrequency;

emit LogRebase(epoch, _totalSupply);

return _totalSupply;

}

function manualRebase() external authorized{

require(!inSwap, "Try again");

require(nextRebase <= block.timestamp, "Not in time");

int256 supplyDelta = int256(_totalSupply.mul(rewardYield).div(REWARD_YIELD_DENOMINATOR));

coreRebase(supplyDelta);

manualSync();

}

function setAutomatedMarketMakerPair(address _pair, bool _value) public onlyOwner {

require(automatedMarketMakerPairs[_pair] != _value, "Value already set");

automatedMarketMakerPairs[_pair] = _value;

if(_value){

_makerPairs.push(_pair);

}else{

require(_makerPairs.length > 1, "Required 1 pair");

for (uint256 i = 0; i < _makerPairs.length; i++) {

if (_makerPairs[i] == _pair) {

_makerPairs[i] = _makerPairs[_makerPairs.length - 1];

_makerPairs.pop();

break;

}

emit SetAutomatedMarketMakerPair(_pair, _value);

}

function setInitialDistributionFinished(bool _value) external onlyOwner {

require(initialDistributionFinished != _value, "Not changed");

initialDistributionFinished = _value;

}

function setFeeExempt(address _addr, bool _value) external onlyOwner {

require(_isFeeExempt[_addr] != _value, "Not changed");

_isFeeExempt[_addr] = _value;

}

function setSwapThreshold(uint256 _value) external onlyOwner {

require(swapThreshold != _value, "Not changed");

swapThreshold = _value;

}

function setFeeReceivers(

address _liquidityReceiver,

address _treasuryReceiver,

address _riskFreeValueReceiver,

address _xLiberoReceiver

) external onlyOwner {

require(_liquidityReceiver != address(0), "Invalid _liquidityReceiver");

require(_treasuryReceiver != address(0), "Invalid _treasuryReceiver");

require(_riskFreeValueReceiver != address(0), "Invalid _riskFreeValueReceiver");

require(_xLiberoReceiver != address(0), "Invalid _xLiberoReceiver");

liquidityReceiver = _liquidityReceiver;

treasuryReceiver = _treasuryReceiver;

riskFreeValueReceiver = _riskFreeValueReceiver;

xLiberoReceiver = _xLiberoReceiver;

}

function setFees(

uint256 _liquidityFee,

uint256 _riskFreeValue,

uint256 _treasuryFee,

uint256 _bu

Saved diffs

Original text

Open file

/**
 *Submitted for verification at BscScan.com on 2022-03-28
*/

// SPDX-License-Identifier: Unlicensed
//

pragma solidity ^0.7.4;

library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

function div(int256 a, int256 b) internal pure returns (int256) {
        require(b != -1 || a != MIN_INT256);

return a / b;
    }

function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

return c;
    }

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

return c;
    }

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

return c;
    }

function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;

return c;
    }

function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

function balanceOf(address who) external view returns (uint256);

function allowance(address owner, address spender)
    external
    view
    returns (uint256);

function transfer(address to, uint256 value) external returns (bool);

function approve(address spender, uint256 value) external returns (bool);

function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);

event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

interface IPancakeSwapPair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

function initialize(address, address) external;
}

interface IPancakeSwapRouter{
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
    external
    payable
    returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
    external
    returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
    external
    returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
    external
    payable
    returns (uint[] memory amounts);

function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IPancakeSwapFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

function createPair(address tokenA, address tokenB) external returns (address pair);

function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

contract Ownable {
    address private _owner;

event OwnershipRenounced(address indexed previousOwner);

event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

constructor() {
        _owner = msg.sender;
    }

function owner() public view returns (address) {
        return _owner;
    }

modifier onlyOwner() {
        require(isOwner());
        _;
    }

function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

function renounceOwnership() public onlyOwner {
        emit OwnershipRenounced(_owner);
        _owner = address(0);
    }

function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

abstract contract ERC20Detailed is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

constructor(
        string memory name_,
        string memory symbol_,
        uint8 decimals_
    ) {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }

function name() public view returns (string memory) {
        return _name;
    }

function symbol() public view returns (string memory) {
        return _symbol;
    }

function decimals() public view returns (uint8) {
        return _decimals;
    }
}

contract WallStreetFinance is ERC20Detailed, Ownable {

using SafeMath for uint256;
    using SafeMathInt for int256;

string public _name = "WallStreet Finance";
    string public _symbol = "WSF";
    uint8 public _decimals = 5;

IPancakeSwapPair public pairContract;
    mapping(address => bool) _isFeeExempt;

modifier validRecipient(address to) {
        require(to != address(0x0));
        _;
    }

uint256 public constant DECIMALS = 5;
    uint256 public constant MAX_UINT256 = ~uint256(0);
    uint8 public constant RATE_DECIMALS = 7;

uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 10 * 10**6 * 10**DECIMALS;

uint256 public liquidityFee = 40;
    uint256 public treasuryFee = 20;
    uint256 public insuranceFee = 60;
    uint256 public wsfBankFee = 20;
    uint256 public nftHolderFee = 20;

uint256 public sellFee = wsfBankFee.add(nftHolderFee);
    uint256 public burnFee = 10;
    uint256 public totalFee = liquidityFee.add(treasuryFee).add(insuranceFee).add(burnFee);
    uint256 public feeDenominator = 1000;

address DEAD = 0x000000000000000000000000000000000000dEaD;
    address ZERO = 0x0000000000000000000000000000000000000000;

address public wsfBankReceiver;
    address public nftHolderReceiver;

address public lpReceiver;
    address public treasuryReceiver;
    address public insuranceReceiver;
    address public firePit;
    address public pairAddress;
    bool public swapEnabled = true;
    IPancakeSwapRouter public router;
    address public pair;
    bool inSwap = false;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
    uint256 private constant MAX_SUPPLY = 10 * 10**10 * 10**DECIMALS;

// BOOL Variables
    bool public _autoRebase = true;
    bool public _autoAddLiquidity = true;

// INT Variables
    uint256 public _initRebaseStartTime;
    uint256 public _lastRebasedTime;
    uint256 public _lastAddLiquidityTime;
    uint256 public _totalSupply;
    uint256 private _gonsPerFragment;
    // MAPPING
    mapping(address => uint256) private _gonBalances;
    mapping(address => mapping(address => uint256)) private _allowedFragments;
    mapping(address => bool) public blacklist;

// EVENT
    event Rebased(uint256 indexed epoch, uint256 totalSupply);

constructor() ERC20Detailed("WallStreet Finance", "WSF", uint8(DECIMALS)) Ownable() {

router = IPancakeSwapRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);
        pair = IPancakeSwapFactory(router.factory()).createPair(
            router.WETH(),
            address(this)
        );

lpReceiver = 0x5562640B953b6c2f79a655E930aFa68b2a65C627;
        treasuryReceiver = 0xa9fe433E3014772bbfeA2B56F8F23CD7b87B2cbb;
        insuranceReceiver = 0x180f8387A0538ee058D305877df5acdBa0947498;
        wsfBankReceiver = 0xEF0935155365db7496304bedc964470C589b9916;
        nftHolderReceiver = 0x741490Fa4c7C67c395C0b5F78a1D6Baaaaa75a09;
        firePit = 0x0000000000000000000000000000000000000000;

_allowedFragments[address(this)][address(router)] = uint256(-1);
        pairAddress = pair;
        pairContract = IPancakeSwapPair(pair);

_totalSupply = INITIAL_FRAGMENTS_SUPPLY;
        _gonBalances[owner()] = TOTAL_GONS;
        _gonsPerFragment = TOTAL_GONS.div(_totalSupply);
        _initRebaseStartTime = block.timestamp;
        _lastRebasedTime = block.number;

_isFeeExempt[owner()] = true;
        _isFeeExempt[address(this)] = true;

emit Transfer(address(0x0),  owner(), _totalSupply);
    }

function setZeroFees() external onlyOwner {
        liquidityFee = 0;
        treasuryFee = 0;
        insuranceFee = 0;
        wsfBankFee = 0;
        nftHolderFee = 0;
        burnFee = 0;

sellFee = 0;
        totalFee = 0;
    }

function setNormalFees() external onlyOwner {
        liquidityFee = 40;
        treasuryFee = 20;
        insuranceFee = 60;
        wsfBankFee = 20;
        nftHolderFee = 20;
        burnFee = 10;

sellFee = wsfBankFee.add(nftHolderFee);
        totalFee = liquidityFee.add(treasuryFee).add(insuranceFee).add(burnFee);

}

function manualRebase() external onlyOwner {
        rebase();
    }

function rebase() internal {

if ( inSwap ) return;

uint deno = 10**7 * 10**18;
        uint rebaseRate = 858 * 10**18;
        uint minuteRebaseRate = 17100 * 10**18;
        uint hourRebaseRate = 1000000 * 10**18;
        uint dayRebaseRate = 188800000 * 10**18;

uint blockCount = block.number.sub(_lastRebasedTime);
        uint tmp = _totalSupply;
        for (uint idx = 0; idx < blockCount.mod(20); idx++) { // 3 sec rebase
            // S' = S(1+p)^r
            tmp = tmp.mul(deno.mul(100).add(rebaseRate)).div(deno.mul(100));
        }

for (uint idx = 0; idx < blockCount.div(20).mod(60); idx++) { // 1 min rebase
            // S' = S(1+p)^r
            tmp = tmp.mul(deno.mul(100).add(minuteRebaseRate)).div(deno.mul(100));
        }

for (uint idx = 0; idx < blockCount.div(20 * 60).mod(24); idx++) { // 1 hour rebase
            // S' = S(1+p)^r
            tmp = tmp.mul(deno.mul(100).add(hourRebaseRate)).div(deno.mul(100));
        }

for (uint idx = 0; idx < blockCount.div(20 * 60 * 24); idx++) { // 1 day rebase
            // S' = S(1+p)^r
            tmp = tmp.mul(deno.mul(100).add(dayRebaseRate)).div(deno.mul(100));
        }

_totalSupply = tmp;
        _gonsPerFragment = TOTAL_GONS.div(tmp);
        _lastRebasedTime = block.number;

pairContract.sync();

emit Rebased(block.timestamp, _totalSupply);
    }

function transfer(address to, uint256 value)
    external
    override
    validRecipient(to)
    returns (bool)
    {
        _transferFrom(msg.sender, to, value);
        return true;
    }

function transferFrom(
        address from,
        address to,
        uint256 value
    ) external override validRecipient(to) returns (bool) {

if (_allowedFragments[from][msg.sender] != uint256(-1)) {
            _allowedFragments[from][msg.sender] = _allowedFragments[from][
            msg.sender
            ].sub(value, "Insufficient Allowance");
        }
        _transferFrom(from, to, value);
        return true;
    }

function _basicTransfer(
        address from,
        address to,
        uint256 amount
    ) internal returns (bool) {
        uint256 gonAmount = amount.mul(_gonsPerFragment);
        _gonBalances[from] = _gonBalances[from].sub(gonAmount);
        _gonBalances[to] = _gonBalances[to].add(gonAmount);
        return true;
    }

function _transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) internal returns (bool) {

require(!blacklist[sender] && !blacklist[recipient], "in_blacklist");

if (inSwap) {
            return _basicTransfer(sender, recipient, amount);
        }
        if (shouldRebase()) {
            rebase();
        }

if (shouldAddLiquidity()) {
            addLiquidity();
        }

if (shouldSwapBack()) {
            swapBack();
        }

uint256 gonAmount = amount.mul(_gonsPerFragment);
        _gonBalances[sender] = _gonBalances[sender].sub(gonAmount);
        uint256 gonAmountReceived = shouldTakeFee(sender, recipient)
        ? takeFee(sender, recipient, gonAmount)
        : gonAmount;
        _gonBalances[recipient] = _gonBalances[recipient].add(
            gonAmountReceived
        );

emit Transfer(
            sender,
            recipient,
            gonAmountReceived.div(_gonsPerFragment)
        );
        return true;
    }

function takeFee(
        address sender,
        address recipient,
        uint256 gonAmount
    ) internal  returns (uint256) {
        uint256 _totalFee = totalFee;

if (recipient == pair) {
            _totalFee = totalFee.add(sellFee);
        }

uint256 feeAmount = gonAmount.div(feeDenominator).mul(_totalFee);

_gonBalances[firePit] = _gonBalances[firePit].add(
            gonAmount.div(feeDenominator).mul(burnFee)
        );
        uint256 maintainFee = _totalFee - burnFee - liquidityFee;

_gonBalances[address(this)] = _gonBalances[address(this)].add(
            gonAmount.div(feeDenominator).mul(maintainFee)
        );
        _gonBalances[lpReceiver] = _gonBalances[lpReceiver].add(
            gonAmount.div(feeDenominator).mul(liquidityFee)
        );

emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));
        return gonAmount.sub(feeAmount);
    }

function addLiquidity() internal swapping {
        uint256 autoLiquidityAmount = _gonBalances[lpReceiver].div(
            _gonsPerFragment
        );
        _gonBalances[address(this)] = _gonBalances[address(this)].add(
            _gonBalances[lpReceiver]
        );
        _gonBalances[lpReceiver] = 0;
        uint256 amountToLiquify = autoLiquidityAmount.div(2);
        uint256 amountToSwap = autoLiquidityAmount.sub(amountToLiquify);

if( amountToSwap == 0 ) {
            return;
        }
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

uint256 balanceBefore = address(this).balance;

router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

uint256 amountETHLiquidity = address(this).balance.sub(balanceBefore);

if (amountToLiquify > 0&&amountETHLiquidity > 0) {
            router.addLiquidityETH{value: amountETHLiquidity}(
                address(this),
                amountToLiquify,
                0,
                0,
                owner(),
                block.timestamp
            );
        }
        _lastAddLiquidityTime = block.timestamp;
    }

function swapBack() internal swapping {

uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);

if( amountToSwap == 0) {
            return;
        }

uint256 balanceBefore = address(this).balance;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

uint256 currentBalance = address(this).balance.sub(
            balanceBefore
        );

uint256 _currentFee = treasuryFee.add(insuranceFee).add(wsfBankFee).add(nftHolderFee);

(bool success, ) = payable(treasuryReceiver).call{
        value: currentBalance.mul(treasuryFee).div(
            _currentFee
        ),
        gas: 30000
        }("");

(success, ) = payable(insuranceReceiver).call{
        value: currentBalance.mul(insuranceFee).div(
            _currentFee
        ),
        gas: 30000
        }("");

(success, ) = payable(wsfBankReceiver).call{
        value: currentBalance.mul(wsfBankFee).div(
            _currentFee
        ),
        gas: 30000
        }("");

(success, ) = payable(nftHolderReceiver).call{
        value: currentBalance.mul(nftHolderFee).div(
            _currentFee
        ),
        gas: 30000
        }("");
    }

function withdrawAllToTreasury() external swapping onlyOwner {

uint256 amountToSwap = _gonBalances[address(this)].div(_gonsPerFragment);
        require( amountToSwap > 0,"There is no token deposited in token contract");
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            treasuryReceiver,
            block.timestamp
        );
    }

function shouldTakeFee(address from, address to)
    internal
    view
    returns (bool)
    {
        return
        (pair == from || pair == to) &&
        !_isFeeExempt[from];
    }

function shouldRebase() internal view returns (bool) {
        return
        _autoRebase &&
        (_totalSupply < MAX_SUPPLY) &&
        msg.sender != pair  &&
        !inSwap &&
        block.number >= (_lastRebasedTime + 1);
    }

function shouldAddLiquidity() internal view returns (bool) {
        return
        _autoAddLiquidity &&
        !inSwap &&
        msg.sender != pair &&
        block.timestamp >= (_lastAddLiquidityTime + 2 days);
    }

function shouldSwapBack() internal view returns (bool) {
        return
        !inSwap &&
        msg.sender != pair  ;
    }

function allowance(address owner_, address spender)
    external
    view
    override
    returns (uint256)
    {
        return _allowedFragments[owner_][spender];
    }

function increaseAllowance(address spender, uint256 addedValue)
    external
    returns (bool)
    {
        _allowedFragments[msg.sender][spender] = _allowedFragments[msg.sender][
        spender
        ].add(addedValue);
        emit Approval(
            msg.sender,
            spender,
            _allowedFragments[msg.sender][spender]
        );
        return true;
    }

function approve(address spender, uint256 value)
    external
    override
    returns (bool)
    {
        _allowedFragments[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

function checkFeeExempt(address _addr) external view returns (bool) {
        return _isFeeExempt[_addr];
    }

function getCirculatingSupply() public view returns (uint256) {
        return
        (TOTAL_GONS.sub(_gonBalances[DEAD]).sub(_gonBalances[ZERO])).div(
            _gonsPerFragment
        );
    }

function isNotInSwap() external view returns (bool) {
        return !inSwap;
    }

function manualSync() external {
        IPancakeSwapPair(pair).sync();
    }

function setFeeReceivers(
        address _lpReceiver,
        address _treasuryReceiver,
        address _insuranceReceiver,
        address _nftHolderReceiver,
        address _wsfBankReceiver
    ) external onlyOwner {
        treasuryReceiver = _treasuryReceiver;
        insuranceReceiver = _insuranceReceiver;
        nftHolderReceiver = _nftHolderReceiver;
        wsfBankReceiver = _wsfBankReceiver;
        lpReceiver = _lpReceiver;
    }

function getLiquidityBacking(uint256 accuracy)
    public
    view
    returns (uint256)
    {
        uint256 liquidityBalance = _gonBalances[pair].div(_gonsPerFragment);
        return
        accuracy.mul(liquidityBalance.mul(2)).div(getCirculatingSupply());
    }

function setWhitelist(address _addr) external onlyOwner {
        _isFeeExempt[_addr] = true;
    }

function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
        require(isContract(_botAddress), "only contract address, not allowed exteranlly owned account");
        blacklist[_botAddress] = _flag;
    }

function setPairAddress(address _pairAddress) public onlyOwner {
        pairAddress = _pairAddress;
    }

function setLP(address _address) external onlyOwner {
        pairContract = IPancakeSwapPair(_address);
    }

function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }

function balanceOf(address who) external view override returns (uint256) {
        return _gonBalances[who].div(_gonsPerFragment);
    }

function isContract(address addr) internal view returns (bool) {
        uint size;
        assembly { size := extcodesize(addr) }
        return size > 0;
    }

receive() external payable {}
}

Changed text

Open file

/**
 *Submitted for verification at FtmScan.com on 2022-03-29
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.4;

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

function _msgData() internal view virtual returns (bytes memory) {
        this;
        return msg.data;
    }
}

abstract contract Auth is Context{
    address owner;
    mapping (address => bool) private authorizations;

constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }

modifier onlyOwner() {
        require(isOwner(msg.sender)); _;
    }

modifier authorized() {
        require(isAuthorized(msg.sender)); _;
    }

function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
        emit Authorized(adr);
    }

function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
        emit Unauthorized(adr);
    }

function isOwner(address account) public view returns (bool) {
        return account == owner;
    }

function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

function transferOwnership(address payable adr) public onlyOwner {
        owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

event OwnershipTransferred(address owner);
    event Authorized(address adr);
    event Unauthorized(address adr);
}