编译器
0.8.17+commit.8df45f5f
文件 1 的 23：Admins.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract Admins is Ownable{
mapping(address => bool) private admins;
function isAdmin(address _admin) public view returns(bool) {
return admins[_admin];
}
function setAdminAddress(address _admin, bool _active) public virtual onlyOwner {
admins[_admin] = _active;
}
modifier onlyOwnerOrAdmins() {
require(admins[_msgSender()] == true || owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
}
文件 2 的 23：BitMaps.sol
pragma solidity ^0.8.0;
library BitMaps {
struct BitMap {
mapping(uint256 => uint256) _data;
}
function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
return bitmap._data[bucket] & mask != 0;
}
function setTo(BitMap storage bitmap, uint256 index, bool value) internal {
if (value) {
set(bitmap, index);
} else {
unset(bitmap, index);
}
}
function set(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
bitmap._data[bucket] |= mask;
}
function unset(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = 1 << (index & 0xff);
bitmap._data[bucket] &= ~mask;
}
}
文件 3 的 23：ChainZokuClaim.sol
pragma solidity ^0.8.13;
import "./libs/interfaces/IChainZokuMint.sol";
import "./libs/Initialize.sol";
import "./libs/ERC721AManager.sol";
import "./libs/Signature.sol";
import "./libs/MultiMint.sol";
import "./libs/ShareProxy.sol";
contract ChainZokuClaim is IChainZokuMint, MultiMint, ERC721AManager, Initialize, ShareProxy, Signature {
using BitMaps for BitMaps.BitMap;
uint256 public MAX_SUPPLY = 3800;
BitMaps.BitMap private internalIdFlagged;
function init(address _zokuByChainZoku, address _multiSigContract, address _shareContract, address _signAddress) public onlyOwner isNotInitialized {
ERC721AManager._setERC721Address(_zokuByChainZoku);
MultiSigProxy._setMultiSigContract(_multiSigContract);
ShareProxy._setShareContract(_shareContract);
Signature.setSignAddress(_signAddress);
Signature.setHashSign(6999455);
}
function MintZokus(
string memory _mintName,
uint256[] calldata _internalIds,
uint256 _internalId,
bytes memory _signature
) public payable canMint(_mintName, _internalIds.length) signedUnique(_mintCollectionValid(_mintName, _internalIds, _internalId), _internalId, _signature) nonReentrant {
require(ERC721AManager._totalMinted() + _internalIds.length <= MAX_SUPPLY - 270, "ChainZokuClaim: Max supply");
require(_internalId > 0, "ChainZokuClaim: bad internalId");
for (uint256 i = 0; i < _internalIds.length; i++) {
_flagValid(_internalIds[i]);
}
ERC721AManager._mint(_msgSender(), _internalIds.length);
}
function MintManual(address _to, uint256 _count, uint256 _step) public onlyOwnerOrAdmins nonReentrant {
MultiSigProxy.validate("MintZokus");
require(_step > 0, "ChainZokuClaim.MintManual: Bad step");
require(_count > 0, "ChainZokuClaim.MintManual: Bad count");
require(ERC721AManager._totalMinted() + _count <= MAX_SUPPLY, "ChainZokuClaim.MintManual: Max supply");
uint256 steps = _count / _step;
uint256 last = _count % _step;
for (uint256 i = 0; i < steps; i++) {
ERC721AManager._mint(_to, _step);
}
if (last > 0) {
ERC721AManager._mint(_to, last);
}
}
function _flagValid(uint256 _internalId) internal {
require(_internalId > 0, "ChainZokuClaim: bad internalId");
require(_internalId & uint256(281474976710655) == 0, "ChainZokuClaim: bad internalId format");
_flagInternalId(_internalId);
uint256[] memory internalIds = new uint256[](1);
internalIds[0] = _internalId;
emit FlagItems(internalIds, uint8(Action.Burn), 0);
}
function _flagInternalId(uint256 _internalId) internal {
require(internalIdFlagged.get(_internalId) == false, "ChainZokuClaim: internalId already flag");
internalIdFlagged.set(_internalId);
}
function _mintCollectionValid(string memory _mintName, uint256[] memory _internalIds, uint256 _internalId) private view returns (bytes32) {
return keccak256(abi.encodePacked(_msgSender(), _mintName, _internalIds, _internalId, HASH_SIGN));
}
}
文件 4 的 23：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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 5 的 23：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 6 的 23：ERC721AManager.sol
pragma solidity ^0.8.13;
import "./interfaces/IERC721Manager.sol";
import "./interfaces/IERC721AProxy.sol";
import "./MultiSigProxy.sol";
abstract contract ERC721AManager is IERC721Manager, MultiSigProxy {
IERC721AProxy public ERC721Address;
function setERC721Address(address _ERC721Address) public onlyOwnerOrAdmins{
MultiSigProxy.validate("setERC721Address");
_setERC721Address(_ERC721Address);
}
function _setERC721Address(address _ERC721Address) internal {
ERC721Address = IERC721AProxy(_ERC721Address);
}
function _mint(address _wallet, uint256 _count) internal{
ERC721Address.mint(_wallet, _count);
}
function _safeMint(address _wallet, uint256 _count) internal{
ERC721Address.mint(_wallet, _count);
}
function _burn(uint256 _tokenId) internal{
ERC721Address.burn(_tokenId);
}
function _totalSupply() internal view returns(uint256){
return ERC721Address.totalSupply();
}
function _totalMinted() internal view returns(uint256){
return ERC721Address.totalMinted();
}
function _totalBurned() internal view returns(uint256){
return ERC721Address.totalBurned();
}
function balanceOf(address _wallet) internal view returns(uint256){
return ERC721Address.balanceOf(_wallet);
}
function ownerOf(uint256 _tokenId) internal view returns(address){
return ERC721Address.ownerOf(_tokenId);
}
function tokensOfOwner(address _wallet) internal view returns(uint256[] memory){
return ERC721Address.tokensOfOwner(_wallet);
}
function transferFrom(address, address, uint256) public override virtual returns(bool) {
return true;
}
}
文件 7 的 23：IChainZokuMint.sol
pragma solidity ^0.8.0;
interface IChainZokuMint {
enum Action {Mint, Transfer, Burn}
struct CollectionMint {
address collection;
Action action;
uint256[] internalIds;
}
event FlagItems(uint256[] internalIds, uint8 action, uint256 zokuTokenId);
}
文件 8 的 23：IERC721A.sol
pragma solidity ^0.8.4;
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
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 payable;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function approve(address to, uint256 tokenId) external payable;
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);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
文件 9 的 23：IERC721AProxy.sol
pragma solidity ^0.8.13;
import "erc721a/contracts/extensions/IERC721AQueryable.sol";
interface IERC721AProxy is IERC721AQueryable{
function mint(address _wallet, uint256 _count) external;
function burn(uint256 _tokenId) external;
function totalMinted() external view returns(uint256);
function totalBurned() external view returns(uint256);
}
文件 10 的 23：IERC721AQueryable.sol
pragma solidity ^0.8.4;
import '../IERC721A.sol';
interface IERC721AQueryable is IERC721A {
error InvalidQueryRange();
function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view returns (uint256[] memory);
function tokensOfOwner(address owner) external view returns (uint256[] memory);
}
文件 11 的 23：IERC721Manager.sol
pragma solidity ^0.8.13;
interface IERC721Manager{
function transferFrom(address from, address to, uint256 tokenId) external returns(bool);
}
文件 12 的 23：IMultiMint.sol
pragma solidity ^0.8.0;
interface IMultiMint {
struct Mint {
uint256 start;
uint256 end;
uint256 maxPerWallet;
uint256 maxPerTx;
uint256 price;
bool paused;
bool valid;
}
event EventMintChange(string _name, Mint sale);
function setMint(string calldata _name, Mint memory _sale) external;
function pauseMint(string calldata _name, bool _pause) external;
function mintIsOpen(string memory _name) external returns(bool);
function mintCurrent() external returns(string memory);
function mintNames() external returns(string[] memory);
function mintPrice(string memory _name, uint256 _count) external returns(uint256);
function mintBalance(string memory _name, address _wallet) external view returns(uint256);
}
文件 13 的 23：IMultiSig.sol
pragma solidity ^0.8.13;
interface IMultiSig {
function validate(string memory) external;
}
文件 14 的 23：Initialize.sol
pragma solidity ^0.8.13;
abstract contract Initialize {
bool private _initialized = false;
modifier isNotInitialized() {
require(_initialized == false, "Already Initialized");
_;
_initialized = true;
}
}
文件 15 的 23：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
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) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
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 (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 16 的 23：MultiMint.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IMultiMint.sol";
import "./Admins.sol";
abstract contract MultiMint is IMultiMint, Admins, ReentrancyGuard {
string[] public mintsNames;
mapping(string => Mint) public mints;
mapping(string => uint8) public mintNamesKey;
mapping(uint8 => mapping(address => uint256)) balance;
modifier canMint(string memory _name, uint256 _count) virtual {
require(mintIsOpen(_name), "Mint not open");
require(_count <= mints[_name].maxPerTx, "Max per tx limit");
require(msg.value >= mintPrice(_name, _count), "Value limit");
if (mints[_name].maxPerWallet > 0) {
require(balance[mintNamesKey[_name]][_msgSender()] + _count <= mints[_name].maxPerWallet, "Max per wallet limit");
balance[mintNamesKey[_name]][_msgSender()] += _count;
}
_;
}
function setMint(string memory _name, Mint memory _mint) public override onlyOwnerOrAdmins {
_setMint(_name, _mint);
}
function _setMint(string memory _name, Mint memory _mint) internal {
require(_mint.valid, "_mint.valid is missing");
if (!mints[_name].valid) {
mintsNames.push(_name);
mintNamesKey[_name] = uint8(mintsNames.length);
}
mints[_name] = _mint;
emit EventMintChange(_name, _mint);
}
function pauseMint(string memory _name, bool _pause) public override onlyOwnerOrAdmins {
mints[_name].paused = _pause;
}
function mintIsOpen(string memory _name) public view override returns (bool){
return mints[_name].start > 0 && block.timestamp >= mints[_name].start && block.timestamp <= mints[_name].end && !mints[_name].paused;
}
function mintCurrent() public override view returns (string memory){
for (uint256 i = 0; i < mintsNames.length; i++) {
if (mintIsOpen(mintsNames[i])) {
return mintsNames[i];
}
}
return "NONE";
}
function mintNames() public view override returns (string[] memory){
return mintsNames;
}
function mintPrice(string memory _name, uint256 _count) public view virtual override returns (uint256){
return mints[_name].price * _count;
}
function mintBalance(string memory _name, address _wallet) public view override returns (uint256){
return balance[mintNamesKey[_name]][_wallet];
}
}
文件 17 的 23：MultiSigProxy.sol
pragma solidity ^0.8.13;
import "./interfaces/IMultiSig.sol";
import "./Admins.sol";
abstract contract MultiSigProxy is Admins{
address public multiSigContract;
function _setMultiSigContract(address _contract) internal {
multiSigContract = _contract;
}
function setMultiSigContract(address _contract) public onlyOwnerOrAdmins {
IMultiSig(multiSigContract).validate("setMultiSigContract");
_setMultiSigContract(_contract);
}
function validate(string memory _method) internal {
IMultiSig(multiSigContract).validate(_method);
}
}
文件 18 的 23：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());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
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);
}
}
文件 19 的 23：ReentrancyGuard.sol
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;
}
}
文件 20 的 23：ShareProxy.sol
pragma solidity ^0.8.13;
import "./MultiSigProxy.sol";
abstract contract ShareProxy is MultiSigProxy {
address public shareContract;
function setShareContract(address _shareContract) public onlyOwnerOrAdmins {
MultiSigProxy.validate("setShareContract");
_setShareContract(_shareContract);
}
function _setShareContract(address _shareContract) internal {
shareContract = _shareContract;
}
function withdraw() public onlyOwnerOrAdmins {
(bool success, ) = shareContract.call{value: address(this).balance}("");
require(success, "Transfer failed.");
}
}
文件 21 的 23：Signature.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/structs/BitMaps.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./Admins.sol";
abstract contract Signature is Admins{
using BitMaps for BitMaps.BitMap;
uint256 public HASH_SIGN;
address public signAddress;
BitMaps.BitMap private signatureIds;
modifier signedNotUnique(bytes32 _hash, bytes memory _signature){
require(checkSignature(_hash, _signature) == signAddress, "Signature error: bad result");
_;
}
modifier signedUnique(bytes32 _hash, uint256 _signatureId, bytes memory _signature){
require(signatureIds.get(_signatureId) == false, "Signature already used");
require(checkSignature(_hash, _signature) == signAddress, "Signature error: bad result");
signatureIds.set(_signatureId);
_;
}
function setHashSign(uint256 _hash) public virtual onlyOwnerOrAdmins {
HASH_SIGN = _hash;
}
function setSignAddress(address _signAddress) public virtual onlyOwnerOrAdmins {
signAddress = _signAddress;
}
function checkSignature(bytes32 _hash, bytes memory _signature) public pure virtual returns (address) {
return ECDSA.recover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)), _signature);
}
}
文件 22 的 23：SignedMath.sol
pragma solidity ^0.8.0;
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);
}
}
}
文件 23 的 23：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
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), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(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) {
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] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
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 keccak256(bytes(a)) == keccak256(bytes(b));
}
}
{
"compilationTarget": {
"contracts/ChainZokuClaim/ChainZokuClaim.sol": "ChainZokuClaim"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 2000
},
"remappings": []
}[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_name","type":"string"},{"components":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"uint256","name":"maxPerWallet","type":"uint256"},{"internalType":"uint256","name":"maxPerTx","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"paused","type":"bool"},{"internalType":"bool","name":"valid","type":"bool"}],"indexed":false,"internalType":"struct IMultiMint.Mint","name":"sale","type":"tuple"}],"name":"EventMintChange","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"internalIds","type":"uint256[]"},{"indexed":false,"internalType":"uint8","name":"action","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"zokuTokenId","type":"uint256"}],"name":"FlagItems","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"},{"inputs":[],"name":"ERC721Address","outputs":[{"internalType":"contract IERC721AProxy","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HASH_SIGN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_count","type":"uint256"},{"internalType":"uint256","name":"_step","type":"uint256"}],"name":"MintManual","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_mintName","type":"string"},{"internalType":"uint256[]","name":"_internalIds","type":"uint256[]"},{"internalType":"uint256","name":"_internalId","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"MintZokus","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_hash","type":"bytes32"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"checkSignature","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_zokuByChainZoku","type":"address"},{"internalType":"address","name":"_multiSigContract","type":"address"},{"internalType":"address","name":"_shareContract","type":"address"},{"internalType":"address","name":"_signAddress","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"address","name":"_wallet","type":"address"}],"name":"mintBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintCurrent","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"}],"name":"mintIsOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintNames","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"mintNamesKey","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"mints","outputs":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"uint256","name":"maxPerWallet","type":"uint256"},{"internalType":"uint256","name":"maxPerTx","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"paused","type":"bool"},{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintsNames","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiSigContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"bool","name":"_pause","type":"bool"}],"name":"pauseMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bool","name":"_active","type":"bool"}],"name":"setAdminAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ERC721Address","type":"address"}],"name":"setERC721Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_hash","type":"uint256"}],"name":"setHashSign","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"components":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"uint256","name":"maxPerWallet","type":"uint256"},{"internalType":"uint256","name":"maxPerTx","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"paused","type":"bool"},{"internalType":"bool","name":"valid","type":"bool"}],"internalType":"struct IMultiMint.Mint","name":"_mint","type":"tuple"}],"name":"setMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_contract","type":"address"}],"name":"setMultiSigContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_shareContract","type":"address"}],"name":"setShareContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signAddress","type":"address"}],"name":"setSignAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shareContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"signAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
