PepeBand Smart Contract Code

Contract 0xBfc5F0222B33FD8FcEb3509F2459Cbd554Aa67C1

/**
 *Submitted for verification at BscScan.com on 2023-10-05
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract PepeBandToken {
    string public constant name = "PepeBand";
    string public constant symbol = "PEPEBAND";
    uint8 public constant decimals = 9;
    uint256 public totalSupply = 900e9 * 1e9; // 900 billion tokens with 9 decimals
    address public owner;
    address public constant marketingWallet = 0x5164634D77b1104Faf535704ccF3dcfaAB56955F;
    address public constant deadWallet = 0x000000000000000000000000000000000000dEaD; // Make deadWallet constant

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => bool) public isExcludedFromFees;
    mapping(address => bool) public isExcludedFromTransferLimit;
    mapping(address => bool) public isExcludedFromBalanceLimit;

    uint256 public marketingFee = 3;
    uint256 public burnFee = 2;
    uint256 public maxTransactionAmount = totalSupply / 50; // 2% of totalSupply
    uint256 public maxBalancePerAddress = totalSupply / 50; // 5% of totalSupply

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event MarketingFeeUpdated(uint256 newFee);
    event BurnFeeUpdated(uint256 newFee);

    constructor() {
        owner = msg.sender;
        balanceOf[msg.sender] = totalSupply;
        isExcludedFromFees[owner] = true;
        isExcludedFromFees[marketingWallet] = true;
        isExcludedFromFees[deadWallet] = true;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can call this function");
        _;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Invalid new owner");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function setMarketingFee(uint256 fee) external onlyOwner {
        require(fee + burnFee <= 5, "Total fee cannot exceed 5%");
        marketingFee = fee;
        emit MarketingFeeUpdated(fee);
    }

    function setBurnFee(uint256 fee) external onlyOwner {
        require(fee + marketingFee <= 5, "Total fee cannot exceed 5%");
        burnFee = fee;
        emit BurnFeeUpdated(fee);
    }

    function setMaxTransactionAmount(uint256 amount) external onlyOwner {
        maxTransactionAmount = amount;
    }

    function setMaxBalancePerAddress(uint256 amount) external onlyOwner {
        maxBalancePerAddress = amount;
    }

    function excludeFromFees(address account, bool exclude) external onlyOwner {
        isExcludedFromFees[account] = exclude;
    }

    function excludeFromTransferLimit(address account, bool exclude) external onlyOwner {
        isExcludedFromTransferLimit[account] = exclude;
    }

    function excludeFromBalanceLimit(address account, bool exclude) external onlyOwner {
        isExcludedFromBalanceLimit[account] = exclude;
    }

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

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

    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");
        require(amount > 0, "Transfer amount must be greater than zero");
        require(amount <= maxTransactionAmount || isExcludedFromTransferLimit[sender], "Exceeds maximum transaction amount");

        // Calculate fees as a percentage of the transfer amount
        uint256 marketingAmount = 0;
        uint256 burnAmount = 0;

        if (!isExcludedFromFees[sender]) {
            marketingAmount = (amount * marketingFee) / 100;
            burnAmount = (amount * burnFee) / 100;
        }

        // Calculate the transfer amount after deducting fees
        uint256 transferAmount = amount - marketingAmount - burnAmount;

        // Check if the recipient is excluded from balance limits
        if (!isExcludedFromBalanceLimit[recipient]) {
            // Check if the resulting balance of the recipient would exceed the max balance per address
            require(balanceOf[recipient] + transferAmount <= maxBalancePerAddress, "Exceeds maximum balance per address");
        }

        // Deduct the transfer amount from the sender's balance
        require(balanceOf[sender] >= transferAmount, "Insufficient balance");
        balanceOf[sender] -= transferAmount;

        // Handle fees only if the sender is not excluded from fees
        if (!isExcludedFromFees[sender]) {
            _handleFees(sender, marketingAmount, burnAmount);
        }

        // Add the transfer amount to the recipient's balance
        balanceOf[recipient] += transferAmount;

        emit Transfer(sender, recipient, transferAmount);
    }

    function _handleFees(address sender, uint256 marketingAmount, uint256 burnAmount) internal {
        // Transfer marketing fee to the marketing wallet
        balanceOf[sender] -= marketingAmount;
        balanceOf[marketingWallet] += marketingAmount;
        emit Transfer(sender, marketingWallet, marketingAmount);

        // Burn tokens
        totalSupply -= burnAmount;
        emit Transfer(sender, deadWallet, burnAmount);
    }

    function renounceOwnership() external onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }
}

Certainly, a detailed explanation of the code for the "PepeBandToken" smart contract:

Token Metadata and Constants

name, symbol, and decimals variables specify the name, symbol, and number of decimal places for the token.
totalSupply is the total supply of tokens, set to 900 billion with 9 decimal places.
owner is the address of the contract owner.
marketingWallet is the address where marketing fees will be sent.
deadWallet is a constant address where tokens will be sent for burning.

Data Structures

balanceOf is a mapping that stores the token balances of all addresses.
allowance is a mapping that tracks approved allowances for token transfers.
isExcludedFromFees is a mapping that determines which addresses are excluded from fees.
isExcludedFromTransferLimit is a mapping that excludes specific addresses from transfer limits.
isExcludedFromBalanceLimit is a mapping that excludes specific addresses from balance limits.

Fee and Limit Parameters

marketingFee is the percentage fee for marketing.
burnFee is the percentage fee for burning tokens.
maxTransactionAmount sets the maximum amount of tokens that can be transferred in a single transaction (2% of total supply).
maxBalancePerAddress sets the maximum token balance allowed for an address (2% of total supply).

Events

Several events are defined to log important contract actions, such as transfers, approvals, ownership transfers, and fee updates.

Constructor

The constructor initializes the contract, setting the owner, distributing the total supply to the owner, and excluding certain addresses from fees.

Modifier

onlyOwner is a modifier that restricts certain functions to be callable only by the owner.

Owner Management

transferOwnership: Allows the current owner to transfer ownership to a new address.

Fee Management

setMarketingFee: Allows the owner to set the marketing fee percentage.
setBurnFee: Allows the owner to set the burn fee percentage.
setMaxTransactionAmount: Allows the owner to set the maximum transaction amount.
setMaxBalancePerAddress: Allows the owner to set the maximum balance per address.
excludeFromFees: Allows the owner to exclude or include specific addresses from fees.

Token Transfer Functions

transfer: Allows users to transfer tokens to another address.
approve: Allows users to approve another address to spend tokens on their behalf.
transferFrom: Allows the approved spender to transfer tokens on behalf of the owner.

Internal Transfer Function (`_transfer`)

_transfer handles the core logic of transferring tokens, including fee calculations and balance checks.
It checks if the sender is excluded from transfer limits, calculates fees, and checks the recipient's balance.

Fee Handling (`_handleFees`)

_handleFees handles the deduction of marketing fees and burning tokens.
It transfers marketing fees to the marketing wallet and burns tokens by reducing the total supply.

Ownership Renouncement

renounceOwnership: Allows the owner to renounce ownership, making the contract ownerless.

This contract implements various features, including transfer restrictions, fee management, and ownership control, to create a customized token with specific rules for fees, limits, and exclusions.

PreviousTokenomics NextNFTs

Last updated 1 year ago