// SPDX-License-Identifier: MIT

/*
GrapeApe provides a decentralized financial asset which rewards users with a sustainable fixed rising floor model
- auto burn
- 99% supply burn within 40 days / elastic supply
- insurance fund for buybacks
created by Ganglyprism

website : https://gaprotocol.com/

*/


pragma solidity ^0.8.0;

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 GrapeApe is ERC20Detailed, Ownable {

using SafeMath for uint256;
using SafeMathInt for int256;

string public _name = "GRAPE APE";
string public _symbol = "GRAPE";
uint8 public _decimals = 18;

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

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

uint256 public constant DECIMALS = 18;
uint256 public constant MAX_UINT256 = ~uint256(0);
uint256 private constant MAX_SUPPLY = 100000 *10**DECIMALS;
uint256 private constant MIN_SUPPLY = 1000 * 10**DECIMALS;

uint256 public liquidityFee = 10;
uint256 public treasuryFee = 40;
uint256 public GrapeApeInsuranceFundFee = 60;
uint256 public sellFee = 70;
uint256 public GrapePitFee = 10;

uint256 public rebaseTime = 3 hours;
uint256 public autoLpTime = 1 days;

uint256 public grapeRate = 312 * 10 ** DECIMALS; // ~2500 $GRAPE in 24H
uint256 public currentEpoch;

uint256 public _lastAddLiquidityTime;

uint256 public totalFee = liquidityFee.add(treasuryFee).add(GrapeApeInsuranceFundFee).add(GrapePitFee);
uint256 public feeDenominator = 1000;

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

address public treasuryReceiver;
address public autoLiquidityReceiver;
address public GrapePit;
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 % MAX_SUPPLY);
bool public _autoRebase;
bool public _autoAddLiquidity;
uint256 public _initRebaseStartTime;
uint256 public _lastRebasedTime;
uint256 public _nextRebaseTime;

uint256 public _totalSupply;
uint256 private _gonsPerFragment;

mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowedFragments;
mapping(address => bool) public blacklist;

event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event Swapped(uint256 tokensSwapped, uint256 bnbReceived, uint256 tokensIntoLiqudity, uint256 bnbIntoLiquidity, bool successSentMarketing);

//BSC
//Router MAINNET: 0x10ED43C718714eb63d5aA57B78B54704E256024E TESTNET: 0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3
constructor() ERC20Detailed(_name, _symbol, uint8(DECIMALS)) Ownable() {

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

treasuryReceiver = msg.sender;
GrapePit = 0x7E040C8070a802FF5Dcf9C17616D94eF3a49E633;
autoLiquidityReceiver = 0xA618E75965A0209980E888aA6d9E655D0308D93d;

_allowedFragments[address(this)][address(router)] = type(uint256).max;
pairAddress = pair;
pairContract = IPancakeSwapPair(pair);

_totalSupply = MAX_SUPPLY;
_balances[msg.sender] = TOTAL_GONS;
_gonsPerFragment = TOTAL_GONS.div(_totalSupply);

_initRebaseStartTime = block.timestamp;
_lastRebasedTime = block.timestamp;
_nextRebaseTime = block.timestamp;

_autoRebase = false;
_autoAddLiquidity = false;

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

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

function startProtocol() external onlyOwner {
_autoRebase = true;
_autoAddLiquidity = true;
_lastAddLiquidityTime = block.timestamp;
}

function rebase() internal {

if ( inSwap ) return;

if (_totalSupply > MIN_SUPPLY){
_totalSupply = _totalSupply.sub(grapeRate);
}

if(_totalSupply < MIN_SUPPLY || _totalSupply == type(uint256).max){
_totalSupply = MIN_SUPPLY;
_autoRebase = false;
}

_gonsPerFragment = TOTAL_GONS.div(_totalSupply);
pairContract.sync();

currentEpoch ;
_lastRebasedTime = block.timestamp;
_nextRebaseTime = block.timestamp rebaseTime;
emit LogRebase(currentEpoch, _totalSupply);
}

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

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] != type(uint256).max) {
_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);
_balances[from] = _balances[from].sub(gonAmount);
_balances[to] = _balances[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 (shouldExcuteSwap()) {
swapBack();
}


uint256 gonAmount = amount.mul(_gonsPerFragment);
_balances[sender] = _balances[sender].sub(gonAmount);

uint256 gonAmountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, gonAmount) : gonAmount;
_balances[recipient] = _balances[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;
uint256 _treasuryFee = treasuryFee;

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

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

_balances[GrapePit] = _balances[GrapePit].add(gonAmount.div(feeDenominator).mul(GrapePitFee));

_balances[address(this)] = _balances[address(this)].add(gonAmount.div(feeDenominator).mul(_treasuryFee.add(GrapeApeInsuranceFundFee)));

_balances[autoLiquidityReceiver] = _balances[autoLiquidityReceiver].add(gonAmount.div(feeDenominator).mul(liquidityFee));


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

function addLiquidity() internal swapping {

uint256 autoLiquidityAmount = _balances[autoLiquidityReceiver].div(_gonsPerFragment);
_balances[address(this)] = _balances[address(this)].add(_balances[autoLiquidityReceiver]);

_balances[autoLiquidityReceiver] = 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, autoLiquidityReceiver, block.timestamp );
}
_lastAddLiquidityTime = block.timestamp;
}

