Address

{{
  "language": "Solidity",
  "sources": {
    "BNB.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

/* ---------------- Panda-like minimal context ---------------- */
contract Context {
    function _msgSender() internal view returns (address) {
        return payable(msg.sender);
    }
    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning
        return msg.data;
    }
}

/* ---------------- SafeMath (same style) ---------------- */
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b; require(c >= a, "add overflow"); return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "sub overflow"); return a - b;
    }
}

/* ---------------- Address (trimmed but keeps pattern) ---------------- */
library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }
}

/* ---------------- ERC20 Interface (same signatures) ---------------- */
interface IERC20 {
    function decimals() external view returns (uint256);
    function symbol() external view returns (string memory);
    function name() external view returns (string memory);
    function totalSupply() external view returns (uint256);
    function balanceOf(address who) external view returns (uint);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address _spender, uint _value) external;
    function transferFrom(address _from, address _to, uint _value) external;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/* =======================================================================
   Panda-like clean ERC20
   - 无税、无黑名单、无限额、无任何管理员权限（owner() 固定死地址）
   - 构造器签名与 PandaTool 模板一致：string[], address[], uint256[], bool[]
   ======================================================================= */
contract PandaToken is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    string private _name;
    string private _symbol;
    uint256 private _decimals;
    uint256 private _totalSupply;

    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;

    constructor(
        string[] memory stringParams,    // [name, symbol]
        address[] memory addressParams,  // 必须为空（保持模板习惯）
        uint256[] memory numberParams,   // [decimals, totalSupply]
        bool[] memory boolParams         // 必须为空（保持模板习惯）
    ) {
        require(addressParams.length == 0, "addr params must empty");
        require(boolParams.length == 0, "bool params must empty");

        // 与 Panda 模板一致：使用 tx.origin 作为初始接收者
        address receiveAddr = tx.origin;

        _name = stringParams[0];
        _symbol = stringParams[1];
        _decimals = numberParams[0];
        _totalSupply = numberParams[1];

        _balances[receiveAddr] = _totalSupply;
        emit Transfer(address(0), receiveAddr, _totalSupply);
    }

    /* -------- ERC20 Views -------- */
    function name() public view override returns (string memory) { return _name; }
    function symbol() public view override returns (string memory) { return _symbol; }
    function decimals() public view override returns (uint256) { return _decimals; }
    function totalSupply() public view override returns (uint256) { return _totalSupply; }
    function owner() public view returns (address) { return deadAddress; }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }
    function allowance(address owner_, address spender) public view override returns (uint256) {
        return _allowances[owner_][spender];
    }

    /* -------- ERC20 Writes -------- */
    function approve(address spender, uint256 amount) public override {
        _approve(_msgSender(), spender, amount);
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override {
        _transfer(sender, recipient, amount);
        uint256 cur = _allowances[sender][_msgSender()];
        require(cur >= amount, "allowance");
        _allowances[sender][_msgSender()] = cur.sub(amount);
    }

    /* -------- Internal helpers -------- */
    function _approve(address owner_, address spender, uint256 amount) internal {
        require(owner_ != address(0) && spender != address(0), "zero addr");
        _allowances[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    function _transfer(address from, address to, uint256 amount) internal {
        require(from != address(0) && to != address(0), "zero addr");
        uint256 fb = _balances[from];
        require(fb >= amount, "balance");
        unchecked { _balances[from] = fb - amount; }
        _balances[to] = _balances[to].add(amount);
        emit Transfer(from, to, amount);
    }

    /* 可选：流通量(排除死地址) */
    function getCirculatingSupply() external view returns (uint256) {
        return _totalSupply.sub(_balances[deadAddress]);
    }

    receive() external payable {}
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}