文件 1 的 1：CitizenNFT.sol
pragma solidity >=0.8.0 <0.9.0 >=0.8.7 <0.9.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;
}
}
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);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
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);
}
}
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
library SafeMath {
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 add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library Base64 {
bytes internal constant TABLE =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function encode(bytes memory data) internal pure returns (string memory) {
uint256 len = data.length;
if (len == 0) return "";
uint256 encodedLen = 4 * ((len + 2) / 3);
bytes memory result = new bytes(encodedLen + 32);
bytes memory table = TABLE;
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let i := 0
} lt(i, len) {
} {
i := add(i, 3)
let input := and(mload(add(data, i)), 0xffffff)
let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
out := shl(8, out)
out := add(
out,
and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
)
out := shl(8, out)
out := add(
out,
and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
)
out := shl(8, out)
out := add(
out,
and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
)
out := shl(224, out)
mstore(resultPtr, out)
resultPtr := add(resultPtr, 4)
}
switch mod(len, 3)
case 1 {
mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
}
case 2 {
mstore(sub(resultPtr, 1), shl(248, 0x3d))
}
mstore(result, encodedLen)
}
return string(result);
}
}
interface IEIP2981 {
function royaltyInfo(uint256 tokenId, uint256 value)
external
view
returns (address, uint256);
}
interface IERC1155WithRoyalty {
function setTokenRoyalty(
uint256 tokenId,
address recipient,
uint16 bps
) external;
function setDefaultRoyalty(address recipient, uint16 bps) external;
}
library Errors {
string constant invalidCitizenshipId = "Unknown Citizen NFT ID";
}
contract CitizenNFT is
ERC1155,
Ownable,
IERC1155WithRoyalty,
IEIP2981,
ReentrancyGuard
{
using SafeMath for uint256;
uint256 private citizenshipStampCostInWei = 250000000000000000;
uint256 private constant CITIZEN_NFT_ID = 42;
uint256 private constant FOUNDING_NFT_ID = 69;
uint256 private constant FIRST_NFT_ID = 7;
event LogEthDeposit(address);
event CitizenLegislatureChanged(string, uint256);
event NewCitizen(address, uint256, uint256);
event TokenRoyaltySet(uint256 tokenId, address recipient, uint16 bps);
event DefaultRoyaltySet(address recipient, uint16 bps);
uint256 private mintedCitizensCounter = 0;
uint256 private mintedFoundingCitizensCounter = 0;
uint256 private mintedFirstCitizensCounter = 0;
struct TokenRoyalty {
address recipient;
uint16 bps;
}
TokenRoyalty public defaultRoyalty;
mapping(uint256 => TokenRoyalty) private _tokenRoyalties;
mapping(uint256 => string) private tokenURIs;
mapping(uint256 => string) private citizenNFTDescriptions;
bool private contractInitialized;
uint256 private reservedCitizenships;
constructor(address _royaltyRecipient, uint16 _royaltyBPS)
Ownable()
ERC1155("")
{
defaultRoyalty = TokenRoyalty(_royaltyRecipient, _royaltyBPS);
tokenURIs[
CITIZEN_NFT_ID
] = "https://gateway.pinata.cloud/ipfs/QmRRnuHVwhoYEHsTxzMcGdrCfthKTS65gnfUqDZkv6kbza";
tokenURIs[
FOUNDING_NFT_ID
] = "https://gateway.pinata.cloud/ipfs/QmSrKL6fhPYU6BbYrV97AJm3aM6naGWZK95QntXXZuGQrF";
tokenURIs[
FIRST_NFT_ID
] = "https://gateway.pinata.cloud/ipfs/Qmb6VmYiktfvNX3YkLosYwjUM82PcEkr2irZ4PWheYiG2b";
citizenNFTDescriptions[CITIZEN_NFT_ID] = "CityDAO Citizen";
citizenNFTDescriptions[FOUNDING_NFT_ID] = "CityDAO Founding Citizen";
citizenNFTDescriptions[FIRST_NFT_ID] = "CityDAO First Citizen";
contractInitialized = false;
reservedCitizenships = 0;
}
function onlineApplicationForCitizenship(uint256 _citizenNumber)
public
payable
nonReentrant
{
require(
msg.value >= citizenshipStampCostInWei * _citizenNumber,
"ser, the state machine needs oil"
);
require(
this.balanceOf(this.owner(), CITIZEN_NFT_ID) - _citizenNumber >
reservedCitizenships,
"No available Citizenship"
);
_safeTransferFrom(
this.owner(),
msg.sender,
CITIZEN_NFT_ID,
_citizenNumber,
""
);
}
function issueNewCitizenships(
address _to,
uint256 _citizenType,
uint256 _numberOfCitizens
) public onlyOwner {
if (_citizenType == 42) {
mintedCitizensCounter = mintedCitizensCounter.add(
_numberOfCitizens
);
} else if (_citizenType == 69) {
mintedFoundingCitizensCounter = mintedFoundingCitizensCounter.add(
_numberOfCitizens
);
} else if (_citizenType == 7) {
mintedFirstCitizensCounter = mintedFirstCitizensCounter.add(
_numberOfCitizens
);
} else {
revert(Errors.invalidCitizenshipId);
}
_mint(_to, _citizenType, _numberOfCitizens, "");
}
function initialCitizenship() external onlyOwner {
require(contractInitialized == false, "contract initialized already");
issueNewCitizenships(msg.sender, CITIZEN_NFT_ID, 10000);
issueNewCitizenships(msg.sender, FOUNDING_NFT_ID, 50);
issueNewCitizenships(msg.sender, FIRST_NFT_ID, 1);
contractInitialized = true;
}
function legislateCostOfEntry(uint256 _stampCost) external onlyOwner {
citizenshipStampCostInWei = _stampCost;
emit CitizenLegislatureChanged("stampCost", _stampCost);
}
function inquireCostOfEntry() external view returns (uint256) {
return citizenshipStampCostInWei;
}
function inquireHousingNumbers() external view returns (uint256) {
return mintedCitizensCounter;
}
function inquireAboutHistory() external view returns (uint256) {
return mintedFoundingCitizensCounter;
}
function raidTheCoffers() external onlyOwner {
uint256 amount = address(this).balance;
(bool success, ) = owner().call{value: amount}("");
require(success, "Anti-corruption agencies stopped the transfer");
}
function reserveCitizenships(uint256 _numberOfCitizenships)
external
onlyOwner
{
reservedCitizenships = _numberOfCitizenships;
}
function howManyReservedCitizenships() external view returns (uint256) {
return reservedCitizenships;
}
fallback() external payable {
emit LogEthDeposit(msg.sender);
}
receive() external payable {
emit LogEthDeposit(msg.sender);
}
function awardCitizenship(
address[] calldata _awardees,
uint256[] calldata _numberOfCitizenships,
uint256 _citizenshipType
) external onlyOwner {
require(
_awardees.length == _numberOfCitizenships.length,
"array length not equal"
);
address cityDAO = this.owner();
for (uint256 i = 0; i < _awardees.length; i++) {
safeTransferFrom(
cityDAO,
_awardees[i],
_citizenshipType,
_numberOfCitizenships[i],
""
);
}
}
function uri(uint256 _citizenNFTId)
public
view
override
returns (string memory)
{
string memory json = Base64.encode(
bytes(
string(
abi.encodePacked(
'{ "name": "',
citizenNFTDescriptions[_citizenNFTId],
'", ',
'"description" : ',
'"A Citizen of CityDAO holds governance in the operations and activities of CityDAO.",',
'"image": "',
tokenURIs[_citizenNFTId],
'"'
"}"
)
)
)
);
return string(abi.encodePacked("data:application/json;base64,", json));
}
function changeURIs(
string[] calldata _tokenURIs,
uint256[] calldata _citizenNFTIds
) external onlyOwner {
for (uint256 i = 0; i < _tokenURIs.length; i++) {
tokenURIs[_citizenNFTIds[i]] = _tokenURIs[i];
}
}
function setTokenRoyalty(
uint256 tokenId,
address recipient,
uint16 bps
) public override onlyOwner {
_tokenRoyalties[tokenId] = TokenRoyalty(recipient, bps);
emit TokenRoyaltySet(tokenId, recipient, bps);
}
function setDefaultRoyalty(address recipient, uint16 bps)
public
override
onlyOwner
{
defaultRoyalty = TokenRoyalty(recipient, bps);
emit DefaultRoyaltySet(recipient, bps);
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155)
returns (bool)
{
return
interfaceId == type(IEIP2981).interfaceId ||
interfaceId == type(IERC1155WithRoyalty).interfaceId ||
super.supportsInterface(interfaceId);
}
function royaltyInfo(uint256 tokenId, uint256 value)
public
view
override
returns (address, uint256)
{
if (_tokenRoyalties[tokenId].recipient != address(0)) {
return (
_tokenRoyalties[tokenId].recipient,
(value * _tokenRoyalties[tokenId].bps) / 10000
);
}
if (defaultRoyalty.recipient != address(0) && defaultRoyalty.bps != 0) {
return (
defaultRoyalty.recipient,
(value * defaultRoyalty.bps) / 10000
);
}
return (address(0), 0);
}
}
