Address

• Goblin.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract GoblinDegenz {
    string public name = "Goblin Degenz";
    string public symbol = "GODE";
    string private _baseTokenURI;
    string private _contractURI;
    uint256 private _nextTokenId;
    address private _owner;
    address private _royaltyReceiver;
    uint96  private _royaltyBps;
    mapping(uint256 => address) private _owners;
    mapping(address => uint256) private _balances;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
    modifier onlyOwner() { require(msg.sender == _owner, "Not owner"); _; }
    constructor(string memory baseURI, string memory contractURI_, address royaltyReceiver, uint96 royaltyBps_) {
        _owner           = msg.sender;
        _baseTokenURI    = baseURI;
        _contractURI     = contractURI_;
        _royaltyReceiver = royaltyReceiver;
        _royaltyBps      = royaltyBps_;
    }
    function contractURI() external view returns (string memory) { return _contractURI; }
    function setContractURI(string memory uri) external onlyOwner { _contractURI = uri; }
    function royaltyInfo(uint256, uint256 salePrice) external view returns (address, uint256) {
        return (_royaltyReceiver, (salePrice * _royaltyBps) / 10000);
    }
    function setRoyalty(address receiver, uint96 bps) external onlyOwner { _royaltyReceiver = receiver; _royaltyBps = bps; }
    function supportsInterface(bytes4 id) public pure returns (bool) {
        return id == 0x80ac58cd || id == 0x5b5e139f || id == 0x01ffc9a7 || id == 0x2a55205a;
    }
    function tokenURI(uint256 tokenId) public view returns (string memory) {
        require(_owners[tokenId] != address(0), "Token does not exist");
        return string(abi.encodePacked(_baseTokenURI, _toString(tokenId), ".json"));
    }
    function setBaseURI(string memory baseURI) external onlyOwner { _baseTokenURI = baseURI; }
    function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; }
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "Token does not exist");
        return owner;
    }
    function approve(address to, uint256 tokenId) public {
        require(msg.sender == ownerOf(tokenId), "Not token owner");
        _tokenApprovals[tokenId] = to; emit Approval(msg.sender, to, tokenId);
    }
    function getApproved(uint256 tokenId) public view returns (address) { return _tokenApprovals[tokenId]; }
    function setApprovalForAll(address operator, bool approved) public {
        _operatorApprovals[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved);
    }
    function isApprovedForAll(address owner, address operator) public view returns (bool) { return _operatorApprovals[owner][operator]; }
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(ownerOf(tokenId) == from, "Wrong owner");
        require(to != address(0), "Zero address");
        require(msg.sender == from || msg.sender == getApproved(tokenId) || isApprovedForAll(from, msg.sender), "Not approved");
        _balances[from]--; _balances[to]++; _owners[tokenId] = to;
        delete _tokenApprovals[tokenId]; emit Transfer(from, to, tokenId);
    }
    function safeTransferFrom(address from, address to, uint256 tokenId) public { transferFrom(from, to, tokenId); }
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory) public { transferFrom(from, to, tokenId); }
    function batchMint(address to, uint256 quantity) external onlyOwner {
        for (uint256 i = 0; i < quantity; i++) {
            uint256 tokenId = _nextTokenId++;
            _owners[tokenId] = to; _balances[to]++;
            emit Transfer(address(0), to, tokenId);
        }
    }
    function totalSupply() external view returns (uint256) { return _nextTokenId; }
    function contractOwner() external view returns (address) { return _owner; }
    function _toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) return "0";
        uint256 temp = value; uint256 digits;
        while (temp != 0) { digits++; temp /= 10; }
        bytes memory buffer = new bytes(digits);
        while (value != 0) { digits--; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; }
        return string(buffer);
    }
}