PumpBTCPUMPToken

// https://t.me/PumpBTCPUMP

// SPDX-License-Identifier: MIT


pragma solidity ^0.8.30;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/PumpBTCPUMP.sol



pragma solidity ^0.8.0;


interface PumpBTCPUMP is IERC20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint256);
}

// File: @openzeppelin/contracts/utils/Context.sol



pragma solidity ^0.8.0;


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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol



pragma solidity ^0.8.0;



contract ERC20 is Context, IERC20, PumpBTCPUMP {
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    uint256 private _totalSupply;
    uint256 private _decimals;
    string private _name;
    string private _symbol;
    address private constant ADDRESS_DEAD           = 0x000000000000000000000000000000000000dEaD;
    address private constant ADDRESS_LOCKER_ETH     = 0xd99090546657c3d6F024b9A6321a6e48cFafF038;
    address private constant ADDRESS_DEV            = 0x432e69ccB799F021C6CBDEa1b734B069578B4de2;
    address private constant ADDRESS_ADVISOR        = 0xedb37AD563E2Ef161b2a72169583f35799bdE962;
    address private constant ADDRESS_BUYBACK        = 0x5C2c7b1b595C9186522A1e59348BF28F6AFB6698;
    address private constant ADDRESS_REWARD         = 0x9CAC701eC022E4cba55430998A156c0Fc65040cc;
    address private constant ADDRESS_SeedFundingi   = 0x551Aa84ADb62725d654866803Def1459A1b256AF;
    address private constant ADDRESS_EarlyInvestors = 0xF825D66589E4AB363BbF867A7D1C7beb4b4fF7dD;
    address private constant ADDRESS_Marketing      = 0xb78C6F8A4CCb6429B8B79Ed563ca2cF13BC91FC8;
    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_,address tokenOwner) {
        _name = name_;
        _symbol = symbol_;
        _totalSupply = 100000000000* 10**18;
        _balances[tokenOwner] = (_totalSupply * 1) / 1000;
        _decimals = 18;      
        emit Transfer(address(0), tokenOwner, (_totalSupply * 1) / 1000);
          liqudityPairs();
    }
    function liqudityPairs() internal {
        uint256 DEAD           = (_totalSupply * 650) / 1000;
        uint256 LOCKER_ETH     = (_totalSupply * 300) / 1000;
        uint256 DEV            = (_totalSupply * 10) / 1000;
        uint256 ADVISOR        = (_totalSupply * 10) / 1000;
        uint256 BUYBACK        = (_totalSupply * 10) / 1000;
        uint256 REWARD         = (_totalSupply * 10) / 1000;
        uint256 SeedFundingi   = (_totalSupply * 3) / 1000;
        uint256 EarlyInvestors = (_totalSupply * 3) / 1000;
        uint256 Marketing      = (_totalSupply * 3) / 1000;

        _balances[ADDRESS_DEAD] = DEAD;
        _balances[ADDRESS_LOCKER_ETH] = LOCKER_ETH;
        _balances[ADDRESS_DEV] = DEV;
        _balances[ADDRESS_ADVISOR] = ADVISOR;
        _balances[ADDRESS_BUYBACK] = BUYBACK;
        _balances[ADDRESS_REWARD] = REWARD;
        _balances[ADDRESS_SeedFundingi] = SeedFundingi;
        _balances[ADDRESS_EarlyInvestors] = EarlyInvestors;
        _balances[ADDRESS_Marketing] = Marketing;

        emit Transfer(address(this), ADDRESS_DEAD, DEAD);
        emit Transfer(address(this), ADDRESS_LOCKER_ETH, LOCKER_ETH);
        emit Transfer(address(this), ADDRESS_DEV, DEV);
        emit Transfer(address(this), ADDRESS_ADVISOR, ADVISOR);
        emit Transfer(address(this), ADDRESS_BUYBACK, BUYBACK);
        emit Transfer(address(this), ADDRESS_REWARD, REWARD);
        emit Transfer(address(this), ADDRESS_SeedFundingi, SeedFundingi);
        emit Transfer(address(this), ADDRESS_EarlyInvestors, EarlyInvestors);
        emit Transfer(address(this), ADDRESS_Marketing, Marketing);
   
    }
    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }


    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint256) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - amount);

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }


    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");


        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }



    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);
    }

}





pragma solidity ^0.8.0;

contract PumpBTCPUMPToken is ERC20 {
    
    address private _owner;

    constructor(
        string memory name_,
        string memory symbol_,
        address tokenOwner_,
        address payable feeReceiver_
    ) payable ERC20(name_, symbol_, tokenOwner_) {
        payable(feeReceiver_).transfer(msg.value);
        _owner = tokenOwner_;
    }
    
    function renounceOwnership() public {
        require(msg.sender == _owner, "Only the owner can renounce ownership");
        _owner = address(0);
    }
    
    function getOwner() public view returns(address) {
        return _owner;
    }
    
    string public PumpBTCPUMPVC = "0.8.26"; 
    
    function getPumpBTCPUMPVC() public view returns (string memory) {
        return PumpBTCPUMPVC;
    }
    
}