文件 1 的 16:Address.sol
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 16:Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 3 的 16:ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 4 的 16:ERC721.sol
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
文件 5 的 16:ERC721Enumerable.sol
pragma solidity ^0.8.0;
import "../ERC721.sol";
import "./IERC721Enumerable.sol";
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
super._beforeTokenTransfer(from, to, tokenId);
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
文件 6 的 16:IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 7 的 16:IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
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);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
文件 8 的 16:IERC721Enumerable.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
文件 9 的 16:IERC721Metadata.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
文件 10 的 16:IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 11 的 16:INFTOwner.sol
pragma solidity ^0.8.0;
interface INFTOwner {
function ownerOf(uint256 tokenId) external view returns (address);
}
文件 12 的 16:Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 13 的 16:Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
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 -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
文件 14 的 16:SyncXColors.sol
pragma solidity ^0.8.4;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import 'base64-sol/base64.sol';
import './legacy_colors/TheColors.sol';
import './legacy_colors/INFTOwner.sol';
contract SyncXColors is ERC721Enumerable, Ownable {
using Strings for uint256;
using Strings for uint16;
using Strings for uint8;
uint256 public constant TotalReservedAmount = 17;
uint256 public constant MAX_SUPPLY = 4317 - TotalReservedAmount;
address public constant THE_COLORS =
address(0x9fdb31F8CE3cB8400C7cCb2299492F2A498330a4);
uint256 public constant mintPrice = 0.05 ether;
uint256 public constant resyncPrice = 0.005 ether;
uint256 public constant maxMintAmount = 10;
uint256 public MintedReserves = 0;
address private constant TREASURY =
address(0x48aE900E9Df45441B2001dB4dA92CE0E7C08c6d2);
address private constant TEAM =
address(0x263853ef2C3Dd98a986799aB72E3b78334EB88cb);
mapping(uint256 => uint16[]) private _colorTokenIds;
mapping(uint256 => uint256) private _seed;
mapping(uint256 => uint8) private _resync_count;
struct SyncTraitsStruct {
uint8[] shape_color;
uint8[] shape_type;
uint16[] shape_x;
uint16[] shape_y;
uint16[] shape_sizey;
uint16[] shape_sizex;
uint16[] shape_r;
uint16 rarity_roll;
bytes[] baseColors;
bytes[] bgColors;
bytes[] infColors;
bytes logoColors;
bytes driftColors;
bytes theme;
bytes7 sigil;
}
constructor() ERC721('Sync x Colors', 'SyncXColors') {}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721)
returns (string memory)
{
require(_exists(tokenId), 'ERC721: operator query for nonexistent token');
SyncTraitsStruct memory syncTraits = generateTraits(tokenId);
string memory svgData = generateSVGImage(tokenId, syncTraits);
string memory image = Base64.encode(bytes(svgData));
return
string(
abi.encodePacked(
'data:application/json;base64,',
Base64.encode(
bytes(
abi.encodePacked(
'{',
'"image":"',
'data:image/svg+xml;base64,',
image,
'",',
generateNameDescription(),
',',
generateAttributes(tokenId, syncTraits),
'}'
)
)
)
)
);
}
function withdraw() internal {
bool sent;
uint256 balance = address(this).balance;
(sent, ) = payable(TEAM).call{value: (balance * 50) / 100}('');
require(sent);
(sent, ) = payable(TREASURY).call{value: (balance * 50) / 100}('');
require(sent);
}
function withdrawOwner() external onlyOwner {
withdraw();
}
function withdrawTeam() external {
require(msg.sender == TEAM, 'Only team can withdraw');
withdraw();
}
function mint(uint256 _mintAmount, uint16[] calldata colorTokenIds)
external
payable
{
uint256 _mintIndex = totalSupply();
require(
_mintAmount > 0 && _mintAmount <= maxMintAmount,
'Max mint 10 per tx'
);
require(colorTokenIds.length <= 3, '# COLORS tokenIds must be <=3');
if (msg.sender == TEAM) {
require(
MintedReserves + _mintAmount <= TotalReservedAmount,
'Not enough reserve tokens'
);
MintedReserves += _mintAmount;
} else {
require(_mintIndex + _mintAmount <= MAX_SUPPLY, 'Exceeds supply');
require(msg.value == (mintPrice * _mintAmount), 'Insufficient funds');
require(isHolder(colorTokenIds), 'COLORS not owned by sender.');
}
for (uint256 i = _mintIndex; i < (_mintIndex + _mintAmount); i++) {
_colorTokenIds[i] = colorTokenIds;
_seed[i] = _rng(i);
_safeMint(msg.sender, i);
}
}
function updateColors(uint256 tokenId, uint16[] calldata colorTokenIds)
external
payable
{
require(msg.sender == ownerOf(tokenId), 'Only NFT holder can updateColors');
require(colorTokenIds.length <= 3, '# COLORS tokenIds must be <=3');
require(msg.value >= resyncPrice, 'Insufficient funds');
require(isHolder(colorTokenIds), 'COLORS not owned by sender.');
_colorTokenIds[tokenId] = colorTokenIds;
_resync_count[tokenId] += 1;
}
function isHolder(uint16[] calldata colorTokenIds)
private
view
returns (bool)
{
address colors_address = THE_COLORS;
for (uint256 i = 0; i < colorTokenIds.length; i++) {
if (
msg.sender !=
INFTOwner(colors_address).ownerOf(uint256(colorTokenIds[i]))
) {
return false;
}
}
return true;
}
function generateNameDescription()
internal
pure
returns (string memory)
{
return
string(
abi.encodePacked(
'"external_url":"https://syncxcolors.xyz",',
unicode'"description":"Sync X Colors is a unique, on-chain generative collection of Syncs on Ethereum. Each Sync can be re-colored with new Colors at any time."'
)
);
}
function generateAttributes(
uint256 tokenId,
SyncTraitsStruct memory syncTraits
) internal view returns (string memory) {
uint16[] memory colorTokenIds = _colorTokenIds[tokenId];
uint256 length = colorTokenIds.length;
bytes[] memory colorArray = new bytes[](3);
for (uint256 i = 0; i < length; i++) {
colorArray[i] = bytes(
TheColors(THE_COLORS).getHexColor(uint256(colorTokenIds[i]))
);
}
string memory attributes = string(
abi.encodePacked(
'"attributes":[',
'{"trait_type":"Rarity","value":"',
syncTraits.theme,
'"},',
'{"trait_type":"Sigil","value":"',
syncTraits.sigil,
'"},'
)
);
attributes = string(
abi.encodePacked(
attributes,
'{"trait_type":"Color 1","value":"',
colorArray[0],
'"},',
'{"trait_type":"Color 2","value":"',
colorArray[1],
'"},',
'{"trait_type":"Color 3","value":"',
colorArray[2],
'"},',
'{"trait_type":"Resyncs","value":',
_resync_count[tokenId].toString(),
'}]'
)
);
return attributes;
}
function getColorsHexStrings(uint256 tokenId)
internal
view
returns (bytes[] memory)
{
uint16[] memory colorTokenIds = _colorTokenIds[tokenId];
uint256 length = _colorTokenIds[tokenId].length;
bytes[] memory hexColors = new bytes[](3);
hexColors[0] = '#222222';
hexColors[1] = '#777777';
hexColors[2] = '#AAAAAA';
for (uint256 i = 0; i < length; i++) {
hexColors[i] = bytes(
TheColors(THE_COLORS).getHexColor(uint256(colorTokenIds[i]))
);
}
return hexColors;
}
function generateSVGImage(uint256 tokenId, SyncTraitsStruct memory syncTraits)
private
pure
returns (string memory)
{
bytes memory svgBG = generateSVGBG(syncTraits);
bytes memory svgInfinity = generateSVGInfinity(syncTraits.infColors);
bytes memory svgLogo = generateSVGLogo(
syncTraits.baseColors,
syncTraits.logoColors,
syncTraits.rarity_roll,
tokenId.toString()
);
bytes memory svgDrift = generateSVGDrift(
syncTraits.baseColors,
syncTraits.driftColors,
syncTraits.rarity_roll,
syncTraits.sigil,
tokenId.toString()
);
return
string(
abi.encodePacked(
'<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500" viewbox="0 0 500 500" style="background-color:#111111">',
svgBG,
svgInfinity,
svgLogo,
svgDrift,
'</svg>'
)
);
}
function generateSVGBG(SyncTraitsStruct memory syncTraits)
private
pure
returns (bytes memory)
{
bytes memory newShape;
bytes memory svgBG = '<g fill-opacity="0.3">';
for (uint256 i = 0; i < 15; i++) {
if (syncTraits.shape_type[i] == 0) {
newShape = abi.encodePacked(
'<circle fill="',
syncTraits.bgColors[syncTraits.shape_color[i]],
'" cx="',
syncTraits.shape_x[i].toString(),
'" cy="',
syncTraits.shape_y[i].toString(),
'" r="',
syncTraits.shape_sizex[i].toString(),
'"'
);
} else if (syncTraits.shape_type[i] == 1) {
newShape = abi.encodePacked(
'<rect fill="',
syncTraits.bgColors[syncTraits.shape_color[i]],
'" x="',
(syncTraits.shape_x[i] / 2).toString(),
'" y="',
(syncTraits.shape_y[i] / 2).toString(),
'" width="',
(syncTraits.shape_sizex[i] * 2).toString(),
'" height="',
(syncTraits.shape_sizey[i] * 2).toString(),
'" transform="rotate(',
syncTraits.shape_r[i].toString(),
')"'
);
}
if (
(syncTraits.rarity_roll % 19 == 0 &&
syncTraits.rarity_roll % 95 != 0) ||
(syncTraits.rarity_roll % 13 == 0)
) {
newShape = abi.encodePacked(
newShape,
' stroke="',
syncTraits.infColors[syncTraits.shape_color[i]],
'"/>'
);
} else {
newShape = abi.encodePacked(newShape, '/>');
}
svgBG = abi.encodePacked(svgBG, newShape);
}
return abi.encodePacked(svgBG, '</g>');
}
function generateSVGInfinity(bytes[] memory infColors)
private
pure
returns (bytes memory)
{
bytes memory infinity1 = abi.encodePacked(
'<g><path stroke-dasharray="0" stroke-dashoffset="0" stroke-width="16" ',
'd="M195.5 248c0 30 37.5 30 52.5 0s 52.5-30 52.5 0s-37.5 30-52.5 0s-52.5-30-52.5 0" fill="none">',
'<animate begin="s.begin" attributeType="XML" attributeName="stroke" values="',
infColors[0],
';',
infColors[1],
';',
infColors[0],
'" dur="4s" fill="freeze"/>'
);
bytes memory infinity2 = abi.encodePacked(
'<animate begin="s.begin" attributeType="XML" attributeName="stroke-dasharray" values="0;50;0" dur="6s" fill="freeze"/>',
'<animate begin="a.begin" attributeType="XML" attributeName="stroke-width" values="16;20;16" dur="1s" fill="freeze"/>',
'</path><path stroke-dasharray="300" stroke-dashoffset="300" stroke-width="16" ',
'd="M195.5 248c0 30 37.5 30 52.5 0s 52.5-30 52.5 0s-37.5 30-52.5 0s-52.5-30-52.5 0" fill="none">'
);
bytes memory infinity3 = abi.encodePacked(
'<animate begin="s.begin" attributeType="XML" attributeName="stroke" values="',
infColors[2],
';',
infColors[0],
';',
infColors[2],
'" dur="4s" fill="freeze"/>',
'<animate id="a" begin="s.begin;a.end" attributeType="XML" attributeName="stroke-width" values="16;20;16" dur="1s" fill="freeze"/>',
'<animate id="s" attributeType="XML" attributeName="stroke-dashoffset" begin="0s;s.end" to= "-1800" dur="6s"/></path></g>'
);
return abi.encodePacked(infinity1, infinity2, infinity3);
}
function generateSVGLogo(
bytes[] memory baseColors,
bytes memory logoColors,
uint16 rarity_roll,
string memory tokenId
) private pure returns (bytes memory) {
bytes memory logo = abi.encodePacked(
'<g id="',tokenId,'b">',
'<path d="M194 179H131c-34 65 0 143 0 143h63C132 251 194 179 194 179Zm-26 128H144s-25-35 0-111h23S126 245 168 307Z" ',
'stroke="black" fill-opacity="0.9" stroke-width="0.7">'
);
if (
rarity_roll % 333 == 0 || rarity_roll % 241 == 0 || rarity_roll % 19 == 0
) {
logo = abi.encodePacked(
logo,
'<set attributeName="stroke-dasharray" to="20"/>',
'<set attributeName="stroke-width" to="2"/>',
'<set attributeName="fill" to="',
logoColors,
'"/>',
'<animate begin="s.begin" attributeType="XML" attributeName="stroke-dashoffset" from="0" to="280" dur="6s" fill="freeze"/>',
'<animate begin="s.begin" attributeType="XML" attributeName="stroke" values="',
baseColors[0],
';',
baseColors[1],
';',
baseColors[2],
';',
baseColors[0],
'" dur="6s" fill="freeze"/>'
);
} else {
logo = abi.encodePacked(
logo,
'<animate begin="s.begin" attributeName="fill" dur="6s" '
'values="black;',
baseColors[0],
';black;',
baseColors[1],
';black;',
baseColors[2],
';black"/>'
);
}
return logo;
}
function generateSVGDrift(
bytes[] memory baseColors,
bytes memory driftColors,
uint16 rarity_roll,
bytes7 sigil,
string memory tokenId
) private pure returns (bytes memory) {
if (rarity_roll % 11 != 0) {
baseColors[0] = driftColors;
baseColors[1] = driftColors;
baseColors[2] = driftColors;
}
bytes memory borders1 = abi.encodePacked(
'</path><text x="2" y="40" font-size="3em" fill-opacity="0.3" fill="',
'black">',
sigil,
'</text>',
'<path d="M90 203c-21 41 0 91 0 91h11c0 0-16-42 0-91z" stroke-opacity="0.7" fill-opacity="0.7" fill="transparent">'
'<animate id="w" attributeName="fill" values="transparent;',
baseColors[0],
';transparent" begin="s.begin+.17s;s.begin+2.17s;s.begin+4.17s" dur="1s"/>',
'<animate begin="w.begin" attributeName="stroke" values="transparent;black;transparent" dur="1s"/>',
'</path>'
);
bytes memory borders2 = abi.encodePacked(
'<path d="M60 212c-17 34 0 74 0 74h9c0-1-13-34 0-74z" stroke-opacity="0.5" fill-opacity="0.5" fill="transparent">',
'<animate attributeName="fill" values="transparent;',
baseColors[1],
';transparent" begin="w.begin+0.2s" dur="1s"/>',
'<animate attributeName="stroke" values="transparent;black;transparent" begin="w.begin+0.2s" dur="1s"/>',
'</path>'
);
bytes memory borders3 = abi.encodePacked(
'<path d="M37 221c-13 26 0 57 0 57h7c0 0-10-26 0-57z" stroke-opacity="0.3" fill-opacity="0.3" fill="transparent">',
'<animate attributeName="fill" values="transparent;',
baseColors[2],
';transparent" begin="w.begin+0.4s" dur="1s"/>',
'<animate attributeName="stroke" values="transparent;black;transparent" begin="w.begin+0.4s" dur="1s"/>',
'</path></g><use href="#',tokenId,'b" x="-500" y="-500" transform="rotate(180)"/>'
);
return abi.encodePacked(borders1, borders2, borders3);
}
function generateTraits(uint256 tokenId)
private
view
returns (SyncTraitsStruct memory)
{
SyncTraitsStruct memory syncTraits;
syncTraits.shape_x = new uint16[](15);
syncTraits.shape_y = new uint16[](15);
syncTraits.shape_sizex = new uint16[](15);
syncTraits.shape_sizey = new uint16[](15);
syncTraits.shape_r = new uint16[](15);
syncTraits.shape_type = new uint8[](15);
syncTraits.shape_color = new uint8[](15);
syncTraits.bgColors = new bytes[](3);
syncTraits.infColors = new bytes[](3);
uint256 seed = _seed[tokenId];
syncTraits.rarity_roll = uint16(
1 + ((seed & 0x3FF) % 1000)
);
syncTraits.baseColors = getColorsHexStrings(tokenId);
if (syncTraits.rarity_roll % 333 == 0) {
syncTraits.theme = 'Concave';
syncTraits.sigil = '\xE2\x9D\xAA\x20\xE2\x9D\xAB';
syncTraits.bgColors[0] = '#214F70';
syncTraits.bgColors[1] = '#2E2E3F';
syncTraits.bgColors[2] = '#2E2E3F';
syncTraits.infColors[0] = '#FAF7C0';
syncTraits.infColors[1] = '#214F70';
syncTraits.infColors[2] = '#FAF7C0';
syncTraits.logoColors = '#FAF7C0';
syncTraits.driftColors = '#FAF7C0';
} else if (syncTraits.rarity_roll % 241 == 0) {
syncTraits.theme = 'Olympus';
syncTraits.sigil = '\xF0\x9D\x9B\x80\x20\x20\x20';
syncTraits.bgColors[0] = '#80A6AF';
syncTraits.bgColors[1] = '#3A424F';
syncTraits.bgColors[2] = '#80A6AF';
syncTraits.infColors[0] = '#FFC768';
syncTraits.infColors[1] = '#3A424F';
syncTraits.infColors[2] = '#FFC768';
syncTraits.logoColors = '#FFC768';
syncTraits.driftColors = '#FFC768';
} else if (syncTraits.rarity_roll % 19 == 0) {
syncTraits.theme = 'Silver';
syncTraits.sigil = '\xE2\x98\x86\x20\x20\x20\x20';
syncTraits.bgColors[0] = '#c0c0c0';
syncTraits.bgColors[1] = '#e5e4e2';
syncTraits.bgColors[2] = '#c0c0c0';
syncTraits.infColors[0] = 'white';
syncTraits.infColors[1] = '#C0C0C0';
syncTraits.infColors[2] = '#CD7F32';
syncTraits.logoColors = 'black';
syncTraits.driftColors = 'black';
if (syncTraits.rarity_roll % 95 == 0) {
syncTraits.theme = 'Gold';
syncTraits.sigil = '\xE2\x98\x85\x20\x20\x20\x20';
syncTraits.bgColors[0] = '#CD7F32';
syncTraits.bgColors[2] = '#725d18';
syncTraits.infColors[0] = 'black';
syncTraits.infColors[2] = '#E5E4E2';
}
} else {
syncTraits.theme = 'Common';
syncTraits.sigil = '\xE2\x97\x8F\x20\x20\x20\x20';
syncTraits.driftColors = 'white';
syncTraits.bgColors = syncTraits.baseColors;
syncTraits.infColors = syncTraits.baseColors;
bytes[] memory upgrades = new bytes[](3);
upgrades[0] = '#214F70';
upgrades[1] = '#FAF7C0';
upgrades[2] = '#222222';
if (syncTraits.rarity_roll % 13 == 0) {
syncTraits.theme = 'Mosaic';
syncTraits.sigil = '\xE2\x9C\xA6\x20\x20\x20\x20';
upgrades[2] = '#3A424F';
} else if (syncTraits.rarity_roll % 11 == 0) {
syncTraits.theme = 'Tokyo Drift';
syncTraits.sigil = '\xE2\x9C\xA7\x20\x20\x20\x20';
upgrades[2] = '#3A424F';
}
if (_colorTokenIds[tokenId].length == 0){
syncTraits.baseColors[0] = upgrades[syncTraits.rarity_roll % 3];
}
}
for (uint256 i = 0; i < 15; i++) {
syncTraits.shape_x[i] = uint16(1 + ((seed & 0x3FF) % 500));
syncTraits.shape_y[i] = uint16(1 + (((seed & 0x3FF0000) / 2**4) % 500));
syncTraits.shape_sizex[i] = uint16(
250 + (((seed & 0x1FF00000000) / 2**5) % 151)
);
syncTraits.shape_sizey[i] = uint16(
250 + (((seed & 0x1FF000000000000) >> 48) % 151)
);
syncTraits.shape_r[i] = uint16(
1 + (((seed & 0x1FF0000000000000000) / 2**6) % 360)
);
syncTraits.shape_type[i] = uint8(
((seed & 0x1FF00000000000000000000) >> 80) % 2
);
syncTraits.shape_color[i] = uint8(
((seed & 0x1FF000000000000000000000000) >> 96) % 3
);
seed = seed >> 2;
}
return syncTraits;
}
function _rng(uint256 tokenId) private view returns (uint256) {
uint256 _tokenId = tokenId + 1;
uint256 seed = uint256(uint160(THE_COLORS));
return
uint256(
keccak256(
abi.encodePacked(
_tokenId.toString(),
block.timestamp,
block.difficulty,
seed
)
)
) + uint256(_tokenId * seed);
}
}
文件 15 的 16:TheColors.sol
pragma solidity ^0.8.0;
pragma abicoder v2;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import 'base64-sol/base64.sol';
import './INFTOwner.sol';
contract TheColors is ERC721Enumerable, Ownable {
using Strings for uint256;
using Strings for uint32;
string public PROVENANCE_HASH = '';
uint256 public constant MAX_COLORS = 4317;
mapping(uint256 => uint32) private _hexColors;
mapping(uint32 => bool) public existingHexColors;
constructor() ERC721('The Colors (thecolors.art)', 'COLORS') {}
function tokenURI(uint256 tokenId)
public
view
virtual
override(ERC721)
returns (string memory)
{
require(
_hexColors[tokenId] > 0,
'ERC721Metadata: URI query for nonexistent token'
);
uint32 hexColor = _hexColors[tokenId];
string memory hexString = uintToHexString(hexColor);
string memory image = Base64.encode(bytes(generateSVGImage(hexString)));
return
string(
abi.encodePacked(
'data:application/json;base64,',
Base64.encode(
bytes(
abi.encodePacked(
'{',
'"image":"',
'data:image/svg+xml;base64,',
image,
'",',
'"image_data":"',
escapeQuotes(generateSVGImage(hexString)),
'",',
generateNameDescription(tokenId, hexString),
generateAttributes(hexColor, hexString),
'}'
)
)
)
)
);
}
function getTokenMetadata(uint256 tokenId)
public
view
returns (string memory)
{
uint32 hexColor = _hexColors[tokenId];
string memory hexString = uintToHexString(hexColor);
string memory image = Base64.encode(bytes(generateSVGImage(hexString)));
return
string(
abi.encodePacked(
'data:application/json',
'{',
'"image":"',
'data:image/svg+xml;base64,',
image,
'",',
'"image_data":"',
escapeQuotes(generateSVGImage(hexString)),
'",',
generateNameDescription(tokenId, hexString),
generateAttributes(hexColor, hexString),
'}'
)
);
}
function getTokenSVG(uint256 tokenId) public view returns (string memory) {
uint32 hexColor = _hexColors[tokenId];
string memory hexString = uintToHexString(hexColor);
return generateSVGImage(hexString);
}
function getBase64TokenSVG(uint256 tokenId)
public
view
returns (string memory)
{
uint32 hexColor = _hexColors[tokenId];
string memory hexString = uintToHexString(hexColor);
string memory image = Base64.encode(bytes(generateSVGImage(hexString)));
return string(abi.encodePacked('data:application/json;base64', image));
}
function getHexColor(uint256 tokenId) public view returns (string memory) {
uint32 hexColor = _hexColors[tokenId];
string memory hexString = uintToHexString(hexColor);
return string(abi.encodePacked('#', hexString));
}
function getRGB(uint256 tokenId) public view returns (string memory) {
string memory r = getRed(tokenId).toString();
string memory g = getGreen(tokenId).toString();
string memory b = getBlue(tokenId).toString();
return string(abi.encodePacked('rgb(', r, ',', g, ',', b, ')'));
}
function getRed(uint256 tokenId) public view returns (uint32) {
uint32 hexColor = _hexColors[tokenId];
return ((hexColor >> 16) & 0xFF);
}
function getGreen(uint256 tokenId) public view returns (uint32) {
uint32 hexColor = _hexColors[tokenId];
return ((hexColor >> 8) & 0xFF);
}
function getBlue(uint256 tokenId) public view returns (uint32) {
uint32 hexColor = _hexColors[tokenId];
return ((hexColor) & 0xFF);
}
function setProvenanceHash(string memory provenanceHash) public onlyOwner {
PROVENANCE_HASH = provenanceHash;
}
function mintNextColors(uint256 numberOfTokens) public {
require(
totalSupply() + numberOfTokens <= MAX_COLORS,
'Purchase would exceed max supply of Colors'
);
uint256 mintIndex;
for (uint256 i = 0; i < numberOfTokens; i++) {
mintIndex = totalSupply();
if (totalSupply() < MAX_COLORS) {
_safeMint(msg.sender, mintIndex);
generateRandomHexColor(mintIndex);
}
}
}
function generateNameDescription(uint256 tokenId, string memory hexString)
internal
pure
returns (string memory)
{
return
string(
abi.encodePacked(
'"external_url":"https://thecolors.art",',
unicode'"description":"The Colors are a set of 8,888 iconic shades generated and stored entirely on-chain to be used as a primitive and for color field vibes. ~ A Color is Forever ∞',
'\\nHex: #',
hexString,
'\\n\\nToken id: #',
tokenId.toString(),
'",',
'"name":"#',
hexString,
'",'
)
);
}
function generateAttributes(uint32 hexColor, string memory hexString)
internal
pure
returns (string memory)
{
string memory r = ((hexColor >> 16) & 0xFF).toString();
string memory g = ((hexColor >> 8) & 0xFF).toString();
string memory b = ((hexColor) & 0xFF).toString();
string memory rgb = string(
abi.encodePacked('rgb(', r, ',', g, ',', b, ')')
);
return
string(
abi.encodePacked(
'"attributes":[',
'{"trait_type":"Hex code","value":"#',
hexString,
'"},'
'{"trait_type":"RGB","value":"',
rgb,
'"},',
'{"trait_type":"Red","value":"',
r,
'"},',
'{"trait_type":"Green","value":"',
g,
'"},',
'{"trait_type":"Blue","value":"',
b,
'"}',
']'
)
);
}
function generateSVGImage(string memory hexString)
internal
pure
returns (string memory)
{
return
string(
abi.encodePacked(
'<svg width="690" height="690" xmlns="http://www.w3.org/2000/svg" style="background-color:#',
hexString,
'">',
'</svg>'
)
);
}
function generateRandomHexColor(uint256 tokenId) internal returns (uint32) {
uint32 hexColor = uint32(_rng() % 16777215);
while (existingHexColors[hexColor]) {
hexColor = uint32(
uint256(hexColor + block.timestamp * tokenId) % 16777215
);
}
existingHexColors[hexColor] = true;
_hexColors[tokenId] = hexColor;
return hexColor;
}
function uintToHexString(uint256 number) public pure returns (string memory) {
bytes32 value = bytes32(number);
bytes memory alphabet = '0123456789abcdef';
bytes memory str = new bytes(6);
for (uint256 i = 0; i < 3; i++) {
str[i * 2] = alphabet[uint256(uint8(value[i + 29] >> 4))];
str[1 + i * 2] = alphabet[uint256(uint8(value[i + 29] & 0x0f))];
}
return string(str);
}
function escapeQuotes(string memory symbol)
internal
pure
returns (string memory)
{
bytes memory symbolBytes = bytes(symbol);
uint256 quotesCount = 0;
for (uint256 i = 0; i < symbolBytes.length; i++) {
if (symbolBytes[i] == '"') {
quotesCount++;
}
}
if (quotesCount > 0) {
bytes memory escapedBytes = new bytes(symbolBytes.length + (quotesCount));
uint256 index;
for (uint256 i = 0; i < symbolBytes.length; i++) {
if (symbolBytes[i] == '"') {
escapedBytes[index++] = '\\';
}
escapedBytes[index++] = symbolBytes[i];
}
return string(escapedBytes);
}
return symbol;
}
function _rng() internal view returns (uint256) {
return
uint256(keccak256(abi.encodePacked(block.timestamp + block.difficulty)));
}
}
文件 16 的 16:base64.sol
pragma solidity >=0.6.0;
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
string memory table = TABLE_ENCODE;
uint256 encodedLen = 4 * ((data.length + 2) / 3);
string memory result = new string(encodedLen + 32);
assembly {
mstore(result, encodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and(shr( 6, input), 0x3F))))
resultPtr := add(resultPtr, 1)
mstore8(resultPtr, mload(add(tablePtr, and( input, 0x3F))))
resultPtr := add(resultPtr, 1)
}
switch mod(mload(data), 3)
case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
}
return result;
}
function decode(string memory _data) internal pure returns (bytes memory) {
bytes memory data = bytes(_data);
if (data.length == 0) return new bytes(0);
require(data.length % 4 == 0, "invalid base64 decoder input");
bytes memory table = TABLE_DECODE;
uint256 decodedLen = (data.length / 4) * 3;
bytes memory result = new bytes(decodedLen + 32);
assembly {
let lastBytes := mload(add(data, mload(data)))
if eq(and(lastBytes, 0xFF), 0x3d) {
decodedLen := sub(decodedLen, 1)
if eq(and(lastBytes, 0xFFFF), 0x3d3d) {
decodedLen := sub(decodedLen, 1)
}
}
mstore(result, decodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 4)
let input := mload(dataPtr)
let output := add(
add(
shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)),
shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))),
add(
shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)),
and(mload(add(tablePtr, and( input , 0xFF))), 0xFF)
)
)
mstore(resultPtr, shl(232, output))
resultPtr := add(resultPtr, 3)
}
}
return result;
}
}
{
"compilationTarget": {
"contracts/SyncXColors.sol": "SyncXColors"
},
"evmVersion": "istanbul",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 5
},
"remappings": []
}
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MintedReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"THE_COLORS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TotalReservedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"uint16[]","name":"colorTokenIds","type":"uint16[]"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resyncPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint16[]","name":"colorTokenIds","type":"uint16[]"}],"name":"updateColors","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTeam","outputs":[],"stateMutability":"nonpayable","type":"function"}]