Comparer le texte

Trouver la différence entre deux fichiers texte

Éditeur live

Cacher identiques

Sans retour à la ligne

Vue

Niveau de précision

Coloration syntaxique

Diffchecker Desktop La façon la plus sécurisée d'utiliser Diffchecker. Obtenez l'application Diffchecker Desktop : vos diffs ne quittent jamais votre ordinateur !Obtenir Desktop

WSFvsFLibero

Créé il y a 4 ansLe diff n'expire jamais

613 suppressions

Lignes
Total
Supprimé

Caractères
Total
Supprimé

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

826 lignes

564 ajouts

Lignes
Total
Ajouté

Caractères
Total
Ajouté

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

796 lignes

/**

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

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

// SPDX-License-Identifier: Unlicensed

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.4;

abstract contract Context {

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

return payable(msg.sender);

}

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

this;

return msg.data;

}

abstract contract Auth is Context{

address owner;

mapping (address => bool) private authorizations;

constructor(address _owner) {

owner = _owner;

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

authorizations[_owner] = true;

}

modifier onlyOwner() {

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

}

modifier authorized() {

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

}

function authorize(address adr) public onlyOwner {

authorizations[adr] = true;

emit Authorized(adr);

}

function unauthorize(address adr) public onlyOwner {

authorizations[adr] = false;

emit Unauthorized(adr);

}

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

return account == owner;

}

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

return authorizations[adr];

}

function transferOwnership(address payable adr) public onlyOwner {

owner = adr;

authorizations[adr] = true;

emit OwnershipTransferred(adr);

}

event OwnershipTransferred(address owner);

event Authorized(address adr);

event Unauthorized(address adr);

}

library SafeMathInt {

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

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

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

int256 c = a * b;

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

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

return c;

}

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

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

return a / b;

}

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

int256 c = a - b;

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

return c;

}

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

int256 c = a + b;

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

return c;

}

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

require(a != MIN_INT256);

return a < 0 ? -a : a;

}

library SafeMath {

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

uint256 c = a + b;

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

return c;

}

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

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

}

function sub(

uint256 a,

uint256 b,

string memory errorMessage

) internal pure returns (uint256) {

require(b <= a, errorMessage);

uint256 c = a - b;

return c;

}

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

if (a == 0) {

return 0;

}

uint256 c = a * b;

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

return c;

}

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

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

}

function div(

uint256 a,

uint256 b,

string memory errorMessage

) internal pure returns (uint256) {

require(b > 0, errorMessage);

uint256 c = a / b;

return c;

}

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

require(b != 0);

return a % b;

}

interface IERC20 {

function totalSupply() external view returns (uint256);

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

function allowance(address owner, address spender)

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

external

view

returns (uint256);

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

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

function transferFrom(

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

address from,

address to,

uint256 value

) external returns (bool);

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

event Approval(

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

address indexed owner,

address indexed spender,

uint256 value

);

}

interface IPancakeSwapPair {

interface InterfaceLP {

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

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

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

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

function decimals() external pure returns (uint8);

function totalSupply() external view returns (uint);

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

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

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

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

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

function DOMAIN_SEPARATOR() external view returns (bytes32);

function PERMIT_TYPEHASH() external pure returns (bytes32);

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

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

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

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

event Swap(

address indexed sender,

uint amount0In,

uint amount1In,

uint amount0Out,

uint amount1Out,

address indexed to

);

event Sync(uint112 reserve0, uint112 reserve1);

function MINIMUM_LIQUIDITY() external pure returns (uint);

function factory() external view returns (address);

function token0() external view returns (address);

function token1() external view returns (address);

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

function price0CumulativeLast() external view returns (uint);

function price1CumulativeLast() external view returns (uint);

function kLast() external view returns (uint);

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

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

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

function skim(address to) external;

function sync() external;

function initialize(address, address) external;

}

interface IPancakeSwapRouter{

function factory() external pure returns (address);

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

function WETH() external pure returns (address);

function addLiquidity(

address tokenA,

address tokenB,

uint amountADesired,

uint amountBDesired,

uint amountAMin,

uint amountBMin,

address to,

uint deadline

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

function addLiquidityETH(

address token,

uint amountTokenDesired,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

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

function removeLiquidity(

address tokenA,

address tokenB,

uint liquidity,

uint amountAMin,

uint amountBMin,

address to,

uint deadline

) external returns (uint amountA, uint amountB);

function removeLiquidityETH(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

) external returns (uint amountToken, uint amountETH);

function removeLiquidityWithPermit(

address tokenA,

address tokenB,

uint liquidity,

uint amountAMin,

uint amountBMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountA, uint amountB);

function removeLiquidityETHWithPermit(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountToken, uint amountETH);

function swapExactTokensForTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external returns (uint[] memory amounts);

function swapTokensForExactTokens(

uint amountOut,

uint amountInMax,

address[] calldata path,

address to,

uint deadline

) external returns (uint[] memory amounts);

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

external

payable

returns (uint[] memory amounts);

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

external

returns (uint[] memory amounts);

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

external

returns (uint[] memory amounts);

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

external

payable

returns (uint[] memory amounts);

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

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

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

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

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

function removeLiquidityETHSupportingFeeOnTransferTokens(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline

) external returns (uint amountETH);

function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(

address token,

uint liquidity,

uint amountTokenMin,

uint amountETHMin,

address to,

uint deadline,

bool approveMax, uint8 v, bytes32 r, bytes32 s

) external returns (uint amountETH);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external payable;

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

function swapExactTokensForETHSupportingFeeOnTransferTokens(

uint amountIn,

uint amountOutMin,

address[] calldata path,

address to,

uint deadline

) external;

}

interface IPancakeSwapFactory {

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

function feeTo() external view returns (address);

function feeToSetter() external view returns (address);

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

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

function allPairsLength() external view returns (uint);

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

function setFeeTo(address) external;

function setFeeToSetter(address) external;

}

contract Ownable {

library Roles {

address private _owner;

struct Role {

mapping (address => bool) bearer;

event OwnershipRenounced(address indexed previousOwner);

event OwnershipTransferred(

address indexed previousOwner,

address indexed newOwner

);

constructor() {

_owner = msg.sender;

}

function owner() public view returns (address) {

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

return _owner;

}

modifier onlyOwner() {

require(isOwner());

}

function isOwner() public view returns (bool) {

return msg.sender == _owner;

}

function renounceOwnership() public onlyOwner {

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

emit OwnershipRenounced(_owner);

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

_owner = address(0);

role.bearer[account] = true;

}

function transferOwnership(address newOwner) public onlyOwner {

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

_transferOwnership(newOwner);

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

role.bearer[account] = false;

}

function _transferOwnership(address newOwner) internal {

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

require(newOwner != address(0));

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

emit OwnershipTransferred(_owner, newOwner);

return role.bearer[account];

_owner = newOwner;

}

abstract contract ERC20Detailed is IERC20 {

string private _name;

string private _symbol;

uint8 private _decimals;

constructor(

string memory name_,

string memory _tokenName,

string memory symbol_,

string memory _tokenSymbol,

uint8 decimals_

uint8 _tokenDecimals

) {

_name = name_;

_name = _tokenName;

_symbol = symbol_;

_symbol = _tokenSymbol;

_decimals = decimals_;

_decimals = _tokenDecimals;

}

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

return _name;

}

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

return _symbol;

}

function decimals() public view returns (uint8) {

return _decimals;

}

contract WallStreetFinance is ERC20Detailed, Ownable {

interface IDEXRouter {

function factory() external pure returns (address);

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

function WETH() external pure returns (address);

function addLiquidity(

address tokenA,

address tokenB,

uint256 amountADesired,

uint256 amountBDesired,

uint256 amountAMin,

uint256 amountBMin,

address to,

uint256 deadline

)

external

returns (

uint256 amountA,

uint256 amountB,

uint256 liquidity

);

function addLiquidityETH(

address token,

uint256 amountTokenDesired,

uint256 amountTokenMin,

uint256 amountETHMin,

address to,

uint256 deadline

)

external

payable

returns (

uint256 amountToken,

uint256 amountETH,

uint256 liquidity

);

function swapExactTokensForTokensSupportingFeeOnTransferTokens(

uint256 amountIn,

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external;

function swapExactETHForTokensSupportingFeeOnTransferTokens(

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external payable;

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

function swapExactTokensForETHSupportingFeeOnTransferTokens(

uint256 amountIn,

uint256 amountOutMin,

address[] calldata path,

address to,

uint256 deadline

) external;

}

interface IDEXFactory {

function createPair(address tokenA, address tokenB)

external

returns (address pair);

}

contract FLiberoToken is ERC20Detailed, Auth {

using SafeMath for uint256;

using SafeMathInt for int256;

bool public initialDistributionFinished = false;

bool public autoRebase = false;

bool public feesOnNormalTransfers = true;

bool public isLiquidityInFtm = true;

bool public isRfvInFtm = true;

bool public isLiquidityEnabled = true;

string public _name = "WallStreet Finance";

uint256 public rewardYield = 1402777;

string public _symbol = "WSF";

uint256 public rebaseFrequency = 600;

uint8 public _decimals = 5;

uint256 public nextRebase = block.timestamp + 31536000;

uint256 public maxSellTransactionAmount = 2000000 * 10 ** 18;

uint256 public swapThreshold = 400000 * 10**18;

IPancakeSwapPair public pairContract;

mapping(address => bool) _isFeeExempt;

address[] private _makerPairs;

mapping (address => bool) public automatedMarketMakerPairs;

Text moved to lines 362-365

modifier validRecipient(address to) {

uint256 private constant REWARD_YIELD_DENOMINATOR = 10000000000;

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

uint256 private constant MAX_TOTAL_BUY_FEE_RATE = 250;

uint256 private constant MAX_TOTAL_SELL_FEE_RATE = 500;

}

uint256 private constant FEE_DENOMINATOR = 1000;

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

uint256 private constant MAX_REBASE_FREQUENCY = 1800;

uint256 private constant DECIMALS = 18;

uint256 private constant MAX_UINT256 = ~uint256(0);

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

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

uint256 private constant MAX_SUPPLY = ~uint128(0);

uint256 public constant DECIMALS = 5;

address private constant DEAD = 0x000000000000000000000000000000000000dEaD;

uint256 public constant MAX_UINT256 = ~uint256(0);

address private constant ZERO = 0x0000000000000000000000000000000000000000;

uint8 public constant RATE_DECIMALS = 7;

address public constant usdcToken = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;

address public liquidityReceiver = 0x730736E3cdffc531b74eb8B30bD2CC50beb8Ab3c;

address public treasuryReceiver = 0x3ff8970f17d463b83D289827B7B8E5Eed61Cc3e8;

address public riskFreeValueReceiver = 0x14c02711A4678fc7De388e77e99B07753C856e84;

address public xLiberoReceiver = 0x8689EDAb5Bdb17b11273a5C9412C4BBC8f2Ec4F8;

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

IDEXRouter public router;

address public pair;

uint256 public liquidityFee = 40;

uint256 public treasuryFee = 20;

uint256 public treasuryFee = 30;

uint256 public insuranceFee = 60;

uint256 public buyFeeRFV = 50;

uint256 public wsfBankFee = 20;

uint256 public buyBurnFee = 20;

uint256 public nftHolderFee = 20;

uint256 public buyxLiberoFee = 0;

uint256 public sellFeeTreasuryAdded = 20;

uint256 public sellFee = wsfBankFee.add(nftHolderFee);

uint256 public sellFeeRFVAdded = 40;

uint256 public burnFee = 10;

uint256 public sellBurnFeeAdded = 0;

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

uint256 public sellxLiberoFeeAdded = 0;

uint256 public feeDenominator = 1000;

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

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

address DEAD = 0x000000000000000000000000000000000000dEaD;

address ZERO = 0x0000000000000000000000000000000000000000;

address public wsfBankReceiver;

bool inSwap;

address public nftHolderReceiver;

address public lpReceiver;

address public treasuryReceiver;

address public insuranceReceiver;

address public firePit;

address public pairAddress;

bool public swapEnabled = true;

IPancakeSwapRouter public router;

address public pair;

bool inSwap = false;

modifier swapping() {

inSwap = true;

inSwap = false;

}

Text moved from lines 415-418

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

modifier validRecipient(address to) {

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

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

// BOOL Variables

}

bool public _autoRebase = true;

bool public _autoAddLiquidity = true;

// INT Variables

uint256 private _totalSupply;

uint256 public _initRebaseStartTime;

uint256 public _lastRebasedTime;

uint256 public _lastAddLiquidityTime;

uint256 public _totalSupply;

uint256 private _gonsPerFragment;

// MAPPING

mapping(address => uint256) private _gonBalances;

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

mapping(address => bool) public blacklist;

// EVENT

event Rebased(uint256 indexed epoch, uint256 totalSupply);

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

router = IPancakeSwapRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);

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

router.WETH(),

address(this)

);

lpReceiver = 0x5562640B953b6c2f79a655E930aFa68b2a65C627;

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

treasuryReceiver = 0xa9fe433E3014772bbfeA2B56F8F23CD7b87B2cbb;

router = IDEXRouter(0xF491e7B69E4244ad4002BC14e878a34207E38c29);

insuranceReceiver = 0x180f8387A0538ee058D305877df5acdBa0947498;

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

wsfBankReceiver = 0xEF0935155365db7496304bedc964470C589b9916;

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

nftHolderReceiver = 0x741490Fa4c7C67c395C0b5F78a1D6Baaaaa75a09;

firePit = 0x0000000000000000000000000000000000000000;

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

pairAddress = pair;

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

pairContract = IPancakeSwapPair(pair);

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

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

setAutomatedMarketMakerPair(pair, true);

setAutomatedMarketMakerPair(pairUsdc, true);

_totalSupply = INITIAL_FRAGMENTS_SUPPLY;

_gonBalances[owner()] = TOTAL_GONS;

_gonBalances[msg.sender] = TOTAL_GONS;

_gonsPerFragment = TOTAL_GONS.div(_totalSupply);

_initRebaseStartTime = block.timestamp;

_lastRebasedTime = block.number;

_isFeeExempt[owner()] = true;

_isFeeExempt[treasuryReceiver] = true;

_isFeeExempt[riskFreeValueReceiver] = true;

_isFeeExempt[address(this)] = true;

_isFeeExempt[msg.sender] = true;

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

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

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

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

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

}

function setZeroFees() external onlyOwner {

receive() external payable {}

liquidityFee = 0;

treasuryFee = 0;

insuranceFee = 0;

wsfBankFee = 0;

nftHolderFee = 0;

burnFee = 0;

sellFee = 0;

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

totalFee = 0;

return _totalSupply;

}

function setNormalFees() external onlyOwner {

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

liquidityFee = 40;

return _allowedFragments[owner_][spender];

treasuryFee = 20;

insuranceFee = 60;

wsfBankFee = 20;

nftHolderFee = 20;

burnFee = 10;

sellFee = wsfBankFee.add(nftHolderFee);

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

}

function manualRebase() external onlyOwner {

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

rebase();

return _gonBalances[who].div(_gonsPerFragment);

}

function rebase() internal {

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

return _isFeeExempt[_addr];

if ( inSwap ) return;

}

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

function shouldRebase() internal view returns (bool) {

uint rebaseRate = 858 * 10**18;

return nextRebase <= block.timestamp;

uint minuteRebaseRate = 17100 * 10**18;

}

uint hourRebaseRate = 1000000 * 10**18;

uint dayRebaseRate = 188800000 * 10**18;

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

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

uint tmp = _totalSupply;

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

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

return false;

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

}else if (feesOnNormalTransfers){

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

return true;

}else{

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

}

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

function shouldSwapBack() internal view returns (bool) {

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

return

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

!automatedMarketMakerPairs[msg.sender] &&

}

!inSwap &&

swapThreshold > 0 &&

totalBuyFee.add(totalSellFee) > 0 &&

balanceOf(address(this)) >= swapThreshold;

}

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

function getCirculatingSupply() public view returns (uint256) {

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

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

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

}

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

function manualSync() public {

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

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

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

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

}catch Error (string memory reason) {

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

emit GenericErrorEvent(reason);

}

_totalSupply = tmp;

_gonsPerFragment = TOTAL_GONS.div(tmp);

_lastRebasedTime = block.number;

pairContract.sync();

emit Rebased(block.timestamp, _totalSupply);

}

function transfer(address to, uint256 value)

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

external

override

validRecipient(to)

returns (bool)

{

_transferFrom(msg.sender, to, value);

return true;

}

function transferFrom(

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

address from,

address to,

uint256 value

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

Text moved to lines 520-523

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

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

msg.sender

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

}

Text moved to lines 526-528

_transferFrom(from, to, value);

return true;

}

function _basicTransfer(

address from,

address to,

uint256 amount

) internal returns (bool) {

uint256 gonAmount = amount.mul(_gonsPerFragment);

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

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

emit Transfer(from, to, amount);

return true;

}

function _transferFrom(

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

address sender,

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

address recipient,

uint256 amount

) internal returns (bool) {

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

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

if (

automatedMarketMakerPairs[recipient] &&

!excludedAccount

) {

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

}

if (inSwap) {

return _basicTransfer(sender, recipient, amount);

}

if (shouldRebase()) {

rebase();

}

if (shouldAddLiquidity()) {

uint256 gonAmount = amount.mul(_gonsPerFragment);

addLiquidity();

}

if (shouldSwapBack()) {

swapBack();

}

uint256 gonAmount = amount.mul(_gonsPerFragment);

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

uint256 gonAmountReceived = shouldTakeFee(sender, recipient)

? takeFee(sender, recipient, gonAmount)

: gonAmount;

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

gonAmountReceived

);

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

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

emit Transfer(

sender,

recipient,

gonAmountReceived.div(_gonsPerFragment)

);

if(

shouldRebase() &&

autoRebase &&

!automatedMarketMakerPairs[sender] &&

!automatedMarketMakerPairs[recipient]

) {

_rebase();

manualSync();

}

return true;

}

function takeFee(

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

Text moved from lines 596-599

address sender,

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

address recipient,

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

uint256 gonAmount

msg.sender

) internal returns (uint256) {

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

uint256 _totalFee = totalFee;

if (recipient == pair) {

_totalFee = totalFee.add(sellFee);

}

Text moved from lines 601-603

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

_transferFrom(from, to, value);

return true;

}

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

function _swapAndLiquify(uint256 contractTokenBalance) private {

gonAmount.div(feeDenominator).mul(burnFee)

uint256 half = contractTokenBalance.div(2);

);

uint256 otherHalf = contractTokenBalance.sub(half);

uint256 maintainFee = _totalFee - burnFee - liquidityFee;

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

if(isLiquidityInFtm){

gonAmount.div(feeDenominator).mul(maintainFee)

uint256 initialBalance = address(this).balance;

);

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

gonAmount.div(feeDenominator).mul(liquidityFee)

);

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

_swapTokensForFTM(half, address(this));

return gonAmount.sub(feeAmount);

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

_addLiquidity(otherHalf, newBalance);

emit SwapAndLiquify(half, newBalance, otherHalf);

}else{

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

_swapTokensForUsdc(half, address(this));

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

addLiquidityUsdc(otherHalf, newBalance);

emit SwapAndLiquifyUsdc(half, newBalance, otherHalf);

}

function addLiquidity() internal swapping {

function _addLiquidity(uint256 tokenAmount, uint256 ftmAmount) private {

uint256 autoLiquidityAmount = _gonBalances[lpReceiver].div(

router.addLiquidityETH{value: ftmAmount}(

_gonsPerFragment

address(this),

tokenAmount,

liquidityReceiver,

block.timestamp

);

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

}

_gonBalances[lpReceiver]

function addLiquidityUsdc(uint256 tokenAmount, uint256 usdcAmount) private {

router.addLiquidity(

address(this),

usdcToken,

tokenAmount,

usdcAmount,

liquidityReceiver,

block.timestamp

);

_gonBalances[lpReceiver] = 0;

}

uint256 amountToLiquify = autoLiquidityAmount.div(2);

uint256 amountToSwap = autoLiquidityAmount.sub(amountToLiquify);

if( amountToSwap == 0 ) {

function _swapTokensForFTM(uint256 tokenAmount, address receiver) private {

return;

}

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

path[0] = address(this);

path[1] = router.WETH();

uint256 balanceBefore = address(this).balance;

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

amountToSwap,

tokenAmount,

path,

address(this),

receiver,

block.timestamp

);

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

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

router.addLiquidityETH{value: amountETHLiquidity}(

address(this),

amountToLiquify,

owner(),

block.timestamp

);

}

_lastAddLiquidityTime = block.timestamp;

}

function _swapTokensForUsdc(uint256 tokenAmount, address receiver) private {

function swapBack() internal swapping {

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

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

if( amountToSwap == 0) {

return;

}

uint256 balanceBefore = address(this).balance;

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

path[0] = address(this);

path[1] = router.WETH();

path[2] = usdcToken;

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

router.swapExactTokensForTokensSupportingFeeOnTransferTokens(

amountToSwap,

tokenAmount,

path,

address(this),

receiver,

block.timestamp

);

}

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

function swapBack() internal swapping {

balanceBefore

uint256 realTotalFee = totalBuyFee.add(totalSellFee);

);

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

uint256 dynamicLiquidityFee = isLiquidityEnabled ? liquidityFee : 0;

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

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

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

value: currentBalance.mul(treasuryFee).div(

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

_currentFee

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

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

gas: 30000

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

}("");

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

if(amountToLiquify > 0){

value: currentBalance.mul(insuranceFee).div(

_swapAndLiquify(amountToLiquify);

_currentFee

}

gas: 30000

}("");

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

if(amountToBurn > 0){

value: currentBalance.mul(wsfBankFee).div(

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

_currentFee

}

gas: 30000

}("");

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

if(amountToRFV > 0){

value: currentBalance.mul(nftHolderFee).div(

if(isRfvInFtm){

_currentFee

_swapTokensForFTM(amountToRFV, riskFreeValueReceiver);

}else{

gas: 30000

_swapTokensForUsdc(amountToRFV, riskFreeValueReceiver);

}("");

}

if(amountToxLibero > 0){

_swapTokensForUsdc(amountToxLibero, xLiberoReceiver);

}

if(amountToTreasury > 0){

_swapTokensForFTM(amountToTreasury, treasuryReceiver);

}

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

}

function withdrawAllToTreasury() external swapping onlyOwner {

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

uint256 _realFee = totalBuyFee;

if(automatedMarketMakerPairs[recipient]) _realFee = totalSellFee;

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

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

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

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

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

path[0] = address(this);

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

path[1] = router.WETH();

router.swapExactTokensForETHSupportingFeeOnTransferTokens(

return gonAmount.sub(feeAmount);

amountToSwap,

}

path,

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

treasuryReceiver,

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

block.timestamp

if (subtractedValue >= oldValue) {

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

} else {

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

subtractedValue

);

}

emit Approval(

msg.sender,

spender,

_allowedFragments[msg.sender][spender]

);

return true;

}

function shouldTakeFee(address from, address to)

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

internal

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

view

spender

returns (bool)

].add(addedValue);

{

emit Approval(

return

msg.sender,

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

spender,

!_isFeeExempt[from];

_allowedFragments[msg.sender][spender]

);

return true;

}

function shouldRebase() internal view returns (bool) {

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

return

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

_autoRebase &&

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

(_totalSupply < MAX_SUPPLY) &&

return true;

msg.sender != pair &&

!inSwap &&

block.number >= (_lastRebasedTime + 1);

}

function shouldAddLiquidity() internal view returns (bool) {

function _rebase() private {

return

if(!inSwap) {

_autoAddLiquidity &&

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

!inSwap &&

coreRebase(supplyDelta);

}

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

uint256 epoch = block.timestamp;

if (supplyDelta == 0) {

emit LogRebase(epoch, _totalSupply);

return _totalSupply;

}

if (supplyDelta < 0) {

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

} else {

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

}

if (_totalSupply > MAX_SUPPLY) {

_totalSupply = MAX_SUPPLY;

}

_gonsPerFragment = TOTAL_GONS.div(_totalSupply);

nextRebase = epoch + rebaseFrequency;

emit LogRebase(epoch, _totalSupply);

return _totalSupply;

}

function manualRebase() external authorized{

require(!inSwap, "Try again");

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

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

coreRebase(supplyDelta);

manualSync();

}

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

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

automatedMarketMakerPairs[_pair] = _value;

if(_value){

_makerPairs.push(_pair);

}else{

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

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

if (_makerPairs[i] == _pair) {

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

_makerPairs.pop();

break;

}

emit SetAutomatedMarketMakerPair(_pair, _value);

}

function setInitialDistributionFinished(bool _value) external onlyOwner {

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

initialDistributionFinished = _value;

}

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

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

_isFeeExempt[_addr] = _value;

}

function setSwapThreshold(uint256 _value) external onlyOwner {

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

swapThreshold = _value;

}

function setFeeReceivers(

address _liquidityReceiver,

address _treasuryReceiver,

address _riskFreeValueReceiver,

address _xLiberoReceiver

) external onlyOwner {

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

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

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

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

liquidityReceiver = _liquidityReceiver;

treasuryReceiver = _treasuryReceiver;

riskFreeValueReceiver = _riskFreeValueReceiver;

xLiberoReceiver = _xLiberoReceiver;

}

function setFees(

uint256 _liquidityFee,

uint256 _riskFreeValue,

uint256 _treasuryFee,

uint256 _bu

Différences enregistrées

Texte d'origine

Ouvrir un fichier

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

// SPDX-License-Identifier: Unlicensed
//

pragma solidity ^0.7.4;

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

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

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

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

return a / b;
    }

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

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

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

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

return c;
    }

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

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

return c;
    }

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

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

return c;
    }

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

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

return c;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

function initialize(address, address) external;
}

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

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

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

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

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

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

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

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

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

contract Ownable {
    address private _owner;

event OwnershipRenounced(address indexed previousOwner);

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

constructor() {
        _owner = msg.sender;
    }

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

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

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

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

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

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

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

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

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

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

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

contract WallStreetFinance is ERC20Detailed, Ownable {

using SafeMath for uint256;
    using SafeMathInt for int256;

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

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

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

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

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

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

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

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

address public wsfBankReceiver;
    address public nftHolderReceiver;

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

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

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

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

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

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

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

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

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

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

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

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

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

sellFee = 0;
        totalFee = 0;
    }

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

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

}

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

function rebase() internal {

if ( inSwap ) return;

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

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

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

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

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

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

pairContract.sync();

emit Rebased(block.timestamp, _totalSupply);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

uint256 balanceBefore = address(this).balance;

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

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

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

function swapBack() internal swapping {

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

if( amountToSwap == 0) {
            return;
        }

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

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

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

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

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

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

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

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

function withdrawAllToTreasury() external swapping onlyOwner {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

receive() external payable {}
}

Texte modifié

Ouvrir un fichier

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