Blockwell-QR Index

0x9f2e6d25cdb1ccef08bae943d3d1f5f7a5a98e4d

supportsInterface keyboard_arrow_up

    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return supportedInterfaces[interfaceId];
    }

unrestrictMinting keyboard_arrow_up

    function unrestrictMinting() public onlyAdmin {
        unrestrictedMinting = true;
    }

restrictMinting keyboard_arrow_up

    function restrictMinting() public onlyAdmin {
        unrestrictedMinting = false;
    }

name keyboard_arrow_up

    function name() external view returns (string) {
        return tokenName;
    }

symbol keyboard_arrow_up

    function symbol() external view returns (string) {
        return tokenSymbol;
    }

totalSupply keyboard_arrow_up

    function totalSupply() public view returns (uint256) {
        return allTokens.length;
    }

balanceOf keyboard_arrow_up

    function balanceOf(address account) public view returns (uint256) {
        require(account != address(0));
        return tokenCount[account];
    }

ownerOf keyboard_arrow_up

    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = owners[tokenId];
        require(owner != address(0));
        return owner;
    }

tokenOfOwnerByIndex keyboard_arrow_up

    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner));
        return ownedTokens[owner][index];
    }

tokenByIndex keyboard_arrow_up

    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply());
        return allTokens[index];
    }

getApproved keyboard_arrow_up

    function getApproved(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId));
        return approval[tokenId];
    }

isApprovedForAll keyboard_arrow_up

    function isApprovedForAll(address account, address operator) public view returns (bool) {
        return operatorApproval[account][operator];
    }

tokenURI keyboard_arrow_up

    function tokenURI(uint256 tokenId) external view returns (string) {
        require(_exists(tokenId));
        return uri[tokenId];
    }

addAdmin keyboard_arrow_up

    function addAdmin(address account) public onlyAdmin {
        _addAdmin(account);
    }

removeAdmin keyboard_arrow_up

    function removeAdmin(address account) public onlyAdmin {
        groups.remove(ADMIN, account);
        emit RemovedFromGroup(ADMIN, account);
    }

isAdmin keyboard_arrow_up

    function isAdmin(address account) public view returns (bool) {
        return groups.contains(ADMIN, account);
    }

approve keyboard_arrow_up

    function approve(address account, uint256 tokenId) public {
        address owner = ownerOf(tokenId);

        require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

        approval[tokenId] = account;
        emit Approval(owner, account, tokenId);
    }

setApprovalForAll keyboard_arrow_up

    function setApprovalForAll(address to, bool approved) public {
        require(to != msg.sender);
        operatorApproval[msg.sender][to] = approved;
        emit ApprovalForAll(msg.sender, to, approved);
    }

transferFrom keyboard_arrow_up

    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId));
        require(to != address(0));

        _clearApproval(from, tokenId);
        _removeTokenFrom(from, tokenId);
        _addTokenTo(to, tokenId);

        emit Transfer(from, to, tokenId);
    }

safeTransferFrom keyboard_arrow_up

    function safeTransferFrom(address from, address to, uint256 tokenId) external payable {
        transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, ""));
    }

safeTransferFrom keyboard_arrow_up

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) external payable {
        transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data));
    }

mint keyboard_arrow_up

    function mint(address to, uint256 tokenId) public onlyAdmin returns (bool) {
        _mint(to, tokenId);
        return true;
    }

mintWithTokenURI keyboard_arrow_up

    function mintWithTokenURI(address to, uint256 tokenId, string URIForToken) public onlyAdmin returns (bool) {
        _mint(to, tokenId);
        _setTokenURI(tokenId, URIForToken);
        return true;
    }

addQr keyboard_arrow_up

    function addQr(uint256 tokenId) public returns (bool) {
        if (!unrestrictedMinting) {
            require(isAdmin(msg.sender), "Must be an admin");
        }
        _mint(tokenOwner, tokenId);
        _setTokenURI(tokenId, concat("https://qr.blockwell.ai/qri/", uint2str(tokenId)));
        return true;
    }

burn keyboard_arrow_up

    function burn(uint256 tokenId) public {
        require(msg.sender == ownerOf(tokenId));
        _burn(msg.sender, tokenId);
    }