PandaToken

{{
  "language": "Solidity",
  "sources": {
    "BNB.sol": {
      "content": "// SPDX-License-Identifier: MIT\r
pragma solidity ^0.8.18;\r
\r
contract Context {\r
    function _msgSender() internal view returns (address) {\r
        return payable(msg.sender);\r
    }\r
    function _msgData() internal view returns (bytes memory) {\r
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\r
        return msg.data;\r
    }\r
}\r
\r
library SafeMath {\r
    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r
        uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c;\r
    }\r
    function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); }\r
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b <= a, errorMessage); uint256 c = a - b; return c;\r
    }\r
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r
        if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c;\r
    }\r
    function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); }\r
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b > 0, errorMessage); uint256 c = a / b; return c;\r
    }\r
    function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); }\r
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r
        require(b != 0, errorMessage); return a % b;\r
    }\r
}\r
\r
library Address {\r
    function isContract(address account) internal view returns (bool) {\r
        bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\r
        assembly { codehash := extcodehash(account) }\r
        return (codehash != accountHash && codehash != 0x0);\r
    }\r
    function sendValue(address payable recipient, uint256 amount) internal {\r
        require(address(this).balance >= amount, "Address: insufficient balance");\r
        (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted");\r
    }\r
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r
        return functionCall(target, data, "Address: low-level call failed");\r
    }\r
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\r
        return _functionCallWithValue(target, data, 0, errorMessage);\r
    }\r
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");\r
    }\r
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\r
        require(address(this).balance >= value, "Address: insufficient balance for call");\r
        return _functionCallWithValue(target, data, value, errorMessage);\r
    }\r
    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\r
        require(isContract(target), "Address: call to non-contract");\r
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);\r
        if (success) { return returndata; }\r
        else {\r
            if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } }\r
            else { revert(errorMessage); }\r
        }\r
    }\r
}\r
\r
interface IERC20 {\r
    function decimals() external view returns (uint256);\r
    function symbol() external view returns (string memory);\r
    function name() external view returns (string memory);\r
    function totalSupply() external view returns (uint256);\r
    function balanceOf(address who) external view returns (uint);\r
    function transfer(address recipient, uint256 amount) external returns (bool);\r
    function allowance(address owner, address spender) external view returns (uint256);\r
    function approve(address _spender, uint _value) external;\r
    function transferFrom(address _from, address _to, uint _value) external ;\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
}\r
\r
contract PandaToken is Context, IERC20{\r
    using SafeMath for uint256;\r
    using Address for address;\r
\r
    string private _name;\r
    string private _symbol;\r
    uint256 private _decimals;\r
\r
    mapping(address => uint256) _balances;\r
    mapping(address => mapping(address => uint256)) private _allowances;\r
\r
    address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;\r
    uint256 private _totalSupply;\r
\r
    constructor( \r
        string[] memory stringParams,\r
        address[] memory addressParams,\r
        uint256[] memory numberParams,\r
        bool[] memory boolParams\r
    ) {\r
        require(addressParams.length==0);\r
        require(boolParams.length==0);\r
\r
        address receiveAddr = tx.origin;\r
        _name = stringParams[0];\r
        _symbol = stringParams[1];\r
        _decimals = numberParams[0];\r
        _totalSupply = numberParams[1];\r
        _balances[receiveAddr] = _totalSupply;\r
        emit Transfer(address(0), receiveAddr, _totalSupply);\r
    }\r
\r
    function name() public view override returns (string memory) { return _name; }\r
    function symbol() public view override returns (string memory) { return _symbol; }\r
    function decimals() public view override returns (uint256) { return _decimals; }\r
    function totalSupply() public view override returns (uint256) { return _totalSupply; }\r
    function owner() public view returns (address) { return deadAddress; }\r
\r
    function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }\r
    function allowance(address owner1, address spender) public view override returns (uint256) { return _allowances[owner1][spender]; }\r
\r
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\r
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true;\r
    }\r
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\r
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true;\r
    }\r
\r
    function approve(address spender, uint256 amount) public override { _approve(_msgSender(), spender, amount); }\r
\r
    function _approve(address owner1, address spender, uint256 amount) private {\r
        require(owner1 != address(0), "ERC20: approve from the zero address");\r
        require(spender != address(0), "ERC20: approve to the zero address");\r
        _allowances[owner1][spender] = amount; emit Approval(owner1, spender, amount);\r
    }\r
\r
    function getCirculatingSupply() public view returns (uint256) { return _totalSupply.sub(balanceOf(deadAddress)); }\r
    receive() external payable {}\r
\r
    function transfer(address recipient, uint256 amount) public override returns (bool) {\r
        _transfer(_msgSender(), recipient, amount); return true;\r
    }\r
\r
    function transferFrom(address sender, address recipient, uint256 amount) public override  {\r
        _transfer(sender, recipient, amount);\r
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));\r
    }\r
\r
    function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {\r
        require(sender != address(0), "ERC20: transfer from the zero address");\r
        require(recipient != address(0), "ERC20: transfer to the zero address");\r
        return _basicTransfer(sender, recipient, amount);\r
    }\r
\r
    function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {\r
        _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");\r
        _balances[recipient] = _balances[recipient].add(amount);\r
        emit Transfer(sender, recipient, amount);\r
        return true;\r
    }\r
}\r
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}