|
"content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity ^0.8.17;\n\ninterface ERC721TokenReceiver {\n function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes memory _data) external returns(bytes4);\n}\n\ncontract Csr {\n\n event Generated(uint indexed index, address indexed a, string value);\n\n /// @dev This emits when ownership of any NFT changes by any mechanism.\n /// This event emits when NFTs are created (`from` == 0) and destroyed\n /// (`to` == 0). Exception: during contract creation, any number of NFTs\n /// may be created and assigned without emitting Transfer. At the time of\n /// any transfer, the approved address for that NFT (if any) is reset to none.\n event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);\n\n /// @dev This emits when the approved address for an NFT is changed or\n /// reaffirmed. The zero address indicates there is no approved address.\n /// When a Transfer event emits, this also indicates that the approved\n /// address for that NFT (if any) is reset to none.\n event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);\n\n /// @dev This emits when an operator is enabled or disabled for an owner.\n /// The operator can manage all NFTs of the owner.\n event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);\n\n bytes4 internal constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;\n\n // ERC 165\n mapping(bytes4 => bool) internal supportedInterfaces;\n\n /**\n * @dev A mapping from NFT ID to the address that owns it.\n */\n mapping (uint256 => address) internal idToOwner;\n\n /**\n * @dev Mapping from NFT ID to approved address.\n */\n mapping (uint256 => address) internal idToApproval;\n\n /**\n * @dev Mapping from owner address to mapping of operator addresses.\n */\n mapping (address => mapping (address => bool)) internal ownerToOperators;\n\n /**\n * @dev Mapping from owner to list of owned NFT IDs.\n */\n mapping(address => uint256[]) internal ownerToIds;\n\n /**\n * @dev Mapping from NFT ID to its index in the owner tokens list.\n */\n mapping(uint256 => uint256) internal idToOwnerIndex;\n\n /**\n * @dev Total number of tokens.\n */\n uint internal numTokens = 0;\n\n /**\n * @dev Guarantees that the msg.sender is an owner or operator of the given NFT.\n * @param _tokenId ID of the NFT to validate.\n */\n modifier canOperate(uint256 _tokenId) {\n address tokenOwner = idToOwner[_tokenId];\n require(tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender]);\n _;\n }\n\n /**\n * @dev Guarantees that the msg.sender is allowed to transfer NFT.\n * @param _tokenId ID of the NFT to transfer.\n */\n modifier canTransfer(uint256 _tokenId) {\n address tokenOwner = idToOwner[_tokenId];\n require(\n tokenOwner == msg.sender\n || idToApproval[_tokenId] == msg.sender\n || ownerToOperators[tokenOwner][msg.sender]\n );\n _;\n }\n\n /**\n * @dev Guarantees that _tokenId is a valid Token.\n * @param _tokenId ID of the NFT to validate.\n */\n modifier validNFToken(uint256 _tokenId) {\n require(idToOwner[_tokenId] != address(0));\n _;\n }\n\n struct Trait {\n string background;\n uint len;\n mapping(uint => OneTrait) elements;\n }\n\n struct OneTrait {\n uint figure;\n uint cx;\n uint cy;\n uint width;\n uint height;\n string color;\n }\n\n /** \n * @dev Nfts collection.\n */\n mapping(uint => Trait) nfts;\n\n /**\n * @dev List of nft figures color.\n */\n string[] internal colors = ['bf392b','e74c3c','9b59b6','8d44ad','2980b9','3398da','1abc9b','169f85','26ae60','2fcb71','f1c40f','f39c13','e57e23','d35400','808b96','17202a','e6b0aa','f7dc6f','f8c370','7fb3d5'];\n \n /**\n * @dev List of nfts background color.\n */\n string[] internal background = ['f2d7d5', 'fadbd8', 'ebdef0', 'e8daee', 'd3e6f1', 'd6eaf8','d0f2eb', 'cfece7','d4efdf','d5f5e3','fbf3cf','fdebd0','f9e5d3','f6ddcc','fbfcfc']; \n \n string internal nftName = \"CircleSquareRectangle\";\n string internal nftSymbol = \"CSR\";\n \n string internal constant s1 = '<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 500 500\"><rect y=\"0\" x=\"0\" width=\"500\" height=\"500\" fill=\"#';\n string internal constant s2 = '</svg>';\n string internal constant s3 = '\"/>';\n\n uint public constant TOKEN_LIMIT = 515; // nfts limit\n uint[] internal nftsQty; // max quantity of nfts by type\n uint[] internal nftsQtyCurrent = [0,0,0]; // current quantity of nfts by type\n\n /**\n * @dev Contract constructor.\n */\n constructor() {\n supportedInterfaces[0x01ffc9a7] = true; // ERC165\n supportedInterfaces[0x80ac58cd] = true; // ERC721\n supportedInterfaces[0x780e9d63] = true; // ERC721 Enumerable\n supportedInterfaces[0x5b5e139f] = true; // ERC721 Metadata\n\n nftsQty.push(464); // 0\n nftsQty.push(32); // 1\n nftsQty.push(16); // 2\n\n // generate\n // kind 0\n draw(1, 0);\n _addNFToken(msg.sender, 1);\n // kind 1\n draw(2, 1);\n _addNFToken(msg.sender, 2);\n // kind 2\n draw(3, 2);\n _addNFToken(msg.sender, 3);\n\n numTokens = 3;\n nftsQtyCurrent[0] = 1;\n nftsQtyCurrent[1] = 1;\n nftsQtyCurrent[2] = 1;\n }\n\n /**\n * Generate random number between A and B.\n * @param _seed integer seed number\n * @param _a minimum number\n * @param _b maximim number\n * @return integer number\n */\n function minMax(uint _seed, uint _a, uint _b) internal view returns (uint) {\n return uint(uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, _seed)))%uint(_b-_a+1))+_a;\n }\n\n /**\n * Convert uint to string.\n * @param _i uint\n * @return _uintAsString string\n */\n function uint2str(uint _i) internal pure returns (string memory _uintAsString) {\n if (_i == 0) {\n return \"0\";\n }\n uint j = _i;\n uint len;\n while (j != 0) {\n len++;\n j /= 10;\n }\n bytes memory bstr = new bytes(len);\n uint k = len;\n while (_i != 0) {\n k = k-1;\n uint8 temp = (48 + uint8(_i - _i / 10 * 10));\n bytes1 b1 = bytes1(temp);\n bstr[k] = b1;\n _i /= 10;\n }\n return string(bstr);\n }\n\n /**\n * @dev create rectangle.\n * @param _cx cx coordinate.\n * @param _cy cy coordinate.\n * @param _radius figure's radius.\n * @param fill figure's color.\n * @param stroke figure's stroke color.\n */\n function createCircle(uint _cx, uint _cy, uint _radius, string memory fill, string memory stroke) internal pure returns(string memory) {\n return string.concat('<circle cx=\"', uint2str(_cx), '\" cy=\"', uint2str(_cy), '\" r=\"', uint2str(_radius), '\"', (bytes(stroke).length > 0 ? string.concat(' stroke=\"#', stroke, '\" stroke-width=\"10\"') : ''), ' fill=\"', (bytes(fill).length > 0 ? string.concat('#', fill) : 'none'), s3);\n }\n\n /**\n * @dev create rectangle.\n * @param _y y coordinate.\n * @param _x x coordinate.\n * @param _height figure's height.\n * @param _width figure's width.\n * @param color figure's color.\n */\n function createRectangle(uint _y, uint _x, uint _height, uint _width, string memory color) pure internal returns(string memory) {\n return string.concat('<rect y=\"', uint2str(_y), '\" x=\"', uint2str(_x), '\" height=\"', uint2str(_height), '\" width=\"', uint2str(_width), '\" fill=\"#', color, s3);\n }\n \n /**\n * @dev create one figure.\n * Available circle, square, rectangle\n * @param _figure figure.\n * @param _cx xc coordinate.\n * @param _cy cy coordinate.\n * @param _width figure's width.\n * @param _width figure's width.\n * @param color figure's color.\n */\n function createFigure(uint _figure, uint _cx, uint _cy, uint _width, uint _height, string memory color) internal view returns(string memory) {\n string memory out;\n if (_figure >= 0 && _figure <= 35) {\n out = string.concat(out, createCircle(_cx, _cy, _width, color, ''));\n } else if (_figure > 35 && _figure <= 75) {\n out = string.concat(out, createRectangle(_cx, _cy, _height, _width, color));\n } else if (_figure > 75 && _figure <= 95) {\n out = string.concat(out, createCircle(_cx, _cy, _width, '', color));\n } else if (_figure > 95) {\n _width = minMax(_cx * _cy * 2, 65, 100);\n for (uint i = 0; i < 3; i++) { \n out = string.concat(out, createCircle(_cx, _cy, _width, '', color));\n _width-=15;\n }\n }\n return out;\n }\n\n /**\n * @dev return generated nft.\n * @param _tokenId id of nft.\n * @return nfts string\n */\n function drawByKind(uint _tokenId) internal view returns (string memory) {\n require(numTokens >= _tokenId, \"no nft\");\n string memory out;\n uint figure;\n uint cx;\n uint cy;\n uint width;\n uint height;\n string memory color;\n bool _generate;\n out = string.concat(out, s1, nfts[_tokenId].background, s3);\n if (nfts[_tokenId].elements[0].figure == 0) _generate = true;\n for(uint i = 0; i<nfts[_tokenId].len; i++) {\n figure = nfts[_tokenId].elements[i].figure;\n cx = nfts[_tokenId].elements[i].cx;\n cy = nfts[_tokenId].elements[i].cy;\n width = nfts[_tokenId].elements[i].width;\n if (_generate) {\n figure = minMax(i * 12, 0, 100);\n cx = minMax(cx * cy * figure * i * 16, cx - 25, cx + 25);\n cy = minMax(cx * cy * i * 17, cy - 25, cy + 25);\n width = minMax(cx * cy * figure * i * 19, 5, 100);\n height = (figure > 55 && figure <= 75) ? minMax(cx * cy * 512, 45, 100) : width;\n }\n if (bytes(nfts[_tokenId].elements[i].color).length == 0 || _generate) {\n color = colors[minMax(block.timestamp * i, 0, colors.length - 1)];\n } else {\n color = nfts[_tokenId].elements[i].color;\n }\n out = string.concat(out, createFigure(figure, cx, cy, width, height, color));\n }\n return string.concat(out, s2);\n }\n\n /**\n * Generate new NFT.\n * @param _tokenId uint - token id.\n * @param _kind uint8 - type of nft.\n */\n function draw(uint _tokenId, uint8 _kind) internal returns (string memory) {\n Trait storage t = nfts[_tokenId];\n OneTrait memory ot;\n uint figure;\n uint8 k = _kind;\n bool isShow;\n uint cx;\n uint cy;\n uint width;\n uint height;\n uint index;\n string memory out;\n string memory color;\n string memory backgroundColor = background[minMax(block.timestamp, 0, background.length - 1)];\n out = string.concat(out, s1, backgroundColor, s3);\n for(uint y = 0; y < 500; y+=50) {\n\n for(uint x = 0; x < 500; x+=50) {\n\n isShow = minMax(y * x * 128, 0, 100) > 80;\n if (isShow) {\n figure = minMax(y * x * 64, 0, 100);\n cx = minMax(y * x * figure, (x < 25 ? 0 : x - 25), x + 25);\n cy = minMax(y * x * cx, (y < 25 ? 0 : y - 25), y + 25);\n width = minMax(x * y * cy, 5, 100);\n color = colors[minMax(x * y * width, 0, colors.length - 1)];\n height = (figure > 55 && figure <= 75) ? minMax(cx * cy * 512, 45, 100) : width;\n out = string.concat(out, createFigure(figure, cx, cy, width, height, color));\n if (k == 1) {\n color = '';\n }\n if (k == 2) {\n figure = 0;\n color = '';\n }\n ot = OneTrait(figure, cx, cy, width, height, color);\n t.elements[index] = ot;\n index++;\n }\n }\n }\n t.background = backgroundColor;\n t.len = index;\n return string.concat(out, s2);\n }\n\n /**\n * Create Circle Square Rectangle figure.\n */\n function createCsr() external payable returns (string memory) {\n return _mint(msg.sender);\n }\n\n //////////////////////////\n //// ERC 721 and 165 ////\n //////////////////////////\n function isContract(address _addr) internal view returns (bool addressCheck) {\n uint256 size;\n assembly { size := extcodesize(_addr) } // solhint-disable-line\n addressCheck = size > 0;\n }\n\n /**\n * @dev Function to check which interfaces are suported by this contract.\n * @param _interfaceID Id of the interface.\n * @return True if _interfaceID is supported, false otherwise.\n */\n function supportsInterface(bytes4 _interfaceID) external view returns (bool) {\n return supportedInterfaces[_interfaceID];\n }\n\n /**\n * @dev Transfers the ownership of an NFT from one address to another address. This function can\n * be changed to payable.\n * @notice Throws unless `msg.sender` is the current owner, an authorized operator, or the\n * approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is\n * the zero address. Throws if `_tokenId` is not a valid NFT. When transfer is complete, this\n * function checks if `_to` is a smart contract (code size > 0). If so, it calls\n * `onERC721Received` on `_to` and throws if the return value is not\n * `bytes4(keccak256(\"onERC721Received(address,uint256,bytes)\"))`.\n * @param _from The current owner of the NFT.\n * @param _to The new owner.\n * @param _tokenId The NFT to transfer.\n * @param _data Additional data with no specified format, sent in call to `_to`.\n */\n function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) external {\n _safeTransferFrom(_from, _to, _tokenId, _data);\n }\n\n /**\n * @dev Transfers the ownership of an NFT from one address to another address. This function can\n * be changed to payable.\n * @notice This works identically to the other function with an extra data parameter, except this\n * function just sets data to \"\"\n * @param _from The current owner of the NFT.\n * @param _to The new owner.\n * @param _tokenId The NFT to transfer.\n */\n function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {\n _safeTransferFrom(_from, _to, _tokenId, \"\");\n }\n\n /**\n * @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved\n * address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero\n * address. Throws if `_tokenId` is not a valid NFT. This function can be changed to payable.\n * @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else\n * they maybe be permanently lost.\n * @param _from The current owner of the NFT.\n * @param _to The new owner.\n * @param _tokenId The NFT to transfer.\n */\n function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {\n address tokenOwner = idToOwner[_tokenId];\n require(tokenOwner == _from);\n require(_to != address(0));\n _transfer(_to, _tokenId);\n }\n\n /**\n * @dev Set or reaffirm the approved address for an NFT. This function can be changed to payable.\n * @notice The zero address indicates there is no approved address. Throws unless `msg.sender` is\n * the current NFT owner, or an authorized operator of the current owner.\n * @param _approved Address to be approved for the given NFT ID.\n * @param _tokenId ID of the token to be approved.\n */\n function approve(address _approved, uint256 _tokenId) external canOperate(_tokenId) validNFToken(_tokenId) {\n address tokenOwner = idToOwner[_tokenId];\n require(_approved != tokenOwner);\n idToApproval[_tokenId] = _approved;\n emit Approval(tokenOwner, _approved, _tokenId);\n }\n\n /**\n * @dev Enables or disables approval for a third party (\"operator\") to manage all of\n * `msg.sender`'s assets. It also emits the ApprovalForAll event.\n * @notice This works even if sender doesn't own any tokens at the time.\n * @param _operator Address to add to the set of authorized operators.\n * @param _approved True if the operators is approved, false to revoke approval.\n */\n function setApprovalForAll(address _operator, bool _approved) external {\n ownerToOperators[msg.sender][_operator] = _approved;\n emit ApprovalForAll(msg.sender, _operator, _approved);\n }\n\n /**\n * @dev Returns the number of NFTs owned by `_owner`. NFTs assigned to the zero address are\n * considered invalid, and this function throws for queries about the zero address.\n * @param _owner Address for whom to query the balance.\n * @return Balance of _owner.\n */\n function balanceOf(address _owner) external view returns (uint256) {\n require(_owner != address(0));\n return _getOwnerNFTCount(_owner);\n }\n\n /**\n * @dev Returns the address of the owner of the NFT. NFTs assigned to zero address are considered\n * invalid, and queries about them do throw.\n * @param _tokenId The identifier for an NFT.\n * @return _owner Address of _tokenId owner.\n */\n function ownerOf(uint256 _tokenId) external view returns (address _owner) {\n _owner = idToOwner[_tokenId];\n require(_owner != address(0));\n }\n\n /**\n * @dev Get the approved address for a single NFT.\n * @notice Throws if `_tokenId` is not a valid NFT.\n * @param _tokenId ID of the NFT to query the approval of.\n * @return Address that _tokenId is approved for.\n */\n function getApproved(uint256 _tokenId) external view validNFToken(_tokenId) returns (address) {\n return idToApproval[_tokenId];\n }\n\n /**\n * @dev Checks if `_operator` is an approved operator for `_owner`.\n * @param _owner The address that owns the NFTs.\n * @param _operator The address that acts on behalf of the owner.\n * @return True if approved for all, false otherwise.\n */\n function isApprovedForAll(address _owner, address _operator) external view returns (bool) {\n return ownerToOperators[_owner][_operator];\n }\n\n /**\n * @dev Actually preforms the transfer.\n * @notice Does NO checks.\n * @param _to Address of a new owner.\n * @param _tokenId The NFT that is being transferred.\n */\n function _transfer(address _to, uint256 _tokenId) internal {\n address from = idToOwner[_tokenId];\n _clearApproval(_tokenId);\n\n _removeNFToken(from, _tokenId);\n _addNFToken(_to, _tokenId);\n\n emit Transfer(from, _to, _tokenId);\n }\n\n /**\n * @dev Mints a new NFT.\n * @notice This is an internal function which should be called from user-implemented external\n * mint function. Its purpose is to show and properly initialize data structures when using this\n * implementation.\n * @param _to The address that will own the minted NFT.\n */\n function _mint(address _to) internal returns (string memory) {\n require(_to != address(0),'null adress');\n require(numTokens < TOKEN_LIMIT);\n uint8 kind; // NFT_SIMPLE\n if (msg.value == 50000000000000000) {\n kind = 1; // NFT_NO_COLOR\n } else if(msg.value == 80000000000000000) {\n kind = 2; // NFT_RANDOM\n }\n // simple nfts check\n if(kind == 0 && msg.value != 30000000000000000) { revert(); }\n // can generate nfts by type\n require(nftsQty[kind] >= nftsQtyCurrent[kind] + 1, \"no nfts by this type.\");\n uint id = numTokens + 1;\n string memory uri = draw(id, kind);\n emit Generated(id, _to, uri);\n\n numTokens++;\n nftsQtyCurrent[kind]++;\n _addNFToken(_to, id);\n\n emit Transfer(address(0), _to, id);\n return uri;\n }\n\n /**\n * @dev Assigns a new NFT to an address.\n * @notice Use and override this function with caution. Wrong usage can have serious consequences.\n * @param _to Address to which we want to add the NFT.\n * @param _tokenId Which NFT we want to add.\n */\n function _addNFToken(address _to, uint256 _tokenId) internal {\n require(idToOwner[_tokenId] == address(0));\n idToOwner[_tokenId] = _to;\n ownerToIds[_to].push(_tokenId);\n uint256 length = ownerToIds[_to].length;\n idToOwnerIndex[_tokenId] = length - 1;\n }\n\n /**\n * @dev Removes a NFT from an address.\n * @notice Use and override this function with caution. Wrong usage can have serious consequences.\n * @param _from Address from wich we want to remove the NFT.\n * @param _tokenId Which NFT we want to remove.\n */\n function _removeNFToken(address _from, uint256 _tokenId) internal {\n require(idToOwner[_tokenId] == _from);\n delete idToOwner[_tokenId];\n\n uint256 tokenToRemoveIndex = idToOwnerIndex[_tokenId];\n uint256 lastTokenIndex = ownerToIds[_from].length - 1;\n\n if (lastTokenIndex != tokenToRemoveIndex) {\n uint256 lastToken = ownerToIds[_from][lastTokenIndex];\n ownerToIds[_from][tokenToRemoveIndex] = lastToken;\n idToOwnerIndex[lastToken] = tokenToRemoveIndex;\n }\n\n ownerToIds[_from].pop();\n }\n\n /**\n * @dev Helper function that gets NFT count of owner. This is needed for overriding in enumerable\n * extension to remove double storage (gas optimization) of owner nft count.\n * @param _owner Address for whom to query the count.\n * @return Number of _owner NFTs.\n */\n function _getOwnerNFTCount(address _owner) internal view returns (uint256) {\n return ownerToIds[_owner].length;\n }\n\n /**\n * @dev Actually perform the safeTransferFrom.\n * @param _from The current owner of the NFT.\n * @param _to The new owner.\n * @param _tokenId The NFT to transfer.\n * @param _data Additional data with no specified format, sent in call to `_to`.\n */\n function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) private canTransfer(_tokenId) validNFToken(_tokenId) {\n address tokenOwner = idToOwner[_tokenId];\n require(tokenOwner == _from);\n require(_to != address(0));\n\n _transfer(_to, _tokenId);\n\n if (isContract(_to)) {\n bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);\n require(retval == MAGIC_ON_ERC721_RECEIVED);\n }\n }\n\n /**\n * @dev Clears the current approval of a given NFT ID.\n * @param _tokenId ID of the NFT to be transferred.\n */\n function _clearApproval(uint256 _tokenId) private {\n if (idToApproval[_tokenId] != address(0)) {\n delete idToApproval[_tokenId];\n }\n }\n\n //// Enumerable\n\n /**\n * @dev Count NFTs tracked by this contract\n * @return A count of valid NFTs tracked by this contract, where each one of\n * them has an assigned and queryable owner not equal to the zero address\n */\n function totalSupply() public view returns (uint256) {\n return numTokens;\n }\n\n /**\n * @dev Throws if `_index` >= `totalSupply()`.\n * @param _index A counter less than `totalSupply()`\n * @return The token identifier for the `_index`th NFT,\n */\n function tokenByIndex(uint256 _index) public view returns (uint256) {\n require(_index < numTokens);\n return _index;\n }\n\n /**\n * @dev returns the n-th NFT ID from a list of owner's tokens.\n * @param _owner Token owner's address.\n * @param _index Index number representing n-th token in owner's list of tokens.\n * @return Token id.\n */\n function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {\n require(_index < ownerToIds[_owner].length);\n return ownerToIds[_owner][_index];\n }\n\n //// Metadata\n\n /**\n * @dev Returns a descriptive name for a collection of NFTokens.\n * @return _name Representing name.\n */\n function name() external view returns (string memory _name) {\n _name = nftName;\n }\n\n /**\n * @dev Returns an abbreviated name for NFTokens.\n * @return _symbol Representing symbol.\n */\n function symbol() external view returns (string memory _symbol) {\n _symbol = nftSymbol;\n }\n\n /**\n * @dev A distinct URI (RFC 3986) for a given NFT.\n * @param _tokenId Id for which we want uri.\n * @return URI of _tokenId.\n */\n function tokenURI(uint256 _tokenId) external view validNFToken(_tokenId) returns (string memory) {\n return drawByKind(_tokenId);\n }\n}"
|
