File 1 of 1: ChateauDeGeneratif.sol
pragma solidity ^0.8.20;
library GenLib {
string internal constant _TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function encode(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return "";
string memory table = _TABLE;
string memory result = new string(4 * ((data.length + 2) / 3));
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let dataPtr := data
let endPtr := add(data, mload(data))
} 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 {
mstore8(sub(resultPtr, 1), 0x3d)
mstore8(sub(resultPtr, 2), 0x3d)
}
case 2 {
mstore8(sub(resultPtr, 1), 0x3d)
}
}
return result;
}
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 parseInt(string memory _a)
internal
pure
returns (uint8 _parsedInt)
{
bytes memory bresult = bytes(_a);
uint8 mint = 0;
for (uint8 i = 0; i < bresult.length; i++) {
if (
(uint8(uint8(bresult[i])) >= 48) &&
(uint8(uint8(bresult[i])) <= 57)
) {
mint *= 10;
mint += uint8(bresult[i]) - 48;
}
}
return mint;
}
function parseInt256(string memory _a) internal pure returns (uint256) {
bytes memory bresult = bytes(_a);
uint256 mint = 0;
for (uint256 i = 0; i < bresult.length; i++) {
if (bresult[i] >= "0" && bresult[i] <= "9") {
mint *= 10;
mint += uint256(uint8(bresult[i]) - 48);
}
}
return mint;
}
function substring(
string memory str,
uint256 startIndex,
uint256 endIndex
) internal pure returns (string memory) {
bytes memory strBytes = bytes(str);
bytes memory result = new bytes(endIndex - startIndex);
for (uint256 i = startIndex; i < endIndex; i++) {
result[i - startIndex] = strBytes[i];
}
return string(result);
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
pragma solidity ^0.8.20;
interface IERC20Errors {
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
interface IERC721Errors {
error ERC721InvalidOwner(address owner);
error ERC721NonexistentToken(uint256 tokenId);
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
error ERC721InvalidSender(address sender);
error ERC721InvalidReceiver(address receiver);
error ERC721InsufficientApproval(address operator, uint256 tokenId);
error ERC721InvalidApprover(address approver);
error ERC721InvalidOperator(address operator);
}
interface IERC1155Errors {
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
error ERC1155InvalidSender(address sender);
error ERC1155InvalidReceiver(address receiver);
error ERC1155MissingApprovalForAll(address operator, address owner);
error ERC1155InvalidApprover(address approver);
error ERC1155InvalidOperator(address operator);
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
pragma solidity ^0.8.20;
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
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_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
pragma solidity ^0.8.20;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.20;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.20;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.20;
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, bytes calldata data) external;
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 setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.20;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.20;
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);
}
pragma solidity ^0.8.20;
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 tokenId => address) private _owners;
mapping(address owner => uint256) private _balances;
mapping(uint256 tokenId => address) private _tokenApprovals;
mapping(address owner => mapping(address operator => 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 returns (uint256) {
if (owner == address(0)) {
revert ERC721InvalidOwner(address(0));
}
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual returns (address) {
return _requireOwned(tokenId);
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
_requireOwned(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual {
_approve(to, tokenId, _msgSender());
}
function getApproved(uint256 tokenId) public view virtual returns (address) {
_requireOwned(tokenId);
return _getApproved(tokenId);
}
function setApprovalForAll(address operator, bool approved) public virtual {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, _msgSender());
if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
transferFrom(from, to, tokenId);
_checkOnERC721Received(from, to, tokenId, data);
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _getApproved(uint256 tokenId) internal view virtual returns (address) {
return _tokenApprovals[tokenId];
}
function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
return
spender != address(0) &&
(owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
}
function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
if (!_isAuthorized(owner, spender, tokenId)) {
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else {
revert ERC721InsufficientApproval(spender, tokenId);
}
}
}
function _increaseBalance(address account, uint128 value) internal virtual {
unchecked {
_balances[account] += value;
}
}
function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
address from = _ownerOf(tokenId);
if (auth != address(0)) {
_checkAuthorized(from, auth, tokenId);
}
if (from != address(0)) {
_approve(address(0), tokenId, address(0), false);
unchecked {
_balances[from] -= 1;
}
}
if (to != address(0)) {
unchecked {
_balances[to] += 1;
}
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
return from;
}
function _mint(address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner != address(0)) {
revert ERC721InvalidSender(address(0));
}
}
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
_mint(to, tokenId);
_checkOnERC721Received(address(0), to, tokenId, data);
}
function _burn(uint256 tokenId) internal {
address previousOwner = _update(address(0), tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
}
function _transfer(address from, address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
function _safeTransfer(address from, address to, uint256 tokenId) internal {
_safeTransfer(from, to, tokenId, "");
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
_transfer(from, to, tokenId);
_checkOnERC721Received(from, to, tokenId, data);
}
function _approve(address to, uint256 tokenId, address auth) internal {
_approve(to, tokenId, auth, true);
}
function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
if (emitEvent || auth != address(0)) {
address owner = _requireOwned(tokenId);
if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
revert ERC721InvalidApprover(auth);
}
if (emitEvent) {
emit Approval(owner, to, tokenId);
}
}
_tokenApprovals[tokenId] = to;
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
if (operator == address(0)) {
revert ERC721InvalidOperator(operator);
}
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireOwned(uint256 tokenId) internal view returns (address) {
address owner = _ownerOf(tokenId);
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
return owner;
}
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
if (to.code.length > 0) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
if (retval != IERC721Receiver.onERC721Received.selector) {
revert ERC721InvalidReceiver(to);
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ERC721InvalidReceiver(to);
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
}
}
pragma solidity ^0.8.20;
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
mapping(uint256 tokenId => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 tokenId => uint256) private _allTokensIndex;
error ERC721OutOfBoundsIndex(address owner, uint256 index);
error ERC721EnumerableForbiddenBatchMint();
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 returns (uint256) {
if (index >= balanceOf(owner)) {
revert ERC721OutOfBoundsIndex(owner, index);
}
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
if (index >= totalSupply()) {
revert ERC721OutOfBoundsIndex(address(0), index);
}
return _allTokens[index];
}
function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
address previousOwner = super._update(to, tokenId, auth);
if (previousOwner == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (previousOwner != to) {
_removeTokenFromOwnerEnumeration(previousOwner, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (previousOwner != to) {
_addTokenToOwnerEnumeration(to, tokenId);
}
return previousOwner;
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = balanceOf(to) - 1;
_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 = balanceOf(from);
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();
}
function _increaseBalance(address account, uint128 amount) internal virtual override {
if (amount > 0) {
revert ERC721EnumerableForbiddenBatchMint();
}
super._increaseBalance(account, amount);
}
}
pragma solidity ^0.8.20;
contract ChateauDeGeneratif is ERC721Enumerable, ReentrancyGuard {
using GenLib for uint8;
struct TokenDetails {
address tokenAddress;
uint256 mintPrice;
uint256 mintLimit;
uint256 mintCount;
bool isAccepted;
}
struct Trait {
string traitName;
string traitType;
string pixels;
uint256 pixelCount;
}
bool public mintingOpen = false;
mapping(address => uint256) public walletMintCount;
mapping(uint256 => Trait[]) public traitTypes;
mapping(string => bool) hashToMinted;
mapping(uint256 => string) internal tokenIdToHash;
mapping(uint8 => TokenDetails) public tokenDetails;
mapping(uint8 => string[]) private secondTerms;
uint256 SEED_NONCE = 0;
uint256 public maxSupply = 2800;
uint256 public mintLimitPerWallet = 10;
uint256 private constant splPer1 = 70;
address constant ETH_ADDRESS = 0x0000000000000000000000000000000000000000;
address LINK_ADDRESS = 0x514910771AF9Ca656af840dff83E8264EcF986CA;
address WBTC_ADDRESS = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
address RLB_ADDRESS = 0x046EeE2cc3188071C02BfC1745A6b17c656e3f3d;
address SHIB_ADDRESS = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address PEPE_ADDRESS = 0x6982508145454Ce325dDbE47a25d4ec3d2311933;
address BITCOIN_ADDRESS = 0x72e4f9F808C49A2a61dE9C5896298920Dc4EEEa9;
address APE_ADDRESS = 0x4d224452801ACEd8B2F0aebE155379bb5D594381;
address LADYS_ADDRESS = 0x12970E6868f88f6557B76120662c1B3E50A646bf;
address GP_ADDRESS = 0x38Ec27c6F05a169e7eD03132bcA7d0cfeE93C2C5;
address _owner;
address payable private address1;
address private constant address2 = 0xD1f785A1642c3310da57Bc966DB21328d96AC2c2;
string[] LETTERS = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
uint16[][8] TIERS;
constructor() ERC721("Chateau De Generatif", "CDG") {
_owner = msg.sender;
address1 = payable(_owner);
secondTerms[0] = ["Vitalique", "Gweigio", "DeFiasco", "De Generatif", "Hashianti", "Defignac", "Blockbelle"];
secondTerms[1] = ["Chainiot Noir", "D'Oracle", "Nodevignoble", "Linklanc", "Linklaret", "Oracelle", "Syncsirah"];
secondTerms[2] = ["Satoshiraz", "Wraprignon", "Ledgernet", "Bitbourg", "Hasherlot", "Ledgerlieu", "Bitbeau"];
secondTerms[3] = ["Casinot", "Betblanc", "Rol' Brut", "Rollblanc", "Rouletteau", "Gambelais", "Casinac"];
secondTerms[4] = ["Le Dogelais", "Pawsecco", "Puppignon", "Shibernet", "Inuvignon", "Dogelato", "Puppoli"];
secondTerms[5] = ["De Pepe", "Le Pepernay", "Greenogrigio", "Pays Du Pepe", "Ribbitret", "Froggiac", "Hopricot"];
secondTerms[6] = ["Sonique", "Hedgehogue", "Barack", "Obamaroma", "Pottere", "Le Coin De Bite", "Hedgehaut"];
secondTerms[7] = ["Boredaux", "Apevignon", "Apellation D'Ape", "Apertino", "Apeaujolais", "Yachtinac", "Primatage"];
secondTerms[8] = ["Remiliot", "De La Rave", "Ladylicante", "Shizo", "Miladoret", "Du Frank", "Chibicru"];
secondTerms[9] = ["D'Or", "Chainpain", "Du Dragon", "Goldpour", "Gold Cuvee", "Dragonello", "Dragonderne"];
tokenDetails[0] = TokenDetails(ETH_ADDRESS, 40000000000000000, 2240, 0, true);
tokenDetails[1] = TokenDetails(LINK_ADDRESS, 5430000000000000000, 336, 0, true);
tokenDetails[2] = TokenDetails(WBTC_ADDRESS, 170000, 280, 0, true);
tokenDetails[3] = TokenDetails(RLB_ADDRESS, 461000000000000000000, 280, 0, true);
tokenDetails[4] = TokenDetails(SHIB_ADDRESS, 7800000000000000000000000, 336, 0, true);
tokenDetails[5] = TokenDetails(PEPE_ADDRESS, 50200000000000000000000000, 336, 0, true);
tokenDetails[6] = TokenDetails(BITCOIN_ADDRESS, 64000000000, 168, 0, true);
tokenDetails[7] = TokenDetails(APE_ADDRESS, 37000000000000000000, 140, 0, true);
tokenDetails[8] = TokenDetails(LADYS_ADDRESS, 351000000000000000000000000, 140, 0, true);
tokenDetails[9] = TokenDetails(GP_ADDRESS, 400000000000000000000000, 49, 0, true);
TIERS[0] = [5300, 100, 850, 500, 700, 900, 700, 350, 300, 250];
TIERS[1] = [3400, 1200, 1100, 1000, 900, 500, 500, 500, 500, 400];
TIERS[2] = [3100, 2100, 1475, 1150, 800, 600, 350, 200, 125, 100];
TIERS[3] = [8300, 400, 250, 150, 300, 600];
TIERS[4] = [6000, 1000, 150, 250, 500, 750, 300, 750, 300];
TIERS[5] = [1700, 1800, 600, 1800, 1400, 1400, 800, 100, 400];
TIERS[6] = [9000, 750, 200, 50];
TIERS[7] = [3700, 500, 1000, 1900, 1000, 1900];
}
function rarityGen(uint256 _randinput, uint8 _rarityTier)
internal
view
returns (string memory)
{
uint16 currentLowerBound = 0;
for (uint8 i = 0; i < TIERS[_rarityTier].length; i++) {
uint16 thisPercentage = TIERS[_rarityTier][i];
if (
_randinput >= currentLowerBound &&
_randinput < currentLowerBound + thisPercentage
) return i.toString();
currentLowerBound = currentLowerBound + thisPercentage;
}
revert();
}
function hash(
uint256 _t,
address _a,
uint256 _c,
uint8 _tokenId
) internal returns (string memory) {
require(_c < 10);
string memory currentHash = GenLib.toString(_tokenId);
for (uint8 i = 0; i < 8; i++) {
SEED_NONCE++;
uint16 _randinput = uint16(
uint256(
keccak256(
abi.encodePacked(
block.timestamp,
block.prevrandao,
_t,
_a,
_c,
SEED_NONCE
)
)
) % 10000
);
currentHash = string(
abi.encodePacked(currentHash, rarityGen(_randinput, i))
);
}
if (hashToMinted[currentHash]) return hash(_t, _a, _c + 1, _tokenId);
return currentHash;
}
function mintCDG(uint8 _tokenId, uint8 _quantity) payable public nonReentrant {
require(mintingOpen || msg.sender == _owner, "Minting is closed");
require(walletMintCount[msg.sender] + _quantity <= mintLimitPerWallet || msg.sender == _owner, "Exceeds wallet mint limit");
require(_quantity > 0 && (_quantity <= 5 || msg.sender == _owner), "1 to 5 NFTs allowed per transaction");
TokenDetails storage details = tokenDetails[_tokenId];
require(details.isAccepted, "Token not accepted");
uint256 totalTokenAmount = details.mintPrice * _quantity;
uint256 _totalSupply = totalSupply();
require(_totalSupply + _quantity <= maxSupply, "Exceeds max supply");
require(details.mintCount + _quantity <= details.mintLimit, "Exceeds mint limit for token");
if (_tokenId == 0) {
require(msg.value == totalTokenAmount, "Incorrect ETH value");
} else {
require(msg.value == 0, "ETH not required for ERC-20 minting");
IERC20 tokenContract = IERC20(details.tokenAddress);
require(tokenContract.transferFrom(msg.sender, address(this), totalTokenAmount), "ERC20 Transfer failed");
}
for (uint8 i = 0; i < _quantity; i++) {
uint256 newTokenId = _totalSupply + i;
tokenIdToHash[newTokenId] = hash(newTokenId, msg.sender, 0, _tokenId);
hashToMinted[tokenIdToHash[newTokenId]] = true;
_mint(msg.sender, newTokenId);
}
details.mintCount += _quantity;
walletMintCount[msg.sender] += _quantity;
}
function generateName(string memory tokenHash) public view returns (string memory) {
uint8[4] memory indices = [
GenLib.parseInt(GenLib.substring(tokenHash, 0, 1)),
GenLib.parseInt(GenLib.substring(tokenHash, 1, 2)),
GenLib.parseInt(GenLib.substring(tokenHash, 2, 3)),
GenLib.parseInt(GenLib.substring(tokenHash, 3, 4))
];
uint256 hashValue = uint256(keccak256(abi.encodePacked(tokenHash)));
string memory suffix = traitTypes[1][indices[1]].traitName;
string memory prefix = traitTypes[2][indices[2]].traitName;
string memory secondTerm = secondTerms[indices[0]][hashValue % 7];
string memory yearStr = traitTypes[3][indices[3]].traitName;
uint256 startYear = GenLib.parseInt256(GenLib.substring(yearStr, 0, 4));
uint256 range = traitTypes[3][indices[3]].pixelCount;
string memory year = GenLib.toString(startYear - (hashValue % (range + 1)));
return string(abi.encodePacked(prefix, secondTerm, suffix, " ", year));
}
function letterToNumber(string memory _inputLetter)
internal
view
returns (uint8)
{
for (uint8 i = 0; i < LETTERS.length; i++) {
if (
keccak256(abi.encodePacked((LETTERS[i]))) ==
keccak256(abi.encodePacked((_inputLetter)))
) return (i);
}
revert();
}
function hashToSVG(string memory _hash) public view returns (string memory) {
string memory svgString;
bool[26][26] memory placedPixels;
bool shouldFlip = shouldFlipSVG(_hash);
for (uint8 i = 4; i < 9; i++) {
uint8 thisTraitIndex = GenLib.parseInt(
GenLib.substring(_hash, i, i + 1)
);
for (uint16 j = 0; j < traitTypes[i][thisTraitIndex].pixelCount; j++) {
string memory thisPixel = GenLib.substring(
traitTypes[i][thisTraitIndex].pixels,
j * 4,
j * 4 + 4
);
svgString = processPixel(thisPixel, placedPixels, svgString, shouldFlip, 1, 2);
}
}
string memory hardcodedPixels = "ha11ia11ja11ka11hb11ib10jb10kb11hc11ic10jc10kc11hd11id10jd10kd11he11ie09je09ke11hf11kf11hg11kg11il00jl00im00jm00hn00in00jn00kn00ho00io00jo00ko00hp00ip00jp00kp00hq00iq00jq00kq00hr00ir00jr00kr00hs00is00js00ks00ht00it00jt00kt00hu00iu00ju00ku00hv00iv00jv00kv00hw00iw00jw00kw00ix00jx00iy00jy00hz11iz11jz11kz11";
for (uint16 k = 0; k < bytes(hardcodedPixels).length / 4; k++) {
string memory pixel = GenLib.substring(hardcodedPixels, k * 4, (k + 1) * 4);
svgString = processPixel(pixel, placedPixels, svgString, shouldFlip, 1 , 2);
}
string memory colorStyles = generateColorStyles(_hash);
svgString = string(
abi.encodePacked(
'<svg id="wine-svg" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 20 30">',
svgString,
"<style>rect{width:1px;height:1px;} #wine-svg{shape-rendering: crispedges;} ",
colorStyles,
"</style></svg>"
)
);
return svgString;
}
function shouldFlipSVG(string memory _hash) internal pure returns (bool) {
uint256 hashNumber = uint256(keccak256(abi.encodePacked(_hash)));
return hashNumber % 10 % 2 == 0;
}
function processPixel(string memory thisPixel, bool[26][26] memory placedPixels, string memory svgString, bool shouldFlip, uint8 paddingLeft, uint8 paddingTop) internal view returns (string memory) {
uint8 originalX = letterToNumber(
GenLib.substring(thisPixel, 0, 1)
);
uint8 y = letterToNumber(
GenLib.substring(thisPixel, 1, 2)
);
uint8 x = shouldFlip ? (17 - originalX) : originalX;
if (!placedPixels[x][y]) {
svgString = string(
abi.encodePacked(
svgString,
"<rect class='c",
GenLib.substring(thisPixel, 2, 4),
"' x='",
(x + paddingLeft).toString(),
"' y='",
(y + paddingTop).toString(),
"'/>"
)
);
placedPixels[x][y] = true;
}
return svgString;
}
function generateColorStyles(string memory _hash) internal view returns (string memory) {
string memory colorStyles = "";
string memory colorCodesTrait0 = traitTypes[0][GenLib.parseInt(GenLib.substring(_hash, 0, 1))].pixels;
string memory colorCodesTrait1 = traitTypes[1][GenLib.parseInt(GenLib.substring(_hash, 1, 2))].pixels;
string memory colorCodesTrait2 = traitTypes[2][GenLib.parseInt(GenLib.substring(_hash, 2, 3))].pixels;
for (uint i = 0; i < 3; i++) {
string memory colorCode = GenLib.substring(colorCodesTrait1, i * 3, (i + 1) * 3);
colorStyles = string(abi.encodePacked(colorStyles, ".c0", GenLib.toString(i), "{fill:#", colorCode, "}"));
}
for (uint i = 0; i < 3; i++) {
string memory colorCode = GenLib.substring(colorCodesTrait2, i * 3, (i + 1) * 3);
colorStyles = string(abi.encodePacked(colorStyles, ".c0", GenLib.toString(i + 3), "{fill:#", colorCode, "}"));
}
colorStyles = string(abi.encodePacked(colorStyles, ".c06{fill:#e64539}.c07{fill:#f57}.c08{fill:#a34}"));
for (uint i = 0; i < 2; i++) {
string memory colorCode = GenLib.substring(colorCodesTrait0, i * 3, (i + 1) * 3);
string memory className = i == 0 ? ".c09" : ".c10";
colorStyles = string(abi.encodePacked(colorStyles, className, "{fill:#", colorCode, "}"));
}
colorStyles = string(abi.encodePacked(colorStyles, ".c11{fill:#000}.c12{fill:#291d2b}.c13{fill:#ffc2a1}.c14{fill:#f0b541}.c15{fill:#3b2027}.c16{fill:#bd6a62}.c17{fill:#efe}.c18{fill:#cf7e2b}.c19{fill:#ab5130}.c20{fill:#3d2936}"));
return colorStyles;
}
function hashToMetadata(string memory _hash)
public
view
returns (string memory)
{
string memory metadataString;
for (uint8 i = 0; i < 9; i++) {
uint8 thisTraitIndex = GenLib.parseInt(
GenLib.substring(_hash, i, i + 1)
);
metadataString = string(
abi.encodePacked(
metadataString,
'{"trait_type":"',
traitTypes[i][thisTraitIndex].traitType,
'","value":"',
traitTypes[i][thisTraitIndex].traitName,
'"}'
)
);
if (i != 8)
metadataString = string(abi.encodePacked(metadataString, ","));
}
return string(abi.encodePacked("[", metadataString, "]"));
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
require(ownerOf(_tokenId) != address(0), "ERC721Metadata: URI query for nonexistent token");
string memory tokenHash = _tokenIdToHash(_tokenId);
string memory name = generateName(tokenHash);
return
string(
abi.encodePacked(
"data:application/json;base64,",
GenLib.encode(
bytes(
string(
abi.encodePacked(
'{"name": "', name, '", "tokenId": "',
GenLib.toString(_tokenId),
'", "description": "A bottle of the finest ', name, '. Generated and stored fully on-chain, courtesy of CDG.", "image": "data:image/svg+xml;base64,',
GenLib.encode(
bytes(hashToSVG(tokenHash))
),
'","attributes":',
hashToMetadata(tokenHash),
"}"
)
)
)
)
)
);
}
function _tokenIdToHash(uint256 _tokenId)
public
view
returns (string memory)
{
string memory tokenHash = tokenIdToHash[_tokenId];
return tokenHash;
}
function addTraitType(uint256 _traitTypeIndex, Trait[] memory traits)
public
onlyOwner
{
for (uint256 i = 0; i < traits.length; i++) {
traitTypes[_traitTypeIndex].push(
Trait(
traits[i].traitName,
traits[i].traitType,
traits[i].pixels,
traits[i].pixelCount
)
);
}
return;
}
function clearTraits() public onlyOwner {
for (uint256 i = 0; i < 9; i++) {
delete traitTypes[i];
}
}
function setTokenDetails(uint8 _id, address _tokenAddress, uint256 _mintPrice, uint256 _mintLimit, bool _isAccepted) external onlyOwner {
tokenDetails[_id] = TokenDetails(_tokenAddress, _mintPrice, _mintLimit, tokenDetails[_id].mintCount, _isAccepted);
}
function reduceMaxSupply(uint256 _newMaxSupply) external onlyOwner {
require(_newMaxSupply < maxSupply, "New max supply must be less than current max supply");
maxSupply = _newMaxSupply;
}
function setMintingStatus(bool _mintingStatus) external onlyOwner {
mintingOpen = _mintingStatus;
}
function setMintLimitAndOwnership(uint256 _mintLimitPerWallet, address _newOwner) external onlyOwner {
mintLimitPerWallet = _mintLimitPerWallet;
if(_newOwner != address(0) && _newOwner != _owner) {
_owner = _newOwner;
}
}
function withdrawETH() public onlyOwner {
uint256 balance = address(this).balance;
uint256 split1 = (balance * splPer1) / 100;
uint256 split2 = balance - split1;
address1.transfer(split1);
address payable payableAddress2 = payable(address2);
payableAddress2.transfer(split2);
}
function withdrawERC20(address _tokenAddress) public onlyOwner {
IERC20 token = IERC20(_tokenAddress);
uint256 balance = token.balanceOf(address(this));
uint256 split1 = (balance * splPer1) / 100;
uint256 split2 = balance - split1;
token.transfer(address1, split1);
token.transfer(address2, split2);
}
modifier onlyOwner() {
require(_owner == msg.sender);
_;
}
}