function swapBack() internal swapping {

uint256 amountToSwap = _balances[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 amountETHToTreasuryAndGIF = address(this).balance.sub( balanceBefore );
payable(treasuryReceiver).call{value: amountETHToTreasuryAndGIF, gas: 30000 };
}

function updateFees(uint256 _liqFee, uint256 _tressuryFee, uint256 _insuranceFee, uint256 _pitFee, uint256 _sellFee) external onlyOwner{

liquidityFee = _liqFee;
treasuryFee = _tressuryFee;
GrapeApeInsuranceFundFee = _insuranceFee;
GrapePitFee = _pitFee;
sellFee = _sellFee;

totalFee = liquidityFee.add(treasuryFee).add(GrapeApeInsuranceFundFee).add(GrapePitFee);

}

// swap stuck tokens
function flushContract() external swapping onlyOwner {

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

require( amountToSwap > 0,"There is no GRAPE 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);

}

// sends stuck bnb
function sendToTreassury() public payable onlyOwner {
(bool os, ) = payable(treasuryReceiver).call{value: address(this).balance }("");
require(os);
}

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

function shouldRebase() public view returns (bool) {
return _autoRebase && msg.sender != pair && !inSwap && block.timestamp >= _nextRebaseTime;
}

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

function blocksUntilRebase() external view returns (uint256) {
return _nextRebaseTime - block.timestamp ;
}

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

function setAutoRebase(bool _flag) external onlyOwner {
if (_flag) {
_autoRebase = _flag;
_lastRebasedTime = block.timestamp;
_nextRebaseTime = block.timestamp;
} else {
_autoRebase = _flag;
}
}

function setAutoLP(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(_balances[DEAD]).sub(_balances[ZERO])).div( _gonsPerFragment);
}

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

function setFeeReceivers( address _treasuryReceiver,address _GrapePit) external onlyOwner {
treasuryReceiver = _treasuryReceiver;
GrapePit = _GrapePit;
}

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

function updateIsFeeExempt(address _addr, bool _status) external onlyOwner {
_isFeeExempt[_addr] = _status;
}

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 updateRebaseTime(uint256 _time) external onlyOwner {
rebaseTime = _time;
_lastRebasedTime = block.timestamp;
_nextRebaseTime = block.timestamp;
}

function updateLpTime(uint256 _time) external onlyOwner {
autoLpTime = _time;
_lastAddLiquidityTime = block.timestamp;
}

function updategrapeRate(uint256 _rate) external onlyOwner {
grapeRate = _rate;
}

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

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

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

receive() external payable {}
}