テキスト比較

2 つのテキストファイルの違いを見つける

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

ツール

WSFvsFLibero

Created 2 years agoDiff never expires

/**

*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;

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

}

pragma solidity ^0.7.4;

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

function sync() external;

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

}

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

library Roles {

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

struct Role {

function decimals() external pure returns (uint8);

mapping (address => bool) bearer;

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 add(Role storage role, address account) internal {

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

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

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

role.bearer[account] = true;

}

function DOMAIN_SEPARATOR() external view returns (bytes32);

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

function PERMIT_TYPEHASH() external pure returns (bytes32);

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

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

role.bearer[account] = false;

}

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

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

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

return role.bearer[account];

}

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

abstract contract ERC20Detailed is IERC20 {

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

string private _name;

event Swap(

string private _symbol;

address indexed sender,

uint8 private _decimals;

uint amount0In,

uint amount1In,

uint amount0Out,

uint amount1Out,

address indexed to

);

event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint);

constructor(

function factory() external view returns (address);

string memory _tokenName,

function token0() external view returns (address);

string memory _tokenSymbol,

function token1() external view returns (address);

uint8 _tokenDecimals

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

) {

function price0CumulativeLast() external view returns (uint);

_name = _tokenName;

function price1CumulativeLast() external view returns (uint);

_symbol = _tokenSymbol;

function kLast() external view returns (uint);

_decimals = _tokenDecimals;

}

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

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

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

return _name;

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

}

function skim(address to) external;

function sync() external;

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

return _symbol;

}

function initialize(address, address) external;

function decimals() public view returns (uint8) {

return _decimals;

}

interface IPancakeSwapRouter{

interface IDEXRouter {

function factory() external pure returns (address);

function WETH() external pure returns (address);

function addLiquidity(

address tokenA,

address tokenB,

uint amountADesired,

uint256 amountADesired,

uint amountBDesired,

uint256 amountBDesired,

uint amountAMin,

uint256 amountAMin,

uint amountBMin,

uint256 amountBMin,

address to,

uint deadline

uint256 deadline

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

)

external

returns (

uint256 amountA,

uint256 amountB,

uint256 liquidity

);

function addLiquidityETH(

address token,

uint amountTokenDesired,

uint256 amountTokenDesired,

uint amountTokenMin,

uint256 amountTokenMin,

uint amountETHMin,

uint256 amountETHMin,

address to,

uint deadline

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

returns (

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

uint256 amountToken,

external

uint256 amountETH,

returns (uint[] memory amounts);

uint256 liquidity

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,

uint256 amountIn,

uint amountOutMin,

uint256 amountOutMin,

address[] calldata path,

address to,

uint deadline

uint256 deadline

) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(

uint amountOutMin,

uint256 amountOutMin,

address[] calldata path,

address to,

uint deadline

uint256 deadline

) external payable;

function swapExactTokensForETHSupportingFeeOnTransferTokens(

uint amountIn,

uint256 amountIn,

uint amountOutMin,

uint256 amountOutMin,

address[] calldata path,

address to,

uint deadline

uint256 deadline

) external;

}

interface IPancakeSwapFactory {

interface IDEXFactory {

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

function createPair(address tokenA, address tokenB)

external

function feeTo() external view returns (address);

returns (address pair);

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 {

contract FLiberoToken is ERC20Detailed, Auth {

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;

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;

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;

bool inSwap;

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

modifier validRecipient(address to) {

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

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

}

// BOOL Variables

uint256 private _totalSupply;

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

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

event Rebased(uint256 indexed epoch, uint256 totalSupply);

router = IDEXRouter(0xF491e7B69E4244ad4002BC14e878a34207E38c29);

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

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

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

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

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

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

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

router = IPancakeSwapRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);

setAutomatedMarketMakerPair(pair, true);

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

setAutomatedMarketMakerPair(pairUsdc, true);

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;

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

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

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

return _gonBalances[who].div(_gonsPerFragment);

}

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

return _isFeeExempt[_addr];

}

function manualRebase() external onlyOwner {

function shouldRebase() internal view returns (bool) {

rebase();

return nextRebase <= block.timestamp;

}

function rebase() internal {

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

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

return false;

}else if (feesOnNormalTransfers){

return true;

}else{

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

}

if ( inSwap ) return;

function shouldSwapBack() internal view returns (bool) {

return

!automatedMarketMakerPairs[msg.sender] &&

!inSwap &&

swapThreshold > 0 &&

totalBuyFee.add(totalSellFee) > 0 &&

balanceOf(address(this)) >= swapThreshold;

}

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

function getCirculatingSupply() public view returns (uint256) {

uint rebaseRate = 858 * 10**18;

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

uint minuteRebaseRate = 17100 * 10**18;

}

uint hourRebaseRate = 1000000 * 10**18;

uint dayRebaseRate = 188800000 * 10**18;

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

function manualSync() public {

uint tmp = _totalSupply;

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

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

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

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

}catch Error (string memory reason) {

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

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

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

emit GenericErrorEvent(reason);

}

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)

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) {

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

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

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

) internal returns (bool) {

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

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) {

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;

}

_transferFrom(from, to, value);

return true;

}

function _swapAndLiquify(uint256 contractTokenBalance) private {

uint256 half = contractTokenBalance.div(2);

uint256 otherHalf = contractTokenBalance.sub(half);

if(isLiquidityInFtm){

uint256 initialBalance = address(this).balance;

_swapTokensForFTM(half, address(this));

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

_addLiquidity(otherHalf, newBalance);

if (recipient == pair) {

emit SwapAndLiquify(half, newBalance, otherHalf);

_totalFee = totalFee.add(sellFee);

}else{

}

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

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

_swapTokensForUsdc(half, address(this));

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

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

gonAmount.div(feeDenominator).mul(burnFee)

);

uint256 maintainFee = _totalFee - burnFee - liquidityFee;

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

addLiquidityUsdc(otherHalf, newBalance);

gonAmount.div(feeDenominator).mul(maintainFee)

);

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

gonAmount.div(feeDenominator).mul(liquidityFee)

);

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

emit SwapAndLiquifyUsdc(half, newBalance, otherHalf);

return gonAmount.sub(feeAmount);

}

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

);

}

function _swapTokensForUsdc(uint256 tokenAmount, address receiver) private {

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

path[0] = address(this);

path[1] = router.WETH();

path[2] = usdcToken;

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

router.swapExactTokensForTokensSupportingFeeOnTransferTokens(

tokenAmount,

path,

receiver,

block.timestamp

);

}

function swapBack() internal swapping {

uint256 realTotalFee = totalBuyFee.add(totalSellFee);

uint256 dynamicLiquidityFee = isLiquidityEnabled ? liquidityFee : 0;

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

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

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

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

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

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

if(amountToLiquify > 0){

_swapAndLiquify(amountToLiquify);

}

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

if(amountToBurn > 0){

router.addLiquidityETH{value: amountETHLiquidity}(

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

address(this),

amountToLiquify,

owner(),

block.timestamp

);

}

_lastAddLiquidityTime = block.timestamp;

}

function swapBack() internal swapping {

if(amountToRFV > 0){

if(isRfvInFtm){

_swapTokensForFTM(amountToRFV, riskFreeValueReceiver);

}else{

_swapTokensForUsdc(amountToRFV, riskFreeValueReceiver);

}

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

if(amountToxLibero > 0){

_swapTokensForUsdc(amountToxLibero, xLiberoReceiver);

}

if( amountToSwap == 0) {

if(amountToTreasury > 0){

return;

_swapTokensForFTM(amountToTreasury, treasuryReceiver);

}

uint256 balanceBefore = address(this).balance;

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

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

}

path[0] = address(this);

path[1] = router.WETH();

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

uint256 _realFee = totalBuyFee;

if(automatedMarketMakerPairs[recipient]) _realFee = totalSellFee;

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

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

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

return gonAmount.sub(feeAmount);

}

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

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

amountToSwap,

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

if (subtractedValue >= oldValue) {

path,

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

address(this),

} else {

block.timestamp

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

subtractedValue

);

}

emit Approval(

msg.sender,

spender,

_allowedFragments[msg.sender][spender]

);

return true;

}

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

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

balanceBefore

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

spender

].add(addedValue);

emit Approval(

msg.sender,

spender,

_allowedFragments[msg.sender][spender]

);

return true;

}

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

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

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

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

return true;

}

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

function _rebase() private {

value: currentBalance.mul(treasuryFee).div(

if(!inSwap) {

_currentFee

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

gas: 30000

}("");

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

coreRebase(supplyDelta);

value: currentBalance.mul(insuranceFee).div(

}

_currentFee

}

gas: 30000

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;

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

if(_value){

value: currentBalance.mul(wsfBankFee).div(

_makerPairs.push(_pair);

_currentFee

}else{

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

gas: 30000

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

}("");

if (_makerPairs[i] == _pair) {

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

_makerPairs.pop();

break;

}

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

emit SetAutomatedMarketMakerPair(_pair, _value);

value: currentBalance.mul(nftHolderFee).div(

_currentFee

gas: 30000

}("");

}

function withdrawAllToTreasury() external swapping onlyOwner {

function setInitialDistributionFinished(bool _value) external onlyOwner {

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

initialDistributionFinished = _value;

}

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

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

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

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

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

_isFeeExempt[_addr] = _value;

path[0] = address(this);

path[1] = router.WETH();

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

amountToSwap,

path,

treasuryReceiver,

block.timestamp

);

}

function shouldTakeFee(address from, address to)

function setSwapThreshold(uint256 _value) external onlyOwner {

internal

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

view

swapThreshold = _value;

returns (bool)

{

return

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

!_isFeeExempt[from];

}

function shouldRebase() internal view returns (bool) {

function setFeeReceivers(

return

address _liquidityReceiver,

_autoRebase &&

address _treasuryReceiver,

(_totalSupply < MAX_SUPPLY) &&

address _riskFreeValueReceiver,

msg.sender != pair &&

address _xLiberoReceiver

!inSwap &&

) external onlyOwner {

block.number >= (_lastRebasedTime + 1);

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 shouldAddLiquidity() internal view returns (bool) {

function setFees(

return

uint256 _liquidityFee,

_autoAddLiquidity &&

uint256 _riskFreeValue,

!inSwap &&

uint256 _treasuryFee,

uint256 _bu

保存された差分

原文

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 setAutoRebase(bool _flag) external onlyOwner {
        if (_flag) {
            _autoRebase = _flag;
            _lastRebasedTime = block.number;
        } else {
            _autoRebase = _flag;
        }
    }

    function setAutoAddLiquidity(bool _flag) external onlyOwner {
        if(_flag) {
            _autoAddLiquidity = _flag;
            _lastAddLiquidityTime = block.timestamp;
        } else {
            _autoAddLiquidity = _flag;
        }
    }

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

    function decreaseAllowance(address spender, uint256 subtractedValue)
    external
    returns (bool)
    {
        uint256 oldValue = _allowedFragments[msg.sender][spender];
        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 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 {}
}

変更されたテキスト

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

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 InterfaceLP {
    function sync() external;
}

library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

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

    constructor(
        string memory _tokenName,
        string memory _tokenSymbol,
        uint8 _tokenDecimals
    ) {
        _name = _tokenName;
        _symbol = _tokenSymbol;
        _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;
    }
}

interface IDEXRouter {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
    external
    returns (
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity
    );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

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;

    uint256 public rewardYield = 1402777;
    uint256 public rebaseFrequency = 600;
    uint256 public nextRebase = block.timestamp + 31536000;
    uint256 public maxSellTransactionAmount = 2000000 * 10 ** 18;
    uint256 public swapThreshold = 400000 * 10**18;

    mapping(address => bool) _isFeeExempt;
    address[] private _makerPairs;
    mapping (address => bool) public automatedMarketMakerPairs;

    uint256 private constant REWARD_YIELD_DENOMINATOR = 10000000000;
    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);

    address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
    address private constant ZERO = 0x0000000000000000000000000000000000000000;
    address public constant usdcToken = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;
    
    address public liquidityReceiver = 0x730736E3cdffc531b74eb8B30bD2CC50beb8Ab3c;
    address public treasuryReceiver = 0x3ff8970f17d463b83D289827B7B8E5Eed61Cc3e8;
    address public riskFreeValueReceiver = 0x14c02711A4678fc7De388e77e99B07753C856e84;
    address public xLiberoReceiver = 0x8689EDAb5Bdb17b11273a5C9412C4BBC8f2Ec4F8;

    IDEXRouter public router;
    address public pair;

    uint256 public liquidityFee = 40;
    uint256 public treasuryFee = 30;
    uint256 public buyFeeRFV = 50;
    uint256 public buyBurnFee = 20;
    uint256 public buyxLiberoFee = 0;
    uint256 public sellFeeTreasuryAdded = 20;
    uint256 public sellFeeRFVAdded = 40;
    uint256 public sellBurnFeeAdded = 0;
    uint256 public sellxLiberoFeeAdded = 0;
    uint256 public totalBuyFee = liquidityFee.add(treasuryFee).add(buyFeeRFV).add(buyBurnFee).add(buyxLiberoFee);
    uint256 public totalSellFee = totalBuyFee.add(sellFeeTreasuryAdded).add(sellFeeRFVAdded).add(sellBurnFeeAdded).add(sellxLiberoFeeAdded);

    bool inSwap;

    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

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

    uint256 private _totalSupply;
    uint256 private _gonsPerFragment;

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

    constructor() ERC20Detailed("Fantom Libero Financial Freedom", "FLIBERO", uint8(DECIMALS)) Auth(msg.sender) {
        router = IDEXRouter(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
        pair = IDEXFactory(router.factory()).createPair(address(this), router.WETH());
        address pairUsdc = IDEXFactory(router.factory()).createPair(address(this), usdcToken);

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

        setAutomatedMarketMakerPair(pair, true);
        setAutomatedMarketMakerPair(pairUsdc, true);

        _totalSupply = INITIAL_FRAGMENTS_SUPPLY;
        _gonBalances[msg.sender] = TOTAL_GONS;
        _gonsPerFragment = TOTAL_GONS.div(_totalSupply);

        _isFeeExempt[treasuryReceiver] = true;
        _isFeeExempt[riskFreeValueReceiver] = true;
        _isFeeExempt[address(this)] = true;
        _isFeeExempt[msg.sender] = true;

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

    receive() external payable {}

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

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

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

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

    function shouldRebase() internal view returns (bool) {
        return nextRebase <= block.timestamp;
    }

    function shouldTakeFee(address from, address to) internal view returns (bool) {
        if(_isFeeExempt[from] || _isFeeExempt[to]){
            return false;
        }else if (feesOnNormalTransfers){
            return true;
        }else{
            return (automatedMarketMakerPairs[from] || automatedMarketMakerPairs[to]);
        }
    }

    function shouldSwapBack() internal view returns (bool) {
        return
        !automatedMarketMakerPairs[msg.sender] &&
        !inSwap &&
        swapThreshold > 0 &&
        totalBuyFee.add(totalSellFee) > 0 &&
        balanceOf(address(this)) >= swapThreshold;
    }

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

    function manualSync() public {
        for(uint i = 0; i < _makerPairs.length; i++){
            try InterfaceLP(_makerPairs[i]).sync() {

            }catch Error (string memory reason) {
                emit GenericErrorEvent("manualSync(): _makerPairs.sync() Failed");
                emit GenericErrorEvent(reason);
            }
        }
    }

    function transfer(address to, uint256 value) external override validRecipient(to) returns (bool){
        _transferFrom(msg.sender, 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(address sender, address recipient, uint256 amount) internal returns (bool) {
        bool excludedAccount = _isFeeExempt[sender] || _isFeeExempt[recipient];

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

        if (
            automatedMarketMakerPairs[recipient] &&
            !excludedAccount
        ) {
            require(amount <= maxSellTransactionAmount, "Error amount");
        }

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

        uint256 gonAmount = amount.mul(_gonsPerFragment);

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

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

        if(
            shouldRebase() &&
            autoRebase &&
            !automatedMarketMakerPairs[sender] &&
            !automatedMarketMakerPairs[recipient]
        ) {
            _rebase();
            manualSync();
        }

        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 _swapAndLiquify(uint256 contractTokenBalance) private {
        uint256 half = contractTokenBalance.div(2);
        uint256 otherHalf = contractTokenBalance.sub(half);

        if(isLiquidityInFtm){
            uint256 initialBalance = address(this).balance;

            _swapTokensForFTM(half, address(this));

            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(uint256 tokenAmount, uint256 ftmAmount) private {
        router.addLiquidityETH{value: ftmAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            liquidityReceiver,
            block.timestamp
        );
    }

    function addLiquidityUsdc(uint256 tokenAmount, uint256 usdcAmount) private {
        router.addLiquidity(
            address(this),
            usdcToken,
            tokenAmount,
            usdcAmount,
            0,
            0,
            liquidityReceiver,
            block.timestamp
        );
    }

    function _swapTokensForFTM(uint256 tokenAmount, address receiver) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            receiver,
            block.timestamp
        );
    }
    function _swapTokensForUsdc(uint256 tokenAmount, address receiver) private {
        address[] memory path = new address[](3);
        path[0] = address(this);
        path[1] = router.WETH();
        path[2] = usdcToken;

        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            receiver,
            block.timestamp
        );
    }

    function swapBack() internal swapping {
        uint256 realTotalFee = totalBuyFee.add(totalSellFee);

        uint256 dynamicLiquidityFee = isLiquidityEnabled ? liquidityFee : 0;
        uint256 contractTokenBalance = _gonBalances[address(this)].div(_gonsPerFragment);

        uint256 amountToLiquify = contractTokenBalance.mul(dynamicLiquidityFee.mul(2)).div(realTotalFee);
        uint256 amountToBurn = contractTokenBalance.mul(buyBurnFee.mul(2).add(sellBurnFeeAdded)).div(realTotalFee);
        uint256 amountToRFV = contractTokenBalance.mul(buyFeeRFV.mul(2).add(sellFeeRFVAdded)).div(realTotalFee);
        uint256 amountToxLibero = contractTokenBalance.mul(buyxLiberoFee.mul(2).add(sellxLiberoFeeAdded)).div(realTotalFee);
        uint256 amountToTreasury = contractTokenBalance.sub(amountToLiquify).sub(amountToBurn).sub(amountToRFV).sub(amountToxLibero);

        if(amountToLiquify > 0){
            _swapAndLiquify(amountToLiquify);
        }

        if(amountToBurn > 0){
            _basicTransfer(address(this), DEAD, amountToBurn);
        }

        if(amountToRFV > 0){
            if(isRfvInFtm){
                _swapTokensForFTM(amountToRFV, riskFreeValueReceiver);
            }else{
                _swapTokensForUsdc(amountToRFV, riskFreeValueReceiver);
            }
        }

        if(amountToxLibero > 0){
            _swapTokensForUsdc(amountToxLibero, xLiberoReceiver);
        }

        if(amountToTreasury > 0){
            _swapTokensForFTM(amountToTreasury, treasuryReceiver);
        }

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

    function takeFee(address sender, address recipient, uint256 gonAmount) internal returns (uint256){
        uint256 _realFee = totalBuyFee;
        if(automatedMarketMakerPairs[recipient]) _realFee = totalSellFee;

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

        _gonBalances[address(this)] = _gonBalances[address(this)].add(feeAmount);
        emit Transfer(sender, address(this), feeAmount.div(_gonsPerFragment));

        return gonAmount.sub(feeAmount);
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool){
        uint256 oldValue = _allowedFragments[msg.sender][spender];
        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 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 _rebase() private {
        if(!inSwap) {
            int256 supplyDelta = int256(_totalSupply.mul(rewardYield).div(REWARD_YIELD_DENOMINATOR));

            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 _burnFee,
        uint256 _xLiberoFee,
        uint256 _sellFeeTreasuryAdded,
        uint256 _sellFeeRFVAdded,
        uint256 _sellBurnFeeAdded,
        uint256 _sellxLiberoFeeAdded
    ) external onlyOwner {
        liquidityFee = _liquidityFee;
        buyFeeRFV = _riskFreeValue;
        treasuryFee = _treasuryFee;
        buyBurnFee = _burnFee;
        buyxLiberoFee = _xLiberoFee;
        sellFeeTreasuryAdded = _sellFeeTreasuryAdded;
        sellFeeRFVAdded = _sellFeeRFVAdded;
        sellBurnFeeAdded = _sellBurnFeeAdded;
        sellxLiberoFeeAdded = _sellxLiberoFeeAdded;

        totalBuyFee = liquidityFee.add(treasuryFee).add(buyFeeRFV).add(buyBurnFee).add(buyxLiberoFee);
        totalSellFee = totalBuyFee.add(sellFeeTreasuryAdded).add(sellFeeRFVAdded).add(sellBurnFeeAdded).add(sellxLiberoFeeAdded);

        require(totalBuyFee < MAX_TOTAL_BUY_FEE_RATE, "Total buy fee too high");
        require(totalSellFee < MAX_TOTAL_SELL_FEE_RATE, "Total sell fee too high");
    }

    function clearStuckBalance(address _receiver) external onlyOwner {
        uint256 balance = address(this).balance;
        payable(_receiver).transfer(balance);
    }

    function rescueToken(address tokenAddress) external onlyOwner returns (bool success){
        require(tokenAddress != address(this),"Not allow recuse Libero");
        uint256 amount = ERC20Detailed(tokenAddress).balanceOf(address(this));
        return ERC20Detailed(tokenAddress).transfer(msg.sender, amount);
    }

    function setAutoRebase(bool _autoRebase) external onlyOwner {
        require(autoRebase != _autoRebase, "Not changed");
        autoRebase = _autoRebase;
    }

    function setRebaseFrequency(uint256 _rebaseFrequency) external onlyOwner {
        require(_rebaseFrequency <= MAX_REBASE_FREQUENCY, "Too high");
        rebaseFrequency = _rebaseFrequency;
    }

    function setRewardYield(uint256 _rewardYield) external onlyOwner {
        require(rewardYield != _rewardYield, "Not changed");
        rewardYield = _rewardYield;
    }

    function setFeesOnNormalTransfers(bool _enabled) external onlyOwner {
        require(feesOnNormalTransfers != _enabled, "Not changed");
        feesOnNormalTransfers = _enabled;
    }

    function setIsLiquidityEnabled(bool _value) external onlyOwner {
        require(isLiquidityEnabled != _value, "Not changed");
        isLiquidityEnabled = _value;
    }

    function setIsLiquidityInFtm(bool _value) external onlyOwner {
        require(isLiquidityInFtm != _value, "Not changed");
        isLiquidityInFtm = _value;
    }

    function setIsRfvInFtm(bool _value) external onlyOwner {
        require(isRfvInFtm != _value, "Not changed");
        isRfvInFtm = _value;
    }

    function setNextRebase(uint256 _nextRebase) external onlyOwner {
        nextRebase = _nextRebase;
    }

    function setMaxSellTransaction(uint256 _maxTxn) external onlyOwner {
        require(_maxTxn >= MIN_MAX_SELL_AMOUNT, "Too small");
        maxSellTransactionAmount = _maxTxn;
    }

    event SwapBack(uint256 contractTokenBalance,uint256 amountToLiquify,uint256 amountToRFV,uint256 amountToTreasury);
    event SwapAndLiquify(uint256 tokensSwapped, uint256 ftmReceived, uint256 tokensIntoLiqudity);
    event SwapAndLiquifyUsdc(uint256 tokensSwapped, uint256 usdcReceived, uint256 tokensIntoLiqudity);
    event LogRebase(uint256 indexed epoch, uint256 totalSupply);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    event GenericErrorEvent(string reason);
}